sansa-stack/archived-sansa-query

SANSA Query Layer

SANSA-Stack

This project comprises the whole Semantic Analytics Stack (SANSA). At a glance, it features the following functionality:

• Ingesting RDF and OWL data in various formats into RDDs
• Operators for working with RDDs and data frames of RDF data at various levels (triples, bindings, graphs, etc)
• Transformation of RDDs to data frames and partitioning of RDDs into R2RML-mapped data frames
• Distributed SPARQL querying over R2RML-mapped data frame partitions using RDB2RDF engines (Sparqlify & Ontop)
• Enrichment of RDDs with inferences
• Application of machine learning algorithms

For a detailed description of SANSA, please visit http://sansa-stack.net.

Layers

The SANSA project is structured in the following five layers developed in their respective sub-folders:

• RDF
• OWL
• Query
• Inference
• ML

Release Cycle

A SANSA stack release is done every six months and consists of the latest stable versions of each layer at this point. This repository is used for organising those joint releases.

Usage

Spark

Requirements

We currently require a Spark 3.x.x with Scala 2.12 setup. A Spark 2.x version can be built from source based on the spark2 branch.

Release Version

Some of our dependencies are not in Maven central (yet), so you need to add following Maven repository to your project POM file repositories section:

<repository>
   <id>maven.aksw.internal</id>
   <name>AKSW Release Repository</name>
   <url>http://maven.aksw.org/archiva/repository/internal</url>
   <releases>
      <enabled>true</enabled>
   </releases>
   <snapshots>
      <enabled>false</enabled>
   </snapshots>
</repository>

If you want to import the full SANSA Stack, please add the following Maven dependency to your project POM file:

<!-- SANSA Stack -->
<dependency>
   <groupId>net.sansa-stack</groupId>
   <artifactId>sansa-stack-spark_2.12</artifactId>
   <version>$LATEST_RELEASE_VERSION$</version>
</dependency>

If you only want to use particular layers, just replace $LAYER_NAME$ with the corresponding name of the layer

<!-- SANSA $LAYER_NAME$ layer -->
<dependency>
   <groupId>net.sansa-stack</groupId>
   <artifactId>sansa-$LAYER_NAME$-spark_2.12</artifactId>
   <version>$LATEST_RELEASE_VERSION$</version>
</dependency>

SNAPSHOT Version

While the release versions are available on Maven Central, latest SNAPSHOT versions have to be installed from source code:

git clone https://github.com/SANSA-Stack/SANSA-Stack.git
cd SANSA-Stack

Then to build and install the full SANSA Spark stack you can do

./dev/mvn_install_stack_spark.sh 

or for a single layer $LAYER_NAME$ you can do

mvn -am -DskipTests -pl :sansa-$LAYER_NAME$-spark_2.12 clean install 

Alternatively, you can use the following Maven repository and add it to your project POM file repositories section:

<repository>
   <id>maven.aksw.snapshots</id>
   <name>AKSW Snapshot Repository</name>
   <url>http://maven.aksw.org/archiva/repository/snapshots</url>
   <releases>
      <enabled>false</enabled>
   </releases>
   <snapshots>
      <enabled>true</enabled>
   </snapshots>
</repository>

Then do the same as for the release version and add the dependency:

<!-- SANSA Stack -->
<dependency>
   <groupId>net.sansa-stack</groupId>
   <artifactId>sansa-stack-spark_2.12</artifactId>
   <version>$LATEST_SNAPSHOT_VERSION$</version>
</dependency>

How to Contribute

We always welcome new contributors to the project! Please see our contribution guide for more details on how to get started contributing to SANSA.

archived-sansa-query's Issues

Add possibility to add Variable Mapping to the result set of Sparqlify approach

As the SANSA query API provides as well possibilities to write queries directly without exposing one endpoint :

val triples = spark.rdf(input)(path)
val query = "SELECT * WHERE {?s ?p ?o} LIMIT 10"
val result = triples.sparql(triples) 

Here we get as a result in a data frame of bindings and would be great if we provide a wrapper which map variables to the result set.

Best

can not run Query example

Here is my example code
`val sc = sparkSession.sparkContext
val sqlc = sparkSession.sqlContext

val filepath = "./data/xxxxx.ttl"

val triples = sparkSession.rdf(lang)(filepath)

//Query
import net.sansa_stack.query.spark.query._
val sparqlQuery = "SELECT * WHERE {?s ?p ?o} LIMIT 10"
val result = triples.sparql(sparqlQuery)
result.rdd.foreach(println)
`

I get following error

`CAST TO string
CAST TO string
CAST TO double precision
CAST TO string
CAST TO string
Exception in thread "main" org.apache.spark.sql.catalyst.parser.ParseException:
mismatched input 'FROM' expecting (line 2, pos 0)

== SQL ==
SELECT a_45.C_3 C_3, a_45.C_4 C_4, a_45.C_5 C_5, a_45.C_11 C_11, a_45.C_6 C_6, a_45.C_10 C_10, a_45.C_7 C_7, a_45.C_8 C_8, a_45.C_9 C_9, a_45.C_14 C_14, a_45.C_13 C_13, a_45.C_12 C_12
FROM
^^^
( SELECT a_1.s C_14, CAST(NULL AS string) C_13, CAST(NULL AS bigint) C_12, CAST(NULL AS string) C_11, a_1.o C_10, CAST('https://tac.nist.gov/tracks/SM-KBP/2019/ontologies/InterchangeOntology#justifiedBy' AS string) C_3, CAST(NULL AS string) C_5, CAST(NULL AS string) C_4, CAST(NULL AS string) C_7, CAST(NULL AS string) C_6, CAST(NULL AS double precision) C_9, CAST(NULL AS string) C_8, CAST('urn:x-arq:DefaultGraph' AS string) `C_15``

Am i missing something here ? I am using 0.6.1-SNAPSHOT version of "sense-rdf" and "sense-query"

Thanks

"null" values in Query result format

Hi

SANSA-Query returns strange "null" values in addition to the expected variables.
For the attached sample file (extension is changed as .ttl is not allowed) and for the simple query
"SELECT ?o WHERE {?s ?p ?o} "
test2.ttl.txt

I get following ?o
[Alice,,null] [Bob,,null] [Clare,,null] [null,null,c922def1e6fa0a4aec50621290367fd1] [null,null,94f03f04f0cef66952474449e02a1942] [CT,,null]

Is there an issue with variable binding ?

Thanks

Exception in QuerySystem with valid SPARQL query

When trying to run the QuerySystem like so

import java.io.File

import org.apache.commons.io.FileUtils
import org.apache.jena.graph.Triple
import org.apache.jena.riot.Lang
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession

import net.sansa_stack.query.spark.semantic.QuerySystem

object Foo {
  val symbol = Map(
    "space" -> " " * 5,
    "blank" -> " ",
    "tabs" -> "\t",
    "newline" -> "\n",
    "colon" -> ":",
    "comma" -> ",",
    "hash" -> "#",
    "slash" -> "/",
    "question-mark" -> "?",
    "exclamation-mark" -> "!",
    "curly-bracket-left" -> "{",
    "curly-bracket-right" -> "}",
    "round-bracket-left" -> "(",
    "round-bracket-right" -> ")",
    "less-than" -> "<",
    "greater-than" -> ">",
    "at" -> "@",
    "dot" -> ".",
    "dots" -> "...",
    "asterisk" -> "*",
    "up-arrows" -> "^^")

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder
      .master("local[*]")
      .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
      .appName("SANSA - Semantic Partitioning")
      .getOrCreate()

    import net.sansa_stack.rdf.spark.io._
    import net.sansa_stack.rdf.spark.partition.semantic.RdfPartition

    val log: RDD[Triple] = spark.rdf(Lang.NTRIPLES)("/tmp/log.nt")
    val partition: RDD[String] = new RdfPartition(
      symbol, log, "/tmp/sem_partitions",
      spark.sparkContext.defaultMinPartitions).partitionGraph()

    val resultsDir = new File("/tmp/results")
    FileUtils.deleteDirectory(resultsDir)

    val qs = new QuerySystem(
        symbol,
        partition,
        "/tmp/query.sparql",
        resultsDir.getAbsolutePath,
        spark.sparkContext.defaultMinPartitions)
    qs.run()
  }
}

with /tmp/query.sparql containing the simple SPARQL query

SELECT ?s
WHERE
  { 
    ?s   ?p  ?o .
  }

I get an IndexOutOfBoundsException:

Exception in thread "main" java.lang.IndexOutOfBoundsException: 5
	at scala.collection.mutable.ResizableArray$class.apply(ResizableArray.scala:43)
	at scala.collection.mutable.ArrayBuffer.apply(ArrayBuffer.scala:48)
	at net.sansa_stack.query.spark.semantic.QuerySystem$$anonfun$refactorUnionQueries$1.apply$mcVI$sp(SparqlQuerySystem.scala:167)
	at scala.collection.immutable.Range.foreach$mVc$sp(Range.scala:160)
	at net.sansa_stack.query.spark.semantic.QuerySystem.refactorUnionQueries(SparqlQuerySystem.scala:142)
	at net.sansa_stack.query.spark.semantic.QuerySystem$$anonfun$run$1.apply$mcVI$sp(SparqlQuerySystem.scala:48)
	at scala.collection.immutable.Range.foreach$mVc$sp(Range.scala:160)
	at net.sansa_stack.query.spark.semantic.QuerySystem.run(SparqlQuerySystem.scala:46)

Modifying the query to

SELECT ?s
WHERE {
    ?s   ?p  ?o .
  }

at least makes the error disappear.

Running S2RDF should start a SPARQL endpoint

Integrate SPARQL Test Suite

E.g. https://www.w3.org/2009/sparql/docs/tests/summary.html or something newer

No results from QuerySystem with simple s-p-o query

When trying to run the QuerySystem like so

import java.io.File

import org.apache.commons.io.FileUtils
import org.apache.jena.graph.Triple
import org.apache.jena.riot.Lang
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession

import net.sansa_stack.query.spark.semantic.QuerySystem

object Foo {
  val symbol = Map(
    "space" -> " " * 5,
    "blank" -> " ",
    "tabs" -> "\t",
    "newline" -> "\n",
    "colon" -> ":",
    "comma" -> ",",
    "hash" -> "#",
    "slash" -> "/",
    "question-mark" -> "?",
    "exclamation-mark" -> "!",
    "curly-bracket-left" -> "{",
    "curly-bracket-right" -> "}",
    "round-bracket-left" -> "(",
    "round-bracket-right" -> ")",
    "less-than" -> "<",
    "greater-than" -> ">",
    "at" -> "@",
    "dot" -> ".",
    "dots" -> "...",
    "asterisk" -> "*",
    "up-arrows" -> "^^")

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder
      .master("local[*]")
      .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
      .appName("SANSA - Semantic Partitioning")
      .getOrCreate()

    import net.sansa_stack.rdf.spark.io._
    import net.sansa_stack.rdf.spark.partition.semantic.RdfPartition

    val log: RDD[Triple] = spark.rdf(Lang.NTRIPLES)("/tmp/log.nt")
    val partition: RDD[String] = new RdfPartition(
      symbol, log, "/tmp/sem_partitions",
      spark.sparkContext.defaultMinPartitions).partitionGraph()

    val resultsDir = new File("/tmp/results")
    FileUtils.deleteDirectory(resultsDir)

    val qs = new QuerySystem(
        symbol,
        partition,
        "/tmp/query.sparql",
        resultsDir.getAbsolutePath,
        spark.sparkContext.defaultMinPartitions)
    qs.run()
  }
}

with /tmp/query.sparql containing the simple s-p-o SPARQL query

SELECT ?s
WHERE {
    ?s   ?p ?o .
  }

I only get empty files in the result directory, even though neither log nor partition are empty.

Compare / Evaluate further RDB2RDF tools

I got error every time I try to load large ttl file

I got "org.apache.spark.SparkException: Job aborted due to stage failure: Task 0 in stage 28.0 failed 4 times, most recent failure: Lost task 0.3 in stage 28.0 (TID 43, 10.3.1.9, executor 20): java.lang.OutOfMemoryError: Requested array size exceeds VM limit" everytime I load large ttl "450MB".

Do you know why?

Query execution result should be exposed as a standard Jena result object.

Parsing JSON to RDF using RML. Is it possible ?

I read in the sansa-lake documentation that it uses RML mapping. However, when it lists the different datasources on this page: https://github.com/SANSA-Stack/SANSA-Query/tree/develop/sansa-query-spark/src/main/scala/net/sansa_stack/query/spark/datalake . JSON is not part of it? My questions is: Can Sansa convert a JSON file into an rdf turtle file using RML mapping.

Thank you

Test and Run Quetzal

• s2rdf
• quetsal

Jena's Node objects should be used instead of mere Strings in the RDDs/DataFrames

Though not sure whether to use Jena directly or the Sansa/BananaRDF Node abstraction. I suppose the latter.

Problem querying RDF containing a triple with an object of type XSD double

I'll demonstrate the problem using the Sparqlify example: https://github.com/SANSA-Stack/SANSA-Examples/blob/develop/sansa-examples-spark/src/main/scala/net/sansa_stack/examples/spark/query/Sparqlify.scala.

Add a triple to src/main/resources/rdf.nt with an object of type XSD double. E.g., simply replace the following triple:

<http://commons.dbpedia.org/resource/Category:People> <http://commons.dbpedia.org/property/width> "100.0"^^<http://dbpedia.org/datatype/perCent> .

with:

<http://commons.dbpedia.org/resource/Category:People> <http://commons.dbpedia.org/property/width> "100.0"^^<http://www.w3.org/2001/XMLSchema#double> . 

Run the Sparqlify class in the server/endpoint mode pointing to the rdf.nt as input (--input src/main/resources/rdf.nt). Execute the simple SELECT * WHERE {?s ?p ?o} query in the browser. Observe the error in the server console.

Exception in thread "Thread-37" java.lang.RuntimeException: java.lang.RuntimeException: org.apache.spark.sql.catalyst.parser.ParseException: 
mismatched input 'FROM' expecting <EOF>(line 2, pos 0)

Wrap S2RDF query execution with jena-sparql-api's QueryExecutionFactory

Queries with variables for predicates do not work; e.g. Select ?s { ?s ?p ?o }

Dataframes are created per predicate and appropriate dataframes are looked up based on a query's predicates. Therefore, queries with variables for predicates fail. The simplest fix that would need to be done is to create a UNION over all existing predicate dataframes. A more sophisticated solution would be to try to re-use candidate selector from Saleems query federation work and / or my RDB2RDF work.

STRAFTER doesn't work in sparql query

When I try to split and select substring, I use STRAFTER in query select. Here is how it works:

When I try it with SANSA query, it returns the same result as without any split&substring operation.

The code is in notebook: https://dbc-c63f139d-39c4.cloud.databricks.com/#notebook/522/command/547 (command 9)

Graph partitioning-based query system doesn't support SPARQL functions which may take N arguments

I tried to run the graph partitioning-based query system as exemplified in the SANSA-Examples repository. The query I tried to execute is

SELECT DISTINCT  ?s
WHERE
  { ?s   <http://www.specialprivacy.eu/langs/splog#logEntryContent>  ?s0 .
    ?s0  <http://www.specialprivacy.eu/langs/usage-policy#hasData>  ?allSuperClassesVar1 ;
         <http://www.specialprivacy.eu/langs/usage-policy#hasPurpose>  <http://www.specialprivacy.eu/vocabs/purposes#Admin> ;
         <http://www.specialprivacy.eu/langs/usage-policy#hasRecipient>  <http://www.specialprivacy.eu/vocabs/recipients#Public> ;
         <http://www.specialprivacy.eu/langs/usage-policy#hasStorage>  <http://www.specialprivacy.eu/vocabs/locations#ThirdParty> .
    ?s   <http://www.specialprivacy.eu/langs/splog#dataSubject>  <http://www.example.com/users/433a4347-e2c7-4e07-a0fd-a054a62ba37f>
    FILTER(?allSuperClassesVar1 NOT IN (<http://www.specialprivacy.eu/vocabs/data#Activity>, <http://www.specialprivacy.eu/langs/usage-policy#AnyData>))
  }

And what I get is this stack trace

Exception in thread "main" java.lang.UnsupportedOperationException: Not support the expression of ExprFunctionN
	at net.sansa_stack.query.spark.graph.jena.ExprParser.visit(ExprParser.scala:72)
	at org.apache.jena.sparql.expr.ExprFunctionN.visit(ExprFunctionN.java:120)
	at org.apache.jena.sparql.algebra.walker.WalkerVisitor.visitExprFunction(WalkerVisitor.java:265)
	at org.apache.jena.sparql.algebra.walker.WalkerVisitor.visit(WalkerVisitor.java:252)
	at org.apache.jena.sparql.expr.ExprFunctionN.visit(ExprFunctionN.java:120)
	at org.apache.jena.sparql.algebra.walker.WalkerVisitor.walk(WalkerVisitor.java:91)
	at org.apache.jena.sparql.algebra.walker.Walker.walk$(Walker.java:104)
[...]

pointing to this match-case expression which explicitly restricts supported filters to Expressions (i.e. basically everything that takes only up to two arguments).

Problem with a SPARQL query containing DISTINCT and ORDER BY

I'll demonstrate the problem using the Sparqlify example: https://github.com/SANSA-Stack/SANSA-Examples/blob/develop/sansa-examples-spark/src/main/scala/net/sansa_stack/examples/spark/query/Sparqlify.scala.

Run the Sparqlify class in the server/endpoint mode pointing to the rdf.nt as input (--input src/main/resources/rdf.nt). Execute the following query:

SELECT DISTINCT ?x ?y WHERE {
    ?x <http://xmlns.com/foaf/0.1/givenName> ?y .
}
ORDER BY ?y

Observe the error in the server console.

Exception in thread "Thread-31" java.lang.RuntimeException: java.lang.RuntimeException: org.apache.spark.sql.AnalysisException: cannot resolve '`a_1.o`' given input columns: [o, o_2, s, l, o_1]; line 4 pos 9;
'Sort ['a_1.o ASC NULLS FIRST, 'a_1.l ASC NULLS FIRST], true
+- Distinct
   +- Project [o#55 AS o#296, l#56 AS l#297, s#54 AS s#298, o#55 AS o_1#299, l#56 AS o_2#300]
      +- SubqueryAlias `a_1`
         +- SubqueryAlias `http://xmlns.com/foaf/0.1/givenname_xmlschema#string_lang`
            +- LogicalRDD [s#54, o#55, l#56], false

	at org.aksw.jena_sparql_api.web.utils.RunnableAsyncResponseSafe.run(RunnableAsyncResponseSafe.java:29)
	at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.RuntimeException: org.apache.spark.sql.AnalysisException: cannot resolve '`a_1.o`' given input columns: [o, o_2, s, l, o_1]; line 4 pos 9;
'Sort ['a_1.o ASC NULLS FIRST, 'a_1.l ASC NULLS FIRST], true
+- Distinct
   +- Project [o#55 AS o#296, l#56 AS l#297, s#54 AS s#298, o#55 AS o_1#299, l#56 AS o_2#300]
      +- SubqueryAlias `a_1`
         +- SubqueryAlias `http://xmlns.com/foaf/0.1/givenname_xmlschema#string_lang`
            +- LogicalRDD [s#54, o#55, l#56], false

	at org.aksw.jena_sparql_api.web.servlets.SparqlEndpointBase$3.run(SparqlEndpointBase.java:352)
	at org.aksw.jena_sparql_api.web.utils.RunnableAsyncResponseSafe.run(RunnableAsyncResponseSafe.java:26)
	... 1 more
Caused by: org.apache.spark.sql.AnalysisException: cannot resolve '`a_1.o`' given input columns: [o, o_2, s, l, o_1]; line 4 pos 9;
'Sort ['a_1.o ASC NULLS FIRST, 'a_1.l ASC NULLS FIRST], true
+- Distinct
   +- Project [o#55 AS o#296, l#56 AS l#297, s#54 AS s#298, o#55 AS o_1#299, l#56 AS o_2#300]
      +- SubqueryAlias `a_1`
         +- SubqueryAlias `http://xmlns.com/foaf/0.1/givenname_xmlschema#string_lang`
            +- LogicalRDD [s#54, o#55, l#56], false

	at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$3.applyOrElse(CheckAnalysis.scala:110)
	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$3.applyOrElse(CheckAnalysis.scala:107)
	at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:278)
	at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:278)
	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)
	at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:277)
	at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$3.apply(TreeNode.scala:275)
	at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$3.apply(TreeNode.scala:275)
	at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$4.apply(TreeNode.scala:326)
	at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)
	at org.apache.spark.sql.catalyst.trees.TreeNode.mapChildren(TreeNode.scala:324)
	at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:275)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:93)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:93)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$1.apply(QueryPlan.scala:105)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$1.apply(QueryPlan.scala:105)
	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)
	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:104)
	at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:116)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$2.apply(QueryPlan.scala:121)
	at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
	at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
	at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
	at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
	at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
	at scala.collection.AbstractTraversable.map(Traversable.scala:104)
	at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:121)
	at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$2.apply(QueryPlan.scala:126)
	at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)
	at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:126)
	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:93)
	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:107)
	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)
	at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:85)
	at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:95)
	at org.apache.spark.sql.catalyst.analysis.Analyzer$$anonfun$executeAndCheck$1.apply(Analyzer.scala:108)
	at org.apache.spark.sql.catalyst.analysis.Analyzer$$anonfun$executeAndCheck$1.apply(Analyzer.scala:105)
	at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:201)
	at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:105)
	at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:57)
	at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:55)
	at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:47)
	at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:78)
	at org.apache.spark.sql.SparkSession.sql(SparkSession.scala:642)
	at net.sansa_stack.query.spark.sparqlify.QueryExecutionUtilsSpark.createQueryExecution(QueryExecutionUtilsSpark.java:23)
	at net.sansa_stack.query.spark.sparqlify.QueryExecutionSparqlifySpark.executeCoreSelect(QueryExecutionSparqlifySpark.java:38)
	at org.aksw.jena_sparql_api.core.QueryExecutionBaseSelect.execSelect(QueryExecutionBaseSelect.java:407)
	at org.aksw.jena_sparql_api.web.servlets.ProcessQuery.processQuery(ProcessQuery.java:117)
	at org.aksw.jena_sparql_api.web.servlets.ProcessQuery.processQuery(ProcessQuery.java:75)
	at org.aksw.jena_sparql_api.web.servlets.SparqlEndpointBase$3.run(SparqlEndpointBase.java:349)
	... 2 more

FILTER in Sparql cannot match int value correctly

When I filter by int value, it returned empty list while in the result there should be some values matched. No error message.

This is my test on GraphDB, showing the query can return matched results:

This is my test on SANSA: https://dbc-c63f139d-39c4.cloud.databricks.com/#notebook/522/command/531 (command 6)

s2rdf: SELECT * { ... } queries cause exception in SQL rewriting step

The class SqlOpTranslator apparently cannot handle algebra expressions which do contain a Project op
Note: Instead of trying to hack in the injections of project ops, the query translator should be enhanced to deal with such valid algebra expressions!

Merge r2rml branch with ontop implementation

We will need to merge r2rml branch into our latest r2rml (e.g. ontop) mappings if there is something useful to be used.
If it has been covered already, we should consider removing the branch.

Best regards,

No results for query that matches blank node

Hi SANSA-Query team,

SANSA-Query does not return any result if it matches a blank node.
Using following query
""" prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> SELECT ?stm ?en ?enAtr ?enAtrVal WHERE { ?stm rdf:subject ?en . ?stm rdf:predicate ?enAtr . ?stm rdf:object ?enAtrVal . } """

test2.ttl
returns expected results. But
test.ttl does not show ANY result, not even the non-blank node result. I also see that in the blank node case, it also outputs lots of debug statement such as
CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string CAST TO string
I do set the valid language as
val lang = Lang.TURTLE

I see the same behavior for ".nt" format. Please suggest me what is causing this issue and if there is a way to fix it.

Thanks
Sumit

FILTER in Sparql cannot match string with type transformation

when filter string in sparql, I used regex() and str() to match the substring. it worked in GraphDB as follows:

When I try on SANSA query layer, it gave an error:

The notebook is: https://dbc-c63f139d-39c4.cloud.databricks.com/#notebook/522/command/531 (command 7)

GROUP BY COUNT could decide on a best match

it seems like the group_by and count functionality gives an error:

Below is my query:

Notebook: https://dbc-c63f139d-39c4.cloud.databricks.com/#notebook/522/command/532 (command 8)