Verwaltung und Programmierung

Arten von Aufrufanforderungen

Unabhängig von der von Ihnen gewählten Methode zum Aufrufen von Net.Data können Sie eine von zwei Anforderungsarten angeben.

Makroanforderung
Gibt an, dass Net.Data das angegebene Makro ausführt.

Direktanforderung
Gibt an, dass Net.Data eine SQL-Anweisung, gespeicherte Prozedur oder Funktion ausführt.

Webentwickler, die eine einzelne SQL-Abfrage schreiben oder eine einzelne Funktion wie eine gespeicherte DB2-Prozedur, ein REXX-Programm oder eine Perl-Funktion aufrufen wollen, können eine Direktanforderung an die Datenbank absetzen. Eine Direktanforderung hat keine komplexe Net.Data-Anwendungslogik, die ein Net.Data-Makro erfordert. Daher umgeht sie den Net.Data-Makroumwandler. Die Parameter der Direktanforderung werden zur Verarbeitung an die entsprechende Sprachumgebung übermittelt, um die Leistung zu steigern.

Abbildung 18 verdeutlicht die Unterschiede zwischen einer Makroanforderung und einer Direktanforderung. Eine Makroanforderung gibt immer ein Makro innerhalb der URL-Adresse für die Anforderung an und kann auch Formulardaten verwenden. Eine Direktanforderung gibt nie ein Makro innerhalb der URL-Adresse an, kann jedoch weiterhin Formulardaten verwenden.

Abbildung 18. Makroanforderung im Vergleich zu Direktanforderung

Makroanforderung im Vergleich zu Direktanforderung

Die Syntax zum Aufrufen von Net.Data hängt von der Net.Data-Konfiguration und der Art Ihrer Anforderung ab. Bei Makro- und Direktanforderungen wird Net.Data mit einer URL-Adresse aufgerufen. Die URL-Adresse kann direkt vom Benutzer eingegeben oder als HTML-Verbindung (Link) oder als HTML-Formular in die HTML-Seite codiert werden. Der Webserver ruft Net.Data über CGI, FastCGI oder eine der Webserver-APIs auf.

Geben Sie bei Makroanforderungen in der URL-Adresse den Namen des Net.Data-Makros und den Namen des im Net.Data-Makro auszuführenden HTML-Blocks an. Geben Sie bei Direktanforderungen in der URL-Adresse den Namen der Net.Data-Sprachumgebung, die SQL-Anweisung bzw. den Namen der Funktion und andere zusätzlich erforderliche Parameterwerte an. Sie geben diese Werte in einer von Net.Data definierten Syntax an.

Wenn Sie von CGI auf APAPI oder FastCGI migrieren, sollten Sie einige Punkte der REXX-Sprachumgebung bedenken. Weitere Informationen finden Sie in REXX-Sprachumgebung.

In den folgenden Abschnitten werden diese Aufrufanforderungen ausführlicher beschrieben:

Die Beispiele geben zwar die zu verwendende Syntax beim Aufrufen von Net.Data über CGI an, die Konzepte gelten jedoch für alle Schnittstellen, mit denen Net.Data aufgerufen werden kann. Informationen zur genauen Syntax, die für die einzelnen Schnittstellenarten erforderlich ist, finden Sie im entsprechenden Abschnitt.

Aufrufen von Net.Data mit einem Makro (Makroanforderung)

Ein Client-Browser ruft Net.Data durch Senden einer Anforderung in Form einer URL auf. In diesem Abschnitt wird gezeigt, wie Sie Net.Data durch Angabe eines Makros in der URL-Anforderung aufrufen können.

Die an Net.Data gesendete Anforderung hat das folgende Format:

http://server/Net.Data_invocation_path/filename/block[?name=val&...]

Parameter:

server
Gibt den Namen und Pfad des Webservers an. Wenn es sich bei dem Server um den lokalen Server handelt, kann der Servername übergangen und eine relative URL-Adresse verwendet werden.

Net.Data_invocation_path
Gibt Pfad und Dateinamen der ausführbaren Net.Data-Datei, Servlet-Klasse, DLL oder gemeinsam benutzten Bibliothek an. Zum Beispiel /cgi-bin/db2www/.

filename
Gibt den Namen der Net.Data-Makrodatei an. Net.Data sucht diesen Dateinamen und versucht, ihn mit den Pfadanweisungen abzugleichen, die in der Initialisierungspfadvariablen MACRO_PATH definiert sind. Weitere Informationen hierzu finden Sie in MACRO_PATH.

block
Gibt den Namen des HTML-Blocks im angegebenen Net.Data-Makro an.

?name=val&...
Gibt mindestens einen optionalen Parameter an, der an Net.Data weitergegeben wird.

Sie geben diese URL direkt im Browser ein. Sie können sie auch wie folgt in einer HTML-Verbindung (Link) angeben bzw. unter Verwendung eines der folgenden Formate erstellen:

Parameter:

method
Gibt die für das Formular verwendete HTML-Methode an.

URL
Gibt die URL-Adresse an, mit der das Net.Data-Makro ausgeführt wird und deren Parameter oben beschrieben sind.

Beispiele

Die folgenden Beispiele veranschaulichen die verschiedenen Methoden zum Aufrufen von Net.Data.

Beispiel 1: Aufrufen von Net.Data mit einer HTML-Verbindung (Link)

<a href="http://server/cgi-bin/db2www/myMacro.dtw/report">
.
.
.
</a>
 

Beispiel 2: Aufrufen von Net.Data mit einem Formular

<form method="post"
 action="http://server/cgi-bin/db2www/myMacro.dtw/report">
.
.
.
</form>

In den folgenden Abschnitten werden HTML-Verbindungen (Links) und -Formulare und der Aufruf von Net.Data mit diesen Mitteln beschrieben:

HTML-Verbindungen (Links)

Wenn Sie eine Webseite verfassen, können Sie eine HTML-Verbindung (Link) erstellen, die zur Ausführung eines HTML-Blocks führt. Wenn ein Benutzer über einen Browser den Text bzw. das Bild anklickt, der bzw. das als eine HTML-Verbindung (Link) definiert ist, führt Net.Data den HTML-Block im Makro aus.

Verwenden Sie den HTML-Befehl <a>, um eine HTML-Verbindung (Link) zu erstellen. Entscheiden Sie, welcher Text bzw. welche Grafik als Hyperlink zum Net.Data-Makro verwendet werden soll. Stellen Sie ihm bzw. ihr dann den Befehl <a> vor und den Befehl </a> nach. Geben Sie im Attribut HREF des Befehls <a> das Makro und den HTML-Block an.

Im folgenden Beispiel wird eine Verbindung (Link) gezeigt, die zur Ausführung einer SQL-Abfrage führt, wenn ein Benutzer den Text "List all monitors" auf einer Webseite auswählt.

<a href="http://server/netdata-cgi/db2www/listA.d2w/report?hdware=mon">
List all monitors</a>

Durch das Anklicken der Verbindung (Link) wird das Makro listA.dtw mit dem HTML-Block "report" aufgerufen. Siehe folgendes Beispiel:

%DEFINE DATABASE="MNS97"
 
 %FUNCTION(DTW_SQL) myQuery(){
SELECT MODNO, COST, DESCRIP FROM EQPTABLE
WHERE TYPE='$(hdware)'
   %REPORT{
<h3>Here is the list you requested</h3>
   %ROW{
<hr />
$(N1): $(V1), $(N2): $(V2)
<p>$(N3): $(V3)</p>
%}
%}
%}
 
%HTML (Report){
@myQuery()
%}

Diese Abfrage gibt eine Tabelle mit der Modellnummer (MODNO), dem Preis (COST) und einer Beschreibung (DESCRIP) für jeden Monitor zurück, der in der Tabelle EQPTABLE beschrieben ist. Der Wert von hdware in der SQL-Anweisung stammt aus der URL-Eingabe. Eine detaillierte Beschreibung der im ROW-Block verwendeten Variablen finden Sie im Handbuch Net.Data Reference.

HTML-Formulare

Sie können die Ausführung Ihrer Net.Data-Makros mit HTML-Formularen dynamisch anpassen. Formulare ermöglichen Benutzern die Angabe von Eingabewerten, die die Ausführung des Makros und den Inhalt der von Net.Data erstellten Webseite beeinflussen.

Das folgende Beispiel baut auf dem Beispiel zur Monitorliste aus HTML-Verbindungen (Links) auf, indem es Benutzern ermöglicht, in einem Browser mit Hilfe eines einfachen HTML-Formulars den Produkttyp auszuwählen, für den Informationen angezeigt werden sollen.

<h1>Hardware Query Form</h1>
<hr>                                                                    
<form method="post" action="/cgi-bin/db2www/listA.dtw/report">
<p>What type of hardware do you want to see?</p>
<ul>
<li><input type="radio" name="hdware" value="mon" checked /> Monitors</li>
<li><input type="radio" name="hdware" value="pnt" /> Pointing devices</li>
<li><input type="radio" name="hdware" value="prt" /> Printers</li>
<li><input type="radio" name="hdware" value="scn" /> Scanners</li>
</ul>
 
<input type="submit" value="submit" />
</form>
 

Nachdem der Benutzer im Browser seine Auswahl getroffen und den Knopf für die Übergabe angeklickt hat, verarbeitet der Webserver den Parameter ACTION des Befehls FORM, wodurch Net.Data aufgerufen wird. Dann führt Net.Data das Makro listA.dtw aus, das über einen HTML-Block mit dem Namen "report" (siehe oben) verfügt.

%DEFINE DATABASE="MNS97"
 
 %FUNCTION(DTW_SQL) myQuery(){
SELECT MODNO, COST, DESCRIP FROM EQPTABLE
WHERE TYPE='$(hdware)'
   %REPORT{
<h3>Here is the list you requested</h3>
   %ROW{
<hr />
$(N1): $(V1), $(N2): $(V2)
<p>$(N3): $(V3)</p>
%}
%}
%}
 
%HTML (Report){
@myQuery()
%}

Im obigen Beispiel stammt der Wert für hdware der SQL-Anweisung aus der HTML-Formulareingabe. Eine detaillierte Beschreibung der im ROW-Block verwendeten Variablen finden Sie im Handbuch Net.Data Reference.

Der Eingabetyp FILE wird von Net.Data auf besondere Weise verarbeitet. Mit diesem Eingabetyp können Benutzer eine Datei auf den Server hochladen, die dann von Net.Data oder einer anderen Anwendung auf dem Server weiter verarbeitet werden kann.

Net.Data führt keine Konvertierung an den hochgeladenen Dateien aus, sie werden als Binärdaten behandelt. Die hochgeladenen Dateien werden in dem in DTW_UPLOAD_DIR angegebenen Verzeichnis gespeichert. Dabei erhalten sie einen eindeutigen Namen, der anhand der folgenden Regeln bestimmt wird:

Syntax:

MacroFileName + '.' + FormVarName + '.' + UniqueIdentifier + '.' + FormFileName

MacroFileName
Der Name des Makros, das die Anforderung verarbeitet (das im Formular genannte Makro). Nur der Dateiname wird verwendet, nicht der vollständige Pfad.

FormVarName
Der Name der Variablen, die im Formular zur Angabe der Datei verwendet wird.

UniqueIdentifier
Eine Zeichenfolge, die die Eindeutigkeit sicherstellt.

Beispiel:

Definieren Sie zuerst DTW_UPLOAD_DIR in der Net.Data-Initialisierungsdatei:

DTW_UPLOAD_DIR /tmp/uploads

Erstellen Sie anschließend ein Formular, das ein Makro aufruft und mindestens einen Eingabebefehl des Typs file verwendet.

<form method="post" enctype="multipart/form-data"
      action="/netdatadev/form.dtw/report">
Name:  <input type="text" name="name" /><br />
Zip code:  <input type="text" name="zipno" /><br />
Resume:  <input type="file" name="resume" /><br />
  <input type="submit" />
</form>

Würde ein Benutzer das Formular mit Angabe der Datei myresume.txt übergeben, würde die Ergebnisdatei mit einem Namen auf den Server geschrieben, der etwa wie folgt aussieht:

/tmp/uploads/form.dtw.resume.20010108112341275-6245-021.myresume.txt

Aufrufen von Net.Data ohne Makro (Direktanforderung)

In diesem Abschnitt wird gezeigt, wie Sie Net.Data mit einer Direktanforderung aufrufen können. Bei Verwendung einer Direktanforderung geben Sie in der URL-Adresse nicht den Namen eines Makros an. Geben Sie anstelle dessen die Net.Data-Sprachumgebung, die SQL-Anweisung bzw. ein auszuführendes Programm und andere zusätzlich erforderliche Parameterwerte unter Verwendung einer von Net.Data definierten Syntax in der URL-Adresse an. Informationen zum Aktivieren und Inaktivieren von Direktanforderungen finden Sie in DTW_DIRECT_REQUEST: Variable zum Aktivieren der Direktanforderung.

Die SQL-Anweisung bzw. das Programm und andere angegebene Parameter werden zur Verarbeitung direkt an die bezeichnete Sprachumgebung übergeben. Direktanforderungen verbessern die Leistung, weil Net.Data kein Makro zu lesen und zu verarbeiten braucht. Die von Net.Data bereitgestellten Sprachumgebungen SQL, ODBC, Oracle, Java, SYSTEM, Perl und REXX unterstützen Direktanforderungen. Sie können Net.Data mit einer URL-Adresse, einem HTML-Formular oder einer HTML-Verbindung (Link) aufrufen.

Eine Direktanforderung ruft Net.Data durch Übergeben der Parameter in der Abfragezeichenfolge der URL-Adresse oder der Formulardaten auf. Das folgende Beispiel verdeutlicht den Kontext, in dem Sie eine Direktanforderung angeben.

<a href="http://server/cgi-bin/db2www/?direct_request">any text</a>

Dabei steht direct_request für die Direktanforderungssyntax. Die folgende HTML-Verbindung (Link) enthält zum Beispiel eine Direktanforderung:

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_PERL&FUNC=my_perl(hi)">
  any text</a>

Syntax für Direktanforderungen

Die Syntax für das Aufrufen von Net.Data mit einer Direktanforderung kann den Aufruf einer Datenbank- bzw. Nicht-Datenbanksprachumgebung enthalten.

Syntax

>>-?--+--------------------------------------------------------------+-- ----+-| Database language environment call |-----+->
      |                .-HTML--.                                     |       '-| Non-database language environment call |-'
      '-DTW_DOCUMENT=--+-XML---+---&--+---------------------------+--'
                                      '-STYLESHEET=--filename--&--'
 
>--------------------------------------------------------------><
 
Database language environment call
 
    .-------------------------------.
    V                               |
|------+-------------------------+--+--LANGENV =---------------->
       '-| Form data entry |--&--'
 
                          .-------------------------------.
                          V                               |
>-------dblangenv----&-------+-------------------------+--+----->
                             '-| Form data entry |--&--'
 
>-----+-SQL=--sql_stmt-------------------------------------+---->
      '-FUNC=--stored_proc_name--(--| Parameter list |--)--'
 
      .-------------------------------.
      V                               |
>--------+-------------------------+--+-------------------------|
         '-&--| Form data entry |--'
 
Formulardateneingabe (Form data entry)
 
|---DATABASE----+-----------------------+--=---VALUE------------|
                +-DB_CASE---------------+
                +-DTW_HTML_TABLE--------+
                +-LOGIN-----------------+
                +-PASSWORD--------------+
                +-RPT_MAX_ROWS----------+
                +-SHOWSQL---------------+
                +-START_ROW_NUM---------+
                '-user_defined_variable-'
 
Parameterliste (Parameter list)
 
    .-,-------------------------------------------------------------.
    V                                                               |
|-----+-IN--parm_type--+-parm_value--------+---------------------+--+->
      |                '-"--parm_value--"--'                     |
      +-OUT--parm_type--+-parm_name--+---------------------------+
      |                 '-parm_name--'                           |
      '-INOUT--parm_type--+-parm_name--+---+-parm_value--------+-'
                          '-parm_name--'   '-"--parm_value--"--'
 
>---------------------------------------------------------------|
 
Aufruf einer Nicht-Datenbanksprachumgebung (Non-databaselanguage environment call)
 
|---LANGENV=------lang_env----&---FUNC--=--program_name--------->
 
        .-,-----------------------.
        V                         |
>----(-----+-------------------+--+---)-------------------------|
           '-"--parm_value--"--'
 

Parameter

DTW_DOCUMENT
Gibt die Art des Dokuments an, das Net.Data als Ausgabe zurückgeben soll. Zulässige Werte sind XML und HTML. Dieser Parameter ist optional; wird er nicht angegeben, wird HTML angenommen.

DTW_STYLESHEET
Gibt die Formatvorlage an, die Net.Data zum Anzeigen von XML verwenden soll. Dieser Parameter ist optional und nur relevant, wenn DTW_DOCUMENT=XML.

stylesheet
Gibt den Dateinamen auf dem Server für die Formatvorlage an.

Database language environment call
Gibt eine Direktanforderung an Net.Data an, die eine Datenbanksprachumgebung aufruft.

Form data entry
Parameter, mit denen Sie die Einstellungen von SQL-Variablen angeben bzw. einfache HTML-Formatierung anfordern können. Ausführlichere Informationen zu diesen Variablen finden Sie im Handbuch Net.Data Reference im entsprechenden Kapitel über Variablen.

DATABASE
Gibt die Datenbank an, an die Net.Data die SQL-Anforderung übergeben soll. Dieser Parameter ist erforderlich.

DB_CASE
Gibt die Groß-/Kleinschreibung für SQL-Anweisungen an.

DTW_HTML_TABLE
Gibt an, ob Net.Data eine HTML-Tabelle oder eine vorformatierte Texttabelle zurückgeben soll.

DTW_DOCUMENT
Gibt an, ob Net.Data die Ergebnisse im XML- oder HTML-Format anzeigen soll. Zulässige Werte sind XML und HTML. HTML ist der Standardwert, wenn kein Schlüsselwort angegeben wird.

LOGIN
Gibt die Benutzer-ID für die Datenbank an.

PASSWORD
Gibt das Kennwort für die Datenbank an.

RPT_MAX_ROWS
Gibt die maximale Anzahl von Zeilen an, die eine Funktion im Bericht zurückgibt.

SHOWSQL
Gibt an, ob Net.Data die auszuführende SQL-Anweisung anzeigen oder verdecken soll.

START_ROW_NUM
Gibt die Nummer der Zeile an, bei der eine Funktion den Bericht beginnen soll.

user_defined_variable
Variablen, die an Net.Data übergeben werden und erforderliche Informationen bereitstellen oder das Verhalten von Net.Data beeinflussen. Benutzerdefinierte Variablen sind Variablen, die Sie selbst für Ihre Anwendungen definieren können.

VALUE
Gibt den Wert der Net.Data-Variablen an.

LANGENV
Gibt die Zielsprachumgebung für den Aufruf der SQL-Anweisung bzw. der gespeicherten Prozedur an. Wenn es sich bei der Sprachumgebung um eine der Datenbanksprachumgebungen handelt, muss der Datenbankname ebenfalls angegeben werden.

dblangenv
Der Name der Datenbanksprachumgebung:
  • DTW_SQL
  • DTW_ODBC
  • DTW_ORA

SQL
Gibt an, dass die Direktanforderung die Ausführung einer Inline-SQL-Anweisung angibt.

sql_stmt
Gibt eine Zeichenfolge an, die eine gültige SQL-Anweisung enthält, die mit dynamischem SQL ausgeführt werden kann.

FUNC
Gibt an, dass die Direktanforderung die Ausführung einer gespeicherten Prozedur angibt.

stored_proc_name
Gibt einen gültigen Namen für eine gespeicherte DB2-Prozedur an.

parm_type
Gibt eine gültige Parameterart für eine gespeicherte DB2-Prozedur an.

parm_name
Gibt einen gültigen Parameternamen an.

parm_value
Gibt einen gültigen Parameterwert für eine gespeicherte DB2-Prozedur an.

IN
Gibt an, dass Net.Data den Parameter zum Übergeben von Eingabedaten an die gespeicherte Prozedur verwenden muss.

INOUT
Gibt an, dass Net.Data den Parameter sowohl zum Übergeben von Eingabedaten an die gespeicherte Prozedur als auch zum Zurückgeben von Ausgabedaten aus der Sprachumgebung verwenden muss.

OUT
Gibt an, dass die Sprachumgebung den Parameter zum Zurückgeben von Ausgabedaten aus der gespeicherten Prozedur verwenden muss.

Non-database language environment call
Gibt eine Direktanforderung an Net.Data an, die eine Nicht-Datenbanksprachumgebung aufruft.

LANGENV
Gibt die Zielsprachumgebung für die Ausführung der Funktion an.

lang_env
Gibt den Namen der Nicht-Datenbanksprachumgebung an:
  • DTW_PERL
  • DTW_REXX
  • DTW_SYSTEM

FUNC
Gibt an, dass die Direktanforderung die Ausführung eines Programms angibt.

program_name
Gibt das Programm mit der auszuführenden Funktion an.

parm_value
Gibt einen gültigen Parameterwert für die Funktion an.

Beispiele für Direktanforderungen

Die folgenden Beispiele zeigen die unterschiedlichen Möglichkeiten zum Aufrufen von Net.Data bei Verwendung der Direktanforderungsmethode.

HTML-Verbindungen (Links)

In den folgenden Beispielen werden Direktanforderungen zum Aufrufen von Net.Data über Verbindungen (Links) verwendet.

Beispiel 1: Eine Verbindung (Link), die die Perl-Sprachumgebung sowie ein Perl-Script aufruft, das sich in der Pfadanweisung EXEC der Net.Data-Initialisierungsdatei befindet

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_PERL&FUNC=my_perl(hi)">
  any text</a>

Beispiel 2: Eine Verbindung (Link), die die Perl-Sprachumgebung wie im vorherigen Beispiel aufruft, jedoch eine Zeichenfolge mit URL-codierten Werten für die doppelten Anführungszeichen und die Leerzeichen übergibt

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_PERL&FUNC=my_perl
     (%22Hello+World%22)">any text</a>

Beispiel 3: Eine URL-Adresse, die zur Ausführung einer SQL-Abfrage mit Hilfe der SQL-Sprachumgebung führt

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_SQL&DATABASE=CELDIAL
 &SQL=select+*+from+customer">any text</a>

Beispiel 4: Eine URL-Adresse, die die REXX-Sprachumgebung und ein REXX-Programm aufruft und Parameter an das Programm übergibt

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_REXX&FUNC=myexec.cmd(parm1,parm2)"
     >any text</a>

Beispiel 5: Eine URL-Adresse, die eine gespeicherte Prozedur aufruft und Parameter an die SQL-Sprachumgebung übergibt

<a href="http://server/cgi-bin/db2www/?LANGENV=DTW_SQL&FUNC=MY_STORED_PROC
   (IN+CHAR(30)+Salaries)&DATABASE=CELDIAL">any text</a>
Hinweis:
Sie müssen bestimmte Zeichen, wie Leerzeichen und doppelte Anführungszeichen, innerhalb von URL-Adressen codieren. In diesem Beispiel müssen die doppelten Anführungszeichen bzw. Leerzeichen innerhalb des Parameterwerts als %22 bzw. als Pluszeichen (+) codiert werden. Wenn dieser Link von einem Makro generiert worden ist, können Sie die integrierte Funktion DTW_URLESCSEQ verwenden, um den gesamten Text zu codieren, der in einer URL-Adresse codiert sein muss. Weitere Informationen zur Funktion DTW_URLESCSEQ finden Sie im Handbuch Net.Data Reference.

HTML-Formulare

In den folgenden Beispielen werden Direktanforderungen zum Aufrufen von Net.Data über Formulare verwendet.

Beispiel: Ein HTML-Formular, das zur Ausführung einer SQL-Abfrage mit Hilfe der SQL-Sprachumgebung führt, die Verbindung zur Datenbank CELDIAL herstellt und eine Tabelle abfragt

<form method="post"
 action="http://server/cgi-bin/db2www/">
<input type=hidden name="LANGENV" value="dtw_sql" />
<input type=hidden name="database" value="celdial" />
 <input type=hidden name="SQL"
       value="select * from table1 where col1=$(inputname)" />
Enter Customer name:
<input type=text name="inputname" value="john" />
<input type=submit />
</form>


[ Seitenanfang | Vorherige Seite | Nächste Seite ]