/** * Extracts any {@code SortCondition} instances from the SPARQL query and holds them in an index of their keys * where the value is that keys sorting direction. */ private static Map<String, Order> createOrderIndexFromQuery(final Query query) { final Map<String, Order> orderingIndex = new HashMap<>(); if (query.hasOrderBy()) { final List<SortCondition> sortingConditions = query.getOrderBy(); for (SortCondition sortCondition : sortingConditions) { final Expr expr = sortCondition.getExpression(); // by default, the sort will be ascending. getDirection() returns -2 if the DESC/ASC isn't // supplied - weird orderingIndex.put(expr.getVarName(), sortCondition.getDirection() == -1 ? Order.decr : Order.incr); } } return orderingIndex; }
private static GraphTraversal<?, ?> transform(final E_LessThanOrEqual expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.lte(value)); }
private static GraphTraversal<?, ?> transform(final E_NotEquals expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.neq(value)); }
private static GraphTraversal<?, ?> transform(final E_Equals expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.eq(value)); }
private static GraphTraversal<?, ?> transform(final E_GreaterThanOrEqual expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.gte(value)); }
private static GraphTraversal<?, ?> transform(final E_LessThan expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.lt(value)); }
private static GraphTraversal<?, ?> transform(final E_GreaterThan expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.gt(value)); }
public SqlExpr getSqlExpr(int index) { E_RdfTerm rdfTerm = getRdfTermExpr(); Expr expr = rdfTerm.getArg(index + 1); String varName = expr.getVarName(); Map<String, SqlExpr> map = projection.getNameToExpr(); SqlExpr result = map.get(varName); return result; }
public static String toTemplateCore(List<Expr> exprs) { StringBuilder b = new StringBuilder(); for(Expr expr : exprs) { if(expr.isVariable()) { String varName = expr.getVarName(); String escapedVarName = escapeForTemplate(varName); b.append("{" + escapedVarName + "}"); } else if(expr.isConstant()) { String str = expr.getConstant().asUnquotedString(); String escapedStr = escapeForTemplate(str); b.append(escapedStr); } else { throw new RuntimeException("Unexpected expression: " + expr); } } String result = b.toString(); return result; }
public static int compare(Expr a, Expr b) { int ca = classify(a); int cb = classify(b); int r = cb - ca; if(r == 0) { switch(ca) { case 0: r = NodeValue.compare(a.getConstant(), b.getConstant()); break; case 1: r = a.getVarName().compareTo(b.getVarName()); break; case 2: r = a.getFunction().getFunctionIRI().compareTo(b.getFunction().getFunctionIRI()); break; default: throw new RuntimeException("should not come here"); } } return r; }
/** * If a variable equals a (uri or string) constant, it means that the view must provide * a prefix for that value. * * @param a * @param b * @return */ public static VariableConstraint deriveIsPrefixOfConstraint(Expr a, Expr b) { if(!(a.isVariable() && b.isConstant())) { return null; } Object value = NodeValueUtils.getValue(b.getConstant()); return new VariableConstraint(a.getVarName(), new IsPrefixOfConstraint(value.toString())); }
/** * If a variable equals a (uri or string) constant, it means that the view must provide * a prefix for that value. * * @param a * @param b * @return */ public static VariableConstraint deriveIsPrefixOfConstraint(Expr a, Expr b) { if(!(a.isVariable() && b.isConstant())) { return null; } Object value = NodeValueUtils.getValue(b.getConstant()); return new VariableConstraint(a.getVarName(), new IsPrefixOfConstraint(value.toString())); }
public static GraphTraversal<?, ?> transform(final E_GreaterThan expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.gt(value)); }
public static GraphTraversal<?, ?> transform(final E_LessThan expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.lt(value)); }
public static GraphTraversal<?, ?> transform(final E_LessThanOrEqual expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.lte(value)); }
public static GraphTraversal<?, ?> transform(final E_Equals expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.eq(value)); }
public static GraphTraversal<?, ?> transform(final E_NotEquals expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.neq(value)); }
public static GraphTraversal<?, ?> transform(final E_GreaterThanOrEqual expression) { final Object value = expression.getArg2().getConstant().getNode().getLiteralValue(); return __.as(expression.getArg1().getVarName()).is(P.gte(value)); }
@Test public void test_function_expansion_10() { Expr single = new ExprVar("x"); UserDefinedFunctionFactory.getFactory().add("http://example/single", single, new ArrayList<>(single.getVarsMentioned())); //Test that with preserveDependencies set to false (the default) that the definition is expanded appropriately //when the outer function has differing numbers of arguments List<Var> args = new ArrayList<>(); args.add(Var.alloc("x")); args.add(Var.alloc("y")); Expr add = new E_Add(new E_Function("http://example/single", new ExprList(new ExprVar("x"))), new ExprVar("y")); UserDefinedFunctionFactory.getFactory().add("http://example/add", add, args); UserDefinedFunctionDefinition def = UserDefinedFunctionFactory.getFactory().get("http://example/add"); Expr base = def.getBaseExpr(); Assert.assertTrue(base instanceof E_Add); E_Add actual = (E_Add)base; Assert.assertTrue(actual.getArg1() instanceof ExprVar); Assert.assertTrue(actual.getArg2() instanceof ExprVar); Assert.assertEquals("x", actual.getArg1().getVarName()); Assert.assertEquals("y", actual.getArg2().getVarName()); }
@Test public void test_function_expansion_11() { Expr single = new ExprVar("x"); UserDefinedFunctionFactory.getFactory().add("http://example/single", single, new ArrayList<>(single.getVarsMentioned())); //Test that with preserveDependencies set to false (the default) that the definition is expanded appropriately //when the outer function has differing numbers of arguments List<Var> args = new ArrayList<>(); args.add(Var.alloc("x")); args.add(Var.alloc("y")); Expr add = new E_Add(new E_Function("http://example/single", new ExprList(new ExprVar("y"))), new ExprVar("y")); UserDefinedFunctionFactory.getFactory().add("http://example/add", add, args); UserDefinedFunctionDefinition def = UserDefinedFunctionFactory.getFactory().get("http://example/add"); Expr base = def.getBaseExpr(); Assert.assertTrue(base instanceof E_Add); E_Add actual = (E_Add)base; Assert.assertTrue(actual.getArg1() instanceof ExprVar); Assert.assertTrue(actual.getArg2() instanceof ExprVar); Assert.assertEquals("y", actual.getArg1().getVarName()); Assert.assertEquals("y", actual.getArg2().getVarName()); }