How to use

com.aerospike.client.Key

constructor

 @Override
 public Status delete(String table, String key) {
  try {
   if (!client.delete(deletePolicy, new Key(namespace, table, key))) {
    System.err.println("Record key " + key + " not found (delete)");
    return Status.ERROR;
   }

   return Status.OK;
  } catch (AerospikeException e) {
   System.err.println("Error while deleting key " + key + ": " + e);
   return Status.ERROR;
  }
 }
}

@Override
public Status read(String table, String key, Set<String> fields,
  Map<String, ByteIterator> result) {
 try {
  Record record;
  if (fields != null) {
   record = client.get(readPolicy, new Key(namespace, table, key),
     fields.toArray(new String[fields.size()]));
  } else {
   record = client.get(readPolicy, new Key(namespace, table, key));
  }
  if (record == null) {
   System.err.println("Record key " + key + " not found (read)");
   return Status.ERROR;
  }
  for (Map.Entry<String, Object> entry: record.bins.entrySet()) {
   result.put(entry.getKey(),
     new ByteArrayByteIterator((byte[])entry.getValue()));
  }
  return Status.OK;
 } catch (AerospikeException e) {
  System.err.println("Error while reading key " + key + ": " + e);
  return Status.ERROR;
 }
}

private Status write(String table, String key, WritePolicy writePolicy,
  Map<String, ByteIterator> values) {
 Bin[] bins = new Bin[values.size()];
 int index = 0;
 for (Map.Entry<String, ByteIterator> entry: values.entrySet()) {
  bins[index] = new Bin(entry.getKey(), entry.getValue().toArray());
  ++index;
 }
 Key keyObj = new Key(namespace, table, key);
 try {
  client.put(writePolicy, keyObj, bins);
  return Status.OK;
 } catch (AerospikeException e) {
  System.err.println("Error while writing key " + key + ": " + e);
  return Status.ERROR;
 }
}

protected Key collectKey(Object obj) {
  // get metadata for object
  ObjectMetadata meta = MapperService.getMapper(obj.getClass()).getRequiredMetadata(obj, defaultNamespace);
  if (meta.userKeyString != null) {
    return new Key(meta.namespace, meta.setName, meta.userKeyString);
  } else {
    return new Key(meta.namespace, meta.setName, meta.userKeyLong);
  }
}

@Override
public void removeCommittedWindowId(String appId, int operatorId) {
 try {
  String keyString = appId + String.valueOf(operatorId);
  Key key = new Key(namespace,metaSet,keyString.hashCode());
  client.delete(null, key);
 }
 catch (AerospikeException e) {
  throw new RuntimeException(e);
 }
}

  public Key makeKey(String namespace, String set) {
    if (hasDigest) {
      byte[] digest = getDigest();
      return new Key(namespace, digest, null, null);
    } else {
      return new Key(namespace, set, getValue1());
    }
  }
}

protected Key collectKey(T obj) {
  // get metadata for object
  ObjectMetadata meta = MapperService.getMapper(obj.getClass()).getRequiredMetadata(obj, defaultNamespace);
  if (meta.userKeyString != null) {
    return new Key(meta.namespace, meta.setName, meta.userKeyString);
  } else {
    return new Key(meta.namespace, meta.setName, meta.userKeyLong);
  }
}

protected static Key collectKey(Object obj, String namespace) {
  // get metadata for object
  ObjectMetadata meta = MapperService.getMapper(obj.getClass()).getRequiredMetadata(obj, namespace);
  if (meta.userKeyString != null) {
    return new Key(meta.namespace, meta.setName, meta.userKeyString);
  } else {
    return new Key(meta.namespace, meta.setName, meta.userKeyLong);
  }
}

private void deleteRecords(
  AerospikeClient client,
  Parameters params,
  String keyPrefix,
  int size	
) throws Exception {
  for (int i = 0; i < size; i++) {
    Key key = new Key(params.namespace, params.set, keyPrefix + i);
    client.delete(params.writePolicy, key);            
  }
}

protected void collectKeys() {
  // check if any Long or String keys were provided
  if (stringKeys != null) {
    for (String stringKey : stringKeys) {
      keys.add(new Key(getNamespace(), getSetName(), stringKey));
    }
  } else if (longKeys != null) {
    for (long longKey : longKeys) {
      keys.add(new Key(getNamespace(), getSetName(), longKey));
    }
  }
}

public void runCommand() {
  long currentKey = keyStart + keyCount;
  Key key = new Key(args.namespace, args.setName, currentKey);
  Bin[] bins = args.getBins(random, true, currentKey);
  
  if (useLatency) {
    begin = System.nanoTime();
  }
  client.put(eventLoop, listener, args.writePolicy, key, bins);        
}

private void runCommand(long keyCurrent, RandomShift random) {
  Key key = new Key(args.namespace, args.setName, keyCurrent);
  // Use predictable value for 0th bin same as key value
  Bin[] bins = args.getBins(random, true, keyCurrent);
  put(key, bins);        
}

protected void collectKeys() {
  // check if any Long or String keys were provided
  if (stringKey != null) {
    key = new Key(getNamespace(), getSetName(), stringKey);
  } else if (longKey != null) {
    key = new Key(getNamespace(), getSetName(), longKey);
  }
}

protected void collectKeys() {
  // check if any Long or String keys were provided
  if (stringKey != null) {
    key = new Key(getNamespace(), getSetName(), stringKey);
  } else if (longKey != null) {
    key = new Key(getNamespace(), getSetName(), longKey);
  }
}

protected void collectKeys() {
  // check if any Long or String keys were provided
  if (stringKey != null) {
    key = new Key(getNamespace(), getSetName(), stringKey);
  } else if (longKey != null) {
    key = new Key(getNamespace(), getSetName(), longKey);
  }
  if (key == null) {
    throw new SpikeifyError("Missing parameter: key not specified.");
  }
}

 @Override
 protected Key getUpdatedBins(TestEvent tuple, List<Bin> bins) throws AerospikeException
 {
  Key key = new Key(NAMESPACE,SET_NAME,String.valueOf(tuple.id));
  bins.add(new Bin("ID",tuple.id));
  return key;
 }
}

/**
 * Asynchronously write and read a bin using alternate methods.
 */
@Override
public void runExample(AerospikeClient client, EventLoop eventLoop) {
  Key key = new Key(params.namespace, params.set, "putgetkey");
  Bin bin = new Bin(params.getBinName("putgetbin"), "value");
  runPutGetInline(client, eventLoop, key, bin);
  runPutGetWithRetry(client, eventLoop, key, bin);
}

@Override
public boolean exists(Class type, String id) {
  ClassMapper mapper = MapperService.getMapper(type);
  return asynClient.exists(null, new Key(getNamespace(mapper), getSetName(mapper), id));
}

@Override
public boolean exists(Class type, Long id) {
  ClassMapper mapper = MapperService.getMapper(type);
  Key key = new Key(getNamespace(mapper), getSetName(mapper), id);
  return asynClient.exists(null, key);
}

private void writeIfGenerationNotChanged(AerospikeClient client, Parameters params) throws Exception {	
  Key key = new Key(params.namespace, params.set, "udfkey2");
  Bin bin = new Bin(params.getBinName("udfbin2"), "string value");		
  
  // Seed record.
  client.put(params.writePolicy, key, bin);
  
  // Get record generation.
  long gen = (Long)client.execute(params.writePolicy, key, "record_example", "getGeneration");
  // Write record if generation has not changed.
  client.execute(params.writePolicy, key, "record_example", "writeIfGenerationNotChanged", Value.get(bin.name), bin.value, Value.get(gen));		
  console.info("Record written.");
}