Delete an index.

@param IndexUUID $indexUUID
196833
public function deleteIndex(IndexUUID $indexUUID)
    {
        $this->load();
        parent::deleteIndex($indexUUID);
        $this->save();
    }
1056961
public function deleteElement($listUuid, $elementUuid)
    {
        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        $chunkSize = $this->getChunkSize($listUuid);

        $options = [
            'cas' => true,
            'watch' => $this->getArrayChunksKeys($listUuid, $numberOfChunks),
            'retry' => 3,
        ];

        // delete in a transaction
        $this->client->transaction($options, function ($tx) use ($listUuid, $numberOfChunks, $chunkSize, $elementUuid) {
            for ($i = 1; $i <= $numberOfChunks; ++$i) {
                $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$i;
                $chunk = $this->client->hgetall($chunkNumber);

                if (array_key_exists($elementUuid, $chunk)) {
                    // delete elements from chunk
                    $tx->hdel($chunkNumber, $elementUuid);

                    // update list index
                    $prevIndex = $this->getIndex($listUuid);
                    $this->addOrUpdateListToIndex(
                        $listUuid,
                        ($prevIndex['size'] - 1),
                        $numberOfChunks,
                        $chunkSize,
                        $prevIndex['ttl']
                    );

                    // delete headers if counter = 0
                    $headersKey = $listUuid.self::SEPARATOR.self::HEADERS;
                    if ($this->getCounter($listUuid) === 0) {
                        $tx->del($headersKey);
                    }

                    break;
                }
            }
        });
    }
423978
def delete(cls, uuid):
        """"""
        to_delete = Workflow.query.get(uuid)
        db.session.delete(to_delete)
1123623
public function checkIndex(IndexUUID $indexUUID): bool
    {
        return array_key_exists($this->getIndexKey($indexUUID), $this->indices);
    }
705040
public function deleteElement($listUuid, $elementUuid)
    {
        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        $chunkSize = $this->getChunkSize($listUuid);

        for ($i = 1; $i <= $numberOfChunks; ++$i) {
            $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$i;
            $chunk = apcu_fetch($chunkNumber);

            if (array_key_exists($elementUuid, $chunk)) {
                // delete elements from chunk
                unset($chunk[(string) $elementUuid]);
                apcu_delete($chunkNumber);
                apcu_store($chunkNumber, $chunk);

                // update list index
                $prevIndex = $this->getIndex($listUuid);
                $this->addOrUpdateListToIndex(
                    $listUuid,
                    ($prevIndex['size'] - 1),
                    $numberOfChunks,
                    $chunkSize,
                    $prevIndex['ttl']
                );

                // delete headers if counter = 0
                $counter = $this->getCounter($listUuid);
                $headersKey = $listUuid.self::SEPARATOR.self::HEADERS;

                if ($counter === 0) {
                    apcu_delete($headersKey);
                }

                break;
            }
        }
    }
780936
public function deleteToken(Token $token)
    {
        $this->db
            ->delete('ucms_user_token')
            ->condition('uid', $token->uid)
            ->execute();
    }
96403
@Override
	public void removeByUuid(String uuid) {
		for (CommerceAvailabilityEstimate commerceAvailabilityEstimate : findByUuid(
				uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceAvailabilityEstimate);
		}
	}
263221
protected function deleteIndexDocuments($table, $uid)
    {
        // record can be indexed for multiple sites
        $indexQueueItems = $this->queue->getItems($table, $uid);
        foreach ($indexQueueItems as $indexQueueItem) {
            $site = $indexQueueItem->getSite();
            $enableCommitsSetting = $site->getSolrConfiguration()->getEnableCommits();
            $siteHash = $site->getSiteHash();
            // a site can have multiple connections (cores / languages)
            $solrConnections = $this->connectionManager->getConnectionsBySite($site);
            $this->deleteRecordInAllSolrConnections($table, $uid, $solrConnections, $siteHash, $enableCommitsSetting);
        }
    }
72155
public function delete($listUuid)
    {
        $list = $this->findListByUuid($listUuid);

        foreach (array_keys($list) as $elementUuid) {
            $this->deleteElement($listUuid, $elementUuid);
        }
    }
10880
@Override
	public void removeByUuid(String uuid) {
		for (CPOption cpOption : findByUuid(uuid, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpOption);
		}
	}
143673
public function deleteElement($listUuid, $elementUuid)
    {
        $sql = 'DELETE FROM `'.self::LIST_ELEMENT_TABLE_NAME.'` WHERE `uuid` = :uuid AND `list` = :list';
        $stmt = $this->pdo->prepare($sql);
        $stmt->bindParam(':uuid', $elementUuid);
        $stmt->bindParam(':list', $listUuid);
        $stmt->execute();
    }
710329
public function delete($index)
    {
        $this
            ->db
            ->delete('ucms_search_index')
            ->condition('index_key', $index)
            ->execute()
        ;

        $this->indexer();
        $this->nodeIndexerChain->removeIndexer($index);

        $this->clearDefinitionCache();

        $this->moduleHandler->invokeAll(self::HOOK_DEF_DELETE, [$index]);

        $this->deleteInClient($index);
    }
1168176
public function deleteToken(TokenUUID $tokenUUID)
    {
        $response = $this
            ->httpClient
            ->get(
                sprintf(
                    '/%s/tokens/%s',
                    $this->getAppUUID()->composeUUID(),
                    $tokenUUID->composeUUID()
                ),
                'delete',
                [],
                [],
                Http::getApisearchHeaders($this)
            );

        self::throwTransportableExceptionIfNeeded($response);
    }
545042
public function deleteUrls(
        $uuid,
        $token = null
    ) {
        $headers = [];

        if (!empty($token)) {
            $headers['Authorization'] = $token;
        }

        $response = $this->client->delete($uuid, [
            'headers' => $headers,
        ]);

        $this->log->debug("Gemini DELETE response", [
            'uuid' => $uuid,
            'response' => $response,
        ]);

        return true;
    }
686044
public function cancel($requestUuid)
    {
        if (empty($requestUuid)) {
            throw new PlivoValidationException(
                "Which call request to cancel? No requestUuid given");
        }
        $this->client->delete(
            "Account/".
            $this->pathParams['authId'].
            "/Request/".
            $requestUuid.
            '/',
            []
        );
    }
1041315
public function deleteIndex()
    {
        foreach ($this->locales as $locale) {
            $this->searchProvider->deleteIndex($this->indexName . '_' . $locale);
        }
    }
933888
def delete(index_name, force, verbose):
    """"""
    result = current_search_client.indices.delete(
        index=index_name,
        ignore=[400, 404] if force else None,
    )
    if verbose:
        click.echo(json.dumps(result))