private ImmutableTerm typeTerm(String text, IRI datatype) { ValueConstant integerConstant = termFactory.getConstantLiteral(text, datatype); return termFactory.getImmutableTypedTerm(integerConstant, datatype); }
@Override public ImmutableTerm visitUntypedStringLiteral(UntypedStringLiteralContext ctx) { LitStringContext lsc = ctx.litString(); ImmutableTerm literal = visitLitString(lsc); LanguageTagContext lc = ctx.languageTag(); if (lc != null) { return termFactory.getImmutableTypedTerm(literal, visitLanguageTag(lc)); } return termFactory.getImmutableTypedTerm(literal, XSD.STRING); }
@Override public ImmutableTerm visitVariableLiteral_2(VariableLiteral_2Context ctx) { Variable var = visitVariable(ctx.variable()); IRI iri = visitIri(ctx.iri()); return termFactory.getImmutableTypedTerm(var, iri); }
@Override public ImmutableTerm visitTypedLiteral(TypedLiteralContext ctx) { ImmutableTerm stringValue = visitLitString(ctx.litString()); IRI iriRef = visitIri(ctx.iri()); return termFactory.getImmutableTypedTerm(stringValue, iriRef); }
@Override public ImmutableTerm visitVariableLiteral_1(VariableLiteral_1Context ctx) { return termFactory.getImmutableTypedTerm(visitVariable(ctx.variable()), visitLanguageTag(ctx.languageTag())); }
return termFactory.getImmutableTypedTerm(uriTemplate, XSD.STRING); case 4://concat ImmutableFunctionalTerm f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, terms.get(0), terms.get(1));
private ImmutableList<TargetAtom> constructTargetQuery(ImmutableFunctionalTerm iriTerm, ObjectRDFType type1, RDFTermType type2) { Variable X = termFactory.getVariable("X"); Variable Y = termFactory.getVariable("Y"); ImmutableFunctionalTerm subjectTerm; if (!type1.isBlankNode()) subjectTerm = termFactory.getImmutableUriTemplate(X); else { subjectTerm = termFactory.getImmutableBNodeTemplate(X); } ImmutableFunctionalTerm objectTerm; if (type2 instanceof ObjectRDFType) { objectTerm = ((ObjectRDFType)type2).isBlankNode() ? termFactory.getImmutableBNodeTemplate(Y) : termFactory.getImmutableUriTemplate(Y); } else { RDFDatatype datatype = (RDFDatatype) type2; if (datatype.getLanguageTag().isPresent()) { LanguageTag languageTag = datatype.getLanguageTag().get(); objectTerm = termFactory.getImmutableTypedTerm(Y, languageTag.getFullString()); } else { objectTerm = termFactory.getImmutableTypedTerm(Y, datatype); } } TargetAtom targetAtom = targetAtomFactory.getTripleTargetAtom(subjectTerm,iriTerm,objectTerm); return ImmutableList.of(targetAtom); }
/** * Definition row graph: an RDF graph consisting of the following triples: * <p/> * - the row type triple. * - a literal triple for each column in a table where the column value is non-NULL. * */ public ImmutableList<TargetAtom> getCQ(DatabaseRelationDefinition table) { ImmutableList.Builder<TargetAtom> atoms = ImmutableList.builder(); //Class Atom ImmutableTerm sub = generateSubject(table, false); atoms.add(getAtom(getTableIRI(table.getID()), sub)); //DataType Atoms for (Attribute att : table.getAttributes()) { // TODO: revisit this RDFDatatype type = (RDFDatatype) att.getTermType(); Variable objV = termFactory.getVariable(att.getID().getName()); ImmutableTerm obj = termFactory.getImmutableTypedTerm(objV, type); atoms.add(getAtom(getLiteralPropertyIRI(att), sub, obj)); } return atoms.build(); }
/** * Definition row graph: an RDF graph consisting of the following triples: * <p/> * - the row type triple. * - a literal triple for each column in a table where the column value is non-NULL. * */ public ImmutableList<ImmutableFunctionalTerm> getCQ(DatabaseRelationDefinition table) { ImmutableList.Builder<ImmutableFunctionalTerm> atoms = ImmutableList.builder(); //Class Atom ImmutableTerm sub = generateSubject(table, false); atoms.add(df.getImmutableFunctionalTerm(df.getClassPredicate(getTableIRI(table.getID())), sub)); //DataType Atoms for (Attribute att : table.getAttributes()) { Predicate.COL_TYPE type = typeMapper.getPredicate(att.getType()); Variable objV = df.getVariable(att.getID().getName()); ImmutableTerm obj = df.getImmutableTypedTerm(objV, type); atoms.add(df.getImmutableFunctionalTerm(df.getDataPropertyPredicate(getLiteralPropertyIRI(att)), sub, obj)); } return atoms.build(); }
objectAtom = termFactory.getImmutableTypedTerm(constantLiteral, lanConstant); objectAtom = termFactory.getImmutableTypedTerm(constantLiteral, type); objectAtom = termFactory.getImmutableTypedTerm(objectAtom, lan); objectAtom = termFactory.getImmutableTypedTerm(objectAtom, type);