Mit Net.Data können Sie Variablen in einem Net.Data-Makro definieren und auf diese Variablen verweisen. Darüber hinaus können Sie diese Variablen vom Makro aus an die Sprachumgebungen übergeben und von dort empfangen. Die übergebenen Variablennamen, Werte und Literalzeichenfolgen werden als Token bezeichnet. Net.Data setzt für die Größe der Token keine Grenze und übergibt alle Token, die Ihr Systemspeicher bearbeiten kann. Bei bestimmten Sprachumgebungen können jedoch Einschränkungen bezüglich der Token-Größe bestehen.
Bei der Definition von Net.Data-Variablen kann die Art der Variable und bei Bedarf ein vordefinierter Wert festgelegt werden. Diese Variablen können je nach Definition in die folgenden Arten untergliedert werden:
In den folgenden Abschnitten wird Folgendes beschrieben:
Wenn eine Kennung einen globalen Geltungsbereich hat, kann auf sie während einer einzelnen Anforderung an einer beliebigen Stelle in einem Makro verwiesen werden. Der Bereich, in dem eine Kennung sichtbar ist, wird als Geltungsbereich der Kennung bezeichnet. Es gibt die folgenden fünf Geltungsbereiche:
Eine Kennung hat einen globalen Geltungsbereich, wenn auf sie von jeder Stelle des Makros aus verwiesen werden kann. Kennungen mit globalem Geltungsbereich sind:
Eine Kennung hat den Geltungsbereich einer Makrodatei, wenn ihre Deklaration außerhalb aller Blöcke erfolgt. Ein Block beginnt mit einer öffnenden geschweiften Klammer ({) und endet mit einem Prozentzeichen und einer schließenden geschweiften Klammer (%}). (DEFINE-Blöcke sind von dieser Definition ausgenommen.) Im Gegensatz zu einer Kennung mit einem globalen Geltungsbereich kann auf eine Kennung mit einem Makrogeltungsbereich nur durch Elemente im Makro verwiesen werden, die auf die Deklaration der Kennung folgen.
Eine Kennung hat den Geltungsbereich FUNCTION-Block, wenn Folgendes zutrifft:
Wenn eine Kennung mit dem gleichen Namen bereits außerhalb der Funktionsdefinition vorhanden ist, verwendet Net.Data die Kennung aus der Funktionsparameterliste innerhalb des Funktionsblocks.
Eine Kennung hat nicht den Geltungsbereich FUNCTION-Block, wenn sie außerhalb der Funktion deklariert oder initialisiert wurde und nicht in der Funktionsparameterliste deklariert wird. Der Wert der Kennung innerhalb des Funktionsblocks bleibt unverändert, außer wenn er durch die Funktion aktualisiert wird.
Eine Kennung hat den Geltungsbereich REPORT-Block, wenn auf sie nur innerhalb eines REPORT-Blocks verwiesen werden kann (zum Beispiel Tabellenspaltennamen N1, N2, ..., Nn). Nur solche Variablen, die Net.Data implizit als Teil der Tabellenverarbeitung definiert, können den Geltungsbereich REPORT-Block haben. Alle anderen verfügbar gemachten Variablen haben den Geltungsbereich FUNCTION-Block.
Eine Kennung hat den Geltungsbereich ROW-Block, wenn auf sie nur innerhalb eines ROW-Blocks verwiesen werden kann (zum Beispiel Tabellenwertnamen V1, V2, ..., Vn). Nur solche Variablen, die Net.Data implizit als Teil der Tabellenverarbeitung definiert, können den Geltungsbereich ROW-Block haben. Alle anderen verfügbar gemachten Variablen haben den Geltungsbereich FUNCTION-Block.
Variablen können in einem Net.Data-Makro auf drei Arten definiert werden:
Ein Variablenwert, der von einem Formular oder von Abfragezeichenfolgedaten empfangen wird, überschreibt einen mit der Anweisung DEFINE in einem Net.Data-Makro definierten Variablenwert.
Die einfachste Art, eine Variable zur Verwendung in einem Net.Data-Makro zu definieren, ist der Einsatz der Anweisung DEFINE. Die Syntax sieht wie folgt aus:
%DEFINE variable_name="variable value" %DEFINE variable_name={ variable value on multiple lines of text %} %DEFINE { variable_name1="variable value 1" variable_name2="variable value 2" %}
variable_name ist der Name, den Sie der Variablen geben. Variablennamen müssen mit einem Buchstaben oder Unterstreichungszeichen beginnen und können jedes beliebige alphanumerische Zeichen, ein Unterstreichungszeichen, einen Punkt oder ein Hash-Zeichen (#) enthalten. Mit Ausnahme der Tabellenvariablen V_columnName muss bei allen Variablennamen die Groß-/Kleinschreibung beachtet werden.
Beispiel:
%DEFINE reply="hello"
Die Variable reply hat den Wert hello.
Zwei aufeinanderfolgende Anführungszeichen allein entsprechen einer leeren Zeichenfolge. Beispiel:
%DEFINE empty=""
Die Variable empty enthält eine leere Zeichenfolge.
Wenn Ihre Variable Sonderzeichen wie Zeilenendezeichen enthält, verwenden Sie geschweifte Blockklammern um den Wert:
%DEFINE introduction={ Hello, My name is John. %}
Sollen Anführungszeichen in einer Zeichenfolge verwendet werden, setzen Sie jeweils zwei Anführungszeichen hintereinander.
%DEFINE HI="say ""hello"""
Sie können auch geschweifte Blockklammern verwenden, um die Anführungszeichen zu umgehen:
%DEFINE HI={ say "hello" %}
Verwenden Sie einen DEFINE-Block, wenn Sie mehrere Variablen mit einer Anweisung DEFINE definieren wollen:
%DEFINE { variable1="value1" variable2="value2" variable3="value3" variable4="value4" %}
Mit den HTML-Formularbefehlen SELECT, INPUT und TEXTAREA können Sie Variablen Werte zuordnen. Im folgenden Beispiel werden Standardbefehle für HTML-Formulare zum Definieren von Net.Data-Variablen verwendet:
<input name="variable_name" TYPE=... />
oder
<select name="variable_name"> <option>value one <option>value two </select>
Mit dem Befehl TEXTAREA können Sie eine Variable zuordnen, die sich auf mehrere Zeilen erstreckt oder Sonderzeichen wie Anführungszeichen enthält:
<textarea name="variable_name" ROWS="4"> Please type the multi-line value of your variable here. </textarea>
variable_name ist der Name, den Sie der Variablen geben. Der Wert der Variablen wird durch die im Formular empfangene Eingabe bestimmt. In HTML-Formulare finden Sie ein Beispiel dafür, wie diese Art der Variablendefinition in einem Net.Data-Makro verwendet wird.
Sie können über die Abfragezeichenfolge Variablen an Net.Data übergeben. Beispiel:
http://www.ibm.com/cgi-bin/db2www/stdqry1.dtw/input?field=custno
In diesem Beispiel geben der Variablenname field und der Variablenwert custno zusätzliche Daten an, die Net.Data über die Abfragezeichenfolge empfängt. Net.Data empfängt und verarbeitet die Daten so wie Formulardaten.
Sie können auf zuvor definierte Variablen verweisen, um an der Stelle des Verweises den Wert der Variablen zu erhalten. Ein Verweis auf eine Variable in Net.Data-Makros besteht aus dem Variablennamen, der in $( und ) eingeschlossen ist. Beispiel:
$(variable_name) $(homeURL)
Wenn Net.Data auf einen Variablenverweis trifft, ersetzt Net.Data den Variablenverweis durch den Wert der Variablen. Variablenverweise können Zeichenfolgen, andere Variablenverweise und Funktionsaufrufe enthalten.
Sie können Variablennamen dynamisch generieren. Bei diesem Verfahren können Sie mit Schleifen Tabellen unterschiedlicher Größe oder Eingabedaten für während der Laufzeit erstellte Listen verarbeiten, wenn die Anzahl in der Liste nicht im voraus ermittelt werden kann. Sie können z. B. Listen von HTML-Formularelementen generieren, die basierend auf von einer SQL-Abfrage zurückgegebenen Sätzen generiert werden.
Wenn Sie Variablen als Teil Ihrer Textdarstellungsanweisungen verwenden wollen, verweisen Sie in den HTML-Blöcken Ihres Makros darauf.
Ungültige Variablenverweise: Ungültige Variablenverweise werden als leere Zeichenfolge aufgelöst. Wenn z. B. ein Variablenverweis ungültige Zeichen wie ein Ausrufezeichen (!) enthält, wird der Verweis als leere Zeichenfolge aufgelöst.
Gültige Variablennamen müssen mit einem alphanumerischen Zeichen oder einem Unterstreichungszeichen anfangen und können aus alphanumerischen Zeichen einschließlich Punkt, Unterstreichungszeichen und Hash-Zeichen bestehen.
Beispiel 1: Variablenverweis in einer Verbindung (Link)
Sie definieren beispielsweise die Variable homeURL wie folgt:
%DEFINE homeURL="http://www.ibm.com/"
Dann können Sie Verweise auf die Homepage in der Form $(homeURL) verwenden und eine Verbindung (Link) erstellen:
<a href="$(homeURL)">Home page</a>
Sie können in vielen Teilen des Net.Data-Makros auf Variablen verweisen. Überprüfen Sie die Sprachkonstrukte in diesem Kapitel, um zu ermitteln, in welchen Teilen des Makros Variablenverweise zulässig sind. Wenn die Variable zu dem Zeitpunkt, zu dem auf sie verwiesen wird, noch nicht definiert ist, gibt Net.Data eine leere Zeichenfolge zurück. Ein Variablenverweis allein definiert die Variable nicht.
Beispiel 2: Dynamisch generierte Variablenverweise
Angenommen, Sie führen eine SQL-Anweisung SELECT mit einer gewissen Anzahl von Elementen aus. Sie können ein HTML-Formular mit Eingabefeldern mit Hilfe der folgenden ROW-Blöcke erstellen:
... %ROW { <input type=text name=@dtw_rconcat("I", ROW_NUM) size=10 maxlength=10 /> %} ...
Da Sie Eingabefelder erstellt haben, wollen Sie höchstwahrscheinlich auf die vom Benutzer eingegebenen Werte zugreifen, wenn das Formular zur Verarbeitung an Ihr Makro übergeben wird. Sie können eine Schleife codieren, um die Werte in einer Liste variabler Länge abzurufen:
<pre> ... @dtw_assign(rowIndex, "1") %while (rowIndex <= rowCount) { The value entered for row $(rowIndex) is: $(I$(rowIndex)) @dtw_add(rowIndex, "1", rowIndex) %} ... </pre>
Net.Data generiert zuerst mit dem Verweis I$(rowIndex) den Variablennamen. Der erste Variablenname könnte z. B. I1 sein. Net.Data verwendet anschließend diesen Wert und löst damit den Variablenwert auf.
Beispiel 3: Ein Variablenverweis mit verschachtelten Variablenverweisen und einem Funktionsaufruf
%define my = "my" %define u = "lower" %define myLOWERvar = "hey" $($(my)@dtw_ruppercase(u)var)
Der Variablenverweis gibt den Wert von hey zurück.
Sie können die folgenden Arten von Variablen in Ihren Makros verwenden:
Wenn Sie Variablen, die von Net.Data in spezieller Weise definiert werden (z. B. ENVVAR, LIST oder Bedingungslistenvariablen), Zeichenfolgen zuordnen, funktioniert die Variable nicht mehr in der definierten Weise. Das heißt, die Variable wird zu einer regulären Variablen, die eine Zeichenfolge enthält.
Informationen zur Syntax und Beispiele jeder Variablenart finden Sie im Handbuch Net.Data Reference.
Bedingungsvariablen ermöglichen Ihnen, einen bedingten Wert für eine Variable mit Hilfe einer Methode zu definieren, die einem IF-THEN-Konstrukt ähnlich ist. Beim Definieren einer Bedingungsvariablen können Sie zwei mögliche Variablenwerte angeben. Wenn die erste Variable, auf die Sie verweisen, existiert, erhält die Bedingungsvariable den ersten Wert. Ansonsten erhält die Bedingungsvariable den zweiten Wert. Die Syntax für eine Bedingungsvariable sieht wie folgt aus:
varA = varB ? "value_1" : "value_2"
Wenn varB definiert ist, gilt varA="value_1", andernfalls gilt varA="value_2". Dies entspricht der Verwendung eines IF-Blocks wie im folgenden Beispiel:
%IF (varB) varA = "value_1" %ELSE varA = "value_2" %ENDIF
In Listenvariablen finden Sie ein Beispiel für die Verwendung von Bedingungsvariablen mit Listenvariablen.
Sie können auf Umgebungsvariablen verweisen, die der Webserver dem Prozess bzw. Thread, der Ihre Net.Data-Anforderung verarbeitet, zur Verfügung stellt. Wenn auf die Variable ENVVAR verwiesen wird, gibt Net.Data den aktuellen Wert der Umgebungsvariablen mit dem gleichen Namen zurück.
Die Syntax zur Definition von Umgebungsvariablen sieht folgendermaßen aus:
%DEFINE var=%ENVVAR
Dabei ist var der Name der Umgebungsvariablen, die definiert wird.
Zum Beispiel kann die Variable SERVER_NAME als Umgebungsvariable definiert werden:
%DEFINE SERVER_NAME=%ENVVAR
Ein Verweis auf sie könnte wie folgt aussehen:
The server is $(SERVER_NAME)
Die Ausgabe sähe wie folgt aus:
The server is www.ibm.com
Weitere Informationen zur Anweisung ENVVAR finden Sie im Handbuch Net.Data Reference.
Sie können über einen Variablenverweis mit Hilfe ausführbarer Variablen andere Programme aufrufen.
Ausführbare Variablen werden in einem Net.Data-Makro mit Hilfe des Sprachkonstrukts EXEC im DEFINE-Block definiert. Weitere Informationen zum Sprachelement EXEC finden Sie im Kapitel über Sprachkonstrukte im Handbuch Net.Data Reference. Im folgenden Beispiel wird die Variable runit zur Ausführung des ausführbaren Programms testProg definiert:
%DEFINE runit=%EXEC "testProg"
Die Variable runit wird zu einer ausführbaren Variablen.
Net.Data führt das ausführbare Programm aus, wenn ein gültiger Variablenverweis in einem Net.Data-Makro erkannt wird. Zum Beispiel wird das Programm testProg ausgeführt, wenn in einem Net.Data-Makro ein gültiger Variablenverweis auf die Variable runit enthalten ist.
Eine einfache Methode besteht darin, auf eine ausführbare Variable aus einer anderen Variablendefinition heraus zu verweisen. Das folgende Beispiel illustriert diese Methode. Die Variable date wird als ausführbare Variable definiert. Anschließend wird dateRpt als Variablenverweis definiert, der die ausführbare Variable enthält.
%DEFINE date=%EXEC "date"
Für jedes Vorkommen des Variablenverweises $(date) im Net.Data-Makro sucht Net.Data nach dem ausführbaren Programm date. Wenn das Programm gefunden wird, zeigt Net.Data folgenden Wert an:
Today is Tue 11-07-1999
Wenn Net.Data eine ausführbare Variable in einem Makro feststellt, sucht Net.Data das angegebene ausführbare Programm nach folgender Methode:
Einschränkung: Setzen Sie eine ausführbare Variable nicht auf den Wert der Ausgabe des aufgerufenen ausführbaren Programms. Im vorangegangenen Beispiel ist der Wert der Variablen date gleich NULL. Wenn Sie diese Variable in einem Funktionsaufruf DTW_ASSIGN verwenden, um ihren Wert einer anderen Variablen zuzuordnen, ist der Wert der neuen Variablen nach der Zuordnung ebenfalls NULL. Der einzige Zweck einer ausführbaren Variablen besteht darin, das Programm aufzurufen, das sie definiert.
Außerdem können Sie Parameter an das auszuführende Programm übergeben, indem Sie diese bei der Variablendefinition mit dem Programmnamen angeben. Im folgenden Beispiel werden die Werte für distance und time an das Programm calcMPH übergeben.
%DEFINE mph=%EXEC "calcMPH $(distance) $(time)"
Sie können verdeckte Variablen verwenden, um den tatsächlichen Namen einer Variablen für Anwendungsbenutzer unsichtbar zu machen, die die Quelle Ihrer Webseite mit ihrem Web-Browser anzeigen. Eine verdeckte Variable wird wie folgt definiert:
%HTML(INPUT){ <form ...> <p>Select fields to view: shanghai<select name="field"> <option value="$$(name)"> Name <option value="$$(addr)"> Address ... </form> %} %DEFINE { name="customer.name" addr="customer.address" %} %FUNCTION(DTW_SQL) mySelect() { SELECT $(Field) FROM customer %} ...
Wenn ein Web-Browser das HTML-Formular anzeigt, werden $$(name) und $$(addr) durch $(name) bzw. $(addr) ersetzt, so dass die tatsächlichen Namen für Tabelle und Spalten im HTML-Formular nirgendwo vorkommen. Anwendungsbenutzer können nicht erkennen, dass die tatsächlichen Variablennamen verdeckt sind. Wenn der Benutzer das Formular übergibt, wird der Block HTML(REPORT) aufgerufen. Wenn @mySelect() den FUNCTION-Block aufruft, wird $(Field) in der SQL-Anweisung durch customer.name bzw. customer.addr in der SQL-Abfrage ersetzt.
Mit Listenvariablen können Sie eine begrenzte Wertefolge erstellen. Diese Variablenart ist besonders hilfreich beim Erstellen einer SQL-Abfrage mit mehreren Elementen, die in einigen WHERE- oder HAVING-Klauseln auftreten. Die Syntax für eine Listenvariable sieht wie folgt aus:
%LIST " value_separator " variable_name
Empfehlung: Leerzeichen sind signifikante Zeichen. Fügen Sie in den meisten Fällen ein Leerzeichen vor und nach dem Wertetrennzeichen ein. Die meisten Abfragen verwenden boolesche oder mathematische Operatoren (z. B. AND, OR oder >) als Wertetrennzeichen. Das folgende Beispiel zeigt die Verwendung von Bedingungsvariablen, verdeckten Variablen und Listenvariablen:
%HTML(INPUT){ <form method="post" action="/cgi-bin/db2www/example2.dtw/report"> <h2>Select one or more cities:</h2> <input type="checkbox" name="conditions" value="$$(cond1)" />Sao Paolo<br /> <input type="checkbox" name="conditions" value="$$(cond2)" />Seattle<br /> <input type="checkbox" name="conditions" value="$$(cond3)" />Shanghai<br /> <input type="submit" value="submit query" /> </form> %} %DEFINE{ DATABASE="custcity" %LIST " OR " conditions cond1="cond1='Sao Paolo'" cond2="cond2='Seattle'" cond3="cond3='Shanghai'" whereClause= ? "WHERE $(conditions)" %} %FUNCTION(DTW_SQL) mySelect() { SELECT name, city FROM citylist $(whereClause) %} %HTML(REPORT){ @mySelect() %}
Wenn im HTML-Formular keine Kästchen ausgewählt werden, ist conditions leer, so dass whereClause in der Abfrage ebenfalls leer ist. Andernfalls hat whereClause die durch OR getrennten Werte, die ausgewählt wurden. Wenn beispielsweise alle drei Städte ausgewählt werden, lautet die SQL-Abfrage:
SELECT name, city FROM citylist WHERE cond1='Sao Paolo' OR cond2='Seattle' OR cond3='Shanghai'
Im Folgenden wird Seattle ausgewählt, so dass die SQL-Abfrage wie folgt aussieht:
SELECT name, city FROM citylist WHERE cond1='Seattle'
Die Tabellenvariable definiert eine Sammlung zusammengehöriger Daten. Sie enthält eine Gruppe von Zeilen und Spalten einschließlich einer Zeile mit Spaltenüberschriften. Eine Tabelle wird in einem Net.Data-Makro wie in der folgenden Anweisung definiert:
%DEFINE myTable=%TABLE(30)
Die Zahl nach %TABLE gibt die maximale Anzahl der Zeilen an, die diese Tabellenvariable enthalten kann. Wenn Sie eine Tabelle ohne Zeilenbegrenzung angeben wollen, müssen Sie den Standardwert bzw. ALL angeben:
%DEFINE myTable2=%TABLE %DEFINE myTable3=%TABLE(ALL)
Eine Tabelle hat bei ihrer Definition null Zeilen und null Spalten. Die einzige Möglichkeit, eine Tabelle mit Werten zu füllen, besteht darin, sie als Parameter OUT oder INOUT an eine Funktion zu übergeben oder die in Net.Data integrierten Tabellenfunktionen zu verwenden. Die Sprachumgebung DTW_SQL fügt die Ergebnisse einer Anweisung SELECT automatisch in eine Tabelle ein.
Bei Nicht-Datenbanksprachumgebungen, wie zum Beispiel DTW_REXX oder DTW_PERL, ist die Sprachumgebung auch dafür verantwortlich, die Tabellenwerte zu setzen. Das Script bzw. das Programm der Sprachumgebung definiert die Tabellenwerte jedoch zellweise. Weitere Informationen dazu, wie Tabellenvariablen von Sprachumgebungen verwendet werden, finden Sie in Verwenden der Sprachumgebungen.
Sie können eine Tabelle zwischen Funktionen übergeben, indem Sie auf den Namen der Tabellenvariablen verweisen. Auf die einzelnen Elemente der Tabelle kann in einem REPORT-Block einer Funktion oder durch die Verwendung der Net.Data-Tabellenfunktionen verwiesen werden. Informationen zum Zugreifen auf einzelne Elemente in einer Tabelle innerhalb eines REPORT-Blocks finden Sie in Variablen zur Tabellenverarbeitung. Informationen zum Zugreifen auf einzelne Elemente einer Tabelle mit einer Tabellenfunktion finden Sie in Tabellenfunktionen. Tabellenvariablen werden in der Regel in einer SQL-Funktion mit Werten gefüllt und anschließend als Eingabe für einen Bericht entweder in der SQL-Funktion oder in einer anderen Funktion verwendet, nachdem sie als Parameter an diese Funktion übergeben wurden. Sie können Tabellenvariablen an eine beliebige Nicht-SQL-Funktion als Parameter IN, OUT oder INOUT übergeben. Tabellen können nur als Parameter OUT an SQL-Funktionen übergeben werden.
Wenn Sie auf eine Tabellenvariable verweisen, wird der Inhalt der Tabelle angezeigt und basierend auf der Einstellung der Variablen DTW_HTML_TABLE formatiert. Im folgenden Beispiel wird der Inhalt von myTable angezeigt:
%HTML (output) { $(myTable) }
Die Spaltennamen und Feldwerte in einer Tabelle werden als Feldgruppenelemente mit dem Ursprung 1 angegeben.
Dies sind durch Net.Data definierte Variablen, die zu folgenden Zwecken verwendet werden können:
Zusätzliche Variablen können entweder von Net.Data bestimmte vordefinierte Werte oder von Ihnen festgelegte Werte besitzen. Zum Beispiel bestimmt Net.Data den Wert der Variablen DTW_CURRENT_FILENAME nach der aktuellen Datei, die momentan verarbeitet wird, während Sie festlegen können, ob Net.Data zusätzliche, durch Tabulatoren und Zeilenvorschubzeichen verursachte Leerzeichen entfernen soll.
Vordefinierte Variablen werden innerhalb des Makros als Variablenverweise verwendet und liefern Informationen zum aktuellen Status von Dateien, Datumsangaben oder den Status eines Funktionsaufrufs. Sie könnten beispielsweise folgende Variable verwenden, um den Namen der aktuellen Datei abzurufen:
%REPORT { <p>This file is <i>$(DTW_CURRENT_FILENAME)</i>.</p> }
Änderbare Variablenwerte werden gewöhnlich mit Hilfe einer Anweisung DEFINE oder der Funktion @DTW_ASSIGN() festgelegt und geben Ihnen die Möglichkeit, die Verarbeitung des Makros durch Net.Data zu beeinflussen. Mit der folgenden Anweisung DEFINE könnten Sie zum Beispiel angeben, dass zusätzliche Leerzeichen (White Space) entfernt werden sollen:
%DEFINE DTW_REMOVE_WS="YES"
Net.Data definiert Variablen zur Tabellenverarbeitung, die in REPORT- und ROW-Blöcken verwendet werden können. Diese Variablen dienen zum Verweisen auf Werte aus SQL-Abfragen und Funktionsaufrufen.
Die Variablen zur Tabellenverarbeitung besitzen einen vordefinierten Wert, der von Net.Data festgelegt wird. Diese Variablen ermöglichen Ihnen, auf Werte aus den Ergebnismengen von SQL-Abfragen oder Funktionsaufrufen nach Spalte, Zeile oder Feld, die bzw. das verarbeitet wird, zu verweisen. Außerdem können Sie auf Informationen zur Anzahl der verarbeiteten Zeilen oder auf eine Liste aller Spaltennamen zugreifen.
Bei der Verarbeitung der Ergebnismenge aus einer SQL-Abfrage ordnet Net.Data zum Beispiel den Wert der Variablen Nn für jeden aktuellen Spaltennamen zu, so dass N1 der ersten Spalte, N2 der zweiten Spalte usw. zugeordnet wird. Sie können für Ihre Webseitenausgabe auf den aktuellen Spaltennamen verweisen.
Variablen zur Tabellenverarbeitung werden als Variablenverweise innerhalb des Makros verwendet. Zum Beispiel können Sie den Namen der aktuellen Spalte, die verarbeitet wird, folgendermaßen abrufen:
%REPORT { <p>Column 1 is <i>$(N1)</i>.</p> }
Variablen zur Tabellenverarbeitung liefern außerdem Informationen zu den Ergebnissen einer Abfrage. Sie können im Makro auf die Variable TOTAL_ROWS verweisen, um die Anzahl der von einer SQL-Abfrage zurückgegebenen Zeilen abzufragen, wie im folgenden Beispiel gezeigt:
Names found: $(TOTAL_ROWS)
Einige der Variablen zur Tabellenverarbeitung werden von anderen Variablen oder integrierten Funktionen beeinflusst. Zum Beispiel setzt die Variable TOTAL_ROWS voraus, dass die SQL-Sprachumgebungsvariable DTW_SET_TOTAL_ROWS aktiviert ist, so dass Net.Data den Wert von TOTAL_ROWS zuordnet, wenn die Ergebnisse aus einer SQL-Abfrage oder einem Funktionsaufruf verarbeitet werden, wie in folgendem Beispiel gezeigt wird:
%DEFINE DTW_SET_TOTAL_ROWS="YES" ... Names found: $(TOTAL_ROWS)
Net.Data zeigt Webseitenausgaben, die durch das Makro generiert werden, in einem Standardberichtsformat an. In einem HTML-Block zeigt das Standardberichtsformat eine Tabelle mit den Befehlen <pre> </pre> oder mit HTML-Tabellenbefehlen an. In einem XML-Block werden die Befehle <RowSet>, <Row> und <Column> verwendet. Sie können den Standardbericht außer Kraft setzen, indem Sie einen REPORT-Block mit Anweisungen zum Anzeigen der Ausgabe definieren oder eine der Berichtsvariablen verwenden, um die Generierung des Standardberichts zu verhindern.
Mit Berichtsvariablen können Sie die Anzeige der Webseitenausgabe und deren Verwendung für Standardberichte und Net.Data-Tabellen anpassen. Diese Variablen müssen vor ihrer Verwendung mit Hilfe einer DEFINE-Anweisung oder der Funktion @DTW_ASSIGN() definiert werden.
Die Berichtsvariablen definieren die Verwendung von Leerzeichen, überschreiben Standardberichtsformate, geben an, ob die Tabellenausgabe in HTML oder Monospace angezeigt werden soll, und bestimmen weitere Anzeigemerkmale. Sie können beispielsweise für DTW_HTML_TABLE "yes" angeben, und Net.Data generiert den Standardbericht mit HTML-Tabellenbefehlen und nicht als Tabelle mit unverschlüsseltem Textformat.
%DEFINE ALIGN="YES" ... <p>Your query was on these columns: $(NLIST)
Mit der Berichtsvariablen START_ROW_NUM können Sie festlegen, ab welcher Zeile die Ergebnisse einer Abfrage angezeigt werden sollen. Zum Beispiel gibt der folgende Variablenwert an, dass Net.Data die Ergebnisse einer Abfrage ab der dritten Zeile anzeigen soll:
%DEFINE START_ROW_NUM = "3"
Sie können außerdem festlegen, ob Net.Data HTML-Befehle für die Standardformatierung verwenden soll. Wenn der Wert der Variablen DTW_HTML_TABLE auf YES gesetzt ist, wird keine Tabelle mit formatiertem Text erstellt, sondern eine HTML-Tabelle.
%DEFINE DTW_HTML_TABLE="YES" %FUNCTION(DTW_SQL){ SELECT NAME, ADDRESS FROM $(qTable) %}
Diese Variablen werden mit Sprachumgebungen verwendet und beeinflussen die Verarbeitung einer Anforderung durch die Sprachumgebung.
Mit diesen Variablen können Sie Aufgaben wie das Herstellen von Verbindungen zu Datenbanken, das Bereitstellen von alternativem Text für Java-Applets, das Aktivieren von Sprachenunterstützung und das Feststellen der erfolgreichen Ausführung einer SQL-Anweisung durchführen.
Zum Beispiel können Sie mit der Variablen SQL_STATE auf den von der Datenbank zurückgegebenen SQLSTATE-Wert zugreifen bzw. diesen Wert anzeigen.
%FUNCTION (DTW_SQL) val1() { select * from customer %REPORT { ... %ROW { ... %} SQLSTATE=$(SQL_STATE) %}
Das folgende Beispiel zeigt, auf welche Datenbank zugegriffen werden soll.
%DEFINE DATABASE="CELDIAL"