/** * Transform a query based on a mapping from variable name to replacement * {@link RDFNode} (a {@link Resource} (or blank node) or a {@link Literal}). */ public static Query transformQuery(Query query, Map<String, ? extends RDFNode> substitutions) { // Must have a different name because of Java's erasure of parameterised types. Map<Var, Node> map = TransformElementLib.convert(substitutions); return transform(query, map); }
/** Transform a query using {@link ElementTransform} and {@link ExprTransform}. * It is the responsibility of these transforms to transform to a legal SPARQL query. */ public static Query transform(Query query, ElementTransform transform, ExprTransform exprTransform) { Query q2 = QueryTransformOps.shallowCopy(query); // "Shallow copy with transform." transformVarExprList(q2.getProject(), exprTransform); transformVarExprList(q2.getGroupBy(), exprTransform); transformExprList(q2.getHavingExprs(), exprTransform); if (q2.getOrderBy() != null) { transformSortConditions(q2.getOrderBy(), exprTransform); } // ?? DOES NOT WORK: transformExprListAgg(q2.getAggregators(), exprTransform) ; ?? // if ( q2.hasHaving() ) {} // if ( q2.hasAggregators() ) {} Element el = q2.getQueryPattern(); Element el2 = ElementTransformer.transform(el, transform, exprTransform); // Top level is always a group. if (!(el2 instanceof ElementGroup)) { ElementGroup eg = new ElementGroup(); eg.addElement(el2); el2 = eg; } q2.setQueryPattern(el2); return q2; }
private static void testShallowCopy(String queryString) { Query q1 = QueryFactory.create(queryString) ; Query q2 = QueryTransformOps.shallowCopy(q1) ; assertEquals(q1, q2) ; }
private void testQueryModel(String input, String output, String varStr, String valStr) { Query q1 = QueryFactory.create(PREFIX+input) ; Query qExpected = QueryFactory.create(PREFIX+output) ; Map<String, RDFNode> map = new HashMap<>() ; Node n = SSE.parseNode(valStr); RDFNode x = ModelUtils.convertGraphNodeToRDFNode(n); map.put(varStr, x); Query qTrans = QueryTransformOps.transformQuery(q1, map) ; assertEquals(qExpected, qTrans) ; }
public static Query transform(Query query, ElementTransform transform) { ExprTransform noop = new ExprTransformApplyElementTransform(transform); return transform(query, transform, noop); }
@Override public QueryExecution createQueryExecution(Query baseQuery) { String baseRename = "v" + (baseRenameId++) + "_"; Map<Var, Var> varMap = QueryUtils.createRandomVarMap(baseQuery, baseRename); Query query = QueryTransformOps.transform(baseQuery, varMap); System.out.println("Remapped: " + query); // Invert the map (TODO Make this a static util function) Map<Var, Var> inverseVarMap = varMap.entrySet().stream() .collect(Collectors.toMap(Entry::getValue, Entry::getKey)); QueryExecution baseQe = super.createQueryExecution(query); QueryExecution result = new QueryExecutionRenameVars(baseQe, inverseVarMap); return result; } }
/** Transform a query based on a mapping from {@link Var} variable to replacement {@link Node}. */ public static Query transform(Query query, Map<Var, ? extends Node> substitutions) { ElementTransform eltrans = new ElementTransformSubst(substitutions); NodeTransform nodeTransform = new NodeTransformSubst(substitutions); ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform, eltrans); return transform(query, eltrans, exprTrans); }
@Override public void visit(ElementSubQuery el) { Query newQuery = QueryTransformOps.transform(el.getQuery(), transform, exprTransform) ; push(new ElementSubQuery(newQuery)) ; }
Query result = QueryTransformOps.transform(query, substitutions);
Query result = QueryTransformOps.transform(query, substitutions);
private void testQuery(String input, String output, String varStr, String valStr) { Query q1 = QueryFactory.create(PREFIX+input) ; Query qExpected = QueryFactory.create(PREFIX+output) ; Map<Var, Node> map = new HashMap<>() ; map.put(Var.alloc(varStr), SSE.parseNode(valStr)) ; Query qTrans = QueryTransformOps.transform(q1, map) ; assertEquals(qExpected, qTrans) ; }
private static void test(String input, String expected) { if ( expected == null ) expected = input ; String qs = gen(PRE, input) ; String qsExpected = gen(PRE, expected) ; Query query = QueryFactory.create(qs, Syntax.syntaxARQ) ; Query query2 = QueryTransformOps.transform(query, new ElementTransformCleanGroupsOfOne()) ; Query queryExpected = QueryFactory.create(qsExpected, Syntax.syntaxARQ) ; Op op1 = Algebra.compile(query) ; Op op2 = Algebra.compile(query2) ; assertEquals("Algebra different", op1, op2) ; boolean modified = ! query.equals(query2) ; boolean expectModification = !queryExpected.equals(query) ; assertEquals("Expect query modifed?", expectModification, modified) ; }