rdflib.plugins.sparql package

Subpackages

Submodules

rdflib.plugins.sparql.aggregates module

class rdflib.plugins.sparql.aggregates.Accumulator(aggregation)[source]

Bases: object

abstract base class for different aggregation functions

Parameters

aggregation (CompValue) –

__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.aggregates', '__doc__': 'abstract base class for different aggregation functions', '__init__': <function Accumulator.__init__>, 'dont_care': <function Accumulator.dont_care>, 'use_row': <function Accumulator.use_row>, 'set_value': <function Accumulator.set_value>, '__dict__': <attribute '__dict__' of 'Accumulator' objects>, '__weakref__': <attribute '__weakref__' of 'Accumulator' objects>, '__annotations__': {'get_value': 'Callable[[], Optional[Literal]]', 'update': "Callable[[FrozenBindings, 'Aggregator'], None]", 'seen': 'Set[Any]'}})
__init__(aggregation)[source]
Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
__weakref__

list of weak references to the object (if defined)

dont_care(row)[source]

skips distinct test

Parameters

row (FrozenBindings) –

Return type

bool

set_value(bindings)[source]

sets final value in bindings

Parameters

bindings (MutableMapping[Variable, Identifier]) –

Return type

None

use_row(row)[source]

tests distinct with set

Parameters

row (FrozenBindings) –

Return type

bool

class rdflib.plugins.sparql.aggregates.Aggregator(aggregations)[source]

Bases: object

combines different Accumulator objects

Parameters

aggregations (List[CompValue]) –

__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.aggregates', '__doc__': 'combines different Accumulator objects', 'accumulator_classes': {'Aggregate_Count': <class 'rdflib.plugins.sparql.aggregates.Counter'>, 'Aggregate_Sample': <class 'rdflib.plugins.sparql.aggregates.Sample'>, 'Aggregate_Sum': <class 'rdflib.plugins.sparql.aggregates.Sum'>, 'Aggregate_Avg': <class 'rdflib.plugins.sparql.aggregates.Average'>, 'Aggregate_Min': <class 'rdflib.plugins.sparql.aggregates.Minimum'>, 'Aggregate_Max': <class 'rdflib.plugins.sparql.aggregates.Maximum'>, 'Aggregate_GroupConcat': <class 'rdflib.plugins.sparql.aggregates.GroupConcat'>}, '__init__': <function Aggregator.__init__>, 'update': <function Aggregator.update>, 'get_bindings': <function Aggregator.get_bindings>, '__dict__': <attribute '__dict__' of 'Aggregator' objects>, '__weakref__': <attribute '__weakref__' of 'Aggregator' objects>, '__annotations__': {'bindings': 'Dict[Variable, Identifier]', 'accumulators': 'Dict[str, Accumulator]'}})
__init__(aggregations)[source]
Parameters

aggregations (List[CompValue]) –

__module__ = 'rdflib.plugins.sparql.aggregates'
__weakref__

list of weak references to the object (if defined)

accumulator_classes = {'Aggregate_Avg': <class 'rdflib.plugins.sparql.aggregates.Average'>, 'Aggregate_Count': <class 'rdflib.plugins.sparql.aggregates.Counter'>, 'Aggregate_GroupConcat': <class 'rdflib.plugins.sparql.aggregates.GroupConcat'>, 'Aggregate_Max': <class 'rdflib.plugins.sparql.aggregates.Maximum'>, 'Aggregate_Min': <class 'rdflib.plugins.sparql.aggregates.Minimum'>, 'Aggregate_Sample': <class 'rdflib.plugins.sparql.aggregates.Sample'>, 'Aggregate_Sum': <class 'rdflib.plugins.sparql.aggregates.Sum'>}
get_bindings()[source]

calculate and set last values

Return type

Mapping[Variable, Identifier]

update(row)[source]

update all own accumulators

Parameters

row (FrozenBindings) –

Return type

None

class rdflib.plugins.sparql.aggregates.Average(aggregation)[source]

Bases: Accumulator

Parameters

aggregation (CompValue) –

__init__(aggregation)[source]
Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
get_value()[source]
Return type

Literal

seen: Set[Any]
update(row, aggregator)[source]
Parameters
Return type

None

class rdflib.plugins.sparql.aggregates.Counter(aggregation)[source]

Bases: Accumulator

Parameters

aggregation (CompValue) –

__init__(aggregation)[source]
Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
eval_full_row(row)[source]
Parameters

row (FrozenBindings) –

Return type

FrozenBindings

eval_row(row)[source]
Parameters

row (FrozenBindings) –

Return type

Identifier

get_value()[source]
Return type

Literal

seen: Set[Any]
update(row, aggregator)[source]
Parameters
Return type

None

use_row(row)[source]

tests distinct with set

Parameters

row (FrozenBindings) –

Return type

bool

class rdflib.plugins.sparql.aggregates.Extremum(aggregation)[source]

Bases: Accumulator

abstract base class for Minimum and Maximum

Parameters

aggregation (CompValue) –

__init__(aggregation)[source]
Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
get_value: Callable[[], Optional[Literal]]
seen: Set[Any]
set_value(bindings)[source]

sets final value in bindings

Parameters

bindings (MutableMapping[Variable, Identifier]) –

Return type

None

update(row, aggregator)[source]
Parameters
Return type

None

class rdflib.plugins.sparql.aggregates.GroupConcat(aggregation)[source]

Bases: Accumulator

__init__(aggregation)[source]
__module__ = 'rdflib.plugins.sparql.aggregates'
get_value()[source]
Return type

Literal

seen: Set[Any]
update(row, aggregator)[source]
Parameters
Return type

None

class rdflib.plugins.sparql.aggregates.Maximum(aggregation)[source]

Bases: Extremum

Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
compare(val1, val2)[source]
Parameters
Return type

TypeVar(_ValueT, Variable, BNode, URIRef, Literal)

get_value: Callable[[], Optional[Literal]]
seen: Set[Any]
value: Any
class rdflib.plugins.sparql.aggregates.Minimum(aggregation)[source]

Bases: Extremum

Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
compare(val1, val2)[source]
Parameters
Return type

TypeVar(_ValueT, Variable, BNode, URIRef, Literal)

get_value: Callable[[], Optional[Literal]]
seen: Set[Any]
value: Any
class rdflib.plugins.sparql.aggregates.Sample(aggregation)[source]

Bases: Accumulator

takes the first eligible value

__init__(aggregation)[source]
__module__ = 'rdflib.plugins.sparql.aggregates'
get_value()[source]
Return type

None

seen: Set[Any]
update(row, aggregator)[source]
Parameters
Return type

None

class rdflib.plugins.sparql.aggregates.Sum(aggregation)[source]

Bases: Accumulator

Parameters

aggregation (CompValue) –

__init__(aggregation)[source]
Parameters

aggregation (CompValue) –

__module__ = 'rdflib.plugins.sparql.aggregates'
get_value()[source]
Return type

Literal

seen: Set[Any]
update(row, aggregator)[source]
Parameters
Return type

None

rdflib.plugins.sparql.aggregates.type_safe_numbers(*args: int) → Tuple[int][source]
rdflib.plugins.sparql.aggregates.type_safe_numbers(*args: Union[Decimal, float, int]) → Tuple[Union[float, int]]
Parameters

args (Union[Decimal, float, int]) –

Return type

Iterable[Union[float, int]]

rdflib.plugins.sparql.algebra module

rdflib.plugins.sparql.algebra.BGP(triples=None)[source]
Parameters

triples (Optional[List[Tuple[Identifier, Identifier, Identifier]]]) –

Return type

CompValue

exception rdflib.plugins.sparql.algebra.ExpressionNotCoveredException[source]

Bases: Exception

__module__ = 'rdflib.plugins.sparql.algebra'
__weakref__

list of weak references to the object (if defined)

rdflib.plugins.sparql.algebra.Extend(p, expr, var)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Filter(expr, p)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Graph(term, graph)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Group(p, expr=None)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Join(p1, p2)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.LeftJoin(p1, p2, expr)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Minus(p1, p2)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.OrderBy(p, expr)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Project(p, PV)[source]
Parameters
Return type

CompValue

exception rdflib.plugins.sparql.algebra.StopTraversal(rv)[source]

Bases: Exception

Parameters

rv (bool) –

__init__(rv)[source]
Parameters

rv (bool) –

__module__ = 'rdflib.plugins.sparql.algebra'
__weakref__

list of weak references to the object (if defined)

rdflib.plugins.sparql.algebra.ToMultiSet(p)[source]
Parameters

p (Union[List[Dict[Variable, str]], CompValue]) –

Return type

CompValue

rdflib.plugins.sparql.algebra.Union(p1, p2)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.Values(res)[source]
Parameters

res (List[Dict[Variable, str]]) –

Return type

CompValue

rdflib.plugins.sparql.algebra.analyse(n, children)[source]

Some things can be lazily joined. This propegates whether they can up the tree and sets lazy flags for all joins

Parameters

  • n (Any) –

  • children (Any) –

Return type

bool

rdflib.plugins.sparql.algebra.collectAndRemoveFilters(parts)[source]

FILTER expressions apply to the whole group graph pattern in which they appear.

http://www.w3.org/TR/sparql11-query/#sparqlCollectFilters

Parameters

parts (List[CompValue]) –

Return type

Optional[Expr]

rdflib.plugins.sparql.algebra.pprintAlgebra(q)[source]
Return type

None

rdflib.plugins.sparql.algebra.reorderTriples(l_)[source]

Reorder triple patterns so that we execute the ones with most bindings first

Parameters

l_ (Iterable[Tuple[Identifier, Identifier, Identifier]]) –

Return type

List[Tuple[Identifier, Identifier, Identifier]]

rdflib.plugins.sparql.algebra.simplify(n)[source]

Remove joins to empty BGPs

Parameters

n (Any) –

Return type

Optional[CompValue]

rdflib.plugins.sparql.algebra.translate(q)[source]

http://www.w3.org/TR/sparql11-query/#convertSolMod

Parameters

q (CompValue) –

Return type

Tuple[Optional[CompValue], List[Variable]]

rdflib.plugins.sparql.algebra.translateAggregates(q, M)[source]
Parameters
Return type

Tuple[CompValue, List[Tuple[Variable, Variable]]]

rdflib.plugins.sparql.algebra.translateAlgebra(query_algebra)[source]
Parameters

query_algebra (Query) – An algebra returned by the function call algebra.translateQuery(parse_tree).

Return type

str

Returns

The query form generated from the SPARQL 1.1 algebra tree for select queries.

rdflib.plugins.sparql.algebra.translateExists(e)[source]

Translate the graph pattern used by EXISTS and NOT EXISTS http://www.w3.org/TR/sparql11-query/#sparqlCollectFilters

Parameters

e (Union[Expr, Literal, Variable, URIRef]) –

Return type

Union[Expr, Literal, Variable, URIRef]

rdflib.plugins.sparql.algebra.translateGraphGraphPattern(graphPattern)[source]
Parameters

graphPattern (CompValue) –

Return type

CompValue

rdflib.plugins.sparql.algebra.translateGroupGraphPattern(graphPattern)[source]

http://www.w3.org/TR/sparql11-query/#convertGraphPattern

Parameters

graphPattern (CompValue) –

Return type

CompValue

rdflib.plugins.sparql.algebra.translateGroupOrUnionGraphPattern(graphPattern)[source]
Parameters

graphPattern (CompValue) –

Return type

Optional[CompValue]

rdflib.plugins.sparql.algebra.translateInlineData(graphPattern)[source]
Parameters

graphPattern (CompValue) –

Return type

CompValue

rdflib.plugins.sparql.algebra.translatePName(p, prologue)[source]

Expand prefixed/relative URIs

Parameters
Return type

Optional[Identifier]

rdflib.plugins.sparql.algebra.translatePath(p: URIRef) → None[source]
rdflib.plugins.sparql.algebra.translatePath(p: CompValue) → Path

Translate PropertyPath expressions

Parameters

p (Union[CompValue, URIRef]) –

Return type

Optional[Path]

rdflib.plugins.sparql.algebra.translatePrologue(p, base, initNs=None, prologue=None)[source]
Parameters
Return type

Prologue

rdflib.plugins.sparql.algebra.translateQuads(quads)[source]
Parameters

quads (CompValue) –

Return type

Tuple[List[Tuple[Identifier, Identifier, Identifier]], DefaultDict[str, List[Tuple[Identifier, Identifier, Identifier]]]]

rdflib.plugins.sparql.algebra.translateQuery(q, base=None, initNs=None)[source]

Translate a query-parsetree to a SPARQL Algebra Expression

Return a rdflib.plugins.sparql.sparql.Query object

Parameters
Return type

Query

rdflib.plugins.sparql.algebra.translateUpdate(q, base=None, initNs=None)[source]

Returns a list of SPARQL Update Algebra expressions

Parameters
Return type

Update

rdflib.plugins.sparql.algebra.translateUpdate1(u, prologue)[source]
Parameters
Return type

CompValue

rdflib.plugins.sparql.algebra.translateValues(v)[source]
Parameters

v (CompValue) –

Return type

Union[List[Dict[Variable, str]], CompValue]

rdflib.plugins.sparql.algebra.traverse(tree, visitPre=<function <lambda>>, visitPost=<function <lambda>>, complete=None)[source]

Traverse tree, visit each node with visit function visit function may raise StopTraversal to stop traversal if complete!=None, it is returned on complete traversal, otherwise the transformed tree is returned

Parameters
Return type

Any

rdflib.plugins.sparql.algebra.triples(l)[source]
Parameters

l (Union[List[List[Identifier]], List[Tuple[Identifier, Identifier, Identifier]]]) –

Return type

List[Tuple[Identifier, Identifier, Identifier]]

rdflib.plugins.sparql.datatypes module

rdflib.plugins.sparql.datatypes.type_promotion(t1, t2)[source]
Parameters
Return type

URIRef

rdflib.plugins.sparql.evaluate module

rdflib.plugins.sparql.evaluate.evalAggregateJoin(ctx, agg)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalAskQuery(ctx, query)[source]
Parameters
Return type

Mapping[str, Union[str, bool]]

rdflib.plugins.sparql.evaluate.evalBGP(ctx, bgp)[source]

A basic graph pattern

Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalConstructQuery(ctx, query)[source]
Parameters
Return type

Mapping[str, Union[str, Graph]]

rdflib.plugins.sparql.evaluate.evalDescribeQuery(ctx, query)[source]
Parameters

ctx (QueryContext) –

Return type

Dict[str, Union[str, Graph]]

rdflib.plugins.sparql.evaluate.evalDistinct(ctx, part)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalExtend(ctx, extend)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalFilter(ctx, part)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalGraph(ctx, part)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalGroup(ctx, group)[source]

http://www.w3.org/TR/sparql11-query/#defn_algGroup

Parameters
rdflib.plugins.sparql.evaluate.evalJoin(ctx, join)[source]
Parameters
Return type

Generator[FrozenDict, None, None]

rdflib.plugins.sparql.evaluate.evalLazyJoin(ctx, join)[source]

A lazy join will push the variables bound in the first part to the second part, essentially doing the join implicitly hopefully evaluating much fewer triples

Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalLeftJoin(ctx, join)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalMinus(ctx, minus)[source]
Parameters
Return type

Generator[FrozenDict, None, None]

rdflib.plugins.sparql.evaluate.evalMultiset(ctx, part)[source]
Parameters
rdflib.plugins.sparql.evaluate.evalOrderBy(ctx, part)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalPart(ctx, part)[source]
Parameters
Return type

Any

rdflib.plugins.sparql.evaluate.evalProject(ctx, project)[source]
Parameters
rdflib.plugins.sparql.evaluate.evalQuery(graph, query, initBindings, base=None)[source]

Caution

This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in SERVICE directives.

When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access.

For information on available security measures, see the RDFLib Security Considerations documentation.

Parameters
Return type

Mapping[Any, Any]

rdflib.plugins.sparql.evaluate.evalReduced(ctx, part)[source]

apply REDUCED to result

REDUCED is not as strict as DISTINCT, but if the incoming rows were sorted it should produce the same result with limited extra memory and time per incoming row.

Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evaluate.evalSelectQuery(ctx, query)[source]
Parameters
Return type

Mapping[str, Union[str, List[Variable], Iterable[FrozenDict]]]

rdflib.plugins.sparql.evaluate.evalServiceQuery(ctx, part)[source]
Parameters
rdflib.plugins.sparql.evaluate.evalSlice(ctx, slice)[source]
Parameters
rdflib.plugins.sparql.evaluate.evalUnion(ctx, union)[source]
Parameters
Return type

Iterable[FrozenBindings]

rdflib.plugins.sparql.evaluate.evalValues(ctx, part)[source]
Parameters
Return type

Generator[FrozenBindings, None, None]

rdflib.plugins.sparql.evalutils module

rdflib.plugins.sparql.operators module

rdflib.plugins.sparql.operators.AdditiveExpression(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_ABS(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-abs

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_BNODE(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-bnode

Return type

BNode

rdflib.plugins.sparql.operators.Builtin_BOUND(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-bound

Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_CEIL(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-ceil

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_COALESCE(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-coalesce

Parameters

expr (Expr) –

rdflib.plugins.sparql.operators.Builtin_CONCAT(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-concat

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_CONTAINS(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strcontains

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_DATATYPE(e, ctx)[source]
Parameters

e (Expr) –

Return type

Optional[str]

rdflib.plugins.sparql.operators.Builtin_DAY(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_ENCODE_FOR_URI(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_EXISTS(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_FLOOR(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-floor

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_HOURS(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_IF(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-if

Parameters

expr (Expr) –

rdflib.plugins.sparql.operators.Builtin_IRI(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-iri

Parameters
Return type

URIRef

rdflib.plugins.sparql.operators.Builtin_LANG(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-lang

Returns the language tag of ltrl, if it has one. It returns “” if ltrl has no language tag. Note that the RDF data model does not include literals with an empty language tag.

Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_LANGMATCHES(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-langMatches

Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_LCASE(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_MD5(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_MINUTES(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_MONTH(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_NOW(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-now

Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_RAND(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#idp2133952

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_REGEX(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-regex Invokes the XPath fn:matches function to match text against a regular expression pattern. The regular expression language is defined in XQuery 1.0 and XPath 2.0 Functions and Operators section 7.6.1 Regular Expression Syntax

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_REPLACE(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-substr

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_ROUND(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-round

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SECONDS(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-seconds

Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SHA1(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SHA256(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SHA384(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SHA512(expr, ctx)[source]
Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STR(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRAFTER(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strafter

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRBEFORE(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strbefore

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRDT(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strdt

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRENDS(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strends

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRLANG(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strlang

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRLEN(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRSTARTS(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strstarts

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_STRUUID(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strdt

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_SUBSTR(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-substr

Parameters

expr (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_TIMEZONE(e, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-timezone

Return type

Literal

Returns

the timezone part of arg as an xsd:dayTimeDuration.

Raises

an error if there is no timezone.

Parameters

e (Expr) –

rdflib.plugins.sparql.operators.Builtin_TZ(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_UCASE(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_UUID(expr, ctx)[source]

http://www.w3.org/TR/sparql11-query/#func-strdt

Parameters

expr (Expr) –

Return type

URIRef

rdflib.plugins.sparql.operators.Builtin_YEAR(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.Builtin_isBLANK(expr, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_isIRI(expr, ctx)[source]
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_isLITERAL(expr, ctx)[source]
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_isNUMERIC(expr, ctx)[source]
Return type

Literal

rdflib.plugins.sparql.operators.Builtin_sameTerm(e, ctx)[source]
Parameters

e (Expr) –

Return type

Literal

rdflib.plugins.sparql.operators.ConditionalAndExpression(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.ConditionalOrExpression(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.EBV(rt: Literal) → bool[source]
rdflib.plugins.sparql.operators.EBV(rt: Union[Variable, IdentifiedNode, SPARQLError, Expr]) → NoReturn
rdflib.plugins.sparql.operators.EBV(rt: Union[Identifier, SPARQLError, Expr]) → Union[bool, NoReturn]

Effective Boolean Value (EBV)

  • If the argument is a typed literal with a datatype of xsd:boolean, the EBV is the value of that argument.

  • If the argument is a plain literal or a typed literal with a datatype of xsd:string, the EBV is false if the operand value has zero length; otherwise the EBV is true.

  • If the argument is a numeric type or a typed literal with a datatype derived from a numeric type, the EBV is false if the operand value is NaN or is numerically equal to zero; otherwise the EBV is true.

  • All other arguments, including unbound arguments, produce a type error.

Parameters

rt (Union[Identifier, SPARQLError, Expr]) –

Return type

bool

rdflib.plugins.sparql.operators.Function(e, ctx)[source]

Custom functions and casts

Parameters
Return type

Node

rdflib.plugins.sparql.operators.MultiplicativeExpression(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.RelationalExpression(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.UnaryMinus(expr, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.UnaryNot(expr, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.UnaryPlus(expr, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.and_(*args)[source]
Parameters

args (Expr) –

Return type

Expr

rdflib.plugins.sparql.operators.calculateDuration(obj1, obj2)[source]

returns the duration Literal between two datetime

Parameters
Return type

Literal

rdflib.plugins.sparql.operators.calculateFinalDateTime(obj1, dt1, obj2, dt2, operation)[source]

Calculates the final dateTime/date/time resultant after addition/ subtraction of duration/dayTimeDuration/yearMonthDuration

Parameters
Return type

Literal

rdflib.plugins.sparql.operators.custom_function(uri, override=False, raw=False)[source]

Decorator version of register_custom_function().

Parameters
Return type

Callable[[Callable[[Expr, FrozenBindings], Node]], Callable[[Expr, FrozenBindings], Node]]

rdflib.plugins.sparql.operators.date(e)[source]
Parameters

e (Literal) –

Return type

date

rdflib.plugins.sparql.operators.dateTimeObjects(expr)[source]

return a dataTime/date/time/duration/dayTimeDuration/yearMonthDuration python objects from a literal

Parameters

expr (Literal) –

Return type

Any

rdflib.plugins.sparql.operators.datetime(e)[source]
Parameters

e (Literal) –

Return type

datetime

rdflib.plugins.sparql.operators.default_cast(e, ctx)[source]
Parameters
Return type

Literal

rdflib.plugins.sparql.operators.isCompatibleDateTimeDatatype(obj1, dt1, obj2, dt2)[source]

Returns a boolean indicating if first object is compatible with operation(+/-) over second object.

Parameters
Return type

bool

rdflib.plugins.sparql.operators.literal(s)[source]
Parameters

s (Literal) –

Return type

Literal

rdflib.plugins.sparql.operators.not_(arg)[source]
Return type

Expr

rdflib.plugins.sparql.operators.numeric(expr)[source]

return a number from a literal http://www.w3.org/TR/xpath20/#promotion

or TypeError

Parameters

expr (Literal) –

Return type

Any

rdflib.plugins.sparql.operators.register_custom_function(uri, func, override=False, raw=False)[source]

Register a custom SPARQL function.

By default, the function will be passed the RDF terms in the argument list. If raw is True, the function will be passed an Expression and a Context.

The function must return an RDF term, or raise a SparqlError.

Parameters
Return type

None

rdflib.plugins.sparql.operators.simplify(expr)[source]
Parameters

expr (Any) –

Return type

Any

rdflib.plugins.sparql.operators.string(s)[source]

Make sure the passed thing is a string literal i.e. plain literal, xsd:string literal or lang-tagged literal

Parameters

s (Literal) –

Return type

Literal

rdflib.plugins.sparql.operators.unregister_custom_function(uri, func=None)[source]

The ‘func’ argument is included for compatibility with existing code. A previous implementation checked that the function associated with the given uri was actually ‘func’, but this is not necessary as the uri should uniquely identify the function.

Parameters
Return type

None

rdflib.plugins.sparql.parser module

SPARQL 1.1 Parser

based on pyparsing

rdflib.plugins.sparql.parser.expandBNodeTriples(terms)[source]

expand [ ?p ?o ] syntax for implicit bnodes

Parameters

terms (ParseResults) –

Return type

List[Any]

rdflib.plugins.sparql.parser.expandCollection(terms)[source]

expand ( 1 2 3 ) notation for collections

Parameters

terms (ParseResults) –

Return type

List[List[Any]]

rdflib.plugins.sparql.parser.expandTriples(terms)[source]

Expand ; and , syntax for repeat predicates, subjects

Parameters

terms (ParseResults) –

Return type

List[Any]

rdflib.plugins.sparql.parser.expandUnicodeEscapes(q)[source]

The syntax of the SPARQL Query Language is expressed over code points in Unicode [UNICODE]. The encoding is always UTF-8 [RFC3629]. Unicode code points may also be expressed using an uXXXX (U+0 to U+FFFF) or UXXXXXXXX syntax (for U+10000 onwards) where X is a hexadecimal digit [0-9A-F]

Parameters

q (str) –

Return type

str

rdflib.plugins.sparql.parser.neg(literal)[source]
Parameters

literal (Literal) –

Return type

Literal

rdflib.plugins.sparql.parser.parseQuery(q)[source]
Parameters

q (Union[str, bytes, TextIO, BinaryIO]) –

Return type

ParseResults

rdflib.plugins.sparql.parser.parseUpdate(q)[source]
Parameters

q (Union[str, bytes, TextIO, BinaryIO]) –

Return type

CompValue

rdflib.plugins.sparql.parser.setDataType(terms)[source]
Parameters

terms (Tuple[Any, Optional[str]]) –

Return type

Literal

rdflib.plugins.sparql.parser.setLanguage(terms)[source]
Parameters

terms (Tuple[Any, Optional[str]]) –

Return type

Literal

rdflib.plugins.sparql.parserutils module

class rdflib.plugins.sparql.parserutils.Comp(name, expr)[source]

Bases: TokenConverter

A pyparsing token for grouping together things with a label Any sub-tokens that are not Params will be ignored.

Returns CompValue / Expr objects - depending on whether evalFn is set.

Parameters

name (str) –

__abstractmethods__ = frozenset({})
__init__(name, expr)[source]
Parameters

name (str) –

__module__ = 'rdflib.plugins.sparql.parserutils'
__slotnames__ = []
postParse(instring, loc, tokenList)[source]
Parameters

  • instring (str) –

  • loc (int) –

  • tokenList (ParseResults) –

Return type

Union[Expr, CompValue]

setEvalFn(evalfn)[source]
Parameters

evalfn (Callable[[Any, Any], Any]) –

Return type

Comp

class rdflib.plugins.sparql.parserutils.CompValue(name, **values)[source]

Bases: OrderedDict

The result of parsing a Comp Any included Params are available as Dict keys or as attributes

Parameters

name (str) –

__getattr__(a)[source]
Parameters

a (str) –

Return type

Any

__getitem__(a)[source]

x.__getitem__(y) <==> x[y]

__init__(name, **values)[source]
Parameters

name (str) –

__module__ = 'rdflib.plugins.sparql.parserutils'
__repr__()[source]

Return repr(self).

Return type

str

__str__()[source]

Return str(self).

Return type

str

clone()[source]
Return type

CompValue

get(a, variables=False, errors=False)[source]

Return the value for key if key is in the dictionary, else default.

Parameters

  • variables (bool) –

  • errors (bool) –

class rdflib.plugins.sparql.parserutils.Expr(name, evalfn=None, **values)[source]

Bases: CompValue

A CompValue that is evaluatable

Parameters
__init__(name, evalfn=None, **values)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.parserutils'
eval(ctx={})[source]
Parameters

ctx (Any) –

Return type

Union[SPARQLError, Any]

class rdflib.plugins.sparql.parserutils.Param(name, expr, isList=False)[source]

Bases: TokenConverter

A pyparsing token for labelling a part of the parse-tree if isList is true repeat occurrences of ParamList have their values merged in a list

Parameters
__abstractmethods__ = frozenset({})
__init__(name, expr, isList=False)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.parserutils'
__slotnames__ = []
postParse2(tokenList)[source]
Parameters

tokenList (Union[List[Any], ParseResults]) –

Return type

ParamValue

class rdflib.plugins.sparql.parserutils.ParamList(name, expr)[source]

Bases: Param

A shortcut for a Param with isList=True

Parameters

name (str) –

__abstractmethods__ = frozenset({})
__init__(name, expr)[source]
Parameters

name (str) –

__module__ = 'rdflib.plugins.sparql.parserutils'
__slotnames__ = []
failAction: Optional[ParseFailAction]
ignoreExprs: List['ParserElement']
parseAction: List[ParseAction]
suppress_warnings_: List[Diagnostics]
class rdflib.plugins.sparql.parserutils.ParamValue(name, tokenList, isList)[source]

Bases: object

The result of parsing a Param This just keeps the name/value All cleverness is in the CompValue

Parameters
__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.parserutils', '__doc__': '\n    The result of parsing a Param\n    This just keeps the name/value\n    All cleverness is in the CompValue\n    ', '__init__': <function ParamValue.__init__>, '__str__': <function ParamValue.__str__>, '__dict__': <attribute '__dict__' of 'ParamValue' objects>, '__weakref__': <attribute '__weakref__' of 'ParamValue' objects>, '__annotations__': {}})
__init__(name, tokenList, isList)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.parserutils'
__str__()[source]

Return str(self).

Return type

str

__weakref__

list of weak references to the object (if defined)

rdflib.plugins.sparql.parserutils.prettify_parsetree(t, indent='', depth=0)[source]
Parameters

  • t (ParseResults) –

  • indent (str) –

  • depth (int) –

Return type

str

rdflib.plugins.sparql.parserutils.value(ctx, val, variables=False, errors=False)[source]

utility function for evaluating something…

Variables will be looked up in the context Normally, non-bound vars is an error, set variables=True to return unbound vars

Normally, an error raises the error, set errors=True to return error

Parameters
Return type

Any

rdflib.plugins.sparql.processor module

Code for tying SPARQL Engine into RDFLib

These should be automatically registered with RDFLib

class rdflib.plugins.sparql.processor.SPARQLProcessor(graph)[source]

Bases: Processor

__init__(graph)[source]
__module__ = 'rdflib.plugins.sparql.processor'
query(strOrQuery, initBindings={}, initNs={}, base=None, DEBUG=False)[source]

Evaluate a query with the given initial bindings, and initial namespaces. The given base is used to resolve relative URIs in the query and will be overridden by any BASE given in the query.

Caution

This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in SERVICE directives.

When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access.

For information on available security measures, see the RDFLib Security Considerations documentation.

Parameters
Return type

Mapping[str, Any]

class rdflib.plugins.sparql.processor.SPARQLResult(res)[source]

Bases: Result

Parameters

res (Mapping[str, Any]) –

__init__(res)[source]
Parameters

res (Mapping[str, Any]) –

__module__ = 'rdflib.plugins.sparql.processor'
askAnswer: Optional[bool]
graph: Optional['Graph']
vars: Optional[List['Variable']]

variables contained in the result.

class rdflib.plugins.sparql.processor.SPARQLUpdateProcessor(graph)[source]

Bases: UpdateProcessor

__init__(graph)[source]
__module__ = 'rdflib.plugins.sparql.processor'
update(strOrQuery, initBindings={}, initNs={})[source]

Caution

This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in SERVICE directives.

When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access.

For information on available security measures, see the RDFLib Security Considerations documentation.

Parameters
Return type

None

rdflib.plugins.sparql.processor.prepareQuery(queryString, initNs={}, base=None)[source]

Parse and translate a SPARQL Query

Parameters
Return type

Query

rdflib.plugins.sparql.processor.prepareUpdate(updateString, initNs={}, base=None)[source]

Parse and translate a SPARQL Update

Parameters
Return type

Update

rdflib.plugins.sparql.processor.processUpdate(graph, updateString, initBindings={}, initNs={}, base=None)[source]

Process a SPARQL Update Request returns Nothing on success or raises Exceptions on error

Parameters
Return type

None

rdflib.plugins.sparql.sparql module

exception rdflib.plugins.sparql.sparql.AlreadyBound[source]

Bases: SPARQLError

Raised when trying to bind a variable that is already bound!

__init__()[source]
__module__ = 'rdflib.plugins.sparql.sparql'
class rdflib.plugins.sparql.sparql.Bindings(outer=None, d=[])[source]

Bases: MutableMapping

A single level of a stack of variable-value bindings. Each dict keeps a reference to the dict below it, any failed lookup is propegated back

In python 3.3 this could be a collections.ChainMap

Parameters

outer (Optional[Bindings]) –

__abstractmethods__ = frozenset({})
__contains__(key)[source]
Parameters

key (Any) –

Return type

bool

__delitem__(key)[source]
Parameters

key (str) –

Return type

None

__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n\n    A single level of a stack of variable-value bindings.\n    Each dict keeps a reference to the dict below it,\n    any failed lookup is propegated back\n\n    In python 3.3 this could be a collections.ChainMap\n    ', '__init__': <function Bindings.__init__>, '__getitem__': <function Bindings.__getitem__>, '__contains__': <function Bindings.__contains__>, '__setitem__': <function Bindings.__setitem__>, '__delitem__': <function Bindings.__delitem__>, '__len__': <function Bindings.__len__>, '__iter__': <function Bindings.__iter__>, '__str__': <function Bindings.__str__>, '__repr__': <function Bindings.__repr__>, '__dict__': <attribute '__dict__' of 'Bindings' objects>, '__weakref__': <attribute '__weakref__' of 'Bindings' objects>, '__abstractmethods__': frozenset(), '_abc_impl': <_abc._abc_data object>, '__annotations__': {'_d': 'Dict[str, str]'}})
__getitem__(key)[source]
Parameters

key (str) –

Return type

str

__init__(outer=None, d=[])[source]
Parameters

outer (Optional[Bindings]) –

__iter__()[source]
Return type

Generator[str, None, None]

__len__()[source]
Return type

int

__module__ = 'rdflib.plugins.sparql.sparql'
__repr__()[source]

Return repr(self).

Return type

str

__setitem__(key, value)[source]
Parameters

  • key (str) –

  • value (Any) –

Return type

None

__str__()[source]

Return str(self).

Return type

str

__weakref__

list of weak references to the object (if defined)

class rdflib.plugins.sparql.sparql.FrozenBindings(ctx, *args, **kwargs)[source]

Bases: FrozenDict

Parameters

ctx (QueryContext) –

__abstractmethods__ = frozenset({})
__getitem__(key)[source]
Parameters

key (Union[Identifier, str]) –

Return type

Identifier

__init__(ctx, *args, **kwargs)[source]
Parameters

ctx (QueryContext) –

__module__ = 'rdflib.plugins.sparql.sparql'
property bnodes: Mapping[Identifier, BNode]
Return type

Mapping[Identifier, BNode]

forget(before, _except=None)[source]

return a frozen dict only of bindings made in self since before

Parameters
Return type

FrozenBindings

merge(other)[source]
Parameters

other (Mapping[Identifier, Identifier]) –

Return type

FrozenBindings

property now: datetime
Return type

datetime

project(vars)[source]
Parameters

vars (Container[Variable]) –

Return type

FrozenBindings

property prologue: Optional[Prologue]
Return type

Optional[Prologue]

remember(these)[source]

return a frozen dict only of bindings in these

Return type

FrozenBindings

class rdflib.plugins.sparql.sparql.FrozenDict(*args, **kwargs)[source]

Bases: Mapping

An immutable hashable dict

Taken from http://stackoverflow.com/a/2704866/81121

Parameters

  • args (Any) –

  • kwargs (Any) –

__abstractmethods__ = frozenset({})
__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n    An immutable hashable dict\n\n    Taken from http://stackoverflow.com/a/2704866/81121\n\n    ', '__init__': <function FrozenDict.__init__>, '__iter__': <function FrozenDict.__iter__>, '__len__': <function FrozenDict.__len__>, '__getitem__': <function FrozenDict.__getitem__>, '__hash__': <function FrozenDict.__hash__>, 'project': <function FrozenDict.project>, 'disjointDomain': <function FrozenDict.disjointDomain>, 'compatible': <function FrozenDict.compatible>, 'merge': <function FrozenDict.merge>, '__str__': <function FrozenDict.__str__>, '__repr__': <function FrozenDict.__repr__>, '__dict__': <attribute '__dict__' of 'FrozenDict' objects>, '__weakref__': <attribute '__weakref__' of 'FrozenDict' objects>, '__abstractmethods__': frozenset(), '_abc_impl': <_abc._abc_data object>, '__annotations__': {'_d': 'Dict[Identifier, Identifier]', '_hash': 'Optional[int]'}})
__getitem__(key)[source]
Parameters

key (Identifier) –

Return type

Identifier

__hash__()[source]

Return hash(self).

Return type

int

__init__(*args, **kwargs)[source]
Parameters

  • args (Any) –

  • kwargs (Any) –

__iter__()[source]
__len__()[source]
Return type

int

__module__ = 'rdflib.plugins.sparql.sparql'
__repr__()[source]

Return repr(self).

Return type

str

__str__()[source]

Return str(self).

Return type

str

__weakref__

list of weak references to the object (if defined)

compatible(other)[source]
Parameters

other (Mapping[Identifier, Identifier]) –

Return type

bool

disjointDomain(other)[source]
Parameters

other (Mapping[Identifier, Identifier]) –

Return type

bool

merge(other)[source]
Parameters

other (Mapping[Identifier, Identifier]) –

Return type

FrozenDict

project(vars)[source]
Parameters

vars (Container[Variable]) –

Return type

FrozenDict

exception rdflib.plugins.sparql.sparql.NotBoundError(msg=None)[source]

Bases: SPARQLError

Parameters

msg (Optional[str]) –

__init__(msg=None)[source]
Parameters

msg (Optional[str]) –

__module__ = 'rdflib.plugins.sparql.sparql'
class rdflib.plugins.sparql.sparql.Prologue[source]

Bases: object

A class for holding prefixing bindings and base URI information

__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n    A class for holding prefixing bindings and base URI information\n    ', '__init__': <function Prologue.__init__>, 'resolvePName': <function Prologue.resolvePName>, 'bind': <function Prologue.bind>, 'absolutize': <function Prologue.absolutize>, '__dict__': <attribute '__dict__' of 'Prologue' objects>, '__weakref__': <attribute '__weakref__' of 'Prologue' objects>, '__annotations__': {'base': 'Optional[str]'}})
__init__()[source]
__module__ = 'rdflib.plugins.sparql.sparql'
__weakref__

list of weak references to the object (if defined)

absolutize(iri)[source]

Apply BASE / PREFIXes to URIs (and to datatypes in Literals)

TODO: Move resolving URIs to pre-processing

Parameters

iri (Union[CompValue, str, None]) –

Return type

Union[CompValue, str, None]

bind(prefix, uri)[source]
Parameters
Return type

None

resolvePName(prefix, localname)[source]
Parameters
Return type

URIRef

class rdflib.plugins.sparql.sparql.Query(prologue, algebra)[source]

Bases: object

A parsed and translated query

Parameters
__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n    A parsed and translated query\n    ', '__init__': <function Query.__init__>, '__dict__': <attribute '__dict__' of 'Query' objects>, '__weakref__': <attribute '__weakref__' of 'Query' objects>, '__annotations__': {'_original_args': 'Tuple[str, Mapping[str, str], Optional[str]]'}})
__init__(prologue, algebra)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.sparql'
__weakref__

list of weak references to the object (if defined)

class rdflib.plugins.sparql.sparql.QueryContext(graph=None, bindings=None, initBindings=None)[source]

Bases: object

Query context - passed along when evaluating the query

Parameters
__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n    Query context - passed along when evaluating the query\n    ', '__init__': <function QueryContext.__init__>, 'now': <property object>, 'clone': <function QueryContext.clone>, 'dataset': <property object>, 'load': <function QueryContext.load>, '__getitem__': <function QueryContext.__getitem__>, 'get': <function QueryContext.get>, 'solution': <function QueryContext.solution>, '__setitem__': <function QueryContext.__setitem__>, 'pushGraph': <function QueryContext.pushGraph>, 'push': <function QueryContext.push>, 'clean': <function QueryContext.clean>, 'thaw': <function QueryContext.thaw>, '__dict__': <attribute '__dict__' of 'QueryContext' objects>, '__weakref__': <attribute '__weakref__' of 'QueryContext' objects>, '__annotations__': {'graph': 'Optional[Graph]', '_dataset': 'Optional[ConjunctiveGraph]', 'prologue': 'Optional[Prologue]', '_now': 'Optional[datetime.datetime]', 'bnodes': 't.MutableMapping[Identifier, BNode]'}})
__getitem__(key)[source]
Parameters

key (Union[str, Path]) –

Return type

Union[str, Path, None]

__init__(graph=None, bindings=None, initBindings=None)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.sparql'
__setitem__(key, value)[source]
Parameters

  • key (str) –

  • value (str) –

Return type

None

__weakref__

list of weak references to the object (if defined)

clean()[source]
Return type

QueryContext

clone(bindings=None)[source]
Parameters

bindings (Union[Bindings, FrozenBindings, List[Any], None]) –

Return type

QueryContext

property dataset: ConjunctiveGraph

“current dataset

Return type

ConjunctiveGraph

get(key, default=None)[source]
Parameters
Return type

Any

load(source, default=False, **kwargs)[source]
Parameters
Return type

None

property now: datetime
Return type

datetime

push()[source]
Return type

QueryContext

pushGraph(graph)[source]
Parameters

graph (Optional[Graph]) –

Return type

QueryContext

solution(vars=None)[source]

Return a static copy of the current variable bindings as dict

Parameters

vars (Optional[Iterable[Variable]]) –

Return type

FrozenBindings

thaw(frozenbindings)[source]

Create a new read/write query context from the given solution

Parameters

frozenbindings (FrozenBindings) –

Return type

QueryContext

exception rdflib.plugins.sparql.sparql.SPARQLError(msg=None)[source]

Bases: Exception

Parameters

msg (Optional[str]) –

__init__(msg=None)[source]
Parameters

msg (Optional[str]) –

__module__ = 'rdflib.plugins.sparql.sparql'
__weakref__

list of weak references to the object (if defined)

exception rdflib.plugins.sparql.sparql.SPARQLTypeError(msg)[source]

Bases: SPARQLError

Parameters

msg (Optional[str]) –

__init__(msg)[source]
Parameters

msg (Optional[str]) –

__module__ = 'rdflib.plugins.sparql.sparql'
class rdflib.plugins.sparql.sparql.Update(prologue, algebra)[source]

Bases: object

A parsed and translated update

Parameters
__dict__ = mappingproxy({'__module__': 'rdflib.plugins.sparql.sparql', '__doc__': '\n    A parsed and translated update\n    ', '__init__': <function Update.__init__>, '__dict__': <attribute '__dict__' of 'Update' objects>, '__weakref__': <attribute '__weakref__' of 'Update' objects>, '__annotations__': {'_original_args': 'Tuple[str, Mapping[str, str], Optional[str]]'}})
__init__(prologue, algebra)[source]
Parameters
__module__ = 'rdflib.plugins.sparql.sparql'
__weakref__

list of weak references to the object (if defined)

rdflib.plugins.sparql.update module

Code for carrying out Update Operations

rdflib.plugins.sparql.update.evalAdd(ctx, u)[source]

add all triples from src to dst

http://www.w3.org/TR/sparql11-update/#add

Parameters
Return type

None

rdflib.plugins.sparql.update.evalClear(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#clear

Parameters
Return type

None

rdflib.plugins.sparql.update.evalCopy(ctx, u)[source]

remove all triples from dst add all triples from src to dst

http://www.w3.org/TR/sparql11-update/#copy

Parameters
Return type

None

rdflib.plugins.sparql.update.evalCreate(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#create

Parameters
Return type

None

rdflib.plugins.sparql.update.evalDeleteData(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#deleteData

Parameters
Return type

None

rdflib.plugins.sparql.update.evalDeleteWhere(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#deleteWhere

Parameters
Return type

None

rdflib.plugins.sparql.update.evalDrop(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#drop

Parameters
Return type

None

rdflib.plugins.sparql.update.evalInsertData(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#insertData

Parameters
Return type

None

rdflib.plugins.sparql.update.evalLoad(ctx, u)[source]

http://www.w3.org/TR/sparql11-update/#load

Parameters
Return type

None

rdflib.plugins.sparql.update.evalModify(ctx, u)[source]
Parameters
Return type

None

rdflib.plugins.sparql.update.evalMove(ctx, u)[source]

remove all triples from dst add all triples from src to dst remove all triples from src

http://www.w3.org/TR/sparql11-update/#move

Parameters
Return type

None

rdflib.plugins.sparql.update.evalUpdate(graph, update, initBindings={})[source]

http://www.w3.org/TR/sparql11-update/#updateLanguage

‘A request is a sequence of operations […] Implementations MUST ensure that operations of a single request are executed in a fashion that guarantees the same effects as executing them in lexical order.

Operations all result either in success or failure.

If multiple operations are present in a single request, then a result of failure from any operation MUST abort the sequence of operations, causing the subsequent operations to be ignored.’

This will return None on success and raise Exceptions on error

Caution

This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in SERVICE directives.

When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access.

For information on available security measures, see the RDFLib Security Considerations documentation.

Parameters
Return type

None

Module contents

SPARQL implementation for RDFLib

New in version 4.0.

rdflib.plugins.sparql.CUSTOM_EVALS = {}

Custom evaluation functions

These must be functions taking (ctx, part) and raise NotImplementedError if they cannot handle a certain part

rdflib.plugins.sparql.prepareQuery(queryString, initNs={}, base=None)[source]

Parse and translate a SPARQL Query

Parameters
Return type

Query

rdflib.plugins.sparql.prepareUpdate(updateString, initNs={}, base=None)[source]

Parse and translate a SPARQL Update

Parameters
Return type

Update

rdflib.plugins.sparql.processUpdate(graph, updateString, initBindings={}, initNs={}, base=None)[source]

Process a SPARQL Update Request returns Nothing on success or raises Exceptions on error

Parameters
Return type

None