ExpressionTree(ExpressionTree other) { this.operator = other.operator; if (other.children == null) { this.children = null; } else { this.children = new ArrayList<ExpressionTree>(); for(ExpressionTree child: other.children) { children.add(new ExpressionTree(child)); } } this.leaf = other.leaf; this.constant = other.constant; }
@Override public Builder literal(TruthValue truth) { ExpressionTree parent = currentTree.getFirst(); parent.getChildren().add(new ExpressionTree(truth)); return this; }
@Override public Builder startAnd() { ExpressionTree node = new ExpressionTree(ExpressionTree.Operator.AND); currentTree.getFirst().getChildren().add(node); currentTree.addFirst(node); return this; }
@Override public Builder startOr() { ExpressionTree node = new ExpressionTree(ExpressionTree.Operator.OR); currentTree.getFirst().getChildren().add(node); currentTree.addFirst(node); return this; }
@Override public Builder startNot() { ExpressionTree node = new ExpressionTree(ExpressionTree.Operator.NOT); currentTree.getFirst().getChildren().add(node); currentTree.addFirst(node); return this; }
private ExpressionTree constant(TruthValue val) { return new ExpressionTree(val); }
private ExpressionTree not(ExpressionTree arg) { return new ExpressionTree(ExpressionTree.Operator.NOT, arg); }
private ExpressionTree or(ExpressionTree... arg) { return new ExpressionTree(ExpressionTree.Operator.OR, arg); }
private ExpressionTree and(ExpressionTree... arg) { return new ExpressionTree(ExpressionTree.Operator.AND, arg); }
private ExpressionTree leaf(int leaf) { return new ExpressionTree(leaf); }
@Override public Builder isNull(String column, PredicateLeaf.Type type) { ExpressionTree parent = currentTree.getFirst(); if (column == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.IS_NULL, type, column, null, null, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder nullSafeEquals(String column, PredicateLeaf.Type type, Object literal) { ExpressionTree parent = currentTree.getFirst(); if (column == null || literal == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.NULL_SAFE_EQUALS, type, column, literal, null, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder lessThan(String column, PredicateLeaf.Type type, Object literal) { ExpressionTree parent = currentTree.getFirst(); if (column == null || literal == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.LESS_THAN, type, column, literal, null, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder lessThanEquals(String column, PredicateLeaf.Type type, Object literal) { ExpressionTree parent = currentTree.getFirst(); if (column == null || literal == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.LESS_THAN_EQUALS, type, column, literal, null, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder equals(String column, PredicateLeaf.Type type, Object literal) { ExpressionTree parent = currentTree.getFirst(); if (column == null || literal == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.EQUALS, type, column, literal, null, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder between(String column, PredicateLeaf.Type type, Object lower, Object upper) { ExpressionTree parent = currentTree.getFirst(); if (column == null || lower == null || upper == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { List<Object> argList = new ArrayList<Object>(); argList.add(lower); argList.add(upper); PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.BETWEEN, type, column, null, argList, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
@Override public Builder in(String column, PredicateLeaf.Type type, Object... literal) { ExpressionTree parent = currentTree.getFirst(); if (column == null || literal == null) { parent.getChildren().add(new ExpressionTree(TruthValue.YES_NO_NULL)); } else { if (literal.length == 0) { throw new IllegalArgumentException("Can't create in expression with " + "no arguments"); } List<Object> argList = new ArrayList<Object>(); argList.addAll(Arrays.asList(literal)); PredicateLeaf leaf = new PredicateLeafImpl(PredicateLeaf.Operator.IN, type, column, null, argList, conf); parent.getChildren().add(new ExpressionTree(addLeaf(leaf))); } return this; }
if (result.isEmpty()) { for(ExpressionTree kid: kids) { ExpressionTree or = new ExpressionTree(ExpressionTree.Operator.OR); result.add(or); for(ExpressionTree node: nonAndList) { or.getChildren().add(new ExpressionTree(node)); for(ExpressionTree kid: kids) { for(ExpressionTree or: work) { ExpressionTree copy = new ExpressionTree(or); copy.getChildren().add(kid); result.add(copy);
return pushDownNot(child.getChildren().get(0)); case CONSTANT: return new ExpressionTree(child.getConstant().not()); case AND: root = new ExpressionTree(ExpressionTree.Operator.OR); for(ExpressionTree kid: child.getChildren()) { root.getChildren().add(pushDownNot(new ExpressionTree(ExpressionTree.Operator.NOT, kid))); root = new ExpressionTree(ExpressionTree.Operator.AND); for(ExpressionTree kid: child.getChildren()) { root.getChildren().add(pushDownNot(new ExpressionTree (ExpressionTree.Operator.NOT, kid)));
return new ExpressionTree(TruthValue.YES_NO_NULL);