Skip to main content
Version: 2.0.7

Sets

Sets are a bucket-level Riak data type that can be used by themselves, associated with a bucket/key pair, or used within a map.

Sets are collections of unique binary values (such as strings). All of the values in a set are unique.

For example, if you attempt to add the element shovel to a set that already contains shovel, the operation will be ignored by Riak KV.

Set Up a Bucket Type​

If you've already created and activated a bucket type with set as the datatype parameter, skip to the next section.

Start by creating a bucket type with the datatype parameter set:

riak-admin bucket-type create sets '{"props":{"datatype":"set"}}'
note

The sets bucket type name provided above is an example and is not required to be sets. You are free to name bucket types whatever you like, with the exception of default.

After creating a bucket with a Riak data type, confirm the bucket property configuration associated with that type is correct:

riak-admin bucket-type status sets

This returns a list of bucket properties and their values in the form of property: value.

If our sets bucket type has been set properly we should see the following pair in our console output:

datatype: set

Once we have confirmed the bucket type is properly configured, we can activate the bucket type to be used in Riak KV:

riak-admin bucket-type activate sets

We can check if activation has been successful by using the same bucket-type status command shown above:

riak-admin bucket-type status sets

After creating and activating our new sets bucket type, we can setup our client to start using the bucket type as detailed in the next section.

Client Setup​

Using sets involves creating a bucket/key pair to house a set and running set-specific operations on that pair.

Here is the general syntax for creating a bucket type/bucket/key combination to handle a set:

// In the Java client, a bucket/bucket type combination is specified
// using a Namespace object. To specify bucket, bucket type, and key,
// use a Location object that incorporates the Namespace object, as is
// done below.

Location set = new Location(new Namespace("<bucket_type>", "<bucket>"), "<key>");

Create a Set​

For the following example, we will use a set to store a list of cities that we want to visit. Let's create a Riak set stored in the key cities in the bucket travel using the sets bucket type created previously:

// In the Java client, you specify the location of Data Types
// before you perform operations on them:

Location citiesSet = new Location(new Namespace("sets", "travel"), "cities");

Upon creation, our set is empty. We can verify that it is empty at any time:

// Using our "cities" Location from above:

FetchSet fetch = new FetchSet.Builder(citiesSet)
    .build();
FetchSet.Response response = client.execute(fetch);
RiakSet set = response.getDatatype();
boolean isEmpty = set.viewAsSet().isEmpty();

Add to a Set​

But let's say that we read a travel brochure saying that Toronto and Montreal are nice places to go. Let's add them to our cities set:

// Using our "cities" Location from above:

SetUpdate su = new SetUpdate()
        .add("Toronto")
        .add("Montreal");
UpdateSet update = new UpdateSet.Builder(citiesSet, su)
        .build();
client.execute(update);

Remove from a Set​

Later on, we hear that Hamilton and Ottawa are nice cities to visit in Canada, but if we visit them, we won't have time to visit Montreal, so we need to remove it from the list.

Note that removing an element from a set is trickier than adding elements. In order to remove an item (or multiple items), we need to first fetch the set, which provides our client access to the set's causal context.

Once we've fetched the set, we can remove the element Montreal and store the set:

// Using our "citiesSet" Location from above

// First, we get a response
FetchSet fetch = new FetchSet.Builder(citiesSet).build();
FetchSet.Response response = client.execute(fetch);

// Then we can fetch the set's causal context
Context ctx = response.getContext();

// Now we build a SetUpdate operation
SetUpdate su = new SetUpdate()
        .remove("Montreal")
        .add("Hamilton")
        .add("Ottawa");

// Finally, we update the set, specifying the context
UpdateSet update = new UpdateSet.Builder(citiesSet, su)
        .withContext(ctx)
        .build();
client.execute(update);

// More information on using causal context with the Java client can be
// found at the bottom of this document

Retrieve a Set​

Now, we can check on which cities are currently in our set:

// Using our "cities" Location from above:

FetchSet fetch = new FetchSet.Builder(citiesSet)
        .build();
FetchSet.Response response = client.execute(fetch);
Set<BinaryValue> binarySet = response.getDatatype().view();
for (BinaryValue city : binarySet) {
  System.out.println(city.toStringUtf8());
}

Find Set Member​

Or we can see whether our set includes a specific member:

// Using our "citiesSet" from above:

System.out.println(citiesSet.contains(("Vancouver"));
System.out.println(citiesSet.contains("Ottawa"));

Size of Set​

We can also determine the size of the set:

// Using our "citiesSet" from above:

int numberOfCities = citiesSet.size();