SPARQLWorks Visualizer
type: WebSite
name: Virtuoso R2RML Documentation
name: OpenLink Virtuoso Homepage
name: W3C R2RML Specification
name: W3C SPARQL 1.1 Query Language
name: W3C RDF Standard

Linked Data
type: DefinedTerm
description: A method of publishing structured data using HTTP URIs and RDF so that it can be interlinked and become more useful through semantic queries.

Quad Map Generation
type: Class
comment: The conversion of R2RML mappings into Virtuoso's internal Quad Map format for efficient SPARQL-to-SQL translation.

SPARQL
type: DefinedTerm
description: SPARQL Protocol and RDF Query Language — the W3C standard query language for RDF graphs. In the virtual knowledge graph, SPARQL queries are translated to SQL and executed against the live Databricks warehouse.

Is this approach suitable for real-time or high-frequency workloads?
type: Question
accepted answer: Answer: Is this approach suitable for real-time or high-frequency wo...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: Is this approach suitable for real-time or high-frequency workloads?

Semantic Web
type: DefinedTerm
description: An extension of the World Wide Web where data is given well-defined meaning through standards like RDF, SPARQL, and OWL — enabling machines and AI agents to reason about interconnected data across system boundaries.

Why use Virtuoso with Databricks instead of Databricks' built-in graph features?
type: Question
accepted answer: Answer: Why use Virtuoso with Databricks instead of Databricks' buil...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: Why use Virtuoso with Databricks instead of Databricks' built-in graph features?

Databricks-Virtuoso Virtual Knowledge Graph FAQ
type: FAQPage
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso
main entity: What is a Virtual Knowledge Graph?
main entity: Why use Virtuoso with Databricks instead of Databricks' built-in graph features?
main entity: Does data get copied from Databricks to Virtuoso?
main entity: What is R2RML and why is it important?
main entity: How do AI agents consume this knowledge graph?
main entity: What are Quad Maps in Virtuoso?
main entity: What is content negotiation and why does it matter for AI agents?
main entity: Is this approach suitable for real-time or high-frequency workloads?
main entity: What Databricks components are required?
main entity: How does this compare to traditional ETL-based knowledge graph construction?
main entity: Can I use this approach with data sources other than Databricks?
main entity: What skills or expertise are needed to implement this?

danielhm
type: Person
alternate name: danielhmills

Entity Type Discovery
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: SPARQL SELECT rdf:type FROM <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> WHERE { ?s a ?o } LIMIT 10
potential action: actionsparqlEntityTypes
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: SELECT * WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?s a ?o } } LIMIT 10

Clone the Demo Repository
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 4
text: Clone the companion GitHub repository containing ODBC templates, R2RML mapping files, ontology, and setup scripts: git clone https://github.com/danielhmills/databricks-sample-kg.git.

Semantic enrichment
type: ActionAccessSpecification
description: R2RML mappings add ontology-defined classes, properties, and inferred relationships — transforming implicit foreign keys into navigable semantic links.

Dashboard: Supplier-Ingredient-Franchise Product Flow
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: Supply chain visibility — traces supplier ingredients to the franchises that use them for a supply chain dashboard.
potential action: actionsparqlSupplierProductFlow
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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

Hyperlink-Based Entity Identity
type: Concept
description: The use of IRIs (Internationalized Resource Identifiers) as globally unique, dereferenceable entity identifiers — enabling entities from different systems (Databricks tables, external reference data, other knowledge graphs) to be linked and reasoned over as a single connected graph.

What are Quad Maps in Virtuoso?
type: Question
accepted answer: Answer: What are Quad Maps in Virtuoso?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What are Quad Maps in Virtuoso?

Databricks-Virtuoso Virtual Knowledge Graph — RDF Knowledge Graph
type: CreativeWork
date created: 2026-06-17
date modified: 2026-06-17
description: Comprehensive RDF knowledge graph covering the value proposition of generating AI Agent-friendly Knowledge Graphs from Databricks-hosted data using Virtuoso, R2RML, SPARQL, and Linked Data principles.

Virtual Knowledge Graph (VKG)
type: DefinedTerm
description: A knowledge graph constructed over existing relational data without physical data movement — using virtual database attachment to expose tables, R2RML to define semantic mappings, and SPARQL for graph querying.

How do AI agents consume this knowledge graph?
type: Question
accepted answer: Answer: How do AI agents consume this knowledge graph?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: How do AI agents consume this knowledge graph?

Virtual Database (VDB)
type: DefinedTerm
description: Virtuoso's capability to attach remote tables from ODBC/JDBC data sources — tables appear in the local catalog as virtual references without copying data.

Answer: Can I use this approach with data sources other than Databri...
type: Answer
text: 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.

Semantic Enrichment
type: Class
comment: The process of augmenting relational data with ontology-defined classes, properties, and inferred relationships to produce a knowledge graph.

Answer: Is this approach suitable for real-time or high-frequency wo...
type: Answer
text: 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.

Can I use this approach with data sources other than Databricks?
type: Question
accepted answer: Answer: Can I use this approach with data sources other than Databri...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: Can I use this approach with data sources other than Databricks?

Answer: What is R2RML and why is it important?...
type: Answer
text: 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.

URIBurner SPARQL Endpoint
type: WebAPI
description: Public SPARQL endpoint for querying knowledge graphs hosted in Virtuoso-backed URIBurner.

Capabilities Enabled
type: CreativeWork
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso

Answer: What is content negotiation and why does it matter for AI ag...
type: Answer
text: 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.

Databricks ODBC/JDBC Documentation
type: WebSite

R2RML Mapping
type: Class
comment: A W3C R2RML declarative mapping that defines how relational tables and columns map to RDF classes and properties.

sales_reviews
type: Dataset
type: Data Platform
description: Customer reviews and ratings for franchises.

URIBurner SPARQL Endpoint
type: WebSite
name: OpenLink Demo SPARQL Endpoint

sales_suppliers
type: Dataset
type: Data Platform
description: Supplier records for ingredients and materials.

requires component
type: Property
comment: A software component or driver required for the pipeline.
domain: Virtual Knowledge Graph

Ontology
type: DefinedTerm
description: A formal vocabulary defining classes, properties, and relationships within a domain. The bakehouse ontology defines Transaction, Franchise, Customer classes and franchise, totalPrice, city properties.

Answer: How do AI agents consume this knowledge graph?...
type: Answer
text: 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.

Production-grade infrastructure
type: ActionAccessSpecification
description: ACID compliance through the underlying Databricks warehouse, federated SPARQL for cross-graph queries, and Virtuoso's proven SPARQL-to-SQL query federation.

Databricks-Virtuoso Knowledge Graph Ontology
type: Ontology
description: Lightweight ontology for modelling the Databricks-to-Virtuoso virtual knowledge graph pipeline: ODBC attachment, R2RML mapping, SPARQL querying, Linked Data entity dereferencing, and AI Agent consumption patterns.
label: Databricks-Virtuoso KG Ontology

Linked Data Entity Navigation
type: Class
comment: The ability to dereference entity URIs via HTTP content negotiation, receiving HTML for browsers or RDF for machines.

Virtual Knowledge Graph
type: Class
comment: A knowledge graph constructed over existing relational data without physical data movement, using virtual database attachment and R2RML declarative mappings.

Virtuoso Universal Server
type: SoftwareApplication
alternate name: OpenLink Virtuoso
application category: Database Management System
application category: Knowledge Graph Platform
application category: SPARQL Endpoint
description: A secure, high-performance, cross-platform relational and graph database server with virtual database, SPARQL, RDF, SQL, and R2RML support.
manufacturer: OpenLink Software

Key Concepts
type: CreativeWork
has part: Virtual Knowledge Graph
has part: Graph Reasoning
has part: Semantic Enrichment
has part: Zero Data Movement
has part: Loosely Coupled Semantic Layer
has part: Hyperlink-Based Entity Identity
has part: AI Agent-Friendly Knowledge Graph
has part: Content Negotiation
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso

Loosely Coupled Semantic Layer
type: Concept
description: A semantic enrichment layer that sits atop existing data platforms without tight coupling — replacing ETL-driven data copying with standards-based virtualization. The knowledge graph is an overlay, not a replacement or another silo.

From Databricks Tables to a Virtual Knowledge Graph with Virtuoso
type: CreativeWork
type: TechArticle
about: Virtual Knowledge Graph
about: databricksPlatform
about: Virtuoso Universal Server
about: Semantic Web
about: Knowledge graph
abstract: A step-by-step guide demonstrating how to unlock machine-computable entity relationships across existing Databricks data without migration, duplication, or platform lock-in — using RDF, SPARQL, R2RML, and Virtuoso's Virtual Database to create an AI Agent-friendly Knowledge Graph deployed on the Semantic Web.
article body: Modern AI and analytics need graph reasoning capabilities — the ability to traverse relationships and discover patterns across connected data — but most enterprise data sits in relational warehouses where relationships rely on implicit foreign keys. This guide shows how to bridge that gap using open W3C standards: RDF for entity relationships, SPARQL for graph querying, and R2RML for exposing relational data as graphs. Hyperlinks (IRIs) serve as globally unique identifiers enabling disparate systems to be connected and reasoned over as a whole. The result is a Knowledge Graph that extends beyond the boundaries of any single database, platform, or application.
author: danielhm
date modified: 2026-06-17
date published: 2026-06-09
has part: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
has part: Key Concepts
has part: Capabilities Enabled
has part: W3C Standards
has part: Software Stack
has part: Bakehouse Sample Dataset
has part: Databricks-Virtuoso Virtual Knowledge Graph FAQ
has part: Databricks-Virtuoso Knowledge Graph Glossary
language: en
mentions: OpenLink Software
mentions: Databricks
related link: https://github.com/danielhmills/databricks-sample-kg
related link: Companion GitHub Repository
related link: https://github.com/danielhmills/databricks-sample-kg/blob/main/README.md
related link: Full README
related link: https://github.com/danielhmills/databricks-sample-kg/blob/main/bakehouse/r2rml.ttl
related link: R2RML Mappings (Turtle)
related link: https://github.com/danielhmills/databricks-sample-kg/blob/main/bakehouse/ontology.ttl
related link: Bakehouse Ontology (Turtle)
related link: https://github.com/danielhmills/sparqlworks/
related link: SPARQLWorks Visualizer
related link: https://www.databricks.com/spark/odbc-driver-download
related link: Databricks ODBC Driver Download
related link: https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html
related link: Databricks ODBC/JDBC Documentation
related link: http://docs.openlinksw.com/virtuoso/rdb2rdfviewsrdb2rdf/
related link: https://virtuoso.openlinksw.com/
related link: https://linkeddata.uriburner.com/sparql
related link: URIBurner SPARQL Endpoint
related link: http://demo.openlinksw.com/sparql
related link: https://www.w3.org/TR/r2rml/
related link: https://www.w3.org/TR/sparql11-query/
related link: https://www.w3.org/RDF/
was generated by: kg-generator skill

graphOntology
type: DataFeed
description: Ontology graph — defines the bakehouse vocabulary: classes (Transaction, Franchise, Customer) and properties (franchise, totalPrice, city).
name: http://www.databricks.com/bakehouse#

Bakehouse Sample Dataset
type: CreativeWork
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso

Answer: What skills or expertise are needed to implement this?...
type: Answer
text: 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.

Semantic Enrichment
type: Concept
description: The process of augmenting relational data with ontology-defined classes (e.g., :Transaction, :Franchise), properties (e.g., :franchise, :totalPrice), and inferred relationships to produce a machine-readable knowledge graph. R2RML mappings are the declarative bridge between SQL schemas and RDF vocabularies.

ODBC
type: DefinedTerm
description: Open Database Connectivity — standard API for accessing database management systems.

Dashboard: Top 10 Customers by Total Spend
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: Customer value analysis — ranks customers by total spend across all their transactions for a CRM dashboard.
potential action: actionsparqlTopCustomers
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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

Content Negotiation
type: Concept
description: An HTTP mechanism where the server inspects the client's Accept header to determine the response format — returning an HTML description page for browsers and RDF (Turtle, JSON-LD, RDF/XML) for semantic agents and RDF clients.

What skills or expertise are needed to implement this?
type: Question
accepted answer: Answer: What skills or expertise are needed to implement this?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What skills or expertise are needed to implement this?

Databricks-Virtuoso Knowledge Graph Glossary
type: DefinedTermSet
has defined term: Virtual Knowledge Graph (VKG)
has defined term: R2RML (RDB to RDF Mapping Language)
has defined term: Quad Map
has defined term: Virtual Database (VDB)
has defined term: SPARQL
has defined term: Linked Data
has defined term: Content Negotiation
has defined term: Ontology
has defined term: ODBC (Open Database Connectivity)
has defined term: AI Agent-Friendly Knowledge Graph
has defined term: Entity URI
has defined term: Semantic Web
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso
type: ConceptScheme

SPARQL
type: DefinedTerm
description: SPARQL Protocol and RDF Query Language — W3C standard for querying and manipulating RDF graphs.

Companion GitHub Repository
type: WebSite

R2RML Mappings (Turtle)
type: WebSite

sales_customers
type: Dataset
type: Data Platform
description: Customer records with names, contact details, and loyalty status.

What is content negotiation and why does it matter for AI agents?
type: Question
accepted answer: Answer: What is content negotiation and why does it matter for AI ag...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What is content negotiation and why does it matter for AI agents?

AI Agent-Friendly Knowledge Graph
type: Concept
description: A knowledge graph designed for consumption by AI agents — featuring dereferenceable entity URIs, machine-readable RDF representations, SPARQL endpoints for structured querying, and navigable entity relationships. The Databricks-Virtuoso pipeline produces such a graph: an AI agent can follow entity links, execute SPARQL queries, and retrieve structured context without custom API integration.

CONSTRUCT for Graph Visualization (SPARQLWorks)
type: SoftwareSourceCode
code sample type: text/x-html-nice-turtle
description: SPARQL CONSTRUCT extracting the Transaction-Franchise-City subgraph for interactive node-link visualization in SPARQLWorks.
potential action: actionsparqlConstructVisualization
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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

Full README
type: WebSite

enables capability
type: Property
comment: A capability unlocked by the virtual knowledge graph approach.
domain: Virtual Knowledge Graph

sales_transactions
type: Dataset
type: Data Platform
description: Transaction records linking customers to franchises with line items and pricing.

Zero Data Movement
type: Concept
description: A defining characteristic of the virtual knowledge graph approach — Databricks tables are attached via ODBC as virtual references, not copied. SPARQL queries are translated to SQL and executed remotely against the Databricks warehouse at query time.

OpenLink Software
type: Organization
description: Creator of Virtuoso Universal Server, URIBurner, and enterprise knowledge graph infrastructure.

Dashboard: Order Size Distribution (Revenue Segmentation)
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: Revenue segmentation analysis — buckets transactions by value range for a financial performance dashboard.
potential action: actionsparqlOrderSizeDistribution
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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)

Verify the Knowledge Graph with SPARQL
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 7
text: Run SPARQL queries against the virtual knowledge graph — test entity type discovery (SELECT * FROM <...> WHERE { ?s a ?o }), cross-table joins (Revenue by Franchise), and CONSTRUCT queries for graph visualization in SPARQLWorks. Confirm dereferenceable entity URIs respond to both browsers and RDF clients via content negotiation.

samples.bakehouse
type: Dataset
description: A fictional bakery chain dataset provided by Databricks as a public sample — includes customers, franchises, suppliers, transactions, and reviews tables.
has part: sales_customers
has part: sales_franchises
has part: sales_transactions
has part: sales_suppliers
has part: sales_reviews

Databricks ODBC Driver
type: SoftwareApplication
application category: Database Driver
description: ODBC driver enabling SQL connectivity between Virtuoso and Databricks SQL warehouses for virtual database attachment.

Answer: Why use Virtuoso with Databricks instead of Databricks' buil...
type: Answer
text: 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.

Standards-based interoperability
type: ActionAccessSpecification
description: W3C standards (RDF, SPARQL, R2RML) prevent vendor lock-in — the knowledge graph is portable and queryable by any standards-compliant SPARQL client or AI agent.

Data Platform
type: Class
comment: A cloud or on-premises platform hosting structured data (warehouses, lakes, lakehouses).

Dashboard: Revenue by City (Geographic Distribution)
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: Geographic revenue breakdown — aggregates totalPrice by franchise city for a regional performance dashboard.
potential action: actionsparqlRevenueByCity
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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)

What Databricks components are required?
type: Question
accepted answer: Answer: What Databricks components are required?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What Databricks components are required?

SPARQLWorks
type: SoftwareApplication
application category: Graph Visualization
description: A SPARQL query visualisation tool that renders CONSTRUCT query results as interactive node-link diagrams for exploring knowledge graph relationships.

Answer: What is a Virtual Knowledge Graph?...
type: Answer
text: 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.

Answer: Does data get copied from Databricks to Virtuoso?...
type: Answer
text: 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.

Test the Attached Tables
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 6
text: Verify the virtual attachment by running a SQL SELECT query against the virtual tables (e.g., SELECT TOP 10 * FROM databricks.bakehouse.sales_customers) via isql or the Conductor iSQL UI.

Connect to the Data Source
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 3
text: Find databricks_odbc in the External Data Sources list, click Connect, supply the username (token) and password (personal access token), and establish the ODBC connection from Virtuoso to the Databricks SQL warehouse.

How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
type: HowTo
description: Seven-step guide to creating an AI Agent-friendly knowledge graph from Databricks-hosted data without migration, duplication, or platform lock-in.
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso
step: Create the ODBC DSN
step: Register the DSN in Virtuoso
step: Connect to the Data Source
step: Clone the Demo Repository
step: Run the Quick Setup Script
step: Test the Attached Tables
step: Verify the Knowledge Graph with SPARQL

urn:databricks:bakehouse:r2rml
type: DataFeed
description: R2RML mapping graph — defines the SQL-to-RDF mapping rules for the bakehouse schema.

What is a Virtual Knowledge Graph?
type: Question
accepted answer: Answer: What is a Virtual Knowledge Graph?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What is a Virtual Knowledge Graph?

Entity URI
type: DefinedTerm
description: A globally unique, dereferenceable HTTP identifier for a knowledge graph entity (e.g., http://demo.openlinksw.com/databricks/bakehouse/franchise-3000046#this). When dereferenced, returns either human-readable HTML or machine-readable RDF depending on the client.

OpenLink Demo SPARQL Endpoint
type: WebAPI
description: Demo SPARQL endpoint hosting the bakehouse virtual knowledge graph for live query testing.

Content Negotiation
type: DefinedTerm
description: An HTTP mechanism where a server returns different representations of the same resource based on the client's Accept header — HTML for browsers, RDF for semantic agents.

W3C Standards
type: CreativeWork
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso

quick_setup.sql
type: SoftwareSourceCode
code repository: databricks-sample-kg
description: SQL script that attaches Databricks tables to Virtuoso's local catalog, grants SPARQL access, loads R2RML mappings and ontology, generates quad maps, and configures URL rewrite rules for Linked Data.
programming language: SQL

What is R2RML and why is it important?
type: Question
accepted answer: Answer: What is R2RML and why is it important?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: What is R2RML and why is it important?

Answer: What are Quad Maps in Virtuoso?...
type: Answer
text: 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.

Databricks ODBC Driver Download
type: WebSite

Quad Map
type: DefinedTerm
description: Virtuoso's internal compiled representation of R2RML mapping rules — the SPARQL engine uses quad maps at query time to translate SPARQL graph patterns into SQL queries against virtual tables.

AI Agent-Friendly Knowledge Graph
type: DefinedTerm
description: A knowledge graph designed for AI agent consumption — featuring dereferenceable entity URIs, machine-readable RDF, SPARQL endpoints, and navigable entity relationships without custom API integration.

Linked Data
type: DefinedTerm
description: A method of publishing structured data on the web using HTTP URIs, RDF, and content negotiation — enabling entities to be interlinked across systems and consumed by both humans and machines.

Zero data movement
type: ActionAccessSpecification
description: Virtuoso's Virtual Database attaches Databricks tables via ODBC as virtual references — no ETL, no duplication, no stale copies.

Answer: How does this compare to traditional ETL-based knowledge gra...
type: Answer
text: 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.

Databricks
type: Organization
description: Cloud data platform provider offering data lakehouse architecture combining data lakes and data warehouses.

sales_franchises
type: Dataset
type: Data Platform
description: Franchise locations with city, country, and coordinate data.

Register the DSN in Virtuoso
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 2
text: Access the External Data Sources Manager in Virtuoso Conductor at /conductor/vdb_conn_dsn.vspx to register the databricks_odbc DSN for use by Virtuoso's Virtual Database engine.

Linked Data entity navigation
type: ActionAccessSpecification
description: Every entity (customer, franchise, transaction) receives a dereferenceable HTTP URI with content negotiation — browsers see HTML descriptions, AI agents retrieve machine-readable RDF.

Revenue by Franchise (Cross-Table SPARQL Join)
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: SPARQL SELECT with SUM aggregation joining Transaction and Franchise tables via the :franchise property, grouped by franchise and city.
potential action: actionsparqlRevenueByFranchise
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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

databricks-sample-kg
type: SoftwareSourceCode
code repository: https://github.com/danielhmills/databricks-sample-kg
description: Companion repository containing ODBC configuration templates, R2RML mappings, ontology, and setup scripts for the Databricks-to-Virtuoso virtual knowledge graph pipeline.

Virtual Knowledge Graph
type: Concept
description: A knowledge graph constructed over existing relational data without physical data movement — using virtual database attachment to expose tables, R2RML to define semantic mappings, and SPARQL for graph querying. The data stays in Databricks; the semantics are layered on top via Virtuoso.

Graph Reasoning
type: Concept
description: The ability to traverse relationships and discover patterns across connected data using ontology-defined semantics rather than implicit foreign keys. In the bakehouse example, foreign keys become navigable hyperlinks connecting Transaction→Franchise→City through named relationships.

graphInstance
type: DataFeed
description: Instance data graph — the runtime virtual knowledge graph containing entity triples generated by applying R2RML mappings to the live Databricks tables.
name: https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl

Software Stack
type: CreativeWork
is part of: From Databricks Tables to a Virtual Knowledge Graph with Virtuoso

Run the Quick Setup Script
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 5
text: Execute quick_setup.sql via isql — this script attaches each Databricks table (ATTACH TABLE ... FROM 'databricks_odbc'), grants SPARQL_SELECT privileges, loads the R2RML mapping and ontology via SPARQL LOAD, generates quad maps via R2RML_MAKE_QM_FROM_G, and configures URL rewrite rules for Linked Data content negotiation.

Create the ODBC DSN
type: HowToStep
is part of: How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
position: 1
text: Configure a Databricks ODBC Data Source Name (DSN) — install the Databricks ODBC Driver, obtain workspace Host/HTTP Path/Personal Access Token, and populate odbcinst.ini and odbc.ini with the driver and connection details.

Graph Reasoning Capability
type: Class
comment: The ability to traverse relationships and discover patterns across connected data using ontology-defined semantics rather than implicit foreign keys.

How does this compare to traditional ETL-based knowledge graph construction?
type: Question
accepted answer: Answer: How does this compare to traditional ETL-based knowledge gra...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: How does this compare to traditional ETL-based knowledge graph construction?

implements standard
type: Property
comment: A W3C or industry standard employed in the solution.
domain: Virtual Knowledge Graph

RDF
type: DefinedTerm
description: Resource Description Framework — W3C standard for representing entity relationships as subject-predicate-object triples.

Dashboard: Top Rated Franchises (Customer Satisfaction)
type: SoftwareSourceCode
code sample type: text/x-html+tr
description: Customer satisfaction metrics — averages review ratings per franchise for a quality monitoring dashboard.
potential action: actionsparqlTopRatedFranchises
programming language: SPARQL
target: OpenLink Demo SPARQL Endpoint
text: 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

Answer: What Databricks components are required?...
type: Answer
text: 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.

maps to
type: Property
comment: The RDF class or property a relational construct maps to.
domain: R2RML Mapping

ODBC (Open Database Connectivity)
type: DefinedTerm
description: A standard API for accessing database management systems — used by Virtuoso to connect to Databricks SQL warehouses for virtual table attachment.

Virtual Database Attachment
type: Class
comment: Connecting to a remote database via ODBC/JDBC without copying data — tables appear in the local catalog as virtual references.

R2RML (RDB to RDF Mapping Language)
type: DefinedTerm
description: A W3C recommendation that declaratively defines how relational database tables, columns, primary keys, and foreign keys map to RDF classes, properties, and object relationships.

Graph reasoning on existing data
type: ActionAccessSpecification
description: SPARQL queries over Databricks tables without data movement — SQL is generated and executed at query time against the live Databricks warehouse.

Bakehouse Ontology (Turtle)
type: WebSite

R2RML
type: DefinedTerm
description: RDB to RDF Mapping Language — W3C recommendation for exposing relational data as RDF graphs using declarative mappings.

uses data platform
type: Property
comment: The data platform whose tables are being virtualized into the knowledge graph.
domain: Virtual Knowledge Graph

kg-generator skill
type: SoftwareApplication
type: SoftwareAgent
description: Knowledge graph generation skill for AI agents — transforms documents and web content into structured RDF.

Does data get copied from Databricks to Virtuoso?
type: Question
accepted answer: Answer: Does data get copied from Databricks to Virtuoso?...
is part of: Databricks-Virtuoso Virtual Knowledge Graph FAQ
text: Does data get copied from Databricks to Virtuoso?

produces artifact
type: Property
comment: An artifact (named graph, entity URI, SPARQL result) produced by the pipeline.
domain: Virtual Knowledge Graph