XML-Konstruktion (XQuery)

Gilt für:SQL Server

In XQuery können Sie die direkten und berechneten Konstruktoren verwenden, um XML-Strukturen innerhalb einer Abfrage zu erstellen.

Verwenden von direkten Konstruktoren

Wenn Sie direkte Konstruktoren verwenden, geben Sie beim Konstruieren des XML-Codes eine XML-ähnliche Syntax an. Die folgenden Beispiele veranschaulichen die XML-Konstruktion mit direkten Konstruktoren.

Erstellen von Elementen

Sie können Elemente konstruieren, indem Sie die XML-Schreibweise verwenden. Im folgenden Beispiel wird der Direkte Elementkonstruktorausdruck verwendet und ein <ProductModel> Element erstellt. Das konstruierte Element besitzt drei untergeordnete Elemente.

• Einen Textknoten.

• Zwei Elementknoten <Summary> und <Features>.

  • Das <Summary> Element verfügt über einen untergeordneten Textknoten, dessen Wert lautet "Some description".

  • Das <Features> Element verfügt über drei untergeordnete Elementknoten, <Color>, und <Warranty><Weight>. Jeder dieser Knoten weist einen untergeordneten Textknoten auf und weist die Werte , bzw. die Werte Redauf252 years parts and labor.

DECLARE @x AS XML;

SET @x = '';

SELECT @x.query('<ProductModel ProductModelID="111">;
This is product model catalog description.
<Summary>Some description</Summary>
<Features>
  <Color>Red</Color>
  <Weight>25</Weight>
  <Warranty>2 years parts and labor</Warranty>
</Features></ProductModel>');

Dies ist der resultierende XML-Code:

<ProductModel ProductModelID="111">
  This is product model catalog description.
  <Summary>Some description</Summary>
  <Features>
    <Color>Red</Color>
    <Weight>25</Weight>
    <Warranty>2 years parts and labor</Warranty>
  </Features>
</ProductModel>

Wie in diesem Beispiel gezeigt, erweist sich das Konstruieren von Elementen aus konstanten Ausdrücken zwar als nützlich; die wahre Stärke dieser Funktion der XQuery-Sprache liegt jedoch in der Möglichkeit, XML-Code zu konstruieren, mit dem Daten dynamisch aus einer Datenbank extrahiert werden können. Verwenden Sie zum Angeben von Abfrageausdrücken geschweifte Klammern. Im XML-Ergebnis wird der Ausdruck dann durch seinen Wert ersetzt. Die folgende Abfrage erstellt beispielsweise ein Element mit einem <NewRoot> untergeordneten Element (<e>). Der Wert des Elements <e> wird berechnet, indem ein Pfadausdruck in geschweiften geschweiften Klammern ("{ ... }") angegeben wird.

DECLARE @x AS XML;

SET @x = '<root>5</root>';

SELECT @x.query('<NewRoot><e> { /root } </e></NewRoot>');

Die geschweiften Klammern fungieren als Token, die einen Kontextwechsel bewirken, sodass die Abfrage von der XML-Konstruktion zur Abfrageauswertung wechselt. In diesem Fall wird der XQuery-Pfadausdruck innerhalb der geschweiften Klammern (/root) ausgewertet und durch sein Ergebnis ersetzt.

Das Ergebnis lautet wie folgt:

<NewRoot>
  <e>
    <root>5</root>
  </e>
</NewRoot>

Die folgende Abfrage ist der vorherigen ähnlich, Der Ausdruck in den geschweiften geschweiften Klammern gibt jedoch die data() Funktion an, mit der der atomische Wert des <root> Elements abgerufen und dem konstruierten Element zugewiesen wird. <e>

DECLARE @x AS XML;
SET @x = '<root>5</root>';

DECLARE @y AS XML;
SET @y = (SELECT @x.query('
                           <NewRoot>
                             <e> { data(/root) } </e>
                           </NewRoot>'));

SELECT @y;

Das Ergebnis lautet wie folgt:

<NewRoot>
  <e>5</e>
</NewRoot>

Wenn die geschweiften Klammern Teil Ihres Texts sein sollen, d. h. nicht als Kontextwechseltoken fungieren sollen, können Sie als Escapezeichen "}}" und "{{" verwenden, wie im folgenden Beispiel gezeigt:

DECLARE @x AS XML;
SET @x = '<root>5</root>';

DECLARE @y AS XML;
SET @y = (SELECT @x.query('
<NewRoot> Hello, I can use {{ and  }} as part of my text</NewRoot>'));

SELECT @y;

Das Ergebnis lautet wie folgt:

<NewRoot> Hello, I can use { and  } as part of my text</NewRoot>

Die folgende Abfrage ist ein weiteres Beispiel für die Konstruktion von Elementen mithilfe des direkten Elementkonstruktors. Außerdem wird der Wert des <FirstLocation> Elements durch Ausführen des Ausdrucks in den geschweiften geschweiften Klammern abgerufen. Der Abfrageausdruck gibt die Fertigungsschritte am ersten Arbeitsplatzstandort aus der Instructions-Spalte der Production.ProductModel-Tabelle zurück.

SELECT Instructions.query('
    declare namespace AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
        <FirstLocation>
           { /AWMI:root/AWMI:Location[1]/AWMI:step }
        </FirstLocation>
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Das Ergebnis lautet wie folgt:

<FirstLocation>
  <AWMI:step xmlns:AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions">
      Insert <AWMI:material>aluminum sheet MS-2341</AWMI:material> into the <AWMI:tool>T-85A framing tool</AWMI:tool>.
  </AWMI:step>
  <AWMI:step xmlns:AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions">
      Attach <AWMI:tool>Trim Jig TJ-26</AWMI:tool> to the upper and lower right corners of the aluminum sheet.
  </AWMI:step>
   ...
</FirstLocation>

Elementinhalt in der XML-Konstruktion

Das folgende Beispiel veranschaulicht das Verhalten von Ausdrücken beim Konstruieren von Elementinhalten mithilfe des direkten Konstruktors. Im folgenden Beispiel gibt der direkte Elementkonstruktor einen Ausdruck an. Für diesen Ausdruck wird im daraus resultierenden XML-Code ein Textknoten erstellt.

DECLARE @x AS XML;
SET @x = '
<root>
  <step>This is step 1</step>
  <step>This is step 2</step>
  <step>This is step 3</step>
</root>';

SELECT @x.query('
<result>
 { for $i in /root[1]/step
    return string($i)
 }
</result>');

Die aus der Auswertung des Ausdrucks resultierende Sequenz atomarer Werte wird dem Textknoten hinzugefügt, wobei die einzelnen atomaren Werte durch Leerzeichen getrennt werden, wie im Ergebnis gezeigt. Das konstruierte Element besitzt ein untergeordnetes Element. Es handelt sich um einen Textknoten, der den im Ergebnis gezeigten Wert enthält.

<result>This is step 1 This is step 2 This is step 3</result>

Wenn Sie anstelle eines einzigen Ausdrucks drei verschiedene Ausdrücke angeben, die drei Textknoten generieren, werden die aneinander angrenzenden Textknoten im XML-Ergebnis durch Verkettung zu einem einzigen zusammengeführt.

DECLARE @x AS XML;
SET @x = '
<root>
  <step>This is step 1</step>
  <step>This is step 2</step>
  <step>This is step 3</step>
</root>';

SELECT @x.query('
<result>
 { string(/root[1]/step[1]) }
 { string(/root[1]/step[2]) }
 { string(/root[1]/step[3]) }
</result>');

Der konstruierte Elementknoten besitzt ein untergeordnetes Element. Es handelt sich um einen Textknoten, der den im Ergebnis gezeigten Wert enthält.

<result>This is step 1This is step 2This is step 3</result>

Attribute erstellen

Wenn Sie Elemente mithilfe des direkten Elementkonstruktors erstellen, können Sie auch Attribute des Elements mithilfe der XML-ähnlichen Syntax angeben, wie in diesem Beispiel gezeigt:

DECLARE @x AS XML;
SET @x = '';

SELECT @x.query('<ProductModel ProductModelID="111">;
This is product model catalog description.
<Summary>Some description</Summary>
</ProductModel>');

Dies ist der resultierende XML-Code:

<ProductModel ProductModelID="111">
  This is product model catalog description.
  <Summary>Some description</Summary>
</ProductModel>

Das konstruierte Element <ProductModel> verfügt über ein ProductModelID-Attribut und diese untergeordneten Knoten:

• Einen Textknoten, This is product model catalog description..

• Ein Elementknoten, <Summary>. Dieser Knoten besitzt einen untergeordneten Textknoten, Some description.

Wenn Sie ein Attribut erstellen, können Sie dessen Wert mit einem Ausdruck in geschweiften geschweiften Klammern angeben. In diesem Fall wird das Ergebnis des Ausdrucks als der Attributwert zurückgegeben.

Im folgenden Beispiel ist die data() Funktion nicht unbedingt erforderlich. Da Sie einem Attribut den Ausdruckswert zuweisen, wird implizit angewendet, data() um den typierten Wert des angegebenen Ausdrucks abzurufen.

DECLARE @x AS XML;
SET @x = '<root>5</root>';

DECLARE @y AS XML;
SET @y = (SELECT @x.query('<NewRoot attr="{ data(/root) }" ></NewRoot>'));

SELECT @y;

Das Ergebnis lautet wie folgt:

<NewRoot attr="5" />

Es folgt eine weiteres Beispiel, in dem Ausdrücke für die Konstruktion der LocationID- und SetupHrs-Attribute angegeben werden. Diese Ausdrücke werden für den XML-Code in der Instructions-Spalte ausgewertet. Der typisierte Wert des Ausdrucks wird anschließend den Attributen zugewiesen.

SELECT Instructions.query('
    declare namespace AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
        <FirstLocation
         LocationID="{ (/AWMI:root/AWMI:Location[1]/@LocationID)[1] }"
         SetupHrs = "{ (/AWMI:root/AWMI:Location[1]/@SetupHours)[1] }" >
           { /AWMI:root/AWMI:Location[1]/AWMI:step }
        </FirstLocation>
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Dies ist das Teilergebnis:

<FirstLocation LocationID="10" SetupHours="0.5" >
  <AWMI:step ...
  </AWMI:step>
  ...
</FirstLocation>

Implementierungseinschränkungen

Die folgenden Einschränkungen sind zu beachten:

• Mehrere oder gemischte (Zeichenfolgen- und XQuery-Ausdruck)-Attributausdrücke werden nicht unterstützt. Wie in der folgenden Abfrage gezeigt, konstruieren Sie beispielsweise XML-Code, in dem Item eine Konstante ist, und der Wert 5 durch Auswerten eines Abfrageausdrucks erhalten wird:

  <a attr="Item 5" />
  

  Die folgende Abfrage gibt einen Fehler zurück, da Sie eine konstante Zeichenfolge mit einem Ausdruck ({/x}) mischen und dies nicht unterstützt wird:

  DECLARE @x AS XML;
  SET @x = '<x>5</x>';
  
  SELECT @x.query('<a attr="Item {/x}"/>');
  

  In diesem Fall haben Sie folgende Möglichkeiten:

  • Sie können den Attributwert durch Verkettung zweier atomarer Werte bilden. Diese atomaren Werte werden für den Attributwert serialisiert, wobei zwischen die beiden Werte ein Leerzeichen eingefügt wird:

    SELECT @x.query('<a attr="{''Item'', data(/x)}"/>');
    

    Das Ergebnis lautet wie folgt:

    <a attr="Item 5" />
    

  • Verwenden Sie die Verkettungsfunktion , um die beiden Zeichenfolgenargumente mit dem resultierenden Attributwert zu verketten:

    SELECT @x.query('<a attr="{concat(''Item'', /x[1])}"/>');
    

    In diesem Fall gibt es kein Leerzeichen zwischen den beiden Zeichenfolgenwerten. Wenn Sie die beiden Werte doch durch ein Leerzeichen trennen möchten, müssen Sie dies explizit angeben.

    Das Ergebnis lautet wie folgt:

    <a attr="Item5" />
    

• Mehrere Ausdrücke als Attributwert werden nicht unterstützt. So gibt beispielsweise folgende Abfrage einen Fehler zurück:

  DECLARE @x AS XML;
  SET @x = '<x>5</x>';
  
  SELECT @x.query('<a attr="{/x}{/x}"/>');
  

• Heterogene Sequenzen werden nicht unterstützt. Jeder Versuch, eine heterogene Sequenz als Attributwert zuzuweisen, gibt einen Fehler zurück, wie im folgenden Beispiel gezeigt. In diesem Beispiel wird eine heterogene Sequenz, eine Zeichenfolge "Item" und ein Element <x>als Attributwert angegeben:

  DECLARE @x AS XML;
  SET @x = '<x>5</x>';
  
  SELECT @x.query('<a attr="{''Item'', /x }" />');
  

  Wenn Sie die Funktion anwenden, funktioniert die data() Abfrage, da sie den Atomwert des Ausdrucks abruft, /xder mit der Zeichenfolge verkettet wird. Es folgt eine Sequenz atomarer Werte:

  SELECT @x.query('<a attr="{''Item'', data(/x)}"/>');
  

  Das Ergebnis lautet wie folgt:

  <a attr="Item 5" />
  

• Die Reihenfolge der Attributknoten wird während der Serialisierung erzwungen und nicht während der Überprüfung des statischen Typs. Beispielsweise ist die folgende Abfrage fehlerhaft, weil sie versucht, nach einem Nichtattributknoten einen Attributknoten hinzuzufügen.

  SELECT CONVERT (XML, '').query('
      element x { attribute att { "pass" }, element y { "Element text" }, attribute att2 { "fail" } }
      ');
  GO
  

  Die vorherige Abfrage gibt den folgenden Fehler zurück:

  XML well-formedness check: Attribute cannot appear outside of element declaration. Rewrite your XQuery so it returns well-formed XML.
  

Hinzufügen von Namespaces

Beim Konstruieren von XML-Code mithilfe von direkten Konstruktoren können die konstruierten Element- und Attributnamen durch das Verwenden von Namespacepräfixen qualifiziert werden. Es gibt folgende Möglichkeiten, um Präfixe an Namespaces zu binden:

• Mithilfe eines Namespacedeklarationsattributs.
• Mithilfe der WITH XMLNAMESPACES Klausel.
• Im XQuery-Prolog.

Verwenden eines Namespacedeklarationsattributs zum Hinzufügen von Namespaces

Im folgenden Beispiel wird ein Namespacedeklarationsattribut beim Erstellen eines Elements <a> verwendet, um einen Standardnamespace zu deklarieren. Durch die Konstruktion des untergeordneten Elements <b> wird die Deklaration des im übergeordneten Element deklarierten Standardnamespaces rückgängig.

DECLARE @x AS XML;
SET @x = '<x>5</x>';

SELECT @x.query('
  <a xmlns="a">
    <b xmlns=""/>
  </a>');

Das Ergebnis lautet wie folgt:

<a xmlns="a">
  <b xmlns="" />
</a>

Sie können dem Namespace ein Präfix zuweisen. Das Präfix wird in der Konstruktion des Elements <a>angegeben.

DECLARE @x AS XML;
SET @x = '<x>5</x>';

SELECT @x.query('
  <x:a xmlns:x="a">
    <b/>
  </x:a>');

Das Ergebnis lautet wie folgt:

<x:a xmlns:x="a">
  <b />
</x:a>

Sie können einen Standardnamespace in der XML-Konstruktion aufheben, aber sie können kein Namespacepräfix aufheben. Die folgende Abfrage gibt einen Fehler zurück, da Sie ein Präfix nicht aufheben können, wie in der Konstruktion des Elements <b>angegeben.

DECLARE @x AS XML;
SET @x = '<x>5</x>';

SELECT @x.query('
  <x:a xmlns:x="a">
    <b xmlns:x=""/>
  </x:a>');

Der neu konstruierte Namespace steht zum Verwenden innerhalb der Abfrage zur Verfügung. Die folgende Abfrage deklariert beispielsweise einen Namespace beim Erstellen des Elements <FirstLocation>und gibt das Präfix in den Ausdrücken für die Attributwerte LocationID und SetupHrs an.

SELECT Instructions.query('
        <FirstLocation xmlns:AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"
         LocationID="{ (/AWMI:root/AWMI:Location[1]/@LocationID)[1] }"
         SetupHrs = "{ (/AWMI:root/AWMI:Location[1]/@SetupHours)[1] }" >
           { /AWMI:root/AWMI:Location[1]/AWMI:step }
        </FirstLocation>
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Durch das Erstellen eines neuen Namespacepräfixes wird auf diese Weise jede bereits vorhandene Namespacedeklaration für dieses Präfix außer Kraft gesetzt. Beispielsweise wird die Namespacedeklaration AWMI="https://someURI"im Abfrageprolog durch die Namespacedeklaration im <FirstLocation> Element überschrieben.

SELECT Instructions.query('
declare namespace AWMI="https://someURI";
        <FirstLocation xmlns:AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"
         LocationID="{ (/AWMI:root/AWMI:Location[1]/@LocationID)[1] }"
         SetupHrs = "{ (/AWMI:root/AWMI:Location[1]/@SetupHours)[1] }" >
           { /AWMI:root/AWMI:Location[1]/AWMI:step }
        </FirstLocation>
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Verwenden eines Prologs zum Hinzufügen von Namespaces

Dieses Beispiel veranschaulicht, wie dem konstruierten XML-Code Namespaces hinzugefügt werden können. Es wird ein Standardnamespace im Prolog der Abfrage hinzugefügt.

DECLARE @x AS XML;
SET @x = '<x>5</x>';

SELECT @x.query('
           declare default element namespace "a";
            <a><b xmlns=""/></a>');

Beim Erstellen des Elements <b>wird das Namespacedeklarationsattribut mit einer leeren Zeichenfolge als Wert angegeben. Dies macht die Deklaration des Standardnamespace des übergeordneten Elements rückgängig.

Das Ergebnis lautet wie folgt:

<a xmlns="a">
  <b xmlns="" />
</a>

XML-Konstruktion und Leerraumbehandlung

Der Inhalt von Elementen in XML-Konstruktionen kann Leerzeichen enthalten. Diese Zeichen werden auf folgende Weise verarbeitet:

• Die Leerzeichen in Namespace-URIs werden als XSD-Typ anyURIbehandelt. Dies ist insbesondere der Umgang mit diesen:

  • Leerzeichen am Anfang und am Ende werden entfernt.
  • Interne Leerzeichenwerte werden zu einem einzigen Leerzeichen zusammengefasst

• Zeilenvorschubzeichen innerhalb des Attributinhalts werden durch Leerzeichen ersetzt. Alle anderen Leerzeichen bleiben unverändert.

• Leerzeichen innerhalb von Elementen werden beibehalten.

Das folgende Beispiel veranschaulicht die Behandlung von Leerzeichen beim Konstruieren von XML-Code:

-- line feed is replaced by space.
DECLARE @x AS XML;
SET @x = '';

SELECT @x.query('

declare namespace myNS="   https://
 abc/
xyz

";
<test attr="    my
test   attr
value    " >

<a>

This     is  a

test

</a>
</test>
') AS XML_Result;

Das Ergebnis lautet wie folgt:

-- result
<test attr="<test attr="    my test   attr  value    "><a>

This     is  a

test

</a></test>
"><a>

This     is  a

test

</a></test>

Andere direct XML-Konstruktoren

Die Konstruktoren für die Verarbeitung von Anweisungen und XML-Kommentaren verwenden dieselbe Syntax wie die entsprechende XML-Konstruktsyntax. Berechnete Konstruktoren für Textknoten werden ebenfalls unterstützt, werden jedoch hauptsächlich zum Erstellen von Textknoten verwendet XML DML .

In der folgenden Abfrage enthält der konstruierte XML-Code ein Element, zwei Attribute, einen Kommentar und eine Verarbeitungsanweisung. Vor dem <FirstLocation>Komma wird ein Komma verwendet, da eine Sequenz erstellt wird.

SELECT Instructions.query('
  declare namespace AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
   <?myProcessingInstr abc="value" ?>,
   <FirstLocation
        WorkCtrID = "{ (/AWMI:root/AWMI:Location[1]/@LocationID)[1] }"
        SetupHrs = "{ (/AWMI:root/AWMI:Location[1]/@SetupHours)[1] }" >
       <!-- some comment -->
       <?myPI some processing instructions ?>
       { (/AWMI:root/AWMI:Location[1]/AWMI:step) }
    </FirstLocation>
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Dies ist das Teilergebnis:

<?myProcessingInstr abc="value" ?>
<FirstLocation WorkCtrID="10" SetupHrs="0.5">
  <!-- some comment -->
  <?myPI some processing instructions ?>
  <AWMI:step xmlns:AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions">I
  nsert <AWMI:material>aluminum sheet MS-2341</AWMI:material> into the <AWMI:tool>T-85A framing tool</AWMI:tool>.
  </AWMI:step>
    ...
</FirstLocation>

Verwenden von berechneten Konstruktoren

In diesem Fall geben Sie die Schlüsselwörter an, die den Typ des zu konstruierenden Knotens identifizieren. Es werden nur folgende Schlüsselwörter unterstützt:

• Element
• Attribut
• Text

Bei Element- und Attributknoten folgen auf diese Schlüsselwörter der Knotenname sowie der Ausdruck in geschweiften Klammern, der den Inhalt dieses Knotens generiert. Im folgenden Beispiel erstellen Sie diesen XML-Code:

<root>
  <ProductModel PID="5">Some text <summary>Some Summary</summary></ProductModel>
</root>

Hier sehen Sie die Abfrage, die berechnete Konstruktoren verwendet, die XML generieren:

DECLARE @x AS XML;
SET @x = '';

SELECT @x.query('element root
               {
                  element ProductModel
     {
attribute PID { 5 },
text{"Some text "},
    element summary { "Some Summary" }
 }
               } ');

Der Ausdruck, der den Knoteninhalt generiert, kann einen Abfrageausdruck angeben.

DECLARE @x AS XML;
SET @x = '<a attr="5"><b>some summary</b></a>';

SELECT @x.query('element root
               {
                  element ProductModel
     {
attribute PID { /a/@attr },
text{"Some text "},
    element summary { /a/b }
 }
               } ');

Mit den berechneten Element- und Attributkonstruktoren, wie in der XQuery-Spezifikation definiert, können Sie die Knotennamen berechnen. Wenn Sie direkte Konstruktoren in SQL Server verwenden, müssen die Knotennamen, z. B. Element und Attribut, als Konstantenliterale angegeben werden. Daher gibt es keinen Unterschied in den direkten Konstruktoren und berechneten Konstruktoren für Elemente und Attribute.

Im folgenden Beispiel wird der Inhalt für die konstruierten Knoten aus den XML-Fertigungsanweisungen abgerufen, die in der Spalte "Anweisungen" des XML-Datentyps in der Tabelle "ProductModel" gespeichert sind.

SELECT Instructions.query('
  declare namespace AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
   element FirstLocation
     {
        attribute LocationID { (/AWMI:root/AWMI:Location[1]/@LocationID)[1] },
        element   AllTheSteps { /AWMI:root/AWMI:Location[1]/AWMI:step }
     }
') AS Result
FROM Production.ProductModel
WHERE ProductModelID = 7;

Dies ist das Teilergebnis:

<FirstLocation LocationID="10">
  <AllTheSteps>
    <AWMI:step> ... </AWMI:step>
    <AWMI:step> ... </AWMI:step>
    ...
  </AllTheSteps>
</FirstLocation>

Weitere Implementierungseinschränkungen

Berechnete Attributkonstruktoren können nicht verwendet werden, um einen neuen Namespace zu deklarieren. Außerdem werden die folgenden berechneten Konstruktoren in SQL Server nicht unterstützt:

• Berechnete Konstruktoren für Dokumentknoten
• Berechnete Konstruktoren für Verarbeitungsanweisungen
• Berechnete Konstruktoren für Kommentare

Verwandte Inhalte

• XQuery Expressions (XQuery-Ausdrücke)