it.unibz.inf.ontop.model.term

Interface TermFactory

All Known Implementing Classes:

TermFactoryImpl

public interface TermFactory

Accessible through Guice (recommended) or through CoreSingletons.

Method Summary

Modifier and Type	Method and Description
VariableNullability	createDummyVariableNullability(ImmutableFunctionalTerm functionalTerm)
ImmutableExpression	getAreCompatibleRDFStringExpression(ImmutableTerm typeTerm1, ImmutableTerm typeTerm2) See https://www.w3.org/TR/sparql11-query/#func-arg-compatibility
ImmutableFunctionalTerm	getBinaryNumericLexicalFunctionalTerm(String dbNumericOperationName, ImmutableTerm lexicalTerm1, ImmutableTerm lexicalTerm2, ImmutableTerm rdfTypeTerm) TODO: find a better name
ImmutableFunctionalTerm	getBnodeFunctionalTerm(String bnodeTemplate, com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments)
ImmutableExpression	getBooleanIfElseNull(ImmutableExpression condition, ImmutableExpression thenExpression)
ImmutableFunctionalTerm	getCommonDenominatorFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableTerm> typeTerms)
ImmutableFunctionalTerm	getCommonPropagatedOrSubstitutedNumericType(ImmutableTerm rdfTypeTerm1, ImmutableTerm rdfTypeTerm2)
ImmutableExpression	getConjunction(ImmutableExpression expression, ImmutableExpression... otherExpressions) Does NOT take care of flattening conjunctions in the arguments
ImmutableExpression	getConjunction(com.google.common.collect.ImmutableList<ImmutableExpression> nonEmptyExpressionList) Must be non-empty Does NOT take care of flattening conjunctions in the arguments
Optional<ImmutableExpression>	getConjunction(Stream<ImmutableExpression> expressionStream) May be empty.
BNode	getConstantBNode(String name)
IRIConstant	getConstantIRI(org.apache.commons.rdf.api.IRI iri) Construct a IRIConstant object.
ImmutableFunctionalTerm	getConversion2RDFLexical(DBTermType inputType, ImmutableTerm term, RDFTermType rdfTermType) May "normalize"
ImmutableFunctionalTerm	getConversion2RDFLexical(ImmutableTerm term, RDFTermType rdfTermType)
ImmutableFunctionalTerm	getConversionFromRDFLexical2DB(DBTermType targetDBType, ImmutableTerm dbTerm, RDFTermType rdfType) May "denormalize"
ImmutableFunctionalTerm	getConversionFromRDFLexical2DB(ImmutableTerm dbTerm, RDFTermType rdfType)
ImmutableFunctionalTerm	getDBAvg(ImmutableTerm subTerm, DBTermType dbType, boolean isDistinct)
ImmutableFunctionalTerm	getDBBinaryNumericFunctionalTerm(String dbNumericOperationName, DBTermType dbNumericType, ImmutableTerm dbTerm1, ImmutableTerm dbTerm2)
ImmutableExpression	getDBBooleanCase(Stream<Map.Entry<ImmutableExpression,ImmutableExpression>> whenPairs, ImmutableExpression defaultValue, boolean doOrderingMatter)
DBConstant	getDBBooleanConstant(boolean value) Returns a DB boolean constant
ImmutableExpression	getDBBooleanInequality(InequalityLabel inequalityLabel, ImmutableTerm dbBooleanTerm1, ImmutableTerm dbBooleanTerm2)
ImmutableFunctionalTerm	getDBCase(Stream<? extends Map.Entry<ImmutableExpression,? extends ImmutableTerm>> whenPairs, ImmutableTerm defaultTerm, boolean doOrderingMatter) IF THEN, ELSE IF ..., ELSE whenPairs must not be empty doOrderingMatter: if false, the when pairs can be re-ordered
ImmutableFunctionalTerm	getDBCaseElseNull(Stream<? extends Map.Entry<ImmutableExpression,? extends ImmutableTerm>> whenPairs, boolean doOrderingMatter) IF THEN, ELSE IF ..., ELSE NULL whenPairs must not be empty
ImmutableFunctionalTerm	getDBCastFunctionalTerm(DBTermType inputType, DBTermType targetType, ImmutableTerm term)
ImmutableFunctionalTerm	getDBCastFunctionalTerm(DBTermType targetType, ImmutableTerm term)
ImmutableFunctionalTerm	getDBCharLength(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBCoalesce(com.google.common.collect.ImmutableList<ImmutableTerm> terms)
ImmutableFunctionalTerm	getDBCoalesce(ImmutableTerm term1, ImmutableTerm term2, ImmutableTerm... terms)
DBConstant	getDBConstant(String value, DBTermType termType)
ImmutableExpression	getDBContains(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
ImmutableFunctionalTerm	getDBCount(boolean isDistinct)
ImmutableFunctionalTerm	getDBCount(ImmutableTerm subTerm, boolean isDistinct)
ImmutableExpression	getDBDateInequality(InequalityLabel inequalityLabel, ImmutableTerm dbDateTerm1, ImmutableTerm dbDateTerm2)
ImmutableExpression	getDBDatetimeInequality(InequalityLabel inequalityLabel, ImmutableTerm dbDatetimeTerm1, ImmutableTerm dbDatetimeTerm2)
ImmutableFunctionalTerm	getDBDayFromDatetime(ImmutableTerm dbDatetimeTerm)
ImmutableExpression	getDBDefaultInequality(InequalityLabel inequalityLabel, ImmutableTerm dbTerm1, ImmutableTerm dbTerm2)
ImmutableExpression	getDBEndsWith(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
DBFunctionSymbolFactory	getDBFunctionSymbolFactory()
ImmutableFunctionalTerm	getDBGroupConcat(ImmutableTerm subTerm, String separator, boolean isDistinct)
ImmutableFunctionalTerm	getDBHours(ImmutableTerm dbDatetimeTerm)
DBConstant	getDBIntegerConstant(int value)
ImmutableFunctionalTerm	getDBIntIndex(ImmutableTerm idTerm, com.google.common.collect.ImmutableList<ImmutableTerm> possibleValues)
ImmutableFunctionalTerm	getDBIntIndex(ImmutableTerm idTerm, ImmutableTerm... possibleValues) The first sub-term encodes the index of the term to return.
ImmutableExpression	getDBIsNotNull(ImmutableTerm immutableTerm)
ImmutableExpression	getDBIsNull(ImmutableTerm immutableTerm)
ImmutableExpression	getDBIsStringEmpty(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBLower(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBMax(ImmutableTerm subTerm, DBTermType dbType)
ImmutableFunctionalTerm	getDBMd5(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBMin(ImmutableTerm subTerm, DBTermType dbType)
ImmutableFunctionalTerm	getDBMinutes(ImmutableTerm dbDatetimeTerm)
ImmutableFunctionalTerm	getDBMonthFromDatetime(ImmutableTerm dbDatetimeTerm)
ImmutableExpression	getDBNonStrictDateEquality(ImmutableTerm dbTerm1, ImmutableTerm dbTerm2)
ImmutableExpression	getDBNonStrictDatetimeEquality(ImmutableTerm dbDatetimeTerm1, ImmutableTerm dbDatetimeTerm2)
ImmutableExpression	getDBNonStrictDefaultEquality(ImmutableTerm dbTerm1, ImmutableTerm dbTerm2) Cannot be simplified --> has to be evaluated by the DB engine Only suitable for DB terms
ImmutableExpression	getDBNonStrictNumericEquality(ImmutableTerm dbNumericTerm1, ImmutableTerm dbNumericTerm2)
ImmutableExpression	getDBNonStrictStringEquality(ImmutableTerm dbStringTerm1, ImmutableTerm dbStringTerm2)
ImmutableExpression	getDBNot(ImmutableExpression expression)
ImmutableFunctionalTerm	getDBNow()
ImmutableExpression	getDBNumericInequality(InequalityLabel inequalityLabel, ImmutableTerm dbNumericTerm1, ImmutableTerm dbNumericTerm2)
ImmutableFunctionalTerm	getDBRand(UUID uuid)
ImmutableExpression	getDBRegexpMatches(com.google.common.collect.ImmutableList<ImmutableTerm> terms)
ImmutableFunctionalTerm	getDBRegexpReplace(ImmutableTerm arg, ImmutableTerm pattern, ImmutableTerm replacement)
ImmutableFunctionalTerm	getDBRegexpReplace(ImmutableTerm arg, ImmutableTerm pattern, ImmutableTerm replacement, ImmutableTerm flags)
ImmutableFunctionalTerm	getDBReplace(ImmutableTerm arg, ImmutableTerm pattern, ImmutableTerm replacement)
ImmutableFunctionalTerm	getDBRight(ImmutableTerm stringTerm, ImmutableTerm lengthTerm)
ImmutableFunctionalTerm	getDBSeconds(ImmutableTerm dbDatetimeTerm)
ImmutableFunctionalTerm	getDBSha1(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBSha256(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBSha512(ImmutableTerm stringTerm)
ImmutableExpression	getDBStartsWith(com.google.common.collect.ImmutableList<ImmutableTerm> terms)
ImmutableFunctionalTerm	getDBStrAfter(ImmutableTerm arg1, ImmutableTerm arg2)
ImmutableFunctionalTerm	getDBStrBefore(ImmutableTerm arg1, ImmutableTerm arg2)
DBConstant	getDBStringConstant(String value)
ImmutableExpression	getDBStringInequality(InequalityLabel inequalityLabel, ImmutableTerm dbStringTerm1, ImmutableTerm dbStringTerm2)
ImmutableFunctionalTerm	getDBSubString2(ImmutableTerm stringTerm, ImmutableTerm from)
ImmutableFunctionalTerm	getDBSubString3(ImmutableTerm stringTerm, ImmutableTerm from, ImmutableTerm to)
ImmutableFunctionalTerm	getDBSum(ImmutableTerm subTerm, DBTermType dbType, boolean isDistinct)
ImmutableFunctionalTerm	getDBTz(ImmutableTerm dbDatetimeTerm)
ImmutableFunctionalTerm	getDBUpper(ImmutableTerm stringTerm)
ImmutableFunctionalTerm	getDBUUID(UUID uuid)
ImmutableFunctionalTerm	getDBYearFromDatetime(ImmutableTerm dbDatetimeTerm)
ImmutableExpression	getDisjunction(ImmutableExpression expression, ImmutableExpression... otherExpressions)
ImmutableExpression	getDisjunction(com.google.common.collect.ImmutableList<ImmutableExpression> nonEmptyExpressionList) Must be non-empty
Optional<ImmutableExpression>	getDisjunction(Stream<ImmutableExpression> expressions) May be empty.
Optional<DBConstant>	getDoubleNaN() Is empty if the DB does not support (and therefore does not store) not-a-number values
ImmutableExpression.Evaluation	getEvaluation(ImmutableExpression expression) Just wraps the expression into an Evaluation object
ImmutableExpression	getFalseOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments) When filled with constants, evaluates to FALSE if one argument is FALSE or to NULL otherwise.
ImmutableFunctionalTerm	getFreshBnodeFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableTerm> terms) NB: a fresh Bnode template is created
ImmutableFunctionalTerm.FunctionalTermDecomposition	getFunctionalTermDecomposition(ImmutableTerm liftableTerm)
ImmutableFunctionalTerm.FunctionalTermDecomposition	getFunctionalTermDecomposition(ImmutableTerm liftableTerm, com.google.common.collect.ImmutableMap<Variable,ImmutableFunctionalTerm> subTermSubstitutionMap)
ImmutableFunctionalTerm	getIfElseNull(ImmutableExpression condition, ImmutableTerm term)
ImmutableFunctionalTerm	getIfThenElse(ImmutableExpression condition, ImmutableTerm thenTerm, ImmutableTerm elseTerm)
ImmutableExpression	getImmutableExpression(BooleanFunctionSymbol functor, com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments)
ImmutableExpression	getImmutableExpression(BooleanFunctionSymbol functor, ImmutableTerm... arguments)
ImmutableFunctionalTerm	getImmutableFunctionalTerm(FunctionSymbol functor, com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
ImmutableFunctionalTerm	getImmutableFunctionalTerm(FunctionSymbol functor, ImmutableTerm... terms)
ImmutableFunctionalTerm	getIRIFunctionalTerm(IRIStringTemplateFunctionSymbol templateSymbol, com.google.common.collect.ImmutableList<DBConstant> arguments) When fact IRIs are decomposed (so as to be included in the mapping)
ImmutableFunctionalTerm	getIRIFunctionalTerm(String iriTemplate, com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments) At least one argument for the IRI functional term with an IRI template is required
ImmutableFunctionalTerm	getIRIFunctionalTerm(Variable variable, boolean temporaryCastToString) temporaryCastToString == true must only be used when dealing with PRE-PROCESSED mapping
ImmutableExpression	getIsAExpression(ImmutableTerm termTypeTerm, RDFTermType baseType) Compares a TermType term to a base type
ImmutableExpression	getIsTrue(NonFunctionalTerm dbBooleanTerm) Wraps a DB boolean constant/variable into an ImmutableExpression
ImmutableFunctionalTerm	getLangTypeFunctionalTerm(ImmutableTerm rdfTypeTerm) Do NOT confuse it with the LANG SPARQL function
ImmutableExpression	getLexicalEffectiveBooleanValue(ImmutableTerm lexicalTerm, ImmutableTerm rdfDatatypeTerm)
ImmutableExpression	getLexicalInequality(InequalityLabel inequalityLabel, ImmutableTerm lexicalTerm1, ImmutableTerm typeTerm1, ImmutableTerm lexicalTerm2, ImmutableTerm typeTerm2)
ImmutableExpression	getLexicalLangMatches(ImmutableTerm langTagTerm, ImmutableTerm langRangeTerm) Do NOT confuse it with the langMatches SPARQL function
ImmutableExpression	getLexicalNonStrictEquality(ImmutableTerm lexicalTerm1, ImmutableTerm typeTerm1, ImmutableTerm lexicalTerm2, ImmutableTerm typeTerm2)
ImmutableExpression.Evaluation	getNegativeEvaluation()
NonGroundFunctionalTerm	getNonGroundFunctionalTerm(FunctionSymbol functor, com.google.common.collect.ImmutableList<ImmutableTerm> terms)
NonGroundFunctionalTerm	getNonGroundFunctionalTerm(FunctionSymbol functor, ImmutableTerm... terms)
ImmutableExpression	getNotYetTypedEquality(ImmutableTerm t1, ImmutableTerm t2) To be used when parsing the mapping and when an equality is found.
Constant	getNullConstant()
ImmutableExpression.Evaluation	getNullEvaluation()
ImmutableFunctionalTerm	getNullRejectingDBConcatFunctionalTerm(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms) At least two terms are expected
ImmutableFunctionalTerm	getPartiallyDefinedToStringCast(Variable variable) Used when building (a fragment of) the lexical part of an RDF term (either the full lexical value or a fragment involved in a template) in a PRE-PROCESSED mapping assertion.
ImmutableExpression.Evaluation	getPositiveEvaluation()
<T extends ImmutableTerm> ProtoSubstitution<T>	getProtoSubstitution(com.google.common.collect.ImmutableMap<Variable,T> map) Minimalist substitution with minimal dependencies.
DBConstant	getProvenanceSpecialConstant() TODO: explain
ImmutableFunctionalTerm	getR2RMLIRISafeEncodeFunctionalTerm(ImmutableTerm term)
ImmutableExpression	getRDF2DBBooleanFunctionalTerm(ImmutableTerm xsdBooleanTerm)
RDFConstant	getRDFConstant(String lexicalValue, RDFTermType termType)
ImmutableFunctionalTerm	getRDFDatatypeStringFunctionalTerm(ImmutableTerm rdfTypeTerm)
ImmutableFunctionalTerm	getRDFFunctionalTerm(ImmutableTerm lexicalTerm, ImmutableTerm typeTerm)
RDFLiteralConstant	getRDFLiteralConstant(String value, org.apache.commons.rdf.api.IRI type)
RDFLiteralConstant	getRDFLiteralConstant(String value, RDFDatatype type) Construct a RDFLiteralConstant object with a type definition.
RDFLiteralConstant	getRDFLiteralConstant(String value, String language) Construct a RDFLiteralConstant object with a language tag.
ImmutableFunctionalTerm	getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm, org.apache.commons.rdf.api.IRI datatypeIRI)
ImmutableFunctionalTerm	getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm, RDFDatatype type)
ImmutableFunctionalTerm	getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm, String language)
RDFTermTypeConstant	getRDFTermTypeConstant(RDFTermType type)
ImmutableFunctionalTerm	getRDFTermTypeFunctionalTerm(ImmutableTerm term, TypeConstantDictionary dictionary, com.google.common.collect.ImmutableSet<RDFTermTypeConstant> possibleConstants, boolean isSimplifiable)
ImmutableFunctionalTerm	getSPARQLEffectiveBooleanValue(ImmutableTerm rdfTerm) Returns an XSD.BOOLEAN
ImmutableFunctionalTerm	getSPARQLNonStrictEquality(ImmutableTerm rdfTerm1, ImmutableTerm rdfTerm2) Using the SPARQL "=" operator Returns an XSD.BOOLEAN
ImmutableExpression	getStrictEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms) terms must have at least two elements
ImmutableExpression	getStrictEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms) terms must have at least two distinct elements
ImmutableExpression	getStrictEquality(ImmutableTerm term1, ImmutableTerm term2, ImmutableTerm... otherTerms)
ImmutableExpression	getStrictNEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms) terms must have at least two elements Logically equivalent to NOT(STRICT_EQx(...))
ImmutableExpression	getStrictNEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms) terms must have at least two elements Logically equivalent to NOT(STRICT_EQx(...))
ImmutableExpression	getStrictNEquality(ImmutableTerm term1, ImmutableTerm term2, ImmutableTerm... otherTerms)
ImmutableExpression	getTrueOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments) When filled with constants, evaluates to TRUE if one argument is TRUE or to NULL otherwise.
ImmutableFunctionalTerm	getTypedNull(DBTermType termType) The resulting functional term may simplify to a regular NULL or not, depending on the DB system.
TypeFactory	getTypeFactory()
ImmutableFunctionalTerm	getUnaryLatelyTypedFunctionalTerm(ImmutableTerm lexicalTerm, ImmutableTerm inputRDFTypeTerm, DBTermType targetType, Function<DBTermType,DBFunctionSymbol> dbFunctionSymbolFct)
ImmutableFunctionalTerm	getUnaryLexicalFunctionalTerm(ImmutableTerm lexicalTerm, ImmutableTerm rdfDatatypeTerm, Function<DBTermType,DBFunctionSymbol> dbFunctionSymbolFct)
Variable	getVariable(String name) Construct a Variable object.
DBConstant	getXsdBooleanLexicalConstant(boolean value) Returns a DB string constant

Method Detail

getImmutableExpression

ImmutableExpression getImmutableExpression(BooleanFunctionSymbol functor,
                                           ImmutableTerm... arguments)

getImmutableExpression

ImmutableExpression getImmutableExpression(BooleanFunctionSymbol functor,
                                           com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments)

getConjunction

ImmutableExpression getConjunction(com.google.common.collect.ImmutableList<ImmutableExpression> nonEmptyExpressionList)

Must be non-empty Does NOT take care of flattening conjunctions in the arguments

getConjunction

ImmutableExpression getConjunction(ImmutableExpression expression,
                                   ImmutableExpression... otherExpressions)

Does NOT take care of flattening conjunctions in the arguments

getConjunction

Optional<ImmutableExpression> getConjunction(Stream<ImmutableExpression> expressionStream)

May be empty. Takes care of flattening the arguments

getDisjunction

ImmutableExpression getDisjunction(com.google.common.collect.ImmutableList<ImmutableExpression> nonEmptyExpressionList)

Must be non-empty

getDisjunction

ImmutableExpression getDisjunction(ImmutableExpression expression,
                                   ImmutableExpression... otherExpressions)

getDisjunction

Optional<ImmutableExpression> getDisjunction(Stream<ImmutableExpression> expressions)

May be empty. Takes care of flattening the arguments

getDBNot

ImmutableExpression getDBNot(ImmutableExpression expression)

getFalseOrNullFunctionalTerm

ImmutableExpression getFalseOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments)

When filled with constants, evaluates to FALSE if one argument is FALSE or to NULL otherwise. Must be non-empty

getTrueOrNullFunctionalTerm

ImmutableExpression getTrueOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments)

When filled with constants, evaluates to TRUE if one argument is TRUE or to NULL otherwise. Must be non-empty

getIsAExpression

ImmutableExpression getIsAExpression(ImmutableTerm termTypeTerm,
                                     RDFTermType baseType)

Compares a TermType term to a base type

getAreCompatibleRDFStringExpression

ImmutableExpression getAreCompatibleRDFStringExpression(ImmutableTerm typeTerm1,
                                                        ImmutableTerm typeTerm2)

See https://www.w3.org/TR/sparql11-query/#func-arg-compatibility

getEvaluation

ImmutableExpression.Evaluation getEvaluation(ImmutableExpression expression)

Just wraps the expression into an Evaluation object

getPositiveEvaluation

ImmutableExpression.Evaluation getPositiveEvaluation()

getNegativeEvaluation

ImmutableExpression.Evaluation getNegativeEvaluation()

getNullEvaluation

ImmutableExpression.Evaluation getNullEvaluation()

getFunctionalTermDecomposition

ImmutableFunctionalTerm.FunctionalTermDecomposition getFunctionalTermDecomposition(ImmutableTerm liftableTerm)

getFunctionalTermDecomposition

ImmutableFunctionalTerm.FunctionalTermDecomposition getFunctionalTermDecomposition(ImmutableTerm liftableTerm,
                                                                                   com.google.common.collect.ImmutableMap<Variable,ImmutableFunctionalTerm> subTermSubstitutionMap)

getImmutableFunctionalTerm

ImmutableFunctionalTerm getImmutableFunctionalTerm(FunctionSymbol functor,
                                                   com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

getImmutableFunctionalTerm

ImmutableFunctionalTerm getImmutableFunctionalTerm(FunctionSymbol functor,
                                                   ImmutableTerm... terms)

getNonGroundFunctionalTerm

NonGroundFunctionalTerm getNonGroundFunctionalTerm(FunctionSymbol functor,
                                                   ImmutableTerm... terms)

getNonGroundFunctionalTerm

NonGroundFunctionalTerm getNonGroundFunctionalTerm(FunctionSymbol functor,
                                                   com.google.common.collect.ImmutableList<ImmutableTerm> terms)

getNotYetTypedEquality

ImmutableExpression getNotYetTypedEquality(ImmutableTerm t1,
                                           ImmutableTerm t2)

To be used when parsing the mapping and when an equality is found. Is expected to replaced later by a proper equality (may be strict or not)

getLexicalNonStrictEquality

ImmutableExpression getLexicalNonStrictEquality(ImmutableTerm lexicalTerm1,
                                                ImmutableTerm typeTerm1,
                                                ImmutableTerm lexicalTerm2,
                                                ImmutableTerm typeTerm2)

getLexicalInequality

ImmutableExpression getLexicalInequality(InequalityLabel inequalityLabel,
                                         ImmutableTerm lexicalTerm1,
                                         ImmutableTerm typeTerm1,
                                         ImmutableTerm lexicalTerm2,
                                         ImmutableTerm typeTerm2)

getDBNonStrictNumericEquality

ImmutableExpression getDBNonStrictNumericEquality(ImmutableTerm dbNumericTerm1,
                                                  ImmutableTerm dbNumericTerm2)

getDBNonStrictStringEquality

ImmutableExpression getDBNonStrictStringEquality(ImmutableTerm dbStringTerm1,
                                                 ImmutableTerm dbStringTerm2)

getDBNonStrictDatetimeEquality

ImmutableExpression getDBNonStrictDatetimeEquality(ImmutableTerm dbDatetimeTerm1,
                                                   ImmutableTerm dbDatetimeTerm2)

getDBNonStrictDateEquality

ImmutableExpression getDBNonStrictDateEquality(ImmutableTerm dbTerm1,
                                               ImmutableTerm dbTerm2)

getDBNonStrictDefaultEquality

ImmutableExpression getDBNonStrictDefaultEquality(ImmutableTerm dbTerm1,
                                                  ImmutableTerm dbTerm2)

Cannot be simplified --> has to be evaluated by the DB engine Only suitable for DB terms

getDBNumericInequality

ImmutableExpression getDBNumericInequality(InequalityLabel inequalityLabel,
                                           ImmutableTerm dbNumericTerm1,
                                           ImmutableTerm dbNumericTerm2)

getDBBooleanInequality

ImmutableExpression getDBBooleanInequality(InequalityLabel inequalityLabel,
                                           ImmutableTerm dbBooleanTerm1,
                                           ImmutableTerm dbBooleanTerm2)

getDBStringInequality

ImmutableExpression getDBStringInequality(InequalityLabel inequalityLabel,
                                          ImmutableTerm dbStringTerm1,
                                          ImmutableTerm dbStringTerm2)

getDBDatetimeInequality

ImmutableExpression getDBDatetimeInequality(InequalityLabel inequalityLabel,
                                            ImmutableTerm dbDatetimeTerm1,
                                            ImmutableTerm dbDatetimeTerm2)

getDBDateInequality

ImmutableExpression getDBDateInequality(InequalityLabel inequalityLabel,
                                        ImmutableTerm dbDateTerm1,
                                        ImmutableTerm dbDateTerm2)

getDBDefaultInequality

ImmutableExpression getDBDefaultInequality(InequalityLabel inequalityLabel,
                                           ImmutableTerm dbTerm1,
                                           ImmutableTerm dbTerm2)

getConstantIRI

IRIConstant getConstantIRI(org.apache.commons.rdf.api.IRI iri)

Construct a IRIConstant object. This type of term is written as a usual URI construction following the generic URI syntax specification (RFC 3986).

scheme://host:port/path#fragment

Examples:

http://example.org/some/paths
http://example.org/some/paths/to/resource#frag01
ftp://example.org/resource.txt


are all well-formed URI strings.

Parameters:

iri - the URI.

Returns:

a URI constant.

getConstantBNode

BNode getConstantBNode(String name)

getDBBooleanConstant

DBConstant getDBBooleanConstant(boolean value)

Returns a DB boolean constant

getXsdBooleanLexicalConstant

DBConstant getXsdBooleanLexicalConstant(boolean value)

Returns a DB string constant

getNullConstant

Constant getNullConstant()

getTypedNull

ImmutableFunctionalTerm getTypedNull(DBTermType termType)

The resulting functional term may simplify to a regular NULL or not, depending on the DB system. Useful for PostgreSQL which has limited type inference capabilities when it comes to NULL and UNION (ALL).

getDBIntegerConstant

DBConstant getDBIntegerConstant(int value)

getDoubleNaN

Optional<DBConstant> getDoubleNaN()

Is empty if the DB does not support (and therefore does not store) not-a-number values

getProvenanceSpecialConstant

DBConstant getProvenanceSpecialConstant()

TODO: explain

getRDFLiteralConstant

RDFLiteralConstant getRDFLiteralConstant(String value,
                                         RDFDatatype type)

Construct a RDFLiteralConstant object with a type definition.

Example:

"Person"^^xsd:String
22^^xsd:Integer

Parameters:

value - the value of the constant.

type - the type of the constant.

Returns:

the value constant.

getRDFLiteralConstant

RDFLiteralConstant getRDFLiteralConstant(String value,
                                         org.apache.commons.rdf.api.IRI type)

getRDFLiteralConstant

RDFLiteralConstant getRDFLiteralConstant(String value,
                                         String language)

Construct a RDFLiteralConstant object with a language tag.

Example:

"This is American English"@en-US


Parameters:

value - the value of the constant.

language - the language tag for the constant.

Returns:

the value constant.

getRDFConstant

RDFConstant getRDFConstant(String lexicalValue,
                           RDFTermType termType)

getRDFLiteralFunctionalTerm

ImmutableFunctionalTerm getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm,
                                                    String language)

getRDFLiteralFunctionalTerm

ImmutableFunctionalTerm getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm,
                                                    RDFDatatype type)

getRDFLiteralFunctionalTerm

ImmutableFunctionalTerm getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm,
                                                    org.apache.commons.rdf.api.IRI datatypeIRI)

getDBConstant

DBConstant getDBConstant(String value,
                         DBTermType termType)

getDBStringConstant

DBConstant getDBStringConstant(String value)

getVariable

Variable getVariable(String name)

Construct a Variable object. The variable name is started by a dollar sign ('$') or a question mark sign ('?'), e.g.:

pred($x)
func(?x, ?y)

Parameters:

name - the name of the variable.

Returns:

the variable object.

getRDFTermTypeConstant

RDFTermTypeConstant getRDFTermTypeConstant(RDFTermType type)

getRDFTermTypeFunctionalTerm

ImmutableFunctionalTerm getRDFTermTypeFunctionalTerm(ImmutableTerm term,
                                                     TypeConstantDictionary dictionary,
                                                     com.google.common.collect.ImmutableSet<RDFTermTypeConstant> possibleConstants,
                                                     boolean isSimplifiable)

getRDFFunctionalTerm

ImmutableFunctionalTerm getRDFFunctionalTerm(ImmutableTerm lexicalTerm,
                                             ImmutableTerm typeTerm)

getIRIFunctionalTerm

ImmutableFunctionalTerm getIRIFunctionalTerm(Variable variable,
                                             boolean temporaryCastToString)

temporaryCastToString == true must only be used when dealing with PRE-PROCESSED mapping

getIRIFunctionalTerm

ImmutableFunctionalTerm getIRIFunctionalTerm(String iriTemplate,
                                             com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments)

At least one argument for the IRI functional term with an IRI template is required

getIRIFunctionalTerm

ImmutableFunctionalTerm getIRIFunctionalTerm(IRIStringTemplateFunctionSymbol templateSymbol,
                                             com.google.common.collect.ImmutableList<DBConstant> arguments)

When fact IRIs are decomposed (so as to be included in the mapping)

getBnodeFunctionalTerm

ImmutableFunctionalTerm getBnodeFunctionalTerm(String bnodeTemplate,
                                               com.google.common.collect.ImmutableList<? extends ImmutableTerm> arguments)

getFreshBnodeFunctionalTerm

ImmutableFunctionalTerm getFreshBnodeFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableTerm> terms)

NB: a fresh Bnode template is created

getDBCastFunctionalTerm

ImmutableFunctionalTerm getDBCastFunctionalTerm(DBTermType targetType,
                                                ImmutableTerm term)

getDBCastFunctionalTerm

ImmutableFunctionalTerm getDBCastFunctionalTerm(DBTermType inputType,
                                                DBTermType targetType,
                                                ImmutableTerm term)

getDBIntIndex

ImmutableFunctionalTerm getDBIntIndex(ImmutableTerm idTerm,
                                      ImmutableTerm... possibleValues)

The first sub-term encodes the index of the term to return. Such values correspond to the following sub-terms For instance DB_IDX(1, "roger", "francis", "ernest") returns "francis"

getDBIntIndex

ImmutableFunctionalTerm getDBIntIndex(ImmutableTerm idTerm,
                                      com.google.common.collect.ImmutableList<ImmutableTerm> possibleValues)

getConversion2RDFLexical

ImmutableFunctionalTerm getConversion2RDFLexical(DBTermType inputType,
                                                 ImmutableTerm term,
                                                 RDFTermType rdfTermType)

May "normalize"

getConversion2RDFLexical

ImmutableFunctionalTerm getConversion2RDFLexical(ImmutableTerm term,
                                                 RDFTermType rdfTermType)

getConversionFromRDFLexical2DB

ImmutableFunctionalTerm getConversionFromRDFLexical2DB(DBTermType targetDBType,
                                                       ImmutableTerm dbTerm,
                                                       RDFTermType rdfType)

May "denormalize"

getConversionFromRDFLexical2DB

ImmutableFunctionalTerm getConversionFromRDFLexical2DB(ImmutableTerm dbTerm,
                                                       RDFTermType rdfType)

getPartiallyDefinedToStringCast

ImmutableFunctionalTerm getPartiallyDefinedToStringCast(Variable variable)

Used when building (a fragment of) the lexical part of an RDF term (either the full lexical value or a fragment involved in a template) in a PRE-PROCESSED mapping assertion. This functional term must not appear in the final mapping

getRDF2DBBooleanFunctionalTerm

ImmutableExpression getRDF2DBBooleanFunctionalTerm(ImmutableTerm xsdBooleanTerm)

getIfElseNull

ImmutableFunctionalTerm getIfElseNull(ImmutableExpression condition,
                                      ImmutableTerm term)

getBooleanIfElseNull

ImmutableExpression getBooleanIfElseNull(ImmutableExpression condition,
                                         ImmutableExpression thenExpression)

getIfThenElse

ImmutableFunctionalTerm getIfThenElse(ImmutableExpression condition,
                                      ImmutableTerm thenTerm,
                                      ImmutableTerm elseTerm)

getDBCase

ImmutableFunctionalTerm getDBCase(Stream<? extends Map.Entry<ImmutableExpression,? extends ImmutableTerm>> whenPairs,
                                  ImmutableTerm defaultTerm,
                                  boolean doOrderingMatter)

IF THEN, ELSE IF ..., ELSE whenPairs must not be empty doOrderingMatter: if false, the when pairs can be re-ordered

getDBCaseElseNull

ImmutableFunctionalTerm getDBCaseElseNull(Stream<? extends Map.Entry<ImmutableExpression,? extends ImmutableTerm>> whenPairs,
                                          boolean doOrderingMatter)

IF THEN, ELSE IF ..., ELSE NULL whenPairs must not be empty

getDBBooleanCase

ImmutableExpression getDBBooleanCase(Stream<Map.Entry<ImmutableExpression,ImmutableExpression>> whenPairs,
                                     ImmutableExpression defaultValue,
                                     boolean doOrderingMatter)

getDBCoalesce

ImmutableFunctionalTerm getDBCoalesce(ImmutableTerm term1,
                                      ImmutableTerm term2,
                                      ImmutableTerm... terms)

getDBCoalesce

ImmutableFunctionalTerm getDBCoalesce(com.google.common.collect.ImmutableList<ImmutableTerm> terms)

getDBReplace

ImmutableFunctionalTerm getDBReplace(ImmutableTerm arg,
                                     ImmutableTerm pattern,
                                     ImmutableTerm replacement)

getDBRegexpReplace

ImmutableFunctionalTerm getDBRegexpReplace(ImmutableTerm arg,
                                           ImmutableTerm pattern,
                                           ImmutableTerm replacement)

getDBRegexpReplace

ImmutableFunctionalTerm getDBRegexpReplace(ImmutableTerm arg,
                                           ImmutableTerm pattern,
                                           ImmutableTerm replacement,
                                           ImmutableTerm flags)

getDBStartsWith

ImmutableExpression getDBStartsWith(com.google.common.collect.ImmutableList<ImmutableTerm> terms)

getDBEndsWith

ImmutableExpression getDBEndsWith(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

getDBContains

ImmutableExpression getDBContains(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

getDBRegexpMatches

ImmutableExpression getDBRegexpMatches(com.google.common.collect.ImmutableList<ImmutableTerm> terms)

getR2RMLIRISafeEncodeFunctionalTerm

ImmutableFunctionalTerm getR2RMLIRISafeEncodeFunctionalTerm(ImmutableTerm term)

getNullRejectingDBConcatFunctionalTerm

ImmutableFunctionalTerm getNullRejectingDBConcatFunctionalTerm(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

At least two terms are expected

getCommonDenominatorFunctionalTerm

ImmutableFunctionalTerm getCommonDenominatorFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableTerm> typeTerms)

getStrictEquality

ImmutableExpression getStrictEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms)

terms must have at least two distinct elements

getStrictEquality

ImmutableExpression getStrictEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

terms must have at least two elements

getStrictEquality

ImmutableExpression getStrictEquality(ImmutableTerm term1,
                                      ImmutableTerm term2,
                                      ImmutableTerm... otherTerms)

getStrictNEquality

ImmutableExpression getStrictNEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms)

terms must have at least two elements Logically equivalent to NOT(STRICT_EQx(...))

getDBIsStringEmpty

ImmutableExpression getDBIsStringEmpty(ImmutableTerm stringTerm)

getStrictNEquality

ImmutableExpression getStrictNEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)

terms must have at least two elements Logically equivalent to NOT(STRICT_EQx(...))

getStrictNEquality

ImmutableExpression getStrictNEquality(ImmutableTerm term1,
                                       ImmutableTerm term2,
                                       ImmutableTerm... otherTerms)

getIsTrue

ImmutableExpression getIsTrue(NonFunctionalTerm dbBooleanTerm)

Wraps a DB boolean constant/variable into an ImmutableExpression

getDBSubString2

ImmutableFunctionalTerm getDBSubString2(ImmutableTerm stringTerm,
                                        ImmutableTerm from)

getDBSubString3

ImmutableFunctionalTerm getDBSubString3(ImmutableTerm stringTerm,
                                        ImmutableTerm from,
                                        ImmutableTerm to)

getDBRight

ImmutableFunctionalTerm getDBRight(ImmutableTerm stringTerm,
                                   ImmutableTerm lengthTerm)

getDBUpper

ImmutableFunctionalTerm getDBUpper(ImmutableTerm stringTerm)

getDBLower

ImmutableFunctionalTerm getDBLower(ImmutableTerm stringTerm)

getLangTypeFunctionalTerm

ImmutableFunctionalTerm getLangTypeFunctionalTerm(ImmutableTerm rdfTypeTerm)

Do NOT confuse it with the LANG SPARQL function

getLexicalLangMatches

ImmutableExpression getLexicalLangMatches(ImmutableTerm langTagTerm,
                                          ImmutableTerm langRangeTerm)

Do NOT confuse it with the langMatches SPARQL function

getTypeFactory

TypeFactory getTypeFactory()

createDummyVariableNullability

VariableNullability createDummyVariableNullability(ImmutableFunctionalTerm functionalTerm)

getRDFDatatypeStringFunctionalTerm

ImmutableFunctionalTerm getRDFDatatypeStringFunctionalTerm(ImmutableTerm rdfTypeTerm)

getDBUUID

ImmutableFunctionalTerm getDBUUID(UUID uuid)

getDBStrBefore

ImmutableFunctionalTerm getDBStrBefore(ImmutableTerm arg1,
                                       ImmutableTerm arg2)

getDBStrAfter

ImmutableFunctionalTerm getDBStrAfter(ImmutableTerm arg1,
                                      ImmutableTerm arg2)

getDBCharLength

ImmutableFunctionalTerm getDBCharLength(ImmutableTerm stringTerm)

getDBIsNull

ImmutableExpression getDBIsNull(ImmutableTerm immutableTerm)

getDBIsNotNull

ImmutableExpression getDBIsNotNull(ImmutableTerm immutableTerm)

getDBMd5

ImmutableFunctionalTerm getDBMd5(ImmutableTerm stringTerm)

getDBSha1

ImmutableFunctionalTerm getDBSha1(ImmutableTerm stringTerm)

getDBSha256

ImmutableFunctionalTerm getDBSha256(ImmutableTerm stringTerm)

getDBSha512

ImmutableFunctionalTerm getDBSha512(ImmutableTerm stringTerm)

getCommonPropagatedOrSubstitutedNumericType

ImmutableFunctionalTerm getCommonPropagatedOrSubstitutedNumericType(ImmutableTerm rdfTypeTerm1,
                                                                    ImmutableTerm rdfTypeTerm2)

getDBFunctionSymbolFactory

DBFunctionSymbolFactory getDBFunctionSymbolFactory()

getProtoSubstitution

<T extends ImmutableTerm> ProtoSubstitution<T> getProtoSubstitution(com.google.common.collect.ImmutableMap<Variable,T> map)

Minimalist substitution with minimal dependencies. Designed to be used by FunctionSymbols. See the SubstitutionFactory for richer substitutions

getBinaryNumericLexicalFunctionalTerm

ImmutableFunctionalTerm getBinaryNumericLexicalFunctionalTerm(String dbNumericOperationName,
                                                              ImmutableTerm lexicalTerm1,
                                                              ImmutableTerm lexicalTerm2,
                                                              ImmutableTerm rdfTypeTerm)

TODO: find a better name

getDBBinaryNumericFunctionalTerm

ImmutableFunctionalTerm getDBBinaryNumericFunctionalTerm(String dbNumericOperationName,
                                                         DBTermType dbNumericType,
                                                         ImmutableTerm dbTerm1,
                                                         ImmutableTerm dbTerm2)

getUnaryLatelyTypedFunctionalTerm

ImmutableFunctionalTerm getUnaryLatelyTypedFunctionalTerm(ImmutableTerm lexicalTerm,
                                                          ImmutableTerm inputRDFTypeTerm,
                                                          DBTermType targetType,
                                                          Function<DBTermType,DBFunctionSymbol> dbFunctionSymbolFct)

getUnaryLexicalFunctionalTerm

ImmutableFunctionalTerm getUnaryLexicalFunctionalTerm(ImmutableTerm lexicalTerm,
                                                      ImmutableTerm rdfDatatypeTerm,
                                                      Function<DBTermType,DBFunctionSymbol> dbFunctionSymbolFct)

getSPARQLNonStrictEquality

ImmutableFunctionalTerm getSPARQLNonStrictEquality(ImmutableTerm rdfTerm1,
                                                   ImmutableTerm rdfTerm2)

Using the SPARQL "=" operator Returns an XSD.BOOLEAN

getSPARQLEffectiveBooleanValue

ImmutableFunctionalTerm getSPARQLEffectiveBooleanValue(ImmutableTerm rdfTerm)

Returns an XSD.BOOLEAN

getLexicalEffectiveBooleanValue

ImmutableExpression getLexicalEffectiveBooleanValue(ImmutableTerm lexicalTerm,
                                                    ImmutableTerm rdfDatatypeTerm)

getDBRand

ImmutableFunctionalTerm getDBRand(UUID uuid)

getDBYearFromDatetime

ImmutableFunctionalTerm getDBYearFromDatetime(ImmutableTerm dbDatetimeTerm)

getDBMonthFromDatetime

ImmutableFunctionalTerm getDBMonthFromDatetime(ImmutableTerm dbDatetimeTerm)

getDBDayFromDatetime

ImmutableFunctionalTerm getDBDayFromDatetime(ImmutableTerm dbDatetimeTerm)

getDBHours

ImmutableFunctionalTerm getDBHours(ImmutableTerm dbDatetimeTerm)

getDBMinutes

ImmutableFunctionalTerm getDBMinutes(ImmutableTerm dbDatetimeTerm)

getDBSeconds

ImmutableFunctionalTerm getDBSeconds(ImmutableTerm dbDatetimeTerm)

getDBTz

ImmutableFunctionalTerm getDBTz(ImmutableTerm dbDatetimeTerm)

getDBNow

ImmutableFunctionalTerm getDBNow()

getDBCount

ImmutableFunctionalTerm getDBCount(boolean isDistinct)

getDBCount

ImmutableFunctionalTerm getDBCount(ImmutableTerm subTerm,
                                   boolean isDistinct)

getDBSum

ImmutableFunctionalTerm getDBSum(ImmutableTerm subTerm,
                                 DBTermType dbType,
                                 boolean isDistinct)

getDBAvg

ImmutableFunctionalTerm getDBAvg(ImmutableTerm subTerm,
                                 DBTermType dbType,
                                 boolean isDistinct)

getDBMin

ImmutableFunctionalTerm getDBMin(ImmutableTerm subTerm,
                                 DBTermType dbType)

getDBMax

ImmutableFunctionalTerm getDBMax(ImmutableTerm subTerm,
                                 DBTermType dbType)

getDBGroupConcat

ImmutableFunctionalTerm getDBGroupConcat(ImmutableTerm subTerm,
                                         String separator,
                                         boolean isDistinct)