assertTrue(fesenClient.prepareSearch("fess_crawler.queue").setQuery(QueryBuilders.termQuery("sessionId", "sessionId")).setSize(0)
                .execute().actionGet().getHits().getTotalHits().value > 0);

        urlQueueService.delete("sessionId");
        assertFalse(fesenClient.prepareSearch("fess_crawler.queue").setQuery(QueryBuilders.termQuery("sessionId", "sessionId")).setSize(0)

		},
		{
			"?x=y&a=b",
			"?x=y&a=b",
		},
	}
	for i, test := range testCases {
		gotQuery := redactLDAPPwd(test.query)
		if gotQuery != test.expectedQuery {
			t.Fatalf("test %d: expected %s got %s", i+1, test.expectedQuery, gotQuery)
		}
	}

                RoleCQ cf = new RoleCQ();
                cqLambda.callback(cf);
                list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
            });
        }
        final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

        return this;
    }

    public SuggestRequestBuilder setSize(final int size) {
        request.setSize(size);
        return this;
    }

    public SuggestRequestBuilder setQuery(final String query) {
        request.setQuery(query);
        return this;
    }

    public SuggestRequestBuilder addTag(final String tag) {
        request.addTag(tag);
        return this;
    }

Suggester suggester = Suggester.builder().build(client, suggestId);

```

### Suggest

```java
SuggestResponse response = suggester.suggest().setQuery("kensaku").execute().getResponse();
```

### Suggest async

```
suggester.suggest().setQuery("kensaku").execute()
  .done(
    response -> {}
  ).error(
    t -> {}
  );
```

### Add suggest document

```java

            if (logger.isDebugEnabled()) {
                logger.debug("{}:{}", query, boost);
            }
            return getQueryProcessor().execute(context, boostQuery.getQuery(), boostQuery.getBoost());
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);

        insertAll(accessResultList, OpType.INDEX);
    }

    @Override
    public int getCount(final String sessionId) {
        return getCount(builder -> builder.setQuery(QueryBuilders.termQuery(SESSION_ID, sessionId)));
    }

    @Override
    public void delete(final String sessionId) {
        deleteBySessionId(sessionId);
    }

    @Override

            boolQueryBuilder.must(queryBuilder);
            filterList.forEach(boolQueryBuilder::filter);
            builder.setQuery(boolQueryBuilder);
        } else {
            builder.setQuery(queryBuilder);
        }

        builder.execute(new ActionListener<SearchResponse>() {
            @Override

        if (logger.isInfoEnabled()) {
            logger.info("Set document limit: {}", limitOfDocumentSize);
        }
        this.limitOfDocumentSize = limitOfDocumentSize;
    }

    public void setQuery(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
    }

    public void addSort(final SortBuilder<?> sortBuilder) {
        sortList.add(sortBuilder);
    }

        final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        for (final BooleanClause clause : booleanQuery.clauses()) {
            final QueryBuilder queryBuilder = getQueryProcessor().execute(context, clause.getQuery(), boost);
            if (queryBuilder != null) {
                switch (clause.getOccur()) {
                case MUST:
                    boolQuery.must(queryBuilder);
                    break;