LINQ with Inference new feature

[charbull]

I would like to add inference support by query for LINQ while generating SPARQL.

Is there anybody else interested in this feature?

Regards,
Charbel

[alien-mcl]

Could you please elaborate a bit more on that feature?

[charbull]

When the context factory is connected to a remote persistent storage, it is possible that the store supports inference by query. As described here.

In RomanticWeb, we can use LINQ to query the underlying store. If I understood correctly, a LINQ query is translated to a SPARQL query and then sent to the persistent store.

Combining both LINQ and Reasoning activated by query would be really powerful.

Maybe supporting something like this? context.AsQueryable().WithReasoning()
The with reasoning parameter will be propagated to the underlying connector of DotNetRDF as in here.

IQueryable<IEntity> untypedQuery = from entity in context.AsQueryable().WithReasoning()
                                   where entity is IPerson
                                   select entity;

Adding this kind of capabilities will allow developers an advanced capability and avoid writing pure SPARQL outside of RomanticWeb when they would like to activate the reasoning.

It will not be complicated to propose a PR.

Charbel

[alien-mcl]

I had a hunch it was about that kind of store's capability. Question is - to what degree this mechanism is transient across various stores. I.e. for Virtuoso I found a SPARQL query should be started with this kind of declaration:

DEFINE input:inference 'urn:owl:inference:rules:tests'

Clearly it is not a bool.
Still, I believe this extension could be useful for some scenarios.

[tpluscode]

Hm, this would have to be translated differently depending on the store queried. Possibly ignored if unsupported?

[tpluscode]

Or, each store that supports reasoning could come with it's own flavor of this extension. Such as

• RomanticWeb.Virtuoso.QueryExtensions#WithReasoning
• RomanticWeb.Stardog.QueryExtensions#WithReasoning

etc

[alien-mcl]

But result of the IEntityContext.AsQueryable is store independent - how would you attach this extension to the queryable instance?

[tpluscode]

You tell me. I haven't touched this code in ages ;)

[charbull]

This feature of reasoning by query is supported in Stardog and AllegroGraph RESt API. I am not sure about other stores as I didn't try them out till this step.

I was following this idea:
if the context Factory can be configured to use DotNetRDF and its connectors. Why not pass the reasoning to the underlying Store connector?

I am not sure yet, still digging in the code, a pointer would help :)

[alien-mcl]

'EntityContext' and 'EntityContextFactory' are loosely coupled with dotNetRDF - currently it is the implementation of the 'ITripleSource' used, but in theory it can be any other implementation.
Indeed, extension would need to pass that reasoning feature down to that underlying triple source - the question is how this extension's API should look like to be transient across various implementations.

[alien-mcl]

@tpluscode - answer to your question - you can't :).
EntityQueryable has no clue on what kind of triple source it is using - it's beneath three layers of abstractions :) (EntityQueryable has EntityQueryExecutor which has instance of the ITripleSource which finally knows something about it's underlying triple store)

[charbull]

So from EntityContext we can call AsQueryable to go to EntityQueryable then we end up in EntityQueryExecutor which knows the store since it has an EntityStore,

 public EntityQueryExecutor(IEntityContext entityContext, IEntitySource entitySource
, IEntityStore store)
        {
            _entityContext = entityContext;
            _entitySource = entitySource;
            _store = store;
            _queryOptimizer = new GenericQueryOptimizer();
        }

can we go through the TripleStoreAdapter like you handle the commit from the EntityContext which goes to PersistentTripleStoreSparqlCommandExecutionStrategy

I don't have the full scope of the implementation, just trying to understand.

PS: @alien-mcl I forked your code but couldn't build it. I attached the logs any hints/help?
logs.txt

Thanks,

[alien-mcl]

Way of passing it to the underlying tripple store is not an issue. The issue is how that extension should look like. We can't introduce store-specific extension as the EntityQueryable doesn't have a notion of a store specification. The only thing that I can come with now is:

public IQueryable<T> WithReasoning(params EntityId[] reasoningRuleset);

This way the extension could be called with explicitly provided iris that Virtuoso could consume and the fact of calling it is enough for stardog.

[charbull]

Thx @alien-mcl, I propose a pull request soon.
Any ideas/hints for the builds errors? which version should I work on ? this one, your fork or another

[alien-mcl]

Hi @charbull - I could you please provide those build errors again?
As for the question - I'd start with the for. I'll merge it to the main repo some time in future (and rather sooner than later)

[charbull]

Hi @alien-mcl,
I attached the logfiles, not sure if it coming from VS 2017 incompatibility?

Charbel
RW.txt

VS.txt
UpgradeLog.htm.txt