Delete one synonym

@param objectID          The objectId of the synonym to delete
@param forwardToReplicas Forward the operation to the replica indices
489954
public JSONObject deleteSynonym(String objectID, boolean forwardToReplicas) throws AlgoliaException {
    return this.deleteSynonym(objectID, forwardToReplicas, RequestOptions.empty);
  }
80660
@Override
    protected void delete(Object entity, Object pKey)
    {
        EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entity.getClass());
        String id = generateJsonDocId(entityMetadata.getTableName(), pKey.toString());
        bucket.remove(id);
        LOGGER.debug("Deleted document with ID : " + id + " from the " + bucket.name() + " Bucket");
    }
759595
@Override
    public EntityResult deleteEntities(List<String> deleteCandidateGuids) throws AtlasException {
        ParamChecker.notEmpty(deleteCandidateGuids, "delete candidate guids");
        return deleteGuids(deleteCandidateGuids);
    }
360405
public int deleteIds(DatabaseConnection databaseConnection, Collection<ID> ids, ObjectCache objectCache)
			throws SQLException {
		// have to build this on the fly because the collection has variable number of args
		int result = MappedDeleteCollection.deleteIds(dao, tableInfo, databaseConnection, ids, objectCache);
		if (dao != null && !localIsInBatchMode.get()) {
			dao.notifyChanges();
		}
		return result;
	}
453292
public void updateReplicasForJoin(TransactionState snapshotTransactionState) {
        long[] replicasAdded = new long[0];
        if (m_term != null) {
            replicasAdded = ((SpTerm) m_term).updateReplicas(snapshotTransactionState);
        }
        m_scheduler.forwardPendingTaskToRejoinNode(replicasAdded, snapshotTransactionState.m_spHandle);
    }
1137336
def save_synonym(objectID, synonym, forward_to_replicas = false, request_options = {})
      client.put("#{Protocol.synonym_uri(name, objectID)}?forwardToReplicas=#{forward_to_replicas}", synonym.to_json, :write, request_options)
    end
803682
@UpdateHandler(name = "delete_record", file = "CouchDbMultifactorAuthenticationTrustRecord_delete.js")
    public void deleteRecord(final CouchDbMultifactorAuthenticationTrustRecord record) {
        db.callUpdateHandler(stdDesignDocumentId, "delete_record", record.getCid(), null);
    }
541293
def delete(self, bulk_id):
        

        collection_name = self.request.headers.get("collection")

        if not collection_name:
            self.raise_error(400, "Missing a collection name header")

        self.revisions = BaseAsyncMotorDocument("%s_revisions" % collection_name)

        self.logger.info("Deleting revisions with bulk_id %s" % (bulk_id))

        result = yield self.revisions.collection.remove({"meta.bulk_id": bulk_id})

        self.write(result)
361750
protected void purgeZeroObject(Long bucketId, Long objectId, AllocationPoint point, boolean copyback) {
        allocationsMap.remove(objectId);

        memoryHandler.purgeZeroObject(bucketId, objectId, point, copyback);

        getFlowController().getEventsProvider().storeEvent(point.getLastWriteEvent());
        getFlowController().getEventsProvider().storeEvent(point.getLastReadEvent());
    }
803360
@Override
    public void deleteStoreIfPresent(String storeName) {
        String tableName = storeToCQLName(storeName);
        if (storeExists(tableName)) {
            new CQLSchemaManager(this).dropCQLTable(tableName);
        }
    }
1186017
@Override
  public Task<Void> deleteApiKey(@NonNull final ObjectId id) {
    return dispatcher.dispatchTask(new Callable<Void>() {
      @Override
      public Void call() {
        deleteApiKeyInternal(id);
        return null;
      }
    });
  }
450742
@SuppressWarnings("WeakerAccess")
  public void deleteAppProfile(String instanceId, String appProfileId) {
    ApiExceptions.callAndTranslateApiException(deleteAppProfileAsync(instanceId, appProfileId));
  }
1009512
protected void removeExistingEntity(String localId) {
		if (StringUtils.isEmpty(localId))
			return;
		List<Feature> listOfFeature = featureRepo.getFeatureIdById(localId);

		if (CollectionUtils.isEmpty(listOfFeature))
			return;
		featureRepo.delete(listOfFeature);
	}
579673
void removeFromInvalidates(String storageID) {
    LightWeightHashSet<Block> blocks = recentInvalidateSets.remove(storageID);
    if (blocks != null) {
      pendingDeletionBlocksCount -= blocks.size();
    }
  }
69413
def delete(self, where=None, start=None, stop=None, **kwargs):
        
        if com._all_none(where, start, stop):
            self._handle.remove_node(self.group, recursive=True)
            return None

        raise TypeError("cannot delete on an abstract storer")
878953
@Override
	public Mono<Void> deleteById(String id) {

		return findSession(id)
				.flatMap(document -> this.mongoOperations.remove(document, this.collectionName).then(Mono.just(document)))
				.map(document -> convertToSession(this.mongoSessionConverter, document))
				.doOnSuccess(mongoSession -> publishEvent(new SessionDeletedEvent(this, mongoSession))) //
				.then();
	}
577145
protected void deleteApiKeyInternal(final ObjectId id) {
    final StitchAuthRequest.Builder reqBuilder = new StitchAuthRequest.Builder();
    reqBuilder
            .withMethod(Method.DELETE)
            .withPath(routes.getApiKeyRouteForId(id.toHexString()))
            .withRefreshToken();
    getRequestClient().doAuthenticatedRequest(reqBuilder.build());
  }