Java Code Examples for org.eclipse.rdf4j.query.algebra.QueryModelNode#visit()

private static boolean isTupleValid(QueryModelNode node) {

        ValidQueryVisitor vqv = new ValidQueryVisitor();
        node.visit(vqv);

        Set<String> spVars = getVarNames(getQNodes("sp", node));

        if (vqv.isValid() && spVars.size() > 0) {

            FilterCollector fvis = new FilterCollector();
            node.visit(fvis);
            List<QueryModelNode> fList = fvis.getFilters();
            return fList.size() == Sets.newHashSet(fList).size() && getVarNames(fList).size() <= spVars.size();

        } else {
            return false;
        }
    }
 

private static Set<QueryModelNode> getQNodes(QueryModelNode queryNode) {
    Set<QueryModelNode> rtns = new HashSet<QueryModelNode>();

    StatementPatternCollector spc = new StatementPatternCollector();
    queryNode.visit(spc);
    rtns.addAll(spc.getStatementPatterns());

    FilterCollector fvis = new FilterCollector();
    queryNode.visit(fvis);
    rtns.addAll(fvis.getFilters());

    ExternalTupleCollector eVis = new ExternalTupleCollector();
    queryNode.visit(eVis);
    rtns.addAll(eVis.getExtTup());

    return rtns;
}
 

private static Set<QueryModelNode> getQNodes(String node, QueryModelNode queryNode) {

        if (node.equals("sp")) {
            Set<QueryModelNode> eSet = new HashSet<QueryModelNode>();
            StatementPatternCollector spc = new StatementPatternCollector();
            queryNode.visit(spc);
            List<StatementPattern> spList = spc.getStatementPatterns();
            eSet.addAll(spList);
            // returns empty set if list contains duplicate StatementPatterns
            if (spList.size() > eSet.size()) {
                return Sets.newHashSet();
            } else {
                return eSet;
            }
        } else if (node.equals("filter")) {

            FilterCollector fvis = new FilterCollector();
            queryNode.visit(fvis);

            return Sets.newHashSet(fvis.getFilters());
        } else {

            throw new IllegalArgumentException("Invalid node type.");
        }
    }
 

private static void organizeBSAs(QueryModelNode node) {

        BindingSetAssignmentCollector bsac = new BindingSetAssignmentCollector();
        node.visit(bsac);

        if (bsac.containsBSAs()) {
            Set<QueryModelNode> bsaSet = bsac.getBindingSetAssignments();
            BindingSetAssignmentExchangeVisitor bsaev = new BindingSetAssignmentExchangeVisitor(bsaSet);
            node.visit(bsaev);
        }
    }
 

private static void organizeExtTuples(QueryModelNode node) {

            ExternalTupleCollector eVis = new ExternalTupleCollector();
            node.visit(eVis);

            ExtTupleExchangeVisitor oev = new ExtTupleExchangeVisitor(eVis.getExtTup());
            node.visit(oev);
        }
 

public static List<BindingSetAssignment> process(QueryModelNode node) {
    BindingSetAssignmentCollector collector = new BindingSetAssignmentCollector();
    node.visit(collector);
    return collector.getBindingSetAssigments();
}
 

public static List<TupleExpr> process(QueryModelNode node) {
	BasicGraphPatternExtractor ex = new BasicGraphPatternExtractor();
	node.visit(ex);
	return ex.bgpList;
}
 

static Collection<Quantifier.Var> process(QueryModelNode node) {
    QuantifierCollector collector = new QuantifierCollector();
    node.visit(collector);
    return collector.vars;
}
 

public static List<QueryModelNode> process(QueryModelNode node) {
    FilterVarValueCollector collector = new FilterVarValueCollector();
    node.visit(collector);
    return collector.getVars();
}
 

public static List<Var> processVar(QueryModelNode node) {
    VarCollector collector = new VarCollector();
    node.visit(collector);
    return collector.getVars();
}
 

public static List<String> process(QueryModelNode node) {
    VarCollector collector = new VarCollector();
    node.visit(collector);
    return collector.getVarNames();
}
 

@Override
public void meet(final Reduced node) {
    //create id, initialize ConstructQueryMetadata builder, register ConstructQueryMetadata
    //builder with FluoQueryBuilder, and add metadata that we currently have
    final String constructId = nodeIds.getOrMakeId(node);

    ConstructQueryMetadata.Builder constructBuilder = fluoQueryBuilder.getConstructQueryBuilder().orNull();
    if(constructBuilder == null) {
        constructBuilder = ConstructQueryMetadata.builder();
        constructBuilder.setNodeId(constructId);
        fluoQueryBuilder.setConstructQueryMetadata(constructBuilder);
    }

    //get child node
    QueryModelNode child = node.getArg();
    Preconditions.checkArgument(child instanceof Projection || child instanceof MultiProjection);
    final UnaryTupleOperator unary = (UnaryTupleOperator) child;

    //get ProjectionElemList to build ConstructGraph
    final List<ProjectionElemList> projections = new ArrayList<>();
    if(unary instanceof Projection) {
        projections.add(((Projection) unary).getProjectionElemList());
    } else {
        projections.addAll(((MultiProjection)unary).getProjections());
    }

    //get ExtensionElems to build ConstructGraph
    final QueryModelNode grandChild = unary.getArg();
    Preconditions.checkArgument(grandChild instanceof Extension);
    final Extension extension = (Extension) grandChild;
    final List<ExtensionElem> extensionElems = extension.getElements();
    final ConstructGraph graph = getConstructGraph(projections, extensionElems);
    constructBuilder.setConstructGraph(graph);

    //set child to the next node we care about in Fluo
    //if Extension's arg is a Group node, then it is an Aggregation, so set child to Extension
    //otherwise set child to Extension's child (only care about Extensions if they are Aggregations)
    if(extension.getArg() instanceof Group) {
        child = extension;
    } else {
        child = extension.getArg();
    }

    //Set the child node in the ConstructQueryMetadataBuilder
    final String childNodeId = nodeIds.getOrMakeId(child);
    constructBuilder.setChildNodeId(childNodeId);

    // Update the child node's metadata.
    final Set<String> childVars = getVars((TupleExpr)child);
    final VariableOrder childVarOrder = new VariableOrder(childVars);
    setChildMetadata(fluoQueryBuilder, childNodeId, childVarOrder, constructId);

    //fast forward visitor to next node we care about
    child.visit(this);
}
 

public static Map<String, Object> process(QueryModelNode node) {
	TripleRefCollector collector = new TripleRefCollector();
	node.visit(collector);
	return collector.getTripleRefs();
}
 

public static Set<String> process(QueryModelNode node) {
	VarNameCollector collector = new VarNameCollector();
	node.visit(collector);
	return collector.getVarNames();
}
 

public void replaceChildNode(QueryModelNode parent, QueryModelNode former, QueryModelNode replacement) {
	this.former = former;
	this.replacement = replacement;
	parent.visit(this);
}
 

public static List<StatementPattern> process(QueryModelNode node) {
	StatementPatternCollector collector = new StatementPatternCollector();
	node.visit(collector);
	return collector.getStatementPatterns();
}
 

@Override
protected void meetNode(QueryModelNode node) throws X {
	// resume previous visitor
	node.visit(visitor);
}
 

public static String printTree(QueryModelNode node) {
	QueryModelTreePrinter treePrinter = new QueryModelTreePrinter();
	node.visit(treePrinter);
	return treePrinter.getTreeString();
}