Java BasicPattern类代码示例

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
@Override
public void visit(ElementTriplesBlock el) {
    final BasicPattern bgp = el.getPattern();
    final ElementTriplesBlock nzed = new ElementTriplesBlock();
    final NodeExprNormalizer nenzer = new NodeExprNormalizer();
    bgp.forEach((t) -> {
        t.getSubject().visitWith(nenzer);
        Node s = nenzer.getResult();
        t.getPredicate().visitWith(nenzer);
        Node p = nenzer.getResult();
        t.getObject().visitWith(nenzer);
        Node o = nenzer.getResult();
        nzed.addTriple(new Triple(s, p, o));
    });
    endVisit(nzed, nenzer);
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
private void setWidths(BasicPattern triples) {
    subjectWidth = -1;
    predicateWidth = -1;

    for (Triple t : triples) {
        String s = slotToString(t.getSubject());
        if (s.length() > subjectWidth) {
            subjectWidth = s.length();
        }

        String p = slotToString(t.getPredicate());
        if (p.length() > predicateWidth) {
            predicateWidth = p.length();
        }
    }
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
private static BasicPattern reorder(BasicPattern pattern, QueryIterPeek peek, ReorderTransformation transform)
{
    if ( transform != null )
    {
        // This works by getting one result from the peek iterator,
        // and creating the more gounded BGP. The tranform is used to
        // determine the best order and the transformation is returned. This
        // transform is applied to the unsubstituted pattern (which will be
        // substituted as part of evaluation.

        if ( ! peek.hasNext() )
            throw new ARQInternalErrorException("Peek iterator is already empty") ;

        BasicPattern pattern2 = Substitute.substitute(pattern, peek.peek() ) ;
        // Calculate the reordering based on the substituted pattern.
        ReorderProc proc = transform.reorderIndexes(pattern2) ;
        // Then reorder original patten
        pattern = proc.reorder(pattern) ;
    }
    return pattern ;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
@Override
public QueryIterator execute(BasicPattern pattern, 
                             QueryIterator input,
                             ExecutionContext execCxt)
{
    // Just want to pick out some BGPs (e.g. on a particualr graph)
    // Test ::  execCxt.getActiveGraph() 
    if ( ! ( execCxt.getActiveGraph() instanceof GraphBase ) )
        // Example: pass on up to the original StageGenerator if
        // not based on GraphBase (which most Graph implementations are). 
        return other.execute(pattern, input, execCxt) ;
    
    System.err.println("MyStageGenerator.compile:: triple patterns = "+pattern.size()) ;

    // Stream the triple matches together, one triple matcher at a time. 
    QueryIterator qIter = input ;
    for (Triple triple : pattern.getList())
        qIter = new QueryIterTriplePattern(qIter, triple, execCxt) ;
    return qIter ;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
public static void formatPattern(IndentedWriter out, BasicPattern pattern, SerializationContext sCxt) {
    boolean first = true;
    for (Triple triple : pattern) {
        if (!first) {
            out.print("\n");
        }
        printTriple(out, triple, sCxt);
        out.print(" .");
        first = false;
    }
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
@Override
public void format(Template template) {
    out.print("{");
    out.incIndent(INDENT);
    out.pad();

    List<Quad> quads = template.getQuads();
    for (Quad quad : quads) {
        BasicPattern bgp = new BasicPattern();
        bgp.add(quad.asTriple());
        out.newline();
        if (!Quad.defaultGraphNodeGenerated.equals(quad.getGraph())) {

            out.print("GRAPH");
            out.print(" ");
            out.print(slotToString(quad.getGraph()));
            out.print(" ");

            out.newline();
            out.incIndent(INDENT);
            out.pad();
            out.print("{");
            out.incIndent(INDENT);
            out.pad();
        }

        formatTriples(bgp);

        if (!Quad.defaultGraphNodeGenerated.equals(quad.getGraph())) {
            out.decIndent(INDENT);
            out.print("}");
            out.decIndent(INDENT);
        }
    }
    out.newline();
    out.decIndent(INDENT);
    out.print("}");
    out.newline();
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
/**
 * Constructor.
 * @param query A Jena Query.  This engine does not use all parts of the Query hierarchy.
 * @param datasetGraph The MarkLogic instance viewed through Jena. Must be a MarkLogicDatasetGraph. 
 * @param initial Bindings for the query.
 * @param context
 */
private MarkLogicQueryEngine(Query query, DatasetGraph datasetGraph,
        Binding initial, Context context) {
    super(query, datasetGraph, initial, context);
    bgp = new BasicPattern();
    bgp.add(new Triple(
            Var.alloc("s"), 
            Var.alloc("p"), 
            Var.alloc("o")));
    template = new Template(bgp);
    this.markLogicDatasetGraph = (MarkLogicDatasetGraph) datasetGraph;
    this.initial = initial;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
/** One round of rule evaluation */
private static void eval1(Graph source, StreamTriple out, Rule rule) {
    BasicPattern pattern = BasicPattern.wrap(rule.getBody()) ;
    ExecutionContext execContext = new ExecutionContext(ARQ.getContext(), source, null, null) ; 
    // Create a chain of triple iterators.
    QueryIterator iter = match(source, pattern) ;
    iter.forEachRemaining(b->{
        Triple t = Substitute.substitute(rule.getHead(), b) ;
        if ( t.isConcrete() && ! source.contains(t) )
            out.triple(t);
    }) ;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
/** Evaluate a BGP : encapsulate for a better/different version */  
private static QueryIterator match(Graph source, BasicPattern pattern) {
    ExecutionContext execContext = new ExecutionContext(ARQ.getContext(), source, null, null) ; 
    // Create a chain of triple iterators.
    QueryIterator chain = QueryIterSingleton.create(BindingFactory.root(), execContext) ; 
    for (Triple triple : pattern)
        chain = new QueryIterTriplePattern(chain, triple, execContext) ;
    return chain ;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
public ElementGenerateTriplesBlock() {
    pattern = new BasicPattern();
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
public BasicPattern getPattern() {
    return pattern;
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
@Override
public void visit(ElementPathBlock el) {
    // Write path block - don't put in a final trailing "." 
    if (el.isEmpty()) {
        out.println("# Empty BGP");
        return;
    }

    // Split into BGP-path-BGP-...
    // where the BGPs may be empty.
    PathBlock pBlk = el.getPattern();
    BasicPattern bgp = new BasicPattern();
    boolean first = true;      // Has anything been output?
    for (TriplePath tp : pBlk) {
        if (tp.isTriple()) {
            bgp.add(tp.asTriple());
            continue;
        }

        if (!bgp.isEmpty()) {
            if (!first) {
                out.println(" .");
            }
            flush(bgp);
            first = false;
        }
        if (!first) {
            out.println(" .");
        }
        // Path
        printSubject(tp.getSubject());
        out.print(" ");
        SPARQLGeneratePathWriter.write(out, tp.getPath(), context);
        out.print(" ");
        printObject(tp.getObject());
        first = false;
    }
    // Flush any stored triple patterns.
    if (!bgp.isEmpty()) {
        if (!first) {
            out.println(" .");
        }
        flush(bgp);
        first = false;
    }
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
private void flush(BasicPattern bgp) {
    formatTriples(bgp);
    bgp.getList().clear();
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
@Override
protected void formatTriples(BasicPattern triples) {
    if (!PRETTY_PRINT) {
        super.formatTriples(triples);
        return;
    }

    // TODO RDF Collections - spot the parsers pattern
    if (triples.isEmpty()) {
        return;
    }

    setWidths(triples);
    if (subjectWidth > TRIPLES_SUBJECT_COLUMN) {
        subjectWidth = TRIPLES_SUBJECT_COLUMN;
    }
    if (predicateWidth > TRIPLES_PROPERTY_COLUMN) {
        predicateWidth = TRIPLES_PROPERTY_COLUMN;
    }

    // Loops:
    List<Triple> subjAcc = new ArrayList<>(); // Accumulate all triples
    // with the same subject.
    Node subj = null; // Subject being accumulated

    boolean first = true; // Print newlines between blocks.

    int indent = -1;
    for (Triple t : triples) {
        if (subj != null && t.getSubject().equals(subj)) {
            subjAcc.add(t);
            continue;
        }

        if (subj != null) {
            if (!first) {
                out.println(" .");
            }
            formatSameSubject(subj, subjAcc);
            first = false;
            // At end of line of a block of triples with same subject.
            // Drop through and start new block of same subject triples.
        }

        // New subject
        subj = t.getSubject();
        subjAcc.clear();
        subjAcc.add(t);
    }

    // Flush accumulator
    if (subj != null && subjAcc.size() != 0) {
        if (!first) {
            out.println(" .");
        }
        first = false;
        formatSameSubject(subj, subjAcc);
    }
}
 

import org.apache.jena.sparql.core.BasicPattern; //导入依赖的package包/类
protected void formatTriples(BasicPattern pattern) {
    SPARQLGenerateFmtUtils.formatPattern(out, pattern, context);
}