Règles de conversion de types dans XQuery

Conversion explicite

Le tableau suivant présente la conversion de types autorisée entre les différents types de primitives intégrés.

• Un type de primitive intégré peut se convertir en un autre type de primitive intégré en respectant les règles en vigueur sur les données de la table.

• Un type de primitive peut également se convertir en tout autre type dérivé de ce type de primitive. Par exemple, vous pouvez convertir le type xs:decimal aussi bien en xs:integer qu'en xs:long.

• Un type dérivé peut être converti en tout autre type dont il constitue l'ancêtre dans la hiérarchie des types, et ce jusqu'à son type de primitive de base intégré. Par exemple, vous pouvez convertir le type xs:token aussi bien en xs:normalizedString qu'en xs:string.

• Un type dérivé peut également être converti en type de primitive si l'ancêtre de sa primitive peut aussi être converti dans le type cible. Par exemple, vous pouvez convertir xs:integer, un type dérivé, en xs:string, un type de primitive, car xs:decimal, l'ancêtre de la primitive de xs:integer, peut être converti en xs:string.

• Un type dérivé peut également être converti en autre type dérivé si l'ancêtre de la primitive du type source peut aussi être converti en ancêtre de primitive du type cible. Par exemple, vous pouvez convertir le type xs:integer en xs:token car vous pouvez convertir le type xs:decimal en xs:string.

• Les règles pour la conversion de types définis par l'utilisateur en types intégrés revient au même que pour la conversion de types intégrés. Ainsi, vous pouvez définir un type myInteger dérivé du type xs:integer. myInteger peut alors être converti en xs:token car vous pouvez convertir le type xs:decimal en xs:string.

Les types de conversion suivants ne sont pas pris en charge :

• La conversion mettant en œuvre les types de liste n'est pas autorisée. Ceci comprend aussi bien les types de liste définis par l'utilisateur que les types de liste intégrés, tels que xs:IDREFS, xs:ENTITIES et xs:NMTOKENS.

• La conversion mettant en œuvre le type xs:QName n'est pas pris en charge.

• Le type xs:NOTATION et les sous-types de durée entièrement triés tels que xdt:yearMonthDuration et xdt:dayTimeDuration ne sont pas pris en charge. C'est pour cela que la conversion mettant en œuvre ces types n'est pas prise en charge.

Les exemples suivants illustrent la conversion explicite de types.

Exemple A

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

Exemple B

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

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

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

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

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

Conversion implicite

La conversion implicite n'est autorisée que pour les types numériques et les types atomiques non typés. Par exemple, la fonction min() suivante renvoie la valeur minimale entre deux valeurs :

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

Dans cet exemple, les deux valeurs transmises à la fonction min() XQuery sont de deux types différents. Ainsi, la conversion implicite est assurée en promouvant le type integer en type double afin de pouvoir comparer les deux valeurs de type double.

La promotion de type telle qu'elle est décrite dans cet exemple suit les règles suivantes :

• Un type numérique dérivé peut être promu en son type de base. Par exemple, le type integer peut être converti en decimal.

• Le type decimal peut être promu en float et une valeur de type float peut être convertie en type double.

La conversion implicite n'étant autorisée que pour les types numériques, ce qui suit n'est pas possible :

• La conversion implicite mettant en œuvre les types de chaîne (string) n'est pas autorisée. Par exemple, si deux types string sont attendus mais que vous transmettez un type string et un type token (jeton), aucune conversion implicite ne se produit et une erreur est renvoyée.

• La conversion implicite des types numériques en types de chaînes n'est pas non plus autorisée. Ainsi, si vous transmettez une valeur de type integer à une fonction s'attendant à un paramètre de type string (chaîne), là encore la conversion implicite ne peut pas se produire et entraîne une erreur.

Conversion de valeurs

Lors de la conversion d'un type vers un autre, les valeurs sont en fait transformées de l'espace de valeurs du type source à celui du type cible. Par exemple, la conversion de xs:decimal en xs:double transforme la valeur décimale en valeur double.

Voici quelques-unes des règles qui s'appliquent lors de la transformation.

Limitations relatives à son implémentation

Les limitations suivantes s'appliquent :

• La valeur à virgule flottante NaN n'est pas prise en charge.

• Les valeurs convertibles sont limitées par les restrictions d'implémentation des types de cibles. Par exemple, vous ne pouvez pas convertir une chaîne de date avec une année négative en xs:date. De telles conversions génèreront la séquence vide si la valeur est fournie au moment de l'exécution (au lieu de déclencher une erreur d'exécution).

Voir aussi

Concepts