@Override public ImmutableFunctionalTerm getImmutableTripleAtom(ImmutableTerm subject, ImmutableTerm predicate, ImmutableTerm object) { return TERM_FACTORY.getImmutableFunctionalTerm(PredicateImpl.QUEST_TRIPLE_PRED, subject, predicate, object); } }
private ImmutableTerm getNestedConcat(String str) { List<ImmutableTerm> terms; terms = addToTermsList(str); if (terms.size() == 1) { return terms.get(0); } ImmutableFunctionalTerm f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, terms.get(0), terms.get(1)); for (int j = 2; j < terms.size(); j++) { f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, f, terms.get(j)); } return f; }
/** * In case the term is functional, creates an immutable copy of it. */ public static ImmutableTerm convertIntoImmutableTerm(Term term) { if (term instanceof Function) { if (term instanceof ImmutableFunctionalTerm) { return (ImmutableTerm) term; } else if (term instanceof Expression) { Expression expression = (Expression) term; return TERM_FACTORY.getImmutableExpression(expression); } else { Function functionalTerm = (Function) term; return TERM_FACTORY.getImmutableFunctionalTerm(functionalTerm); } } /** * Other terms (constant and variable) are immutable. */ return (ImmutableTerm) term; }
/** * Computes one Most General Unifier (MGU) of (two) substitutions. */ public static Optional<ImmutableSubstitution<ImmutableTerm>> computeMGUS(ImmutableSubstitution<? extends ImmutableTerm> substitution1, ImmutableSubstitution<? extends ImmutableTerm> substitution2) { ImmutableList.Builder<ImmutableTerm> firstArgListBuilder = ImmutableList.builder(); ImmutableList.Builder<ImmutableTerm> secondArgListBuilder = ImmutableList.builder(); for (Map.Entry<Variable, ? extends ImmutableTerm> entry : substitution1.getImmutableMap().entrySet()) { firstArgListBuilder.add(entry.getKey()); secondArgListBuilder.add(entry.getValue()); } for (Map.Entry<Variable, ? extends ImmutableTerm> entry : substitution2.getImmutableMap().entrySet()) { firstArgListBuilder.add(entry.getKey()); secondArgListBuilder.add(entry.getValue()); } ImmutableList<ImmutableTerm> firstArgList = firstArgListBuilder.build(); ImmutableList<ImmutableTerm> secondArgList = secondArgListBuilder.build(); Predicate predicate = ATOM_FACTORY.getAtomPredicate(PREDICATE_STR, firstArgList.size()); ImmutableFunctionalTerm functionalTerm1 = TERM_FACTORY.getImmutableFunctionalTerm(predicate, firstArgList); ImmutableFunctionalTerm functionalTerm2 = TERM_FACTORY.getImmutableFunctionalTerm(predicate, secondArgList); return computeMGU(functionalTerm1, functionalTerm2); }
private ImmutableTerm normalizeFunctionalTerm(ImmutableFunctionalTerm functionalTerm) { if (isSupportingNullArguments(functionalTerm)) { return functionalTerm; } ImmutableList<ImmutableTerm> newArguments = functionalTerm.getTerms().stream() .map(arg -> (arg instanceof ImmutableFunctionalTerm) ? normalizeFunctionalTerm((ImmutableFunctionalTerm) arg) : arg) .collect(ImmutableCollectors.toList()); if (newArguments.stream() .anyMatch(arg -> arg.equals(nullValue))) { return nullValue; } return termFactory.getImmutableFunctionalTerm(functionalTerm.getFunctionSymbol(), newArguments); }
private static ImmutableTerm normalizeFunctionalTerm(ImmutableFunctionalTerm functionalTerm) { if (isSupportingNullArguments(functionalTerm)) { return functionalTerm; } ImmutableList<ImmutableTerm> newArguments = functionalTerm.getArguments().stream() .map(arg -> (arg instanceof ImmutableFunctionalTerm) ? normalizeFunctionalTerm((ImmutableFunctionalTerm) arg) : arg) .collect(ImmutableCollectors.toList()); if (newArguments.stream() .anyMatch(arg -> arg.equals(TermConstants.NULL))) { return TermConstants.NULL; } return TERM_FACTORY.getImmutableFunctionalTerm(functionalTerm.getFunctionSymbol(), newArguments); }
private ImmutableTerm createObjectTerm(String column, FunctionSymbol datatype) { ImmutableTerm object; if(column.matches("\"([\\w.]+)?\"")){ object = termFactory.getConstantLiteral(column.substring(1, column.length()-1)); } else { List<FormatString> columnStrings = parse(column); if (columnStrings.size() > 1) { throw new RuntimeException("Unsupported column mapping: " + column); } String columnName = columnStrings.get(0).toString(); object = termFactory.getVariable(columnName); } if (datatype == null) { return object; } else { return termFactory.getImmutableFunctionalTerm(datatype, object); } }
@Override public ImmutableFunctionalTerm applyToFunctionalTerm(ImmutableFunctionalTerm functionalTerm) { if (isEmpty()) return functionalTerm; ImmutableList.Builder<ImmutableTerm> subTermsBuilder = ImmutableList.builder(); for (ImmutableTerm subTerm : functionalTerm.getTerms()) { subTermsBuilder.add(apply(subTerm)); } FunctionSymbol functionSymbol = functionalTerm.getFunctionSymbol(); /* * Distinguishes the BooleanExpression from the other functional terms. */ if (functionSymbol instanceof OperationPredicate) { return termFactory.getImmutableExpression((OperationPredicate) functionSymbol, subTermsBuilder.build()); } else { return termFactory.getImmutableFunctionalTerm(functionSymbol, subTermsBuilder.build()); } }
@Override public ImmutableFunctionalTerm applyToFunctionalTerm(ImmutableFunctionalTerm functionalTerm) { if (isEmpty()) return functionalTerm; ImmutableList.Builder<ImmutableTerm> subTermsBuilder = ImmutableList.builder(); for (ImmutableTerm subTerm : functionalTerm.getArguments()) { subTermsBuilder.add(apply(subTerm)); } Predicate functionSymbol = functionalTerm.getFunctionSymbol(); /** * Distinguishes the BooleanExpression from the other functional terms. */ if (functionSymbol instanceof OperationPredicate) { return TERM_FACTORY.getImmutableExpression((OperationPredicate) functionSymbol, subTermsBuilder.build()); } else { return TERM_FACTORY.getImmutableFunctionalTerm(functionSymbol, subTermsBuilder.build()); } }
return Optional.of(TERM_FACTORY.getImmutableFunctionalTerm(functionalTerm1.getFunctionSymbol(), argumentBuilder.build()));
argumentBuilder.add(newArgument); return Optional.of(termFactory.getImmutableFunctionalTerm(functionalTerm1.getFunctionSymbol(), argumentBuilder.build()));
ImmutableFunctionalTerm f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, terms.get(0), terms.get(1)); for(int j=2;j<terms.size();j++){ f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, f, terms.get(j));
/** * Definition row graph: an RDF graph consisting of the following triples: * * - a reference triple for each <column name list> in a table's foreign keys where none of the column values is NULL. * */ private ImmutableList<ImmutableFunctionalTerm> getRefCQ(ForeignKeyConstraint fk) { ImmutableTerm sub = generateSubject(fk.getRelation(), true); ImmutableTerm obj = generateSubject(fk.getReferencedRelation(), true); ImmutableFunctionalTerm atom = df.getImmutableFunctionalTerm( df.getObjectPropertyPredicate(getReferencePropertyIRI(fk)), sub, obj); return ImmutableList.of(atom); }
? TERM_FACTORY.getImmutableFunctionalTerm(TERM_FACTORY.getClassPredicate(predicateName), m.target.getTerm(0)) : TERM_FACTORY.getImmutableFunctionalTerm(TERM_FACTORY.getObjectPropertyPredicate(predicateName), m.target.getTerm(0), m.target.getTerm(2));
.collect(ImmutableCollectors.toList()); ImmutableTerm newDef = termFactory.getImmutableFunctionalTerm( def.getFunctionSymbol(), newArgs); return Maps.immutableEntry(v, newDef);
/** * 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(); }
/** * In case the term is functional, creates an immutable copy of it. */ public ImmutableTerm convertIntoImmutableTerm(Term term) { if (term instanceof Function) { if (term instanceof Expression) { Expression expression = (Expression) term; return termFactory.getImmutableExpression(expression); } else { Function functionalTerm = (Function) term; if (functionalTerm.getFunctionSymbol() instanceof FunctionSymbol) return termFactory.getImmutableFunctionalTerm( (FunctionSymbol) functionalTerm.getFunctionSymbol(), convertTerms(functionalTerm)); else throw new NotAFunctionSymbolException(term + " is not using a FunctionSymbol but a " + functionalTerm.getFunctionSymbol().getClass()); } } /* * Other terms (constant and variable) are immutable. */ return (ImmutableTerm) term; }
.collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> termFactory.getImmutableFunctionalTerm(IF_ELSE_NULL, newCondition, e.getValue()) )));
.collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> termFactory.getImmutableFunctionalTerm(IF_ELSE_NULL, newCondition, e.getValue()) )));