@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.isNull(columnName, literalType); }
/** * Builds the expression and leaf list from the original predicate. * @param expression the expression to translate. */ ConvertAstToSearchArg(Configuration conf, ExprNodeGenericFuncDesc expression) { this.conf = conf; builder = SearchArgumentFactory.newBuilder(conf); parse(expression); }
/** * Build the search argument from the expression. * @return the search argument */ public SearchArgument buildSearchArgument() { return builder.build(); }
@Test(expected = IllegalArgumentException.class) public void testBadLiteral() throws Exception { SearchArgumentFactory.newBuilder() .startAnd() .lessThan("x", PredicateLeaf.Type.LONG, "hi") .end() .build(); }
@Test(expected = IllegalArgumentException.class) public void testBadLiteralList() throws Exception { SearchArgumentFactory.newBuilder() .startAnd() .in("x", PredicateLeaf.Type.STRING, "hi", 23) .end() .build(); } }
@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 protected SearchArgument.Builder add(SearchArgument.Builder builder) { Object[] castedLiterals = new Object[literals.length]; for (int i = 0; i < literals.length; i++) { castedLiterals[i] = castLiteral(literals[i]); } return builder.in(columnName, literalType, (Object[]) castedLiterals); }
@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.lessThan(columnName, literalType, castLiteral(literal)); }
@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.lessThanEquals(columnName, literalType, castLiteral(literal)); }
@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.equals(columnName, literalType, castLiteral(literal)); }
private static Object getLiteral(Configuration conf, ExprNodeDesc child, BoxType boxType) { if (child instanceof ExprNodeConstantDesc) { return boxLiteral((ExprNodeConstantDesc) child, boxType); } else if (child instanceof ExprNodeDynamicValueDesc) { LiteralDelegate value = ((ExprNodeDynamicValueDesc) child).getDynamicValue(); value.setConf(conf); return value; } return null; }
@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.between(columnName, literalType, castLiteral(lowerBound), castLiteral(upperBound)); }
/** * Create a leaf expression when we aren't sure where the variable is * located. * @param operator the operator type that was found * @param expression the expression to check */ private void createLeaf(PredicateLeaf.Operator operator, ExprNodeGenericFuncDesc expression) { createLeaf(operator, expression, findVariable(expression)); }
@Override protected SearchArgument.Builder add(SearchArgument.Builder builder) { return builder.nullSafeEquals(columnName, literalType, castLiteral(literal)); }
@Override public SearchArgument createSarg(byte[] expr) { return ConvertAstToSearchArg.create(expr); } }
/** * Create a predicate leaf. This is used by another test. */ public static PredicateLeaf createPredicateLeaf(PredicateLeaf.Operator operator, PredicateLeaf.Type type, String columnName, Object literal, List<Object> literalList) { return new SearchArgumentImpl.PredicateLeafImpl(operator, type, columnName, literal, literalList, null); }
@Override public Object getLiteral() { if (literal instanceof LiteralDelegate) { return ((LiteralDelegate) literal).getLiteral(); } return literal; }
public static void setPredicateLeafColumn(PredicateLeaf leaf, String newName) { SearchArgumentImpl.PredicateLeafImpl.setColumnName(leaf, newName); } }
/** * Builds the expression and leaf list from the original predicate. * @param expression the expression to translate. */ ConvertAstToSearchArg(Configuration conf, ExprNodeGenericFuncDesc expression) { this.conf = conf; builder = SearchArgumentFactory.newBuilder(conf); parse(expression); }