Chapter 19
Ruby API

19.1 Client Library

HyperDex provides ruby bindings under the module HyperDex::Client. This library wraps the HyperDex C Client library and enables use of native Ruby data types.

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

19.1.1 Building the HyperDex Ruby Binding

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

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

19.1.2 Using Ruby Within Your Application

All client operation are defined in the HyperDex::Ruby module. You can access this in your program with:

    require  ’hyperdex’

19.1.3 Hello World

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

    require  "hyperdex"
   c  =  HyperDex::Client::Client.new("127.0.0.1",  1982)
   c.put(:kv,  "some key", {:v  =>  "Hello World!"})
    puts  ’put "Hello World!"’
    puts  ’got:’, c.get(:kv,  "some key")

You can run this example with:

    % ruby hello-world.rb
    put "Hello World!"
    got:
    {:v=>"Hello World!"}

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

• Every operation is synchronous. The PUT and GET operations run to completion by default.
• Ruby types are automatically converted to HyperDex types. There’s no need to specify information such as the length of each string, as one would do with the C API.
• Ruby symbols are permitted wherever a string may be used. By convention, space names and attribute names are specified using Ruby symbols, e.g. :kv and :v. Of course, you may use strings for these parameters too.

19.1.4 Asynchronous Operations

For convenience, the Ruby bindings treat every operation as synchronous. This enables you to write short scripts 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:

    require  "hyperdex"
   c  =  HyperDex::Client::Client.new("127.0.0.1",  1982)
    p  = c.async_put(:kv,  "some key", {:v  =>  "Hello World!"})
    p.wait()
    puts  ’put "Hello World!"’
   g  = c.async_get(:kv,  "some key")
    puts  ’got:’, g.wait()

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:

    require  "hyperdex"
   c  =  HyperDex::Client::Client.new("127.0.0.1",  1982)
    p  = c.async_put(:kv,  "some key", {:v  =>  "Hello World!"})
   p1  = c.loop()
    puts  ’put objects are the same:’, (p.equal? p1)
    p.wait()
    puts  ’put "Hello World!"’
   g  = c.async_get(:kv,  "some key")
   g1  = c.loop()
    puts  ’get objects are the same:’, (g.equal? g1)
    puts  ’got:’, g.wait()

19.1.5 Data Structures

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

19.1.5.1 Examples

This section shows examples of Ruby data structures that are recognized by HyperDex. The examples here are for illustration purposes and are not exhaustive. Strings The HyperDex client recognizes Ruby’s strings and symbols and automatically converts them to HyperDex strings. For example, the following two calls are equivalent and have the same effect:

   c.put("kv",  "somekey", {"v"  =>  "somevalue"})
   c.put(:kv,  :somekey, {:v  =>  :somevalue})

The recommended convention is to use symbols for space and attribute names, and strings for keys and values like so:

   c.put(:kv,  "somekey", {:v  =>  "somevalue"})

Integers The HyperDex client recognizes Ruby’s integers, longs, and fixnums and automatically converts them to HyperDex integers. For example:

   c.put(:kv,  "somekey", {:v  =>  42})

Floats The HyperDex client recognizes Ruby’s floating point numbers and automatically converts them to HyperDex floats. For example:

   c.put(:kv,  "somekey", {:v  =>  3.1415})

Lists The HyperDex client recognizes Ruby lists and automatically converts them to HyperDex lists. For example:

   c.put(:kv,  "somekey", {:v1  =>  ["a",  "b",  "c"]})
   c.put(:kv,  "somekey", {:v2  =>  [1,  2,  3]})
   c.put(:kv,  "somekey", {:v3  =>  [1.0,  0.5,  0.25]})

Sets The HyperDex client recognizes Ruby sets and automaticaly converts them to HyperDex sets. For example:

    require  ’set’
   c.put(:kv,  "somekey", {:v1  => (Set.new  ["a",  "b",  "c"])})
   c.put(:kv,  "somekey", {:v2  => (Set.new  [1,  2,  3])})
   c.put(:kv,  "somekey", {:v3  => (Set.new  [1.0,  0.5,  0.25])})

Note that you’ll have to include the set module from the standard library. Maps The HyperDex client recognizes Ruby hashes and automatically converts them to HyperDex maps. For example:

   c.put(:kv,  "somekey", {:v1  => {"k"  =>  "v"}})
   c.put(:kv,  "somekey", {:v2  => {1  =>  2}})
   c.put(:kv,  "somekey", {:v3  => {3.14  =>  0.125}})
   c.put(:kv,  "somekey", {:v3  => {"a"  =>  1}})

19.1.6 Attributes

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

   {:name  =>  "value"}

19.1.7 Map Attributes

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

   {:name  => {"key"  =>  "value"}}

19.1.8 Predicates

Predicates in Ruby 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:

   {:v  =>  "value"}

This is the same as saying:

   {:v  =>  HyperDex::Client::Equals.new(’value’)}

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

   {:v  =>  HyperDex::Client::LessEqual.new(5)}
   {:v  =>  HyperDex::Client::GreaterEqual.new(5)}
   {:v  =>  HyperDex::Client::Range.new(5,  10)}
   {:v  =>  HyperDex::Client::Regex.new(’^s.*’)}
   {:v  =>  HyperDex::Client::LengthEquals.new(5)}
   {:v  =>  HyperDex::Client::LengthLessEqual.new(5)}
   {:v  =>  HyperDex::Client::LengthGreaterEqual.new(5)}
   {:v  =>  HyperDex::Client::Contains.new(’value’)}

19.1.9 Error Handling

All error handling within the Ruby bindings is done via the begin/rescue mechanism of Ruby. Errors will be raised by the library 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.

    begin
            puts c.put(:kv,  :my_key, {:v  =>  5})
    rescue  HyperDex::Client::HyperDexClientException  => e
            puts e.status
            puts e.symbol
            puts e
    end

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:

19.1.10 Operations

19.1.10.1 get

Retrieve an object from space using key. Definition:

   get(spacename, key)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.

Returns: Object if found, nil if not found. Raises exception on error.

19.1.10.2 async_get

Retrieve an object from space using key. Definition:

   async_get(spacename, key)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.

Returns: A Deferred object with a wait method that returns the object if found, nil if not found. Raises exception on error. See also: This is the asynchronous form of get.

19.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:

   get_partial(spacename, key, attributenames)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributenames
  A list of attributes to return.

Returns: Object if found, nil if not found. Raises exception on error.

19.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:

   async_get_partial(spacename, key, attributenames)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributenames
  A list of attributes to return.

Returns: A Deferred object with a wait method that returns the object if found, nil if not found. Raises exception on error. See also: This is the asynchronous form of get_partial.

19.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:

   put(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_put(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of put.

19.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:

   cond_put(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_put(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_put.

19.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:

   group_put(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_put(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_put.

19.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:

   put_if_not_exist(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_put_if_not_exist(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of put_if_not_exist.

19.1.10.13 del

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

   del(spacename, key)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.14 async_del

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

   async_del(spacename, key)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of del.

19.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:

   cond_del(spacename, key, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_del(spacename, key, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_del.

19.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:

   group_del(spacename, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_del(spacename, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_del.

19.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:

   atomic_add(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_add(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_add.

19.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:

   cond_atomic_add(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_add(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_add.

19.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:

   group_atomic_add(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_add(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_add.

19.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:

   atomic_sub(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_sub(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_sub.

19.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:

   cond_atomic_sub(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_sub(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_sub.

19.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:

   group_atomic_sub(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_sub(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_sub.

19.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:

   atomic_mul(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_mul(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_mul.

19.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:

   cond_atomic_mul(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_mul(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_mul.

19.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:

   group_atomic_mul(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_mul(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_mul.

19.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:

   atomic_div(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_div(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_div.

19.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:

   cond_atomic_div(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_div(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_div.

19.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:

   group_atomic_div(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_div(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_div.

19.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:

   atomic_mod(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_mod(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_mod.

19.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:

   cond_atomic_mod(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_mod(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_mod.

19.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:

   group_atomic_mod(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_mod(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_mod.

19.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:

   atomic_and(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_and(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_and.

19.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:

   cond_atomic_and(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_and(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_and.

19.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:

   group_atomic_and(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_and(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_and.

19.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:

   atomic_or(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_or(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_or.

19.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:

   cond_atomic_or(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_or(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_or.

19.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:

   group_atomic_or(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_or(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_or.

19.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:

   atomic_xor(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_xor(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_xor.

19.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:

   cond_atomic_xor(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_xor(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_xor.

19.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:

   group_atomic_xor(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_xor(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_xor.

19.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:

   atomic_min(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_min(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_min.

19.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:

   cond_atomic_min(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_min(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_min.

19.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:

   group_atomic_min(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_min(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_min.

19.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:

   atomic_max(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_atomic_max(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_max.

19.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:

   cond_atomic_max(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_atomic_max(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_max.

19.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:

   group_atomic_max(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_atomic_max(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_max.

19.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:

   string_prepend(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_string_prepend(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of string_prepend.

19.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:

   cond_string_prepend(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_string_prepend(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_string_prepend.

19.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:

   group_string_prepend(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_string_prepend(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_string_prepend.

19.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:

   string_append(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_string_append(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of string_append.

19.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:

   cond_string_append(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_string_append(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_string_append.

19.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:

   group_string_append(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_string_append(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_string_append.

19.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:

   list_lpush(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_list_lpush(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of list_lpush.

19.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:

   cond_list_lpush(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_list_lpush(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_list_lpush.

19.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:

   group_list_lpush(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_list_lpush(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_list_lpush.

19.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:

   list_rpush(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_list_rpush(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of list_rpush.

19.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:

   cond_list_rpush(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_list_rpush(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_list_rpush.

19.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:

   group_list_rpush(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_list_rpush(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_list_rpush.

19.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:

   set_add(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_set_add(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_add.

19.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:

   cond_set_add(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_set_add(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_add.

19.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:

   group_set_add(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_set_add(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_add.

19.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:

   set_remove(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_set_remove(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_remove.

19.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:

   cond_set_remove(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_set_remove(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_remove.

19.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:

   group_set_remove(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_set_remove(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_remove.

19.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:

   set_intersect(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_set_intersect(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_intersect.

19.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:

   cond_set_intersect(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_set_intersect(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_intersect.

19.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:

   group_set_intersect(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_set_intersect(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_intersect.

19.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:

   set_union(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_set_union(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_union.

19.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:

   cond_set_union(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_set_union(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_union.

19.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:

   group_set_union(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_set_union(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_union.

19.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:

   document_rename(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_document_rename(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of document_rename.

19.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:

   cond_document_rename(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_document_rename(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_document_rename.

19.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:

   group_document_rename(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_document_rename(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_document_rename.

19.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:

   document_unset(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_document_unset(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of document_unset.

19.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:

   cond_document_unset(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_document_unset(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_document_unset.

19.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:

   group_document_unset(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_document_unset(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_document_unset.

19.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:

   map_add(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_add(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_add.

19.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:

   cond_map_add(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_add(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_add.

19.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:

   group_map_add(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_add(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_add.

19.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:

   map_remove(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_remove(spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_remove.

19.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:

   cond_map_remove(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_remove(spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_remove.

19.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:

   group_map_remove(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_remove(spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• attributes
  A hash specifying attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_remove.

19.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:

   map_atomic_add(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_add(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_add.

19.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:

   cond_map_atomic_add(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_add(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_add.

19.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:

   group_map_atomic_add(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_add(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_add.

19.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:

   map_atomic_sub(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_sub(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_sub.

19.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:

   cond_map_atomic_sub(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_sub(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_sub.

19.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:

   group_map_atomic_sub(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_sub(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_sub.

19.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:

   map_atomic_mul(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_mul(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_mul.

19.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:

   cond_map_atomic_mul(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_mul(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_mul.

19.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:

   group_map_atomic_mul(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_mul(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_mul.

19.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:

   map_atomic_div(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_div(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_div.

19.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:

   cond_map_atomic_div(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_div(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_div.

19.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:

   group_map_atomic_div(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_div(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_div.

19.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:

   map_atomic_mod(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_mod(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_mod.

19.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:

   cond_map_atomic_mod(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_mod(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_mod.

19.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:

   group_map_atomic_mod(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_mod(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_mod.

19.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:

   map_atomic_and(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_and(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_and.

19.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:

   cond_map_atomic_and(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_and(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_and.

19.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:

   group_map_atomic_and(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.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:

   async_group_map_atomic_and(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_and.

19.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:

   map_atomic_or(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_map_atomic_or(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_or.

19.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:

   cond_map_atomic_or(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.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:

   async_cond_map_atomic_or(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_or.

19.1.10.191 group_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_atomic_or(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.192 async_group_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_atomic_or(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_or.

19.1.10.193 map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   map_atomic_xor(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.194 async_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   async_map_atomic_xor(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_xor.

19.1.10.195 cond_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   cond_map_atomic_xor(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.196 async_cond_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   async_cond_map_atomic_xor(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_xor.

19.1.10.197 group_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_atomic_xor(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.198 async_group_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_atomic_xor(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_xor.

19.1.10.199 map_string_prepend

Prepend the specified string to the value of the key-value pair for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   map_string_prepend(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.200 async_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   async_map_string_prepend(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_string_prepend.

19.1.10.201 cond_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   cond_map_string_prepend(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.202 async_cond_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   async_cond_map_string_prepend(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_string_prepend.

19.1.10.203 group_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_string_prepend(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.204 async_group_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_string_prepend(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_string_prepend.

19.1.10.205 map_string_append

Append the specified string to the value of the key-value pair for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   map_string_append(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.206 async_map_string_append

Append the specified string to the value of the key-value pair for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   async_map_string_append(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_string_append.

19.1.10.207 cond_map_string_append

Append the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   cond_map_string_append(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.208 async_cond_map_string_append

Append the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   async_cond_map_string_append(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_string_append.

19.1.10.209 group_map_string_append

Append the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_string_append(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.210 async_group_map_string_append

Append the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_string_append(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_string_append.

19.1.10.211 map_atomic_min

Take the minium of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   map_atomic_min(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.212 async_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   async_map_atomic_min(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_min.

19.1.10.213 cond_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   cond_map_atomic_min(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.214 async_cond_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   async_cond_map_atomic_min(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_min.

19.1.10.215 group_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_atomic_min(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.216 async_group_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_atomic_min(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_min.

19.1.10.217 map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   map_atomic_max(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.218 async_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

   async_map_atomic_max(spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_max.

19.1.10.219 cond_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   cond_map_atomic_max(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: True if the operation succeeded. False if any provided predicates failed. Raises an exception on error.

19.1.10.220 async_cond_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

   async_cond_map_atomic_max(spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• key
  The key for the operation as a Ruby type.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded or False if any provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_max.

19.1.10.221 group_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   group_map_atomic_max(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: Number of objects found. Raises exception on error.

19.1.10.222 async_group_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

   async_group_map_atomic_max(spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• mapattributes
  A hash specifying map attributes to modify and their respective key/values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_max.

19.1.10.223 search

Return all objects that match the specified checks. This operation behaves as an iterator and may return multiple objects from the single call. Definition:

   search(spacename, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.

Returns: An iterator that returns objects one at a time. Excpetions will be returned via the same path to enable applications to retrieve partial results in the face of errors.

19.1.10.224 sorted_search

Return all objects that match the specified checks, sorted according to attr. This operation behaves as an iterator and may return multiple objects from the single call. Definition:

   sorted_search(spacename, predicates, sortby, limit, maxmin)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.
• sortby
  The attribute to sort by.
• limit
  The number of results to return.
• maxmin
  Maximize (‘max’) or minimize (‘min’).

Returns: An iterator that returns objects one at a time. Excpetions will be returned via the same path to enable applications to retrieve partial results in the face of errors.

19.1.10.225 count

Count the number of objects that match the specified checks. This will return the number of objects counted by the search. If an error occurs during the count, the count may reflect a partial count. The real count will be higher than the returned value.

A count is the server-side equivalent of performing a search, and counting the number of objects that exist. For that reason, its efficiency closely follows that of search, except it will not transfer any objects over the network. Definition:

   count(spacename, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.

Returns: Number of objects found. Raises exception on error.

19.1.10.226 async_count

Count the number of objects that match the specified checks. This will return the number of objects counted by the search. If an error occurs during the count, the count may reflect a partial count. The real count will be higher than the returned value.

A count is the server-side equivalent of performing a search, and counting the number of objects that exist. For that reason, its efficiency closely follows that of search, except it will not transfer any objects over the network. Definition:

   async_count(spacename, predicates)

Parameters:

• spacename
  The name of the space as a string or symbol.
• predicates
  A hash of predicates to check against.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of count.

19.1.11 Working with Signals

The HyperDex client library is signal-safe. Should a signal interrupt the client during a blocking operation, it will raise a HyperDexClientException with status HYPERDEX_CLIENT_INTERRUPTED.

19.1.12 Working with Threads

The Ruby module is fully reentrant. Instances of HyperDex::Client::Client and their associated state may be accessed from multiple threads, provided that the application employs its own synchronization that provides mutual exclusion.

Put simply, a multi-threaded application should protect each Client instance with a mutex or lock to ensure correct operation.