Package edu.isi.karma.kr2rml.template

Examples of edu.isi.karma.kr2rml.template.TemplateTermSet

537
538
539
540
541
542
543
544
545
546
547
548
549
550
              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());
                }
              }
View Full Code Here
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
          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
50
51
52
53
54
55
56
57
58
59
60
   
    this.pom = pom;
    combinedSubjectObjectTermsToPaths = new HashMap<ColumnTemplateTerm, HNodePath>();
    combinedSubjectObjectTermsToPaths.putAll(subjectTermsToPaths);
    this.isLiteral = true;
    TemplateTermSet literalTemplate = pom.getObject().getRdfLiteralType();
    literalTemplateValue = null;
    if(literalTemplate != null)
    {
      literalTemplateValue = generateStringValueForTemplate(literalTemplate);
    }
View Full Code Here
65
66
67
68
69
70
71
72
73
74
75
  }
 
  public void generateLiteral(TemplateTermSet subjectMapTemplate, PredicateObjectMap pom, Map<ColumnTemplateTerm, HNodePath> subjectTermsToPaths) throws HNodeNotFoundKarmaException
  {
    this.isLiteral = true;
    TemplateTermSet literalTemplate = pom.getObject().getRdfLiteralType();
    literalTemplateValue = null;
    if(literalTemplate != null)
    {
      literalTemplateValue = generateStringValueForTemplate(literalTemplate);
    }
View Full Code Here
127
128
129
130
131
132
133
134
135
136
137
138
    for (TemplateTermSet typeTerm:triplesMap.getSubject().getRdfsType()) {
     
      PredicateObjectMap pom = new PredicateObjectMap(Prefixes.KARMA_DEV + PredicateObjectMap.getNewId(),triplesMap);
      pom.setObject(new ObjectMap(factory.getNewId("objectmap"), typeTerm, null));
      Predicate typePredicate = new Predicate(factory.getNewId("predicate"));
      TemplateTermSet typeTemplate = new TemplateTermSet();
      typeTemplate.addTemplateTermToSet(new StringTemplateTerm(Uris.RDF_TYPE_URI));
      typePredicate.setTemplate(typeTemplate);
      pom.setPredicate(typePredicate);
      PredicateObjectMappingPlan pomPlan = new ColumnPredicateObjectMappingPlan(subjectMapPlan.getTemplate(), pom, subjectMapPlan.getSubjectTermsToPaths(), kr2rmlMapping,uriFormatter, factory, translator, hNodeToContextUriMap, generateContext, selection);
      columnLinksPlans.add(pomPlan);
    }
View Full Code Here
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
          }
        } else {
          NodeIterator objMapColStmts = model.listObjectsOfProperty(objNode, columnProp);
          // RDF Literal Type
          Statement objMapRdfLiteralTypeStmt = model.getProperty(objNode, rdfLiteralTypeProp);
          TemplateTermSet rdfLiteralTypeTermSet = null;
          if (objMapRdfLiteralTypeStmt != null && objMapRdfLiteralTypeStmt.getObject().isLiteral()) {
            StringTemplateTerm rdfLiteralTypeTerm =
                new StringTemplateTerm(objMapRdfLiteralTypeStmt.getObject().toString(), true);
            rdfLiteralTypeTermSet = new TemplateTermSet();
            rdfLiteralTypeTermSet.addTemplateTermToSet(rdfLiteralTypeTerm);
          }
          while (objMapColStmts.hasNext()) {
            RDFNode colNode = objMapColStmts.next();
            objMap = new ObjectMap(getNewObjectMapId(objectMapCounter++),
                TemplateTermSetBuilder.constructTemplateTermSetFromR2rmlColumnString(
                    colNode.toString(), formatter), rdfLiteralTypeTermSet);
          }
          if(objMap == null)
          {
            NodeIterator templateItr = model.listObjectsOfProperty(objNode, templateProp);
            //try a literal/constant node
            if(templateItr == null ||  !templateItr.hasNext()){
              templateItr = model.listObjectsOfProperty(objNode, constantProp);
            }
            TemplateTermSet objTemplTermSet = null;
            while (templateItr.hasNext()) {
              RDFNode templNode = templateItr.next();
              String template = templNode.toString();
              boolean isUri = !templNode.isLiteral();
              objTemplTermSet = TemplateTermSetBuilder.constructTemplateTermSetFromR2rmlTemplateString(
                template, isUri, kr2rmlMapping.getColumnNameFormatter());
           
            }
            objMap = new ObjectMap(getNewObjectMapId(objectMapCounter++),
                objTemplTermSet, rdfLiteralTypeTermSet);
          }
          // Check if anything needs to be added to the columnNameToPredicateObjectMap Map
          if(objMap != null)
            addColumnNameToPredObjectMapLink(objMap, pom, kr2rmlMapping);
        }
      }
      pom.setObject(objMap);
      trMap.addPredicateObjectMap(pom);
    }
   
 
    // Try to add template to pom
      TemplateTermSet subjTemplTermSet = trMap.getSubject().getTemplate();
      if(subjTemplTermSet != null)
      {
        List<TemplateTerm> terms = subjTemplTermSet.getAllTerms();
        if(isValidTemplate(terms))
        {
          PredicateObjectMap pom = new PredicateObjectMap(PredicateObjectMap.getNewId(),trMap);
          Predicate pred = new Predicate(Uris.CLASS_INSTANCE_LINK_URI + "-" + predicateIdCounter++);
          pred.getTemplate().addTemplateTermToSet(
              new StringTemplateTerm(Uris.CLASS_INSTANCE_LINK_URI, true));
          pom.setPredicate(pred);
          StringTemplateTerm rdfLiteralTypeTerm = new StringTemplateTerm("", true);
          TemplateTermSet rdfLiteralTypeTermSet = new TemplateTermSet();
          rdfLiteralTypeTermSet.addTemplateTermToSet(rdfLiteralTypeTerm);
          ObjectMap objMap = new ObjectMap(getNewObjectMapId(objectMapCounter++),
              subjTemplTermSet, rdfLiteralTypeTermSet);
          pom.setObject(objMap);
          trMap.addPredicateObjectMap(pom);
          addColumnNameToPredObjectMapLink(objMap, pom, kr2rmlMapping);
View Full Code Here
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
    }
    return false;
  }
 
  private void addColumnNameToPredObjectMapLink(ObjectMap objMap, PredicateObjectMap pom, KR2RMLMapping kr2rmlMapping) {
    TemplateTermSet objTermSet = objMap.getTemplate();
    if(objTermSet == null)
    {
      logger.error("No matching object term set");
      return;
    }
    for (TemplateTerm term:objTermSet.getAllTerms()) {
      if (term instanceof ColumnTemplateTerm) {
        String columnName = term.getTemplateTermValue();
        String columnNameWithoutFormatting = kr2rmlMapping.getColumnNameFormatter().getColumnNameWithoutFormatting(columnName);
        List<PredicateObjectMap> existingPomList = kr2rmlMapping.getAuxInfo().
            getColumnNameToPredObjLinks().get(columnNameWithoutFormatting); 
View Full Code Here
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
      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);
        }
      }
View Full Code Here
29
30
31
32
33
34
35
  protected TemplateTermSet template;
 
  public TermMap(String id) {
    super();
    this.id = id;
    this.template = new TemplateTermSet();
  }
View Full Code Here
54
55
56
57
58
59
60
61
62
63
64
    this.kr2rmlMapping = kr2rmlMapping;
    this.translator = translator;
    this.selection = sel;
  }
  protected TemplateTermSetPopulator generateTemplateTermSetPopulatorForSubjectMap(SubjectMap subjMap) throws HNodeNotFoundKarmaException {
    TemplateTermSet subjMapTemplate = null;
    TemplateTermSetPopulator subjectMapTTSPopulator = null;
    if (subjMap.isBlankNode()) {
      List<String> columnsCovered  = kr2rmlMapping.getAuxInfo().getBlankNodesColumnCoverage().get(subjMap.getId());
      subjMapTemplate = generateSubjectMapTemplateForBlankNode(subjMap, columnsCovered); 
      subjectMapTTSPopulator = new TemplateTermSetPopulator(subjMapTemplate, new StringBuilder(), uriFormatter, true, false);
View Full Code Here
TOP

Related Classes of edu.isi.karma.kr2rml.template.TemplateTermSet

  • edu.isi.karma.kr2rml.KR2RMLMappingWriter
  • edu.isi.karma.kr2rml.mapping.KR2RMLMappingGenerator
  • edu.isi.karma.kr2rml.mapping.WorksheetR2RMLJenaModelParser
  • edu.isi.karma.kr2rml.planning.ColumnPredicateObjectMappingPlan
  • edu.isi.karma.kr2rml.planning.ConstantPredicateObjectMappingPlan
  • edu.isi.karma.kr2rml.planning.MapPlan
  • edu.isi.karma.kr2rml.planning.TriplesMapWorkerPlan
  • edu.isi.karma.kr2rml.SubjectMap
  • edu.isi.karma.kr2rml.TermMap
  • edu.isi.karma.rep.HNode
    • 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.