How to use

operate

method

in

com.aerospike.client.AerospikeClient

@Override
public boolean exists(Serializable id, Class<?> type) {
  Assert.notNull(id, "Id must not be null!");
  Assert.notNull(type, "Type must not be null!");
  try {
    AerospikePersistentEntity<?> entity = mappingContext.getPersistentEntity(type);
    Key key = getKey(id, entity);
    Record record = this.client.operate(null, key, Operation.getHeader());
    return record != null;
  } catch (AerospikeException e) {
    DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e);
    throw translatedException == null ? e : translatedException;
  }
}

private Record getAndTouch(Key key, int expiration) {
  WritePolicy writePolicy = new WritePolicy(client.writePolicyDefault);
  writePolicy.expiration = expiration;
  return this.client.operate(writePolicy, key, Operation.touch(), Operation.get());
}

client.operate(this.params.writePolicy, key,
    com.aerospike.client.cdt.ListOperation.append(b.name, b.value));

@SuppressWarnings("unchecked")
@Override
public <T> T append(T objectToAppendTo, Map<String, String> values) {
  Assert.notNull(objectToAppendTo,
      "Object to append to must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToAppendTo, data);
    Operation[] ops = new Operation[values.size() + 1];
    int x = 0;
    for (Map.Entry<String, String> entry : values.entrySet()) {
      Bin newBin = new Bin(entry.getKey(), entry.getValue());
      ops[x] = Operation.append(newBin);
      x++;
    }
    ops[x] = Operation.get();
    Record record = this.client.operate(null, data.getKey(), ops);
    return mapToEntity(data.getKey(), (Class<T>) objectToAppendTo.getClass(), record);
  }
  catch (AerospikeException o_O) {
    DataAccessException translatedException = exceptionTranslator
        .translateExceptionIfPossible(o_O);
    throw translatedException == null ? o_O : translatedException;
  }
}

@SuppressWarnings("unchecked")
@Override
public <T> T prepend(T objectToPrependTo, Map<String, String> values) {
  Assert.notNull(objectToPrependTo,
      "Object to prepend to must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToPrependTo, data);
    Operation[] ops = new Operation[values.size() + 1];
    int x = 0;
    for (Map.Entry<String, String> entry : values.entrySet()) {
      Bin newBin = new Bin(entry.getKey(), entry.getValue());
      ops[x] = Operation.prepend(newBin);
      x++;
    }
    ops[x] = Operation.get();
    Record record = this.client.operate(null, data.getKey(), ops);
    return mapToEntity(data.getKey(), (Class<T>) objectToPrependTo.getClass(), record);
  }
  catch (AerospikeException o_O) {
    DataAccessException translatedException = exceptionTranslator
        .translateExceptionIfPossible(o_O);
    throw translatedException == null ? o_O : translatedException;
  }
}

Record record = client.operate(params.writePolicy, key, 
    MapOperation.putItems(MapPolicy.Default, binName, inputMap)
    );
record = client.operate(params.writePolicy, key, 
    MapOperation.removeByValueRange(binName, null, Value.get(end), MapReturnType.COUNT)
    );

@SuppressWarnings("unchecked")
public <T> T add(T objectToAddTo, Map<String, Long> values) {
  Assert.notNull(objectToAddTo, "Object to add to must not be null!");
  Assert.notNull(values, "Values must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToAddTo, data);
    Operation[] operations = new Operation[values.size() + 1];
    int x = 0;
    for (Map.Entry<String, Long> entry : values.entrySet()) {
      Bin newBin = new Bin(entry.getKey(), entry.getValue());
      operations[x] = Operation.add(newBin);
      x++;
    }
    operations[x] = Operation.get();
    WritePolicy writePolicy = new WritePolicy(this.client.writePolicyDefault);
    writePolicy.expiration = data.getExpiration();
    Record record = this.client.operate(writePolicy, data.getKey(),
        operations);
    return mapToEntity(data.getKey(), (Class<T>) objectToAddTo.getClass(), record);
  } catch (AerospikeException e) {
    DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e);
    throw translatedException == null ? e : translatedException;
  }
}

@Override
public ValueWrapper putIfAbsent(Object key, Object value) {
  Record record = client.operate(this.createOnly, getKey(key), Operation.put(new Bin(VALUE, value)), Operation.get(VALUE));
  return toWrapper(record);
}

@SuppressWarnings("unchecked")
public <T> T add(T objectToAddTo, String binName, long value) {
  Assert.notNull(objectToAddTo, "Object to add to must not be null!");
  Assert.notNull(binName, "Bin name must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToAddTo, data);
    WritePolicy writePolicy = new WritePolicy(this.client.writePolicyDefault);
    writePolicy.expiration = data.getExpiration();
    Record record = this.client.operate(writePolicy, data.getKey(),
        Operation.add(new Bin(binName, value)), Operation.get());
    return mapToEntity(data.getKey(), (Class<T>) objectToAddTo.getClass(), record);
  } catch (AerospikeException e) {
    DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e);
    throw translatedException == null ? e : translatedException;
  }
}

Record record = client.operate(params.writePolicy, key, 
    ListOperation.appendItems(binName, inputList)
    );
record = client.operate(params.writePolicy, key, 
    ListOperation.pop(binName, -1),
    ListOperation.size(binName)

@SuppressWarnings("unchecked")
@Override
public <T> T prepend(T objectToPrependTo, String fieldName, String value) {
  Assert.notNull(objectToPrependTo,
      "Object to prepend to must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToPrependTo, data);
    Record record = this.client.operate(null, data.getKey(),
        Operation.prepend(new Bin(fieldName, value)),
        Operation.get(fieldName));
    return mapToEntity(data.getKey(), (Class<T>) objectToPrependTo.getClass(), record);
  }
  catch (AerospikeException o_O) {
    DataAccessException translatedException = exceptionTranslator
        .translateExceptionIfPossible(o_O);
    throw translatedException == null ? o_O : translatedException;
  }
}

@SuppressWarnings("unchecked")
@Override
public <T> T append(T objectToAppendTo, String binName, String value) {
  Assert.notNull(objectToAppendTo,
      "Object to append to must not be null!");
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(objectToAppendTo, data);
    Record record = this.client.operate(null, data.getKey(),
        Operation.append(new Bin(binName, value)),
        Operation.get(binName));
    return mapToEntity(data.getKey(), (Class<T>) objectToAppendTo.getClass(), record);
  }
  catch (AerospikeException o_O) {
    DataAccessException translatedException = exceptionTranslator
        .translateExceptionIfPossible(o_O);
    throw translatedException == null ? o_O : translatedException;
  }
}

Record record = client.operate(writePolicy, key, Operation.touch(), Operation.getHeader());

Record record = client.operate(params.writePolicy, key, 
    MapOperation.putItems(MapPolicy.Default, binName, inputMap)
    );
record = client.operate(params.writePolicy, key, 
    MapOperation.removeByKey(binName, Value.get(1), MapReturnType.VALUE),
    MapOperation.size(binName)

Record record = client.operate(params.writePolicy, key, 
    MapOperation.putItems(MapPolicy.Default, binName, inputMap)
    );
record = client.operate(params.writePolicy, key, 
    MapOperation.increment(MapPolicy.Default, binName, Value.get("John"), Value.get(5)),
    MapOperation.decrement(MapPolicy.Default, binName, Value.get("Jim"), Value.get(4))
record = client.operate(params.writePolicy, key, 
    MapOperation.getByRankRange(binName, -2, 2, MapReturnType.KEY_VALUE)
    );

/**
 * Demonstrate multiple operations on a single record in one call.
 */
@Override
public void runExample(AerospikeClient client, Parameters params) throws Exception {
  // Write initial record.
  Key key = new Key(params.namespace, params.set, "opkey");
  Bin bin1 = new Bin("optintbin", 7);
  Bin bin2 = new Bin("optstringbin", "string value");		
  console.info("Put: namespace=%s set=%s key=%s bin1=%s value1=%s bin2=%s value2=%s",
    key.namespace, key.setName, key.userKey, bin1.name, bin1.value, bin2.name, bin2.value);
  client.put(params.writePolicy, key, bin1, bin2);
  // Add integer, write new string and read record.
  Bin bin3 = new Bin(bin1.name, 4);
  Bin bin4 = new Bin(bin2.name, "new string");
  console.info("Add: " + bin3.value);
  console.info("Write: " + bin4.value);
  console.info("Read:");
  Record record = client.operate(params.writePolicy, key, Operation.add(bin3), Operation.put(bin4), Operation.get());
  if (record == null) {
    throw new Exception(String.format(
      "Failed to get: namespace=%s set=%s key=%s",
      key.namespace, key.setName, key.userKey));
  }
  validateBin(key, record, bin3.name, 11, record.getInt(bin3.name));
  validateBin(key, record, bin4.name, bin4.value.toString(), record.getValue(bin4.name));    
}

private void doPersistWithCas(Object document, AerospikePersistentEntity<?> entity) {
  try {
    AerospikeWriteData data = AerospikeWriteData.forWrite();
    converter.write(document, data);
    Key key = data.getKey();
    Bin[] bins = data.getBinsAsArray();
    ConvertingPropertyAccessor accessor = getPropertyAccessor(entity, document);
    WritePolicy policy = getCasAwareWritePolicy(data, entity, accessor);
    Operation[] operations = OperationUtils.operations(bins, Operation::put, Operation.getHeader());
    Record newRecord = client.operate(policy, key, operations);
    accessor.setProperty(entity.getVersionProperty(), newRecord.generation);
  } catch (AerospikeException e) {
    int code = e.getResultCode();
    if (code == ResultCode.KEY_EXISTS_ERROR || code == ResultCode.GENERATION_ERROR) {
      throw new OptimisticLockingFailureException("Save document with version value failed", e);
    }
    DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e);
    throw translatedException == null ? e : translatedException;
  }
}

record = client.operate(params.writePolicy, key, Operation.add(bin), Operation.get(bin.name));