A color-coded version of this document showing changes made since the previous version is also available.
This document is also available in these non-normative formats: PDF version.
Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
The W3C Director seeks review and feedback from W3C Advisory Committee representatives, via their review form by 15 November 2012. This will allow the Director to assess consensus and determine whether to issue this document as a W3C Edited Recommendation.
Others are encouraged by the OWL Working Group and the Rule Interchange Format (RIF) Working Group to continue to send reports of implementation experience, and other feedback, to public-owl-comments@w3.org (public archive). Reports of any success or difficulty with the test cases are encouraged. Open discussion among developers is welcome at public-owl-dev@w3.org (public archive).
Publication as a Proposed Edited Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
The Resource Description Framework [RDF] is defined to have an extensible system of typed literals, based on XML Schema datatypes [XSD], and also to have plain literals. In the RDF specification, plain literals differ from typed literals in that plain literals have no datatype and can optionally have a language tag, indicating the natural language of the content. (See Tags for Identifying Languages [BCP 47]). These options for expressing RDF literals complicate specifications which interact with RDF, such as RIF and OWL. Furthermore, RDF does not provide a name for the set of all plain literals, which, for example, prevents one from stating in RDFS or OWL that the range of some property must be a plain literal.
In response, this specification introduces a datatype called rdf:PlainLiteral. The datatype is in the "rdf:" namespace because it refers to parts of the conceptual model of RDF. This extension, however, does not change that conceptual model, and thus does not affect specifications that depend on it, such as SPARQL [SPARQL]. The value space of rdf:PlainLiteral consists of all data values represented by RDF plain literals, which allows RDF applications to explicitly refer to this set (e.g., in rdfs:range assertions).
Because RDF plain literals are already a part of RDF and SPARQL syntaxes, rdf:PlainLiteral literals are written as RDF plain literals in RDF and SPARQL syntaxes.
As with plain literals, this datatype can associate language tags with Unicode strings, but it does not provide its own facilities for representing natural language utterances. Unicode bidirectional control characters [BIDI] may be used within these literals, like all other Unicode characters. (Richer, XML-based representations such as XHTML [XHTML] and Ruby annotations [RUBY] can be expressed using the rdf:XMLLiteral datatype.)
A character is an atomic unit of text. Each character has a Universal Character Set (UCS) code point [ISO/IEC 10646] (or, equivalently, a Unicode code point [UNICODE]) that MUST match the Char production from XML [XML] thus ensuring compatibility with XML Schema Datatypes [XML Schema Datatypes]. Code points are sometimes represented in this document as U+ followed by a four-digit hexadecimal value of the code point.
A string is a finite sequence of zero or more characters. The length of a string is the number of characters in it. Strings are written in this specification by enclosing them in double quotes. Two strings are identical if and only if they contain exactly the same characters in exactly the same sequence.
UCS [ISO/IEC 10646] and Unicode [UNICODE] provide for 1,114,112 different code points. The Char production from XML [XML], however, excludes the surrogate code points and the code points U+FFFE and U+FFFF. Thus, rdf:PlainLiteral provides a total of 1,112,033 different characters. This number is important, as it can affect the satisfiability of an OWL 2 ontology. Consider the following example:
ClassAssertion( MinCardinality( n a:property DatatypeRestriction( xs:string xs:length 1 ) ) a:i ) |
This OWL 2 axiom states that the individual a:i is connected by the property a:property to at least n different strings of length one. The number of such strings is limited to 1,112,033 by the above definitions, so this ontology is satisfiable if and only if n is smaller than or equal to 1,112,033.
A language tag is a string matching the langtag production from BCP 47 [BCP 47]. Furthermore, note that this definition corresponds to the well-formed rather than the valid class of conformance in BCP 47. A language tag MAY contain subtags that are not registered in the IANA Language Subtag Registry, although an rdf:PlainLiteral implementation MAY also choose to reject such invalid language tags.
The language tag "en-fubar" is not registered with the IANA Language Subtag Registry, so an rdf:PlainLiteral implementation is allowed to reject it. This string, however, matches the langtag production from BCP 47, so it is a perfectly valid language tag for the purpose of this specification. Consequently, the value space of rdf:PlainLiteral (see Section 3 for its definition) contains, say, the pair < "some string" , "en-fubar" >.
This specification uses Uniform Resource Identifiers (URIs), which are defined in RFC 3986 [RFC 3986], for naming datatypes and their components. For readability, URIs prefixes are often abbreviated using a short prefix name according to the convention of RDF [RDF]. The following prefix names are used throughout this document:
The names of the built-in functions defined in Section 5 are QNames, as defined in the XML namespaces specification [XML Namespaces]. The following namespace abbreviations are used in Section 5:
Whether an expression of the form pr:ln denotes an abbreviated URI or a QName should be clear from the context: only the names of the built-in functions in Section 5 are QNames; all other such expressions denote abbreviated URIs.
Datatypes are defined in this document along the lines of XML Schema Datatypes [XML Schema Datatypes]. Each datatype is identified by a URI and is described by the following components:
A plain literal is a string with an optional language tag [RDF]. A plain literal without a language tag is interpreted in an RDF interpretation [RDF Semantics] by itself. A plain literal with a language tag can be written as "abc"@langTag, and is interpreted in an RDF interpretation as a pair < "abc" , "langTag" >.
A typed literal consists of a string and a datatype URI [RDF] and can be written as "abc"^^datatypeURI. Given an RDF datatype identified by datatypeURI, an RDF datatyped-interpretation that includes the datatype interprets the typed literal as the data value that the datatype assigns to the lexical form "abc".
The italicized keywords MUST, MUST NOT, SHOULD, SHOULD NOT, and MAY specify certain aspects of the normative behavior of tools implementing this specification, and are interpreted as specified in RFC 2119 [RFC 2119].
The datatype identified by the URI http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral (abbreviated rdf:PlainLiteral) is defined as follows.
Value Space. The value space of rdf:PlainLiteral consists of
Lexical Space. An rdf:PlainLiteral lexical form is a string of the form "abc@langTag" where "abc" is an arbitrary (possibly empty) string, and "langTag" is either the empty string or a (not necessarily lowercase) language tag. Each such lexical form is mapped to a data value dv as follows:
The following table shows several rdf:PlainLiteral lexical forms and their corresponding data values.
Lexical form | Corresponding data value |
---|---|
"Family Guy@en" | < "Family Guy" , "en" > |
"Family Guy@EN" | < "Family Guy" , "en" > |
"Family Guy@FOX@en" | < "Family Guy@FOX" , "en" > |
"Family Guy@" | "Family Guy" |
"Family Guy@FOX@" | "Family Guy@FOX" |
The following table shows several of strings that are not rdf:PlainLiteral lexical forms.
String | The reason for not being an rdf:PlainLiteral lexical form |
---|---|
"Family Guy" | does not contain at least one @ (U+0040) character |
"Family Guy@12" | "12" is not a language tag according to BCP 47 |
Facet Space. The facet space of rdf:PlainLiteral is defined as shown in Table 1.
A facet pair ( F v ) is in the facet space of rdf:PlainLiteral if... | Each such facet pair is mapped to the subset of the value space of rdf:PlainLiteral containing... |
---|---|
...F is xs:length, xs:minLength, xs:maxLength, xs:pattern, xs:enumeration, or xs:assertion and ( F v ) is in the facet space of xs:string. | ...all strings of the form "abc" and all pairs of the form < "abc" , "lc-langtag" > such that "abc" is contained in the subset of the value space of xs:string determined by ( F v ) as specified by XML Schema Datatypes [XML Schema Datatypes]. |
...F is rdf:langRange and v is an extended language range as specified in Section 2.2 of [RFC4647]. | ...all pairs of the form < "abc" , "lc-langtag" > such that "lc-langtag" matches v under extended filtering as specified in Section 3.3.2 of [RFC4647]. |
The facet xs:length can be used to refer to a subset of strings of a particular length regardless of whether they have a language tag or not. Thus, the subset of the value space of rdf:PlainLiteral corresponding to the facet pair ( xs:length 3 ) contains the string "abc", as well as the pairs < "abc" , "en" > and < "abc" , "de" >.
The facet rdf:langRange can be used to refer to a subset of strings containing the language tag. Note that the language range need not be in lowercase, and that the matching algorithm is case-insensitive. Thus, the subset of the value space of rdf:PlainLiteral corresponding to the facet pair ( rdf:langRange "de-DE" ) contains the pairs < "abc" , "de-de" > and < "abc" , "de-de-1996" > (because these match the language range "de-DE" according to RFC 4647), but not the string "abc" (because it is not a pair with a language tag) or the pairs < "abc" , "de-deva" > and < "abc" , "de-latn-de" > (because these do not match the language range "de-DE" according to RFC 4647).
The facet pair ( rdf:langRange "*" ) is mapped to the subset of the value space of rdf:PlainLiteral containing all pairs of the form < "abc" , "lc-langtag" >. In languages such as OWL 2, this can be used to specify that a data value must contain a language tag.
It follows from the above that in datatyped interpretations that include the rdf:PlainLiteral datatype, the value space of rdf:PlainLiteral contains exactly all data values assigned to plain literals (with or without a language tag). The rdf:PlainLiteral datatype thus provides an explicit way of referring to this set.
To eliminate another source of syntactic redundancy and to retain a large degree of interoperability with applications that do not understand the rdf:PlainLiteral datatype, the form of rdf:PlainLiteral literals in syntaxes for RDF graphs and for SPARQL is the already existing syntax for the corresponding plain literal, not the syntax for a typed literal. Therefore, typed literals with rdf:PlainLiteral as the datatype are considered by this specification to be not valid in syntaxes for RDF graphs or SPARQL.
To implement this design and provide this interoperability, applications that employ this datatype MUST use plain literals (instead of rdf:PlainLiteral typed literals) whenever a syntax for plain literals is provided, such as in existing syntaxes for RDF graphs and SPARQL results.
Additionally, systems may need similar restrictions for non-syntactic public interfaces. For instance, in extended SPARQL basic graph matching, the results of matching SPARQL basic graph patterns in an entailment regime that understands rdf:PlainLiteral MUST provide variable bindings in existing RDF plain literal form.
This section defines functions that construct and operate on rdf:PlainLiteral data values. The terminology used and the way in which these functions are described are in accordance with the XQuery 1.0 and XPath 2.0 Functions and Operators [XPathFunc]. Each function is identified by a QName [XML Namespaces]. The error codes used in this section are given in Appendix G of the XPath 2.0 specification [XPath20] and Appendix C of XQuery and XPath function specification [XPathFunc].
plfn:PlainLiteral-from-string-lang( $arg1 as xs:string, $arg2 as xs:string) as rdf:PlainLiteral
Summary: returns the data value < $arg1, lowercase($arg2) > if $arg2 is present, and returns the data value $arg1 otherwise. Both arguments must be of type xs:string or one of its subtypes, and $arg2 — if present — must be a (nonempty) language tag; otherwise, this function raises type error err:FORG0006. Note that, since in the value space of rdf:PlainLiteral language tags are in lowercase, this function converts $arg2 to lowercase.
plfn:string-from-PlainLiteral( $arg as rdf:PlainLiteral) as xs:string
Summary: returns the string part s if $arg is a rdf:PlainLiteral data value of the form < s, l > or of the form s. If $arg is not of type rdf:PlainLiteral, this function raises type error err:FORG0006.
plfn:lang-from-PlainLiteral( $arg as rdf:PlainLiteral ) as xs:language
Summary: returns the language tag l if $arg is an rdf:PlainLiteral data value of the form < s, l >, and returns the empty string if $arg is an rdf:PlainLiteral data value of the form s. If $arg is not of type rdf:PlainLiteral, this function raises type error err:FORG0006.
The notion of collations used in this section is taken from Section 7.3.1 of XPath and XQuery function specification [XPathFunc].
plfn:compare( $comparand1 as rdf:PlainLiteral?, $comparand2 as rdf:PlainLiteral? ) as xs:integer?
plfn:compare( $comparand1 as rdf:PlainLiteral?, $comparand2 as rdf:PlainLiteral?, $collation as xs:string ) as xs:integer?
Summary: if either $comparand1 or $comparand2 is not of type rdf:PlainLiteral, of if $collation is specified but is not of type xs:string, this function raises type error err:FORG0006. Otherwise, the function returns the empty sequence if one of the arguments is empty, if one of $comparand1 and $comparand2 has a language tag and the other one does not, or if the language parts of $comparand1 and $comparand2 are unequal; otherwise, this function returns -1, 0, or 1 depending on whether the value of the string-part of $comparand1 (or $comparand1 itself if it has no language tag) is respectively less than, equal to, or greater than the value of the string-part of $comparand2 (or $comparand2 itself if it has no language tag). The collation used by the invocation of this function is determined according to the rules in Section 7.3.1 of the XPath and XQuery functions specification [XPathFunc].
The first version of this function enables the comparison of rdf:PlainLiteral values using the XQuery operators "eq", "ne", "gt", "lt", "le", and "ge".
The two functions may be viewed as declared XQuery functions with the following definitions:
declare function plfn:compare( $comparand1 as rdf:PlainLiteral?, $comparand2 as rdf:PlainLiteral? ) as xs:integer? { return if ( fn:empty($comparand1) ) then $comparand1 else if ( fn:empty($comparand2) ) then $comparand2 else if ( fn:compare ( plfn:lang-from-PlainLiteral( $comparand1 ), plfn:lang-from-PlainLiteral( $comparand2 ) ) = 0 ) then fn:compare ( plfn:string-from-PlainLiteral( $comparand1 ), plfn:string-from-PlainLiteral( $comparand2 ) ) }
declare function plfn:compare( $comparand1 as rdf:PlainLiteral?, $comparand2 as rdf:PlainLiteral? $collation as xs:string ) as xs:integer? { return if ( fn:empty($comparand1) ) then $comparand1 else if ( fn:empty($comparand2) ) then $comparand2 else if ( fn:compare ( plfn:lang-from-PlainLiteral( $comparand1 ), plfn:lang-from-PlainLiteral( $comparand2 ) ) = 0 ) then fn:compare ( plfn:string-from-PlainLiteral( $comparand1 ) , plfn:string-from-PlainLiteral( $comparand2 ), $collation) }
plfn:length($arg as rdf:PlainLiteral) as xs:integer
Summary: returns the number of characters in the string part s if $arg is an rdf:PlainLiteral data value of the form < s, l > or a string value s, respectively. If $arg is not of type rdf:PlainLiteral, this function raises type error err:FORG0006.
This function may be viewed as a declared XQuery function with the following definition:
declare function plfn:length($arg as rdf:PlainLiteral?) as xs:integer { return fn:string-length ( plfn:string-from-PlainLiteral( $arg ) ) }
plfn:matches-language-range($arg as rdf:PlainLiteral?, $range as xs:string) as xs:boolean
Summary: This function is only defined if $arg is a sequence of length 0 or 1 of literals of type rdf:PlainLiteral and $range is of type xs:string; if the parameters do not satisfy these typing conditions, the function raises a type error err:FORG0006. If the typing conditions are fulfilled, the function returns true in case $arg is an rdf:PlainLiteral data value of the form < s, l > with l a language tag that matches the extended language range $range as specified by the extended filtering algorithm for "Matching of Language Tags" [BCP-47]; otherwise, it returns false. This means that the function returns false if the argument $arg is a string rdf:PlainLiteral data value. An empty input sequence is treated as a rdf:PlainLiteral data value consisting of the empty string, and accordingly on such input this function also returns false.
The RIF and OWL Working Groups made parallel efforts to support strings with associated language tags, as found in RDF. This specification is the outcome of a collaboration between the two groups, and it is based on the work on the datatypes rif:text and owl:internationalizedString.
In addition to members and chairs of both Working Groups, the editors would like to thank Addison Phillips, C. Michael Sperberg-McQueen, Eric Prud'hommeaux, Andy Seaborne, and Pat Hayes, along with other participants of the public-rdf-text mailing list, for their assistance in working out the details of this specification.
This section summarizes the changes to this document since the Recommendation of 27 October, 2009.
This section summarizes the changes to this document since the Proposed Recommendation of 22 September, 2009.
This section summarizes the changes to this document since the Candidate Recommendation of 11 June, 2009.
Since the last call draft of 21 April 2009, the following changes have been made: