new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s1") }); final FunctionNode bound2 = new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s2") }); final FunctionNode not1 = FunctionNode.NOT(bound2); new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s3") }); final FunctionNode bound4 = new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s4") }); final FunctionNode bound5 = new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s5") }); final FunctionNode or1 = FunctionNode.OR(FunctionNode.AND(bound3,bound4), bound5); new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("s6") }); FunctionNode.AND( FunctionNode.AND( FunctionNode.AND(bound1, not1), or1), bound6);
final URI functionURI = functionNode.getFunctionURI(); (IValueExpressionNode) functionNode.get(0); final URI innerFunctionURI = innerFunctionNode.getFunctionURI(); FunctionNode.NOT( (ValueExpressionNode)innerFunctionNode.get(0))); final IValueExpressionNode negRight = pushNegations( FunctionNode.NOT( (ValueExpressionNode)innerFunctionNode.get(1))); return FunctionNode.OR( (ValueExpressionNode)negLeft, (ValueExpressionNode)negRight); FunctionNode.NOT( (ValueExpressionNode)innerFunctionNode.get(0))); final IValueExpressionNode negRight = pushNegations( FunctionNode.NOT( (ValueExpressionNode)innerFunctionNode.get(1))); return FunctionNode.AND( (ValueExpressionNode)negLeft, (ValueExpressionNode)negRight); final BOp innerInner = innerFunctionNode.get(0);
protected FunctionNode bound(final VarNode varNode) { final FunctionNode rslt = new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { varNode } ); rslt.setValueExpression(new IsBoundBOp(varNode.getValueExpression())); return rslt; }
final FunctionNode filterEq = FunctionNode.EQ(new VarNode("s"), new VarNode("o")); final FunctionNode filterNeq = FunctionNode.NE(new VarNode("s"), new VarNode("o")); final FunctionNode filterLe = FunctionNode.LE(new VarNode("s"), new VarNode("o")); final FunctionNode filterLt = FunctionNode.LT(new VarNode("s"), new VarNode("o")); final FunctionNode filterGe = FunctionNode.GE(new VarNode("s"), new VarNode("o")); final FunctionNode filterGt = FunctionNode.GT(new VarNode("s"), new VarNode("o")); final FunctionNode comb1 = FunctionNode.AND(filterEq, filterNeq); final FunctionNode comb2 = FunctionNode.AND(filterLe, filterLt); final FunctionNode comb3 = FunctionNode.AND(filterGt, filterGe); FunctionNode.NOT( FunctionNode.AND(FunctionNode.AND(comb1, comb2),comb3))); final FunctionNode filterEqInv = FunctionNode.NE(new VarNode("s"), new VarNode("o")); final FunctionNode filterNeqInv = FunctionNode.EQ(new VarNode("s"), new VarNode("o")); final FunctionNode filterLeInv = FunctionNode.GT(new VarNode("s"), new VarNode("o")); final FunctionNode filterLtInv = FunctionNode.GE(new VarNode("s"), new VarNode("o")); final FunctionNode filterGeInv = FunctionNode.LT(new VarNode("s"), new VarNode("o")); final FunctionNode filterGtInv = FunctionNode.LE(new VarNode("s"), new VarNode("o")); final FunctionNode comb1 = FunctionNode.OR(filterEqInv, filterNeqInv); final FunctionNode comb2 = FunctionNode.OR(filterLeInv, filterLtInv); final FunctionNode comb3 = FunctionNode.OR(filterGtInv, filterGeInv); FunctionNode.OR(FunctionNode.OR(comb1, comb2),comb3)); assertTrue(StaticAnalysis.isCNF(filterNode));
FunctionNode.NOT( FunctionNode.OR( FunctionNode.LT(new VarNode("s"), new VarNode("o")), new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("o") })))); assertFalse(StaticAnalysis.isCNF(filterNode)); whereClause.addChild( new FilterNode( FunctionNode.GE(new VarNode("s"), new VarNode("o")))); whereClause.addChild( new FilterNode( FunctionNode.NOT( new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("o") }))));
/** * 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); }
FunctionNode.AND( FunctionNode.EQ(new VarNode("s"), new VarNode("o")), FunctionNode.NE(new VarNode("s"), new ConstantNode(test)))); FunctionNode.EQ(new VarNode("s"), new VarNode("o")))); whereClause.addChild( new FilterNode( FunctionNode.EQ(new VarNode("s"), new VarNode("o")))); whereClause.addChild( new FilterNode( FunctionNode.NE(new VarNode("s"), new ConstantNode(test))));
new FunctionNode(FunctionRegistry.GT, null, new ValueExpressionNode[] { new VarNode("o2"), FunctionNode.subtract(new VarNode("o1"), new ConstantNode(ten)) }); new FunctionNode(FunctionRegistry.LT, null, new ValueExpressionNode[] { new VarNode("o2"), FunctionNode.add(new VarNode("o1"), new ConstantNode(ten)) }); final FunctionNode f = FunctionNode.AND(f1, f2); new FunctionNode(FunctionRegistry.GT, null, new ValueExpressionNode[] { new VarNode("o2"), FunctionNode.subtract(new VarNode("o1"), new ConstantNode(ten)) }); new FunctionNode(FunctionRegistry.LT, null, new ValueExpressionNode[] { new VarNode("o2"), FunctionNode.add(new VarNode("o1"), new ConstantNode(ten)) }); final FunctionNode f = FunctionNode.AND(f1, f2);
/** * <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); }
/** * Return <code>t1 <= t2</code> */ static public FunctionNode LE(final ValueExpressionNode t1, final ValueExpressionNode t2) { return new FunctionNode(FunctionRegistry.LE, null/* scalarValues */, new ValueExpressionNode[] { t1, t2 }); }
FunctionNode.NOT( new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("o") })); final FunctionNode filterANot2 = FunctionNode.NOT(filterANot1); final FunctionNode filterANot3 = FunctionNode.NOT(filterANot2); FunctionNode.NOT( new FunctionNode(FunctionRegistry.EQ, null, new ValueExpressionNode[] { new VarNode("s"), new VarNode("o") })); final FunctionNode filterBNot2 = FunctionNode.NOT(filterBNot1); final FunctionNode filterBNot3 = FunctionNode.NOT(filterBNot2); final FunctionNode filterBNot4 = FunctionNode.NOT(filterBNot3); FunctionNode.NOT( FunctionNode.OR(filterANot3, filterBNot4))); assertFalse(StaticAnalysis.isCNF(filterNode)); new FunctionNode(FunctionRegistry.BOUND, null, new ValueExpressionNode[] { new VarNode("o") }); new FunctionNode(FunctionRegistry.NE, null, new ValueExpressionNode[] { new VarNode("s"), new VarNode("o") });
having.addExpr(FunctionNode.LT( new FunctionNode(FunctionRegistry.SUM, null, y), new ConstantNode(new XSDNumericIV(10)) ));
new ConstantNode(dcDate), new VarNode("date"))); whereClause.addChild(new FilterNode(FunctionNode.GT( new VarNode("date"), new ConstantNode(dateTime))));
final FunctionNode fn = FunctionNode.add(new ConstantNode(c12), new ConstantNode(c1)); final FunctionNode fn = FunctionNode.add(new ConstantNode(c12), new ConstantNode(c1)); fn.setValueExpression(new Constant<IV<?, ?>>(c13));
/** * Returns a fresh filter node with the specified variable in their * {@link ValueExpressionNode}. The filter is not of type * EXISTS or NOT EXISTS. */ FilterNode filterWithVar(final String varName) { final FilterNode fn = (FilterNode) new Helper(){{ tmp = filter(FunctionNode.EQ(varNode(varName),constantNode(a))); }}.getTmp(); return (FilterNode)resolveVEs(fn); }
/** * Unit test verifies that a constant within a group by clause does not * cause the group by clause to be interpreted as an aggregate. * * <pre> * select ?index * group by (?o + 1 AS ?index) * </pre> */ @SuppressWarnings({ "rawtypes", "unchecked" }) public void test_aggregateExpr_04() { final VarNode index = new VarNode("index"); final VarNode o = new VarNode("o"); final IValueExpressionNode mathExpr = FunctionNode.add( o, new ConstantNode(new XSDNumericIV(1))); final ProjectionNode select = new ProjectionNode(); select.addProjectionVar(index); final GroupByNode groupBy = new GroupByNode(); groupBy.addExpr(new AssignmentNode(index, mathExpr)); final HavingNode having = null; new VerifyAggregates(select, groupBy, having); }
/** * Returns a fresh filter node with the specified variables in their * {@link ValueExpressionNode}. The filter is not of type * EXISTS or NOT EXISTS. */ FilterNode filterWithVars(final String varName1, final String varName2) { final FilterNode fn = (FilterNode) new Helper(){{ tmp = filter(FunctionNode.NE(varNode(varName1),varNode(varName2))); }}.getTmp(); return (FilterNode)resolveVEs(fn); }