Typumwandlungsregeln in XQueryType Casting Rules in XQuery

DIESES THEMA GILT FÜR: jaSQL Server (ab 2012)neinAzure SQL-DatenbankneinAzure SQL Data Warehouse neinParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2012)noAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

Das folgende Spezifikationsdiagramm für Funktionen und Operatoren von W3C XQuery 1.0 und XPath 2.0 zeigt die integrierten Datentypen.The following W3C XQuery 1.0 and XPath 2.0 Functions and Operators specifications diagram shows the built-in data types. Dies umfasst die integrierten Grundtypen und abgeleiteten Typen.This includes the built-in primitive and built-in derived types.

XQuery 1.0-TyphierarchieXQuery 1.0 type hierarchy

In diesem Thema werden die Regeln für die Typumwandlung beschrieben, die beim Umwandeln von einem Typ in einen anderen mithilfe der folgenden Methoden angewendet werden:This topic describes the type casting rules that are applied when casting from one type to another by using one of the following methods:

  • Explizite Umwandlung, die Sie verwenden Sie umgewandelt als oder die typenkonstruktorfunktionen (z. B. xs:integer("5")).Explicit casting that you do by using cast as or the type constructor functions (for example, xs:integer("5")).

  • Implizite Umwandlung, die während der Typhöherstufung auftrittImplicit casting that occurs during type promotion

Explizite UmwandlungExplicit Casting

Die folgende Tabelle erläutert die zulässige Typumwandlung zwischen den integrierten Grundtypen.The following table outlines the allowed type casting between the built-in primitive types.

Umwandlungsregeln für XQuery. Describes casting rules for XQuery.

  • Ein integrierter Grundtyp kann basierend auf den in der Tabelle aufgeführten Regeln in einen anderen integrierten Grundtyp umgewandelt werden.A built-in primitive type can cast to another built-in primitive type, based on the rules in the table.

  • Ein Grundtyp kann in jeden beliebigen Typ umgewandelt werden, der von diesem betreffenden Grundtyp abgeleitet ist.A primitive type can be cast to any type derived from that primitive type. Sie können z. B. Typumwandlung aus xs: decimal auf xs: Integer, oder von xs: decimal auf xs: Long.For example, you can cast from xs:decimal to xs:integer, or from xs:decimal to xs:long.

  • Ein abgeleiteter Typ kann in einen beliebigen Typ umgewandelt werden, der sein Vorgänger in der Typhierarchie ist (bis hinauf zu seinem integrierten Grundtyp).A derived type can be cast to any type that is its ancestor in the type hierarchy, all the way up to its built-in primitive base type. Sie können z. B. Typumwandlung aus xs: Token auf normalizedString oder xs: String.For example, you can cast from xs:token to xs:normalizedString or to xs:string.

  • Ein abgeleiteter Typ kann in einen Grundtyp umgewandelt werden, wenn sein primitiver Vorgänger in den Zieltyp umgewandelt werden kann.A derived type can be cast to a primitive type if its primitive ancestor can be cast to the target type. Sie können z. B. eine Typumwandlung xs: Integer, einen abgeleiteten Typ, in eine xs: String', ' primitive eingeben, da xs: decimal, xs: Integerdes Primitive Vorgänger umgewandelt werden kann, um xs: String.For example, you can cast xs:integer, a derived type, to an xs:string, primitive type, because xs:decimal, xs:integer's primitive ancestor, can be cast to xs:string.

  • Ein abgeleiteter Typ kann in einen anderen abgeleiteten Typ umgewandelt werden, wenn der primitive Vorgänger des Quelltyps in den primitiven Vorgänger des Zieltyps umgewandelt werden kann.A derived type can be cast to another derived type if the source type's primitive ancestor can be cast to the target type's primitive ancestor. Sie können z. B. Typumwandlung aus xs: Integer auf xs: Token, da umgewandelt werden kann xs: decimal auf xs: String.For example, you can cast from xs:integer to xs:token, because you can cast from xs:decimal to xs:string.

  • Die Regeln zum Umwandeln benutzerdefinierter Typen in integrierte Typen sind die gleichen wie für die integrierten Datentypen.The rules for casting user-defined types to built-in types are the same as for the built-in types. Beispielsweise können Sie definieren eine MyInteger von abgeleiteten Typ xs: Integer Typ.For example, you can define a myInteger type derived from xs:integer type. Klicken Sie dann MyInteger umgewandelt werden kann, um xs: Token, da xs: decimal umgewandelt werden kann, um xs: String.Then, myInteger can be cast to xs:token, because xs:decimal can be cast to xs:string.

    Die folgenden Datentypumwandlungsarten werden nicht unterstützt:The following kinds of casting are not supported:

  • Die Typumwandlung in oder aus Listentypen ist nicht zulässig.Casting to or from list types is not allowed. Dies schließt sowohl benutzerdefinierte Listentypen und integrierte Listentypen wie z. B. xs: IDREFS, xs: Entities, und xs: NMTOKENS.This includes both user-defined list types and built-in list types such as xs:IDREFS, xs:ENTITIES, and xs:NMTOKENS.

  • Typumwandlung in oder aus xs: QName wird nicht unterstützt.Casting to or from xs:QName is not supported.

  • xs: Notation und die vollständig geordneten Untertypen von Duration xdt: yearmonthduration und dayTimeDuration, werden nicht unterstützt.xs:NOTATION and the fully ordered subtypes of duration, xdt:yearMonthDuration and xdt:dayTimeDuration, are not supported. Daher ist auch die Typumwandlung in oder aus diese(n) Datentypen nicht zulässig.As a result, casting to or from these types is not supported.

    Die folgenden Beispiele veranschaulichen die explizite Typumwandlung.The following examples illustrate explicit type casting.

Beispiel AExample A

Das folgende Beispiel fragt eine Variable vom Typ xml ab.The following example queries an xml type variable. Die Abfrage gibt eine Sequenz eines Werts vom simple-Typ zurück, der als xs:string typisiert ist.The query returns a sequence of a simple type value typed as xs:string.

declare @x xml  
set @x = '<e>1</e><e>2</e>'  
select @x.query('/e[1] cast as xs:string?')  
go  

Beispiel BExample B

Das folgende Beispiel fragt eine typisierte xml-Variable ab.The following example queries a typed xml variable. Das Beispiel erstellt zuerst eine XML-Schemaauflistung.The example first creates an XML schema collection. Anschließend wird die XML-Schemaauflistung zum Erstellen einer typisierten xml-Variablen verwendet.It then uses the XML schema collection to create a typed xml variable. Das Schema stellt die Typisierungsinformationen für die XML-Instanz bereit, die der Variablen zugeordnet ist.The schema provides the typing information for the XML instance assigned to the variable. Anschließend werden Abfragen für die Variable angegeben.Queries are then specified against the variable.

create xml schema collection myCollection as N'  
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">  
      <xs:element name="root">  
            <xs:complexType>  
                  <xs:sequence>  
                        <xs:element name="A" type="xs:string"/>  
                        <xs:element name="B" type="xs:string"/>  
                        <xs:element name="C" type="xs:string"/>  
                  </xs:sequence>  
            </xs:complexType>  
      </xs:element>  
</xs:schema>'  
go  

Die folgende Abfrage gibt einen statischen Fehler zurück, da nicht bekannt ist, wie viele <root>-Elemente der obersten Ebene in der Dokumentinstanz vorhanden sind.The following query returns a static error, because you do not know how many top level <root> elements are in the document instance.

declare @x xml(myCollection)  
set @x = '<root><A>1</A><B>2</B><C>3</C></root>  
          <root><A>4</A><B>5</B><C>6</baz></C>'  
select @x.query('/root/A cast as xs:string?')  
go  

Die Abfrage ist erfolgreich, wenn ein <root>-Singleton-Element im Ausdruck angegeben wird.By specifying a singleton <root> element in the expression, the query succeeds. Die Abfrage gibt eine Sequenz eines Werts vom simple-Typ zurück, der als xs:string typisiert ist.The query returns a sequence of a simple type value typed as xs:string.

declare @x xml(myCollection)  
set @x = '<root><A>1</A><B>2</B><C>3</C></root>  
              <root><A>4</A><B>5</B><C>6</C></root>'  
select @x.query('/root[1]/A cast as xs:string?')  
go  

Im folgenden Beispiel enthält die Variable vom Typ xml ein document-Schlüsselwort, das die XML-Schemaauflistung angibt.In the following example, the xml type variable includes a document keyword that specifies the XML schema collection. Dies zeigt an, dass es sich bei der XML-Instanz um ein Dokument handeln muss, das ein einziges Element der obersten Ebene besitzt.This indicates that the XML instance must be a document that has a single top-level element. Wenn Sie zwei <root>-Elemente in der XML-Instanz erstellen, wird ein Fehler zurückgegeben.If you create two <root> elements in the XML instance, it will return an error.

declare @x xml(document myCollection)  
set @x = '<root><A>1</A><B>2</B><C>3</C></root>  
              <root><A>4</A><B>5</B><C>6</C></root>'  
go  

Sie können die Instanz so ändern, dass nur ein Element der obersten Ebene eingeschlossen wird. Die Abfrage funktioniert dann.You can change the instance to include only one top level element and the query works. Die Abfrage gibt erneut eine Sequenz eines Werts vom simple-Typ zurück, der als xs:string typisiert ist.Again, the query returns a sequence of a simple type value typed as xs:string.

declare @x xml(document myCollection)  
set @x = '<root><A>1</A><B>2</B><C>3</C></root>'  
select @x.query('/root/A cast as xs:string?')  
go  

Implizite TypumwandlungImplicit Casting

Implizite Typumwandlung ist nur für numerische Datentypen und nicht typisierte atomare Datentypen zulässig.Implicit casting is allowed only for numeric types and untyped atomic types. Beispielsweise die folgenden min() -Funktion gibt das Minimum der beiden Werte zurück:For example, the following min() function returns the minimum of the two values:

min(xs:integer("1"), xs:double("1.1"))  

In diesem Beispiel die beiden Werte übergeben, an die XQuery min() Funktion weisen unterschiedliche Datentypen.In this example, the two values passed in to the XQuery min() function are of different types. Aus diesem Grund wird implizite Konvertierung durchgeführt, in denen Ganzzahl Typ wird zu höher gestuft doppelte und die beiden doppelte Werte verglichen werden.Therefore, implicit conversion is performed where integer type is promoted to double and the two double values are compared.

Die Typhöherstufung, die in diesem Beispiel gezeigt wurde, unterliegt den folgenden Regeln:The type promotion as described in this example follows these rules:

  • Ein integrierter abgeleiteter numerischer Datentyp kann auf seinen Basistyp heraufgestuft werden.A built-in derived numeric type may be promoted to its base type. Beispielsweise Ganzzahl auf heraufgestuft werden decimal.For example, integer may be promoted to decimal.

  • Ein decimal auf heraufgestuft werden "float", und ein "float" auf heraufgestuft werden doppelte.A decimal may be promoted to float, and a float may be promoted to double.

    Da implizite Typumwandlung nur für numerische Datentypen zulässig ist, sind die folgenden Vorgänge nicht zulässig.Because implicit casting is allowed only for numeric types, the following is not allowed:

  • Die implizite Typumwandlung für Zeichenfolgen-Datentypen ist nicht zulässig.Implicit casting for string types is not allowed. Angenommen, zwei Zeichenfolge -Datentypen erwartet werden, und übergeben Sie eine Zeichenfolge und ein token, tritt keine implizite Typumwandlung auf, und ein Fehler zurückgegeben.For example, if two string types are expected and you pass in a string and a token, no implicit casting occurs and an error is returned.

  • Die implizite Typumwandlung aus numerischen Datentypen in Zeichenfolgen-Datentypen ist nicht zulässig.Implicit casting from numeric types to string types is not allowed. Wenn Sie z. B. einen Wert vom Typ integer an eine Funktion übergeben, die einen Parameter vom string-Typ erwartet, tritt keine implizite Typumwandlung auf, und es wird ein Fehler zurückgegeben.For example, if you pass an integer type value to a function that is expecting a string type parameter, no implicit casting occurs and an error is returned.

Typumwandlung von WertenCasting values

Wenn eine Umwandlung von einem Datentyp in einen anderen erfolgt, werden die Istwerte aus dem Wertebereich des Quelltyps in den Wertebereich des Zieltyps transformiert.When casting from one type to another, the actual values are transformed from the source type's value space to the target type's value space. Die Typumwandlung aus einem xs:decimal- in einen xs:double-Typ transformiert z. B. den decimal-Wert in einen double-Wert.For example, casting from an xs:decimal to an xs:double will transform the decimal value into a double value.

Im Folgenden finden Sie einige der Transformationsregeln.Following are some of the transformation rules.

Umwandeln eines Werts aus einem string- oder untypedAtomic-TypCasting a value from a string or untypedAtomic type

Der Wert, der in einen string- oder untypedAtomic-Typ umgewandelt wird, wird auf die gleiche Weise wie beim Überprüfen des Werts basierend auf den Regeln des Zieltyps transformiert.The value that is being cast to a string or untypedAtomic type is transformed in the same manner as validating the value based on the target type's rules. Dies schließt ggf. Muster- und Leerzeichenverarbeitungsregeln ein.This includes eventual pattern and white-space processing rules. Die folgende Umwandlung ist z. B. erfolgreich und generiert einen double-Wert (1.1e0):For example, the following will succeed and generate a double value, 1.1e0:

xs:double("1.1")

Bei der Umwandlung in binäre Typen wie z. B. xs:base64Binary oder xs:hexBinary aus einem string- oder untypedAtomic-Typ müssen die Eingabewerte base64- bzw. hexadezimal codiert sein.When casting to binary types such as xs:base64Binary or xs:hexBinary from a string or untypedAtomic type, the input values have to be base64 or hex encoded, respectively.

Umwandeln eines Werts in einen string- oder untypedAtomic-TypCasting a value to a string or untypedAtomic type

Bei der Umwandlung eines string- oder untypedAtomic-Typs wird der Wert in die kanonische lexikalische Darstellung von XQuery transformiert.Casting to a string or untypedAtomic type transforms the value to its XQuery canonical lexical representation. Dies kann insbesondere bedeuten, dass ein Wert, der während der Eingabe einem bestimmten Muster oder einer anderen Einschränkung unterworfen war, nicht gemäß dieser Einschränkung dargestellt wird.Specifically, this can mean that a value that may have obeyed a specific pattern or other constraint during input will not be represented according to that constraint. Informieren Sie Benutzer dazu SQL ServerSQL Server Typen, in denen kann Einschränkung des Typs ein Problem werden, indem Sie eine Warnung bereitgestellt wird, wenn diese Typen in die schemaauflistung geladen werden.To inform users about this, SQL ServerSQL Server flags types where the type constraint can be a problem by providing a warning when those types are loaded into the schema collection.

Wenn ein Wert vom Typ xs:float oder xs:double oder einer ihrer Untertypen in einen string- oder untypedAtomic-Typ umgewandelt wird, wird der Wert in wissenschaftlicher Schreibweise dargestellt.When casting a value of type xs:float or xs:double, or any one of their subtypes, to a string or untypedAtomic type, the value is represented in scientific notation. Dies geschieht nur, wenn der Absolutwert des Werts kleiner als 1.0E-6 oder größer oder gleich 1.0E6 ist.This is done only when the value's absolute value is less than 1.0E-6, or greater than or equal to 1.0E6. Dies bedeutet, dass 0 in wissenschaftlicher Schreibweise zu 0.0E0 serialisiert wird.This means that 0 is serialized in scientific notation to 0.0E0.

Beispielsweise gibt xs:string(1.11e1) den Zeichenfolgenwert "11.1" zurück, während xs:string(-0.00000000002e0) den Zeichenfolgenwert "-2.0E-11" zurückgibt.For example, xs:string(1.11e1) will return the string value "11.1", while xs:string(-0.00000000002e0) will return the string value, "-2.0E-11".

Bei der Umwandlung binärer Typen wie z. B. xs:base64Binary oder xs:hexBinary in einen string- oder untypedAtomic-Typ werden die Binärwerte in base64- bzw. hexadezimal codierter Form dargestellt.When casting binary types, such as xs:base64Binary or xs:hexBinary, to a string or untypedAtomic type, the binary values will be represented in their base64 or hex encoded form, respectively.

Umwandeln eines Werts in einen numeric-TypCasting a value to a numeric type

Wenn ein Wert eines numeric-Typs in einen Wert eines anderen numeric-Typs umgewandelt wird, wird der Wert aus einem Wertebereich dem anderen Wertebereich zugeordnet, ohne die Zeichenfolgenserialisierung zu durchlaufen.When casting a value of one numeric type to a value of another numeric type, the value is mapped from one value space to the other without going through string serialization. Wenn der Wert nicht der Einschränkung eines Zieltyps genügt, gelten die folgenden Regeln:If the value does not satisfy the constraint of a target type, the following rules apply:

  • Wenn der Quellwert bereits vom Typ numeric und der Zieltyp xs:float oder ein Untertyp davon ist, der -INF- oder INF-Werte zulässt, und die Typumwandlung des numeric-Quellwerts zu einem Überlauf führen würde, wird der Wert INF zugeordnet, wenn er positiv ist, oder -INF, wenn der Wert negativ ist.If the source value is already numeric and the target type is either xs:float or a subtype thereof that allows -INF or INF values, and casting of the source numeric value would result in an overflow, the value is mapped to INF if the value is positive or -INF if the value is negative. Wenn der Zieltyp keine INF- oder -INF-Werte zulässt und ein Überlauf auftreten würde, schlägt die Typumwandlung fehl. Das Ergebnis ist in dieser Version von SQL Server die leere Sequenz.If the target type does not allow INF or -INF, and an overflow would occur, the cast fails and the result in this release of SQL Server is the empty sequence.

  • Wenn der Quellwert bereits vom Typ numeric und der Zieltyp ein numeric-Typ ist, der 0, -0e0 oder 0e0 im zulässigen Wertebereich enthält, und die Typumwandlung des numeric-Quellwerts einen Unterlauf verursachen würde, wird der Wert auf die folgende Weise zugeordnet:If the source value is already numeric and the target type is a numeric type that includes 0, -0e0, or 0e0 in its accepted value range, and casting of the source numeric value would result in an underflow, the value is mapped in the following ways:

    • Der Wert wird für einen decimal-Zieltyp 0 zugeordnet.The value is mapped to 0 for a decimal target type.

    • Der Wert wird -0e0 zugeordnet, wenn der Wert einen negativen Unterlauf verursacht.The value is mapped to -0e0 when the value is a negative underflow.

    • Der Wert wird 0e0 zugeordnet, wenn der Wert einen negativen Unterlauf für einen float- oder double-Zieltyp verursacht.The value is mapped to 0e0 when the value is a positive underflow for a float or double target type.

      Die Typumwandlung schlägt fehl, wenn der Zieltyp nicht Null in seinem Wertebereich enthält; das Ergebnis ist die leere Sequenz.If the target type does not include zero in its value space, the cast fails and the result is the empty sequence.

      Beachten Sie, dass durch die Umwandlung eines Werts in einen binären Gleitkommawert wie z. B. xs:float, xs:double oder einen der jeweiligen Untertypen die Genauigkeit beeinträchtigt werden kann.Note that casting a value to a binary floating point type, such as xs:float, xs:double, or any one of their subtypes, may lose precision.

ImplementierungseinschränkungenImplementation Limitations

Die folgenden Einschränkungen sind zu beachten:These are the limitations:

  • Der Gleitkommawert NaN wird nicht unterstützt.The floating point value NaN is not supported.

  • Umwandelbare Werte werden durch die Implementierungsbeschränkungen der Zieltypen eingeschränkt.Castable values are restricted by the target types implementation restrictions. Sie können nicht mit einem negativen Jahr in eine Datumszeichenfolge z. B. eine Typumwandlung xs: Date.For example, you cannot cast a date string with a negative year to xs:date. Solche Umwandlungen führen zu einer leeren Sequenz, wenn der Wert zur Laufzeit bereitgestellt wird (statt einen Laufzeitfehler auszulösen).Such casts will result in the empty sequence if the value is provided at run time (instead of raising a run-time error).

Siehe auchSee Also

Definieren der Serialisierung von XML-DatenDefine the Serialization of XML Data