@prefix : . @prefix post: . @prefix ex: . @prefix ont: . @prefix schema: . @prefix rdf: . @prefix rdfs: . @prefix owl: . @prefix xsd: . @prefix skos: . @prefix dbr: . @prefix dbo: . ################################################################# # Ontology declaration (small, document-local; no corpus-canonical # term found in agent-rdf-memory/entities/ontology-terms.ttl for # RDF 1.2 triple-term / reifier / historical-approach concepts) ################################################################# ont: a owl:Ontology ; schema:name "RDF 1.2 Support in Virtuoso — Lightweight Concept Ontology"@en ; schema:description "Minimal ontology describing RDF 1.2 statement-annotation concepts (triple terms, reifiers, annotation syntax), historical statement-annotation approaches, and code-example provenance used by the companion knowledge graph for the OpenLink Community post introducing RDF 1.2 support in Virtuoso."@en ; schema:url . ont:Concept a owl:Class ; rdfs:label "RDF 1.2 Concept"@en ; rdfs:isDefinedBy ont: ; rdfs:comment "A named RDF 1.2 / SPARQL 1.2 modeling concept discussed in the source article (e.g. Triple Term, Reifier, Annotation Syntax)."@en . ont:HistoricalApproach a owl:Class ; rdfs:label "Historical Statement-Annotation Approach"@en ; rdfs:isDefinedBy ont: ; rdfs:subClassOf ont:Concept ; rdfs:comment "A pre-RDF-1.2 modeling pattern used to attach metadata to RDF statements (standard reification, n-ary relations, singleton properties)."@en . ont:RDF12Feature a owl:Class ; rdfs:label "RDF 1.2 Feature"@en ; rdfs:isDefinedBy ont: ; rdfs:subClassOf ont:Concept ; rdfs:comment "A capability introduced by RDF 1.2 for treating triples as first-class values (triple terms, reifiers, annotation syntax, SPARQL 1.2 query support)."@en . ont:BenefitClaim a owl:Class ; rdfs:label "RDF 1.2 Benefit Claim"@en ; rdfs:isDefinedBy ont: ; rdfs:comment "A stated advantage of RDF 1.2 statement annotation over prior approaches, as argued in the 'Why RDF 1.2 Matters' section of the source article."@en . ont:exampleSource a owl:ObjectProperty ; rdfs:label "example illustrates concept"@en ; rdfs:isDefinedBy ont: ; rdfs:domain schema:SoftwareSourceCode ; rdfs:range ont:Concept ; rdfs:comment "Relates a code example (schema:SoftwareSourceCode) to the RDF 1.2 / historical-approach concept it demonstrates."@en . ont:exampleOrigin a owl:DatatypeProperty ; rdfs:label "example origin"@en ; rdfs:isDefinedBy ont: ; rdfs:domain schema:SoftwareSourceCode ; rdfs:range xsd:string ; rdfs:comment "Marks whether a code example is verbatim from the source article ('post') or supplied for completeness from the RDF 1.2 / RDF-star / SPARQL 1.2 W3C specifications ('spec-supplement')."@en . ont:reifiesStatementAbout a owl:ObjectProperty ; rdfs:label "reifies statement about"@en ; rdfs:isDefinedBy ont: ; rdfs:comment "RDF 1.1-safe stand-in for rdf:reifies << s p o >>, used only in this document's materialized example data so the file stays parseable as RDF 1.1 Turtle; the real RDF 1.2 triple-term form is preserved verbatim inside the relevant schema:SoftwareSourceCode entities."@en . ################################################################# # Article / Source ################################################################# a schema:TechArticle ; schema:headline "Introducing RDF 1.2 Support in Virtuoso"@en ; schema:name "Introducing RDF 1.2 Support in Virtuoso"@en ; schema:description "OpenLink Community post announcing RDF 1.2 support in Virtuoso: triple terms, reifiers, annotation syntax, and SPARQL 1.2 query support for statement-level provenance, confidence, and metadata."@en ; schema:abstract """

Organizations routinely need to answer questions a plain RDF triple cannot: where a fact came from, when it was verified, who asserted it, and how trustworthy it is. Before RDF 1.2, developers reached for standard reification, n-ary relations, or singleton properties to attach that metadata — each solved the immediate problem but introduced its own verbosity, lost-triple, or predicate-explosion tradeoff. RDF 1.2 replaces all three with a single standardized mechanism.

Virtuoso now implements that mechanism directly: triple terms let a statement be referenced as a value, reifiers attach source/date/confidence metadata to it without disturbing the base triple, and the compact annotation syntax lets both be written in one line. SPARQL 1.2 extends the query language to match — INSERT DATA, TRIPLE(), SUBJECT()/PREDICATE()/OBJECT(), and isTRIPLE() all operate on triple terms directly — so provenance, confidence, and verification data become first-class, standards-based, and queryable rather than a bespoke application convention.

"""@en ; schema:url ; schema:datePublished "2026-06-01"^^xsd:date ; schema:author :danielhm ; schema:publisher :openlinkSoftware ; schema:about ont:Concept, :virtuoso, :rdf12, :sparql12 ; schema:mentions :standardReification, :nAryRelations, :singletonProperties, :tripleTermConcept, :reifierConcept, :annotationSyntaxConcept ; schema:isPartOf ; schema:hasPart :faqPage, :glossary, :howTo . :danielhm a schema:Person ; schema:name "Daniel Heward-Mills"@en ; schema:url ; schema:memberOf :openlinkSoftware . :openlinkSoftware a schema:Organization, owl:Thing ; owl:sameAs dbr:OpenLink_Software ; schema:name "OpenLink Software"@en ; schema:url . :virtuoso a schema:SoftwareApplication, owl:Thing ; owl:sameAs dbr:Virtuoso_Universal_Server ; schema:name "Virtuoso"@en ; schema:applicationCategory "Multi-Model DBMS / Universal Server"@en ; schema:producer :openlinkSoftware ; schema:url . :rdf12 a schema:DefinedTerm, owl:Thing ; owl:sameAs dbr:Resource_Description_Framework ; schema:name "RDF 1.2"@en ; schema:description "The W3C-standardized next major revision of the Resource Description Framework, adding triple terms, reifiers, and annotation syntax for statement-level metadata."@en . :sparql12 a schema:DefinedTerm, owl:Thing ; owl:sameAs dbr:SPARQL ; schema:name "SPARQL 1.2"@en ; schema:description "The companion query-language revision to RDF 1.2, adding triple-term literals, VALUES/FILTER/BIND support for triple terms, and the TRIPLE()/SUBJECT()/PREDICATE()/OBJECT()/isTRIPLE() functions."@en . ################################################################# # Core RDF 1.2 concepts ################################################################# :tripleTermConcept a ont:RDF12Feature ; schema:name "Triple Term"@en ; schema:description "RDF 1.2's mechanism for treating an RDF triple as a first-class value that can itself be the subject or object of another statement, written with double angle brackets: << :s :p :o >>."@en . :reifierConcept a ont:RDF12Feature ; schema:name "Reifier"@en ; schema:description "A resource related to a triple term via rdf:reifies, used to attach metadata (source, verification date, confidence) to a statement without altering the base triple."@en . :annotationSyntaxConcept a ont:RDF12Feature ; schema:name "Annotation Syntax"@en ; schema:description "RDF 1.2 Turtle shorthand ({| ... |}) that asserts a triple and attaches reifier metadata in one compact statement, automatically creating an underlying reifier."@en . :sparql12QuerySupportConcept a ont:RDF12Feature ; schema:name "SPARQL 1.2 Query Support"@en ; schema:description "SPARQL query-language extensions for reading and writing RDF 1.2 triple terms and reifiers, including INSERT DATA with annotation syntax and explicit reifiers inside named graphs."@en . :standardReification a ont:HistoricalApproach ; schema:name "Standard Reification"@en ; schema:description "The original RDF mechanism that creates an rdf:Statement resource with rdf:subject/rdf:predicate/rdf:object properties to describe a triple. Verbose and did not clearly express observer/scribe semantics."@en . :nAryRelations a ont:HistoricalApproach ; schema:name "N-Ary Relations"@en ; schema:description "A pattern that converts a relationship into a first-class event/relationship resource carrying the participants and metadata as properties. The original direct triple no longer exists; every query must traverse the intermediate node."@en . :singletonProperties a ont:HistoricalApproach ; schema:name "Singleton Properties"@en ; schema:description "A pattern that mints a unique predicate for each occurrence of a relationship (e.g. :worksFor_123) so metadata can attach to the predicate itself, at the cost of generating large numbers of one-off predicates in bulk datasets."@en . :multipleSourcesSameFact a ont:BenefitClaim ; schema:name "Multiple Sources Can Describe the Same Fact"@en ; schema:description "RDF 1.2 separates the statement itself from the records that describe it, so independent systems can each attach their own provenance to a shared, single asserted triple via separate reifiers."@en . :standardsBasedProvenance a ont:BenefitClaim ; schema:name "Standards-Based Provenance"@en ; schema:description "RDF 1.2 supplies a common W3C framework for recording where information originated and how it was verified, replacing bespoke application-specific annotation models."@en . :cleanerDataModels a ont:BenefitClaim ; schema:name "Cleaner Data Models"@en ; schema:description "The underlying relationship stays a simple direct triple while metadata attaches separately through reifiers, avoiding artificial event nodes or synthetic one-off predicates."@en . :improvedInteroperability a ont:BenefitClaim ; schema:name "Improved Interoperability"@en ; schema:description "Applications exchanging RDF 1.2 data can rely on one common representation for statement annotations, provenance, confidence scores, temporal metadata, and evidence tracking."@en . ################################################################# # Materialized example data (RDF 1.1-valid modeling of the # post's Alice / Acme Corp scenario, part of the Core/Full KG # and queryable once this document is loaded into a named graph) ################################################################# ex:alice a schema:Person ; schema:name "Alice"@en ; ex:worksFor ex:AcmeCorp . ex:AcmeCorp a schema:Organization ; schema:name "Acme Corp"@en . ex:HRSystem a schema:SoftwareApplication ; schema:name "HR System"@en . ex:CorporateDirectory a schema:SoftwareApplication ; schema:name "Corporate Directory"@en . ex:employmentRecord1 a ont:Reifier ; rdfs:comment "RDF 1.1-safe restatement of the explicit-reifier example. The real RDF 1.2 triple-term form (rdf:reifies << :alice :worksFor :AcmeCorp >>) is preserved verbatim in :ceExplicitReifierForm."@en ; ont:reifiesStatementAbout ex:alice ; ex:source ex:HRSystem ; ex:verifiedOn "2025-01-15"^^xsd:date ; ex:confidence "0.98"^^xsd:decimal . ex:hrRecord a ont:Reifier ; ont:reifiesStatementAbout ex:alice ; ex:source ex:HRSystem ; ex:verifiedOn "2025-01-15"^^xsd:date . ex:directoryRecord a ont:Reifier ; ont:reifiesStatementAbout ex:alice ; ex:source ex:CorporateDirectory ; ex:verifiedOn "2025-01-20"^^xsd:date . :ceBaseRelationship a schema:SoftwareSourceCode ; schema:name "Base Relationship Used Throughout the Article"@en ; schema:description "The single relationship the entire article reuses as its running example. Not presented as a live SPARQL Workbench query: anonymous SPARQL UPDATE (INSERT DATA) against the endpoint always fails with 401 (ACL requires authentication), so INSERT-based examples are documented as reference text only, not framed as runnable."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 1 ; ont:exampleOrigin "post" ; ont:exampleSource :tripleTermConcept ; schema:isPartOf ; schema:text """PREFIX : <#> :alice :worksFor :AcmeCorp .""" . :ceMetadataToAttach a schema:SoftwareSourceCode ; schema:name "Metadata to Attach to the Relationship"@en ; schema:description "The provenance metadata (source system, verification date) the article attempts to attach to the base relationship using each historical and RDF 1.2 approach in turn."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 2 ; ont:exampleOrigin "post" ; ont:exampleSource :reifierConcept ; schema:isPartOf ; schema:text """PREFIX : PREFIX xsd: :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date .""" . :ceStandardReification a schema:SoftwareSourceCode ; schema:name "Standard Reification Example"@en ; schema:description "The original RDF reification pattern: an rdf:Statement resource with rdf:subject/rdf:predicate/rdf:object plus provenance properties."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 3 ; ont:exampleOrigin "post" ; ont:exampleSource :standardReification ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX rdf: PREFIX xsd: :employmentStatement rdf:type rdf:Statement ; rdf:subject :alice ; rdf:predicate :worksFor ; rdf:object :AcmeCorp ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date .""" . :ceNAryRelations a schema:SoftwareSourceCode ; schema:name "N-Ary Relations Example"@en ; schema:description "N-ary relations model the employment relationship as a first-class :EmploymentRelationship event resource carrying both participants and provenance."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 4 ; ont:exampleOrigin "post" ; ont:exampleSource :nAryRelations ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX rdf: PREFIX xsd: :employmentEvent1 rdf:type :EmploymentRelationship ; :employee :alice ; :employer :AcmeCorp ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date .""" . :ceNAryRelationsLostTriple a schema:SoftwareSourceCode ; schema:name "The Direct Triple No Longer Exists Under N-Ary Relations"@en ; schema:description "Under the N-Ary Relations pattern this direct triple no longer exists; every query must traverse the intermediate :employmentEvent1 node instead."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 5 ; ont:exampleOrigin "post" ; ont:exampleSource :nAryRelations ; schema:isPartOf ; schema:text """PREFIX : :alice :worksFor :AcmeCorp .""" . :ceSingletonProperties a schema:SoftwareSourceCode ; schema:name "Singleton Properties Example"@en ; schema:description "Singleton properties mint a unique predicate :worksFor_123 for this specific occurrence of the relationship so metadata can attach to the predicate itself."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 6 ; ont:exampleOrigin "post" ; ont:exampleSource :singletonProperties ; schema:isPartOf ; schema:text """PREFIX rdf: PREFIX xsd: :worksFor_123 rdf:type rdf:Property ; :singletonPropertyOf :worksFor ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date . :alice :worksFor_123 :AcmeCorp .""" . :ceTripleTermValue a schema:SoftwareSourceCode ; schema:name "A Triple Represented Directly as a Value"@en ; schema:description "RDF 1.2's triple-term syntax: the statement itself, written with double angle brackets, becomes a referenceable value — here bound to ?statement so it can be run live as a SPARQL 1.2 SELECT. This is a read-only query with no ACL/authentication requirement — live-verified against Virtuoso 08.03.3335 (2026-08-15), returns the correctly resolved triple term."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 7 ; ont:exampleOrigin "post" ; ont:exampleSource :tripleTermConcept ; schema:isPartOf ; schema:text """PREFIX : SELECT (<< :alice :worksFor :AcmeCorp >> AS ?statement) WHERE {}""" . :ceExplicitReifierForm a schema:SoftwareSourceCode ; schema:name "Explicit Reifier Form"@en ; schema:description "A named reifier (:employmentRecord1) explicitly points at the triple term via rdf:reifies, giving the observation a stable identifier other statements can reference."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 8 ; ont:exampleOrigin "post" ; ont:exampleSource :reifierConcept ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX rdf: PREFIX xsd: :employmentRecord1 rdf:reifies << :alice :worksFor :AcmeCorp >> ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date .""" . :ceAnnotationShorthand a schema:SoftwareSourceCode ; schema:name "Annotation Shorthand"@en ; schema:description "The concise RDF 1.2 annotation syntax: assert the triple and attach reifier metadata in one statement using the {| ... |} block."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 9 ; ont:exampleOrigin "post" ; ont:exampleSource :annotationSyntaxConcept ; schema:isPartOf ; schema:text """PREFIX xsd: :alice :worksFor :AcmeCorp {| :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date |} .""" . :ceAnnotationExpansion a schema:SoftwareSourceCode ; schema:name "Conceptual Expansion of the Annotation Shorthand"@en ; schema:description "What the annotation shorthand conceptually expands to: the base triple plus an auto-generated blank-node reifier carrying the metadata."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 10 ; ont:exampleOrigin "post" ; ont:exampleSource :annotationSyntaxConcept ; schema:isPartOf ; schema:text """PREFIX rdf: PREFIX xsd: :alice :worksFor :AcmeCorp . _:r rdf:reifies << :alice :worksFor :AcmeCorp >> ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date .""" . :ceMultipleSources a schema:SoftwareSourceCode ; schema:name "Two Independent Systems Confirming the Same Fact"@en ; schema:description "HR System and Corporate Directory each attach their own reifier (:hrRecord, :directoryRecord) to the same underlying triple, preserving independent provenance."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 11 ; ont:exampleOrigin "post" ; ont:exampleSource :multipleSourcesSameFact ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX rdf: PREFIX xsd: :alice :worksFor :AcmeCorp . :hrRecord rdf:reifies << :alice :worksFor :AcmeCorp >> ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date . :directoryRecord rdf:reifies << :alice :worksFor :AcmeCorp >> ; :source :CorporateDirectory ; :verifiedOn "2025-01-20"^^xsd:date .""" . :ceCleanerDataModel a schema:SoftwareSourceCode ; schema:name "Cleaner Data Model: Simple Triple Plus Separate Reifier"@en ; schema:description "Illustrates the 'Cleaner Data Models' claim: the base relationship stays a plain, direct triple while the reifier attaches separately."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 12 ; ont:exampleOrigin "post" ; ont:exampleSource :cleanerDataModels ; schema:isPartOf ; schema:text """PREFIX : <#> :alice :worksFor :AcmeCorp . PREFIX rdf: :employmentRecord1 rdf:reifies << :alice :worksFor :AcmeCorp >> .""" . :ceInsertAnnotationSyntax a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 INSERT DATA Using Annotation Syntax"@en ; schema:description "Inserts an annotated relationship into the named graph urn:graph:employees using the compact RDF 1.2 annotation syntax, including a numeric :confidence score. Reference text only, not presented as a live-runnable SPARQL Workbench query: anonymous SPARQL UPDATE against the endpoint always returns 401 (ACL requires authentication), confirmed live 2026-08-15."@en ; schema:programmingLanguage "SPARQL Update"@en ; schema:position 13 ; ont:exampleOrigin "post" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX xsd: INSERT DATA { GRAPH { :alice :worksFor :AcmeCorp {| :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date ; :confidence 0.98 |} . } }""" . :ceInsertExplicitReifiers a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 INSERT DATA Using Explicit Reifiers"@en ; schema:description "The explicit-reifier equivalent of the annotation-syntax insert, useful when the reifier itself must be referenced elsewhere in the domain model. Reference text only, not presented as a live-runnable SPARQL Workbench query: anonymous SPARQL UPDATE against the endpoint always returns 401 (ACL requires authentication), confirmed live 2026-08-15."@en ; schema:programmingLanguage "SPARQL Update"@en ; schema:position 14 ; ont:exampleOrigin "post" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX rdf: PREFIX xsd: PREFIX : <#> INSERT DATA { GRAPH { :alice :worksFor :AcmeCorp . :employmentRecord1 rdf:reifies << :alice :worksFor :AcmeCorp >> ; :source :HRSystem ; :verifiedOn "2025-01-15"^^xsd:date ; :confidence 0.98 . } }""" . :ceNestedTripleTerm a schema:SoftwareSourceCode ; schema:name "Nested Triple Term: A Statement About a Reified Statement"@en ; schema:description "A nested triple term: the outer statement asserts a confidence score about the inner statement 'the HR System stated that Alice works for Acme Corp', demonstrating that triple terms can themselves be quoted."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 15 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :tripleTermConcept ; schema:isPartOf ; schema:text """PREFIX : <#> PREFIX xsd: << << :alice :worksFor :AcmeCorp >> :statedBy :HRSystem >> :confidence 0.9 .""" . :ceAssertionAboutTripleTerm a schema:SoftwareSourceCode ; schema:name "Asserting a Claim Directly About a Triple Term"@en ; schema:description "A triple term used directly as the subject of another statement, distinct from the rdf:reifies pattern: here :bob is said to have asserted the employment claim."@en ; schema:programmingLanguage "Turtle"@en ; schema:position 16 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :tripleTermConcept ; schema:isPartOf ; schema:text """PREFIX : <#> << :alice :worksFor :AcmeCorp >> :assertedBy :bob .""" . :ceSelectTripleFunction a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 SELECT Constructing a Triple Term with TRIPLE()"@en ; schema:description "The SPARQL 1.2 TRIPLE() function builds a triple-term value from three bound terms inside a query projection, letting results carry statements as first-class values. Scoped to this document's DAV-uploaded named graph (not the post's illustrative urn:graph:employees, which anonymous users can never populate) — matches ex:alice ex:worksFor ex:AcmeCorp already materialized there, so this returns a real, non-empty result live. Live-verified against Virtuoso 08.03.3335 (2026-08-15): the default SELECT result format (text/x-html+tr) fails on this query with 'Error SR066: Unsupported case in CONVERT (ARRAY_OF_POINTER -> VARCHAR)' — a narrow HTML-table-writer bug specific to triple-term values produced via the TRIPLE() function (a triple term produced via the << >> literal syntax is unaffected and renders fine in text/x-html+tr). The 'Run live query' link for this example uses application/sparql-results+json instead, which handles both forms correctly; the generator's shared live-link builder now auto-detects TRIPLE() usage and applies this format automatically."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 17 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX : SELECT ?statement WHERE { GRAPH { ?person :worksFor ?org . BIND(TRIPLE(?person, :worksFor, ?org) AS ?statement) } }""" . :ceFilterSubjectPredicateObject a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 FILTER Using SUBJECT()/PREDICATE()/OBJECT()"@en ; schema:description "SPARQL 1.2's SUBJECT() and PREDICATE() accessor functions decompose a bound triple term so its components can be tested in a FILTER clause. Scoped to this document's DAV-uploaded named graph. Returns 0 rows live: the materialized instance data models its reifiers with the RDF-1.1-safe stand-in ont:reifiesStatementAbout (not rdf:reifies << >>), because the local generator toolchain's RDF parser does not support RDF-star/RDF 1.2 quoted-triple syntax — see :employmentRecord1 for the actual stored form. The query itself is correct SPARQL 1.2 and would match real rdf:reifies << >> data if present."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 18 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX rdf: PREFIX : SELECT ?reifier WHERE { GRAPH { ?reifier rdf:reifies ?stmt ; :source :HRSystem . FILTER (SUBJECT(?stmt) = :alice && PREDICATE(?stmt) = :worksFor) } }""" . :ceIsTripleFilter a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 FILTER Using isTRIPLE()"@en ; schema:description "The isTRIPLE() type-testing function confirms a bound value is a triple term before further processing, mirroring isIRI()/isLITERAL()/isBLANK(). Scoped to this document's DAV-uploaded named graph. Returns 0 rows live for the same reason as the SUBJECT()/PREDICATE()/OBJECT() example: the materialized data uses the ont:reifiesStatementAbout stand-in rather than rdf:reifies << >>, since the local generator toolchain's RDF parser lacks RDF-star support."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 19 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX rdf: SELECT ?reifier ?stmt WHERE { GRAPH { ?reifier rdf:reifies ?stmt . FILTER isTRIPLE(?stmt) } }""" . :ceConstructTripleTerms a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 CONSTRUCT Producing Triple Terms"@en ; schema:description "A CONSTRUCT query that reifies query results on the fly, generating a fresh reifier for every matched employment relationship together with its confidence score. Live-verified against Virtuoso 08.03.3335 (2026-08-15): calling TRIPLE() directly inside the CONSTRUCT template's rdf:reifies object position raised a SPARQL compiler syntax error; BIND-ing the triple term in the WHERE clause first, then referencing the bound variable in CONSTRUCT, parses and executes cleanly (200 OK). Scoped to this document's DAV-uploaded named graph; returns 0 rows live because the materialized data does not carry the {| :confidence ... |} annotation syntax on ex:alice ex:worksFor ex:AcmeCorp (same RDF-star tooling limitation as the SUBJECT()/PREDICATE() example) — the query itself is confirmed valid."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 20 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX : PREFIX rdf: CONSTRUCT { :provenanceReport rdf:reifies ?stmt ; :confidence ?confidence . } WHERE { GRAPH { ?person :worksFor ?org {| :confidence ?confidence |} . BIND(TRIPLE(?person, :worksFor, ?org) AS ?stmt) } }""" . :ceValuesTripleTerm a schema:SoftwareSourceCode ; schema:name "SPARQL 1.2 VALUES With a Triple-Term Literal"@en ; schema:description "A VALUES clause binding ?stmt directly to a triple-term literal, parameterizing the query to find every reifier attached to that exact statement. Live-verified against Virtuoso 08.03.3335 (2026-08-15): a triple-term constant inside a VALUES data block currently raises a SPARQL compiler syntax error on this build — confirmed general to the VALUES clause itself, not specific to SELECT: the identical failure reproduces in ASK, SELECT (both inline and as a trailing VALUES clause), and CONSTRUCT, and the TRIPLE() function-call form was tried as an alternative with the same rejection. A VALUES block with an ordinary IRI constant (no triple term) works fine in the same query forms, isolating the limitation to triple-term literals specifically as VALUES data. The identical << >> syntax parses and executes cleanly everywhere else it was tested (SELECT projection, BIND, and as the object of rdf:reifies in INSERT DATA/CONSTRUCT). Kept here as a spec-accurate SPARQL 1.2 example and a known current engine limitation, not a documentation error. Scoped to this document's DAV-uploaded named graph."@en ; schema:programmingLanguage "SPARQL"@en ; schema:position 21 ; ont:exampleOrigin "spec-supplement" ; ont:exampleSource :sparql12QuerySupportConcept ; schema:isPartOf ; schema:text """PREFIX : PREFIX rdf: SELECT ?reifier WHERE { GRAPH { VALUES ?stmt { << :alice :worksFor :AcmeCorp >> } ?reifier rdf:reifies ?stmt . } }""" . :faqPage a schema:FAQPage ; schema:name "RDF 1.2 Support in Virtuoso — Frequently Asked Questions"@en ; schema:isPartOf ; schema:mainEntity :faqWhatIsRdf12, :faqWhatIsTripleTerm, :faqWhatIsReifier, :faqWhatIsAnnotationSyntax, :faqWhyNotStandardReification, :faqWhyNotNAryRelations, :faqWhyNotSingletonProperties, :faqMultipleReifiers, :faqSparql12NewFunctions, :faqInsertAnnotatedData, :faqDoesVirtuosoSupportRdf12, :faqWhatProblemsDoesRdf12Solve . :faqWhatIsRdf12 a schema:Question ; schema:position 1 ; schema:name """What is RDF 1.2?"""@en ; schema:acceptedAnswer :faqWhatIsRdf12Answer . :faqWhatIsRdf12Answer a schema:Answer ; schema:text """RDF 1.2 is the current W3C-standardized revision of the Resource Description Framework. It adds triple terms, reifiers, and annotation syntax so RDF statements themselves can be referenced and annotated with metadata such as provenance, confidence, and verification dates, without changing the base triple."""@en . :faqWhatIsTripleTerm a schema:Question ; schema:position 2 ; schema:name """What is a triple term in RDF 1.2?"""@en ; schema:acceptedAnswer :faqWhatIsTripleTermAnswer . :faqWhatIsTripleTermAnswer a schema:Answer ; schema:text """A triple term is an RDF triple written as a value using double angle brackets, e.g. << :alice :worksFor :AcmeCorp >>. It lets a statement be referenced from elsewhere in the graph, for example as the object of rdf:reifies."""@en . :faqWhatIsReifier a schema:Question ; schema:position 3 ; schema:name """What is a reifier?"""@en ; schema:acceptedAnswer :faqWhatIsReifierAnswer . :faqWhatIsReifierAnswer a schema:Answer ; schema:text """A reifier is a resource related to a triple term through rdf:reifies. It carries metadata about the statement — source system, verification date, confidence score — while leaving the original triple untouched and directly queryable."""@en . :faqWhatIsAnnotationSyntax a schema:Question ; schema:position 4 ; schema:name """What does the RDF 1.2 annotation syntax ({| |}) do?"""@en ; schema:acceptedAnswer :faqWhatIsAnnotationSyntaxAnswer . :faqWhatIsAnnotationSyntaxAnswer a schema:Answer ; schema:text """The annotation syntax lets you assert a triple and its metadata in a single compact statement, e.g. :alice :worksFor :AcmeCorp {| :source :HRSystem |} . It automatically creates an underlying reifier equivalent to writing the explicit rdf:reifies form by hand."""@en . :faqWhyNotStandardReification a schema:Question ; schema:position 5 ; schema:name """Why not just use standard RDF reification?"""@en ; schema:acceptedAnswer :faqWhyNotStandardReificationAnswer . :faqWhyNotStandardReificationAnswer a schema:Answer ; schema:text """Standard reification (rdf:type rdf:Statement with rdf:subject/predicate/object) is verbose, does not clearly express who is making the claim (observer/scribe semantics), and is cumbersome for humans to author and maintain at scale."""@en . :faqWhyNotNAryRelations a schema:Question ; schema:position 6 ; schema:name """Why not model every relationship as an n-ary event?"""@en ; schema:acceptedAnswer :faqWhyNotNAryRelationsAnswer . :faqWhyNotNAryRelationsAnswer a schema:Answer ; schema:text """N-ary relations work well when the relationship genuinely is a multi-participant event, but they remove the direct triple: every query has to traverse an intermediate resource even for the simple case of 'who works where'."""@en . :faqWhyNotSingletonProperties a schema:Question ; schema:position 7 ; schema:name """Why not use singleton properties?"""@en ; schema:acceptedAnswer :faqWhyNotSingletonPropertiesAnswer . :faqWhyNotSingletonPropertiesAnswer a schema:Answer ; schema:text """Singleton properties preserve a direct subject-predicate-object triple, but minting a unique predicate per occurrence (e.g. :worksFor_123) does not scale: large datasets can generate millions of one-off predicates that complicate querying, indexing, and reasoning."""@en . :faqMultipleReifiers a schema:Question ; schema:position 8 ; schema:name """Can more than one reifier describe the same triple?"""@en ; schema:acceptedAnswer :faqMultipleReifiersAnswer . :faqMultipleReifiersAnswer a schema:Answer ; schema:text """Yes. RDF 1.2 explicitly separates the statement from the records describing it, so independent sources (e.g. an HR System and a Corporate Directory) can each attach their own reifier with its own provenance to the same underlying triple."""@en . :faqSparql12NewFunctions a schema:Question ; schema:position 9 ; schema:name """What new SPARQL 1.2 functions work with triple terms?"""@en ; schema:acceptedAnswer :faqSparql12NewFunctionsAnswer . :faqSparql12NewFunctionsAnswer a schema:Answer ; schema:text """SPARQL 1.2 adds TRIPLE() to construct a triple term from three bound terms, SUBJECT()/PREDICATE()/OBJECT() to decompose a bound triple term, and isTRIPLE() to test whether a value is a triple term — usable in SELECT projections, BIND, FILTER, CONSTRUCT, and VALUES."""@en . :faqInsertAnnotatedData a schema:Question ; schema:position 10 ; schema:name """How do I insert an annotated statement into a named graph in Virtuoso?"""@en ; schema:acceptedAnswer :faqInsertAnnotatedDataAnswer . :faqInsertAnnotatedDataAnswer a schema:Answer ; schema:text """Use SPARQL 1.2 INSERT DATA with either the annotation shorthand (triple followed by {| ... |}) or the explicit reifier form (a resource with rdf:reifies << ... >>) inside a GRAPH <...> block, as shown in the two SPARQL 1.2 INSERT DATA reference examples on this page — note that anonymous SPARQL UPDATE against a public endpoint like URIBurner always requires authentication (401), so these are documented as reference syntax rather than presented as live-runnable Workbench queries."""@en . :faqDoesVirtuosoSupportRdf12 a schema:Question ; schema:position 11 ; schema:name """Does Virtuoso support RDF 1.2?"""@en ; schema:acceptedAnswer :faqDoesVirtuosoSupportRdf12Answer . :faqDoesVirtuosoSupportRdf12Answer a schema:Answer ; schema:text """Yes. Virtuoso now provides support for RDF 1.2 capabilities — triple terms, reifiers, annotation syntax, and SPARQL 1.2 query support — so developers can build graph applications on the latest RDF and SPARQL standards."""@en . :faqWhatProblemsDoesRdf12Solve a schema:Question ; schema:position 12 ; schema:name """What real-world problems does RDF 1.2 statement annotation solve?"""@en ; schema:acceptedAnswer :faqWhatProblemsDoesRdf12SolveAnswer . :faqWhatProblemsDoesRdf12SolveAnswer a schema:Answer ; schema:text """It answers questions organizations routinely need to ask about their data: where a fact came from, when it was verified, who asserted it, how trustworthy it is, and what evidence supports it — without inventing a bespoke, non-portable annotation scheme."""@en . :glossary a schema:DefinedTermSet ; schema:name "RDF 1.2 Support in Virtuoso — Glossary"@en ; schema:isPartOf ; schema:hasDefinedTerm :glTripleTerm, :glReifier, :glAnnotationSyntax, :glStandardReification, :glNAryRelation, :glSingletonProperty, :glProvenance, :glNamedGraph, :glSparql12, :glConfidenceScore, :glVirtuoso, :glRdfStatement . :glTripleTerm a schema:DefinedTerm ; schema:name """Triple Term"""@en ; schema:description """An RDF triple used as a value, written << :s :p :o >>, that can be referenced as the object of rdf:reifies or as the subject/object of another statement."""@en ; schema:inDefinedTermSet :glossary . :glReifier a schema:DefinedTerm ; schema:name """Reifier"""@en ; schema:description """A resource linked to a triple term via rdf:reifies, used to attach source, date, and confidence metadata to a statement."""@en ; schema:inDefinedTermSet :glossary . :glAnnotationSyntax a schema:DefinedTerm ; schema:name """Annotation Syntax"""@en ; schema:description """RDF 1.2 Turtle shorthand ({| ... |}) that asserts a triple and creates its reifier in one statement."""@en ; schema:inDefinedTermSet :glossary . :glStandardReification a schema:DefinedTerm ; schema:name """Standard (RDF) Reification"""@en ; schema:description """The original RDF mechanism describing a statement via an rdf:Statement resource with rdf:subject, rdf:predicate, and rdf:object."""@en ; schema:inDefinedTermSet :glossary . :glNAryRelation a schema:DefinedTerm ; schema:name """N-Ary Relation"""@en ; schema:description """A modeling pattern that turns a relationship into a first-class resource carrying all its participants and metadata as properties."""@en ; schema:inDefinedTermSet :glossary . :glSingletonProperty a schema:DefinedTerm ; schema:name """Singleton Property"""@en ; schema:description """A uniquely minted predicate created for one specific occurrence of a relationship so metadata can attach to the predicate itself."""@en ; schema:inDefinedTermSet :glossary . :glProvenance a schema:DefinedTerm ; schema:name """Provenance"""@en ; schema:description """Information describing the origin of a piece of data: who asserted it, when, from what source, and how it was verified."""@en ; schema:inDefinedTermSet :glossary . :glNamedGraph a schema:DefinedTerm ; schema:name """Named Graph"""@en ; schema:description """A collection of RDF triples identified by an IRI (e.g. urn:graph:employees), used to partition datasets, applications, or tenants within a single quad store."""@en ; schema:inDefinedTermSet :glossary . :glSparql12 a schema:DefinedTerm ; schema:name """SPARQL"""@en ; schema:description """The query-language companion to RDF 1.2, adding syntax and functions (TRIPLE, SUBJECT, PREDICATE, OBJECT, isTRIPLE) for working with triple terms."""@en ; schema:inDefinedTermSet :glossary . :glConfidenceScore a schema:DefinedTerm ; schema:name """Confidence Score"""@en ; schema:description """A numeric value (e.g. 0.98) attached to a statement via its reifier, expressing how trustworthy the asserted fact is judged to be."""@en ; schema:inDefinedTermSet :glossary . :glVirtuoso a schema:DefinedTerm ; schema:name """Virtuoso"""@en ; schema:description """OpenLink Software's multi-model database/universal server, which now supports RDF 1.2 triple terms, reifiers, annotation syntax, and SPARQL 1.2 query features."""@en ; schema:inDefinedTermSet :glossary . :glRdfStatement a schema:DefinedTerm ; schema:name """rdf:Statement"""@en ; schema:description """The RDF 1.0/1.1 class used by standard reification to represent a statement as a resource with rdf:subject/rdf:predicate/rdf:object properties."""@en ; schema:inDefinedTermSet :glossary . :howTo a schema:HowTo ; schema:name "How to Model and Query Statement Metadata with RDF 1.2 in Virtuoso"@en ; schema:description "A step-by-step path from a plain RDF triple to a fully annotated, provenance-bearing, SPARQL-1.2-queryable statement in Virtuoso, following the pattern used throughout the source article."@en ; schema:isPartOf ; schema:step post:howToStep1, post:howToStep2, post:howToStep3, post:howToStep4, post:howToStep5, post:howToStep6, post:howToStep7 . post:howToStep1 a schema:HowToStep ; schema:position 1 ; schema:name """Identify the base relationship you need to annotate"""@en ; schema:text """Start with the plain, direct triple you want to keep queryable — for example :alice :worksFor :AcmeCorp . Do not fold it into an event node or a one-off predicate."""@en ; schema:isPartOf post:howTo . post:howToStep2 a schema:HowToStep ; schema:position 2 ; schema:name """Decide what metadata needs to be attached"""@en ; schema:text """List the provenance facts required: source system, verification date, confidence score, or other evidence — the same fields the article attaches via :source and :verifiedOn."""@en ; schema:isPartOf post:howTo . post:howToStep3 a schema:HowToStep ; schema:position 3 ; schema:name """Choose annotation syntax for a single quick assertion"""@en ; schema:text """For a one-shot, human-authored assertion, use the compact form: :alice :worksFor :AcmeCorp {| :source :HRSystem ; :verifiedOn \\"2025-01-15\\"^^xsd:date |} ."""@en ; schema:isPartOf post:howTo . post:howToStep4 a schema:HowToStep ; schema:position 4 ; schema:name """Choose an explicit reifier when the observation needs its own identifier"""@en ; schema:text """If the reifier itself will be referenced elsewhere in the domain model, mint a named resource with rdf:reifies << :alice :worksFor :AcmeCorp >> instead of relying on the auto-generated blank node."""@en ; schema:isPartOf post:howTo . post:howToStep5 a schema:HowToStep ; schema:position 5 ; schema:name """Attach multiple independent reifiers for multiple sources"""@en ; schema:text """When more than one system confirms the same fact, create one reifier per source (e.g. :hrRecord, :directoryRecord) rather than merging their metadata onto a single record."""@en ; schema:isPartOf post:howTo . post:howToStep6 a schema:HowToStep ; schema:position 6 ; schema:name """Insert annotated data into a named graph with SPARQL 1.2"""@en ; schema:text """Use INSERT DATA { GRAPH { ... } } with either the annotation shorthand or the explicit reifier form, as shown in the two SPARQL 1.2 INSERT DATA reference examples on this page — this requires an authenticated SPARQL UPDATE session, since anonymous INSERT against a public endpoint always fails with 401."""@en ; schema:isPartOf post:howTo . post:howToStep7 a schema:HowToStep ; schema:position 7 ; schema:name """Query triple terms with SPARQL 1.2 functions"""@en ; schema:text """Use TRIPLE() to build triple terms in a projection, SUBJECT()/PREDICATE()/OBJECT() to decompose a bound triple term in a FILTER, and isTRIPLE() to test whether a value is a triple term before further processing, as shown in the read-only SPARQL Workbench queries on this page."""@en ; schema:isPartOf post:howTo . ################################################################## # RDF-star / RDF 1.2 supplement — genuine rdf:reifies << >> and # {| |} annotation-syntax triples, appended for DAV upload only. # Not parseable by rdflib 7.6.0 (no RDF-star plugin), so this block # is excluded from the generator-input copy of this file and only # appears in the *-DEPLOY.ttl variant meant for direct DAV PUT. ################################################################## ex:employmentRecord1 rdf:reifies << ex:alice ex:worksFor ex:AcmeCorp >> . ex:hrRecord rdf:reifies << ex:alice ex:worksFor ex:AcmeCorp >> . ex:directoryRecord rdf:reifies << ex:alice ex:worksFor ex:AcmeCorp >> . ex:alice ex:worksFor ex:AcmeCorp {| ex:confidence 0.98 |} .