public DimensionMapping(FormulaNode formula) { this.formId = null; this.formula = formula.asExpression(); this.type = Type.VALUE; }
@Override public FieldValue evaluate(EvalContext context) { return expr.evaluate(context); }
public FormulaError(FormulaNode node, String message) { this(node.getSourceRange(), message); }
private String parentFormula(ParsedFormula formula) { if(!formula.isValid()) { return formula.getFormula(); } SymbolNode parentSymbol = new SymbolNode(ColumnModel.PARENT_SYMBOL); FormulaNode transformed = formula.getRootNode().transform(node -> { if(node instanceof SymbolNode) { // A -> parent.A return new CompoundExpr(parentSymbol, (SymbolNode) node); } else { return node; } }); return transformed.asExpression(); } }
@Override public FormulaNode transform(Function<FormulaNode, FormulaNode> function) { List<FormulaNode> transformedArgs = new ArrayList<>(); for (FormulaNode argument : arguments) { transformedArgs.add(argument.transform(function)); } return function.apply(new FunctionCallNode(this.function, transformedArgs)); }
public Slot<ColumnView> evaluateExpression(FormulaNode expr) { return expr.accept(columnVisitor); }
private void buildRelevanceCalculator(FormTree.Node node) { String formula = node.getField().getRelevanceConditionExpression(); FormulaNode rootNode; try { rootNode = FormulaParser.parse(formula); } catch (Exception e) { LOGGER.log(Level.WARNING, "Invalid relevance formula: " + formula, e); return; } relevanceCalculators.put(node.getFieldId(), instance -> { evalContext.setInstance(instance); try { return rootNode.evaluateAsBoolean(evalContext); } catch (Exception e) { LOGGER.log(Level.SEVERE, "Failed to evaluate relevance condition", e); return true; } }); }
@Override public FormulaNode transform(Function<FormulaNode, FormulaNode> function) { return function.apply(new CompoundExpr( value.transform(function), field)); }
@Override public Slot<ColumnView> visitGroup(GroupNode group) { return group.getExpr().accept(this); }
boolean relevant; if (instance.isPresent()) { relevant = expr.evaluateAsBoolean(new FormEvalContext(formClass, instance.get())); relevant = expr.evaluateAsBoolean(new FormEvalContext(formClass, new TypedFormRecord(ResourceId.generateSubmissionId(formClass), formClass.getId())));
public String asExpression() { return "(" + expr.asExpression() + ")"; }
@Override public FieldValue evaluate(EvalContext context) { List<FieldValue> evaluatedArguments = Lists.newArrayList(); for (FormulaNode expr : arguments) { evaluatedArguments.add(expr.evaluate(context)); } return function.apply(evaluatedArguments); }
private FunctionCallNode binaryInfixCall(FormulaFunction op, FormulaNode left, FormulaNode right) { SourceRange source = new SourceRange(left.getSourceRange(), right.getSourceRange()); return new FunctionCallNode(op, Arrays.asList(left, right), source); }
@Override public FormulaNode transform(Function<FormulaNode, FormulaNode> function) { return function.apply(new GroupNode(expr.transform(function))); }
private Slot<ColumnView> evaluateExpression(String expression) { FormulaNode parsed = FormulaParser.parse(expression); return parsed.accept(columnVisitor); }
@JsonProperty("formula") public String getFormulaAsString() { if(formula == null) { return null; } else { return formula.asExpression(); } }
@Override public FieldValue evaluate(EvalContext context) { FieldValue baseValue = value.evaluate(context); if(baseValue instanceof EnumValue) { EnumValue enumValue = (EnumValue) baseValue; return evaluateEnumValue(enumValue); } return BooleanFieldValue.FALSE; }
private FieldType validateFunctionCall(FunctionCallNode call) { // If function calls are involved, this is no longer // a simple field reference this.simpleReference = false; List<FormulaNode> arguments = call.getArguments(); List<FieldType> argumentTypes = new ArrayList<>(); boolean validationFailed = false; for (FormulaNode formulaNode : arguments) { try { argumentTypes.add(validateExpr(formulaNode)); } catch (ValidationFailed e) { // Continue validating the other arguments. validationFailed = true; } } if(validationFailed) { throw new ValidationFailed(); } try { return call.getFunction().resolveResultType(argumentTypes); } catch (ArgumentException e) { errors.add(new FormulaError(arguments.get(e.getArgumentIndex()).getSourceRange(), e.getMessage())); throw new ValidationFailed(); } catch(FormulaException e) { errors.add(new FormulaError(call, e.getMessage())); throw new ValidationFailed(); } }
/** * Returns a filter for records referenced by the given field. */ public Optional<FormulaNode> getReferenceBaseFilter(ResourceId fieldId) { FormulaNode filter = fieldFilters.get(fieldId); if(filter == null) { return Optional.absent(); } SymbolNode fieldExpr = new SymbolNode(fieldId); return Optional.of(filter.transform(x -> { if(x.equals(fieldExpr)) { return new SymbolNode(ColumnModel.RECORD_ID_SYMBOL); } else { return x; } })); } }
@Override public ColumnPlanNode visitFunctionCall(FunctionCallNode callNode) { if(!(callNode.getFunction() instanceof ColumnFunction)) { throw new UnsupportedOperationException("TODO: " + callNode.getFunction().getId()); } List<ColumnPlanNode> arguments = new ArrayList<>(); for (FormulaNode formulaNode : callNode.getArguments()) { arguments.add(formulaNode.accept(this)); } return new VectorOp((ColumnFunction) callNode.getFunction(), arguments); }