Deletes the entities having the given keys.

@param keys
the entities' keys
@throws EntityManagerException
if any error occurs while deleting.
324472
public void deleteByKey(List<DatastoreKey> keys) {
    try {
      Key[] nativeKeys = new Key[keys.size()];
      for (int i = 0; i < keys.size(); i++) {
        nativeKeys[i] = keys.get(i).nativeKey();
      }
      nativeWriter.delete(nativeKeys);
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
389717
public static function destroy(array $keys = [])
    {
        if (empty($keys))
        {
            session_destroy();
        }
        else
        {
            foreach ($keys as $key) {
                if (static::_isSet($key))
                {
                    unset($_SESSION[$key]);
                }
            }
        }
    }
169001
@Override public synchronized Long del(final String ... keys) {
        long deleted = 0L;
        String key;
        for (int idx = 0; idx < keys.length; idx += 1) {
            key = keys[idx];
            timers.remove(key);
            expirations.remove(key);
            for (IRedisCache cache : caches) {
                if (cache.exists(key)) {
                    cache.remove(key);
                    keyModified(key);
                    deleted += 1L;
                    break;
                }
            }
        }
        return deleted;
    }
1246415
public <E> void delete(Class<E> entityClass, DatastoreKey parentKey, long id) {
    try {
      EntityMetadata entityMetadata = EntityIntrospector.introspect(entityClass);
      Key nativeKey = Key.newBuilder(parentKey.nativeKey(), entityMetadata.getKind(), id).build();
      nativeWriter.delete(nativeKey);
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
1340322
@Override
    public void delete(Object entity, Object pKey)
    {
        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entity.getClass());
        Object connection = getConnection();
        Pipeline pipeLine = null;
        try
        {
            if (isBoundTransaction())
            {
                pipeLine = ((Jedis) connection).pipelined();
                onDelete(entity, pKey, pipeLine);
            }
            else
            {
                onDelete(entity, pKey, connection);
            }
            getIndexManager().remove(metadata, entity, pKey);
        }
        finally
        {
            if (pipeLine != null)
            {
                pipeLine.sync();
            }
            onCleanup(connection);
        }
    }
1010685
public void deleteObjects(Collection objects)
    {
        for (Iterator iterator = objects.iterator(); iterator.hasNext();)
        {
            getDatabase().deletePersistent(iterator.next());
        }
    }
1344052
@Override
    protected void delete(Object entity, Object pKey)
    {
        EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entity.getClass());
        r.db(entityMetadata.getSchema()).table(entityMetadata.getTableName()).get(pKey).delete().run(connection);
    }
1312281
public void deleteObjects(Collection objects)
    {
        PersistenceBroker broker = null;
        try
        {
            broker = getBroker();
            this.deleteObjects(broker, objects);
        }
        finally
        {
            if (broker != null) broker.close();
        }
    }
1180737
protected List<String> deleteObjects(List<String> keys) throws IOException {
    List<String> result = new ArrayList<>();
    for (String key : keys) {
      boolean status = deleteObject(key);
      // If key is a directory, it is possible that it was not created through Alluxio and no
      // zero-byte breadcrumb exists
      if (status || key.endsWith(getFolderSuffix())) {
        result.add(key);
      }
    }
    return result;
  }
1337364
public final void remove(EntityMetadata metadata, Object entity, Object key)
    {
        if (indexer != null)
        {
            if (indexer.getClass().getName().equals(IndexingConstants.LUCENE_INDEXER))
            {
                ((com.impetus.kundera.index.lucene.Indexer) indexer).unindex(metadata, key, kunderaMetadata, null);
            }
            else
            {
                indexer.unIndex(metadata.getEntityClazz(), entity, metadata, (MetamodelImpl) kunderaMetadata
                        .getApplicationMetadata().getMetamodel(metadata.getPersistenceUnit()));
            }
        }
    }
138564
public static void removeCache(Class<? extends BaseEntity> entityClass,String key){
    	if(CacheHandler.cacheProvider == null)return;
    	String entityClassName = entityClass.getSimpleName();
		key = entityClassName + CacheHandler.SPLIT_PONIT + key;
		String cacheGroupKey = entityClassName + CacheHandler.GROUPKEY_SUFFIX;
		
		CacheHandler.cacheProvider.remove(key);
		CacheHandler.cacheProvider.removeFromGroup(cacheGroupKey, key);
		
	}
899204
public void delete(Object entity) {
    try {
      entityManager.executeEntityListeners(CallbackType.PRE_DELETE, entity);
      Key nativeKey = Marshaller.marshalKey(entityManager, entity);
      nativeWriter.delete(nativeKey);
      entityManager.executeEntityListeners(CallbackType.POST_DELETE, entity);
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
433413
public void setKeyNames(java.util.Collection<String> keyNames) {
        if (keyNames == null) {
            this.keyNames = null;
            return;
        }

        this.keyNames = new com.amazonaws.internal.SdkInternalList<String>(keyNames);
    }
1253355
private void deleteFromIndices(ApiType oldObj, String key) {
    for (Map.Entry<String, Function<ApiType, List<String>>> indexEntry : this.indexers.entrySet()) {
      Function<ApiType, List<String>> indexFunc = indexEntry.getValue();
      List<String> indexValues = indexFunc.apply(oldObj);
      if (io.kubernetes.client.util.common.Collections.isEmptyCollection(indexValues)) {
        continue;
      }

      Map<String, Set<String>> index = this.indices.get(indexEntry.getKey());
      if (index == null) {
        continue;
      }
      for (String indexValue : indexValues) {
        Set<String> indexSet = index.get(indexValue);
        if (indexSet != null) {
          indexSet.remove(key);
        }
      }
    }
  }
622581
public void deletion(K key) {
        if (deletions==null) deletions = new ArrayList<K>();
        deletions.add(key);
    }
1060112
public void remove(String key) {
    Iterator<Pair<String, ArrayList<String>>> it = store.iterator();
    while (it.hasNext()) {
      String thisKey = it.next().first;
      if (key.equals(thisKey)) {
        it.remove();
        break;
      }
    }
  }
1334643
public void clear(Collection keys) {
		synchronized (mirror) {
			synchronized (data) {
				Iterator i = keys.iterator();
				while (i.hasNext()) {
					Object key = i.next();
					data.remove(key);
					mirror.remove(key);
				}
			}
		}
	}