TermFactoryImpl (ontop-model 4.0.3-owlapi5 API)

java.lang.Object
- it.unibz.inf.ontop.model.term.impl.TermFactoryImpl

All Implemented Interfaces:: TermFactory

public class TermFactoryImpl
extends Object
implements TermFactory

Method Summary

All Methods Instance Methods Concrete Methods
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> conjunctionOfExpressions)` 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.
`IRIConstant`	`getConstantIRI(String iri)`
`ImmutableFunctionalTerm`	`getConversion2RDFLexical(DBTermType inputType, ImmutableTerm term, RDFTermType rdfTermType)` May "normalize"
`ImmutableFunctionalTerm`	`getConversion2RDFLexical(ImmutableTerm dbTerm, RDFTermType rdfType)`
`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 defaultExpression, 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 term, 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 term1, ImmutableTerm term2)` 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 text, ImmutableTerm from, ImmutableTerm to)`
`ImmutableFunctionalTerm`	`getDBRegexpReplace(ImmutableTerm arg, ImmutableTerm pattern, ImmutableTerm replacement, ImmutableTerm flags)`
`ImmutableFunctionalTerm`	`getDBReplace(ImmutableTerm text, ImmutableTerm from, ImmutableTerm to)`
`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> disjunctionOfExpressions)` Must be non-empty
`Optional<ImmutableExpression>`	`getDisjunction(Stream<ImmutableExpression> expressionStream)` 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> arguments)` 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

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getConstantIRI
```
public IRIConstant getConstantIRI(org.apache.commons.rdf.api.IRI iri)
```
Description copied from interface: TermFactory

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.

Specified by:

getConstantIRI in interface TermFactory

Parameters:

iri - the URI.

Returns:

a URI constant.

getConstantIRI
```
public IRIConstant getConstantIRI(String iri)
```
Specified by:

getConstantIRI in interface TermFactory

getRDFLiteralConstant
```
public RDFLiteralConstant getRDFLiteralConstant(String value,
                                                RDFDatatype type)
```
Description copied from interface: TermFactory

Construct a RDFLiteralConstant object with a type definition.
Example:
"Person"^^xsd:String 22^^xsd:Integer

Specified by:

getRDFLiteralConstant in interface TermFactory

Parameters:

value - the value of the constant.

type - the type of the constant.

Returns:

the value constant.

getRDFLiteralConstant

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

Specified by:: getRDFLiteralConstant in interface TermFactory

getRDFLiteralConstant
```
public RDFLiteralConstant getRDFLiteralConstant(String value,
                                                String language)
```
Description copied from interface: TermFactory

Construct a RDFLiteralConstant object with a language tag.
Example:
"This is American English"@en-US

Specified by:

getRDFLiteralConstant in interface TermFactory

Parameters:

value - the value of the constant.

language - the language tag for the constant.

Returns:

the value constant.

getRDFConstant

public RDFConstant getRDFConstant(String lexicalValue,
                                  RDFTermType termType)

Specified by:: getRDFConstant in interface TermFactory

getRDFLiteralFunctionalTerm

public ImmutableFunctionalTerm getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm,
                                                           RDFDatatype type)

Specified by:: getRDFLiteralFunctionalTerm in interface TermFactory

getRDFLiteralFunctionalTerm

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

Specified by:: getRDFLiteralFunctionalTerm in interface TermFactory

getDBConstant

public DBConstant getDBConstant(String value,
                                DBTermType termType)

Specified by:: getDBConstant in interface TermFactory

getDBStringConstant
```
public DBConstant getDBStringConstant(String value)
```
Specified by:

getDBStringConstant in interface TermFactory

getRDFLiteralFunctionalTerm

public ImmutableFunctionalTerm getRDFLiteralFunctionalTerm(ImmutableTerm lexicalTerm,
                                                           String language)

Specified by:: getRDFLiteralFunctionalTerm in interface TermFactory

getVariable
```
public Variable getVariable(String name)
```
Description copied from interface: TermFactory

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)

Specified by:

getVariable in interface TermFactory

Parameters:

name - the name of the variable.

Returns:

the variable object.

getRDFTermTypeConstant
```
public RDFTermTypeConstant getRDFTermTypeConstant(RDFTermType type)
```
Specified by:

getRDFTermTypeConstant in interface TermFactory

getRDFTermTypeFunctionalTerm

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

Specified by:: getRDFTermTypeFunctionalTerm in interface TermFactory

getImmutableExpression

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

Specified by:: getImmutableExpression in interface TermFactory

getImmutableExpression

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

Specified by:: getImmutableExpression in interface TermFactory

getConjunction
```
public ImmutableExpression getConjunction(com.google.common.collect.ImmutableList<ImmutableExpression> conjunctionOfExpressions)
```
Description copied from interface: TermFactory

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

Specified by:

getConjunction in interface TermFactory

getConjunction

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

Description copied from interface: TermFactory

Does NOT take care of flattening conjunctions in the arguments

Specified by:: getConjunction in interface TermFactory

getConjunction
```
public Optional<ImmutableExpression> getConjunction(Stream<ImmutableExpression> expressionStream)
```
Description copied from interface: TermFactory

May be empty. Takes care of flattening the arguments

Specified by:

getConjunction in interface TermFactory

getDisjunction

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

Description copied from interface: TermFactory

Must be non-empty

Specified by:: getDisjunction in interface TermFactory

getDisjunction

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

Specified by:: getDisjunction in interface TermFactory

getDisjunction
```
public Optional<ImmutableExpression> getDisjunction(Stream<ImmutableExpression> expressionStream)
```
Description copied from interface: TermFactory

May be empty. Takes care of flattening the arguments

Specified by:

getDisjunction in interface TermFactory

getDBNot

public ImmutableExpression getDBNot(ImmutableExpression expression)

Specified by:: getDBNot in interface TermFactory

getFalseOrNullFunctionalTerm
```
public ImmutableExpression getFalseOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments)
```
Description copied from interface: TermFactory

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

Specified by:

getFalseOrNullFunctionalTerm in interface TermFactory

getTrueOrNullFunctionalTerm
```
public ImmutableExpression getTrueOrNullFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableExpression> arguments)
```
Description copied from interface: TermFactory

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

Specified by:

getTrueOrNullFunctionalTerm in interface TermFactory

getIsAExpression

public ImmutableExpression getIsAExpression(ImmutableTerm termTypeTerm,
                                            RDFTermType baseType)

Description copied from interface: TermFactory

Compares a TermType term to a base type

Specified by:: getIsAExpression in interface TermFactory

getAreCompatibleRDFStringExpression

public ImmutableExpression getAreCompatibleRDFStringExpression(ImmutableTerm typeTerm1,
                                                               ImmutableTerm typeTerm2)

Description copied from interface: TermFactory

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

Specified by:: getAreCompatibleRDFStringExpression in interface TermFactory

getEvaluation
```
public ImmutableExpression.Evaluation getEvaluation(ImmutableExpression expression)
```
Description copied from interface: TermFactory

Just wraps the expression into an Evaluation object

Specified by:

getEvaluation in interface TermFactory

getPositiveEvaluation
```
public ImmutableExpression.Evaluation getPositiveEvaluation()
```
Specified by:

getPositiveEvaluation in interface TermFactory

getNegativeEvaluation
```
public ImmutableExpression.Evaluation getNegativeEvaluation()
```
Specified by:

getNegativeEvaluation in interface TermFactory

getNullEvaluation
```
public ImmutableExpression.Evaluation getNullEvaluation()
```
Specified by:

getNullEvaluation in interface TermFactory

getFunctionalTermDecomposition

public ImmutableFunctionalTerm.FunctionalTermDecomposition getFunctionalTermDecomposition(ImmutableTerm liftableTerm)

Specified by:: getFunctionalTermDecomposition in interface TermFactory

getFunctionalTermDecomposition

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

Specified by:: getFunctionalTermDecomposition in interface TermFactory

getImmutableFunctionalTerm

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

Specified by:: getImmutableFunctionalTerm in interface TermFactory

getImmutableFunctionalTerm

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

Specified by:: getImmutableFunctionalTerm in interface TermFactory

getNonGroundFunctionalTerm

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

Specified by:: getNonGroundFunctionalTerm in interface TermFactory

getNonGroundFunctionalTerm

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

Specified by:: getNonGroundFunctionalTerm in interface TermFactory

getTypeFactory
```
public TypeFactory getTypeFactory()
```
Specified by:

getTypeFactory in interface TermFactory

createDummyVariableNullability

public VariableNullability createDummyVariableNullability(ImmutableFunctionalTerm functionalTerm)

Specified by:: createDummyVariableNullability in interface TermFactory

getRDFDatatypeStringFunctionalTerm
```
public ImmutableFunctionalTerm getRDFDatatypeStringFunctionalTerm(ImmutableTerm rdfTypeTerm)
```
Specified by:

getRDFDatatypeStringFunctionalTerm in interface TermFactory

getDBUUID

public ImmutableFunctionalTerm getDBUUID(UUID uuid)

Specified by:: getDBUUID in interface TermFactory

getDBStrBefore

public ImmutableFunctionalTerm getDBStrBefore(ImmutableTerm arg1,
                                              ImmutableTerm arg2)

Specified by:: getDBStrBefore in interface TermFactory

getDBStrAfter

public ImmutableFunctionalTerm getDBStrAfter(ImmutableTerm arg1,
                                             ImmutableTerm arg2)

Specified by:: getDBStrAfter in interface TermFactory

getDBCharLength

public ImmutableFunctionalTerm getDBCharLength(ImmutableTerm stringTerm)

Specified by:: getDBCharLength in interface TermFactory

getDBIsNull

public ImmutableExpression getDBIsNull(ImmutableTerm immutableTerm)

Specified by:: getDBIsNull in interface TermFactory

getDBIsNotNull

public ImmutableExpression getDBIsNotNull(ImmutableTerm immutableTerm)

Specified by:: getDBIsNotNull in interface TermFactory

getDBMd5

public ImmutableFunctionalTerm getDBMd5(ImmutableTerm stringTerm)

Specified by:: getDBMd5 in interface TermFactory

getDBSha1

public ImmutableFunctionalTerm getDBSha1(ImmutableTerm stringTerm)

Specified by:: getDBSha1 in interface TermFactory

getDBSha256

public ImmutableFunctionalTerm getDBSha256(ImmutableTerm stringTerm)

Specified by:: getDBSha256 in interface TermFactory

getDBSha512

public ImmutableFunctionalTerm getDBSha512(ImmutableTerm stringTerm)

Specified by:: getDBSha512 in interface TermFactory

getCommonPropagatedOrSubstitutedNumericType

public ImmutableFunctionalTerm getCommonPropagatedOrSubstitutedNumericType(ImmutableTerm rdfTypeTerm1,
                                                                           ImmutableTerm rdfTypeTerm2)

Specified by:: getCommonPropagatedOrSubstitutedNumericType in interface TermFactory

getDBFunctionSymbolFactory
```
public DBFunctionSymbolFactory getDBFunctionSymbolFactory()
```
Specified by:

getDBFunctionSymbolFactory in interface TermFactory

getProtoSubstitution
```
public <T extends ImmutableTerm> ProtoSubstitution<T> getProtoSubstitution(com.google.common.collect.ImmutableMap<Variable,T> map)
```
Description copied from interface: TermFactory

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

Specified by:

getProtoSubstitution in interface TermFactory

getBinaryNumericLexicalFunctionalTerm

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

Description copied from interface: TermFactory

TODO: find a better name

Specified by:: getBinaryNumericLexicalFunctionalTerm in interface TermFactory

getDBBinaryNumericFunctionalTerm

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

Specified by:: getDBBinaryNumericFunctionalTerm in interface TermFactory

getUnaryLatelyTypedFunctionalTerm

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

Specified by:: getUnaryLatelyTypedFunctionalTerm in interface TermFactory

getUnaryLexicalFunctionalTerm

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

Specified by:: getUnaryLexicalFunctionalTerm in interface TermFactory

getSPARQLNonStrictEquality

public ImmutableFunctionalTerm getSPARQLNonStrictEquality(ImmutableTerm rdfTerm1,
                                                          ImmutableTerm rdfTerm2)

Description copied from interface: TermFactory

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

Specified by:: getSPARQLNonStrictEquality in interface TermFactory

getSPARQLEffectiveBooleanValue
```
public ImmutableFunctionalTerm getSPARQLEffectiveBooleanValue(ImmutableTerm rdfTerm)
```
Description copied from interface: TermFactory

Returns an XSD.BOOLEAN

Specified by:

getSPARQLEffectiveBooleanValue in interface TermFactory

getLexicalEffectiveBooleanValue

public ImmutableExpression getLexicalEffectiveBooleanValue(ImmutableTerm lexicalTerm,
                                                           ImmutableTerm rdfDatatypeTerm)

Specified by:: getLexicalEffectiveBooleanValue in interface TermFactory

getDBRand

public ImmutableFunctionalTerm getDBRand(UUID uuid)

Specified by:: getDBRand in interface TermFactory

getDBYearFromDatetime

public ImmutableFunctionalTerm getDBYearFromDatetime(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBYearFromDatetime in interface TermFactory

getDBMonthFromDatetime

public ImmutableFunctionalTerm getDBMonthFromDatetime(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBMonthFromDatetime in interface TermFactory

getDBDayFromDatetime

public ImmutableFunctionalTerm getDBDayFromDatetime(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBDayFromDatetime in interface TermFactory

getDBHours

public ImmutableFunctionalTerm getDBHours(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBHours in interface TermFactory

getDBMinutes

public ImmutableFunctionalTerm getDBMinutes(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBMinutes in interface TermFactory

getDBSeconds

public ImmutableFunctionalTerm getDBSeconds(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBSeconds in interface TermFactory

getDBTz

public ImmutableFunctionalTerm getDBTz(ImmutableTerm dbDatetimeTerm)

Specified by:: getDBTz in interface TermFactory

getDBNow
```
public ImmutableFunctionalTerm getDBNow()
```
Specified by:

getDBNow in interface TermFactory

getDBCount

public ImmutableFunctionalTerm getDBCount(boolean isDistinct)

Specified by:: getDBCount in interface TermFactory

getDBCount

public ImmutableFunctionalTerm getDBCount(ImmutableTerm term,
                                          boolean isDistinct)

Specified by:: getDBCount in interface TermFactory

getDBSum

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

Specified by:: getDBSum in interface TermFactory

getDBAvg

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

Specified by:: getDBAvg in interface TermFactory

getDBMin

public ImmutableFunctionalTerm getDBMin(ImmutableTerm subTerm,
                                        DBTermType dbType)

Specified by:: getDBMin in interface TermFactory

getDBMax

public ImmutableFunctionalTerm getDBMax(ImmutableTerm subTerm,
                                        DBTermType dbType)

Specified by:: getDBMax in interface TermFactory

getDBGroupConcat

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

Specified by:: getDBGroupConcat in interface TermFactory

getNotYetTypedEquality
```
public ImmutableExpression getNotYetTypedEquality(ImmutableTerm t1,
                                                  ImmutableTerm t2)
```
Description copied from interface: TermFactory

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)

Specified by:

getNotYetTypedEquality in interface TermFactory

getLexicalNonStrictEquality

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

Specified by:: getLexicalNonStrictEquality in interface TermFactory

getLexicalInequality

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

Specified by:: getLexicalInequality in interface TermFactory

getDBNonStrictNumericEquality

public ImmutableExpression getDBNonStrictNumericEquality(ImmutableTerm dbNumericTerm1,
                                                         ImmutableTerm dbNumericTerm2)

Specified by:: getDBNonStrictNumericEquality in interface TermFactory

getDBNonStrictStringEquality

public ImmutableExpression getDBNonStrictStringEquality(ImmutableTerm dbStringTerm1,
                                                        ImmutableTerm dbStringTerm2)

Specified by:: getDBNonStrictStringEquality in interface TermFactory

getDBNonStrictDatetimeEquality

public ImmutableExpression getDBNonStrictDatetimeEquality(ImmutableTerm dbDatetimeTerm1,
                                                          ImmutableTerm dbDatetimeTerm2)

Specified by:: getDBNonStrictDatetimeEquality in interface TermFactory

getDBNonStrictDateEquality

public ImmutableExpression getDBNonStrictDateEquality(ImmutableTerm dbTerm1,
                                                      ImmutableTerm dbTerm2)

Specified by:: getDBNonStrictDateEquality in interface TermFactory

getDBNonStrictDefaultEquality
```
public ImmutableExpression getDBNonStrictDefaultEquality(ImmutableTerm term1,
                                                         ImmutableTerm term2)
```
Description copied from interface: TermFactory

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

Specified by:

getDBNonStrictDefaultEquality in interface TermFactory

getDBNumericInequality

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

Specified by:: getDBNumericInequality in interface TermFactory

getDBBooleanInequality

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

Specified by:: getDBBooleanInequality in interface TermFactory

getDBStringInequality

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

Specified by:: getDBStringInequality in interface TermFactory

getDBDatetimeInequality

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

Specified by:: getDBDatetimeInequality in interface TermFactory

getDBDateInequality

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

Specified by:: getDBDateInequality in interface TermFactory

getDBDefaultInequality

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

Specified by:: getDBDefaultInequality in interface TermFactory

getConstantBNode
```
public BNode getConstantBNode(String name)
```
Specified by:

getConstantBNode in interface TermFactory

getDBBooleanConstant
```
public DBConstant getDBBooleanConstant(boolean value)
```
Description copied from interface: TermFactory

Returns a DB boolean constant

Specified by:

getDBBooleanConstant in interface TermFactory

getXsdBooleanLexicalConstant
```
public DBConstant getXsdBooleanLexicalConstant(boolean value)
```
Description copied from interface: TermFactory

Returns a DB string constant

Specified by:

getXsdBooleanLexicalConstant in interface TermFactory

getNullConstant
```
public Constant getNullConstant()
```
Specified by:

getNullConstant in interface TermFactory

getTypedNull
```
public ImmutableFunctionalTerm getTypedNull(DBTermType termType)
```
Description copied from interface: TermFactory

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).

Specified by:

getTypedNull in interface TermFactory

getDBIntegerConstant
```
public DBConstant getDBIntegerConstant(int value)
```
Specified by:

getDBIntegerConstant in interface TermFactory

getDoubleNaN
```
public Optional<DBConstant> getDoubleNaN()
```
Description copied from interface: TermFactory

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

Specified by:

getDoubleNaN in interface TermFactory

getProvenanceSpecialConstant
```
public DBConstant getProvenanceSpecialConstant()
```
Description copied from interface: TermFactory

TODO: explain

Specified by:

getProvenanceSpecialConstant in interface TermFactory

getRDFFunctionalTerm

public ImmutableFunctionalTerm getRDFFunctionalTerm(ImmutableTerm lexicalTerm,
                                                    ImmutableTerm typeTerm)

Specified by:: getRDFFunctionalTerm in interface TermFactory

getIRIFunctionalTerm
```
public ImmutableFunctionalTerm getIRIFunctionalTerm(Variable variable,
                                                    boolean temporaryCastToString)
```
Description copied from interface: TermFactory

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

Specified by:

getIRIFunctionalTerm in interface TermFactory

getIRIFunctionalTerm

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

Description copied from interface: TermFactory

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

Specified by:: getIRIFunctionalTerm in interface TermFactory

getIRIFunctionalTerm

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

Description copied from interface: TermFactory

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

Specified by:: getIRIFunctionalTerm in interface TermFactory

getBnodeFunctionalTerm

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

Specified by:: getBnodeFunctionalTerm in interface TermFactory

getFreshBnodeFunctionalTerm
```
public ImmutableFunctionalTerm getFreshBnodeFunctionalTerm(com.google.common.collect.ImmutableList<ImmutableTerm> arguments)
```
Description copied from interface: TermFactory

NB: a fresh Bnode template is created

Specified by:

getFreshBnodeFunctionalTerm in interface TermFactory

getDBCastFunctionalTerm

public ImmutableFunctionalTerm getDBCastFunctionalTerm(DBTermType targetType,
                                                       ImmutableTerm term)

Specified by:: getDBCastFunctionalTerm in interface TermFactory

getDBCastFunctionalTerm

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

Specified by:: getDBCastFunctionalTerm in interface TermFactory

getDBIntIndex
```
public ImmutableFunctionalTerm getDBIntIndex(ImmutableTerm idTerm,
                                             ImmutableTerm... possibleValues)
```
Description copied from interface: TermFactory

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"

Specified by:

getDBIntIndex in interface TermFactory

getDBIntIndex

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

Specified by:: getDBIntIndex in interface TermFactory

getConversion2RDFLexical

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

Description copied from interface: TermFactory

May "normalize"

Specified by:: getConversion2RDFLexical in interface TermFactory

getConversion2RDFLexical

public ImmutableFunctionalTerm getConversion2RDFLexical(ImmutableTerm dbTerm,
                                                        RDFTermType rdfType)

Specified by:: getConversion2RDFLexical in interface TermFactory

getConversionFromRDFLexical2DB

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

Description copied from interface: TermFactory

May "denormalize"

Specified by:: getConversionFromRDFLexical2DB in interface TermFactory

getConversionFromRDFLexical2DB

public ImmutableFunctionalTerm getConversionFromRDFLexical2DB(ImmutableTerm dbTerm,
                                                              RDFTermType rdfType)

Specified by:: getConversionFromRDFLexical2DB in interface TermFactory

getPartiallyDefinedToStringCast
```
public ImmutableFunctionalTerm getPartiallyDefinedToStringCast(Variable variable)
```
Description copied from interface: TermFactory

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

Specified by:

getPartiallyDefinedToStringCast in interface TermFactory

getRDF2DBBooleanFunctionalTerm

public ImmutableExpression getRDF2DBBooleanFunctionalTerm(ImmutableTerm xsdBooleanTerm)

Specified by:: getRDF2DBBooleanFunctionalTerm in interface TermFactory

getIfElseNull

public ImmutableFunctionalTerm getIfElseNull(ImmutableExpression condition,
                                             ImmutableTerm term)

Specified by:: getIfElseNull in interface TermFactory

getBooleanIfElseNull

public ImmutableExpression getBooleanIfElseNull(ImmutableExpression condition,
                                                ImmutableExpression thenExpression)

Specified by:: getBooleanIfElseNull in interface TermFactory

getIfThenElse

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

Specified by:: getIfThenElse in interface TermFactory

getDBCase

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

Description copied from interface: TermFactory

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

Specified by:: getDBCase in interface TermFactory

getDBCaseElseNull

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

Description copied from interface: TermFactory

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

Specified by:: getDBCaseElseNull in interface TermFactory

getDBBooleanCase

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

Specified by:: getDBBooleanCase in interface TermFactory

getDBCoalesce

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

Specified by:: getDBCoalesce in interface TermFactory

getDBCoalesce

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

Specified by:: getDBCoalesce in interface TermFactory

getDBReplace

public ImmutableFunctionalTerm getDBReplace(ImmutableTerm text,
                                            ImmutableTerm from,
                                            ImmutableTerm to)

Specified by:: getDBReplace in interface TermFactory

getDBRegexpReplace

public ImmutableFunctionalTerm getDBRegexpReplace(ImmutableTerm text,
                                                  ImmutableTerm from,
                                                  ImmutableTerm to)

Specified by:: getDBRegexpReplace in interface TermFactory

getDBRegexpReplace

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

Specified by:: getDBRegexpReplace in interface TermFactory

getDBStartsWith

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

Specified by:: getDBStartsWith in interface TermFactory

getDBEndsWith

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

Specified by:: getDBEndsWith in interface TermFactory

getDBContains

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

Specified by:: getDBContains in interface TermFactory

getDBRegexpMatches

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

Specified by:: getDBRegexpMatches in interface TermFactory

getR2RMLIRISafeEncodeFunctionalTerm
```
public ImmutableFunctionalTerm getR2RMLIRISafeEncodeFunctionalTerm(ImmutableTerm term)
```
Specified by:

getR2RMLIRISafeEncodeFunctionalTerm in interface TermFactory

getNullRejectingDBConcatFunctionalTerm
```
public ImmutableFunctionalTerm getNullRejectingDBConcatFunctionalTerm(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
```
Description copied from interface: TermFactory

At least two terms are expected

Specified by:

getNullRejectingDBConcatFunctionalTerm in interface TermFactory

getCommonDenominatorFunctionalTerm

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

Specified by:: getCommonDenominatorFunctionalTerm in interface TermFactory

getStrictEquality
```
public ImmutableExpression getStrictEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms)
```
Description copied from interface: TermFactory

terms must have at least two distinct elements

Specified by:

getStrictEquality in interface TermFactory

getStrictEquality
```
public ImmutableExpression getStrictEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
```
Description copied from interface: TermFactory

terms must have at least two elements

Specified by:

getStrictEquality in interface TermFactory

getStrictEquality

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

Specified by:: getStrictEquality in interface TermFactory

getStrictNEquality
```
public ImmutableExpression getStrictNEquality(com.google.common.collect.ImmutableSet<ImmutableTerm> terms)
```
Description copied from interface: TermFactory

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

Specified by:

getStrictNEquality in interface TermFactory

getDBIsStringEmpty

public ImmutableExpression getDBIsStringEmpty(ImmutableTerm stringTerm)

Specified by:: getDBIsStringEmpty in interface TermFactory

getStrictNEquality
```
public ImmutableExpression getStrictNEquality(com.google.common.collect.ImmutableList<? extends ImmutableTerm> terms)
```
Description copied from interface: TermFactory

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

Specified by:

getStrictNEquality in interface TermFactory

getStrictNEquality

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

Specified by:: getStrictNEquality in interface TermFactory

getIsTrue
```
public ImmutableExpression getIsTrue(NonFunctionalTerm dbBooleanTerm)
```
Description copied from interface: TermFactory

Wraps a DB boolean constant/variable into an ImmutableExpression

Specified by:

getIsTrue in interface TermFactory

getDBSubString2

public ImmutableFunctionalTerm getDBSubString2(ImmutableTerm stringTerm,
                                               ImmutableTerm from)

Specified by:: getDBSubString2 in interface TermFactory

getDBSubString3

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

Specified by:: getDBSubString3 in interface TermFactory

getDBRight

public ImmutableFunctionalTerm getDBRight(ImmutableTerm stringTerm,
                                          ImmutableTerm lengthTerm)

Specified by:: getDBRight in interface TermFactory

getDBUpper

public ImmutableFunctionalTerm getDBUpper(ImmutableTerm stringTerm)

Specified by:: getDBUpper in interface TermFactory

getDBLower

public ImmutableFunctionalTerm getDBLower(ImmutableTerm stringTerm)

Specified by:: getDBLower in interface TermFactory

getLangTypeFunctionalTerm
```
public ImmutableFunctionalTerm getLangTypeFunctionalTerm(ImmutableTerm rdfTypeTerm)
```
Description copied from interface: TermFactory

Do NOT confuse it with the LANG SPARQL function

Specified by:

getLangTypeFunctionalTerm in interface TermFactory

getLexicalLangMatches

public ImmutableExpression getLexicalLangMatches(ImmutableTerm langTagTerm,
                                                 ImmutableTerm langRangeTerm)

Description copied from interface: TermFactory

Do NOT confuse it with the langMatches SPARQL function

Specified by:: getLexicalLangMatches in interface TermFactory

Class TermFactoryImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getConstantIRI

getConstantIRI

getRDFLiteralConstant

getRDFLiteralConstant

getRDFLiteralConstant

getRDFConstant

getRDFLiteralFunctionalTerm

getRDFLiteralFunctionalTerm

getDBConstant

getDBStringConstant

getRDFLiteralFunctionalTerm

getVariable

getRDFTermTypeConstant

getRDFTermTypeFunctionalTerm

getImmutableExpression

getImmutableExpression

getConjunction

getConjunction

getConjunction

getDisjunction

getDisjunction

getDisjunction

getDBNot

getFalseOrNullFunctionalTerm

getTrueOrNullFunctionalTerm

getIsAExpression

getAreCompatibleRDFStringExpression

getEvaluation

getPositiveEvaluation

getNegativeEvaluation

getNullEvaluation

getFunctionalTermDecomposition

getFunctionalTermDecomposition

getImmutableFunctionalTerm

getImmutableFunctionalTerm

getNonGroundFunctionalTerm

getNonGroundFunctionalTerm

getTypeFactory

createDummyVariableNullability

getRDFDatatypeStringFunctionalTerm

getDBUUID

getDBStrBefore

getDBStrAfter

getDBCharLength

getDBIsNull

getDBIsNotNull

getDBMd5

getDBSha1

getDBSha256

getDBSha512

getCommonPropagatedOrSubstitutedNumericType

getDBFunctionSymbolFactory

getProtoSubstitution

getBinaryNumericLexicalFunctionalTerm

getDBBinaryNumericFunctionalTerm

getUnaryLatelyTypedFunctionalTerm

getUnaryLexicalFunctionalTerm

getSPARQLNonStrictEquality

getSPARQLEffectiveBooleanValue

getLexicalEffectiveBooleanValue

getDBRand

getDBYearFromDatetime

getDBMonthFromDatetime

getDBDayFromDatetime

getDBHours

getDBMinutes

getDBSeconds

getDBTz

getDBNow

getDBCount

getDBCount

getDBSum

getDBAvg

getDBMin

getDBMax

getDBGroupConcat