Fork me on GitHub

Chapter 16
Java API

16.1 Client Library

HyperDex provides Java bindings in the package org.hyperdex.client. This package wraps the HyperDex C Client library and enables the use of native Java data types.

This library was brought up-to-date following the 1.0.5 release.

16.1.1 Building the HyperDex Java Binding

The HyperDex Java Binding must be requested at configure time as it is not automatically built. You can ensure that the Java bindings are always built by providing the --enable-java-bindings option to ./configure like so:

  % ./configure --enable-client --enable-java-bindings

16.1.2 Using Java Within Your Application

All client operation are defined in the org.hyperdex.client package. You can access this in your program with:

  import org.hyperdex.client.*;

16.1.3 Hello World

The following is a minimal application that stores the value ”Hello World” and then immediately retrieves the value:

  import java.util.*;
  import org.hyperdex.client.*;
  
  public class HelloWorld

  {
      public static void main(String[] args) throws HyperDexClientException

      {
          Client c = new Client("127.0.0.1", 1982);
          /* put */

          Map<String, Object> attrs = new HashMap<String, Object>();
          attrs.put("v", "Hello World!");

          System.out.println("put: " + c.put("kv", "k", attrs));
          /* get */

          System.out.println("got: " + c.get("kv", "k"));
      }
  }

You can run this example with:

  % javac HelloWorld.java
  % java -Djava.library.path=/usr/local/lib HelloWorld
  put: true
  got: {v=Hello World!}

Right away, there are several points worth noting in this example:

16.1.4 Asynchronous Operations

For convenience, the Java bindings treat every operation as synchronous. This enables you to write short programs without concern for asynchronous operations. Most operations come with an asynchronous form, denoted by the async_ prefix. For example, the above Hello World example could be rewritten in asynchronous fashion as such:

  import java.util.*;
  import org.hyperdex.client.*;
  
  public class HelloWorldAsyncWait

  {
      public static void main(String[] args) throws HyperDexClientException

      {
          Client c = new Client("127.0.0.1", 1982);
          /* put */

          Map<String, Object> attrs = new HashMap<String, Object>();

          attrs.put("v", "Hello World!");
          Deferred dp = c.async_put("kv", "k", attrs);

          System.out.println("put: " + dp.waitForIt());
          /* get */

          Deferred dg = c.async_get("kv", "k");
          System.out.println("got: " + dg.waitForIt());
      }
  }

This enables applications to issue multiple requests simultaneously and wait for their completion in an application-specific order. It’s also possible to use the loop method on the client object to wait for the next request to complete:

  import java.util.*;
  import org.hyperdex.client.*;
  
  public class HelloWorldAsyncLoop

  {
      public static void main(String[] args) throws HyperDexClientException

      {
          Client c = new Client("127.0.0.1", 1982);
          /* put */

          Map<String, Object> attrs = new HashMap<String, Object>();
          attrs.put("v", "Hello World!");

          Deferred dl;
          Deferred dp = c.async_put("kv", "k", attrs);
          dl = (Deferred)c.loop();

          assert dl == dp;
          System.out.println("put: " + dl.waitForIt());
          /* get */

          Deferred dg = c.async_get("kv", "k");
          dl = (Deferred)c.loop();

          assert dl == dg;
          System.out.println("got: " + dl.waitForIt());
      }
  }

16.1.5 Data Structures

The Java bindings automatically manage conversion of data types from Java to HyperDex types, enabling applications to be written in idiomatic Java.

16.1.5.1 Examples

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 Java’s strings and automatically converts them to HyperDex strings. For example, the following call stores a string: equivalent and have the same effect:

  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", "someattrs");
  c.put("kv", "somekey", attrs);
Integers  The HyperDex client recognizes Java’s integers and automatically converts them to HyperDex integers. For example:
  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", 42);
  c.put("kv", "somekey", attrs);
Floats  The HyperDex client recognizes Java’s floating point numbers and automatically converts them to HyperDex floats. For example:
  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", 3.1415);
  c.put("kv", "somekey", attrs);
Lists  The HyperDex client recognizes Java lists and automatically converts them to HyperDex lists. For example:
  List<Object> list = new ArrayList<Object>();
  list.add("a");
  list.add("b");
  list.add("c");
  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", list);
  c.put("kv", "somekey", attrs);
Sets  The HyperDex client recognizes Java sets and automatically converts them to HyperDex sets. For example:
  Set<Object> set = new HashSet<Object>();
  set.add("a");
  set.add("b");
  set.add("c");
  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", set);
  c.put("kv", "somekey", attrs);
Maps  The HyperDex client recognizes Java maps and automatically converts them to HyperDex maps. For example:
  Map<Object, Object> map = new HashMap<Object, Object>();
  map.put("k", "v");
  Map<String, Object> attrs = new HashMap<String, Object>();
  attrs.put("v", map);
  c.put("kv", "somekey", attrs);

16.1.6 Attributes

Attributes in Java are specified in the form of a map from attribute names to their values. As you can see in the examples above, attributes are specified in the form:

  Map<String, Object> attrs = new HashMap<String, Object>();

16.1.7 Map Attributes

Map attributes in Java are specified in the form of a nested map. The outer map key specifies the name, while the inner map key-value pair’s specify the key-value pair of the map. For example:

  Map<String, Map<Object, Object>> mapattrs = new HashMap<String, Map<Object, Object>>();

16.1.8 Predicates

Predicates in Java are specified in the form of a hash from attribute names to their predicates. In the simple case, the predicate is just a value to be compared against:

  Map<String, Object> checks = new HashMap<String, Object>();
  checks.put("v", "value");

This is the same as saying:

  Map<String, Object> checks = new HashMap<String, Object>();
  checks.put("v", new Equals("value"));

The Java bindings support the full range of predicates supported by HyperDex itself. For example:

  checks.put("v", new LessEqual(5));
  checks.put("v", new GreaterEqual(5));
  checks.put("v", new RangeEqual(5, 10));
  checks.put("v", new Regex("^s.*"));
  checks.put("v", new LengthEquals(5));
  checks.put("v", new LengthLessEqual(5));
  checks.put("v", new LengthGreaterEqual(5));
  checks.put("v", new Contains(value));

16.1.9 Error Handling

All error handling within the Java bindings is done via the try/catch mechanism of Java. Errors will be thrown by the package and should be handled by your application. For example, if we were trying to store an integer (5) as attribute "v", where "v" is actually a string, we’d generate an error.

  try
  {
      attrs.put("v", 5);
      System.out.println("put: " + c.put("kv", "k", attrs));
  }
  catch (HyperDexClientException e)
  {
      System.out.println(e.status());
      System.out.println(e.symbol());
      System.out.println(e.message());
  }

Errors of type HyperDexClientException will contain both a message indicating what went wrong, as well as the underlying enum hyperdex_client_returncode. The member status indicates the numeric value of this enum, while symbol returns the enum as a string. The above code will fail with the following output:

8525  
HYPERDEX_CLIENT_WRONGTYPE  
invalid attribute "v": attribute has the wrong type

16.1.10 Operations

16.1.10.1 get

Retrieve an object from space using key. Definition: 

  public Map<String, Object> get(
          String spacename,
          Object key) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.2 async_get

Retrieve an object from space using key. Definition: 

  public Deferred async_get(
          String spacename,
          Object key) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of get.

16.1.10.3 get_partial

Retrieve part of an object from space using key. Only the specified attributes of the object will be returned to the client. Definition: 

  public Map<String, Object> get_partial(
          String spacename,
          Object key,
          List<String> attributenames) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.4 async_get_partial

Retrieve part of an object from space using key. Only the specified attributes of the object will be returned to the client. Definition: 

  public Deferred async_get_partial(
          String spacename,
          Object key,
          List<String> attributenames) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of get_partial.

16.1.10.5 put

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: 

  public Boolean put(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.6 async_put

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: 

  public Deferred async_put(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of put.

16.1.10.7 cond_put

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: 

  public Boolean cond_put(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.8 async_cond_put

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: 

  public Deferred async_cond_put(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_put.

16.1.10.9 group_put

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: 

  public Long group_put(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.10 async_group_put

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: 

  public Deferred async_group_put(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_put.
16.1.10.11 put_if_not_exist

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: 

  public Boolean put_if_not_exist(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.12 async_put_if_not_exist

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: 

  public Deferred async_put_if_not_exist(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of put_if_not_exist.

16.1.10.13 del

Delete key from space. If no object exists, the operation will fail with NOTFOUND. Definition: 

  public Boolean del(String spacename, Object key) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.14 async_del

Delete key from space. If no object exists, the operation will fail with NOTFOUND. Definition: 

  public Deferred async_del(
          String spacename,
          Object key) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of del.

16.1.10.15 cond_del

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: 

  public Boolean cond_del(
          String spacename,
          Object key,
          Map<String, Object> predicates) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.16 async_cond_del

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: 

  public Deferred async_cond_del(
          String spacename,
          Object key,
          Map<String, Object> predicates) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_del.

16.1.10.17 group_del

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: 

  public Long group_del(
          String spacename,
          Map<String, Object> predicates) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.18 async_group_del

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: 

  public Deferred async_group_del(
          String spacename,
          Map<String, Object> predicates) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_del.
16.1.10.19 atomic_add

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: 

  public Boolean atomic_add(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.20 async_atomic_add

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: 

  public Deferred async_atomic_add(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_add.

16.1.10.21 cond_atomic_add

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: 

  public Boolean cond_atomic_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.22 async_cond_atomic_add

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: 

  public Deferred async_cond_atomic_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_add.

16.1.10.23 group_atomic_add

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: 

  public Long group_atomic_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.24 async_group_atomic_add

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: 

  public Deferred async_group_atomic_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_add.
16.1.10.25 atomic_sub

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: 

  public Boolean atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.26 async_atomic_sub

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: 

  public Deferred async_atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_sub.

16.1.10.27 cond_atomic_sub

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: 

  public Boolean cond_atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.28 async_cond_atomic_sub

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: 

  public Deferred async_cond_atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_sub.

16.1.10.29 group_atomic_sub

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: 

  public Long group_atomic_sub(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.30 async_group_atomic_sub

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: 

  public Deferred async_group_atomic_sub(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_sub.
16.1.10.31 atomic_mul

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: 

  public Boolean atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.32 async_atomic_mul

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: 

  public Deferred async_atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_mul.

16.1.10.33 cond_atomic_mul

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: 

  public Boolean cond_atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.34 async_cond_atomic_mul

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: 

  public Deferred async_cond_atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_mul.

16.1.10.35 group_atomic_mul

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: 

  public Long group_atomic_mul(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.36 async_group_atomic_mul

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: 

  public Deferred async_group_atomic_mul(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_mul.
16.1.10.37 atomic_div

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: 

  public Boolean atomic_div(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.38 async_atomic_div

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: 

  public Deferred async_atomic_div(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_div.

16.1.10.39 cond_atomic_div

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: 

  public Boolean cond_atomic_div(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.40 async_cond_atomic_div

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: 

  public Deferred async_cond_atomic_div(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_div.

16.1.10.41 group_atomic_div

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: 

  public Long group_atomic_div(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.42 async_group_atomic_div

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: 

  public Deferred async_group_atomic_div(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_div.
16.1.10.43 atomic_mod

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: 

  public Boolean atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.44 async_atomic_mod

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: 

  public Deferred async_atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_mod.

16.1.10.45 cond_atomic_mod

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: 

  public Boolean cond_atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.46 async_cond_atomic_mod

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: 

  public Deferred async_cond_atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_mod.

16.1.10.47 group_atomic_mod

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: 

  public Long group_atomic_mod(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.48 async_group_atomic_mod

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: 

  public Deferred async_group_atomic_mod(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_mod.
16.1.10.49 atomic_and

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: 

  public Boolean atomic_and(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.50 async_atomic_and

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: 

  public Deferred async_atomic_and(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_and.

16.1.10.51 cond_atomic_and

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: 

  public Boolean cond_atomic_and(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.52 async_cond_atomic_and

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: 

  public Deferred async_cond_atomic_and(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_and.

16.1.10.53 group_atomic_and

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: 

  public Long group_atomic_and(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.54 async_group_atomic_and

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: 

  public Deferred async_group_atomic_and(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_and.
16.1.10.55 atomic_or

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: 

  public Boolean atomic_or(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.56 async_atomic_or

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: 

  public Deferred async_atomic_or(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_or.

16.1.10.57 cond_atomic_or

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: 

  public Boolean cond_atomic_or(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.58 async_cond_atomic_or

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: 

  public Deferred async_cond_atomic_or(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_or.

16.1.10.59 group_atomic_or

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: 

  public Long group_atomic_or(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.60 async_group_atomic_or

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: 

  public Deferred async_group_atomic_or(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_or.
16.1.10.61 atomic_xor

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: 

  public Boolean atomic_xor(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.62 async_atomic_xor

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: 

  public Deferred async_atomic_xor(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_xor.

16.1.10.63 cond_atomic_xor

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: 

  public Boolean cond_atomic_xor(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.64 async_cond_atomic_xor

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: 

  public Deferred async_cond_atomic_xor(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_xor.

16.1.10.65 group_atomic_xor

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: 

  public Long group_atomic_xor(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.66 async_group_atomic_xor

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: 

  public Deferred async_group_atomic_xor(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_xor.
16.1.10.67 atomic_min

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: 

  public Boolean atomic_min(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.68 async_atomic_min

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: 

  public Deferred async_atomic_min(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_min.

16.1.10.69 cond_atomic_min

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: 

  public Boolean cond_atomic_min(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.70 async_cond_atomic_min

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: 

  public Deferred async_cond_atomic_min(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_min.

16.1.10.71 group_atomic_min

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: 

  public Long group_atomic_min(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.72 async_group_atomic_min

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: 

  public Deferred async_group_atomic_min(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_min.
16.1.10.73 atomic_max

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: 

  public Boolean atomic_max(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.74 async_atomic_max

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: 

  public Deferred async_atomic_max(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of atomic_max.

16.1.10.75 cond_atomic_max

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: 

  public Boolean cond_atomic_max(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.76 async_cond_atomic_max

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: 

  public Deferred async_cond_atomic_max(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_atomic_max.

16.1.10.77 group_atomic_max

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: 

  public Long group_atomic_max(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.78 async_group_atomic_max

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: 

  public Deferred async_group_atomic_max(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_atomic_max.
16.1.10.79 string_prepend

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: 

  public Boolean string_prepend(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.80 async_string_prepend

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: 

  public Deferred async_string_prepend(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of string_prepend.

16.1.10.81 cond_string_prepend

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: 

  public Boolean cond_string_prepend(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.82 async_cond_string_prepend

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: 

  public Deferred async_cond_string_prepend(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_string_prepend.

16.1.10.83 group_string_prepend

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: 

  public Long group_string_prepend(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.84 async_group_string_prepend

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: 

  public Deferred async_group_string_prepend(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_string_prepend.
16.1.10.85 string_append

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: 

  public Boolean string_append(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.86 async_string_append

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: 

  public Deferred async_string_append(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of string_append.

16.1.10.87 cond_string_append

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: 

  public Boolean cond_string_append(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.88 async_cond_string_append

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: 

  public Deferred async_cond_string_append(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_string_append.

16.1.10.89 group_string_append

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: 

  public Long group_string_append(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.90 async_group_string_append

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: 

  public Deferred async_group_string_append(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_string_append.
16.1.10.91 list_lpush

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: 

  public Boolean list_lpush(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.92 async_list_lpush

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: 

  public Deferred async_list_lpush(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of list_lpush.

16.1.10.93 cond_list_lpush

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: 

  public Boolean cond_list_lpush(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.94 async_cond_list_lpush

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: 

  public Deferred async_cond_list_lpush(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_list_lpush.

16.1.10.95 group_list_lpush

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: 

  public Long group_list_lpush(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.96 async_group_list_lpush

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: 

  public Deferred async_group_list_lpush(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_list_lpush.
16.1.10.97 list_rpush

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: 

  public Boolean list_rpush(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.98 async_list_rpush

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: 

  public Deferred async_list_rpush(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of list_rpush.

16.1.10.99 cond_list_rpush

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: 

  public Boolean cond_list_rpush(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.100 async_cond_list_rpush

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: 

  public Deferred async_cond_list_rpush(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_list_rpush.

16.1.10.101 group_list_rpush

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: 

  public Long group_list_rpush(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.102 async_group_list_rpush

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: 

  public Deferred async_group_list_rpush(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_list_rpush.
16.1.10.103 set_add

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: 

  public Boolean set_add(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.104 async_set_add

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: 

  public Deferred async_set_add(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of set_add.

16.1.10.105 cond_set_add

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: 

  public Boolean cond_set_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.106 async_cond_set_add

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: 

  public Deferred async_cond_set_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_set_add.

16.1.10.107 group_set_add

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: 

  public Long group_set_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.108 async_group_set_add

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: 

  public Deferred async_group_set_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_set_add.
16.1.10.109 set_remove

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: 

  public Boolean set_remove(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.110 async_set_remove

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: 

  public Deferred async_set_remove(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of set_remove.

16.1.10.111 cond_set_remove

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: 

  public Boolean cond_set_remove(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.112 async_cond_set_remove

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: 

  public Deferred async_cond_set_remove(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_set_remove.

16.1.10.113 group_set_remove

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: 

  public Long group_set_remove(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.114 async_group_set_remove

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: 

  public Deferred async_group_set_remove(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_set_remove.
16.1.10.115 set_intersect

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: 

  public Boolean set_intersect(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.116 async_set_intersect

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: 

  public Deferred async_set_intersect(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of set_intersect.

16.1.10.117 cond_set_intersect

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: 

  public Boolean cond_set_intersect(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.118 async_cond_set_intersect

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: 

  public Deferred async_cond_set_intersect(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_set_intersect.

16.1.10.119 group_set_intersect

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: 

  public Long group_set_intersect(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.120 async_group_set_intersect

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: 

  public Deferred async_group_set_intersect(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_set_intersect.
16.1.10.121 set_union

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: 

  public Boolean set_union(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.122 async_set_union

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: 

  public Deferred async_set_union(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of set_union.

16.1.10.123 cond_set_union

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: 

  public Boolean cond_set_union(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.124 async_cond_set_union

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: 

  public Deferred async_cond_set_union(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_set_union.

16.1.10.125 group_set_union

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: 

  public Long group_set_union(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.126 async_group_set_union

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: 

  public Deferred async_group_set_union(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_set_union.
16.1.10.127 document_rename

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: 

  public Boolean document_rename(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.128 async_document_rename

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: 

  public Deferred async_document_rename(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of document_rename.

16.1.10.129 cond_document_rename

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: 

  public Boolean cond_document_rename(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.130 async_cond_document_rename

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: 

  public Deferred async_cond_document_rename(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_document_rename.

16.1.10.131 group_document_rename

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: 

  public Long group_document_rename(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.132 async_group_document_rename

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: 

  public Deferred async_group_document_rename(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_document_rename.
16.1.10.133 document_unset

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: 

  public Boolean document_unset(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.134 async_document_unset

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: 

  public Deferred async_document_unset(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of document_unset.

16.1.10.135 cond_document_unset

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: 

  public Boolean cond_document_unset(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.136 async_cond_document_unset

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: 

  public Deferred async_cond_document_unset(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_document_unset.

16.1.10.137 group_document_unset

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: 

  public Long group_document_unset(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.138 async_group_document_unset

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: 

  public Deferred async_group_document_unset(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_document_unset.
16.1.10.139 map_add

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: 

  public Boolean map_add(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.140 async_map_add

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: 

  public Deferred async_map_add(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_add.

16.1.10.141 cond_map_add

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: 

  public Boolean cond_map_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.142 async_cond_map_add

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: 

  public Deferred async_cond_map_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_add.

16.1.10.143 group_map_add

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: 

  public Long group_map_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.144 async_group_map_add

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: 

  public Deferred async_group_map_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_add.
16.1.10.145 map_remove

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: 

  public Boolean map_remove(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.146 async_map_remove

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: 

  public Deferred async_map_remove(
          String spacename,
          Object key,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_remove.

16.1.10.147 cond_map_remove

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: 

  public Boolean cond_map_remove(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.148 async_cond_map_remove

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: 

  public Deferred async_cond_map_remove(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_remove.

16.1.10.149 group_map_remove

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: 

  public Long group_map_remove(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.150 async_group_map_remove

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: 

  public Deferred async_group_map_remove(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Object> attributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_remove.
16.1.10.151 map_atomic_add

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: 

  public Boolean map_atomic_add(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.152 async_map_atomic_add

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: 

  public Deferred async_map_atomic_add(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_add.

16.1.10.153 cond_map_atomic_add

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: 

  public Boolean cond_map_atomic_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.154 async_cond_map_atomic_add

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: 

  public Deferred async_cond_map_atomic_add(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_add.

16.1.10.155 group_map_atomic_add

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: 

  public Long group_map_atomic_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.156 async_group_map_atomic_add

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: 

  public Deferred async_group_map_atomic_add(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_add.
16.1.10.157 map_atomic_sub

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: 

  public Boolean map_atomic_sub(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.158 async_map_atomic_sub

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: 

  public Deferred async_map_atomic_sub(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_sub.

16.1.10.159 cond_map_atomic_sub

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: 

  public Boolean cond_map_atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.160 async_cond_map_atomic_sub

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: 

  public Deferred async_cond_map_atomic_sub(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_sub.

16.1.10.161 group_map_atomic_sub

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: 

  public Long group_map_atomic_sub(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.162 async_group_map_atomic_sub

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: 

  public Deferred async_group_map_atomic_sub(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_sub.
16.1.10.163 map_atomic_mul

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: 

  public Boolean map_atomic_mul(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.164 async_map_atomic_mul

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: 

  public Deferred async_map_atomic_mul(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_mul.

16.1.10.165 cond_map_atomic_mul

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: 

  public Boolean cond_map_atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.166 async_cond_map_atomic_mul

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: 

  public Deferred async_cond_map_atomic_mul(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_mul.

16.1.10.167 group_map_atomic_mul

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: 

  public Long group_map_atomic_mul(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.168 async_group_map_atomic_mul

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: 

  public Deferred async_group_map_atomic_mul(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_mul.
16.1.10.169 map_atomic_div

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: 

  public Boolean map_atomic_div(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.170 async_map_atomic_div

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: 

  public Deferred async_map_atomic_div(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_div.

16.1.10.171 cond_map_atomic_div

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: 

  public Boolean cond_map_atomic_div(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.172 async_cond_map_atomic_div

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: 

  public Deferred async_cond_map_atomic_div(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_div.

16.1.10.173 group_map_atomic_div

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: 

  public Long group_map_atomic_div(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.174 async_group_map_atomic_div

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: 

  public Deferred async_group_map_atomic_div(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_div.
16.1.10.175 map_atomic_mod

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: 

  public Boolean map_atomic_mod(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.176 async_map_atomic_mod

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: 

  public Deferred async_map_atomic_mod(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_mod.

16.1.10.177 cond_map_atomic_mod

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: 

  public Boolean cond_map_atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.178 async_cond_map_atomic_mod

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: 

  public Deferred async_cond_map_atomic_mod(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_mod.

16.1.10.179 group_map_atomic_mod

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: 

  public Long group_map_atomic_mod(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.180 async_group_map_atomic_mod

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: 

  public Deferred async_group_map_atomic_mod(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_mod.
16.1.10.181 map_atomic_and

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: 

  public Boolean map_atomic_and(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.182 async_map_atomic_and

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: 

  public Deferred async_map_atomic_and(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_and.

16.1.10.183 cond_map_atomic_and

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: 

  public Boolean cond_map_atomic_and(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.184 async_cond_map_atomic_and

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: 

  public Deferred async_cond_map_atomic_and(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of cond_map_atomic_and.

16.1.10.185 group_map_atomic_and

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: 

  public Long group_map_atomic_and(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns a number indicating the number of objects counted. On error, this function will raise a HyperDexClientException describing the error.
16.1.10.186 async_group_map_atomic_and

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: 

  public Deferred async_group_map_atomic_and(
          String spacename,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns a number indicating the number :f objects counted. On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of group_map_atomic_and.
16.1.10.187 map_atomic_or

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: 

  public Boolean map_atomic_or(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.188 async_map_atomic_or

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: 

  public Deferred async_map_atomic_or(
          String spacename,
          Object key,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error. See also:  This is the asynchronous form of map_atomic_or.

16.1.10.189 cond_map_atomic_or

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: 

  public Boolean cond_map_atomic_or(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This function returns an object indicating the success or failure of the operation. Valid values to be returned are:

On error, this function will raise a HyperDexClientException describing the error.

16.1.10.190 async_cond_map_atomic_or

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: 

  public Deferred async_cond_map_atomic_or(
          String spacename,
          Object key,
          Map<String, Object> predicates,
          Map<String, Map<Object, Object>> mapattributes) throws HyperDexClientException
Parameters:  Returns:  This asynchronous operation returns a Deferred object with a waitForIt method which blocks and returns an object indicating the success or failure of the operation. Valid values to be returned are: