/** * Prints the text representation of different terms. */ private static String getDisplayName(ImmutableTerm term, PrefixManager prefixManager) { if (term instanceof ImmutableFunctionalTerm) return displayFunction((ImmutableFunctionalTerm) term, prefixManager); if (term instanceof Variable) return displayVariable((Variable)term); if (term instanceof IRIConstant) return displayURIConstant((Constant)term, prefixManager); if (term instanceof ValueConstant) return displayValueConstant((Constant)term); if (term instanceof BNode) return displayBnode((BNode)term); throw new UnexpectedTermException(term); }
private String printSourceQuery(OBDASQLQuery query) { String sourceString = SourceQueryRenderer.encode(query); String toReturn = convertTabToSpaces(sourceString); return toReturn.replaceAll("\n", "\n\t\t\t"); } private String convertTabToSpaces(String input) {
public Collection<TriplesMap> getTripleMaps() { OBDAMappingTransformer transformer = new OBDAMappingTransformer(rdfFactory); transformer.setOntology(ontology); return splitMappingAxioms(this.ppMappingAxioms).stream() .map(a -> transformer.getTriplesMap(a, prefixmng)) .collect(Collectors.toList()); }
TurtleWriter turtleWriter = new TurtleWriter(); for (Function atom : body) { String subject, predicate, object = ""; String originalString = atom.getFunctionSymbol().toString(); if (isUnary(atom)) { Term subjectTerm = atom.getTerm(0); subject = getDisplayName(subjectTerm, prefixManager); predicate = "a"; object = getAbbreviatedName(originalString, prefixManager, false); if (originalString.equals(object)) { object = "<" + object + ">"; subject = getDisplayName(subjectTerm, prefixManager); Term predicateTerm = atom.getTerm(1); predicate = getDisplayName(predicateTerm, prefixManager); Term objectTerm = atom.getTerm(2); object = getDisplayName(objectTerm, prefixManager); subject = getDisplayName(subjectTerm, prefixManager); predicate = getAbbreviatedName(originalString, prefixManager, false); if (originalString.equals(predicate)) { predicate = "<" + predicate + ">"; object = getDisplayName(objectTerm, prefixManager); turtleWriter.put(subject, predicate, object); return turtleWriter.print();
private static String displayFunction(ImmutableFunctionalTerm function, PrefixManager prefixManager) { Predicate functionSymbol = function.getFunctionSymbol(); String fname = getAbbreviatedName(functionSymbol.toString(), prefixManager, false); if (functionSymbol instanceof DatatypePredicate) return displayDatatypeFunction(function, functionSymbol, fname, prefixManager); if (functionSymbol instanceof URITemplatePredicate) return displayURITemplate(function, prefixManager); if (functionSymbol == ExpressionOperation.CONCAT) return displayConcat(function); if (functionSymbol instanceof BNodePredicate) return displayFunctionalBnode(function); return displayOrdinaryFunction(function, fname, prefixManager); }
/*** * Sets the current mapping to the input. Note, if the current mapping is * set, this means that this dialog is "updating" a mapping, and not * creating a new one. */ public void setMapping(SQLPPTriplesMap mapping) { this.mapping = mapping; cmdInsertMapping.setText("Update"); txtMappingID.setText(mapping.getId()); OBDASQLQuery sourceQuery = mapping.getSourceQuery(); String srcQuery = SourceQueryRenderer.encode(sourceQuery); txtSourceQuery.setText(srcQuery); ImmutableList<TargetAtom> targetQuery = mapping.getTargetAtoms(); String trgQuery = TargetQueryRenderer.encode(targetQuery, prefixManager); txtTargetQuery.setText(trgQuery); } }
public void run(File file) throws Exception { SQLPPMappingToR2RMLConverter writer = new SQLPPMappingToR2RMLConverter(obdaModel.generatePPMapping(), modelManager.getActiveOntology(), obdaModel.getRdfFactory()); writer.write(file); }
public static void getNestedConcats(StringBuilder stb, ImmutableTerm term1, ImmutableTerm term2) { if (term1 instanceof ImmutableFunctionalTerm) { ImmutableFunctionalTerm f = (ImmutableFunctionalTerm) term1; getNestedConcats(stb, f.getTerms().get(0), f.getTerms().get(1)); } else { stb.append(appendTerms(term1)); } if (term2 instanceof ImmutableFunctionalTerm) { ImmutableFunctionalTerm f = (ImmutableFunctionalTerm) term2; getNestedConcats(stb, f.getTerms().get(0), f.getTerms().get(1)); } else { stb.append(appendTerms(term2)); } }
/** * the method to write the R2RML mappings * from an rdf Model to a file * * @param file the ttl file to write to */ public void write(File file) throws Exception { try { FileOutputStream fos = new FileOutputStream(file); write(fos); } catch (Exception e) { e.printStackTrace(); throw e; } }
private ImmutableSet<SQLPPTriplesMap> splitMappingAxioms(List<SQLPPTriplesMap> mappingAxioms) { /* * Delimiter string d used for assigning ids to split mapping axioms. * If a mapping axiom with id j is split into multiple ones, * each of then will have "j"+"d"+int as an identifier */ String delimiterSubstring = getSplitMappingAxiomIdDelimiterSubstring(mappingAxioms); return mappingAxioms.stream() .flatMap(m -> splitMappingAxiom(m, delimiterSubstring).stream()) .collect(ImmutableCollectors.toSet()); }
private static String displayConcat(ImmutableFunctionalTerm function) { StringBuilder sb = new StringBuilder(); ImmutableList<? extends ImmutableTerm> terms = function.getTerms(); sb.append("\""); getNestedConcats(sb, terms.get(0), terms.get(1)); sb.append("\""); return sb.toString(); }
private String printTargetQuery(ImmutableList<TargetAtom> query) { return TargetQueryRenderer.encode(query, ppMapping.getMetadata().getPrefixManager()); }
private static String displayOrdinaryFunction(ImmutableFunctionalTerm function, String fname, PrefixManager prefixManager) { StringBuilder sb = new StringBuilder(); sb.append(fname); sb.append("("); boolean separator = false; for (ImmutableTerm innerTerm : function.getTerms()) { if (separator) { sb.append(", "); } sb.append(getDisplayName(innerTerm, prefixManager)); separator = true; } sb.append(")"); return sb.toString(); }
/** * Adding the subject, predicate and object components to this container. * * @param subject * The subject term of the Function. * @param predicate * The Function predicate. * @param object * The object term of the Function. */ void put(String subject, String predicate, String object) { // Subject to Predicates map ArrayList<String> predicateList = subjectToPredicates.get(subject); if (predicateList == null) { predicateList = new ArrayList<String>(); } insert(predicateList, predicate); subjectToPredicates.put(subject, predicateList); // Predicate to Objects map ArrayList<String> objectList = predicateToObjects.get(predicate + "_" + subject); // predicate that appears in 2 different subjects should not have all objects assigned to both subjects if (objectList == null) { objectList = new ArrayList<String>(); } objectList.add(object); predicateToObjects.put(predicate + "_" + subject, objectList); }
private static String displayURIConstant(Term term, PrefixManager prefixManager) { StringBuilder sb = new StringBuilder(); String originalUri = term.toString(); String shortenUri = getAbbreviatedName(originalUri, prefixManager, false); // shorten the URI if possible if (!shortenUri.equals(originalUri)) { sb.append(shortenUri); } else { // If the URI can't be shorten then use the full URI within brackets sb.append("<"); sb.append(originalUri); sb.append(">"); } return sb.toString(); }
TurtleWriter turtleWriter = new TurtleWriter(); for (TargetAtom atom : body) { String subject, predicate, object = ""; String originalString = atom.getProjectionAtom().getPredicate().toString(); if (isUnary(atom.getProjectionAtom())) { ImmutableTerm subjectTerm = atom.getSubstitutedTerm(0); subject = getDisplayName(subjectTerm, prefixManager); predicate = "a"; object = getAbbreviatedName(originalString, prefixManager, false); if (originalString.equals(object)) { object = "<" + object + ">"; subject = getDisplayName(subjectTerm, prefixManager); ImmutableTerm predicateTerm = atom.getSubstitutedTerm(1); predicate = getDisplayName(predicateTerm, prefixManager); ImmutableTerm objectTerm = atom.getSubstitutedTerm(2); object = getDisplayName(objectTerm, prefixManager); subject = getDisplayName(subjectTerm, prefixManager); predicate = getAbbreviatedName(originalString, prefixManager, false); if (originalString.equals(predicate)) { predicate = "<" + predicate + ">"; object = getDisplayName(objectTerm, prefixManager); turtleWriter.put(subject, predicate, object); return turtleWriter.print();
private void prepareTextPanes(SQLPPTriplesMap value, boolean selected) { ImmutableList<TargetAtom> targetQuery = value.getTargetAtoms(); String trgQuery = TargetQueryRenderer.encode(targetQuery, prefixManager); trgQueryTextPane.setText(trgQuery); String srcQuery = SourceQueryRenderer.encode(sourceQuery); srcQueryTextPane.setText(srcQuery);
public static void getNestedConcats(StringBuilder stb, Term term1, Term term2){ if (term1 instanceof Function){ Function f = (Function) term1; getNestedConcats(stb, f.getTerms().get(0), f.getTerms().get(1)); }else{ stb.append(appendTerms(term1)); } if (term2 instanceof Function){ Function f = (Function) term2; getNestedConcats(stb, f.getTerms().get(0), f.getTerms().get(1)); }else{ stb.append(appendTerms(term2)); } }
private static String displayDatatypeFunction(ImmutableFunctionalTerm function, Predicate functionSymbol, String fname, PrefixManager prefixManager) { StringBuilder sb = new StringBuilder(); // Language tag case if (functionSymbol.getName().equals(RDF.LANGSTRING.getIRIString())) { // with the language tag ImmutableTerm var = function.getTerms().get(0); ImmutableTerm lang = function.getTerms().get(1); sb.append(getDisplayName(var, prefixManager)); sb.append("@"); if (lang instanceof ValueConstant) { // Don't pass this to getDisplayName() because // language constant is not written as @"lang-tag" sb.append(((ValueConstant) lang).getValue()); } else { sb.append(getDisplayName(lang, prefixManager)); } } else { // for the other data types ImmutableTerm var = function.getTerms().get(0); sb.append(getDisplayName(var, prefixManager)); sb.append("^^"); sb.append(fname); } return sb.toString(); }
/** * Adding the subject, predicate and object components to this container. * * @param subject * The subject term of the Function. * @param predicate * The Function predicate. * @param object * The object term of the Function. */ void put(String subject, String predicate, String object) { // Subject to Predicates map ArrayList<String> predicateList = subjectToPredicates.get(subject); if (predicateList == null) { predicateList = new ArrayList<String>(); } insert(predicateList, predicate); subjectToPredicates.put(subject, predicateList); // Predicate to Objects map ArrayList<String> objectList = predicateToObjects.get(predicate + "_" + subject); // predicate that appears in 2 different subjects should not have all objects assigned to both subjects if (objectList == null) { objectList = new ArrayList<String>(); } objectList.add(object); predicateToObjects.put(predicate + "_" + subject, objectList); }