@Test public void shouldReturnCursorThatAccessesTuples() { results = new QueryResults(columns, statistics, tuples, context.getProblems(), null); Cursor cursor = results.getCursor(); Iterator<Object[]> expectedIter = tuples.iterator(); int rowNumber = 0; while (cursor.hasNext() && expectedIter.hasNext()) { cursor.next(); Object[] tuple = expectedIter.next(); // Check the column values by column name and index ... for (Column column : results.getColumns().getColumns()) { String columnName = column.getColumnName(); int columnIndex = columns.getColumnIndexForName(columnName); assertThat(cursor.getValue(columnName), is(tuple[columnIndex])); assertThat(cursor.getValue(columnIndex), is(tuple[columnIndex])); // Get the location for this column ... int locationIndex = columns.getLocationIndex(column.selectorName().name()); Location location = (Location) tuple[locationIndex]; assertThat(cursor.getLocation(columnIndex), is(location)); } // Check the locations by selector name and index ... for (String selectorName : results.getColumns().getSelectorNames()) { int locationIndex = columns.getLocationIndex(selectorName); Location location = (Location) tuple[locationIndex]; assertThat(cursor.getLocation(selectorName), is(location)); assertThat(location.getPath(), is(notNullValue())); } // Check the row index ... assertThat(cursor.getRowIndex(), is(rowNumber++)); } assertThat(cursor.hasNext(), is(false)); assertThat(expectedIter.hasNext(), is(false)); }
/** * Create the constraint evaluator that is used by the {@link SelectComponent} to evaluate the * supplied {@link Constraint criteria}. * * @param types the type system; may not be null * @param schemata the schemata; may not be null * @param columns the definition of the result columns and the tuples; may not be null * @param constraint the criteria that this {@link SelectComponent} is to evaluate * @param variables the variables that are to be substituted for the various {@link * BindVariableName} {@link StaticOperand operands}; may not be null * @return the constraint evaluator; never null */ protected ConstraintChecker createChecker( final TypeSystem types, Schemata schemata, Columns columns, Constraint constraint, Map<String, Object> variables) { if (constraint instanceof Or) { Or orConstraint = (Or) constraint; final ConstraintChecker left = createChecker(types, schemata, columns, orConstraint.left(), variables); final ConstraintChecker right = createChecker(types, schemata, columns, orConstraint.right(), variables); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return left.satisfiesConstraints(tuple) || right.satisfiesConstraints(tuple); } }; } if (constraint instanceof Not) { Not notConstraint = (Not) constraint; final ConstraintChecker original = createChecker(types, schemata, columns, notConstraint.getConstraint(), variables); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return !original.satisfiesConstraints(tuple); } }; } if (constraint instanceof And) { And andConstraint = (And) constraint; final ConstraintChecker left = createChecker(types, schemata, columns, andConstraint.left(), variables); final ConstraintChecker right = createChecker(types, schemata, columns, andConstraint.right(), variables); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return left.satisfiesConstraints(tuple) && right.satisfiesConstraints(tuple); } }; } if (constraint instanceof ChildNode) { ChildNode childConstraint = (ChildNode) constraint; final int locationIndex = columns.getLocationIndex(childConstraint.selectorName().name()); final Path parentPath = (Path) types.getPathFactory().create(childConstraint.getParentPath()); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { Location location = (Location) tuple[locationIndex]; return location.getPath().getParent().equals(parentPath); } }; } if (constraint instanceof DescendantNode) { DescendantNode descendantNode = (DescendantNode) constraint; final int locationIndex = columns.getLocationIndex(descendantNode.selectorName().name()); final Path ancestorPath = (Path) types.getPathFactory().create(descendantNode.getAncestorPath()); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { Location location = (Location) tuple[locationIndex]; return location.getPath().isDescendantOf(ancestorPath); } }; } if (constraint instanceof SameNode) { SameNode sameNode = (SameNode) constraint; final int locationIndex = columns.getLocationIndex(sameNode.selectorName().name()); final String path = sameNode.getPath(); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { Location location = (Location) tuple[locationIndex]; return location.toString().equals(path); } }; } if (constraint instanceof PropertyExistence) { PropertyExistence propertyExistance = (PropertyExistence) constraint; String selectorName = propertyExistance.selectorName().name(); final String propertyName = propertyExistance.getPropertyName(); final int columnIndex = columns.getColumnIndexForProperty(selectorName, propertyName); return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return tuple[columnIndex] != null; } }; } if (constraint instanceof FullTextSearch) { return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return true; } }; } if (constraint instanceof Relike) { return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return true; } }; } if (constraint instanceof Comparison) { Comparison comparison = (Comparison) constraint; // Create the correct dynamic operation ... DynamicOperation dynamicOperation = createDynamicOperation(types, schemata, columns, comparison.getOperand1()); Operator operator = comparison.operator(); StaticOperand staticOperand = comparison.getOperand2(); return createChecker(types, schemata, columns, dynamicOperation, operator, staticOperand); } if (constraint instanceof SetCriteria) { SetCriteria setCriteria = (SetCriteria) constraint; DynamicOperation dynamicOperation = createDynamicOperation(types, schemata, columns, setCriteria.leftOperand()); Operator operator = Operator.EQUAL_TO; final List<ConstraintChecker> checkers = new LinkedList<ConstraintChecker>(); for (StaticOperand setValue : setCriteria.rightOperands()) { ConstraintChecker rightChecker = createChecker(types, schemata, columns, dynamicOperation, operator, setValue); assert rightChecker != null; checkers.add(rightChecker); } if (checkers.isEmpty()) { // Nothing will satisfy these constraints ... return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { return false; } }; } return new ConstraintChecker() { @Override public boolean satisfiesConstraints(Object[] tuple) { for (ConstraintChecker checker : checkers) { if (checker.satisfiesConstraints(tuple)) return true; } return false; } }; } assert false; return null; }