From Databricks Tables
to a Virtual Knowledge Graph with Virtuoso

PREFIX : <http://www.databricks.com/bakehouse#>

CONSTRUCT
{
  ?transaction a :Transaction;
   :franchise ?franchise;
   :totalPrice ?totalPrice.

  ?franchise :city ?franchiseCity.
}
WHERE
{
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl>
  {
    ?transaction a :Transaction;
     :franchise ?franchise;
     :totalPrice ?totalPrice.

    ?franchise :city ?franchiseCity.
  }
}
LIMIT 100

CONSTRUCT uses text/x-html-nice-turtle result format.

SELECT *
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?s a ?o
  
  }
}
LIMIT 10

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?orderSizeBucket
(COUNT(?transaction) AS ?transactionCount)
(SUM(?totalPrice) AS ?totalRevenue)
(ROUND(AVG(?totalPrice)) AS ?avgValue)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?transaction a :Transaction;
     :totalPrice ?totalPrice.
    BIND(
      IF(?totalPrice < 10, "Small (<$10)",
      IF(?totalPrice < 30, "Medium ($10-$30)",
      IF(?totalPrice < 60, "Large ($30-$60)",
      "Enterprise (>$60)")))
      AS ?orderSizeBucket)
  
  }
}
GROUP BY ?orderSizeBucket
ORDER BY DESC(?totalRevenue)

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?city
(COUNT(DISTINCT ?transaction) AS ?orderCount)
(SUM(?totalPrice) AS ?revenue)
(ROUND(AVG(?totalPrice)) AS ?avgOrderValue)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?transaction a :Transaction;
     :franchise ?franchise;
     :totalPrice ?totalPrice.
    ?franchise :city ?city.
  
  }
}
GROUP BY ?city
ORDER BY DESC(?revenue)

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?franchise
?franchiseCity
SUM(?totalPrice) as ?revenue
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?transaction a :Transaction;
     :franchise ?franchise;
     :totalPrice ?totalPrice.
  
    ?franchise :city ?franchiseCity.
  
  }
}
GROUP BY ?franchise ?franchiseCity
ORDER BY DESC(?revenue)
LIMIT 10

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?supplierName
?ingredientName
(COUNT(DISTINCT ?franchise) AS ?franchisesServed)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?supply a :SupplyContract;
     :supplier ?supplier;
     :ingredient ?ingredient;
     :franchise ?franchise.
    ?supplier :supplierName ?supplierName.
    ?ingredient :ingredientName ?ingredientName.
  
  }
}
GROUP BY ?supplierName ?ingredientName
ORDER BY DESC(?franchisesServed)
LIMIT 15

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?customerName
(COUNT(DISTINCT ?transaction) AS ?purchaseCount)
(SUM(?totalPrice) AS ?lifetimeValue)
(ROUND(SUM(?totalPrice)/COUNT(DISTINCT ?transaction)) AS ?avgPurchaseValue)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?transaction a :Transaction;
     :customer ?customer;
     :totalPrice ?totalPrice.
    ?customer :customerName ?customerName.
  
  }
}
GROUP BY ?customerName
ORDER BY DESC(?lifetimeValue)
LIMIT 10

SELECT uses text/x-html+tr result format.

PREFIX : <http://www.databricks.com/bakehouse#>

SELECT
?franchiseName
?city
(COUNT(?review) AS ?reviewCount)
(ROUND(AVG(?rating))*10/10 AS ?avgRating)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> {
  
    ?review a :Review;
     :franchise ?franchise;
     :rating ?rating.
    ?franchise :city ?city.
    OPTIONAL { ?franchise :franchiseName ?franchiseName. }
  
  }
}
GROUP BY ?franchiseName ?city
HAVING (COUNT(?review) >= 3)
ORDER BY DESC(?avgRating)
LIMIT 10

SELECT uses text/x-html+tr result format.

A Virtual Knowledge Graph (VKG) is a semantic layer constructed over existing relational data without physical data movement. It uses virtual database attachment (ODBC/JDBC) to connect to source systems, R2RML mappings to declare how tables and columns map to RDF classes and properties, and SPARQL-to-SQL query translation to execute graph queries against the live relational data at query time. The data stays in place; the semantics are layered on top.

Traditional ETL-based approaches: extract data from source, transform to RDF, load into a triplestore — creating a copy that must be kept in sync. The virtual approach: no extraction, no transformation pipeline, no load step, no stale copies. R2RML mappings define the semantic model declaratively; SPARQL queries execute against live data. Changes in Databricks tables are immediately visible in SPARQL results. The trade-off is query latency versus data freshness — the virtual approach prioritizes freshness and simplicity over raw graph traversal speed.

Yes. Virtuoso's Virtual Database supports any ODBC or JDBC data source — PostgreSQL, MySQL, Oracle, SQL Server, Snowflake, BigQuery, and many others. The same pattern applies: attach tables via ODBC, define R2RML mappings, load the ontology, generate quad maps, and query via SPARQL. The knowledge graph becomes a unified semantic layer spanning multiple heterogeneous data platforms.

SQL knowledge for table attachment and testing; basic understanding of RDF and SPARQL for query writing; familiarity with R2RML for mapping design (the Turtle syntax is straightforward for anyone comfortable with data modelling); and Virtuoso administration basics (Conductor UI or isql command-line). The companion GitHub repository provides templates and working examples — most practitioners can have a working virtual knowledge graph running within an hour.

Databricks provides graph capabilities within its platform, but Virtuoso adds: (1) standards-based interoperability via W3C RDF/SPARQL/R2RML — no vendor lock-in; (2) Linked Data entity URIs enabling cross-system entity navigation; (3) federated SPARQL across multiple data sources; (4) AI Agent-friendly machine-readable RDF with content negotiation; and (5) a loosely coupled architecture where the knowledge graph is an overlay, not yet another silo.

No. The virtual knowledge graph approach achieves zero data movement. Databricks tables are attached via ODBC as virtual references — they appear in Virtuoso's local catalog but no data is copied. SPARQL queries are translated to SQL at query time and executed remotely against the live Databricks SQL warehouse. This means the knowledge graph always reflects current data without ETL pipelines or stale copies.

R2RML (RDB to RDF Mapping Language) is a W3C recommendation that defines how relational database tables, columns, and foreign keys map to RDF classes, properties, and relationships. It provides a declarative, standards-based bridge between the SQL world and the semantic graph world — no custom code needed. The mapping is a Turtle file that can be version-controlled, reviewed, and reused across projects.

AI agents consume the virtual knowledge graph through three standard interfaces: (1) SPARQL endpoint — structured graph queries returning typed results with entity IRIs; (2) Linked Data entity URIs — dereferenceable HTTP URIs that return RDF (Turtle, JSON-LD, RDF/XML) when requested with the appropriate Accept header; (3) HTML entity descriptions — human-readable pages with navigable hyperlinks for agentic browsing. No custom API, SDK, or platform-specific integration is required — any standards-compliant SPARQL client or HTTP agent can interact with the graph.

Quad Maps are Virtuoso's internal representation of R2RML mappings — they define how SPARQL graph patterns translate to SQL queries against virtual tables. The R2RML_MAKE_QM_FROM_G function converts declarative R2RML Turtle mappings into optimized Quad Maps that Virtuoso's SPARQL engine uses at query time. This is what makes SPARQL queries executable against remote relational tables without data movement.

Content negotiation is an HTTP mechanism where the server inspects the client's Accept header to determine the response format. For the bakehouse knowledge graph: browsers requesting text/html receive a human-readable HTML description page with navigable links; AI agents and RDF clients requesting application/ld+json or text/turtle receive machine-readable RDF. This single-URI, multi-format approach means the same entity identifier works for both human exploration and automated agent consumption — a cornerstone of Linked Data and the Semantic Web.

The virtual knowledge graph approach using ODBC attachment is best suited for batch reasoning, GraphRAG over reference data, or exploratory graph analytics. For millisecond-latency graph traversals or high-frequency transactional writes, a native graph store may be more appropriate. However, for the majority of enterprise AI agent use cases — where agents need to discover entity relationships, traverse connections, and retrieve structured context — the performance characteristics are more than adequate.

You need: (1) a Databricks SQL warehouse (Serverless, Pro, or Classic) to provide the ODBC endpoint; (2) the Databricks ODBC Driver installed on the Virtuoso host; (3) a Personal Access Token for authentication; and (4) the workspace Host and HTTP Path for the SQL warehouse. The public samples.bakehouse dataset provides the example tables — your own Databricks catalogs and schemas work the same way.