When is a query language called rationally complete

Find all fixed but unverified work items. Find all unresolved defects. Find all high priority or high severity work items that are still unresolved. In RTC, content in work items is mainly provided in form of text. Various conditions allow for querying textual values , ranging from very specific, e. A full-text condition will search for work items that contain the text in their summary, description or comments attributes.

Note that it uses word stemming techniques and thus may results in less findings compared to using summary, description or comments directly. Also other content attributes, such as tags, estimate, duration and even custom attributes , can provide very selective results in cases where you know these values in existing work items. Find all work items that have a custom attribute called Build Notes and whose Due Date is ten days from now.

In situations where you know people or teams that are possibly involved in work items you can query for attributes in the People dimension. They define the relationships of work item with respect to RTC users and teams. Teams can be found by querying for specific conditions using the Team Area and Filed Against attributes. Find all fixed but unverified work items of the Work Item team.

Find all high priority or high severity work items that were created by people outside your organization and are still unresolved. If you know particular events that have happened to your queried work items, you can use attributes from the Temporal Dimension.

Most conditions here specify events that happened within a certain range of time or at a certain point in time. However, we also added planning and verification related attributes to this dimension, as planning looks into the future and approvals confirm the past of work items. Putting constraints on any attribute of type Timestamp , Iteration , and Approval can tell you when something happened and can thus be considered a search on the Temporal Dimension.

Find all fixed but unverified work items of the Work Item team that were fixed during the current iteration. The final dimension is about structural relationships and linkage between work items and with other artifacts. Query conditions in the structural dimension specify how work items related to other work item and artifacts within RTC. Linkage employs link types, such as related, blocks, or tested-by to specify relationships between work items. This can be very useful if you know that Stories are usually parents of tasks.

Artifact relationships are defined by artifacts, such as attachments, builds, change sets, etc. You can query very selectively for some work items if you know about such a relationship. The conditions in the Structural Dimension formulate how are work items related to other work items or artifacts.

After finding too many work items with some starting condition, e. Find all unresolved defects of the Work Item team that block other teams. Find all work items that you created which were resolved as duplicates and whose duplicates are still unresolved. Note: This query works only for direct duplicates.

Longer duplicate chains are not considered. Find all defects and enhancements of the Work Item team that depend on another unresolved work item. Find all work items that have an attachment of png image type. Find all fixed work items that are not included in a build.

Find all stories without children. This topic is also discussed in Getting Started with Work Items. The authors are developers in the Tracking and Planning team working on the Work Item component of Rational Team Concert with main contributions to the query engine, work item templates, and the server backend. Rather than storing data in separate files for each application, data are stored so as to appear to users as being stored in only one location.

A single database services multiple applications. For example, instead of a corporation storing employee data in separate information systems and separate files for personnel, payroll, and benefits, the corporation could create a single common human resources database.

Figure illustrates the database concept. FIGURE The contemporary database environment A single human resources database serves multiple applications and also enables a corporation to easily draw together all the information for various applications. The database management system acts as the interface between the application programs and the data. FIGURE Sample data dictionary report The sample data dictionary report for a human resources database provides helpful information, such as the size of the data element, which programs and reports use it, and which group in the organization is the owner responsible for maintaining it.

The report also shows some of the other names that the organization uses for this piece of data. FIGURE The relational data model Each table is a relation, each row is a tuple representing a record, and each column is an attribute representing a field. These relations can easily be combined and extracted to access data and produce reports, provided that any two share a common data element. FIGURE A hierarchical database for a human resources system The hierarchical database model looks like an organizational chart or a family tree.

It has a single root segment Employee connected to lower level segments Compensation, Job Assignments, and Benefits. The output of the above query is as follows. It is also invalid to use a QName with a namespace prefix that has not been declared. The following query is also semantically invalid. Namespace declaration attributes may redefine a namespace prefix within a given scope. The following query is valid. Unless a default namespace is in effect, any element name, attribute name, or NameTest without a namespace prefix is not associated with a namespace.

Hence, the following query returns the empty sequence. A Default Namespace Declaration defines a namespace URI that will be associated with any element name or element name test that does not have a namespace prefix, or with any function that does not have a namespace prefix. Different default namespaces can be specified for elements and for functions. The following is the result of the above query. As in XPath 1.

In element constructors, unprefixed attributes create attribute nodes whose namespace URI is null. Attribute name tests without prefixes match attributes whose namespace URI is null.

A Schema Import imports the element and attribute declarations and type definitions from a schema, mapping them into the Query Data Model using rules that will be specified in a future edition of [XQuery 1. The URI in a schema import specifies the namespace to be imported, and optionally the location of the schema in which the namespace is defined.

Importing a schema has no effect on the in-scope namespaces, since it does not associate a prefix with the namespace. When a schema is imported, the query generally accompanies the schema import with appropriate namespace or default namespace declarations to make it possible to refer to the names defined in the schema.

Note: Whether or not the locally declared elements and attributes of a schema are imported is an open issue. It is an error to import two schemas that both define the same name in the same symbol space and in the same scope. For instance, a query may not import two schemas that provide global element declarations for two elements with the same expanded name.

In addition to the built-in functions described in [XQuery 1. A function definition specifies the name of the function, the names and datatypes of the parameters, and the datatype of the result. All datatypes are specified using the syntax described in 2. A function definition also includes an expression called the function body that defines how the result of the function is computed from its parameters.

The name of a function may be qualified with a namespace. The default namespace for functions is the namespace of the XML Query 1. The default namespace for functions may be changed by a default namespace declaration, as in this example:. If a function parameter is declared using a name but no type, it accepts arguments of any type. If the returns clause is omitted from a function definition, the function may return a value of any type.

The following example illustrates the definition and use of a function that accepts a sequence of employee elements, summarizes them by department, and returns a sequence of dept elements. Each argument value to a function must be an instance of the argument's declared type, and the value of a function's body must be an instance of the function's return type.

During static analysis, a query processor checks that that a value is an instance of its corresponding declared type by applying assert. At run-time, a query processor checks that the dynamic type of a value is an instance of its corresponding declared type by applying treat.

This run-time application of treat may be omitted if the query has passed static analysis and is therefore known to be type correct. A function may be defined recursively--that is, it may reference its own definition.

Mutually recursive functions, whose bodies reference each other, are also allowed. The following example defines a recursive function that computes the maximum depth of an element hierarchy, and calls the function to find the maximum depth of a particular document.

In its definition, the user-defined function depth calls the built-in functions empty and max. In XQuery 1. Only one function definition may have a given name.

We consider function overloading to be a useful and important feature that deserves further study in future versions of XQuery. Although XQuery does not allow overloading of user-defined functions, some of the built-in functions in the XQuery core library are overloaded--for example, the string function of XPath can convert an instance of almost any type into a string.

If a future version of XQuery supports function overloading, an ambiguity may arise between a function that takes a node as parameter and a function with the same name that takes a simple value as parameter since a function call automatically extracts the simple value of a node when necessary. The designers of such a future version of XQuery can avoid this ambiguity by writing suitable rules to govern function overloading.

Nevertheless, users who are concerned about this possibility may choose to explicitly extract simple values from nodes when calling functions with simple value parameters. Note: Rules for invoking functions on complex-type arguments are still an open issue, as noted under "Basic Conversion Rules. In previous sections, we have focused on explaining the meaning of the syntactic constructs of XQuery. This section contains examples of several important classes of queries that can be expressed using the syntax described in earlier sections.

In some cases we describe functions introduced to support specific usage scenarios. In others, we show particular ways to combine operators that have already been introduced.

The applications described here include filtering a document to produce a table of contents, joins across multiple data sources, grouping and aggregates, and queries based on sequential relationships in documents.

One of the functions in the XQuery core function library is called filter. This function takes a single parameter which can be any expression. The function evaluates its argument and returns a shallow copy of the nodes that are selected by the argument, preserving any relationships that exist among these nodes. For example, suppose that the argument to filter is a path expression that selects nodes X, Y, and Z from some document.

Suppose that, in the original document, nodes Y and Z are descendants at any level of node X. Then the result of filter is a copy of node X, with copies of nodes Y and Z as its immediate children. Any other intervening nodes from the original document are not present in the result. The name filter suggests a function that operates on a document to extract the parts that are of interest and discard the remainder, while retaining the structure of the original document. The semantics of filter are illustrated by Figure 1.

The result contains copies of all nodes of type A and B in the original hierarchy, with their original relationships preserved. Note that the action of the filter function may split a node hierarchy into multiple hierarchies preserving the sequential relationships among the root nodes of the resulting hierarchies. The following example illustrates how filter might be used to compute a table of contents for a document that contains many levels of nested sections.

The query filters the document, retaining only section elements, title elements nested directly inside section elements, and the text of those title elements. Other elements, such as paragraphs and figure titles, are eliminated, leaving only the "skeleton" of the document.

The example generates a table of contents for a document named cookbook. Joins, which combine data from multiple sources into a single result, are a very important type of query. In this section we will illustrate how several types of joins can be expressed in XQuery.

We will base our examples on the following three documents:. A document named parts. A document named suppliers. A document named catalog. The catalog document contains many item elements, each of which in turn contains partno , suppno , and price subelements.

A conventional "inner" join returns information from two or more related sources, as illustrated by the following example, which combines information from three documents. The example generates a "descriptive catalog" derived from the catalog document, but containing part descriptions instead of part numbers and supplier names instead of supplier numbers. The new catalog is ordered alphabetically by part description and secondarily by supplier name.

The previous query returns information only about parts that have suppliers and suppliers that have parts. An outer join is a join that preserves information from one or more of the participating sources, including elements that have no matching element in the other source. For example, a left outer join between suppliers and parts might return information about suppliers that have no matching parts.

The following query demonstrates a left outer join. It returns names of all the suppliers in alphabetic order, including those that supply no parts. In the result, each supplier element contains the descriptions of all the parts it supplies, in alphabetic order.

The previous query preserves information about suppliers that supply no parts. Another type of join, called a full outer join , might be used to preserve information about both suppliers that supply no parts and parts that have no supplier. The result of a full outer join can be structured in any of several ways. The following query generates a list of supplier elements, each containing nested part elements for the parts that it supplies if any , followed by a list of part elements for the parts that have no supplier.

This might be thought of as a "supplier-centered" full outer join. Other forms of outer join queries are also possible. The previous query uses an element constructor to enclose its output inside a master-list element. The concatenation operator "," is used to combine the two main parts of the query. The result is an ordered sequence of supplier elements followed by an orphan-parts element that contains descriptions of all the parts that have no supplier.

Many queries involve forming data into groups and applying some aggregation function such as count or avg to each group. The following example shows how such a query might be expressed in XQuery, using the catalog document defined in the previous section. This query finds the part number and average price for parts that have at least 3 suppliers.

The distinct-values function in this query eliminates duplicate part numbers from the set of all part numbers in the catalog document. The result of distinct-values is a sequence in which order is not significant. The query uses an element constructor to enclose each part number and average price in a containing element called well-supplied-item. Although these operators are quite simple, they can be used to express sophisticated queries for XML documents in which sequence is meaningful.

The first two queries in this section involve a surgical report that contains procedure , incision , and anesthesia elements. The following query returns a critical sequence that contains all elements and nodes found between the first and second incisions of the first procedure.

The following query reports incisions for which no prior anesthesia was recorded in the surgical report. In some documents, particular sequences of elements may indicate a logical hierarchy. This is most commonly true of HTML.

In this example, we assume that an h2 element containing the text "Introduction" marks the beginning of the introduction, and the introduction continues until the next h2 or h1 element, or the end of the document, whichever comes first.

Note that the above query also makes explicit the hierarchy that was implicit in the original document. The EBNF contains only non-terminals, and all terminals are presented in a separate table.

In the following table, operators with a higher precedence number are more tightly bound than operators with a lower precedence number. Operators listed at the same level are evaluated from left to right. For readability, whitespace may be used in expressions even though not explicitly allowed by the grammar: Whitespace may be freely added within patterns before or after any token, except in a few cases where whitespace is needed to disambiguate the token:.

In XML, "-" is a valid character in an element or attribute name. When used as an operator after the characters of a name, it must be separated from the name, eg by using whitespace or parentheses. Tokens may be often only recognized in a specific state within the evaluation, and a token in turn may cause the grammar to transition to a different state. These state transitions are given below following the enumeration of tokens.

When tokenizing, the longest possible token is always returned. If there is an ambiguity between two tokens, the token that has an lower grammar number is more specific than a token with a higher grammar number.

In literal XML, any name may be used as an element name or attribute name, even if it is a reserved word in XQuery's expression syntax. To make this possible, XQuery uses separate lexical states for start tags and end tags. Similarly, strings that would be treated as a reserved keyword in XQuery's expression syntax are treated as normal character sequences when they occur in element content, attribute values, processing instructions, XML comments, or CDATA sections.

The following example contains the string "FOR" many times, but this string is always interpreted the same way that it would be by a native XML parser, not as an XQuery keyword:.

When followed by whitespace, it is treated as the less-than sign, and there is no state transition. Before changing state, the tokenizer pushes the current state to a stack. Element constructors also push the current state, popping it at the conclusion of an end tag.

However, several lexical transitions occur between the beginning and end of an element constructor. This state allows attributes in the native XML syntax.

When the end tag is terminated, the state is popped to the state that was pushed at the start of the corresponding start tag. To allow curly braces to be used as character content, a double left or right curly brace is interpreted as a single curly brace character.

Any lexical pattern that is not recognized under a given state will be an unrecognized token, and thus an error. What should be the precedence of a RangeExpr? The XQuery grammar has it in a bit different place than is listed here. XPath 1. The current XQuery spec attempts to avoid reserved words but the result is that the XQuery grammar relies heavily on lexing tricks that make it difficult to document and difficult to extend.

There is currently a substantial feeling in the XQuery group that the language should have some reserved words, which would be an incompatible change from XPath 1. XSL WG Position: Exceptionally strong feeling that requiring element names that match a reserved word to be escaped is utterly unacceptable.

If reserved words are required they must start with an escape character so they cannot conflict with element names.

Attempt to maintain grammar and revisit this issue as necessary. We recognize that there is a problem but solutions are all distasteful. Decision by: xsl on [link to member only information] joint meeting. Decision by: xquery on [link to member only information] joint meeting. Thtopchange the text, the grammar, and the examples.

In XPath 1. But XQuery believes that a node-set containing one element with value False should not be implicitly converted to True. The section on comparisons performs exceptional treatment for node-set to Boolean conversions. Jonathan Marsh does not support such an exception.

Either we should remove the exception and take the backward compatibility hit, or we should define a different mechanism to access the typed-value so that the compatibility question is avoided. Consistency of functions that take boolean formal argument. Agreed that choice context is not necessary for XPath predicates. Standard fallback conversions will handle case when required value is optional boolean but actual value is not. Adoption of Michael R's proposal in [link to member only information: Proposal to close issue expr[nodes]].

There have been some problems called to attention on the editor's list about the decision made at the telcon concerning dealing with nodes in predicates and the like. Sequences are defined to not be able to contain sequences. Yet, it is probably that we need to be able to represent null in sequences in order to maintain cardinality for table processing and the like.

Proposal: Nulls are a special value or an empty sequence: It is a special value when it is a member of a sequence. It is an empty sequence for type checking and iteration. This may require tagging empty sequences that were returned as null with a flag.

Should we default then to return an empty sequence? Should the 3-valued logic functions be part of the XPath function library? Note that they can be implemented as user functions not as efficient as a "native" implementation. We may want to include the user definition as an example. For functions, the null empty sequence is passed to the function, the precedent set by SQL.

Should comparison operations act the same, or should they be defined to always return an empty sequence in this case? Is for really a proper construct for a simple expression language? Will the definition of for in XPath cause problems for XQuery? Are such quantifiers desireable? If so, what are their semantics, and what use cases support them? Note that there is no additional expressive power over the current single-variable syntax, this is purely a question of convenience.

Section 2. Static type checking and schema validation are not equivalent, but we might want to do both in a query.

For example, we might want to assert statically that an expression has a particular type and also validate dynamically the value of an expression w. The differences between static type checking and schema validation must be enumerated clearly the XSFD people should help us with this.

Some discussion of algorithmic issues of type checking are needed. In addition, we may want to define "conformance levels" for XQuery, in which some processors or some processing modes are more permissive about types. This is related to xquery-schema-importxquery-schema-import. We do not specify what is the effect of type checking a query that is applied to a document without a DTD or Schema.

In general, a schema-less document has type xs:AnyType and type checking can proceed under that assumption. A related issue is what is the effect of type checking a query that is applied to an incompletely validated document. Does the definition of a type include both element-names and element-contents as in the Formal Semantics document , or only element-contents as in XML Schema?

Do we need a function that returns the type name of its operand? If so, what should it return if the operand is an element with a given xsi:type - the element name? Specification of this function requires more work on types in XQuery. If the latter, should we require a warning? With respect to parameter types and return types in functions? We need more thought about what constitutes a valid parameter-type for a function.

Attribute-types as well as element-types? Type-names vs. Should all the MSL symbol spaces be represented? Using univeral names similar to those found in the MSL document, but with a different syntax, would allow us to reference any schema type in XQuery function definitions. More detailed rules need to be developed for function resolution.

What kinds of function overloading are allowed? A promotion hierarchy of basic types needs to be specified. The issue of polymorphic functions with dynamic dispatch needs to be studied. Can overloaded functions be defined such that the parameter-type of one function is a subtype of the parameter-type of another function? If so, what are the constraints on the return-types of these functions?

Is function selection based on the static type of the argument or on the dynamic type of the argument dynamic dispatch, performed at execution time? If XQuery supports dynamic dispatch, is it based on all the arguments of a function or on only one distinguished argument?

Observation: This is a very complex area of language design. If it proves too difficult to solve in the available time, it may be wise to take a simple approach such as avoiding dynamic dispatch in Version 1 of XML Query. We will attempt to simplify XML Query Level 1 by omitting these, unless it becomes clear that they are needed. We realize that this might happen. Is it an error for a query to specify content that may not appear, according to the schema definition?

If the schema does not allow a nose to appear on an invoice, is this query an error, or will it simply return an empty list? As part of the general description of errors, which is largely still to be done, we must carefully distinguish static from dynamic errors. In general, we should probably attempt to catch errors as early as possible. The following examples have been suggested by the Algebra team:. It then generates a sequence containing all the integers from the left-hand operand to the right-hand operand, inclusive.

If either of the operands cannot be converted to an integer, an error results. In a well-formed document, in which arbitrary strings may be converted to integers, it could be dynamic.

The Algebra has a syntax for declaring types. Is this sufficient? Some important questions:. Do we need to allow inline XML schema declarations in the prolog of a query? The following example shows one potential syntax for this. The implementation would then assign an internal URI to the namespace. We do not specify how a Schema or DTD is 'imported' into a query so that its information is available during type checking.

Schema and DTDs can either be named explicitly e. The mechanism for statically accessing a Schema or DTD is unspecified. The semantics of the instanceof operator are not defined over all operands, e. What should the symantics be for these types? If this is not true, a static, compile-time error is raised. Do we need a Context Item to track the "current item" in a for itteration, and, if so, how should it work? How should ". Do we need a way to specify the nodes in the input context?

Many queries do not specifically state the input to which they will be applied. This allows the same query, for instance, to be applied to a number of databases. This variable might even be useful in the syntax of XQuery itself. It seems like the context should include a default namespace declaration for use for the QNames within node tests within the XPath. I'm worried about complexities with other qnames besides the one in node tests, like function qnames.

The Functions and Operators doc specifies named collations. These probably need to be part of the context.

The definition and syntax of a query module are still under discussion in the working group. The specifications in this section are pending approval by the working group. Future versions of the language may support other forms of query modules, such as update statements and view definitions.

The means by which a query module gains access to the functions defined an an external function library remains to be defined. Should xmlns only be respected for construction, Xquery expressions but not functions, or also functions?

Does XQuery need a way to specify the encoding of a query? For instance, should the prolog allow statements like the following? There is no operator to access the typed constant content of an element.

In the Algebra, the data operator does this. Should XQuery do the same? Some functions taking node sequences and implicitly map? Decision by: xsl on [link to member only information] It was noted that there are other issues on data that may lead to further discussions. Consensus is to define data on only singleton node and empty sequence. This decision will be reflected in next WD. Section 1 - 4th paragraph says the typed-value of an element with complex type is the same as its string-value. This is not currently consistent with the data model.

The data model doc says, in section 4. For an element in a well-formed document with no associated schema, the element's typed-value is the empty sequence. Note: Question: I had a note from this, "insert from minutes", but I only see "Need to track "what does data " return as an issue.

Typed value? Something else? Should this issue be removed from this document? Do we need an identity-based equality operator? Please justify your answer with sample queries. Note that XPath gets along without it. It is not clear that these operators should apply to simple values, because simple values do not have a concept of node identity.

If these operators are defined for simple values, perhaps they should have a lower precedence than arithmetic operators. This seems inconsistent. Both of these comparions should be carried out as string comparisons using the default collation. This seems to conflict with strong typing. Status: Open, pending discussion.

Is this acceptable for us? Do we need another notion of deep equality? If so, what are the compatibility issues with XPath? When elements are compared, are comments and PIs considered in the comparison? How is whitespace handled? Do we need to allow more than one way to handle these in comparisons? This document does not have a general discussion of errors, when they are raised, and how they are processed.

This is needed. The data model does not distinguish between sequences and between 'node sets', i. XQuery-Null-Issue Question: What should happen if a function expecting one element is invoked on an empty sequence?

What should happen if a function expecting one element is invoked on a sequence of more than one element? Many XPath functions and node-tests implicitly operate on the current node if no argument is specified. Should this apply to all functions? All unary functions? Only certain functions? What should the the result of various aggregate functions when applied to the empty sequence? As in SQL, count returns 0, and all other aggregate functions return the empty sequence. The statement "the longest possible token" means the longest sequence that would form a token in the token-space of the grammar, not the longest that would be valid in the current syntactic context.

Or should both be supported? Why is axis availability part of the run-time context? Myaxis::foo should be a syntax error. This seems like a really clunky mechanism for subsetting. The alternative, as Mike Kay presented, is to provide a set of booleans telling if the given axis is available. Proposed resolution: Axis subsetting should be done at the grammar level, similar to how XSLT pattern matching is specified. XPath supports 13 axes. The current Working Draft says that XQuery will support a subset of these axes, including at least those axes required by the abbreviated syntax.

The definitive set of axes to be supported by XQuery has not yet been determined. In the current Working Draft, the examples use abbreviated syntax, but the grammar supports unabbreviated syntax. For the axes required by the abbreviated syntax, should XQuery allow both the unabbreviated and abbreviated syntax? If we decide not to support additional axes, no new functionality would be added by supporting the unabbreviated syntax.

Opinions vary as to whether the unabbreviated syntax is clearer. The XPath task force has recommended that we allow any expression in a path step. Proponents note that this adds to the symmetry of the language. Opponents note that this allows queries to be written that are very difficult to read, and may raise some issues for optimization. This needs further study. Option 8A: Yes. Option 8B: No. Option 8C: Only if it is declared to have required content and to be "nilable". An extensibility mechanism needs to be defined that permits XQuery to access a library of functions written in some other programming language such as Java.

Some sources of information: the definition of external functions in SQL, the implementation of external functions in Kweelt. Should we say something about the fact that XPath is meant to be a abstract specification? I am concerned about people getting the impression that XPath can be used by itself. Maybe it can be, and maybe this is OK. The division of path expressions into relative and absolute isn't reflected in the syntax. If the first step is an AxisStepExpr, add ".

The semantics would still be specified in the data model document. Similarly, we would add a section that listed the functions in the evaluation context that are supported. The semantics for these functions would be in the XPath document as decided this morning. In general, our handling of references needs a lot of work. Should we allow this for element constructors with literal element names? If a list of expressions contains adjacent element constructors, should a comma appear between these element constructors?

The attribute function takes two parameters. The first is the name of the attribute to be constructed. The second is the value of the attribute to be constructed. If an attribute function occurs within an element constructor, the attribute is added to the set of attributes for that element.

XQuery currently allows computed attribute values without quotes, which is not well-formed XML:. This makes it hard to embed queries that use this syntax in well-formed XML documents. Also, the Formal Description uses a syntax for element and attribute construction that is more suitable for use with inference notation.

Should an alternative construction syntax be used that eliminates both problems? Close the issue, pending convincing use cases. Can't there always be an intervening parser or other tool to create the XML data model instance?

In attribute constructors and string constructors, XQuery uses quotes or apostrophes as delimiters. How are these characters escaped when they occur within strings that are created by one of these constructors? I propose that we use double-delimiters within a string literal, e. Copy and reference semantics must be defined properly for updates to work. This must be coordinated with the algebra team.

Can a query construct an entire XML document? What restrictions are there, eg on the internal subset, processing instructions or comments on the root level? Option 10A: Attribute is not created. Option 10B: Run-time error.

Option 10C: The attribute is created, and its value is the empty sequence. Option 10D: The attribute is created and its value is the empty sequence if this is allowed by the attribute type; otherwise it's a run-time error. Option 10E: The attribute is created and its value is the empty sequence. However, an error may occur when the attribute is serialized.