cz.jirutka.rsql.parser.ast.OrNode Java Examples

@Test
void testVisitOrNode() {
  String argument0 = "piet";
  ComparisonOperator operator0 = new ComparisonOperator("=q=");
  ComparisonNode node0 = new ComparisonNode(operator0, "*", singletonList(argument0));

  String argument1 = "jan";
  ComparisonOperator operator1 = new ComparisonOperator("=q=");
  ComparisonNode node1 = new ComparisonNode(operator1, "*", singletonList(argument1));

  OrNode orNode = new OrNode(asList(node0, node1));
  Query query =
      Query.builder()
          .setOperator(OR)
          .setValue(
              asList(
                  Query.builder().setOperator(MATCHES).setValue(argument0).build(),
                  Query.builder().setOperator(MATCHES).setValue(argument1).build()))
          .build();
  assertEquals(query, queryRsqlVisitor.visit(orNode));
}
 

@Override
public Query<Entity> visit(OrNode node) {
  initQuery();
  boolean nested = node.getChildren().size() > 1;
  if (nested) {
    q.nest();
  }

  for (Iterator<Node> it = node.iterator(); it.hasNext(); ) {
    Node child = it.next();
    child.accept(this);

    if (it.hasNext()) {
      q.or();
    }
  }
  if (nested) {
    q.unnest();
  }

  return q;
}
 

@Override
public SearchQuery visit(final OrNode node) {
  final List<SearchQuery> queries = new ArrayList<>();
  for (final Node child: node.getChildren()) {
    queries.add(child.accept(this));
  }
  return SearchQueryUtils.or(queries);
}
 

@Override
public List<Predicate> visit(final OrNode node, final String param) {
    beginLevel(true);
    final List<Predicate> childs = acceptChilds(node);
    endLevel();
    if (!childs.isEmpty()) {
        return toSingleList(cb.or(childs.toArray(new Predicate[childs.size()])));
    }
    return toSingleList(cb.conjunction());
}
 

@Override
public PermissionsQuery visit(OrNode orNode) {
  List<Node> nodes = orNode.getChildren();
  PermissionsQuery permissionsQuery = new PermissionsQuery();
  if (nodes.size() == 2) {
    for (Node node : nodes) {
      if (node instanceof ComparisonNode) {
        setQuery((ComparisonNode) node, permissionsQuery);
      } else {
        throw new UnsupportedOperationException("invalide node");
      }
    }
  }
  return permissionsQuery;
}
 

@Test
void testVisitOr() {
  ComparisonNode comparisonNodeUser =
      new ComparisonNode(
          new ComparisonOperator("=="), "user", Collections.singletonList("user1"));
  ComparisonNode comparisonNodeRole =
      new ComparisonNode(
          new ComparisonOperator("=in=", true), "role", Arrays.asList("role1", "role2"));
  OrNode orNode = new OrNode(Arrays.asList(comparisonNodeUser, comparisonNodeRole));
  assertEquals(
      new PermissionsQuery(asList("user1"), asList("role1", "role2")), visitor.visit(orNode));
}
 

@Override
public Void visit(OrNode node, MultiValueMap<String, String> map) {
	log.debug("visit(node:{},map:{})", node, map);
	node.getChildren().forEach(n -> n.accept(this, map));
	return null;
}
 

@Override
public Void visit(OrNode node, Map<String, MultiValueMap<String, String>> map) {
	log.debug("visit(node:{},map:{})", node, map);
	node.getChildren().forEach(n -> n.accept(this, map));
	return null;
}
 

@Override
public BooleanExpression visit(OrNode node, Path entityClass) {
	log.debug("visit(node:{},param:{})", node, entityClass);

	return node.getChildren().stream().map(n -> n.accept(this, entityClass)).collect(Collectors.reducing(BooleanExpression::or)).get();
}
 

@Override
public Predicate visit(OrNode node, Root root) {
	log.debug("visit(node:{},root:{})", node, root);

	return node.getChildren().stream().map(n -> n.accept(this, root)).collect(Collectors.reducing(builder::or)).get();
}
 

@Override
public T visit(OrNode node) {
    return visit((LogicalNode) node);
}
 

@Override
public T visit(OrNode node) {
    return visit((LogicalNode) node);
}
 

@Override
public Query visit(OrNode node) {
  return visit(node, OR);
}
 

@Override
public AggregateQuery visit(OrNode node) {
  throw new MolgenisQueryException(
      "RSQL query operator OR (';' or 'or') not allowed in aggregates query");
}
 

@Override
public Specification<T> visit(final OrNode node, final Void param) {
    return builder.createSpecification(node);
}