import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
/**
 * Method for translating an operator-tree. Move filter conditions as far as
 * possible down in the tree. In the optimal way, the filter conditions is
 * the parent of an OpBGP.
 */
private Op translate(Op op) {
	if (log.isDebugEnabled()) {
		log.debug("Before translation:\n" + PrintUtils.toString(op));
	}
	// Shape filter expressions to maximize opportunities for pushing them
	// down
	op = Transformer.transform(new TransformFilterCNF(), op);
	// Try to move any filters as far down as possible
	op = PushDownOpFilterVisitor.transform(op);
	// Translate BGPs that have a filter immediately above them
	op = Transformer.transform(new TransformOpBGP(mapping, true), op);
	// Translate BGPs that don't have a filter
	op = Transformer.transform(new TransformOpBGP(mapping, false), op);

	if (log.isDebugEnabled()) {
		log.debug("After translation:\n" + PrintUtils.toString(op));
	}
	return op;
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
@Override
protected Op modifyOp(Op op)
{
    // Just property functions
    Transform t = new TransformPropertyFunction(context) ;
    op = Transformer.transform(t, op) ;
    return op ;
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public RemediatorQuery(String queryString) {
	super();
	this.queryString = queryString;
	this.originalQuery = QueryFactory.create(this.queryString);
	this.originalOperations = Algebra.compile(this.originalQuery);
	queryVars = new QueryVars(
			OpVars.mentionedVars(this.originalOperations));
	Simplifier  simplifier = new Simplifier();
	this.simplifiedOperations = Transformer.transform(simplifier, this.originalOperations);
	//Create lookup for simplified operations
	for(Triple triple:((OpBGP)this.simplifiedOperations).getPattern().getList()){
		//TODO Should only put in relevant operations for this dataset.
		simplifiedTriples.put(triple.hashCode(), triple);
	}
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public Op createQueryClause(RemediatorQuery remediatorQuery,
		QueryVars globalQueryVars) {
	Substituter substituter = new Substituter(globalQueryVars,
			this, remediatorQuery.getSimplifiedTriples());
	Op substitutedOperations = Transformer.transform(substituter,
			remediatorQuery.getOperations());
	//this.setOpService(
	//		substitutedOperations);
	return substitutedOperations;		
	
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public Op transform(Op op) {
    return Transformer.transform(this, op, visitor, null);
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public Op optimize(Op op) {
    return Transformer.transform(this, op);
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
private Op optimizeAlgebra(Op opRoot) {
	/*
	 * Algebra Optimierer fuehrt High-Level Transformationen aus (z.B. Filter Equalilty)
	 * -> nicht BGP reordering
	 * 
	 * zunaechst muss gesetzt werden was alles optimiert werden soll, z.B.
	 * ARQ.set(ARQ.optFilterEquality, true);
	 * oder
	 * ARQ.set(ARQ.optFilterPlacement, true);
	 * 
	 * Danach kann dann Algebra.optimize(op) aufgerufen werden
	 */

	/*
	 * Algebra.optimize always executes TransformJoinStrategy -> not always wanted
	 * ARQ.set(ARQ.optFilterPlacement, false);
	 * ARQ.set(ARQ.optFilterEquality, true);
	 * ARQ.set(ARQ.optFilterConjunction, true);
	 * ARQ.set(ARQ.optFilterDisjunction, true);
	 * opRoot = Algebra.optimize(opRoot);
	 */

	/*
	 * Reihenfolge der Optimierungen wichtig!
	 * 
	 * 1. Transformationen der SPARQL-Algebra bis auf FilterPlacement -> koennte Kreuzprodukte erzeugen
	 * 2. BGPOptimizer -> Neuanordnung der Triple im BGP zur Vermeidung von Kreuzprodukten und zur Minimierung von Joins
	 * 3. FilterPlacement -> Vorziehen des Filters soweit moeglich
	 */

	// Perform Join optimization only if optimization level is set to ALL
	if (Tags.optimizer == Optimizer.ALL) {
		TransformJoinStrategy joinStrategy = new TransformJoinStrategy();
		opRoot = Transformer.transform(joinStrategy, opRoot);
	}

	// Perform filter optimizations if optimization level is set to FILTER or ALL
	if (Tags.optimizer == Optimizer.FILTER || Tags.optimizer == Optimizer.ALL) {
		// ARQ optimization of Filter conjunction
		TransformFilterConjunction filterConjunction = new TransformFilterConjunction();
		opRoot = Transformer.transform(filterConjunction, opRoot);

		// ARQ optimization of Filter disjunction
		TransformFilterDisjunction filterDisjunction = new TransformFilterDisjunction();
		opRoot = Transformer.transform(filterDisjunction, opRoot);

		// ARQ optimization of Filter equality
		TransformFilterEquality filterEquality = new TransformFilterEquality();
		opRoot = Transformer.transform(filterEquality, opRoot);

		// Own optimization of Filter variable equality
		TransformFilterVarEquality filterVarEquality = new TransformFilterVarEquality();
		opRoot = filterVarEquality.transform(opRoot);
	}

	// Perform BGP optimization if optimization level is set to BGP, FILTER or ALL
	if (Tags.optimizer == Optimizer.BGP || Tags.optimizer == Optimizer.FILTER || Tags.optimizer == Optimizer.ALL) {
		// Own BGP optimizer using variable counting heuristics
		BGPOptimizerNoStats bgpOptimizer = new BGPOptimizerNoStats();
		opRoot = bgpOptimizer.optimize(opRoot);
	}

	// Perform filter optimizations if optimization level is set to FILTER or ALL
	// Filter Placement must be done last!
	if (Tags.optimizer == Optimizer.FILTER || Tags.optimizer == Optimizer.ALL) {
		// ARQ optimization of Filter placement
		TransformFilterPlacement filterPlacement = new TransformFilterPlacement();
		opRoot = Transformer.transform(filterPlacement, opRoot);
	}
	return opRoot;
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public Op transform(Op op) {
	return Transformer.transform(this, op, visitor, null);
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
public Op optimize(Op op) {
	return Transformer.transform(this, op);
}
 

import com.hp.hpl.jena.sparql.algebra.Transformer; //导入依赖的package包/类
private static Op simplify(Op op) {
    return Transformer.transform(simplify, op) ;
}