Пример #1
0
 @Override
 protected Query applyArrayReference(
     Reference arrayReference, Literal literal, Context context) throws IOException {
   QueryBuilderHelper builder =
       QueryBuilderHelper.forType(((CollectionType) arrayReference.valueType()).innerType());
   return builder.eq(arrayReference.ident().columnIdent().fqn(), literal.value());
 }
Пример #2
0
 @Override
 protected Query applyArrayReference(
     Reference arrayReference, Literal literal, Context context) throws IOException {
   // 1 < ANY (array_col) --> array_col > 1
   return rangeQuery.toQuery(
       arrayReference,
       ((CollectionType) arrayReference.valueType()).innerType(),
       literal.value());
 }
Пример #3
0
 @Override
 protected Query applyArrayReference(
     Reference arrayReference, Literal literal, Context context) throws IOException {
   String notLike =
       negateWildcard(convertWildcardToRegex(BytesRefs.toString(literal.value())));
   return new RegexpQuery(
       new Term(arrayReference.info().ident().columnIdent().fqn(), notLike),
       RegexpFlag.COMPLEMENT.value());
 }
Пример #4
0
 @Override
 protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
     throws IOException {
   // col like ANY (['a', 'b']) --> or(like(col, 'a'), like(col, 'b'))
   BooleanQuery booleanQuery = new BooleanQuery();
   booleanQuery.setMinimumNumberShouldMatch(1);
   for (Object value : toIterable(arrayLiteral.value())) {
     booleanQuery.add(
         likeQuery.toQuery(reference, value, context), BooleanClause.Occur.SHOULD);
   }
   return booleanQuery;
 }
Пример #5
0
 @Override
 protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
     throws IOException {
   // col < ANY ([1,2,3]) --> or(col<1, col<2, col<3)
   BooleanQuery booleanQuery = new BooleanQuery();
   booleanQuery.setMinimumNumberShouldMatch(1);
   for (Object value : toIterable(arrayLiteral.value())) {
     booleanQuery.add(
         inverseRangeQuery.toQuery(reference, reference.valueType(), value),
         BooleanClause.Occur.SHOULD);
   }
   return booleanQuery;
 }
Пример #6
0
  @Test
  public void testUpdateWithEmptyObjectArray() throws Exception {
    UpdateAnalyzedStatement.NestedAnalyzedStatement analysis =
        analyze("update users set friends=? where other_id=0", new Object[] {new Map[0], 0})
            .nestedStatements()
            .get(0);

    Literal friendsLiteral =
        (Literal)
            analysis
                .assignments()
                .get(new Reference(USER_TABLE_INFO.getReferenceInfo(new ColumnIdent("friends"))));
    assertThat(friendsLiteral.valueType().id(), is(ArrayType.ID));
    assertEquals(DataTypes.OBJECT, ((ArrayType) friendsLiteral.valueType()).innerType());
    assertThat(((Object[]) friendsLiteral.value()).length, is(0));
  }
Пример #7
0
      @Override
      public Query apply(Function input, Context context) throws IOException {
        Tuple<Reference, Literal> tuple = prepare(input);
        if (tuple == null) {
          return null;
        }
        String field = tuple.v1().info().ident().columnIdent().fqn();
        Literal literal = tuple.v2();
        CollectionType dataType = ((CollectionType) literal.valueType());

        Set values = (Set) literal.value();
        DataType innerType = dataType.innerType();
        BytesRef[] terms = getBytesRefs(values, TermBuilder.forType(innerType));
        TermsFilter termsFilter = new TermsFilter(field, terms);
        return new FilteredQuery(Queries.newMatchAllQuery(), termsFilter);
      }
Пример #8
0
      @Override
      protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
          throws IOException {
        //  col != ANY ([1,2,3]) --> not(col=1 and col=2 and col=3)
        String columnName = reference.info().ident().columnIdent().fqn();
        QueryBuilderHelper builder = QueryBuilderHelper.forType(reference.valueType());
        BooleanFilter filter = new BooleanFilter();

        BooleanFilter notFilter = new BooleanFilter();
        for (Object value : toIterable(arrayLiteral.value())) {
          notFilter.add(builder.eqFilter(columnName, value), BooleanClause.Occur.MUST);
        }
        filter.add(notFilter, BooleanClause.Occur.MUST_NOT);

        return new FilteredQuery(Queries.newMatchAllQuery(), filter);
      }
Пример #9
0
      @Override
      protected Query applyArrayReference(
          Reference arrayReference, Literal literal, Context context) throws IOException {
        // 1 != any ( col ) -->  gt 1 or lt 1
        String columnName = arrayReference.info().ident().columnIdent().fqn();
        Object value = literal.value();

        QueryBuilderHelper builder = QueryBuilderHelper.forType(arrayReference.valueType());
        BooleanQuery query = new BooleanQuery();
        query.setMinimumNumberShouldMatch(1);
        query.add(
            builder.rangeQuery(columnName, value, null, false, false), BooleanClause.Occur.SHOULD);
        query.add(
            builder.rangeQuery(columnName, null, value, false, false), BooleanClause.Occur.SHOULD);
        return query;
      }
Пример #10
0
 private TermsFilter termsFilter(String columnName, Literal arrayLiteral) {
   TermsFilter termsFilter;
   Object values = arrayLiteral.value();
   if (values instanceof Collection) {
     termsFilter =
         new TermsFilter(
             columnName,
             getBytesRefs((Collection) values, TermBuilder.forType(arrayLiteral.valueType())));
   } else {
     termsFilter =
         new TermsFilter(
             columnName,
             getBytesRefs((Object[]) values, TermBuilder.forType(arrayLiteral.valueType())));
   }
   return termsFilter;
 }
Пример #11
0
      @Override
      protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
          throws IOException {
        // col not like ANY (['a', 'b']) --> not(and(like(col, 'a'), like(col, 'b')))
        BooleanQuery query = new BooleanQuery();
        BooleanQuery notQuery = new BooleanQuery();

        String columnName = reference.ident().columnIdent().fqn();
        QueryBuilderHelper builder = QueryBuilderHelper.forType(reference.valueType());
        for (Object value : toIterable(arrayLiteral.value())) {
          notQuery.add(
              builder.like(columnName, value, context.indexCache.filter()),
              BooleanClause.Occur.MUST);
        }
        query.add(notQuery, BooleanClause.Occur.MUST_NOT);
        return query;
      }
Пример #12
0
      @Override
      public Query apply(Function input, Context context) {
        Tuple<Reference, Literal> tuple = super.prepare(input);
        if (tuple == null) {
          return null;
        }
        Reference reference = tuple.v1();
        Literal literal = tuple.v2();
        String columnName = reference.info().ident().columnIdent().fqn();
        if (DataTypes.isCollectionType(reference.valueType())
            && DataTypes.isCollectionType(literal.valueType())) {

          // create boolean filter with term filters to pre-filter the result before applying the
          // functionQuery.
          BooleanFilter boolTermsFilter = new BooleanFilter();
          DataType type = literal.valueType();
          while (DataTypes.isCollectionType(type)) {
            type = ((CollectionType) type).innerType();
          }
          QueryBuilderHelper builder = QueryBuilderHelper.forType(type);
          Object value = literal.value();
          buildTermsQuery(boolTermsFilter, value, columnName, builder);

          if (boolTermsFilter.clauses().isEmpty()) {
            // all values are null...
            return genericFunctionQuery(input, context);
          }

          // wrap boolTermsFilter and genericFunction filter in an additional BooleanFilter to
          // control the ordering of the filters
          // termsFilter is applied first
          // afterwards the more expensive genericFunctionFilter
          BooleanFilter filterClauses = new BooleanFilter();
          filterClauses.add(boolTermsFilter, BooleanClause.Occur.MUST);
          filterClauses.add(genericFunctionFilter(input, context), BooleanClause.Occur.MUST);
          return new FilteredQuery(Queries.newMatchAllQuery(), filterClauses);
        }
        QueryBuilderHelper builder = QueryBuilderHelper.forType(tuple.v1().valueType());
        return builder.eq(columnName, tuple.v2().value());
      }
Пример #13
0
 @Override
 public String visitLiteral(Literal symbol, Void context) {
   return formatValue(symbol.value());
 }
Пример #14
0
 @Override
 protected Query applyArrayReference(
     Reference arrayReference, Literal literal, Context context) throws IOException {
   return likeQuery.toQuery(arrayReference, literal.value(), context);
 }