TMQL requirements 1.2.0

3.1 Relationship to other standards

1. The syntax of any URIs within TMQL query statements shall be governed by the rules of RFC 2396 [RFC2396] as modified by RFC 2732 [RFC2732].

2. The native character set of TMQL shall be Unicode [Unicode].

3. Any ordering of strings shall be based on externally-defined specifications for internationalized string collation. Candidates are the Unicode Collation Algorithm [UTR10], and ISO 14651 [ISO14651].

4. The TMQL standard should be defined based on a set of use cases representing general classes of queries expected to be common [UC].

5. TMQL shall be based on [ISO13250].

6. TMQL shall be based on the topic map data model [DM]. (Thus, TMQL will also support XTM 1.0 [XTM] and XTM 1.1 [XTM11], respectively)

7. TMQL shall be harmonized with the Topic Map Constraint Language [TMCL] in the sense that there shall be no overlap of functionality, The standards shall be compatible and features from TMCL shall be reused in TMQL wherever suitable.

3.2 Structure

1. The TMQL standard SHALL clearly define how it uses each of the concepts of the query environment (see 2 Query Environment), and whether it uses any of them.

2. The TMQL standard MUST have a part which details the query language for Topic Maps. This section MUST define a formal syntax and the semantics of query statements.

3. The TMQL standard SHALL contain a conformance clause, stating the conditions under which TMQL implementations may claim to conform to the standard.

4. The TMQL standard MAY have a part which covers updating of Topic Maps and MAY also contain a section about administration of Topic Map repositories. This MAY include suggestions for language means for query optimization and storage modalities.

5. The TMQL standard MAY have a part which covers output from TMQL result sets.

3.3 Syntax

TMQL query statements will have to have a syntax when written as serialized text. This will be used in the authoring process and also when machines exchange statements.

1. The syntax of TMQL statements SHALL be defined in terms of a formal, context-free grammar. It is suggested to use EBNF as notation.

2. An XML syntax for TMQL query statement MAY be defined. This is mainly thought for interchange, not as primary notation for humans. It is suggested to use [RELAX-NG] as the schema language for this syntax.

3. The formal definition of the grammar MUST constrain query statements to be written in [Unicode].

3.4 Semantics

When defining the execution semantics of TMQL statements the definition has to include the underlying data, the query statement (serialized or deserialized) and a result, either in form of a serialized or deserialized data structure.

It is also expected that for semantic characterisation an execution context is used to capture intermediate steps in the query process.

1. The TMQL standard shall be rigorous and should fully define the results of queries so that any given query can only have one correct result (disregarding sorting orders where no sorting is mandated). It should also be — as far as the rigor allows — be easily understandable to the average engineer.

2. The TMQL standard shall define error situations and how TMQL processors are required to react to them or to flag them to the calling application.

3. The execution context MAY be defined as seems appropriate for a language, there is no constraint on the form and nature of this context.

4. The definition of the underlying data MUST be based (directly or indirectly) on the data model [DM].

5. The definition of the result of a TMQL query MUST be done by using also [DM] for TM-structured data. For other kinds of output the standard MAY use any other appropriate means to formally define the structure. If the structure contains text, then [Unicode] MUST be enforced.

4.1 Functionality

1. TMQL MUST be able to solve the use cases outlined in [UC]. This can be achieved either directly with the language or via an extension framework if such is defined.

2. TMQL shall support all natural languages equally. That is, TMQL shall be fully internationalized with respect to text representation, text ordering, etc.

3. A TMQL query SHALL contain all the information necessary to interpret it (with respect to its TMQL environment, inter-query context, and intra-query context).

4.2 Input

1. TMQL MUST allow to specify queries shall be able to span over multiple topic maps. This is to say, that TMQL should allow querying of topic maps stored in a distributed fashion.

2. Statements in TMQL itself SHOULD NOT contain any assumptions how Topic Maps are represented. They should only refer to the abstract model defined by the [DM].

3. TMQL must allow the environment to pass in literals into a query as query parameters.

4. The character set for exchange of text data between the environment and an TMQL processor SHALL BE [Unicode].

4.3 Result sets

1. Result sets shall be instances of an abstract TMQL data model.

2. TMQL SHALL enable the specification of primitive, XML, and topic map results.

3. When serializing results the TMQL standard SHALL enable queries to specify the character encoding of the output.

4. For result sets TMQL MUST support sorting of query results according to properties and values related to the result set. This relationship must be clearly defined.

5. TMQL shall support limiting the number of values returned by a particular query. (This is essentially the same feature as that provided by SQL's LIMIT feature, but TMQL may choose to support it in a completely different way.)

6. TMQL shall support paging the values returned by a particular query through functionality for slicing the list of results. (This is essentially the same functionality as that provided by SQL's LIMIT and OFFSET features, but TMQL may choose to support it in a completely different way.)

4.4 Usability

1. TMQL SHALL have a concise and human-readable syntax.

2. TMQL SHOULD scale in terms of complexity: Simple (and frequent) queries should be formalizable with short statements. Complex queries may take longer statements; for these TMQL SHALL make it possible to write queries in a modular fashion.

3. TMQL SHALL BE extensible. TMQL shall define controlled mechanisms for third-party extensions, e.g., domain-specific extensions.

4.5 Implementation

1. TMQL SHALL BE independent of any particular implementation technique or implementation language.

2. TMQL SHALL BE efficiently implementable for the typical queries.

3. It SHOULD BE technically feasible to automatically assess queries in terms of their computational costs.

4. The TMQL query syntax SHALL BE designed to be easily embeddable into XML documents and programming language source code. (This means for example that characters like '&' and '<' cannot be commonly used in TMQL.)

5. The syntax SHOULD BE designed so that queries expected to be common be as easy to write as possible.