Verwaltung und Programmierung

Net.Data-Makrovariablen

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:

Geltungsbereich von Kennungen

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:

Definieren von Variablen

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.

Verweisen auf Variablen

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.

Variablenarten

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

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.

Umgebungsvariablen

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.

Ausführbare Variablen

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:

  1. Es durchsucht die Verzeichnisse, die in der Net.Data-Initialisierungsdatei durch EXEC_PATH definiert sind. Nähere Informationen finden Sie in EXEC_PATH.
  2. Wenn Net.Data das Programm nicht findet, durchsucht das System die Verzeichnisse, die in der Umgebungsvariablen PATH bzw. in der Bibliothekenliste definiert sind. Wird das ausführbare Programm gefunden, führt Net.Data das Programm aus.

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)" 

Verdeckte Variablen

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:

  1. Definieren Sie eine Variable für jede Zeichenfolge, die Sie verdecken wollen, nach dem letzten Verweis auf die jeweilige Variable im HTML-Block. Variablen werden immer mit Hilfe des Sprachkonstrukts DEFINE definiert, nachdem sie im HTML-Block verwendet wurden, wie in folgendem Beispiel. Auf die Variablen $$(variable) wird zuerst verwiesen, anschließend werden sie definiert.
  2. Verwenden Sie in dem HTML-Block, in dem auf die Variablen verwiesen wird, für einen Variablenverweis zwei Dollarzeichen anstelle eines einzelnen Dollarzeichens. Zum Beispiel $$(X) anstelle von $(X).

       %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.

Listenvariablen

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'

Tabellenvariablen

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.

Zusätzliche Variablen

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"

Variablen zur Tabellenverarbeitung

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)

Berichtsvariablen

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)
%}

Sprachumgebungsvariablen

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"


[ Seitenanfang | Vorherige Seite | Nächste Seite ]