SPARQLStore query parameter initBindings does not have the same behavior as the other stores

[Tpt]

RDFLib SPARQL query processor considers the initBindings parameter of the Store/Graph query method as a set of binds to do at the beginning of the query, inside of the SELECT expression. However SPARQLStore considers it as a join to be done after the query have been processed using a final VALUES clause when it generates a SPARQL query to send to the remote store.

For example the call

store.query("SELECT ?s WHERE { FILTER(BOUND(?s)) }", initBindings={Variable("s"): URIRef("http://example.com/foo")})

will be evaluated by the Memory store like

SELECT ?s WHERE { VALUES ?s { <http://example.com/foo> } FILTER(BOUND(?s)) }

and by the SPARQLStore like:

SELECT ?s WHERE { FILTER(BOUND(?s)) } VALUES ?s { <http://example.com/foo> }

This leads the Memory store to return one solution with the assignation ?s -> <http://example.com/foo> and the SPARQLStore to return no solution.

It would be great to harmonize the behavior. I encountered this issue while working on oxrdflib that currently follows the SPARQLStore behavior, breaking some usages relying on the Memory store behavior.

I can confirm the issue. FWIW, I found what might be a workaround, you can set the use_store_provided kwarg to False and get the desired behaviour.
Using a Fuseki instance primed with:

INSERT DATA { 
    <http://example.org/book/book1>  <http://purl.org/dc/elements/1.1/title>  "SPARQL Tutorial" .
    <http://example.org/book/book1>  <http://example.org/ns#price>  42 .
    <http://example.org/book/book2>  <http://purl.org/dc/elements/1.1/title>  "The Semantic Web" .
    <http://example.org/book/book2>  <http://example.org/ns#price>  23 .
}

The following test passes:

from rdflib import Graph, Literal, URIRef, XSD
def test_bindings():
    g = Graph("SPARQLStore")
    g.open("http://localhost:3030/db/query")
    bindings = {Variable("book"): URIRef("http://example.org/book/book1")}
    query = "SELECT ?book WHERE { FILTER(BOUND(?book)) }"
    res = g.query(query, initBindings=bindings, use_store_provided=False)
    assert list(res) == [(rdflib.term.URIRef('http://example.org/book/book1'),)]

[white-gecko]

Just to add a small snippet to demonstrate the situation on the SPARQLStore:

from rdflib import URIRef
from rdflib.plugins.stores.sparqlstore import SPARQLStore


def query_inject(query, default_graph):
    print(query)


store = SPARQLStore()
store._query = query_inject
store.query(
    "select ?p ?o {?resourceIri ?p ?o}",
    initBindings={"resourceIri": URIRef("http://example.org/example")},
)

returns

select ?p ?o {?resourceIri ?p ?o}
VALUES ( ?resourceIri )
{ ( <http://example.org/example> ) }

The relevant code is in lines 278-281:

rdflib/rdflib/plugins/stores/sparqlstore.py

Lines 258 to 285 in 440755b

	def query( # type: ignore[override]
	self,
	query: Union[Query, str],
	initNs: Mapping[str, Any] | None = None, # noqa: N803
	initBindings: Mapping[str, Identifier] | None = None, # noqa: N803
	queryGraph: str | None = None, # noqa: N803
	DEBUG: bool = False, # noqa: N803
	) -> Result:
	self.debug = DEBUG
	assert isinstance(query, str)
	if initNs is not None and len(initNs) > 0:
	query = self._inject_prefixes(query, initNs)
	if initBindings:
	if not self.sparql11:
	raise Exception("initBindings not supported for SPARQL 1.0 Endpoints.")
	v = list(initBindings)
	# VALUES was added to SPARQL 1.1 on 2012/07/24
	query += "\nVALUES ( %s )\n{ ( %s ) }\n" % (
	" ".join("?" + str(x) for x in v),
	" ".join(self.node_to_sparql(initBindings[x]) for x in v),
	)
	return self._query(
	query, default_graph=queryGraph if self._is_contextual(queryGraph) else None
	)

[white-gecko]

My idea to fix this issue basically is to parse the query to the algebra, just below the Project take the original p value, inject a Join(p, the init bindings), this is a not working sketch:

from rdflib.plugins.sparql.algebra import (
    Join,
    ToMultiSet,
    translateAlgebra,
    translateQuery,
)
from rdflib.plugins.sparql.parser import (
    ValuesClause,
    parseQuery,
)

…

strOrQuery = query

if initBindings:
    if not self.sparql11:
        raise Exception("initBindings not supported for SPARQL 1.0 Endpoints.")

    if isinstance(strOrQuery, str):
        strOrQuery = translateQuery(parseQuery(strOrQuery), base, initNs)

    # inject the bindings on the algebra
    v = list(initBindings)

    valuesString = "\nVALUES ( %s )\n{ ( %s ) }\n" % (
        " ".join("?" + str(x) for x in v),
        " ".join(self.node_to_sparql(initBindings[x]) for x in v),
    )

    # THIS DOES NOT WORK
    multiset = ToMultiSet(ValuesClause.parseString(valuesString))

    if strOrQuery.algebra.p.name == "Project":
        bgp = strOrQuery.algebra.p.p.clone()
        strOrQuery.algebra.p.p = Join(bgp, multiset)
    # THIS DOES NOT WORK

    strOrQuery = translateAlgebra(strOrQuery)

But I don't get the internals of pyparsing. Maybe someone could make this part working, then we will also figure out, how to handle it for other Select, Construct, Describe, and Ask queries.

[white-gecko]

I have managed to inject the values into a parse tree, while still operating on the algebra should be more elegant since it would not require extra translateAlgebra -> parseQuery roundtripping, if a Query would be given to the query() method.

from pyparsing.core import ZeroOrMore
from rdflib.plugins.sparql.algebra import (
    translateAlgebra,
    translateQuery,
)
from rdflib.plugins.sparql.parser import (
    DataBlockValue,
    parseQuery,
)
from rdflib.plugins.sparql.parserutils import CompValue
from rdflib.term import Variable

…

strOrQuery = query

if initBindings:
    if not self.sparql11:
        raise Exception("initBindings not supported for SPARQL 1.0 Endpoints.")

    if not isinstance(strOrQuery, str):
        # Translate back any Query object to a string, since we need the parse tree
        # this is superfluous if we can do the operations on the algebra
        strOrQuery = translateAlgebra(strOrQuery)

    # inject the bindings on the algebra
    v = list(initBindings)

    parseTree = parseQuery(strOrQuery)
    inline_data = CompValue(
        "InlineData",
        var=[Variable(x) for x in v],
        value=[
            # This string parsing is also not elegant, but I could not figure out, how to create the ParseResults by hand
            ZeroOrMore(DataBlockValue).parseString(
                " ".join(self.node_to_sparql(initBindings[x]) for x in v)
            )
        ],
    )
    parseTree[1]["where"]["part"].append(inline_data)

    # finally translate the parse tree to a propper Query object with algebra to be able to call translateAlgebra on it
    strOrQuery = translateQuery(parseTree, base, initNs)

if not isinstance(strOrQuery, str):
    # make sure we finally have a string since the sparql connector only operates on strings
    strOrQuery = translateAlgebra(strOrQuery)

However, translateAlgebra currently only supports SELECT queries:

rdflib/rdflib/plugins/sparql/algebra.py

Lines 1636 to 1650 in 440755b

	def translateAlgebra(query_algebra: Query) -> str:
	"""
	Translates a SPARQL 1.1 algebra tree into the corresponding query string.
	Args:
	query_algebra: An algebra returned by `translateQuery`.
	Returns:
	The query form generated from the SPARQL 1.1 algebra tree for
	SELECT queries.
	"""
	query_from_algebra = _AlgebraTranslator(
	query_algebra=query_algebra
	).translateAlgebra()
	return query_from_algebra

So this would still need to be fixed in order to get the whole thing covered.