documentUpdateIndex = "fess.update";

        // Create mock SearchEngineClient
        searchEngineClient = new SearchEngineClient() {
            @Override
            public long deleteByQuery(String index, QueryBuilder query) {
                deleteByQueryCalled = true;
                deleteIndex = index;
                deleteQuery = query;
                return 1L;
            }
        };

                return oldDocList;
            }

            @Override
            public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {
                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {

     */
    public SuggestDeleteResponse deleteByQuery(final String queryString) {
        ensureOperations();
        return deletionOps.deleteByQuery(index, queryString);
    }

    /**
     * Deletes suggest items by a query builder.
     * @param queryBuilder The query builder.
     * @return The SuggestDeleteResponse.
     */
    public SuggestDeleteResponse deleteByQuery(final QueryBuilder queryBuilder) {

            /* No-op */ }
    }

    private static class FastMockSearchEngineClient extends SearchEngineClient {
        @Override
        public long deleteByQuery(String index, QueryBuilder queryBuilder) {
            return 0L;
        }
    }

    private static class FastMockDataConfigBhv extends DataConfigBhv {
        // Minimal implementation
    }

        suggester.indexer().index(item);
        suggester.refresh();

        SuggestDeleteResponse deleteResponse = suggester.indexer().deleteByQuery(FieldNames.TEXT + ":テスト");

        assertNotNull(deleteResponse);
        assertFalse(deleteResponse.hasError());
    }

    @Test
    public void test_deleteByQueryBuilder() throws Exception {

        assertFalse(response.hasError());
    }

    @Test
    public void test_deleteByInvalidQueryString() throws Exception {
        try {
            suggester.indexer().deleteByQuery("invalid:[query");
            // Some invalid queries may still be accepted by OpenSearch
        } catch (Exception e) {
            // Expected - invalid query syntax

        }
        bulkDelete.execute().actionGet(fessConfig.getIndexSearchTimeout());

        // Delete any remaining events beyond the search size limit (discard overflow)
        try {
            client.deleteByQuery(indexName, QueryBuilders.termQuery("hostname", hostname));
        } catch (final Exception e) {
            logger.debug("Failed to delete remaining log notifications.", e);
        }

        final String docId = form.docId;
        try {
            final QueryBuilder query = QueryBuilders.termQuery(fessConfig.getIndexFieldDocId(), docId);
            searchEngineClient.deleteByQuery(fessConfig.getIndexDocumentUpdateIndex(), query);
            saveInfo(messages -> messages.addSuccessDeleteDocFromIndex(GLOBAL));
        } catch (final Exception e) {

        runner.refresh();

        assertEquals(3, suggester.getAllWordsNum());

        SuggestWriterResult result = writer.deleteByQuery(runner.client(), suggester.settings(), suggester.getIndex(),
                QueryBuilders.matchQuery(FieldNames.TEXT, "テスト0"));

        assertNotNull(result);
        assertFalse(result.hasFailure());

     *
     * @param index        the index name
     * @param queryBuilder the query to match documents for deletion
     * @return the number of documents deleted
     */
    public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        SearchResponse response = client.prepareSearch(index)