Package edu.isi.karma.kr2rml

Examples of edu.isi.karma.kr2rml.SubjectMap


  private void calculateColumnNodesCoveredByBlankNodes() throws KarmaException {
    DisplayModel dm = new DisplayModel(alignmentGraph);
   
    for (Node treeNode:alignmentGraph.vertexSet()) {
      if (treeNode instanceof InternalNode && r2rmlMapping.getSubjectMapIndex().containsKey(treeNode.getId())) {
        SubjectMap subjMap = r2rmlMapping.getSubjectMapIndex().get(treeNode.getId());
       
        if (subjMap.isBlankNode()) {
          List<String> columnsCovered = new ArrayList<String>();
          Set<LabeledLink> links = dm.getOutgoingEdgesOf(treeNode);
          Iterator<LabeledLink> linkIterator = links.iterator();
          while(linkIterator.hasNext())
          {
View Full Code Here


  private void createTripleMaps() {
    Set<Node> nodes = alignmentGraph.vertexSet();
    for (Node node:nodes) {
      if (node instanceof InternalNode) {
        // Create a TriplesMap corresponding to the Internal node
        SubjectMap subjMap = r2rmlMapping.getSubjectMapIndex().get(node.getId());
        TriplesMap trMap = new TriplesMap(TriplesMap.getNewId(), subjMap);
        r2rmlMapping.getTriplesMapIndex().put(node.getId(), trMap);
        this.r2rmlMapping.addTriplesMap(trMap);
        r2rmlMapping.getAuxInfo().getTriplesMapGraph().addTriplesMap(trMap);
      }
View Full Code Here

  private void createSubjectMaps() {
    Set<Node> nodes = alignmentGraph.vertexSet();
    for (Node node:nodes) {
      if (node instanceof InternalNode) {
        SubjectMap subj = new SubjectMap(node.getId());
       
        if (node.getId().equals(steinerTreeRoot.getId()))
          subj.setAsSteinerTreeRootNode(true);
       
        // Add the user provided namespace as the first template term
        subj.getTemplate().addTemplateTermToSet(new StringTemplateTerm(sourceNamespace));
        StringTemplateTerm typeTerm = new StringTemplateTerm(node.getLabel().getUri(), true);
        TemplateTermSet typeTermSet = new TemplateTermSet();
        typeTermSet.addTemplateTermToSet(typeTerm);
        subj.addRdfsType(typeTermSet);
        r2rmlMapping.getSubjectMapIndex().put(node.getId(), subj);
       

        Set<LabeledLink> outgoingLinks = alignmentGraph.outgoingEdgesOf(node);
        for (LabeledLink link:outgoingLinks) {
         
          if (link instanceof ClassInstanceLink || link instanceof ColumnSubClassLink) {
            Node tNode = link.getTarget();
            if (tNode instanceof ColumnNode) {
              ColumnNode cnode = (ColumnNode) tNode;
              String hNodeId = cnode.getHNodeId();
              String columnName = translator.getColumnNameForHNodeId(hNodeId);
              ColumnTemplateTerm cnTerm = new ColumnTemplateTerm(columnName);
             
              // Identify classInstance links to set the template
              if (link instanceof ClassInstanceLink) {
               
                TemplateTermSet tts = expandColumnTemplateTermForPyTransforms(
                   hNodeId, cnTerm);
                subj.setTemplate(tts);
              }
             
              // Identify the isSubclassOfClass links to set the correct type
              else if (link instanceof ColumnSubClassLink) {
                TemplateTermSet typeTermSet2 = new TemplateTermSet();
                typeTermSet2.addTemplateTermToSet(cnTerm);
                subj.addRdfsType(typeTermSet2);
              }
             
              List<String> columnsCovered = new LinkedList<String>();
              for(TemplateTerm term : subj.getTemplate().getAllColumnNameTermElements())
              {
                columnsCovered.add(term.getTemplateTermValue());
              }
              r2rmlMapping.getAuxInfo().getSubjectMapIdToTemplateAnchor().put(subj.getId(), KR2RMLMappingAuxillaryInformation.findSubjectMapTemplateAnchor(columnsCovered));
            } else {
              logger.error("Target node of Class Instance link should always be a " +
                  "column node.");
            }
          }
        }
      } else if(node instanceof LiteralNode) {
        LiteralNode literalNode = (LiteralNode)node;
       
        SubjectMap subj = new SubjectMap(literalNode.getId());
       
        if (literalNode.getId().equals(steinerTreeRoot.getId()))
          subj.setAsSteinerTreeRootNode(true);
       
        StringTemplateTerm typeTerm = new StringTemplateTerm(literalNode.getLabel().getUri(), true);
        TemplateTermSet typeTermSet = new TemplateTermSet();
        typeTermSet.addTemplateTermToSet(typeTerm);
        subj.addRdfsType(typeTermSet);
       
        TemplateTermSet templateTermSet = new TemplateTermSet();
        StringTemplateTerm tempTerm = new StringTemplateTerm(literalNode.getValue(), literalNode.isUri());
        templateTermSet.addTemplateTermToSet(tempTerm);
        subj.setTemplate(templateTermSet);
       
        r2rmlMapping.getSubjectMapIndex().put(node.getId(), subj);
      }
    }
  }
View Full Code Here

  private void createPredicateObjectMaps(boolean generateInverse) {
    Set<Node> nodes = alignmentGraph.vertexSet();
    for (Node node:nodes) {
      if (node instanceof InternalNode) {
        // Create a TriplesMap corresponding to the Internal node
        SubjectMap subjMap = r2rmlMapping.getSubjectMapIndex().get(node.getId());
        TriplesMap subjTrMap = r2rmlMapping.getTriplesMapIndex().get(node.getId());
       
        // Create the predicate object map for each outgoing link
        Set<LabeledLink> outgoingEdges = alignmentGraph.outgoingEdgesOf(node);
        for (LabeledLink olink:outgoingEdges) {
View Full Code Here

   
    // Get all the triple maps
    NodeIterator trMapsResItr = model.listObjectsOfProperty(mappingResource, hasTrMapUri);
    while (trMapsResItr.hasNext()) {
      Resource trMapRes = trMapsResItr.next().asResource();
      SubjectMap subjMap = addSubjectMapForTripleMap(trMapRes, kr2rmlMapping, subjectMapResources);
     
      // Add the Triples map
      TriplesMap trMap = new TriplesMap(trMapRes.getURI(), subjMap);
      kr2rmlMapping.getTriplesMapIndex().put(trMapRes.getURI(), trMap);
      kr2rmlMapping.addTriplesMap(trMap);
View Full Code Here

  private String getNewObjectMapId(int objectMapCounter) {
    return "ObjectMap" + objectMapCounter;
  }

  private SubjectMap addSubjectMapForTripleMap(Resource trMapRes, KR2RMLMapping kr2rmlMapping, List<Resource> subjectMapResources) throws  JSONException {
    SubjectMap subjMap = null;
    Property subjMapProp = model.getProperty(Uris.RR_SUBJECTMAP_URI);
    Property templateProp = model.getProperty(Uris.RR_TEMPLATE_URI);
    Property rdfTypeProp = model.getProperty(Uris.RDF_TYPE_URI);
    Property rrClassProp = model.getProperty(Uris.RR_CLASS_URI);
    Resource steinerTreeRootNodeRes = model.getResource(Uris.KM_STEINER_TREE_ROOT_NODE);
   
    NodeIterator subjMapsItr = model.listObjectsOfProperty(trMapRes, subjMapProp);
    while (subjMapsItr.hasNext()){
      Resource subjMapBlankRes = subjMapsItr.next().asResource();
      subjectMapResources.add(subjMapBlankRes);
     
      String subjMapId = subjMapBlankRes.getId().getLabelString();
      subjMap = new SubjectMap(subjMapId);
      kr2rmlMapping.getSubjectMapIndex().put(subjMapId, subjMap);
     
      // Get the subject template
      NodeIterator templateItr = model.listObjectsOfProperty(subjMapBlankRes, templateProp);
      TemplateTermSet subjTemplTermSet = null;
      while (templateItr.hasNext()) {
        RDFNode templNode = templateItr.next();
        String template = templNode.toString();
        subjTemplTermSet = TemplateTermSetBuilder.constructTemplateTermSetFromR2rmlTemplateString(
            template, kr2rmlMapping.getColumnNameFormatter());
        List<String> columnsCovered = new LinkedList<String>();
        for(TemplateTerm term : subjTemplTermSet.getAllColumnNameTermElements())
        {
          columnsCovered.add(term.getTemplateTermValue());
        }
        kr2rmlMapping.getAuxInfo().getSubjectMapIdToTemplateAnchor().put(subjMap.getId(), KR2RMLMappingAuxillaryInformation.findSubjectMapTemplateAnchor(columnsCovered));
       
      }
      subjMap.setTemplate(subjTemplTermSet);
     
      // Get the subject type
      NodeIterator rdfTypesItr = model.listObjectsOfProperty(subjMapBlankRes, rrClassProp);
      while (rdfTypesItr.hasNext()) {
        RDFNode typeNode = rdfTypesItr.next();
       
        if (typeNode.isAnon()) {
          NodeIterator typeTemplItr = model.listObjectsOfProperty(typeNode.asResource(),
              templateProp);
         
          while (typeTemplItr.hasNext()) {
            RDFNode templNode = typeTemplItr.next();
            String template = templNode.toString();
            TemplateTermSet typeTermSet = TemplateTermSetBuilder.
                constructTemplateTermSetFromR2rmlTemplateString(
                template);
            subjMap.addRdfsType(typeTermSet);
          }
          continue;
        }
       
        if (typeNode instanceof Resource) {
          // Skip the steiner tree root type
          if(((Resource) typeNode).getURI().equals(Uris.KM_STEINER_TREE_ROOT_NODE))
            continue;
         
          StringTemplateTerm uriTerm = new StringTemplateTerm(
              ((Resource) typeNode).getURI(), true);
          TemplateTermSet typeTermSet = new TemplateTermSet();
          typeTermSet.addTemplateTermToSet(uriTerm);
          subjMap.addRdfsType(typeTermSet);
        } else {
          TemplateTermSet typeTermSet = TemplateTermSetBuilder.
              constructTemplateTermSetFromR2rmlTemplateString(
              typeNode.toString());
          subjMap.addRdfsType(typeTermSet);
        }
      }
     
      // Check if it is as the Steiner tree root node
      if (model.contains(subjMapBlankRes, rdfTypeProp, steinerTreeRootNodeRes)) {
        subjMap.setAsSteinerTreeRootNode(true);
      }
    }
    return subjMap;
  }
View Full Code Here

     
      if (model.contains(subjMapRes, termTypeProp, blankNodeRes)) {
        List<String> columnsCovered = new ArrayList<String>();
        Resource blankNodeSubjRes = blankNodeSubjMapItr.next();
       
        SubjectMap subjMap = kr2rmlMapping.getSubjectMapIndex().get(blankNodeSubjRes.getId().getLabelString());
        subjMap.setAsBlankNode(true);
        NodeIterator bnodePrefixItr = model.listObjectsOfProperty(blankNodeSubjRes, kmBnodePrefixProp);
        while (bnodePrefixItr.hasNext()) {
          kr2rmlMapping.getAuxInfo().getBlankNodesUriPrefixMap().put(subjMap.getId(),
              bnodePrefixItr.next().toString());
        }
       
        TriplesMap mytm = null;
        for(TriplesMap tm : kr2rmlMapping.getTriplesMapList())
        {
          if(tm.getSubject().getId().equalsIgnoreCase(subjMap.getId()))
          {
            mytm = tm;
           
            List<PredicateObjectMap> poms = mytm.getPredicateObjectMaps();
            for(PredicateObjectMap pom : poms )
            {
              ObjectMap objMap = pom.getObject();
              if(objMap == null)
              {
                logger.error("Unable to find object map for pom :" + pom.toString());
              }
               
              TemplateTermSet templateTermSet = pom.getObject().getTemplate();
              if(templateTermSet != null)
              {
                TemplateTerm term = templateTermSet.getAllTerms().get(0);
                if(term!= null && term instanceof ColumnTemplateTerm)
                {
                  columnsCovered.add(term.getTemplateTermValue());
                }
              }
            }
           
            if(columnsCovered.isEmpty())
            {
              //String blankNodeUriPrefix = kr2rmlMapping.getAuxInfo().getBlankNodesUriPrefixMap().get(subjMap.getId());
              //throw new KarmaException("You need to define a URI for "+blankNodeUriPrefix+ ".");
            }
            break;
          }
        }
   
        logger.debug("Adding columns for blank node" + subjMap.getId() + " List: " +
            columnsCovered);
        kr2rmlMapping.getAuxInfo().getBlankNodesColumnCoverage().put(subjMap.getId(), columnsCovered);
        kr2rmlMapping.getAuxInfo().getSubjectMapIdToTemplateAnchor().put(subjMap.getId(), KR2RMLMappingAuxillaryInformation.findSubjectMapTemplateAnchor(columnsCovered));
        // Get the blank node prefix
       
      }
    }
  }
View Full Code Here

    configureSubjectMapPlan(triplesMap);
  }
  public SubjectMap configureSubjectMapPlan(TriplesMap triplesMap)
      throws HNodeNotFoundKarmaException {
    subjectTermsToPaths = new HashMap<ColumnTemplateTerm, HNodePath>();
    SubjectMap subjMap = triplesMap.getSubject();
    subjectMapTTSPopulator = generateTemplateTermSetPopulatorForSubjectMap(subjMap);
    populateTermsToPathForSubject(subjectTermsToPaths, subjectMapTTSPopulator.getTerms());
    subjectPlan = new TemplateTermSetPopulatorPlan(subjectTermsToPaths, subjectTermsToPaths.keySet(), selection);
    return subjMap;
  }
View Full Code Here

TOP

Related Classes of edu.isi.karma.kr2rml.SubjectMap

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.