public void addProjectionExpression(final AssignmentNode assignment) { addExpr(assignment); }
public void addProjectionExpression(final AssignmentNode assignment) { addExpr(assignment); }
/** * Adds a variable to be projected. The variable is modeled as an assignment * of itself to itself, so everything in the projection node winds up * looking like an assignment. * * @param var * The variable. */ public void addProjectionVar(final VarNode var) { addExpr(new AssignmentNode(var, var)); }
/** * Adds a variable to be projected. The variable is modeled as an assignment * of itself to itself, so everything in the projection node winds up * looking like an assignment. * * @param var * The variable. */ public void addProjectionVar(final VarNode var) { addExpr(new AssignmentNode(var, var)); }
/** * Unit test when projecting a constant * <pre> * SELECT 12 as ?x * </pre> */ public void test_with_constant() { @SuppressWarnings({ "unchecked", "rawtypes" }) final VarNode x = new VarNode("x"); @SuppressWarnings({ "rawtypes", "unchecked" }) final ConstantNode xExpr = new ConstantNode( new XSDNumericIV(12)); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = null; final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * Verify that a reference to a variable defined by a previous select * expression is allowed and that the select dependency is recognized. * * <pre> * SELECT SUM(?y) as ?z, SUM(?x)+?z as ?a * GROUP BY ?b * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_reverseReference_allowed_aka_select_dependency() { final VarNode a = new VarNode("a"); final VarNode b = new VarNode("b"); final VarNode x = new VarNode("x"); final VarNode y = new VarNode("y"); final VarNode z = new VarNode("z"); final IValueExpressionNode zExpr = new FunctionNode(FunctionRegistry.SUM, null,y); final IValueExpressionNode aExpr = FunctionNode.add(new FunctionNode(FunctionRegistry.SUM, null,x), z); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(z, zExpr)); select.addExpr(new AssignmentNode(a, aExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(b); final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * Unit test for {@link IGroupByState#isAnyDistinct()) where the DISTINCT * keyword appears within an {@link IAggregate} in the SELECT clause. * <pre> * SELECT SUM(DISTINCT ?y) as ?x * GROUP BY ?z * HAVING ?x > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_isAnyDistinct_select() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final Map<String, Object> scalarValues = new HashMap<>(); scalarValues.put(Annotations.DISTINCT, Boolean.TRUE); final IValueExpressionNode xExpr = new FunctionNode(FunctionRegistry.SUM, scalarValues, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( x, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * Unit test for {@link IGroupByState#isAnyDistinct()) where the DISTINCT * keyword appears within an {@link IAggregate} in the SELECT clause. * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING SUM(DISTINCT ?y) > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_isAnyDistinct_having() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final IValueExpressionNode xExpr = new FunctionNode(FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); final Map<String, Object> scalarValues = new HashMap<>(); scalarValues.put(Annotations.DISTINCT, Boolean.TRUE); having.addExpr(FunctionNode.GT( new FunctionNode(FunctionRegistry.SUM, scalarValues, y), new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?x+MIN(?y)) as ?z * GROUP BY ?a * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_nestedAggregates() { final VarNode a = new VarNode("a"); final VarNode x = new VarNode("x"); final VarNode y = new VarNode("y"); final VarNode z = new VarNode("z"); final IValueExpressionNode zExpr = new FunctionNode(FunctionRegistry.SUM, null, FunctionNode.add(x, new FunctionNode( FunctionRegistry.MIN, null, y))); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(z, zExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(a); final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * Unit test when projecting a constant * <pre> * SELECT 12 as ?x * </pre> */ public void test_with_constant() { @SuppressWarnings({ "unchecked", "rawtypes" }) final VarNode x = new VarNode("x"); @SuppressWarnings({ "rawtypes", "unchecked" }) final ConstantNode xExpr = new ConstantNode( new XSDNumericIV(12)); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = null; final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING ?x > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_simpleHavingClause() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final IValueExpressionNode xExpr = new FunctionNode( FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( x, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * Verify that a reference to a variable defined by a previous select * expression is allowed and that the select dependency is recognized. * * <pre> * SELECT SUM(?y) as ?z, SUM(?x)+?z as ?a * GROUP BY ?b * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_reverseReference_allowed_aka_select_dependency() { final VarNode a = new VarNode("a"); final VarNode b = new VarNode("b"); final VarNode x = new VarNode("x"); final VarNode y = new VarNode("y"); final VarNode z = new VarNode("z"); final IValueExpressionNode zExpr = new FunctionNode(FunctionRegistry.SUM, null,y); final IValueExpressionNode aExpr = FunctionNode.add(new FunctionNode(FunctionRegistry.SUM, null,x), z); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(z, zExpr)); select.addExpr(new AssignmentNode(a, aExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(b); final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING SUM(?y) > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_complexHavingClause() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final FunctionNode xExpr = new FunctionNode( FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(new VarNode(z)); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( xExpr, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * Unit test for {@link IGroupByState#isAnyDistinct()) where the DISTINCT * keyword appears within an {@link IAggregate} in the SELECT clause. * <pre> * SELECT SUM(DISTINCT ?y) as ?x * GROUP BY ?z * HAVING ?x > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_isAnyDistinct_select() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final Map<String, Object> scalarValues = new HashMap<>(); scalarValues.put(Annotations.DISTINCT, Boolean.TRUE); final IValueExpressionNode xExpr = new FunctionNode(FunctionRegistry.SUM, scalarValues, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( x, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * Unit test for {@link IGroupByState#isAnyDistinct()) where the DISTINCT * keyword appears within an {@link IAggregate} in the SELECT clause. * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING SUM(DISTINCT ?y) > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_isAnyDistinct_having() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final IValueExpressionNode xExpr = new FunctionNode(FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); final Map<String, Object> scalarValues = new HashMap<>(); scalarValues.put(Annotations.DISTINCT, Boolean.TRUE); having.addExpr(FunctionNode.GT( new FunctionNode(FunctionRegistry.SUM, scalarValues, y), new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?x+MIN(?y)) as ?z * GROUP BY ?a * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_nestedAggregates() { final VarNode a = new VarNode("a"); final VarNode x = new VarNode("x"); final VarNode y = new VarNode("y"); final VarNode z = new VarNode("z"); final IValueExpressionNode zExpr = new FunctionNode(FunctionRegistry.SUM, null, FunctionNode.add(x, new FunctionNode( FunctionRegistry.MIN, null, y))); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(z, zExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(a); final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING ?x > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_simpleHavingClause() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final IValueExpressionNode xExpr = new FunctionNode( FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(z); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( x, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }
/** * <pre> * SELECT SUM(?y) as ?x * GROUP BY ?z * HAVING SUM(?y) > 10 * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_complexHavingClause() { final VarNode y = new VarNode("y"); final VarNode x = new VarNode("x"); final VarNode z = new VarNode("z"); final FunctionNode xExpr = new FunctionNode( FunctionRegistry.SUM, null, y); final ProjectionNode select = new ProjectionNode(); select.addExpr(new AssignmentNode(x, xExpr)); final GroupByNode groupBy = new GroupByNode(); groupBy.addGroupByVar(new VarNode(z)); final HavingNode having = new HavingNode(); having.addExpr(FunctionNode.GT( xExpr, new ConstantNode(new XSDNumericIV(10)) )); new VerifyAggregates(select, groupBy, having); }