org.aksw.sparqlify.core.datatypes

Interface TypeSystem

All Known Implementing Classes:

DatatypeSystemCustom

public interface TypeSystem

A class with knowlegde about the type hierarchy. For instance, given two datatypes, it is possible to determine the most general datatype (int, float -> numeric), or the mightier of the two (float, double) -> double. Essentially, the dataypes form a tree,

Author:

raven

Method Summary

Methods

Modifier and Type	Method and Description
com.hp.hpl.jena.sparql.expr.NodeValue	cast(com.hp.hpl.jena.sparql.expr.NodeValue value, TypeToken target)
Factory1<SqlExpr>	cast(TypeToken from, TypeToken to) Return a factory for creating cast-expressions between the given datatypes Null if no such cast exists.
Integer	compare(TypeToken a, TypeToken b) Returns -1, 0, 1 if a is more specific, equal, more general the b.
SparqlFunction	createSparqlFunction(String name, SqlExprEvaluator evaluator)
XClass	getByClass(Class<?> clazz) Deprecated.
XClass	getByName(String name)
XClass	getByName(TypeToken token)
List<TypeToken>	getDirectSuperClasses(TypeToken type)
SparqlFunction	getSparqlFunction(String name)
TypeToken	getTokenForClass(Class<?> clazz)
boolean	isSuperClassOf(TypeToken a, TypeToken b)
SqlMethodCandidate	lookupMethod(String sparqlFunctionName, List<TypeToken> argTypes)
TypeToken	mostGenericDatatype(TypeToken from, TypeToken to) Returns the top-most node of the tree of compatible datatypes Hm, how to justify not returning object? so integer and string -> numeric string -> text The rationale is, that all numeric types have similar semantics in regard to comparison and arithmetic operations.
void	registerCoercion(XMethod method)
void	registerSqlFunction(String sparqlFunctionName, XMethod sqlFunction)
XClass	requireByName(String name)
Set<TypeToken>	supremumDatatypes(TypeToken from, TypeToken to)

Method Detail

createSparqlFunction

SparqlFunction createSparqlFunction(String name,
                                  SqlExprEvaluator evaluator)

registerSqlFunction

void registerSqlFunction(String sparqlFunctionName,
                       XMethod sqlFunction)

getByName

XClass getByName(String name)

getByName

XClass getByName(TypeToken token)

getByClass

@Deprecated
XClass getByClass(Class<?> clazz)

Deprecated.

getTokenForClass

TypeToken getTokenForClass(Class<?> clazz)

requireByName

XClass requireByName(String name)

registerCoercion

void registerCoercion(XMethod method)

getSparqlFunction

SparqlFunction getSparqlFunction(String name)

lookupMethod

SqlMethodCandidate lookupMethod(String sparqlFunctionName,
                              List<TypeToken> argTypes)

getDirectSuperClasses

List<TypeToken> getDirectSuperClasses(TypeToken type)

cast

com.hp.hpl.jena.sparql.expr.NodeValue cast(com.hp.hpl.jena.sparql.expr.NodeValue value,
                                         TypeToken target)

cast

Factory1<SqlExpr> cast(TypeToken from,
                     TypeToken to)

Return a factory for creating cast-expressions between the given datatypes Null if no such cast exists. Constant folding may be performed, but do not rely on it. So cast(string, int).create(NodeValue.makeString('666')) may return Cast((string, int), NodeValue('666')) rather than NodeValue.makeInteger(666)

isSuperClassOf

boolean isSuperClassOf(TypeToken a,
                     TypeToken b)

mostGenericDatatype

TypeToken mostGenericDatatype(TypeToken from,
                            TypeToken to)

Returns the top-most node of the tree of compatible datatypes Hm, how to justify not returning object? so integer and string -> numeric string -> text The rationale is, that all numeric types have similar semantics in regard to comparison and arithmetic operations. However mixing string and numeric is invalid.

Parameters:

from -

to -

Returns:

supremumDatatypes

Set<TypeToken> supremumDatatypes(TypeToken from,
                               TypeToken to)

compare

Integer compare(TypeToken a,
              TypeToken b)

Returns -1, 0, 1 if a is more specific, equal, more general the b. null if no subsumption relation exists

Parameters:

a -

b -

Returns: