@Override public Result<Void> delete(Iterable<?> keysOrEntities) { // We have to be careful here, objs could contain raw Keys or Keys or entity objects or both! List<com.google.appengine.api.datastore.Key> keys = new ArrayList<com.google.appengine.api.datastore.Key>(); for (Object obj: keysOrEntities) keys.add(this.factory.getRawKey(obj)); return new ResultAdapter<Void>(this.ads.delete(this.txn, keys)); }
@Override public Future<Void> delete(final Transaction txn, final Iterable<Key> keys) { // Always trigger, even on failure - the delete might have succeeded even though a timeout // exception was thrown. We will always be safe emptying the key from the cache. Future<Void> future = new TriggerFuture<Void>(this.rawAsync.delete(txn, keys)) { @Override protected void trigger() { if (txn != null) { for (Key key: keys) ((TransactionWrapper)txn).deferEmptyFromCache(key); } else { memcache.empty(keys); } } }; if (txn instanceof TransactionWrapper) ((TransactionWrapper)txn).enlist(future); return future; }
@Override public FutureObject<Void> destroyAsync(IdRef<?> id) { Future<Void> future = asyncDatastore().delete(IdRefToKey.toKey(r, id)); return new FutureObject<>(r, future); }
public Void run(AsyncDatastoreService ads) throws Exception { Future<Void> fd1 = ads.delete(k1.get()); Assert.assertNotNull(fd1); fd1.get(); return null; } };
AsyncDatastoreService ds = DatastoreServiceFactory.getAsyncDatastoreService(); // create query for your kind Query query = new Query("Kind"); // we don't need anything else than the key query.setKeysOnly(); // set the filter for date before now query.setFilter( new FilterPredicate( "date", FilterOperator.LESS_THAN_OR_EQUAL, new Date())); PreparedQuery pq = ds.prepare(query); // asIterable is more efficient than asList for (Entity en : pq.asIterable()) { // delete each entity ds.delete(en.getKey()); }
@Test public void testMultipleDataGet() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey(ASYNC_ENTITY, "testMultipleDataGet"); Key key = parent.getKey(); final int recordCount = 10; List<Entity> lisRec = new ArrayList<Entity>(); for (int i = 0; i < recordCount; i++) { Entity newRec = new Entity(ASYNC_ENTITY, key); newRec.setProperty("count", i); newRec.setProperty("timestamp", new Date()); lisRec.add(newRec); } List<Key> eKeys = service.put(lisRec); Future<Map<Key, Entity>> futureKeyEntity = asyncService.get(eKeys); Map<Key, Entity> es = futureKeyEntity.get(); assertTaskIsDoneAndNotCancelled(futureKeyEntity); assertEquals(recordCount, es.size()); asyncService.delete(eKeys); }
@Test public void testCRUD() throws Exception { AsyncDatastoreService service = DatastoreServiceFactory.getAsyncDatastoreService(); Entity e1 = new Entity("ASYNC"); e1.setProperty("foo", "bar"); Future<Key> k1 = service.put(e1); Assert.assertNotNull(k1); Key key = k1.get(); Assert.assertNotNull(key); Future<Entity> fe1 = service.get(key); Assert.assertNotNull(fe1); Assert.assertEquals(e1, fe1.get()); Future<Void> fd1 = service.delete(key); Assert.assertNotNull(fd1); fd1.get(); assertStoreDoesNotContain(key); }
@Test public void testDataDelete() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey(ASYNC_ENTITY, "testDataDelete"); Key key = parent.getKey(); Entity newRec = new Entity(ASYNC_ENTITY); newRec.setProperty("count", 0); newRec.setProperty("timestamp", new Date()); Key ekey = service.put(newRec); Future<Void> future = asyncService.delete(ekey); future.get(); assertTaskIsDoneAndNotCancelled(future); assertEquals(0, service.prepare(simpleQuery(key)).countEntities(withDefaults())); }
@Test public void testMultipleDataDelete() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey(ASYNC_ENTITY, "testMultipleDelete"); Key key = parent.getKey(); List<Entity> lisRec = new ArrayList<Entity>(); final int recordCount = 10; for (int i = 0; i < recordCount; i++) { Entity newRec = new Entity(ASYNC_ENTITY, key); newRec.setProperty("count", i); newRec.setProperty("timestamp", new Date()); lisRec.add(newRec); } List<Key> eKeys = service.put(lisRec); assertEquals("Entities not available to test delete.", recordCount, service.prepare(simpleQuery(key)).countEntities(withDefaults())); Future<Void> future = asyncService.delete(eKeys); future.get(); assertTaskIsDoneAndNotCancelled(future); assertEquals(0, service.prepare(simpleQuery(key)).countEntities(withDefaults())); }