How to use

transform

method

in

org.apache.jena.sparql.syntax.syntaxtransform.QueryTransformOps

/**
 * 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);
}

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) ;
}