org.elasticsearch.index.query.MatchAllQueryBuilder Java Examples

public static QueryBuilder buildSearchQuery(ConnectorSession session, TupleDomain<ElasticsearchColumnHandle> constraint, Optional<String> query)
{
    BoolQueryBuilder queryBuilder = new BoolQueryBuilder();
    if (constraint.getDomains().isPresent()) {
        for (Map.Entry<ElasticsearchColumnHandle, Domain> entry : constraint.getDomains().get().entrySet()) {
            ElasticsearchColumnHandle column = entry.getKey();
            Domain domain = entry.getValue();

            checkArgument(!domain.isNone(), "Unexpected NONE domain for %s", column.getName());
            if (!domain.isAll()) {
                queryBuilder.filter(new BoolQueryBuilder().must(buildPredicate(session, column.getName(), domain, column.getType())));
            }
        }
    }
    query.map(QueryStringQueryBuilder::new)
            .ifPresent(queryBuilder::must);

    if (queryBuilder.hasClauses()) {
        return queryBuilder;
    }
    return new MatchAllQueryBuilder();
}
 

@Test
public void shouldSaveTwice() {
  final ImmutableList.Builder<Person> builder = ImmutableList.builder();
  for(int i=0; i< ElasticSearchRepository.SCROLL_SIZE * 2;i++) {
    builder.add(PERSON);
  }
  final List<Person> persons = builder.build();

  final List<Person> saved = repository.saveAll(persons);
  assertEquals(persons.size(), saved.size());

  final List<Person> found = repository.search(new MatchAllQueryBuilder());
  assertEquals(persons.size(), found.size());

  repository.deleteAll(saved);
}
 

public void testParseAnomalyDetectorWithNullFilterQuery() throws IOException {
    String detectorString = "{\"name\":\"todagtCMkwpcaedpyYUM\",\"description\":"
        + "\"ClrcaMpuLfeDSlVduRcKlqPZyqWDBf\",\"time_field\":\"dJRwh\",\"indices\":[\"eIrgWMqAED\"],"
        + "\"feature_attributes\":[{\"feature_id\":\"lxYRN\",\"feature_name\":\"eqSeU\",\"feature_enabled\""
        + ":true,\"aggregation_query\":{\"aa\":{\"value_count\":{\"field\":\"ok\"}}}}],\"detection_interval\":"
        + "{\"period\":{\"interval\":425,\"unit\":\"Minutes\"}},\"window_delay\":{\"period\":{\"interval\":973,"
        + "\"unit\":\"Minutes\"}},\"schema_version\":-1203962153,\"ui_metadata\":{\"JbAaV\":{\"feature_id\":"
        + "\"rIFjS\",\"feature_name\":\"QXCmS\",\"feature_enabled\":false,\"aggregation_query\":{\"aa\":"
        + "{\"value_count\":{\"field\":\"ok\"}}}}},\"last_update_time\":1568396089028}";
    AnomalyDetector parsedDetector = AnomalyDetector.parse(TestHelpers.parser(detectorString));
    assertTrue(parsedDetector.getFilterQuery() instanceof MatchAllQueryBuilder);
}
 

protected void doMatchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
    regQ(builder);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

protected void doMatchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
    regQ(builder);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

protected void doMatchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
    regQ(builder);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void addQuery(final Consumer<BoolQueryBuilder> boolQuery) {
    BoolQueryBuilder builder;
    if (queryBuilder instanceof MatchAllQueryBuilder) {
        builder = QueryBuilders.boolQuery();
    } else {
        builder = QueryBuilders.boolQuery().must(queryBuilder);
    }
    boolQuery.accept(builder);
    if (builder.hasClauses()) {
        queryBuilder = builder;
    }
}
 

/**
 * Merges a top level aggregation query with an inner select
 * @param top
 * @param nested
 * @return
 * @throws SQLException 
 */
private ParseResult mergeAggWithSelect(ParseResult top, ParseResult nested) throws SQLException {
	if(nested.getRequestScore()) throw new SQLException("Unable to request a _score on an aggregation");
	int limit = top.getLimit();
	List<OrderBy> sorts = top.getSorts();
	boolean useCache = top.getUseCache() || nested.getUseCache();
	
	QueryBuilder query = top.getQuery();
	if(query instanceof MatchAllQueryBuilder) query = nested.getQuery();
	else if(!(nested.getQuery() instanceof MatchAllQueryBuilder)) query = QueryBuilders.boolQuery().must(top.getQuery()).must(nested.getQuery());

	AggregationBuilder agg = top.getAggregation();
	IComparison having = top.getHaving();
	Heading head = new Heading();
	if(nested.getHeading().hasAllCols()){
		head = top.getHeading();
	}else{
		for(Column col : top.getHeading().columns()){
			if(col.hasCalculation()){
				translateCalculation(col.getCalculation(), nested.getHeading());
				head.add(new Column(col.getColumn(), col.getOp()).setAlias(col.getAlias())
						.setCalculation(col.getCalculation()).setSqlType(Types.FLOAT));
			}else{
				Column col2 = nested.getHeading().getColumnByNameAndOp(col.getColumn(), Operation.NONE);
				if(col2 == null) col2 = nested.getHeading().getColumnByLabel(col.getAlias());
				if(col2 == null && col.getOp() == Operation.COUNT){
					head.add(col);
					continue;
				}else if(col2 == null) throw new SQLException("Unable to determine column '"+col.getLabel()+"' within nested query");
				String alias = (col.getAlias() == null ? col.getColumn() : col.getAlias());
				head.add(new Column(col2.getColumn(), col.getOp()).setAlias(alias).setVisible(col.isVisible())
						.setSqlType(col2.getSqlType()));
			}
		}
	}
	head.buildIndex();
	return new ParseResult(head, nested.getSources(), query, agg, having, sorts, limit, useCache, false);
}
 

public static QueryBuilder simpleQueryBuilder(String q, boolean or, Boosts boosts) {
    if (q.equals("yacyall")) return new MatchAllQueryBuilder();
    final MultiMatchQueryBuilder qb = QueryBuilders
            .multiMatchQuery(q)
            .operator(or ? Operator.OR : Operator.AND)
            .zeroTermsQuery(ZeroTermsQuery.ALL);
    boosts.forEach((mapping, boost) -> qb.field(mapping.getMapping().name(), boost));
    return qb;
}
 

/**
 * This method returns the base query (only single-value attributes) for a targeting channel.
 * @param targetingChannel
 * @return
 */
private BoolQueryBuilder createBaseQueryForSingleValues(TargetingChannel targetingChannel)
{
    BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();

    boolQueryBuilder.must(new MatchAllQueryBuilder());

    append(boolQueryBuilder, targetingChannel.getT(), ES_PREDICTION_DOC_PREFIX + "t");
    append(boolQueryBuilder, targetingChannel.getSi(), ES_PREDICTION_DOC_PREFIX + "si");
    append(boolQueryBuilder, targetingChannel.getM(), ES_PREDICTION_DOC_PREFIX + "m");
    append(boolQueryBuilder, targetingChannel.getA(), ES_PREDICTION_DOC_PREFIX + "a");
    append(boolQueryBuilder, targetingChannel.getG(), ES_PREDICTION_DOC_PREFIX + "g");
    return boolQueryBuilder;
}
 

public void testParseAnomalyDetectorWithEmptyFilterQuery() throws IOException {
    String detectorString = "{\"name\":\"todagtCMkwpcaedpyYUM\",\"description\":"
        + "\"ClrcaMpuLfeDSlVduRcKlqPZyqWDBf\",\"time_field\":\"dJRwh\",\"indices\":[\"eIrgWMqAED\"],"
        + "\"feature_attributes\":[{\"feature_id\":\"lxYRN\",\"feature_name\":\"eqSeU\",\"feature_enabled\":"
        + "true,\"aggregation_query\":{\"aa\":{\"value_count\":{\"field\":\"ok\"}}}}],\"filter_query\":{},"
        + "\"detection_interval\":{\"period\":{\"interval\":425,\"unit\":\"Minutes\"}},\"window_delay\":"
        + "{\"period\":{\"interval\":973,\"unit\":\"Minutes\"}},\"schema_version\":-1203962153,\"ui_metadata\":"
        + "{\"JbAaV\":{\"feature_id\":\"rIFjS\",\"feature_name\":\"QXCmS\",\"feature_enabled\":false,"
        + "\"aggregation_query\":{\"aa\":{\"value_count\":{\"field\":\"ok\"}}}}},"
        + "\"last_update_time\":1568396089028}";
    AnomalyDetector parsedDetector = AnomalyDetector.parse(TestHelpers.parser(detectorString));
    assertTrue(parsedDetector.getFilterQuery() instanceof MatchAllQueryBuilder);
}
 

@Override
public QueryBuilder getDSL() {
    MatchAllQueryBuilder builders = matchAllQuery();
    return builders;
}
 

public SimpleSearchQueryBuilder matchAll(){
	MatchAllQueryBuilder q = matchAllQuery();
	queryBuilder = q;
	return this;
}
 

public MatchAllQueryBuilder matchAllBuilder(){
	MatchAllQueryBuilder q = matchAllQuery();
	queryBuilder = q;
	return q;
}
 

@Test
public void shouldWithQuery() {
  final QueryBuilder query = new MatchAllQueryBuilder();
  scroll.withQuery(query);
  verify(search).setQuery(query);
}
 

public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    assertObjectNotNull("opLambda", opLambda);
    doMatchAll(opLambda);
}
 

public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    assertObjectNotNull("opLambda", opLambda);
    doMatchAll(opLambda);
}
 

public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
    assertObjectNotNull("opLambda", opLambda);
    doMatchAll(opLambda);
}