WebSphere Message Broker Version 8.0.0.5 Betriebssysteme: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Sehen Sie sich die Informationen zur aktuellen Produktversion im IBM Integration Bus Version 9.0 an.

CREATE-Anweisung

Die CREATE-Anweisung (Erstellungsanweisung) erstellt ein neues Nachrichtenfeld.

Syntax

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-CREATE--Qualifikationsmerkmal--Ziel--+------------+---------->
                                        '-AS-Klausel-'   

>--+--------------------+--+---------------------+-------------><
   |                (1) |  |                 (2) |   
   '-DOMAIN-Klausel-----'  +-REPEAT-Klauseln-----+   
                           +-ValuesClauses-------+   
                           +-FromClause----------+   
                           |             (3)     |   
                           '-ParseClause---------'   

Qualifikationsmerkmal

|--+-FIELD-------------------+----------------------------------|
   '-+-PREVIOUSSIBLING-+--OF-'   
     +-NEXTSIBLING-----+         
     +-FIRSTCHILD------+         
     '-LASTCHILD-------'         

AS-Klausel

|--AS--AliasfeldverweisVariable---------------------------------|

DOMAIN-Klausel

|--DOMAIN--Ausdruck---------------------------------------------|

REPEAT-Klauseln

|--REPEAT--+-----------------+----------------------------------|
           '-VALUE--Ausdruck-'   

VALUES-Klauseln

|--+--------------------+--+-----------------+------------------|
   '-| NAMES-Klauseln |-'  '-VALUE--Ausdruck-'   

NAMES-Klauseln

                                                                     (4)     
|--+-+----------------+--+---------------------+--+----------------+-----+--|
   | '-TYPE--Ausdruck-'  '-NAMESPACE--Ausdruck-'  '-NAME--Ausdruck-'     |   
   '-IDENTITY--Pfadelement-----------------------------------------------'   

FROM-Klausel

|--FROM--Quellenfeldreferenz------------------------------------|

PARSE-Klausel

|--PARSE--(--Bitstromausdruck--+----------------------------+--)--|
                               | .-<<---------------------. |      
                               | V                        | |      
                               '---+-ENCODING--Ausdruck-+-+-'      
                                   +-CCSID--Ausdruck----+          
                                   +-SET--Ausdruck------+          
                                   +-TYPE--Ausdruck-----+          
                                   +-FORMAT--Ausdruck---+          
                                   '-Optionen-----------'          

Optionen

|--OPTIONS--+----------+----------------------------------------|
            '-Ausdruck-'   

Anmerkungen:
  1. Verwenden Sie nicht die DOMAIN-Klausel und die PARSE-Klausel mit dem Qualifikationsmerkmal FIELD.
  2. Verwenden Sie die REPEAT-Klauseln nur mit den Qualifikationsmerkmalen PREVIOUSSIBLING und NEXTSIBLING.
  3. Alle Unterklauseln in der PARSE-Klausel können nur einmal vorkommen.
  4. Falls vorhanden, müssen die Elemente TYPE, NAMESPACE und NAME in der Reihenfolge stehen, die im Pfeildiagramm angegeben ist.

Das neue Nachrichtenfeld wird an einer vorgegebenen Position (CREATE FIELD) oder relativ zu einer bereits vorhandenen Position (CREATE ... OF...) erstellt. Die Erstellung neuer Felder ist nur möglich, wenn der Zielfeldreferenz auf eine Nachrichtenstruktur zeigt, die Änderungen zulässt (z. B. Environment, InputLocalEnvironment, OutputLocalEnvironment, OutputRoot oder OutputExceptionList).

Wenn die FIELD-Klausel angegeben ist, wird zu dem durch "Ziel" angegebenen Feld navigiert (bei Bedarf werden die Felder erstellt) und alle Werteklauseln und die FROM-Klausel werden verarbeitet. Durch das Einschließen einer FIELD-Klausel werden jedoch nicht zwangsläufig Felder erstellt, sondern die Klausel stellt nur sicher, dass die angegebenen Felder vorhanden sind.

Wenn in der Zielfeldreferenz Feldgruppenindizes verwendet werden, kann nur eine einzige Instanz eines bestimmten Feldes erstellt werden. Angenommen, Sie schreiben eine SET-Anweisung, die wie folgt beginnt:
 SET OutputRoot.XMLNS.Message.Structure[2].Field = ...  

In diesem Fall muss in der Nachricht bereits eine Instanz von "Structure" vorhanden sein. Das heißt, dass die einzigen Felder in der Baumstruktur, die erstellt wurden, diejenigen Felder sind, die sich auf einem direkten Pfad vom Stamm zu dem Feld, das von der Feldreferenz angegeben wird, befinden.

Wenn eine PREVIOUSSIBLING-, NEXTSIBLING-, FIRSTCHILD- oder LASTCHILD-Klausel angegeben ist, wird auf dieselbe Weise wie bei der FIELD-Klausel zu dem durch "Ziel" angegebenen Feld navigiert (bei Bedarf werden die Felder erstellt). An der angegebenen Position wird dann ein neues Feld erstellt und eingefügt (z. B. als PREVIOUSSIBLING oder FIRSTCHILD). Eine CREATE-Anweisung mit einer dieser Klauseln erstellt immer ein neues Feld und stellt dieses an die angegebene Position.

Wenn Sie zwei Zielanweisungen CREATE FIRSTCHILD OF verwenden, die dasselbe Ziel angeben, erstellt die zweite Anweisung ein neues Feld als das erste untergeordnete Feld des Ziels und verschiebt das zuvor erstellte erste untergeordnete Feld in der Nachrichtenbaumstruktur nach rechts (sodass es nicht mehr das erste untergeordnete Feld ist). Entsprechend navigiert CREATE LASTCHILD OF "Ziel" zum Zielfeld und fügt ganz rechts ein neues Feld hinzu, wobei es das bisherige letzte untergeordnete Feld nach links verschiebt.

CREATE PREVIOUSSIBLING OF "Ziel" erstellt ein Feld unmittelbar links von dem durch "Ziel" angegebenen Feld (sodass sich die Tiefe der Baumstruktur nicht ändert) und entsprechend erstellt CREATE NEXTSIBLING OF "Ziel" ein Feld unmittelbar rechts von dem durch "Ziel" angegebenen Feld. Bei der Erstellung von PREVIOUSSIBLING oder NEXTSIBLING können Sie unter Verwendung des Schlüsselwortes REPEAT angeben, dass Art und Name des neuen Feldes aus dem aktuellen Feld übernommen werden sollen.

AS-Klausel:

Falls die AS-Klausel vorhanden ist, wird die benannte Verweisvariable verschoben, sodass sie auf das neu erstellte Feld zeigt. Verwenden Sie diese Klausel, wenn das neue Feld in einen weiteren Bearbeitungsablauf einbezogen werden soll.

DOMAIN-Klausel:

Ist die DOMAIN-Klausel angegeben, hat sie zur Folge, dass das neue Feld einem neuen Parser des angegebenen Typs zugeordnet wird. Diese Klausel erwartet einen Root-Feldnamen (z. B. XMLNS oder MQRFH2). Wenn die DOMAIN-Klausel angegeben ist, aber nur eine Zeichenfolge mit Nulllänge enthält, wird ein neuer Parser desselben Typs wie der Parser, der Eigner des durch "Ziel" angegebenen Felds ist, erstellt. Es wird eine Ausnahmebedingung ausgegeben, wenn der angegebene Domänenname nicht den Datentyp CHARACTER hat oder wenn er dem Wert NULL entspricht. Verwenden Sie die FIELD-Klausel nicht mit der DOMAIN-Klausel, da in diesem Fall nicht sicher ist, ob ein neues Feld erstellt wird.

REPEAT-Klausel:

Art und Name des neuen Feldes können unter Verwendung der REPEAT-Klausel aus dem Zielfeld übernommen werden. Ebenso können Art, Name und Wert des neuen Feldes:
  • aus einem beliebigen vorhandenen Feld kopiert werden (unter Verwendung der FROM-Klausel)
  • explizit angegeben werden (unter Verwendung der VALUES-Klausel)
  • durch die syntaktische Analyse eines Bitstroms definiert werden (unter Verwendung des PARSE-Klausel)
Im Fall von FROM- und PARSE-Klauseln können auch untergeordnete Elemente für das neue Feld erstellt werden.

VALUES-Klausel:

Für die Werteklauseln TYPE, NAME und VALUE (oder eine Untermenge davon) kann jeder Ausdruck angegeben werden, der einen geeigneten Datentyp zurückgibt (Integer für TYPE, Zeichenfolge für NAME und jeder beliebige Skalartyp für VALUE). Es wird eine Ausnahmebedingung ausgegeben, wenn für TYPE oder NAME der Wert NULL angegeben wurde.

NAMES-Klausel:

Für die NAMES-Klausel können alle Ausdrücke angegeben werden, die einen Wert ungleich null des Typs CHARACTER zurückgeben. Die Bedeutung hängt davon ab, ob NAME- und NAMESPACE-Klauseln wie folgt vorhanden sind:
NAMESPACE NAME Element ist wie folgt benannt
Nein Nein Das Element ist unbenannt (das Namenskennzeichen wird nicht automatisch gesetzt)
Nein Ja Das Element erhält den Namen im Standardnamespace.
Ja Nein Dem Element wird der leere Name im angegebenen Namespace zugeordnet.
Ja Ja Dem Element wird der angegebene Name im angegebenen Namespace zugeordnet.

Für den Operanden IDENTITY kann anstelle der TYPE- und NAME-Klauseln ein einziges Pfadelement angegeben werden, wobei ein Pfadelement (maximal) einen Typ, einen Namespace, einen Namen und einen Index enthält. Diese Elemente geben den Typ, den Namespace, den Namen und den Index des Elements an, das erstellt werden soll, und unterliegen den Regeln, die im Abschnitt über Feldreferenzen beschrieben sind (siehe Übersicht über ESQL-Feldreferenzen). Beispiel:

		IDENTITY (XMLNS.attribute)Space1:Name1[42]

Verwendungsbeispiele für den Operanden IDENTITY finden Sie unten unter 'Beispiele'.

FROM-Klausel:

Für die FROM-Klausel werden Typ, Name und Wert des neuen Feldes aus dem Feld, auf das über Quellenfeldreferenz verwiesen wird, übernommen. Alle bestehenden untergeordneten Felder des Ziels werden abgehängt (das Feld könnte im Fall einer FIELD-Klausel bereits bestehen) und das neue Feld erhält Kopien der dem Quellfeld untergeordneten Felder.

PARSE-Klausel:

Wenn eine PARSE-Klausel vorhanden ist, wird unter dem neu erstellten Feld aus dem bereitgestellten Bitstrom eine untergeordnete Baumstruktur erstellt. Der für die Erstellung der untergeordneten Baumstruktur verwendete Algorithmus hängt vom Parser und den angegebenen Optionen ab. Alle Parser unterstützen den Modus 'RootBitStream'. In diesem Modus wird zur Erstellung der Baumstruktur der Algorithmus des Empfangsknotens verwendet.

Einige Parser unterstützen einen zweiten Modus, nämlich 'FolderBitStream'. In diesem Modus wird eine untergeordnete Baumstruktur von einem Bitstrom generiert, der mit der Funktion ASBITSTREAM erstellt wurde (siehe ASBITSTREAM-Funktion).

Wenn Sie die PARSE-Klausel verwenden, geben Sie einen skalaren Wert an, der den Bitstrom enthält, der für BitStreamExpression syntaktisch analysiert werden soll. Wenn Sie eine Nachrichtenbaumstruktur-Feldreferenz verwenden, müssen Sie sicherstellen, dass er einen skalaren Wert enthält, der den Bitstrom beinhaltet. Ein vorhandener Nachrichtentextordner wie z. B. InputRoot.XMLNSC enthält keinen Bitstrom; aus diesem Grund können Sie damit nicht den Ordner XMLNS serialisieren. Wenn Sie einen anderen Wert als einen Skalar, der den Bitstrom enthält, an die PARSE-Klausel für BitStreamExpression übergeben, generiert der Nachrichtenfluss die Fehlernachricht BIP2906. Stattdessen müssen Sie zuerst die ASBITSTREAM-Funktion aufrufen, um den vorhandenen Nachrichtenbaumstrukturordner zu serialisieren. Das Ergebnis der ASBITSTREAM-Funktion kann dann als BitStreamExpression an die PARSE-Klausel übergeben werden.

Im folgenden Beispiel wird veranschaulicht, wie der XMLNSC-Ordner serialisiert und dann das Ergebnis von ASBITSTREAM in der PARSE-Klausel verwendet wird.
DECLARE inCCSID INT InputProperties.CodedCharSetId;                     
DECLARE inEncoding INT InputProperties.Encoding;                        
DECLARE inBitStream BLOB ASBITSTREAM(InputRoot.XMLNSC, inEncoding, inCCSID);
CREATE LASTCHILD OF OutputRoot DOMAIN('MRM')                            
       PARSE(inBitStream, inEncoding, inCCSID, 'DP3UK14002001',         
             'TestCase', 'XML1', options); 

Wenn die PARSE-Anweisung verarbeitet wird, werden alle Ausdrücke für PARSE-Klauseln ausgewertet. Es wird eine Ausnahmebedingung ausgegeben, wenn einer der folgenden Ausdrücke nicht einen Nicht-Null-Wert des entsprechenden Typs zurückgibt:

Klausel Typ Standardwert
OPTIONS Ganzzahl RootBitStream & ValidateNone
ENCODING Ganzzahl 0
CCSID Ganzzahl 0
SET Zeichen Zeichenfolge mit einer Länge von '0'
TYPE Zeichen Zeichenfolge mit einer Länge von '0'
FORMAT Zeichen Zeichenfolge mit einer Länge von '0'

Details zur Syntax der TYPE-Klausel finden Sie im Abschnitt Namespaces in der Eigenschaft 'Nachricht' angeben.

Obwohl die OPTIONS-Klausel alle Ausdrücke akzeptiert, die einen Wert des Typs INTEGER zurückgeben, ist es nur sinnvoll, Optionswerte aus der Liste der verfügbaren Konstanten zu generieren (unter Verwendung der BITOR-Funktion, wenn mehrere Optionen erforderlich sind).

Bei der Erstellung wird dem Wert der Typ INTEGER zugeordnet, und Sie können den Wert in einer Variablen speichern, als Parameter an eine Funktion übergeben oder auch direkt in einer CREATE-Anweisung verwenden. Liste mit global definierten Konstanten:
        Masteroptionen für Validierung...
        ValidateContentAndValue
        ValidateValue		-- Kann mit 'ValidateContent' verwendet werden
        ValidateContent		-- Kann mit 'ValidateValue' verwendet werden
        ValidateNone

        Optionen für Fehlerauswertung...
        ValidateException
        ValidateExceptionList
        ValidateLocalError
        ValidateUserTrace

       Optionen für Ablaufsteuerung bei der Validierung...
        ValidateComplete
        ValidateImmediate
        ValidateDeferred
Anmerkungen:
  1. Der Abschnitt Auswertungseigenschaften enthält detaillierte Informationen zu den Auswertungsoptionen.
  2. Die Optionen für Ablaufsteuerung bei der Validierung entsprechen den Optionen für Parsing-Ablauf; dabei entspricht insbesondere ValidateDeferred der Option Parse Timing On Demand (Bedarfsbezogene Ablaufsteuerung für Syntaxanalyse).

Funktional entsprechende C- und Java™-APIs

Funktional entsprechende Optionen stehen nicht zur Verfügung in:
  • den MBElement-Methoden createElementAsLastChildFromBitstream() und toBitstream() der Java-Plug-in-Knoten-API
  • den Methoden cniCreateElementAsLastChildFromBitstream() und cniElementAsBitstream der C-Plug-in-Knoten-API.

Sie können jeweils nur eine Option aus jeder Gruppe auswählen. Dies gilt nicht für 'ValidateValue' und 'ValidateContent'. Diese zwei Optionen können für die Inhalt- und Wertevalidierung zusammen verwendet werden. Wenn Sie keine Option in einer Gruppe angeben, wird die fettgedruckte Option verwendet.

Die ENCODING-Klausel akzeptiert alle Ausdrücke, die einen Wert des Typs INTEGER zurückgeben. Es ist jedoch nur sinnvoll, Optionswerte aus der Liste der verfügbaren Konstanten zu generieren:
       MQENC_INTEGER_NORMAL
       MQENC_INTEGER_REVERSED
       MQENC_DECIMAL_NORMAL
       MQENC_DECIMAL_REVERSED
       MQENC_FLOAT_IEEE_NORMAL
       MQENC_FLOAT_IEEE_REVERSED
       MQENC_FLOAT_S390

Die Werte für die CCSID-Klausel entsprechen dem normalen Nummerierungssystem. Beispiel: 1200 = UCS-2, 1208 = UTF-8.

Für ABSENT-Klauseln werden die angegebenen Standardwerte verwendet. Verwenden Sie die Standardwerte für die CCSID und die Codierung, da diese aus den Einstellungen für die Codierung und die CCSID des Warteschlangenmanagers übernommen werden.

Dementsprechend ist die Verwendung von Standardwerten für die Nachrichtengruppen-, Nachrichtentyp- und Nachrichtenformatoptionen hilfreich, da für viele Parser Informationen zu Nachrichtengruppe, -typ und -format nicht erforderlich sind, sodass die Angabe eines beliebigen Werts möglich ist.

Wenn ein Ausdruck bereits bewertet wurde, wird ein Bitstrom unter Verwendung der Ergebnisse der Ausdrücke syntaktisch analysiert.
Anmerkung: Da in dieser Funktion eine Vielzahl von Klauseln enthalten sind, wird eine alternative Syntax unterstützt, in der eine durch Kommas getrennte Liste von Parametern und keine benannten Klauseln bereitgestellt werden. In diesem Fall müssen die Ausdrücke in folgender Reihenfolge angegeben werden:
ENCODING -> CCSID -> SET -> TYPE -> FORMAT -> OPTIONS

Die Liste kann an jeder beliebigen Stelle abgeschnitten werden, und in allen Klauseln, für die Sie keinen Wert angeben, können Sie einen ganz leeren Ausdruck verwenden.

Beispiele für die Verwendung der CREATE-Anweisung

  1. Mit dem folgenden Beispiel wird das angegebene Feld erstellt:
    CREATE FIELD OutputRoot.XMLNS.Data;
  2. Im folgenden Beispiel wird ein Feld ohne Angabe von NAME, TYPE oder VALUE als erstes untergeordnetes Feld von ref1 erstellt:
    CREATE FIRSTCHILD OF ref1;
  3. Im folgenden Beispiel wird ein Feld mit den angegebenen Werten für TYPE, NAME und VALUE erstellt:
    CREATE NEXTSIBLING OF ref1 TYPE NameValue NAME 'Price' VALUE 92.3;
  4. Im folgenden Beispiel wird ein Feld mit Angaben für TYPE und NAME, aber ohne eine Angabe für VALUE erstellt, das dem Feld der gleichen Ebene (wird über die dynamische Feldreferenz ref1 angegeben) vorangestellt wird:
    CREATE PREVIOUSSIBLING OF ref1 TYPE Name NAME 'Quantity';
  5. Das folgende Beispiel erstellt ein neues Feld namens 'Component' und verschiebt die Verweisvariable 'targetCursor', sodass diese auf dieses Feld zeigt:
    CREATE FIRSTCHILD OF targetCursor AS targetCursor NAME 'Component';
  6. Das folgende Beispiel erstellt ein neues Feld als rechtes Element in derselben Ebene wie das Feld, auf das die Verweisvariable 'targetCursor' zeigt; Art und Name des letzteren Feldes werden für das neue Feld übernommen. Anschließend verschiebt die Anweisung die Verweisvariable 'targetCursor', sodass sie auf das neue Feld zeigt:
    CREATE NEXTSIBLING OF targetCursor AS targetCursor REPEAT;
  7. Im folgenden Beispiel wird die Verwendung der PARSE-Klausel veranschaulicht:
    DECLARE bodyBlob BLOB ASBITSTREAM(InputRoot.XMLNS, InputProperties.Encoding,
     InputProperties.CodedCharSetId);
    DECLARE creationPtr REFERENCE TO OutputRoot;
    CREATE LASTCHILD OF creationPtr DOMAIN('XMLNS') PARSE(bodyBlob,
                        InputProperties.Encoding,
     InputProperties.CodedCharSetId);

    Dieses Beispiel kann erweitert werden, um die Serialisierung und Syntaxanalyse eines Feldes oder Ordners zu veranschaulichen:

    DECLARE bodyBlob BLOB ASBITSTREAM(InputRoot.XMLNS.TestCase.myFolder,
                        InputProperties.Encoding,
    InputProperties.CodedCharSetId,",",",FolderBitStream);
    DECLARE creationPtr REFERENCE TO OutputRoot;
    CREATE LASTCHILD OF creationPtr DOMAIN('XMLNS') PARSE(bodyBlob,
                        InputProperties.Encoding,
    InputProperties.CodedCharSetId,",",",FolderBitStream);
  8. Das folgende Beispiel veranschaulicht die Verwendung des Operanden IDENTITY:
    CREATE FIELD OutputRoot.XMLNS.TestCase.Root IDENTITY (XML.ParserRoot)Root;
    CREATE FIELD OutputRoot.XMLNS.TestCase.Root.Attribute 
           IDENTITY (XML.Attribute)NSpace1:Attribute VALUE 'Attrib Value';
    CREATE LASTCHILD OF OutputRoot.XMLNS.TestCase.Root 
           IDENTITY (XML.Element)NSpace1:Element1[1] VALUE 'Element 1 Value';
    CREATE LASTCHILD OF OutputRoot.XMLNS.TestCase.Root 
           IDENTITY (XML.Element)NSpace1:Element1[2] VALUE 'Element 2 Value';

    Dies führt zur Generierung der folgenden Ausgabenachricht:

    <TestCase>
     <Root xmlns:NS1="NSpace1" NS1:Attribute="Attrib Value">
      <NS1:Element1>Element 1 Value</NS1:Element1>
      <NS1:Element1>Element 2 Value</NS1:Element1>
     </Root>
    </TestCase>
  9. Das folgende Beispiel zeigt, wie Sie die DOMAIN-Klausel verwenden können, um den Verlust von Daten zu vermeiden, die nur für den XMLNS-Parser gelten, wenn eine nicht ähnliche Parser-Kopie (unlike-parser-copy) vorkommt:
    DECLARE bodyBlob BLOB ASBITSTREAM(InputRoot.XMLNS, InputProperties.Encoding,
    InputProperties.CodedCharSetId);
    CREATE FIELD Environment.Variables.myXMLTree;
    DECLARE creationPtr REFERENCE TO Environment.Variables.myXMLTree;
    CREATE FIRSTCHILD OF creationPtr DOMAIN('XMLNS') PARSE(bodyBlob, 
                        InputProperties.Encoding, 
    InputProperties.CodedCharSetId);

Beispiel einer CREATE-Anweisung

Dieses Beispiel enthält die ESQL-Anweisungen und eine Eingabenachricht. Als Ergebnis wird die am Ende des Beispiels gezeigte Ausgabenachricht erstellt.

CREATE COMPUTE MODULE CreateStatement_Compute
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
	  CALL CopyMessageHeaders();

        CREATE FIELD OutputRoot.XMLNS.TestCase.description TYPE NameValue VALUE 'This is my TestCase' ;
        DECLARE cursor REFERENCE TO OutputRoot.XMLNS.TestCase;
        CREATE FIRSTCHILD OF cursor Domain('XMLNS') 
               NAME 'Identifier' VALUE InputRoot.XMLNS.TestCase.Identifier;
        CREATE LASTCHILD  OF cursor Domain('XMLNS') NAME 'Sport' VALUE InputRoot.XMLNS.TestCase.Sport;
        CREATE LASTCHILD  OF cursor Domain('XMLNS') NAME 'Date' VALUE InputRoot.XMLNS.TestCase.Date;
        CREATE LASTCHILD  OF cursor Domain('XMLNS') NAME 'Type' VALUE InputRoot.XMLNS.TestCase.Type;
        CREATE FIELD         cursor.Division[1].Number TYPE NameValue VALUE 'Premiership';
        CREATE FIELD         cursor.Division[1].Result[1].Number TYPE NameValue VALUE  '1' ;
        CREATE FIELD         cursor.Division[1].Result[1].Home TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[1].Result[1].Home NAME 'Team' VALUE 'Liverpool' ;
        CREATE LASTCHILD OF  cursor.Division[1].Result[1].Home NAME 'Score' VALUE '4';
        CREATE FIELD         cursor.Division[1].Result[1].Away TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[1].Result[1].Away NAME 'Team' VALUE 'Everton';
        CREATE LASTCHILD OF  cursor.Division[1].Result[1].Away NAME 'Score' VALUE '0';
        CREATE FIELD         cursor.Division[1].Result[2].Number TYPE NameValue VALUE  '2';
        CREATE FIELD         cursor.Division[1].Result[2].Home TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[1].Result[2].Home NAME 'Team' VALUE 'Manchester United';
        CREATE LASTCHILD OF  cursor.Division[1].Result[2].Home NAME 'Score' VALUE '2';
        CREATE FIELD         cursor.Division[1].Result[2].Away TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[1].Result[2].Away NAME 'Team' VALUE 'Arsenal';
        CREATE LASTCHILD OF  cursor.Division[1].Result[2].Away NAME 'Score' VALUE '3';
        CREATE FIELD         cursor.Division[2].Number TYPE NameValue  VALUE '2';
        CREATE FIELD         cursor.Division[2].Result[1].Number TYPE NameValue  VALUE  '1';
        CREATE FIELD         cursor.Division[2].Result[1].Home TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[2].Result[1].Home NAME 'Team' VALUE 'Port Vale';
        CREATE LASTCHILD OF  cursor.Division[2].Result[1].Home NAME 'Score' VALUE '9' ;
        CREATE FIELD         cursor.Division[2].Result[1].Away TYPE Name;
        CREATE LASTCHILD OF  cursor.Division[2].Result[1].Away NAME 'Team' VALUE 'Brentford';
        CREATE LASTCHILD OF  cursor.Division[2].Result[1].Away NAME 'Score' VALUE '5';

	END;

	CREATE PROCEDURE CopyMessageHeaders() BEGIN
		DECLARE I INTEGER 1;
		DECLARE J INTEGER CARDINALITY(InputRoot.*[]);
		WHILE I < J DO
			SET OutputRoot.*[I] = InputRoot.*[I];
			SET I = I + 1;
		END WHILE;
	END;

END MODULE;
Bemerkungen | Marken | Downloads | Bibliothek | Support | Feedback

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Letzte Aktualisierung:
        
        Letzte Aktualisierung: 2015-02-28 16:21:29


ReferenzthemaReferenzthema | Version 8.0.0.5 | ak04950_