@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 void scanCallback(Key key, Record record) throws AerospikeException { if (client.delete(null, key)) count.addAndGet(1); /* * after 10,000 records delete, return print the * count. */ if (count.get() % 10000 == 0) { log.trace("Deleted {}", count.get()); } } }, new String[] {});
@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); } }
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); } }
@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); } }
@Override public void evict(Object key) { this.client.delete(null, getKey(key)); }
private Map<String, Long> delete(KeyRecordIterator results) { long readCount = 0; long updateCount = 0; while (results.hasNext()) { KeyRecord keyRecord = results.next(); readCount++; try { if (client.delete(null, keyRecord.key)) updateCount++; } catch (AerospikeException e) { log.error("Unexpected exception deleting " + keyRecord.key, e); } } Map<String, Long> map = new HashMap<String, Long>(); map.put("read", readCount); map.put("write", updateCount); return map; }
@Override public Object delete(Serializable id, Serializable keyspace) { Key key = new Key(namespace, keyspace.toString(), id.toString()); Object object = get(id, keyspace); if (object != null) { WritePolicy wp = new WritePolicy(); wp.recordExistsAction = RecordExistsAction.UPDATE_ONLY; client.delete(wp, key); } return object; }
@Override public boolean delete(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); return this.client.delete(null, key); } catch (AerospikeException e) { DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e); throw translatedException == null ? e : translatedException; } }
/** * {@inheritDoc} * * @param key the key of the object * @return whether the object was successfully deleted */ @Override public boolean delete(K key) { Key recordKey = getAerospikeKey(key); return aerospikeClient .delete(aerospikeParameters.getAerospikeMapping().getWritePolicy(), recordKey); }
@Override public boolean delete(Object objectToDelete) { Assert.notNull(objectToDelete, "Object to delete must not be null!"); try { AerospikeWriteData data = AerospikeWriteData.forWrite(); converter.write(objectToDelete, data); return this.client.delete(null, data.getKey()); } catch (AerospikeException e) { DataAccessException translatedException = exceptionTranslator.translateExceptionIfPossible(e); throw translatedException == null ? e : translatedException; } }
/** * Delete a bid key from the cache/aerospile. * @param skey String. The key name. * @throws Exception on Aerospike/cache errors. */ public void del(String skey) { if (ae == null) { cache.remove(skey); return; } Key key = new Key("test", "cache", skey); ae.getClient().delete(null, key); }
/** * {@inheritDoc} * * @param query matching records to this query will be deleted * @return the number of deleted records */ @Override public long deleteByQuery(Query<K, T> query) { Result<K, T> result = query.execute(); int deleteCount = 0; try { while (result.next()) { if (aerospikeClient.delete(null, getAerospikeKey(result.getKey()))) { deleteCount++; } } return deleteCount; } catch (Exception e) { LOG.error(e.getMessage(), e); return -1; } }
/** * Write/Read ArrayList<String> directly instead of relying on java serializer. */ private void testListStrings(AerospikeClient client, Parameters params) throws Exception { console.info("Read/Write ArrayList<String>"); Key key = new Key(params.namespace, params.set, "listkey1"); client.delete(params.writePolicy, key); ArrayList<String> list = new ArrayList<String>(); list.add("string1"); list.add("string2"); list.add("string3"); Bin bin = new Bin(params.getBinName("listbin1"), list); client.put(params.writePolicy, key, bin); Record record = client.get(params.policy, key, bin.name); List<?> receivedList = (List<?>) record.getValue(bin.name); validateSize(3, receivedList.size()); validate("string1", receivedList.get(0)); validate("string2", receivedList.get(1)); validate("string3", receivedList.get(2)); console.info("Read/Write ArrayList<String> successful."); }
/** * Write/Read HashMap<String,String> directly instead of relying on java serializer. */ private void testMapStrings(AerospikeClient client, Parameters params) throws Exception { console.info("Read/Write HashMap<String,String>"); Key key = new Key(params.namespace, params.set, "mapkey1"); client.delete(params.writePolicy, key); HashMap<String,String> map = new HashMap<String,String>(); map.put("key1", "string1"); map.put("key2", "string2"); map.put("key3", "string3"); Bin bin = new Bin(params.getBinName("mapbin1"), map); client.put(params.writePolicy, key, bin); Record record = client.get(params.policy, key, bin.name); Map<?,?> receivedMap = (Map<?,?>) record.getValue(bin.name); validateSize(3, receivedMap.size()); validate("string1", receivedMap.get("key1")); validate("string2", receivedMap.get("key2")); validate("string3", receivedMap.get("key3")); console.info("Read/Write HashMap<String,String> successful"); }
/** * {@inheritDoc} * * @param key the key of the object * @return whether the object was successfully deleted */ @Override public boolean delete(K key) throws GoraException { try { Key recordKey = getAerospikeKey(key); return aerospikeClient .delete(aerospikeParameters.getAerospikeMapping().getWritePolicy(), recordKey); } catch (Exception e) { throw new GoraException(e); } }
/** * {@inheritDoc} * * @param query matching records to this query will be deleted * @return the number of deleted records */ @Override public long deleteByQuery(Query<K, T> query) throws GoraException { int deleteCount = 0; try { Result<K, T> result = query.execute(); while (result.next()) { if (aerospikeClient.delete(null, getAerospikeKey(result.getKey()))) { deleteCount++; } } return deleteCount; } catch (Exception e) { throw new GoraException(e); } }
/** * Set a key value as string. * @param skey String. The key name. * @param value String. The value. * @throws Exception on aerorpike or cache errors. */ public void set(String skey, String value) { if (ae == null) { cache.put(skey, value); return; } Key key = new Key("test", "cache", skey); Bin bin1 = new Bin("value", value); ae.getClient().delete(null, key); ae.getClient().put(null, key, bin1); }
static void cleanMetaTable() { AerospikeClient client = null; try { client = new AerospikeClient(NODE, PORT); Statement stmnt = new Statement(); stmnt.setNamespace(NAMESPACE); stmnt.setSetName(AerospikeTransactionalStore.DEFAULT_META_SET); RecordSet rs = client.query(null, stmnt); while (rs.next()) { client.delete(null, rs.getKey()); } } catch (AerospikeException e) { LOG.error("cleanMetaTable failed: {}", e); throw e; } finally { if (null != client) { client.close(); } } }
static void cleanTable() { AerospikeClient client = null; try { client = new AerospikeClient(NODE, PORT); Statement stmnt = new Statement(); stmnt.setNamespace(NAMESPACE); stmnt.setSetName(SET_NAME); RecordSet rs = client.query(null, stmnt); while (rs.next()) { client.delete(null, rs.getKey()); } } catch (AerospikeException e) { LOG.error("cleanTable failed: {}", e); throw e; } finally { if (null != client) { client.close(); } } }