public static Slot<ColumnSet> enqueue(FormTree tree, QueryModel model, FormScanBatch batch) { FormClass formClass = tree.getRootFormClass(); Preconditions.checkNotNull(formClass); QueryEvaluator evaluator = new QueryEvaluator(FilterLevel.PERMISSIONS, tree, batch); return evaluator.evaluate(model); }
public Slot<TableFilter> filter(FormulaNode filter) { if(filter == null) { return new PendingSlot<>(TableFilter.ALL_SELECTED); } else { return new MemoizedSlot<>(evaluateExpression(filter), new Function<ColumnView, TableFilter>() { @Override public TableFilter apply(ColumnView columnView) { return new TableFilter(columnView); } }); } }
private static ColumnSet sort(ColumnSet columnSet, List<SortModel> sortModels) { Stack<SortModel> sortModelStack = constructSortModelStack(sortModels); int[] sortVector = generateIndexArray(columnSet.getNumRows()); Range range = new Range(0, columnSet.getNumRows()-1); // determine the sort vector of the current columnset, based on the defined sort models order(columnSet, sortModelStack, sortVector, range); categorize(columnSet, sortModelStack, sortVector, range); // return the new sorted column set, with rows reordered by the sort vector return sortColumnSet(columnSet, sortVector); }
private Slot<TableFilter> computePermissionFilter(ResourceId formId) { FormPermissions permissions = supervisor.getFormPermissions(formId); if(!permissions.isVisible()) { return new PendingSlot<>(TableFilter.NONE_SELECTED); } if(!permissions.hasVisibilityFilter()) { return new PendingSlot<>(TableFilter.ALL_SELECTED); } // Otherwise apply per-record permissions try { FormTreeBuilder formTreeBuilder = new FormTreeBuilder(formClassProvider); FormTree formTree = formTreeBuilder.queryTree(formId); FormulaNode formula = FormulaParser.parse(permissions.getViewFilter()); QueryEvaluator evaluator = new QueryEvaluator(FilterLevel.NONE, formTree, this); Slot<ColumnView> filterView = evaluator.evaluateExpression(formula); return new MemoizedSlot<>(filterView, new Function<ColumnView, TableFilter>() { @Override public TableFilter apply(ColumnView columnView) { return new TableFilter(columnView); } }); } catch (Exception e) { LOGGER.log(Level.SEVERE, "Failed to parse visibility filter", e); LOGGER.severe("Error parsing visibility filter '" + permissions.getViewFilter() + " in form " + formId + ": " + e.getMessage() + ". " + "For security reasons, no results will be shown"); return new PendingSlot<>(TableFilter.NONE_SELECTED); } }
public Slot<ColumnSet> evaluate(final QueryModel model) { Slot<TableFilter> filter = filter(model.getFilter()); Slot<ColumnView> view; try { view = evaluateExpression(column.getFormula()); } catch (FormulaException e) { throw new QuerySyntaxException("Syntax error in column " + column.getId() +
} else { order(columnSet, sortModelStack, sortVector, range); categorize(columnSet, sortModelStack, sortVector, range); range.resetRange().addToRange(i);
private static int commonLength(Map<String, ColumnView> dataMap) { Iterator<ColumnView> iterator = dataMap.values().iterator(); if(!iterator.hasNext()) { throw new IllegalStateException("Cannot calculate row count from empty column set."); } int length = iterator.next().numRows(); while(iterator.hasNext()) { if(length != iterator.next().numRows()) { logMismatchedRows(dataMap); throw new IllegalStateException("Query returned columns of different lengths. See logs for details."); } } return length; }
@Test public void circularReference() throws Exception { final FormClass formClass = new FormClass(ResourceId.valueOf("XYZ")); formClass.addField(ResourceId.valueOf("FA")) .setCode("A") .setLabel("Field A") .setType(new CalculatedFieldType("B")); formClass.addField(ResourceId.valueOf("FB")) .setCode("B") .setLabel("Field B") .setType(new CalculatedFieldType("A")); FormStorageProviderStub catalog = new FormStorageProviderStub(); catalog.addForm(formClass).withRowCount(10); ColumnSetBuilder builder = new ColumnSetBuilder(catalog, new NullFormScanCache(), new NullFormSupervisor()); FormScanBatch batch = builder.createNewBatch(); QueryEvaluator evaluator = new QueryEvaluator(FilterLevel.BASE, catalog.getTree(formClass.getId()), batch); Slot<ColumnView> a = evaluator.evaluateExpression(new SymbolNode("A")); Slot<ColumnView> aPlusOne = evaluator.evaluateExpression(FormulaParser.parse("A+1")); builder.execute(batch); assertThat(a.get().numRows(), equalTo(10)); assertThat(a.get().getString(0), nullValue()); assertThat(aPlusOne.get().getString(0), equalTo(Double.toString(1d))); assertThat(aPlusOne.get().getDouble(0), equalTo(1d)); }
new NullFormSupervisor()); QueryEvaluator evaluator = new QueryEvaluator(FilterLevel.PERMISSIONS, formTree, batch); Slot<ColumnSet> queryResult = evaluator.evaluate(queryModel);
private Slot<ColumnView> expandCalculatedField(NodeMatch node) { try { Slot<ColumnView> calculation = evaluateExpression(node.getCalculation()); FormulaNode relevanceFormula = tryParseRelevance(node); if(relevanceFormula == null) { return calculation; } else { return new MemoizedSlot2<>(calculation, evaluateExpression(relevanceFormula), new BiFunction<ColumnView, ColumnView, ColumnView>() { @Override public ColumnView apply(ColumnView calculation, ColumnView relevance) { return new RelevanceViewMask(calculation, relevance); } }); } } catch (FormulaException e) { LOGGER.log(Level.WARNING, "Exception in calculated field " + node.getFormClass().getId() + "." + node.getFieldComponent() + " = " + node.getCalculation() + ": " + e.getMessage(), e); return batch.addEmptyColumn(filterLevel, node.getFormClass()); } }