W3C

SPARQL 1.1 Update

W3C Working Draft 22 October 2009

This version:
http://www.w3.org/TR/2009/WD-sparql11-update-20091022/
Latest version:
http://www.w3.org/TR/sparql11-update/
Editors:
Simon Schenk <sschenk@uni-koblenz.de>
Paul Gearon <gearon@computer.org>

Abstract

This document describes SPARQL-Update, an update language for RDF graphs. It uses a syntax derived from SPARQL. Update operations are performed on a collection of graphs in a Graph Store. Operations are provided to change existing RDF graphs as well as create and remove graphs in the Graph Store.

Status of this document

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/.

This is the First Public Working Draft of the "SPARQL 1.1 Update" specification for review by W3C members and other interested parties.

If you wish to make comments regarding this document, please send them to public-rdf-dawg-comments@w3.org (subscribe, archives)

Implementors should be aware that this specification is not stable. Implementors who are not taking part in the discussions are likely to find the specification changing out from under them in incompatible ways. Vendors interested in implementing this specification before it eventually reaches the Candidate Recommendation stage should join the aforementioned mailing lists and take part in the discussions.

Publication as a Working Draft 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.

The publication of this document by the W3C as a W3C Working Draft does not imply that all of the participants in the W3C SPARQL working group endorse the contents of the specification. Indeed, for any section of the specification, one can usually find many members of the working group or of the W3C as a whole who object strongly to the current text, the existence of the section at all, or the idea that the working group should even spend time discussing the concept of that section.

The W3C SPARQL Working Group is the W3C working group responsible for this specification's progress along the W3C Recommendation track.

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.

Table of Contents

1 Introduction
    1.1 Scope and Limitations
    1.2 Document Conventions
2 Relation to new features in SPARQL 1.1
    2.1 SubQueries
    2.2 BGP extensions of different entailment regimes
    2.3 Basic Federated Query
    2.4 Property Paths
3 Examples
4 The Graph Store
    4.1 Graph Store and SPARQL Query Services
    4.2 SPARQL-Update Services
5 Syntax
    5.1 Graph Update
        5.1.1 INSERT DATA
        5.1.2 DELETE DATA
        5.1.3 MODIFY
        5.1.4 DELETE
        5.1.5 INSERT
        5.1.6 LOAD
        5.1.7 CLEAR
    5.2 Graph Management
        5.2.1 Graph Creation
        5.2.2 Graph Removal
6 SPARQL-Update Definition

Appendices

A Security Considerations
B SPARQL-Update Grammar
C References
    C.1 Normative References
    C.2 Other References
D CVS History
    D.1


1 Introduction

SPARQL-Update is a language to express updates to an RDF store. It is intended to be a standard mechanism by which updates to a remote RDF Store can be described, communicated and stored. SPARQL-Update is a companion language to SPARQL and is envisaged to be used in conjunction with the SPARQL query language. The reuse of the SPARQL syntax, in both style and detail, reduces the learning curve for developers and reduces implementation costs.

SPARQL-Update provides the following facilities:

Related work:

1.1 Scope and Limitations

SPARQL-Update is not:

  • a replacement for RSS or Atom, which may be used to advertise changes.
  • a mechanism to exchange changes to RDF graphs between applications.
  • a general web-wide approach to update and distribution of RDF-based information.

2 Relation to new features in SPARQL 1.1

Issues related to SPARQL 1.0 - Query or features proposed in this document are listed inline with the corresponding features. Issues related to potential new features in SPARQL 1.1 - Query are listed in this section.

3 Examples

This section gives some example snippets in the Update language.

(a) Adding some triples to a graph. The snippet describes two RDF triples to be inserted into the default graph of the RDF store.

PREFIX dc: <http://purl.org/dc/elements/1.1/>
INSERT DATA
{ <http://example/book3> dc:title    "A new book" ;
                         dc:creator  "A.N.Other" .
}

(b) This SPARQL-Update request contains a triple to be deleted and a triple to be added (used here to correct a book title). The requested change happens in the named graph identified by the URI http://example/bookStore.

PREFIX dc: <http://purl.org/dc/elements/1.1/>

DELETE DATA FROM <http://example/bookStore>
{ <http://example/book3>  dc:title  "Fundamentals of Compiler Desing" }

INSERT DATA INTO <http://example/bookStore>
{ <http://example/book3>  dc:title  "Fundamentals of Compiler Design" }

(c) The example below has a request to delete all records of old books (with date before year 2000)

PREFIX dc:  <http://purl.org/dc/elements/1.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

DELETE
 { ?book ?p ?v }
WHERE
  { ?book dc:date ?date .
    FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
    ?book ?p ?v
  }

The pattern in WHERE is matched against the graph store analogously to SPARQL - Query. The resulting variable bindings are used to instantiate the triple patterns in the DELETE template analogously to CONSTRUCT. The resulting triples are then removed from the graph store. If the pattern matching fails, no changes are done.

(d) This snippet copies records from one named graph to another named graph based on a pattern

PREFIX dc:  <http://purl.org/dc/elements/1.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

INSERT INTO <http://example/bookStore2>
 { ?book ?p ?v }
WHERE
  { GRAPH  <http://example/bookStore>
       { ?book dc:date ?date .
         FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
         ?book ?p ?v
  } }	

(e) An example to move records from one named graph to another named graph based on a pattern

PREFIX dc:  <http://purl.org/dc/elements/1.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

INSERT INTO <http://example/bookStore2>
 { ?book ?p ?v }
WHERE
  { GRAPH  <http://example/bookStore>
     { ?book dc:date ?date . 
       FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
       ?book ?p ?v
     }
  }

DELETE FROM <http://example/bookStore>
 { ?book ?p ?v }
WHERE
  { GRAPH  <http://example/bookStore>
      { ?book dc:date ?date . 
        FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime ) 
        ?book ?p ?v
      } 
  }   	

(f) An example to update people with the name "Bill" to "William".

PREFIX foaf:  <http://xmlns.com/foaf/0.1/>

MODIFY <http://example/addresses>
DELETE { ?person foaf:firstName 'Bill' }
INSERT { ?person foaf:firstName 'William' }
WHERE
  { ?person a foaf:Person .
    ?person foaf:firstName 'Bill'
  } 

4 The Graph Store

A Graph Store is a repository of RDF graphs managed by a single service. Like an RDF Dataset operated on by SPARQL, a Graph Store contains one unnamed graph and zero or more named graphs. Unlike an RDF dataset, named graphs can be added to or deleted from a graph store. A Graph Store need not be authoritative for the graphs it contains.

In the simple case, where there is one default graph and no named graphs, SPARQL-Update is a language for the update of a single graph.

Note:

Depending on the outcome of ISSUE-20, the number of unnamed graphs might be fixed to one or be zero or one.

5 Syntax

SPARQL-Update supports two categories of update operations on a Graph Store:

Multiple operations can be packed into requests. The operations of a request are executed in lexical order.

5.1 Graph Update

Graph update operations change existing graphs in the Graph Store but do not create or delete them.

The INSERT DATA operation adds some triples, which are inline in the request, into a graph.

The DELETE DATA operation removes some triples, which are inline in the request, from a graph

The fundamental pattern-based operation of a graph update is MODIFY. There are two restricted forms for INSERT and DELETE of triples by pattern; both are special cases of the MODIFY operation. A modify operation consists of a group of triples to be deleted and a group of triples to be added. The specification of the triples is based on a query pattern.

The difference between MODIFY / INSERT / DELETE and INSERT DATA / DELETE DATA is that INSERT DATA and DELETE DATA do not take a template and pattern. The DATA forms require concrete data (no named variables).  Having specific operations means that a request can be streamed so that large, pure-data, updates can be done.

The LOAD operation reads the contents of a document representing a graph into a graph in the graph store.

The CLEAR operation removes all the triples in a graph.

5.1.3 MODIFY

# UPDATE outline syntax : general form:
MODIFY [ <uri> ]*
DELETE { template }
INSERT { template }
[ WHERE { pattern } ]

The template and pattern forms are as defined in SPARQL for construct templates and graph patterns.

The deletion of the triples happens before the insertion. The pattern in WHERE clause is evaluated only once, before the delete part of the operation is performed. The overall processing model is that the pattern is executed, the results used to instantiate the DELETE template, the deletes performed, the results used again to instantiate the INSERT template, and the inserts performed.

The pattern is evaluated as in a SPARQL query SELECT * WHERE { pattern } and all the named variables are made available to the INSERT template and the DELETE template for defining the triples to be inserted or deleted.

The <uri> clause names the graph in the graph store to be updated; if omitted, the MODIFY applies to the unnamed graph.

If the operation is on a graph that does not exist, an error is generated. Graphs are not created by the graph update operations. The graph management operations have to be used to create new graphs.

6 SPARQL-Update Definition

Graph matching in SPARQL-Update is taken over from SPARQL/Query. Analogous to CONSTRUCT queries in SPARQL/Query, the result of graph pattern matching is converted into triples for the actual update operation.

Note:

We need to define an algebra operator for conversion of bindings to triples. The operator depends on syntax decision for INSERT based on CONSTRUCT or GroupGraphPattern.

A Security Considerations

Exposing RDF data for update creates many security issues which any deployment must be aware of, and consider the risks involved. This submission does not describe such issues.

In addition to exposing update services over web technologies, implementers of both systems using SPARQL-Update and servers providing a graph store, must be aware that a string-based language is susceptible to insertion attacks in the construction of SPARQL-Update requests.

B SPARQL-Update Grammar

Rules from rule 16, Prologue, are taken from the SPARQL grammar.

Note: This grammar does not use special rules for parsing INSERT DATA/DELETE DATA where only triples, not triple patterns (allowing named variables) are allowed. It assumes the update processor will check template contains only ground triples.

 

[1]   Prologue   ::=   (BaseDecl)? (PrefixDecl)*
[2]   BaseDecl   ::=   "BASE" IRI_REF
[3]   PrefixDecl   ::=   "PREFIX" PNAME_NS IRI_REF
[4]   UpdateUnit   ::=   Prologue (( Update | Manage ))*
[5]   Update   ::=   Modify
| Insert
| Delete
| Load
| Clear
[6]   Modify   ::=   "MODIFY" (GraphIRI)* "DELETE" ConstructTemplate "INSERT" ConstructTemplate (UpdatePattern)?
[7]   Delete   ::=   "DELETE" ( DeleteData | DeleteTemplate )
[8]   DeleteData   ::=   "DATA" (( ("FROM")? IRIref ))* ConstructTemplate
[9]   DeleteTemplate   ::=   (( ("FROM")? IRIref ))* ConstructTemplate (UpdatePattern)?
[10]   Insert   ::=   "INSERT" ( InsertData | InsertTemplate )
[11]   InsertData   ::=   "DATA" (( ("INTO")? IRIref ))* ConstructTemplate
[12]   InsertTemplate   ::=   (( ("INTO")? IRIref ))* ConstructTemplate (UpdatePattern)?
[13]   GraphIRI   ::=   "GRAPH" IRIref
[14]   Load   ::=   "LOAD" (IRIref)+ (( "INTO" IRIref ))?
[15]   Clear   ::=   "CLEAR" (GraphIRI)?
[16]   Manage   ::=   Create
| Drop
[17]   Create   ::=   "CREATE" ("SILENT")? GraphIRI
[18]   Drop   ::=   "DROP" ("SILENT")? GraphIRI
[19]   UpdatePattern   ::=   ("WHERE")? GroupGraphPattern
[20]   GroupGraphPattern   ::=   "{" ( SubSelect | GroupGraphPatternSub ) "}"
[21]   GroupGraphPatternSub   ::=   (TriplesBlock)? (( ( GraphPatternNotTriples | Filter ) (".")? (TriplesBlock)? ))*
[22]   TriplesBlock   ::=   TriplesSameSubjectPath (( "." (TriplesBlock)? ))?
[23]   GraphPatternNotTriples   ::=   OptionalGraphPattern
| GroupOrUnionGraphPattern
| GraphGraphPattern
| ExistsElt
| NotExistsElt
[24]   OptionalGraphPattern   ::=   "OPTIONAL" GroupGraphPattern
[25]   GraphGraphPattern   ::=   "GRAPH" VarOrIRIref GroupGraphPattern
[26]   ExistsElt   ::=   "EXISTS" GroupGraphPattern
[27]   NotExistsElt   ::=   ( "UNSAID" | "NOT EXISTS" ) GroupGraphPattern
[28]   GroupOrUnionGraphPattern   ::=   GroupGraphPattern (( "UNION" GroupGraphPattern ))*
[29]   Filter   ::=   "FILTER" Constraint
[30]   Constraint   ::=   BrackettedExpression
| BuiltInCall
| FunctionCall
[31]   FunctionCall   ::=   IRIref ArgList
[32]   ArgList   ::=   ( NIL | "(" Expression (( "," Expression ))* ")" )
[33]   TriplesSameSubject   ::=   VarOrTerm PropertyListNotEmpty
| TriplesNode PropertyList
[34]   PropertyListNotEmpty   ::=   Verb ObjectList (( ";" (( Verb ObjectList ))? ))*
[35]   PropertyList   ::=   (PropertyListNotEmpty)?
[36]   ObjectList   ::=   Object (( "," Object ))*
[37]   Object   ::=   GraphNode
[38]   Verb   ::=   VarOrIRIref
| "a"
[39]   TriplesSameSubjectPath   ::=   VarOrTerm PropertyListNotEmptyPath
| TriplesNode PropertyListPath
[40]   PropertyListNotEmptyPath   ::=   ( VerbPath | VerbSimple ) ObjectList (( ";" (( ( VerbPath | VerbSimple ) ObjectList ))? ))*
[41]   PropertyListPath   ::=   (PropertyListNotEmpty)?
[42]   VerbPath   ::=   Path
[43]   VerbSimple   ::=   Var
[44]   PathUnit   ::=   Path
[45]   Path   ::=   PathAlternative
[46]   PathAlternative   ::=   PathSequence (( "|" PathSequence ))*
[47]   PathSequence   ::=   PathEltOrReverse (( "/" PathEltOrReverse | "^" PathElt ))*
[48]   PathElt   ::=   PathPrimary (PathMod)?
[49]   PathEltOrReverse   ::=   PathElt
| "^" PathElt
[50]   PathMod   ::=   ( "*" | "?" | "+" | "{" ( Integer ( "," ( "}" | Integer "}" ) | "}" ) ) )
[51]   PathPrimary   ::=   ( IRIref | "a" | "(" Path ")" )
[52]   Integer   ::=   INTEGER
[53]   TriplesNode   ::=   Collection
| BlankNodePropertyList
[54]   BlankNodePropertyList   ::=   "[" PropertyListNotEmpty "]"
[55]   Collection   ::=   "(" (GraphNode)+ ")"
[56]   GraphNode   ::=   VarOrTerm
| TriplesNode
[57]   VarOrTerm   ::=   Var
| GraphTerm
[58]   VarOrIRIref   ::=   Var
| IRIref
[59]   Var   ::=   VAR1
| VAR2
[60]   GraphTerm   ::=   IRIref
| RDFLiteral
| NumericLiteral
| BooleanLiteral
| BlankNode
| NIL
[61]   Expression   ::=   ConditionalOrExpression
[62]   ConditionalOrExpression   ::=   ConditionalAndExpression (( "||" ConditionalAndExpression ))*
[63]   ConditionalAndExpression   ::=   ValueLogical (( "&&" ValueLogical ))*
[64]   ValueLogical   ::=   RelationalExpression
[65]   RelationalExpression   ::=   NumericExpression (( "=" NumericExpression | "!=" NumericExpression | "<" NumericExpression | ">" NumericExpression | "<=" NumericExpression | ">=" NumericExpression ))?
[66]   NumericExpression   ::=   AdditiveExpression
[67]   AdditiveExpression   ::=   MultiplicativeExpression (( "+" MultiplicativeExpression | "-" MultiplicativeExpression | ( NumericLiteralPositive | NumericLiteralNegative ) (( ( "*" UnaryExpression ) | ( "/" UnaryExpression ) ))? ))*
[68]   MultiplicativeExpression   ::=   UnaryExpression (( "*" UnaryExpression | "/" UnaryExpression ))*
[69]   UnaryExpression   ::=   "!" PrimaryExpression
| "+" PrimaryExpression
| "-" PrimaryExpression
| PrimaryExpression
[70]   PrimaryExpression   ::=   BrackettedExpression
| BuiltInCall
| IRIrefOrFunction
| RDFLiteral
| NumericLiteral
| BooleanLiteral
| Var
| Aggregate
[71]   BrackettedExpression   ::=   "(" Expression ")"
[72]   BuiltInCall   ::=   "STR" "(" Expression ")"
| "LANG" "(" Expression ")"
| "LANGMATCHES" "(" Expression "," Expression ")"
| "DATATYPE" "(" Expression ")"
| "BOUND" "(" Var ")"
| "COALESCE" ArgList
| "IF" "(" Expression "," Expression "," Expression ")"
| "sameTerm" "(" Expression "," Expression ")"
| "isIRI" "(" Expression ")"
| "isURI" "(" Expression ")"
| "isBLANK" "(" Expression ")"
| "isLITERAL" "(" Expression ")"
| RegexExpression
| ExistsFunc
| NotExistsFunc
[73]   RegexExpression   ::=   "REGEX" "(" Expression "," Expression (( "," Expression ))? ")"
[74]   ExistsFunc   ::=   "EXISTS" GroupGraphPattern
[75]   NotExistsFunc   ::=   ( "UNSAID" | "NOT EXISTS" ) GroupGraphPattern
[76]   Aggregate   ::=   ( "COUNT" "(" ( "*" | Var | "DISTINCT" ( "*" | Var ) ) ")" | "SUM" "(" Expression ")" | "MIN" "(" Expression ")" | "MAX" "(" Expression ")" | "AVG" "(" Expression ")" )
[77]   IRIrefOrFunction   ::=   IRIref (ArgList)?
[78]   RDFLiteral   ::=   String (( LANGTAG | ( "^^" IRIref ) ))?
[79]   NumericLiteral   ::=   NumericLiteralUnsigned
| NumericLiteralPositive
| NumericLiteralNegative
[80]   NumericLiteralUnsigned   ::=   INTEGER
| DECIMAL
| DOUBLE
[81]   NumericLiteralPositive   ::=   INTEGER_POSITIVE
| DECIMAL_POSITIVE
| DOUBLE_POSITIVE
[82]   NumericLiteralNegative   ::=   INTEGER_NEGATIVE
| DECIMAL_NEGATIVE
| DOUBLE_NEGATIVE
[83]   BooleanLiteral   ::=   "true"
| "false"
[84]   String   ::=   STRING_LITERAL1
| STRING_LITERAL2
| STRING_LITERAL_LONG1
| STRING_LITERAL_LONG2
[85]   IRIref   ::=   IRI_REF
| PrefixedName
[86]   PrefixedName   ::=   PNAME_LN
| PNAME_NS
[87]   BlankNode   ::=   BLANK_NODE_LABEL
| ANON
[88]   <IRI_REF>   ::=   "<" (( [^<>\"{}|^`\\] - [#0000- ] ))* ">"
[89]   <PNAME_NS>   ::=   (PN_PREFIX)? ":"
[90]   <PNAME_LN>   ::=   PNAME_NS PN_LOCAL
[91]   <BLANK_NODE_LABEL>   ::=   "_:" PN_LOCAL
[92]   <VAR1>   ::=   "?" VARNAME
[93]   <VAR2>   ::=   "$" VARNAME
[94]   <LANGTAG>   ::=   "@" ([a-zA-Z])+ (( "-" ([a-zA-Z0-9])+ ))*
[95]   <INTEGER>   ::=   ([0-9])+
[96]   <DECIMAL>   ::=   ([0-9])+ "." ([0-9])*
| "." ([0-9])+
[97]   <DOUBLE>   ::=   ([0-9])+ "." ([0-9])* EXPONENT
| "." (( [0-9] ))+ EXPONENT
| (( [0-9] ))+ EXPONENT
[98]   <INTEGER_POSITIVE>   ::=   "+" INTEGER
[99]   <DECIMAL_POSITIVE>   ::=   "+" DECIMAL
[100]   <DOUBLE_POSITIVE>   ::=   "+" DOUBLE
[101]   <INTEGER_NEGATIVE>   ::=   "-" INTEGER
[102]   <DECIMAL_NEGATIVE>   ::=   "-" DECIMAL
[103]   <DOUBLE_NEGATIVE>   ::=   "-" DOUBLE
[104]   <EXPONENT>   ::=   [eE] ([+-])? ([0-9])+
[105]   <STRING_LITERAL1>   ::=   "'" (( ( [^'\\\n\r] ) | ECHAR ))* "'"
[106]   <STRING_LITERAL2>   ::=   '"' (( ( [^\"\\\n\r] ) | ECHAR ))* '"'
[107]   <STRING_LITERAL_LONG1>   ::=   "'''" (( (( "'" | "''" ))? ( [^'\\] | ECHAR ) ))* "'''"
[108]   <STRING_LITERAL_LONG2>   ::=   '"""' (( (( '"' | '""' ))? ( [^\"\\] | ECHAR ) ))* '"""'
[109]   <ECHAR>   ::=   "\\" [tbnrf\\\"']
[110]   <NIL>   ::=   "(" (WS)* ")"
[111]   <WS>   ::=   " "
| "\t"
| "\r"
| "\n"
[112]   <ANON>   ::=   "[" (WS)* "]"
[113]   <PN_CHARS_BASE>   ::=   [A-Z]
| [a-z]
| [#00C0-#00D6]
| [#00D8-#00F6]
| [#00F8-#02FF]
| [#0370-#037D]
| [#037F-#1FFF]
| [#200C-#200D]
| [#2070-#218F]
| [#2C00-#2FEF]
| [#3001-#D7FF]
| [#F900-#FDCF]
| [#FDF0-#FFFD]
| [#10000-#EFFFF]
[114]   <PN_CHARS_U>   ::=   PN_CHARS_BASE
| "_"
[115]   <VARNAME>   ::=   ( PN_CHARS_U | [0-9] ) (( PN_CHARS_U | [0-9] | #00B7 | [#0300-#036F] | [#203F-#2040] ))*
[116]   <PN_CHARS>   ::=   PN_CHARS_U
| "-"
| [0-9]
| #00B7
| [#0300-#036F]
| [#203F-#2040]
[117]   <PN_PREFIX>   ::=   PN_CHARS_BASE (( (( PN_CHARS | "." ))* PN_CHARS ))?
[118]   <PN_LOCAL>   ::=   ( PN_CHARS_U | [0-9] ) (( (( PN_CHARS | "." ))* PN_CHARS ))?
[119]   PASSED TOKENS   ::=   ([ \t\r\n])+

C References

C.1 Normative References

IANA-CHARSETS
(Internet Assigned Numbers Authority) Official Names for Character Sets, ed. Keld Simonsen et al. (See http://www.iana.org/assignments/character-sets.)

C.2 Other References

Aho/Ullman
Aho, Alfred V., Ravi Sethi, and Jeffrey D. Ullman. Compilers: Principles, Techniques, and Tools. Reading: Addison-Wesley, 1986, rpt. corr. 1988.
Brüggemann-Klein
Brüggemann-Klein, Anne. Formal Models in Document Processing. Habilitationsschrift. Faculty of Mathematics at the University of Freiburg, 1993. (See ftp://ftp.informatik.uni-freiburg.de/documents/papers/brueggem/habil.ps.)
Brüggemann-Klein and Wood
Brüggemann-Klein, Anne, and Derick Wood. Deterministic Regular Languages. Universität Freiburg, Institut für Informatik, Bericht 38, Oktober 1991. Extended abstract in A. Finkel, M. Jantzen, Hrsg., STACS 1992, S. 173-184. Springer-Verlag, Berlin 1992. Lecture Notes in Computer Science 577. Full version titled One-Unambiguous Regular Languages in Information and Computation 140 (2): 229-253, February 1998.
Clark
James Clark. Comparison of SGML and XML. (See http://www.w3.org/TR/NOTE-sgml-xml-971215.)
IANA-LANGCODES
(Internet Assigned Numbers Authority) Registry of Language Tags (See http://www.iana.org/assignments/language-subtag-registry.)
IETF RFC 2141
IETF (Internet Engineering Task Force). RFC 2141: URN Syntax, ed. R. Moats. 1997. (See http://www.ietf.org/rfc/rfc2141.txt.)
IETF RFC 3023
IETF (Internet Engineering Task Force). RFC 3023: XML Media Types. eds. M. Murata, S. St.Laurent, D. Kohn. 2001. (See http://www.ietf.org/rfc/rfc3023.txt.)
IETF RFC 2781
IETF (Internet Engineering Task Force). RFC 2781: UTF-16, an encoding of ISO 10646, ed. P. Hoffman, F. Yergeau. 2000. (See http://www.ietf.org/rfc/rfc2781.txt.)
ISO 639
(International Organization for Standardization). ISO 639:1988 (E). Code for the representation of names of languages. [Geneva]: International Organization for Standardization, 1988.
ISO 3166
(International Organization for Standardization). ISO 3166-1:1997 (E). Codes for the representation of names of countries and their subdivisions — Part 1: Country codes [Geneva]: International Organization for Standardization, 1997.
ISO 8879
ISO (International Organization for Standardization). ISO 8879:1986(E). Information processing — Text and Office Systems — Standard Generalized Markup Language (SGML). First edition — 1986-10-15. [Geneva]: International Organization for Standardization, 1986.
ISO/IEC 10744
ISO (International Organization for Standardization). ISO/IEC 10744-1992 (E). Information technology — Hypermedia/Time-based Structuring Language (HyTime). [Geneva]: International Organization for Standardization, 1992. Extended Facilities Annexe. [Geneva]: International Organization for Standardization, 1996.
WEBSGML
ISO (International Organization for Standardization). ISO 8879:1986 TC2. Information technology — Document Description and Processing Languages. [Geneva]: International Organization for Standardization, 1998. (See http://www.sgmlsource.com/8879/n0029.htm.)
XML Names
Tim Bray, Dave Hollander, and Andrew Layman, editors. Namespaces in XML. Textuality, Hewlett-Packard, and Microsoft. World Wide Web Consortium, 1999. (See http://www.w3.org/TR/xml-names/.)

D CVS History

$Log: Overview.html,v $
Revision 1.3  2009/10/23 14:16:51  ivan
*** empty log message ***

Revision 1.2  2009/10/22 07:22:09  ivan
*** empty log message ***

Revision 1.1  2009/10/21 14:26:23  ivan
*** empty log message ***

Revision 1.6  2009/10/21 12:57:48  lfeigenb
remove broken links to grammar pieces

Revision 1.5  2009/10/21 12:50:22  lfeigenb
fix broken grammar links

Revision 1.4  2009/10/21 03:36:18  lfeigenb
version order fix

Revision 1.3  2009/10/21 03:35:31  lfeigenb
publication prep

Revision 1.2  2009/10/20 20:50:37  lfeigenb
validation errors

Revision 1.14  2009/10/20 19:45:52  lfeigenb
small fixes for naming and cleanup

Revision 1.13  2009/10/20 19:10:19  lfeigenb
Fixed and added support for markup that was previously unsupported by our XSLTs.

Future SPARQL-specific customizations should go in shared/sparql.xsl

Revision 1.12  2009/10/20 14:40:52  pgearon
Removed reference to ISSUE-22

Revision 1.11  2009/10/20 07:45:16  sschenk
turned notes into issues: ISSUES 45-48

Revision 1.10  2009/10/17 15:05:21  pgearon
changed cvs log details as it included some half baked html

Revision 1.9  2009/10/16 21:54:54  pgearon
Updates as per email from Luke Wilson-Mawer on October 16, 2009. Also converted <i> to <em> and removed <span class="prod"> from the grammar.

Revision 1.8  2009/10/15 09:42:40  sschenk
address comments in
http://lists.w3.org/Archives/Public/public-rdf-dawg/2009OctDec/0041.html

Revision 1.7  2009/10/14 10:07:02  sschenk
zero modification commit to fix R1.6 commit message

Revision 1.6  2009/10/14 09:36:53  sschenk
convert all @@todos into issue or note

Revision 1.5  2009/10/13 10:20:40  sschenk
restructuring and section renaming

Revision 1.4  2009/10/11 19:53:47  sschenk
Add dtd, xsls for update, update grammar

Revision 1.1  2009/09/14 21:17:28  eric
CREATED