@Test
  public void economizingTriplesEconomizesTheNodes() {
    Node s1a = Node.createURI("http://example.com/s1");
    Node s1b = Node.createURI("http://example.com/s1");
    Node p1a = Node.createURI("http://example.com/p1");
    Node p1b = Node.createURI("http://example.com/p1");
    Node o1a = Node.createLiteral("55", XSDDatatype.XSDint);
    Node o1b = Node.createLiteral("55", XSDDatatype.XSDint);

    assertTrue(o1a != o1b);

    Triple t1 = new Triple(s1a, p1a, o1a);
    Triple t2 = new Triple(s1b, p1b, o1b);
    assertTrue(t1 != t2);
    assertEquals(t1, t2);

    Economizer<Triple> e = new TripleEconomizer();

    Triple t3 = e.economize(t1);
    Triple t4 = e.economize(t2);

    assertTrue(t3.getSubject() == t4.getSubject());
    assertTrue(t3.getObject() == t4.getObject());
    assertTrue(t3.getPredicate() == t4.getPredicate());

    assertTrue(s1a.equals(t3.getSubject()));
    assertTrue(p1a.equals(t3.getPredicate()));
    assertTrue(o1a.equals(t3.getObject()));
  }
  private static RdfStream getRdfStreamFromResource(final String resourcePath, final Lang lang) {
    final Model model = createDefaultModel();

    RDFDataMgr.read(model, WebACRolesProviderTest.class.getResourceAsStream(resourcePath), lang);

    final List<Triple> triples = new ArrayList<>();
    model
        .listStatements()
        .forEachRemaining(
            x -> {
              final Triple t = x.asTriple();
              if (t.getObject().isURI() && t.getObject().getURI().startsWith(FEDORA_URI_PREFIX)) {
                triples.add(
                    new Triple(
                        t.getSubject(),
                        t.getPredicate(),
                        createURI(
                            FEDORA_PREFIX
                                + t.getObject().getURI().substring(FEDORA_URI_PREFIX.length()))));
              } else {
                triples.add(t);
              }
            });

    return new RdfStream(triples);
  }
Example #3
0
  public SPhraseSpec getNLForTriple2(Triple t) {
    SPhraseSpec p = nlgFactory.createClause();
    // process subject
    if (t.getSubject().isVariable()) {
      p.setSubject(t.getSubject().toString());
    } else {
      p.setSubject(getNPPhrase(t.getSubject().toString(), false));
    }

    // process predicate
    if (t.getPredicate().isVariable()) {
      p.setVerb("be related via " + t.getPredicate().toString() + " to");
    } else {
      p.setVerb(getVerbFrom(t.getPredicate()));
    }

    // process object
    if (t.getObject().isVariable()) {
      p.setObject(t.getObject().toString());
    } else if (t.getObject().isLiteral()) {
      p.setObject(t.getObject().getLiteralLexicalForm());
    } else {
      p.setObject(getNPPhrase(t.getObject().toString(), false));
    }

    p.setFeature(Feature.TENSE, Tense.PRESENT);
    return p;
  }
    /* @see com.hp.hpl.jena.sparql.syntax.ElementVisitorBase#visit(com.hp.hpl.jena.sparql.syntax.ElementTriplesBlock) */
    @Override
    public void visit(final ElementTriplesBlock elementtriplesblock) {
      for (final Triple t : elementtriplesblock.getPattern()) {
        try {
          if (t.getPredicate().isVariable())
            throw new IllegalArgumentException(
                "Variables cannot be used in predicate position in ABoxQuery");

          Atom atom = null;
          final String predURI = t.getPredicate().getURI();
          if (RDF.type.getURI().equals(predURI)) {
            if (t.getObject().isVariable())
              throw new IllegalArgumentException(
                  "Variables cannot be used as objects of rdf:type triples in ABoxQuery");

            final OWLClass c = owlModel.createClass(new URI(t.getObject().getURI()));
            final SWRLIndividualObject arg = makeIndividalObject(t.getSubject());

            atom = swrlFactory.createClassAtom(c, arg);
          } else {
            final OWLProperty p = owlModel.getProperty(new URI(predURI));

            if (p == null)
              throw new IllegalArgumentException(
                  predURI + " is unknown [Object|Datatype]Property in the backing OWL model.");
            else if (p.isDatatypeProperty()) {
              final OWLDataProperty dp = owlModel.createDataProperty(p.getURI());
              final SWRLIndividualObject arg1 = makeIndividalObject(t.getSubject());
              final SWRLDataObject arg2 = makeDataObject(t.getObject());

              atom = swrlFactory.createDataPropertyAtom(dp, arg1, arg2);
            } else if (p.isObjectProperty()) {
              final OWLObjectProperty op = owlModel.createObjectProperty(p.getURI());
              final SWRLIndividualObject arg1 = makeIndividalObject(t.getSubject());
              final SWRLIndividualObject arg2 = makeIndividalObject(t.getObject());

              atom = swrlFactory.createIndividualPropertyAtom(op, arg1, arg2);
            }
            // else it could be a annotation property, which are not relevant anyway
          }

          if (atom != null) atoms = atoms.cons(atom);
        } catch (final URISyntaxException e) {
          throw new IllegalArgumentException(
              e.getInput() + " appearing in the query string is not a valid URI!");
        }
      }
    }
    @Override
    public Op transform(OpQuadPattern quadPattern) {
      Node gNode = quadPattern.getGraphNode();
      Node g = substitute(gNode, binding);

      BasicPattern triples = new BasicPattern();
      for (Triple triple : quadPattern.getBasicPattern()) {
        Node s = substitute(triple.getSubject(), binding);
        Node p = substitute(triple.getPredicate(), binding);
        Node o = substitute(triple.getObject(), binding);
        Triple t = new Triple(s, p, o);
        triples.add(t);
      }

      // Pure quading.
      // for ( Iterator iter = quadPattern.getQuads().iterator() ;
      // iter.hasNext() ; )
      // {
      // Quad quad = (Quad)iter.next() ;
      // if ( ! quad.getGraph().equals(gNode) )
      // throw new
      // ARQInternalErrorException("Internal error: quads block is not uniform over the graph node")
      // ;
      // Node s = substitute(quad.getSubject(), binding) ;
      // Node p = substitute(quad.getPredicate(), binding) ;
      // Node o = substitute(quad.getObject(), binding) ;
      // Triple t = new Triple(s, p, o) ;
      // triples.add(t) ;
      // }

      return new OpQuadPattern(g, triples);
    }
Example #6
0
  /**
   * Returns a collection of RDFStatements that match the described subject
   *
   * @param subject Subject
   * @return collection of RDFStatements
   */
  public Collection<RDFStatement> getStatements(String subject) {

    if (subject == null || subject.isEmpty()) {
      return null;
    }
    List<RDFStatement> statement = null;

    try {
      // define a describe query
      String query = String.format("DESCRIBE %s FROM < %s >", subject, this.graphName);

      logger.debug("Query: \n{}", query);
      Query sparqlQuery = QueryFactory.create(query);
      VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(sparqlQuery, this.graph);
      // execute the query and get the graph
      Model model = vqe.execDescribe();
      Graph queriedGraph = model.getGraph();
      // itreate over the retrieved triples, and place them inside a list
      ExtendedIterator<Triple> iter = queriedGraph.find(Node.ANY, Node.ANY, Node.ANY);
      statement = new ArrayList<>();
      while (iter.hasNext()) {
        Triple t = (Triple) iter.next();
        RDFStatement stmt =
            new RDFStatement(
                t.getSubject().toString(), t.getPredicate().toString(), t.getObject().toString());
        statement.add(stmt);
      }
    } catch (Exception ex) {
      logger.error("Exception occured while querying for statements", ex);
    }
    return statement;
  }
 public static String str(Triple t) {
   return serialize(t.getSubject())
       + " "
       + serialize(t.getPredicate())
       + " "
       + serialize(t.getObject());
 }
Example #8
0
 public OntModel applyRenamings() {
   OntModel result = ModelFactory.createMem();
   Graph graph = result.getGraph();
   Iterator it = model.getGraph().find(Triple.ANY);
   while (it.hasNext()) {
     Triple t = (Triple) it.next();
     Node s = t.getSubject().isURI() ? rename(t.getSubject()) : null;
     Node o = t.getObject().isURI() ? rename(t.getObject()) : null;
     if (s != null || o != null)
       t =
           Triple.create(
               s != null ? s : t.getSubject(), t.getPredicate(), o != null ? o : t.getObject());
     graph.add(t);
   }
   return result;
 }
  public SPDXChecksum(Model spdxModel, Node checksumNode) throws InvalidSPDXAnalysisException {
    this.model = spdxModel;
    this.checksumNode = checksumNode;
    if (checksumNode.isBlank()) {
      checksumResource = model.createResource(checksumNode.getBlankNodeId());
    } else if (checksumNode.isURI()) {
      checksumResource = model.createResource(checksumNode.getURI());
    } else {
      throw (new InvalidSPDXAnalysisException("Checksum node can not be a literal"));
    }
    // Algorithm
    Node p =
        spdxModel
            .getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_ALGORITHM)
            .asNode();
    Triple m = Triple.createMatch(checksumNode, p, null);
    ExtendedIterator<Triple> tripleIter = spdxModel.getGraph().find(m);
    while (tripleIter.hasNext()) {
      Triple t = tripleIter.next();
      if (t.getObject().isLiteral()) {
        // The following is for compatibility with rdf generated with older
        // versions of the tool
        this.algorithm = t.getObject().toString(false);
      } else if (t.getObject().isURI()) {
        this.algorithm = URI_TO_ALGORITHM.get(t.getObject().getURI());
        if (this.algorithm == null) {
          this.algorithm = "UNKNOWN";
        }
      } else {
        throw (new InvalidSPDXAnalysisException(
            "Invalid checksum algorithm - must be one of the defined algorithms supported by SPDX."));
      }
    }

    // value
    p =
        spdxModel
            .getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_VALUE)
            .asNode();
    m = Triple.createMatch(checksumNode, p, null);
    tripleIter = spdxModel.getGraph().find(m);
    while (tripleIter.hasNext()) {
      Triple t = tripleIter.next();
      this.value = t.getObject().toString(false);
    }
  }
Example #10
0
 public static void outputPlain(IndentedWriter out, Triple triple, SerializationContext naming) {
   // No tag
   output(out, triple.getSubject(), naming);
   out.print(" ");
   output(out, triple.getPredicate(), naming);
   out.print(" ");
   output(out, triple.getObject(), naming);
 }
Example #11
0
 protected static String sparqlTriple(Triple triple) {
   StringBuffer serializedTriple = new StringBuffer();
   serializedTriple.append(sparqlNodeUpdate(triple.getSubject(), ""));
   serializedTriple.append(" ");
   serializedTriple.append(sparqlNodeUpdate(triple.getPredicate(), ""));
   serializedTriple.append(" ");
   serializedTriple.append(sparqlNodeUpdate(triple.getObject(), ""));
   serializedTriple.append(" .");
   return serializedTriple.toString();
 }
 @Override
 public void addGraph(Node gn, Graph g) {
   // Convert to quads.
   // super.addGraph(gn, g) ;
   ExtendedIterator<Triple> iter = g.find(Node.ANY, Node.ANY, Node.ANY);
   for (; iter.hasNext(); ) {
     Triple t = iter.next();
     add(gn, t.getSubject(), t.getPredicate(), t.getObject());
   }
 }
Example #13
0
 public DBPattern(Triple pat, Mapping varMap) {
   pattern = pat;
   sources = new ArrayList();
   isBusy = false;
   isConnected = false;
   isStmt = isReif = false;
   S = nodeToElement(pattern.getSubject(), varMap);
   P = nodeToElement(pattern.getPredicate(), varMap);
   O = nodeToElement(pattern.getObject(), varMap);
   Scost = elementCost(S);
   Pcost = elementCost(P);
   Ocost = elementCost(O);
 }
 ReificationStatementMask(Triple t) {
   mask = HasNada;
   Node p = t.getPredicate();
   if (p != null) {
     if (p.equals(RDF.Nodes.subject)) mask = HasSubj;
     else if (p.equals(RDF.Nodes.predicate)) mask = HasPred;
     else if (p.equals(RDF.Nodes.object)) mask = HasObj;
     else if (p.equals(RDF.Nodes.type)) {
       Node o = t.getObject();
       if (o.equals(RDF.Nodes.Statement)) mask = HasType;
     }
   }
 }
  public NTriplesFileLuceneSyntacticIndexCreator(
      InputStream nTriplesStream, String indexPath, String searchField) throws IOException {
    // setup the index
    Directory directory = FSDirectory.open(new File(indexPath));

    // setup the index analyzer
    Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_43);
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_43, analyzer);
    indexWriterConfig.setRAMBufferSizeMB(1024.0);
    indexWriterConfig.setOpenMode(OpenMode.CREATE);
    IndexWriter writer = new IndexWriter(directory, indexWriterConfig);

    System.out.println("Creating index ...");

    // setup the index fields, here two fields, for URI and text
    FieldType stringType = new FieldType(StringField.TYPE_STORED);
    stringType.setStoreTermVectors(false);
    FieldType textType = new FieldType(TextField.TYPE_STORED);
    textType.setStoreTermVectors(false);

    Set<Document> documents = new HashSet<Document>();

    Iterator<Triple> iterator =
        RiotReader.createIteratorTriples(nTriplesStream, Lang.NTRIPLES, null);

    Triple triple;
    String text;
    String uri;
    Document doc;
    int i = 0;
    while (iterator.hasNext()) {
      triple = iterator.next();

      uri = triple.getSubject().getURI();
      text = triple.getObject().getLiteralLexicalForm();

      doc = new Document();
      doc.add(new Field("uri", uri, stringType));
      doc.add(new Field(searchField, text, textType));

      writer.addDocument(doc);
      if (i++ % 10000 == 0) {
        //				writer.commit();
        System.out.println(i);
      }
    }

    writer.commit();
    writer.close();
  }
    /**
     * Return an equivalent triple pattern with standardized variable names (?s, ?p, ?o). This
     * method is needed to ensure that functionally equivalent triple patterns do not get assigned
     * to different entries in the cache.
     *
     * @param triplePattern
     * @return a Triple that is equivalent to triplePattern, but with standard variable names
     */
    protected Triple standardizeVarNames(Triple triplePattern) {
      Node s = triplePattern.getSubject();
      Node p = triplePattern.getPredicate();
      Node o = triplePattern.getObject();

      // make the key consistent, regardless of user's chosen variable names
      if (s.isVariable()) {
        s = NodeCreateUtils.create("?s");
      }
      if (p.isVariable()) {
        p = NodeCreateUtils.create("?p");
      }
      if (o.isVariable()) {
        o = NodeCreateUtils.create("?o");
      }
      return new Triple(s, p, o);
    }
  protected ElementGroup getWhereClauseWithBlankNodeFilter(Triple triplePattern) {

    Node s = triplePattern.getSubject();
    Node o = triplePattern.getObject();

    ElementGroup whereClause = new ElementGroup();
    whereClause.addTriplePattern(triplePattern);
    if (s.isVariable()) {
      whereClause.addElementFilter(
          new ElementFilter(new E_LogicalNot(new E_IsBlank(new ExprVar(s)))));
    }
    if (o.isVariable()) {
      whereClause.addElementFilter(
          new ElementFilter(new E_LogicalNot(new E_IsBlank(new ExprVar(o)))));
    }

    return whereClause;
  }
Example #18
0
 public SPhraseSpec getNLForTriple(Triple t) {
   SPhraseSpec p = nlgFactory.createClause();
   // process predicate then return subject is related to
   if (t.getPredicate().isVariable()) {
     if (t.getSubject().isVariable()) {
       p.setSubject(t.getSubject().toString());
     } else {
       p.setSubject(getNPPhrase(t.getSubject().toString(), false));
     }
     p.setVerb("be related via " + t.getPredicate().toString() + " to");
     if (t.getObject().isVariable()) {
       p.setObject(t.getObject().toString());
     } else {
       p.setObject(getNPPhrase(t.getObject().toString(), false));
     }
   } else {
     NLGElement subj;
     if (t.getSubject().isVariable()) {
       subj = nlgFactory.createWord(t.getSubject().toString(), LexicalCategory.NOUN);
     } else {
       subj =
           nlgFactory.createWord(
               uriConverter.convert(t.getSubject().toString()), LexicalCategory.NOUN);
     }
     //        subj.setFeature(Feature.POSSESSIVE, true);
     //        PhraseElement np = nlgFactory.createNounPhrase(subj,
     // getEnglishLabel(t.getPredicate().toString()));
     p.setSubject(
         realiser.realise(subj) + "\'s " + uriConverter.convert(t.getPredicate().toString()));
     p.setVerb("be");
     if (t.getObject().isVariable()) {
       p.setObject(t.getObject().toString());
     } else if (t.getObject().isLiteral()) {
       p.setObject(t.getObject().getLiteralLexicalForm());
     } else {
       p.setObject(getNPPhrase(t.getObject().toString(), false));
     }
   }
   p.setFeature(Feature.TENSE, Tense.PRESENT);
   return p;
 }
  public static Collection<Node> containerMembers(Graph graph, Node container, Node containerType) {
    if (!isContainer(graph, container, containerType)) return null;

    ExtendedIterator<Triple> iter = graph.find(container, Node.ANY, Node.ANY);

    SortedMap<Integer, Node> triples = new TreeMap<Integer, Node>(order);
    try {
      for (; iter.hasNext(); ) {
        Triple t = iter.next();
        int index = getIndex(t);
        if (index == NOT_FOUND) continue;
        // Insert
        triples.put(new Integer(index), t.getObject());
      }
    } finally {
      iter.close();
    }
    return triples.values();
  }
  public static Triple substitute(Triple triple, Binding binding, int index) {
    if (isNotNeeded(binding)) return triple;

    Node s = triple.getSubject();
    Node p = triple.getPredicate();
    Node o = triple.getObject();

    Node s1 = substitute(s, binding);
    Node p1 = substitute(p, binding);
    Node o1 = substitute(o, binding);

    Triple t = triple;
    s1 = generateCountableNode(index, s, s1);
    p1 = generateCountableNode(index, p, p1);
    o1 = generateCountableNode(index, o, o1);
    t = new Triple(s1, p1, o1);

    return t;
  }
  @Override
  public void delete(Graph g) {
    Model[] model = separateStatementsWithBlankNodes(g);
    deleteModel(model[1] /*statements without blank nodes*/);
    // replace blank nodes in remaining statements with variables

    StringBuffer patternBuff = new StringBuffer();
    Iterator<Triple> tripIt = g.find(null, null, null);
    while (tripIt.hasNext()) {
      Triple t = tripIt.next();
      patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getSubject(), null));
      patternBuff.append(" ");
      patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getPredicate(), null));
      patternBuff.append(" ");
      patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getObject(), null));
      patternBuff.append(" .\n");
    }

    StringBuffer queryBuff = new StringBuffer();
    String graphURI = graph.getGraphURI();
    queryBuff.append(
        "DELETE { " + ((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "") + " \n");
    queryBuff.append(patternBuff);
    if (graphURI != null) {
      queryBuff.append("    } \n");
    }
    queryBuff.append("} WHERE { \n");
    if (graphURI != null) {
      queryBuff.append("    GRAPH <" + graphURI + "> { \n");
    }
    queryBuff.append(patternBuff);
    if (graphURI != null) {
      queryBuff.append("    } \n");
    }
    queryBuff.append("} \n");

    log.debug(queryBuff.toString());

    graph.executeUpdate(queryBuff.toString());
  }
  public List<AlphaResultUnion> calculateAlphaSTG(
      Collection<Triple> triples, AbstractConceptMapping cm) throws Exception {
    List<AlphaResultUnion> alphaResultUnionList = new Vector<AlphaResultUnion>();

    Triple firstTriple = triples.iterator().next();
    Node tpSubject = firstTriple.getSubject();
    SQLLogicalTable alphaSubject = this.calculateAlphaSubject(tpSubject, cm);
    // String logicalTableAlias = cm.getLogicalTableAlias();
    String logicalTableAlias = alphaSubject.getAlias();
    //		if(logicalTableAlias == null || logicalTableAlias.equals("")) {
    //			cm.setLogicalTableAlias(alphaSubject.getAlias());
    //		}

    // mapping projection of corresponding predicates

    for (Triple tp : triples) {
      Node tpPredicate = tp.getPredicate();
      List<SQLJoinTable> alphaPredicateObjects = new Vector<SQLJoinTable>();
      List<SQLLogicalTable> alphaPredicateObjects2 = new Vector<SQLLogicalTable>();
      if (tpPredicate.isURI()) {
        String tpPredicateURI = tpPredicate.getURI();

        Collection<String> mappedClassURIs = cm.getMappedClassURIs();
        boolean processableTriplePattern = true;
        if (tp.getObject().isURI()) {
          String objectURI = tp.getObject().getURI();
          if (RDF.type.getURI().equals(tpPredicateURI) && mappedClassURIs.contains(objectURI)) {
            processableTriplePattern = false;
          }
        }

        if (processableTriplePattern) {
          List<SQLJoinTable> alphaPredicateObjectAux =
              calculateAlphaPredicateObjectSTG(tp, cm, tpPredicateURI, logicalTableAlias);
          if (alphaPredicateObjectAux != null) {
            alphaPredicateObjects.addAll(alphaPredicateObjectAux);
          }

          List<SQLLogicalTable> alphaPredicateObjectAux2 =
              calculateAlphaPredicateObjectSTG2(tp, cm, tpPredicateURI, logicalTableAlias);
          if (alphaPredicateObjectAux2 != null) {
            alphaPredicateObjects2.addAll(alphaPredicateObjectAux2);
          }

          AlphaResult alphaResult =
              new AlphaResult(alphaSubject, alphaPredicateObjects, tpPredicateURI);
          // alphaResult.setAlphaPredicateObjects2(alphaPredicateObjectAux2);

          AlphaResultUnion alphaTP = new AlphaResultUnion(alphaResult);
          alphaResultUnionList.add(alphaTP);
        }
      } else if (tpPredicate.isVariable()) {
        Collection<AbstractPropertyMapping> pms = cm.getPropertyMappings();
        AlphaResultUnion alphaTP = new AlphaResultUnion();
        for (AbstractPropertyMapping pm : pms) {
          String tpPredicateURI = pm.getMappedPredicateName();
          List<SQLJoinTable> alphaPredicateObjectAux =
              calculateAlphaPredicateObjectSTG(tp, cm, tpPredicateURI, logicalTableAlias);
          if (alphaPredicateObjectAux != null) {
            alphaPredicateObjects.addAll(alphaPredicateObjectAux);
          }

          List<SQLLogicalTable> alphaPredicateObjectAux2 =
              calculateAlphaPredicateObjectSTG2(tp, cm, tpPredicateURI, logicalTableAlias);
          if (alphaPredicateObjectAux2 != null) {
            alphaPredicateObjects2.addAll(alphaPredicateObjectAux2);
          }

          AlphaResult alphaResult =
              new AlphaResult(alphaSubject, alphaPredicateObjects, tpPredicateURI);
          // alphaResult.setAlphaPredicateObjects2(alphaPredicateObjectAux2);

          alphaTP.add(alphaResult);
        }

        if (alphaTP != null) {
          alphaResultUnionList.add(alphaTP);
        }

      } else {
        String errorMessage = "Predicate has to be either an URI or a variable";
        throw new QueryTranslationException(errorMessage);
      }
    }

    return alphaResultUnionList;
  }
Example #23
0
 public static void addVarsFromTriple(Collection<Var> acc, Triple t) {
   addVar(acc, t.getSubject());
   addVar(acc, t.getPredicate());
   addVar(acc, t.getObject());
 }
 public static TripleWithHash create(int n, String s) {
   Triple t = triple(s);
   return new TripleWithHash(n, t.getSubject(), t.getPredicate(), t.getObject());
 }
Example #25
0
 /** Delete a triple - return true if it was deleted, false if it didn't exist */
 public boolean delete(Triple triple) {
   return table.deleteRow(triple.getSubject(), triple.getPredicate(), triple.getObject());
 }
Example #26
0
 public boolean add(Triple triple) {
   return table.addRow(triple.getSubject(), triple.getPredicate(), triple.getObject());
 }
 public double match(Triple t) {
   return match(
       Item.createNode(t.getSubject()),
       Item.createNode(t.getPredicate()),
       Item.createNode(t.getObject()));
 }