Query and compiler

ORM query builder; compiles Python filters to SPARQL.

class sparqlmodel.query.Query(session, model_cls)

Bases: object

ORM query builder for a SPARQLModel class.

__init__(session, model_cls)

polymorphic(enabled=True)

Include rdfs:subClassOf descendants of this model’s rdf_type.

Return type:

Query

values(**bindings)

Add a VALUES binding row (IRI/literal values for SPARQL variables).

Return type:

Query

Query expression types for the SPARQL compiler.

class sparqlmodel.expressions.CompareOp(*values)

Bases: str, Enum

class sparqlmodel.expressions.FieldRef(model_cls, field_name, path=())

Bases: object

Reference to a model field in a query expression.

str()

IRI field compared via STR(?) (after path hops).

Return type:

IriStrFieldRef

lower()

Case-insensitive compare via LCASE(STR(?)).

Return type:

IriStrFieldRef

upper()

Compare via UCASE(STR(?)).

Return type:

IriStrFieldRef

__init__(model_cls, field_name, path=())

class sparqlmodel.expressions.IriStrFieldRef(field, mode)

Bases: object

IRI field with SPARQL string function wrapper.

__init__(field, mode)

class sparqlmodel.expressions.IriStrCompare(left, op, right)

Bases: object

Compare STR / LCASE / UCASE of an IRI binding.

__init__(left, op, right)

class sparqlmodel.expressions.PropertyPathCompare(model_cls, sparql_path, op, right)

Bases: object

Filter using a SPARQL property path (escape hatch for ^, +, *).

__init__(model_cls, sparql_path, op, right)

class sparqlmodel.expressions.CompareExpr(left, op, right)

Bases: object

Comparison expression for query filtering.

__init__(left, op, right)

class sparqlmodel.expressions.NotExpr(inner)

Bases: object

Boolean NOT of a filter expression.

__init__(inner)

class sparqlmodel.expressions.AndExpr(expressions)

Bases: object

AND combination of comparison expressions.

__init__(expressions)

class sparqlmodel.expressions.OrExpr(expressions)

Bases: object

OR combination of comparison or AND expressions.

__init__(expressions)

sparqlmodel.expressions.not_(expr)

Negate a filter expression (SPARQL FILTER NOT EXISTS / boolean NOT).

Return type:

NotExpr

sparqlmodel.expressions.property_path(model_cls, path, op, value)

Build a property-path filter (path uses /, ^, *, + as in SPARQL).

Return type:

PropertyPathCompare

sparqlmodel.expressions.property_eq(model_cls, path, value)

property_path shorthand for equality.

Return type:

PropertyPathCompare

ORM filter expressions → SPARQL WHERE clauses.

sparqlmodel.compiler.compile_compare(expr, model_cls, root_var, registry, join_counter, join_cache, *, use_not_exists_for_ne=True)

Compile a comparison; return (patterns, filters).

Return type:

tuple[list[str], list[str]]

sparqlmodel.compiler.compile_and_branch(expr, model_cls, root_var, registry, join_counter, *, use_not_exists_for_ne=True)

Compile an AND branch inside OR as a single EXISTS block.

Return type:

str

sparqlmodel.compiler.compile_or(expr, model_cls, root_var, registry, join_counter, *, use_not_exists_for_ne=True)

Compile OR into a FILTER with EXISTS disjunction.

Return type:

list[str]

sparqlmodel.compiler.compile_where(model_cls, expressions, registry, *, limit=None, offset=None, order_by=(), count=False, use_not_exists_for_ne=True, polymorphic=False, values_bindings=())

Compile WHERE expressions into a full SELECT SPARQL query.

Return type:

str