Unabhängig von der von Ihnen gewählten Methode zum Aufrufen von Net.Data können Sie eine von zwei Anforderungsarten angeben.
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
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.
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:
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:
<a href="URL">any text</a>
<form method="method" ACTION="URL">any text</form>
Parameter:
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:
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.
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
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
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>
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
Die folgenden Beispiele zeigen die unterschiedlichen Möglichkeiten zum Aufrufen von Net.Data bei Verwendung der Direktanforderungsmethode.
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>
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>