Sascha Krüger, Jörg Seelmann-Eggebert

ABAP® Best Practices

Inhalt

Vorwort 11

1 Einleitung 13

1.1 An wen richtet sich dieses Buch? .................................................................. 13

1.2 Wie ist dieses Buch zu lesen? ........................................................................ 13
1.3 Wie kann ich mit diesem Buch praktisch arbeiten? ................................... 16
1.3.1 Systemvoraussetzungen .................................................................... 16
1.3.2 Beispielprogramme ............................................................................ 16
1.3.3 Übungsdaten ...................................................................................... 17
1.4 Syntaxkonventionen ........................................................................................ 19

2 Softwareentwicklung mit ABAP 21

2.1 Einleitung .......................................................................................................... 21

2.2 Objektorientiertes oder klassisches ABAP? ................................................ 22
2.2.1 Bessere Datenkapselung ................................................................... 23
2.2.2 Mehrfachinstanziierung .................................................................... 24
2.2.3 Bessere Wiederverwendbarkeit des Quelltextes ........................... 30
2.2.4 Separation von Schnittstelle und Implementierung ...................... 40
2.2.5 Unterstützung ereignisgesteuerter Programmierung .................... 45
2.2.6 Keine »schwarze Magie« durch den Verzicht auf implizite
Funktionalitäten ................................................................................. 47
2.2.7 Verbesserte Syntax- und Semantikregeln ....................................... 48
2.2.8 Einziger Weg zur Nutzung neuer ABAP-Technologien ................. 49
2.2.9 ABAP Objects – just do it! ................................................................ 50
2.3 (Nicht) Wiederverwendbare Komponenten ................................................ 53
2.3.1 Freigabestatus von Funktionsbausteinen und Klassen ................. 54
2.3.2 Handlungsempfehlung ...................................................................... 55
2.4 Entwicklungsrichtlinien in der ABAP-Welt .................................................. 59
2.4.1 Namenskonventionen ....................................................................... 60
2.4.2 Vermeidung von Literalen durch Verwendung
von Konstanten ................................................................................. 65
2.4.3 Dokumentation von funktionalen Einheiten ................................. 68
2.4.4 QS-Assessment .................................................................................. 69
2.5 Robuste Programme entwickeln ................................................................... 72
2.5.1 Defensive Programmierung .............................................................. 72
2.5.2 Ausnahmebehandlung ...................................................................... 73

Inhalt 5
 2.5.3 Klassenbasierte Ausnahmebehandlung ........................................... 81
2.5.4 Definition eigener Ausnahmen ........................................................ 85
2.5.5 Einbinden der traditionellen Ausnahmebehandlung in die
klassenbasierte Ausnahmebehandlung ........................................... 89
2.5.6 Historische Fehlerereignisse ............................................................. 92

3 Lösungskonzepte für die tägliche

Programmierarbeit mit ABAP 95

3.1 Dynamische und generische Programmierung ............................................ 95

3.1.1 Dynamische Adressierung von Feldnamen .................................... 96
3.1.2 Dynamische Adressierung von Tabellennamen ............................. 98
3.1.3 Dynamische Angabe von Feldlisten und Klauseln bei SELECT .... 101
3.1.4 Dynamische Erzeugung eines Datenobjekts beliebigen Typs ...... 105
3.1.5 Dynamische Adressierung von Strukturkomponenten ................. 108
3.1.6 Sichere Sortierung einer internen Tabelle dynamisch durch
den Benutzer erlauben ...................................................................... 110
3.1.7 Dynamischer Aufruf von internen Unterroutinen ......................... 114
3.1.8 Dynamischer Aufruf von externen Unterroutinen mit Zugriff
auf globale Felder des externen Programms .................................. 117
3.1.9 Dynamischer Aufruf von Funktionsbausteinen mit dynamischer
Parameterübergabe ........................................................................... 120
3.1.10 Dynamische Erzeugung von Klasseninstanzen und dynamischer
Methodenaufruf mit dynamischer Parameterübergabe ................ 126
3.1.11 Polymorphie über Interfaces ............................................................ 134
3.2 Generierung von Programmen ....................................................................... 140
3.2.1 Erzeugung transienter Programme .................................................. 141
3.2.2 Erzeugung persistenter Programme ................................................ 152
3.2.3 Performancevergleich ........................................................................ 156
3.3 Run-Time Type Identification ......................................................................... 158
3.3.1 Arbeitsweise mit RTTI-Klassen ......................................................... 159
3.3.2 Geschachtelte Strukturen generisch auslesen ................................ 161
3.3.3 Export eines beliebigen Datenbanktabelleninhalts mit
Überschriftenzeile .............................................................................. 165
3.4 SQL-Performance und effiziente Datenbankkommunikation ................... 169
3.4.1 Selektion der benötigten Felder ...................................................... 171
3.4.2 Vermeiden von SELECT...CHECK-Anweisungen ........................... 171
3.4.3 Aggregationsfunktionen .................................................................... 172
3.4.4 Lesen mehrerer Datenbanktabellen ................................................ 173
3.4.5 Update mehrerer Datensätze ........................................................... 174
3.4.6 Kopieren von Datenbanktabellen in interne Tabellen .................. 175
3.4.7 Abschalten der Änderungsprotokollierung für Tabellen ............... 177
3.5 Zeichenkettenverarbeitung ............................................................................. 182
3.5.1 Strings versus C-Felder ...................................................................... 184
3.5.2 Zerlegen eines Strings in gleich große Blöcke ................................ 186
3.5.3 Einlesen einer Textdatei in eine interne Tabelle
mit Zeilentyp STRING ....................................................................... 187
3.5.4 Einfügen von Zeichenketten ............................................................. 190

6 Inhalt
3.6 Datumsfelder .................................................................................................... 191
3.6.1 Berechnung der Differenz zwischen zwei Daten ........................... 192
3.6.2 Letzter Tag eines Monats .................................................................. 193
3.6.3 Anzahl der Schaltjahre zwischen zwei Jahren ................................ 194
3.6.4 Bestimmung des nächsten Arbeitstages ......................................... 195
3.6.5 Berechnung von Kalenderwochen und Wochentagen ................. 197

4 GUI- und Desktop-Entwicklung 201

4.1 GUI-Controls und das Control Framework .................................................. 201

4.1.1 GUI-Controls ...................................................................................... 202
4.1.2 Control Framework ........................................................................... 203
4.1.3 Einbinden eines GUI-Controls ......................................................... 204
4.1.4 Mehrere GUI-Controls einsetzen .................................................... 208
4.2 ALV-Grid-Control ............................................................................................. 211
4.2.1 Daten aus mehreren Quellen (mit eingeschränkter
Spaltenselektion) darstellen ............................................................. 211
4.2.2 Einfaches Drop-Down-Listenfeld im Grid darstellen .................... 219
4.2.3 Drop-Down-Listenfeld nur für bestimmte Zellen
im Grid darstellen .............................................................................. 226
4.2.4 Reaktion auf Hotspot-Clicks und Setzen eines Filters .................. 232
4.3 Frontend-Kommunikation .............................................................................. 240
4.3.1 Datenaustausch mit dem Clipboard ................................................ 242
4.3.2 Mit dem Dateisystem des Frontends arbeiten ............................... 244
4.3.3 Export eines beliebigen Tabelleninhalts in eine durch
Trennzeichen separierte Liste .......................................................... 250
4.3.4 Ausführen eines Programms auf dem Präsentationsserver .......... 255
4.3.5 Arbeiten mit der Windows-Registry ............................................... 258
4.3.6 Fortschrittsanzeige in der Statusleiste des SAP GUI ...................... 262
4.4 Dynpros und ABAP Objects ........................................................................... 264

5 Kommunikation mit der Außenwelt 275

5.1 Kommunikation mit dem Applikationsserver ............................................. 275

5.1.1 Interne Tabelle auf dem Applikationsserver speichern
und einlesen ....................................................................................... 276
5.1.2 Kommandos auf dem Applikationsserver ausführen .................... 281
5.1.3 Externe Kommandos ausführen ...................................................... 284
5.2 RFC ..................................................................................................................... 290
5.2.1 Erstellen eines externen RFC-Client-Programms ........................... 291
5.2.2 Externer RFC-Client mit dynamischer Tabellendefinition ............ 303
5.2.3 Erstellen eines externen RFC-Servers ............................................. 309
5.2.4 Externer RFC-Server als integrierte Applikation ............................ 315
5.3 FTP-Kommunikation ........................................................................................ 318
5.3.1 Kommunikation mit FTP-Servern .................................................... 319

Inhalt 7
 5.3.2 Ausführen von FTP-Kommandolisten zum Transfer
von Dateien ........................................................................................ 324
5.3.3 FTP-Transfer von Dateien in interne Tabellen ............................... 330
5.4 Desktop-Integration ........................................................................................ 334
5.4.1 COM-Klassen ..................................................................................... 334
5.4.2 COM-Klasse aufrufen ........................................................................ 336
5.4.3 Datenaustausch mit Word, Excel & Co. ......................................... 345

6 SAP GUI Scripting 375

6.1 Einleitung und Überblick ................................................................................ 375

6.1.1 Technologischer Hintergrund ........................................................... 376
6.1.2 Voraussetzungen für das GUI Scripting .......................................... 380
6.1.3 Aufzeichnen und Abspielen eines Scripts ....................................... 383
6.1.4 Konstanten für virtuelle Keys und Funktionstasten ...................... 390
6.2 Fortgeschrittene Scripting-Applikationen ................................................... 391
6.2.1 Überblick ............................................................................................. 391
6.2.2 Verbindung mit dem SAP GUI-Prozess herstellen ......................... 392
6.2.3 Verbindung mit dem SAP-System herstellen ................................. 395
6.2.4 Ermitteln einer bestimmten SAP-Session ....................................... 397
6.2.5 Anmelden am SAP-System per Script ............................................. 399
6.2.6 Abmelden vom SAP-System per Script ........................................... 401
6.2.7 Einsatz der Scripting-Support-Routinen ......................................... 403
6.2.8 Exportieren einer beliebigen Liste ................................................... 405

A Glossar 417

B Tabellen des Flugdatenmodells 425

C Konstanten für virtuelle

Funktionstasten-Codes 429

D ABAP-Systemfelder 433

E Nützliche Eingaben im OK-Code-Feld 439

E.1 Direkter Aufruf von Transaktionen (Modusverwaltung) ........................... 439

E.2 Batchinput ......................................................................................................... 440
E.3 ABAP-Debugging ............................................................................................. 440
E.4 Pufferkommandos ............................................................................................ 440

8 Inhalt
F Die Autoren 441

Index 443

Inhalt 9
Vorwort
Gäbe es eine letzte Wahrheit, dann ließe sie sich nicht beweisen. So viel-
deutig dieser Satz auch sein mag, eines ist sicher: Er gilt insbesondere für
den Bereich der Softwareentwicklung. Welcher der richtige, der beste, der
bessere Lösungsweg für ein gerade zu lösendes Entwurfs- oder Program-
mierproblem ist, lässt sich nur selten mit Gewissheit beantworten. Und
gerade bei Fragen rund um die Programmiersprache ABAP sind solche
Antworten deshalb besonders schwer zu finden, weil für viele Probleme
viele verschiedene Lösungswege angeboten werden, was zweifellos mit
der langen Historie und der Evolution der Sprache zusammenhängt.

Zahlreiche Fragen von ABAP-Entwicklern, denen wir im Laufe der Zeit

begegnet sind, Diskussionen in Internetforen und der eigene Drang zur
Erprobung neuer Sprachkonzepte haben uns daher dazu inspiriert, dieses
Buch zu schreiben - ein Buch, das man vielleicht am ehesten als »Koch-
buch« bezeichnen könnte, in dem Sie Rezepte für die unterschiedlichsten
Menüs finden. Menüs für viele Mahlzeiten, die Sie sehr gerne mögen,
aber noch nie zubereitet haben, und für andere Mahlzeiten, die bereits zu
Ihrem Kochrepertoire gehören, deren Variationen Ihnen jedoch neu sind.
Es ist ein Buch, in dem Sie für verschiedene Problemstellungen, die
immer wieder auftreten, typische und sauber entwickelte Lösungsansätze
finden. Abhängig von Ihrem Erfahrungsstand werden Sie beim Durchblät-
tern vermutlich auf eine ganze Reihe von Themen stoßen, die sofort Ihr
Interesse wecken. Andere Überschriften bzw. Lösungen werden Sie viel-
leicht vermissen.

In diesem Zusammenhang möchten wir Sie ermutigen, uns ein Feedback

zukommen zu lassen, welche Lösungskonzepte Sie sich zusätzlich vorstel-
len könnten oder wünschen würden. Sie sind auch herzlich dazu eingela-
den, eigene Lösungskonzepte für bestimmte Probleme beizusteuern und
in eventuelle Folgeauflagen dieses Buches einfließen zu lassen.

Wie immer im Leben gibt es auch beim Umfang eines Buches gewisse
Beschränkungen. Während der Erstellung des Manuskripts standen wir
ständig vor der Entscheidung, welche Lösungen bzw. Rezepte wir auf-
nehmen sollten und welche nicht. Letztendlich basiert der Inhalt natür-
lich auf einer subjektiven Auswahl, die wir aufgrund von Recherchen in
Internetforen und intensiven Gesprächen mit ABAP-Entwicklern, Exper-
ten und Anfängern getroffen haben. Dabei kam es uns nicht zuletzt auch
darauf an, ein Gleichgewicht zwischen dem herzustellen, was die SAP
empfiehlt, und dem, was in der Praxis tatsächlich gemacht wird. Sie wer-

Vorwort 11
 den darüber hinaus in diesem Buch Lösungen für ABAP-Probleme finden,
die gar nicht mit nativen ABAP-Mitteln gelöst werden sollten, weil es ein-
fach nicht der beste Weg ist.

Natürlich möchten wir uns bei all den Interviewpartnern und Inputliefe-
ranten ganz herzlich bedanken, die uns tatkräftig bei der Stoffsammlung
und Durchsicht des Manuskripts unterstützt haben. Ohne sie wäre dieses
Buch nie realisiert worden. Unser Dank gilt Thomas Davidson, Ralf Drum,
Horst Keller, Jürgen Kompa, Doreen Koselowski, Ralph Schnarkowski,
Daniela Schälchi, Paul Lewis Trip und ganz besonders Tobias Trapp. Darü-
ber hinaus danken wir auch Tomas Wehren und seinem Team von SAP
PRESS für die gute Zusammenarbeit. Besonderer Dank soll hier Florian
Zimniak zukommen, der mit geradezu unglaublicher Gelassenheit (und
effektivem Nachdruck) viele unserer terminlichen Schwierigkeiten aus-
gleichen konnte. Außerdem bedanken wir uns herzlich bei Stefan Proksch
für die tatkräftige Unterstützung im Endspurt der Manuskriptabgabe.

Sascha Krüger dankt ganz besonders seiner Frau Katja, die noch mehr als
sonst mit Zuspruch, Unterstützung, Kritik und ihrer wunderbaren Art,
Menschen zu inspirieren, dafür gesorgt hat, dass dieses Projekt zu einem
erfolgreichen Abschluss kommen konnte – und das mehr, als sich die
meisten vorstellen können.

Jörg Seelmann-Eggebert dankt ganz besonders seinen beiden Kindern

Anna und Jorge sowie seiner Frau Annette, die mit einem unglaublichen
Verständnis und einer fortwährenden Unterstützung einen erheblichen
Teil zur Fertigstellung des Manuskripts beigetragen haben – und das,
obwohl die Zeit für das gemeinsame Familienleben ohnehin schon knapp
bemessen war.

Solingen, im Januar 2005 Alfter, im Januar 2005

Sascha Krüger Jörg Seelmann-Eggebert

12 Vorwort
 5 Kommunikation mit der
Außenwelt
Die Integration von SAP-System und anderen Anwendungen
ist ein wesentlicher Bestandteil für die Abbildung durchgängi-
ger, automatisierter Prozesse. In diesem Kapitel stellen wir
eine Reihe von Fallbeispielen vor, deren zentrales Thema die
Kommunikation eines SAP-Systems mit anderen Anwen-
dungssystemen ist.

5.1 Kommunikation mit dem Applikationsserver

ABAP stellt Ihnen verschiedene Sprachelemente zur Verfügung, mit
denen Dateien bearbeitet werden können. Da dem SAP-System eine wie
in Abbildung 5.1 skizzierte Architektur zugrunde liegt, müssen hierbei – in
Abhängigkeit davon, wo die zu bearbeitenden Dateien physisch abgelegt
sind – zwei unterschiedliche Szenarien betrachtet werden.

왘 Arbeiten mit Dateien auf dem Präsentationsserver Speichern von

Um mit Dateien auf dem Präsentationsserver arbeiten zu können, wird Dateien

dem Anwender ab dem Release 4.6 die Klasse CL_GUI_FRONTEND_

SERVICES mit verschiedensten Methoden zur Verfügung gestellt. Für
vorhergehende Releases können die (mittlerweile veralteten) Funkti-
onsbausteine GUI_DOWNLOAD und GUI_UPLOAD genutzt werden.
왘 Arbeiten mit Dateien auf dem Applikationsserver
In ABAP wird eine Vielzahl von Anweisungen bereitgestellt, mit denen
Dateien auf dem Applikationsserver bearbeitet werden können. Die
folgenden Abschnitte beschreiben, wie Sie Daten anstatt in der Daten-
bank in Dateien speichern bzw. wieder daraus laden können.

Abbildung 5.1 R/3-Systemarchitektur

Kommunikation mit der Außenwelt 275

 Dieser Abschnitt beschäftigt sich mit der Verwaltung von Dateien auf
dem Applikationsserver. Die nutzbaren Sprachelemente von ABAP finden
Sie in Tabelle 5.1.

Befehl Bedeutung

OPEN DATASET Öffnen einer Datei zum Lesen bzw. zum Schreiben von Daten.
Es können sowohl Textdateien als auch Binärdateien behandelt
werden.

CLOSE DATASET Schließen einer Datei

TRANSFER Schreiben eines Datenobjektes in eine Datei

READ DATASET Lesen eines Datenobjektes aus einer Datei

GET DATASET Abfragen von Eigenschaften wie Dateiattribute bzw. Cursor-

position einer bereits geöffneten Datei

SET DATASET Ändern von Eigenschaften wie Dateiattribute bzw. Cursorposi-

tion einer bereits geöffneten Datei

DELETE DATASET Löschen einer Datei auf dem Applikationsserver

Tabelle 5.1 Sprachelemente von ABAP für die Verwaltung von Daten auf dem
Applikationsserver

5.1.1 Interne Tabelle auf dem Applikationsserver

speichern und einlesen
Aufgabenstellung
In diesem Abschnitt wird eine interne Tabelle in einer Datei auf dem
Applikationsserver gespeichert und anschließend wieder eingelesen.
Dabei werden sowohl die Ausgabe als auch die Eingabe in eigenen Rou-
tinen realisiert, da es sich hierbei um modularisierbare und wiederver-
wendbare Programmeinheiten handelt.

Vorgehensweise
왘 Geben Sie das Programm wie in Listing 5.1 dargestellt ein und führen
Sie es aus.
왘 Voraussetzung für eine korrekte Funktionsweise ist ein Applikations-
server, der mit dem Betriebssystem Windows arbeitet. Nutzen Sie ein
anderes Betriebssystem (beispielsweise UNIX) für den Applikationsser-
ver, so müssen Sie die Zeile

s_filename TYPE STRING VALUE 'C:\beispiel001.txt'.

276 Kommunikation mit der Außenwelt

 derart anpassen, dass ein für das genutzte Betriebssystem gültiger
Dateiname eingetragen ist.
In jedem Fall gilt es sicherzustellen, dass es sich bei dem angegebenen
Dateinamen um eine zugreifbare und beschreibbare Datei handelt.

Codebeispiel

*&------------------------------------------------*
*& Report Z_FILE_01 *
*&------------------------------------------------*

REPORT Z_FILE_01.

TYPES:
BEGIN OF t_line,
col_1 TYPE I,
col_2(10) TYPE C,
END OF t_line,

t_tab TYPE TABLE OF t_line.

DATA:
n_cnt TYPE I VALUE 0,
s_cnt(5) TYPE C,
str_line TYPE t_line,
tab_records TYPE t_tab,
s_filename TYPE STRING VALUE 'C:\beispiel001.txt'.

FIELD-SYMBOLS <fs> TYPE t_line.

START-OF-SELECTION.

* interne Tabelle fuellen

DO 10 TIMES.
n_cnt = n_cnt + 1.
str_line-col_1 = n_cnt.
s_cnt = n_cnt.
CONCATENATE 'Zeile ' s_cnt INTO str_line-col_2.
APPEND str_line TO tab_records.
ENDDO.

Kommunikation mit dem Applikationsserver 277

 * Schreiben der Tabelle in eine Datei
PERFORM table_to_file
USING
tab_records
s_filename.

* Lesen der Datei in eine Tabelle

PERFORM file_to_table
USING
tab_records
s_filename.

* Ausgabe der Tabelle

LOOP AT tab_records ASSIGNING <fs>.
WRITE: / <fs>-col_1, <fs>-col_2.
ENDLOOP.

*&--------------------------------*
*& FORMS
*&--------------------------------*

FORM table_to_file
USING
tab_records TYPE t_tab
s_filename TYPE STRING.

FIELD-SYMBOLS <fs> TYPE ANY.

* Datei oeffnen
OPEN DATASET s_filename FOR OUTPUT IN BINARY MODE.

* Tabelle in die Datei schreiben

LOOP AT tab_records ASSIGNING <fs>.
TRANSFER <fs> TO s_filename.
ENDLOOP.

* Datei schliessen
CLOSE DATASET s_filename.
ENDFORM.

278 Kommunikation mit der Außenwelt

FORM file_to_table
USING
tab_records TYPE t_tab
s_filename TYPE STRING.

DATA:
str_rec LIKE LINE OF tab_records.

CLEAR tab_records.
OPEN DATASET s_filename FOR INPUT IN BINARY MODE.
DO.
READ DATASET s_filename INTO str_rec.
IF SY-SUBRC <> 0.
EXIT.
ENDIF.
APPEND str_rec TO tab_records.
ENDDO.

CLOSE DATASET s_filename.

ENDFORM.
Listing 5.1 Dateien auf dem Applikationsserver

Erläuterung zur Lösung

Das in Listing 5.1 abgebildete Programm enthält vier durch entspre-
chende Kommentierung abgetrennte Programmteile:

왘 Initialisierung einer internen Tabelle

왘 Ausgabe der internen Tabelle über die Routine table_to_file in eine

Datei
왘 Einlesen der geschriebenen Datei in eine interne Tabelle, wobei die
Routine file_to_table genutzt wird
왘 Ausgabe der internen Tabelle

In Anbetracht dessen, dass die wesentlichen Schritte die Ein- bzw. Aus-
gabe von Daten in bzw. aus Dateien ist, werden wir nur die Routinen
file_to_table und table_to_file detailliert beschreiben.

Die Ausgabeanweisungen sind im Unterprogramm table_to_file Öffnen einer Datei

zusammengefasst. Als Parameter werden dabei nur die zu speichernde
interne Tabelle und ein auf dem Applikationsserver gültiger Dateiname
übergeben. Im ersten Schritt wird die Datei über die Anweisung

Kommunikation mit dem Applikationsserver 279

 OPEN DATASET s_filename FOR OUTPUT IN BINARY MODE.

geöffnet. In unserer Lösung haben wir uns für eine Binärdatei entschie-
den, da keine Notwendigkeit der Weiterverarbeitung besteht. Möchten
Sie aber beispielsweise die physische Datei auf dem Applikationsserver
weiter bearbeiten, können Sie mit der Option TEXT MODE eine unter dem
Betriebssystem des Applikationsservers lesbare Datei generieren lassen.

Im Anschluss traversieren wir die übergebene interne Tabelle und schrei-

ben jede Zeile mit

TRANSFER <fs> TO s_filename.

in die Datei. Adressiert wird die Ausgabedatei über den Dateinamen,

wobei bei dieser Angabe ein textuell identischer Name übergeben wer-
den muss. Würde beim Schreiben der Datensätze die Ausgabedatei bei-
spielsweise mit

'C:\<Unterverzeichnis>\..\beispiel001.txt'

angesprochen werden, wäre eine Exception die Folge.

Flache Strukturen1 können dabei mit einer TRANSFER-Anweisung ausge-

geben werden, eine komponentenweise Übertragung in die Datei ist
nicht notwendig. Über das Sprachelement

CLOSE DATASET

wird die Ausgabedatei anschließend wieder geschlossen.

Lesen aus einer Das zweite Unterprogramm file_to_table liest den Inhalt einer Datei
Datei und schreibt diesen in eine interne Tabelle. Auch hier werden als Parame-
ter der Name der Datei sowie eine interne Tabelle für die Aufnahme der
Daten genutzt. Da wir die über das Unterprogramm table_to_file
gespeicherte Datei erneut einlesen möchten, müssen wir die Datei auch
wieder als Binärdatei (Parameter IN BINARY MODE) öffnen2.

Das Einlesen der einzelnen Zeilen der internen Tabelle erfolgt mittels der
Anweisung

1 Allerdings ist es nicht möglich, auch interne Tabellen mit nur einer TRANSFER-
Anweisung auszugeben. Daher müssen wir den Weg über die zeilenweise Ausgabe
beschreiten.
2 Es werden keine Typinformationen der geschriebenen Datensätze gespeichert. Vor
diesem Hintergrund ist es natürlich möglich, Dateien in einem anderen Format ein-
zulesen als sie geschrieben wurden. So können z. B. Datensätze als Zeichenketten
(Typ C oder STRING) herausgeschrieben und anschließend in Hexadezimal-Darstel-
lung (Typ X) wieder eingelesen werden.

280 Kommunikation mit der Außenwelt

READ DATASET s_filename INTO str_rec.
Wir übergeben dabei ein Datenobjekt, das die gleiche Struktur besitzt
wie bei der Ausgabe. Über die Auswertung des Ergebniswertes sy-subrc
– der Rückgabewert 4 signalisiert das Ende der Datei – kann dann festge-
stellt werden, wann der Inhalt der Datei vollständig ausgelesen wurde.

Erweiterung zur Lösung

Die Schwachstelle der in Listing 5.1 vorgestellten Lösung liegt in der
Abhängigkeit vom jeweils genutzten Betriebssystem für den Applikations-
server. Mitunter kann es erforderlich sein, plattformunabhängige und
damit portable Lösungen zu entwickeln. Hierfür wird Ihnen von SAP das
Konzept der logischen Datei- und Pfadnamen an die Hand gegeben. Im
ABAP-Programm wird dabei mit einem logischen, plattformunabhängi-
gen Dateinamen gearbeitet.

Um nun diesen logischen Dateinamen zur Laufzeit auf den betriebssyste- Logische
mabhängigen, physischen Dateipfad abbilden zu können, wird Ihnen der Dateinamen

Funktionsbaustein FILE_GET_NAME zur Verfügung gestellt. Dieser liefert

zu einem logischen Dateinamen den korrespondierenden physischen
Dateinamen. Die ermittelte vollständige Dateibezeichnung setzt sich aus
dem gültigen3 physischen Dateipfad und dem physischem Dateinamen
zusammen, wobei Platzhalter, die erst zur Laufzeit aufgelöst werden, ein-
gesetzt werden können. Eine ausführliche Beschreibung können Sie der
Funktionsbaustein-Dokumentation von FILE_GET_NAME entnehmen.

Die vollständige Konfiguration und Pflege von plattformunabhängigen

Dateinamen können Sie mandantenübergreifend mit der Transaktion FILE
durchführen.

5.1.2 Kommandos auf dem Applikationsserver ausführen

Aufgabenstellung
In dieser Aufgabe soll der Inhalt eines Verzeichnisses auf dem Applikati- Arbeiten mit dem
onsserver ausgelesen und in einer internen Tabelle abgelegt werden. Als Applikations-
server
Zwischenschritt soll das Ergebnis in einer Datei auf dem Applikationsser-
ver gespeichert werden.

3 Die Gültigkeit bezieht sich auf das zur Laufzeit aktuelle Betriebssystem des Applika-
tionsservers.

Kommunikation mit dem Applikationsserver 281

 Vorgehensweise
왘 Geben Sie das in Listing 5.2 dargestellte Programm ein und führen Sie
es anschließend aus.
왘 Der abgebildete Programmcode basiert auf der Annahme, dass es sich
beim Betriebssystem des Applikationsservers um ein Windows-System
handelt. Wenn Sie eine Plattform auf Unix-Basis für Ihren Applikati-
onsserver nutzen, müssen Sie die Zeile

'c:\winnt\system32\cmd.exe /c dir /w c:\*.*'

durch das entsprechende Kommando (typischerweise /bin/ls) anpas-

sen. Außerdem müssen Sie den verwendeten Dateinamen betriebssys-
temabhängig gestalten. Hierzu muss die Programmzeile

s_filename TYPE STRING VALUE 'C:\BEISPIEL03.txt'

derart angepasst werden, dass eine gültige und zugreifbare Datei refe-
renziert wird.
왘 Der vorgestellte Lösungsansatz in Listing 5.2 funktioniert nur bei
Applikationsservern, die mit dem Betriebssystem Windows bzw. Unix
arbeiten.

Codebeispiel

*&-------------------------------------------------*
*& Report Z_FILE_02 *
*&-------------------------------------------------*

REPORT Z_FILE_02.

DATA:
str_line TYPE STRING,
tab_lines TYPE TABLE OF STRING,
s_filename TYPE STRING VALUE 'C:\BEISPIEL03.txt'.

START-OF-SELECTION.

* Kommando auf dem Applikationsserver ausfuehren

OPEN DATASET s_filename
FOR OUTPUT
FILTER
'c:\winnt\system32\cmd.exe /c dir /w c:\*.*'

282 Kommunikation mit der Außenwelt

 IN TEXT MODE
ENCODING DEFAULT.

* Datei schliessen
CLOSE DATASET s_filename.

* physische Datei oeffnen

OPEN DATASET s_filename
FOR INPUT
IN TEXT MODE
ENCODING DEFAULT.

* Inhalt lesen und speichern

DO.
READ DATASET s_filename INTO str_line.
IF SY-SUBRC <> 0.
EXIT.
ENDIF.
APPEND str_line TO tab_lines.

WRITE / str_line.
ENDDO.
Listing 5.2 Verzeichnis auf einem Windows-basierten Applikationsserver auslesen

Erläuterung zur Lösung

Unsere in Listing 5.2 vorgestellte Lösung arbeitet in zwei Phasen:

왘 In dem ersten Schritt speichern wir den Inhalt des gewünschten Ver-
zeichnisses in einer Datei auf dem Applikationsserver.
왘 Anschließend wird im folgenden Programmblock diese Datei eingele-
sen und in eine interne Tabelle kopiert.

Für das Ermitteln des Inhalts eines Verzeichnisses auf dem Applikations- Ausführen von
server nutzen wir das Sprachelement OPEN DATASET mit dem Zusatz FIL- Betriebssystem-
kommandos
TER. Diese Option erlaubt es, ein Betriebssystem-Kommando an den
Applikationsserver zu übertragen und dieses dann dort auszuführen. In
Abhängigkeit davon, ob die angesprochene Datei mit dem Zusatz FOR
INPUT bzw. FOR OUTPUT geöffnet wird, wird entweder der Inhalt der Datei
als Eingabe für das Kommando genutzt bzw. die Ausgabe des Komman-
dos in die Datei geschrieben. Hintergrund für diese Funktionsweise ist
eine Redirektion der Eingabe (stdin) bzw. der Ausgabe (stdout). Die fol-

Kommunikation mit dem Applikationsserver 283

 gende Übersicht verdeutlicht dieses Verhalten an Hand des Kommandos
sort.exe (bzw. das Kommando sort bei Unix-Betriebssystemen).

왘 OPEN DATASET sortbsp.txt FOR INPUT FILTER 'sort.exe'...

Das entsprechende Betriebssystemkommando, das letztendlich ausge-
führt wird, ist
sort.exe < sortbsp.txt
Das heißt, es wird die Datei gelesen und ihr Inhalt sortiert.
왘 OPEN DATASET sortbsp.txt FOR OUTPUT FILTER 'sort.exe'...
Bei diesem Aufruf4 lautet das korrespondierende Betriebssystemkom-
mando
sort.exe > sortbsp.txt
In diesem Fall wird das Ergebnis des sort-Befehls in die Datei
sortbsp.txt geschrieben.

Enthält der voll qualifizierte Pfad des Kommandos Leerzeichen, dann

muss der Befehl in doppelte Anführungsstriche gesetzt werden, zum Bei-
spiel wie folgt:

... FILTER '"C:\Program Files\...\excel.exe"'

Die Einschränkung dieses Lösungsweges liegt im Betriebssystem begrün-

det. Zum einen müssen Sie über Kenntnisse hinsichtlich des verwendeten
Betriebssystems Ihres Applikationsservers verfügen5, um ein korrektes
Betriebssystemkommando angeben zu können. Des Weiteren arbeitet
die FILTER-Option nur auf den Betriebssystemen Windows und Unix.

5.1.3 Externe Kommandos ausführen

Aufgabenstellung
Kommandos auf Die im vorangehenden Abschnitt beschriebene Lösung erlaubt es Ihnen,
dem Applikations- Kommandos auf dem Applikationsserver auszuführen und dabei eine
server ausführen
Redirektion der Eingabe bzw. Ausgabe in eine Datei vorzunehmen. Aller-
dings ist dieses Vorgehen auf Windows- und Unix-basierte Betriebs-
systeme beschränkt.

In der an dieser Stelle beschriebenen Aufgabenstellung soll von der kon-

kreten Betriebssystemplattform abstrahiert werden und eine allgemeine

4 Dieser Aufruf dient nur der Verdeutlichung und macht in dieser Form wenig Sinn,
da die Eingabe über die Konsole erfolgen müsste.
5 Es besteht die Möglichkeit, über das Systemfeld sy-opsys dynamisch, nämlich zur
Laufzeit des ABAP-Programms, das genutzte Betriebssystem zu bestimmen.

284 Kommunikation mit der Außenwelt

Lösung zum Ausführen von Betriebssystembefehlen auf dem Applikati-
onsserver entwickelt werden.

Vorgehensweise
왘 Um betriebssystemunabhängige Kommandos benutzen zu können,
bedienen wir uns des Konzepts der externen Betriebssystemkomman-
dos. Diese können über Transaktion SM69 verwaltet werden.
Um das in Listing 5.3 verwendete Betriebssystemkommando einzu-
richten, führen Sie die nachfolgend beschriebenen Schritte durch:
왘 Gehen Sie in das Menü Anzeigen externer Betriebssystemkom-
mandos (Transaktion SM69).
왘 Dort wählen Sie über das Menü Bearbeiten den Menüpunkt Anle-
gen bzw. F6. Gegebenenfalls muss zuvor in den Änderungsmodus
(Menü Kommandoliste • Anzeige <-> Ändern bzw. F5) umgeschal-
tet werden.
왘 Bei der jetzt erscheinenden Bildschirmmaske füllen Sie die Felder
wie Abbildung 5.2 gezeigt aus und speichern Ihren Eintrag. Das Feld
Parameter für Betriebssystem-Kommando bezieht sich in diesem
Zusammenhang auf das Betriebssystemkommando selbst. Mitunter
kann es nämlich erforderlich sein, als Kommando die zu nutzende
Shell (zum Beispiel cmd bei Windows bzw. sh oder Derivate im
Unix-Umfeld) und über die Parameter den erforderlichen Shell-
Befehl anzugeben. Die Steuerung der Parameter für den Betriebs-
systembefehl werden wir später dynamisch über das Programm vor-
nehmen.
Sie können übrigens, um Ihre Konfiguration zu verifizieren, externe
Betriebssystemkommandos auch testen. Nutzen Sie hierzu Transaktion
SM49 und wählen Sie dort die gewünschte Konfiguration aus. In der
erscheinenden Dialogmaske müssen Sie die zusätzlichen Parameter –
in unserem Beispiel den Namen des Rechners, den Sie über das ping-
Kommando ansprechen möchten – eingeben und erhalten als Ergebnis
die Ausgaben des Kommandos.
왘 Damit das Betriebssystemkommando auch ausgeführt werden kann,
wird das Programm sapxpg bzw. sapxpg.exe6 benötigt.

6 Dieses wird beispielsweise in der MiniWAS-Version nicht mitgeliefert und muss

daher nachinstalliert werden. Es kann als Servicedatei vom SAP Service Marketplace
heruntergeladen und über sapcar.exe in das MiniWAS-Verzeichnis eingespielt wer-
den. Sapcar.exe ist das Kompressions- bzw. Dekompressionsprogramm der SAP, das
ähnlich wie zip, tar usw. funktioniert.

Kommunikation mit dem Applikationsserver 285

 왘 Die Programmzeile

s_parameters LIKE sxpgcolist-parameters VALUE 'knb008'

muss so angepasst werden, dass ein existenter und erreichbarer Name
referenziert wird.
왘 Geben Sie das in Listing 5.3 abgebildete Programm ein und führen Sie
es anschließend aus.

Abbildung 5.2 Dialogmaske zum Anlegen eines externen Betriebssystemkommandos

Codebeispiel

*&-------------------------------------------------*
*& Report Z_FILE_03 *
*&-------------------------------------------------*

REPORT Z_FILE_03.

DATA:
s_command LIKE sxpgcolist-name VALUE 'ZWINPING',
s_parameters LIKE
sxpgcolist-parameters VALUE 'knb008',
c_status LIKE extcmdexex-status,
n_exitcode LIKE extcmdexex-exitcode,
tab_btcxpm LIKE TABLE OF btcxpm.

FIELD-SYMBOLS <fs> LIKE btcxpm.

286 Kommunikation mit der Außenwelt

START-OF-SELECTION.

REFRESH tab_btcxpm.
CLEAR tab_btcxpm.

* Ausfuehren des Programms ZWINPING

CALL FUNCTION 'SXPG_CALL_SYSTEM'
EXPORTING
COMMANDNAME = s_command
ADDITIONAL_PARAMETERS = s_parameters
IMPORTING
STATUS = c_status
EXITCODE = n_exitcode
TABLES
EXEC_PROTOCOL = tab_btcxpm
EXCEPTIONS
NO_PERMISSION = 1
COMMAND_NOT_FOUND = 2
PARAMETERS_TOO_LONG = 3
SECURITY_RISK = 4
WRONG_CHECK_CALL_INTERFACE = 5
PROGRAM_START_ERROR = 6
PROGRAM_TERMINATION_ERROR = 7
X_ERROR = 8
PARAMETER_EXPECTED = 9
TOO_MANY_PARAMETERS = 10
ILLEGAL_COMMAND = 11
OTHERS = 12.

* Ausgabe des Ergebnisses

IF sy-subrc <> 0.
WRITE: / 'Fehler bei der Ausfuehrung', sy-subrc.
ELSE.
WRITE: / 'Befehl ist erfolgreich ausgefuehrt.',
'Ergebnis ist:'.
WRITE: / 'Status: ', c_status,
' Exitcode: ', n_exitcode.

LOOP AT tab_btcxpm ASSIGNING <fs>.

WRITE: / <fs>-MESSAGE.

Kommunikation mit dem Applikationsserver 287

 ENDLOOP.
ENDIF.
Listing 5.3 Ausführen eines Kommandos auf dem Applikationsserver über den Funkti-
onsbaustein SXPG_CALL_SYSTEM

Erläuterung zur Lösung

Externe Zentraler Codeabschnitt des in Listing 5.3 dargestellten ABAP-Programms
Kommandos ist der Aufruf CALL FUNCTION 'SXPG_CALL_SYSTEM'. Der Funktionsbau-
ausführen
stein kapselt alle erforderlichen Schritte zum Ausführen eines Betriebssys-
tem-Kommandos. Als Eingabeparameter werden die folgenden Parame-
ter erwartet:

왘 COMMANDNAME
Dieser Parameter enthält Namen des externen Betriebssystemkom-
mandos, so wie zuvor in Transaktion SM69 konfiguriert.
왘 ADDITIONAL_PARAMETERS
Über diesen Parameter werden die erforderlichen Argumente des
Betriebssystem-Kommandos übergeben. Es handelt sich hierbei um
eine einzige Zeichenkette, die alle Argumente entsprechend der jewei-
ligen Syntax durch Leerzeichen getrennt umfasst.

Da der Funktionsbaustein SXPG_CALL_SYSTEM remotefähig ist, können

externe Betriebssystemkommandos auf jedem Rechner, auf dem ein SAP-
System läuft, gestartet werden – sofern entsprechende Berechtigungen
erteilt wurden.

Der Algorithmus, mit dessen Hilfe aus dem Namen des Betriebssystem-
kommandos der reale, physische Befehl bestimmt wird, verfährt nach den
folgenden Schritten:

왘 Wenn ein Betriebssystemkommando mit dem gleichen Betriebssys-

temtyp wie im Systemfeld sy-opsys existiert, wird diese Definition für
die Ausführung des Kommandos genutzt.
왘 Wird hierüber keine Definition gefunden, so wird die Recherche auf
die Syntaxgruppe7 des Betriebssystemtyps wie im Systemfeld sy-
opsys ausgedehnt.
왘 Bleibt auch diese Suche erfolglos, wird die Definition des Betriebssys-
temkommandos gesucht, das den Betriebssystemtyp ANYOS8 trägt.

7 Über die Syntaxgruppe werden jeweils die Betriebssysteme gruppiert, die für Datei-
namen, Befehle etc. die gleiche Syntax nutzen.
8 Definitionen mit dem Betriebssystemtyp ANYOS beschreiben Betriebssystemkom-
mandos, die in allen von SAP unterstützten Betriebssystemen ausführbar sind.

288 Kommunikation mit der Außenwelt

왘 Erst wenn alle vorherigen Schritte keine Definition finden, wird die
Ausnahme COMMAND_NOT_FOUND ausgelöst.

Ist die physische Befehlszeile ermittelt, wird der Befehl ausgeführt9. Des- Auswertung der
sen Ergebnis wird über zwei Rückgabeparameter sowie eine Tabelle über- Rückgabewerte

mittelt:

왘 STATUS
Dieser Wert liefert den Erfolg der Ausführung des externen Betriebs-
systemkommandos – das Ergebnis 'O' zeigt das erfolgreiche Starten
und Ausführen des Befehls an, über das Ergebnis 'E' wird mitgeteilt,
dass ein Fehlerfall aufgetreten ist.
왘 EXITCODE
Hierbei handelt es sich um einen numerischen Wert, der den Return-
code des jeweiligen Kommandos anzeigt.
왘 EXEC_PROTOCOL
Diese interne Tabelle gibt die Ausgaben der Kanäle stdout und stderr
des externen Betriebssystemkommandos an das aufrufende Programm
zurück.

In Abbildung 5.3 finden Sie die Ausgabe unseres Betriebssystemkomman-

dos ZWINPING. Um die verschiedenen Verhaltensweisen auszutesten, set-
zen Sie einfach in der Zeile

s_parameters LIKE sxpgcolist-parameters VALUE 'knb008'

den Wert auf einen Zielrechner, der nicht existent bzw. nicht erreichbar
ist.

Erweiterung zur Lösung

Im Zusammenhang der oben vorgestellten Lösung möchten wir Ihnen
einen weiteren Funktionsbaustein namens SXPG_COMMAND_EXECUTE
vorstellen, der für das Ausführen externer Betriebssystemkommandos
herangezogen werden kann.

9 Zusätzlich erfolgt noch eine Berechtigungsprüfung sowie die Feststellung, ob uner-

laubte bzw. »gefährliche« Sonderzeichen enthalten sind; z. B. sind es bei Windows-
basierten Betriebssystemen die Zeichen |, &, <, >, ( und ) sowie bei Unix die Zei-
chen |, &, ;, ^, \, <, > und `. Zu diesen Details verweisen wir an dieser Stelle auf die
Dokumentation der Funktionsbausteine.

Kommunikation mit dem Applikationsserver 289

 Abbildung 5.3 Bildschirmausgabe des externen Kommandos ZWINPING

Auch mit diesem Funktionsbaustein wird der Benutzer einer Berechti-

gungsprüfung für ein bestimmtes externes Betriebssystemkommando
unterzogen und bei positiven Ergebnis wird dieses Kommando anschlie-
ßend ausgeführt. Neben diversen Einstellmöglichkeiten bietet Ihnen die-
ser Funktionsbaustein allerdings zusätzlich die Möglichkeit, das Ziel-
system anzugeben. Damit entfällt die Einschränkung auf den
Applikationsserver des zugrunde liegenden SAP-Systems.

5.2 RFC
RFC steht für Remote Function Call und bezeichnet letztendlich die Mög-
lichkeit, eine Funktion aufrufen zu können, die unter einem anderen Sys-
tem ausgeführt wird. Für die SAP-Welt bedeutet diese Fähigkeit, Funkti-
onen von anderen SAP-Systemen und auch Nicht-SAP-Systemen nutzen
zu können.

Entfernte Für beide Fälle werden von SAP über RFC entsprechende Schnittstellen
Funktionen geliefert. Während der erste Fall, nämlich die Einbindung von Funktionen
aufrufen
anderer SAP-Systeme, derzeit durch das Sprachkonstrukt

CALL FUNCTION...DESTINATION
abgedeckt wird, werden für die Integration fremder Applikationen von
SAP eine Vielzahl von Programmierschnittstellen zur Verfügung gestellt.
Die zu integrierende Anwendung kann dabei entweder als Client
(Anwendung, die SAP-Funktionen nutzt) oder als Server (Anwendung,
die Funktionen für SAP bereitstellt) eingesetzt werden.

290 Kommunikation mit der Außenwelt

Index

A RfcReceive 300
ABAP 417 RfcSendData 315
ABAP Dictionary 417 CFW 417
ABAP Objects 417 Class Builder 418
ABAP Workbench 417 Class-ID 335
ABAP-Editor 417 Class-Pool 418
ABAP-Laufzeitumgebung 417 Client-Server-Architektur 418
ActiveX 336 Clipboard 242
Aggregationsfunktionen 172 Clipboardfunktionalitäten 240
Aktualparameter 417 CLSID 334
ALV-Grid-Control 201, 211 Cluster 418
Drop-Down-Listenfeld 219 COM-Objekte 334
Event-Handler 235 Aufruf von Methoden 343
Filter setzen 232 Erzeugen 343
Hotspot 232 Freigeben 343
mehrere Datenquellen 211 Word 364
Änderungsprotokollierung 177 COM-Technologie
Anweisungsblock 417 Excelintegration 355
Anwendungsprogramm 417 Control Framework 49, 201, 203
Applikationsserver 281
Applikationsserver 417 D
Attribut 417 Datei- und Verzeichnisoperationen
Ausnahmen 240
eigene 85 Dateinamen 281
Historie 92 Datei-Upload/Download 240
klassenbasiert 78 Datenbank 418
traditionell 74 Datenbank-Commit 418
Überblick 73 Datenbank-LUW 418
Datenbank-Rollback 418
B Datenbankschnittstelle 418
BAPI 417 Datenbankserver 418
Beispielprogramme 16 Datenbanksystem 418
Datenbanktabelle 418
C Datenelement 418
Cast 417 Datenkapselung 23
C-Funktion Datenobjekt 419
RfcAccept 316 Datenobjekts
RfcCall 300 dynamisch erzeugen 105
RfcCallReceive 300 Datentyp 419
RfcClose 298 Datumsfelder 191
RfcDispatch 316 Arbeitstag 195
RfcGetName 318 Differenzberechnung 192
RfcGetStructureInfoFlat 307 Kalenderwoche 197
RfcInstallStructure 305 Schaltjahre 194
RfcOpen 299 DCL 418

Index 443
 DDL 418 Funktionsbaustein
Destination 310 dynamischer Aufruf 120
SAPFTP 322 Freigabe 54
Dialogmodul 419 globale Schnittstelle 271
DML 418 Parametertabelle 123
Dokumentation 68 Wiederverwendung 54
Domäne 419 Funktionsbaustein 419
Drop-Down-Listenfeld 219, 226 Funktionsgruppe 419
Handlemechanismus 224, 231
Dynamik 96 G
Datenobjekt erzeugen 105 genh.exe 293, 301
Feldlisten 101 Globale Daten 419
Feldnamen 96 GUI Scripting
Funktionsbausteinaufruf 120 abmelden 401
Klasseninstanzen erzeugen 126 anmelden 399
Klauseln 101 langsame Netzwerkverbindungen
Methodenaufruf 126 381
Objekte erzeugen 126 Objekthierarchie 376
Performance 156 Objektmodell 376
Sortierung 110 Session ermitteln 397
Strukturkomponenten 108 Verbindung herstellen 395
Tabellennamen 98 Voraussetzungen 380
Dynpro 264 GUI Scriptings 375
Dynpro 419 GUI-Control 202
mehrfacher Einsatz 208
E GUI-Control 420
Elementarer Datentyp 419 GUIDs 334
Entwicklungsrichtlinien 59 GUI-Status 420
Ereignisblock 419
Ereignisse 45 H
Excel Hash-Tabelle 420
Objekt-Hierarchie 352
Excelmakro 353 I
IID 335
F Include-Programm 420
Feld 419 Indextabelle 420
Feldkatalog 216 Instanz 420
Automatischer Aufbau 216 Integration
Halbautomatischer Aufbau 217 Textverarbeitung Word 363
Manueller Aufbau 217 Interface 420
Feldsymbol 419 Interfacepool 420
Flache Struktur 419 Interfacereferenz 420
Formalparameter 419 Interfaces 40
Fortschrittsanzeige 262 klassisches ABAP 45
Fremdschlüssel 419 Interne Tabelle 420
FTP 318, 330
FTP-Server 319, 324 J
Function Builder 419 Join 420

444 Index
K O
Kapselung 420 Oberklasse 421
Klasse 420 Object Navigator 421
Klassenbibliothek 420 Objekt 421
Klassenreferenz 420 Objekt-ID 378
Kommandos ausführen 284 absolute 380
Komplexe Datentypen 420 Position extrahieren 412
Konstante 421 relative 380
Kopfzeile 421 Objektreferenz 421
Kurzdump 421 OCX-Komponente 366
OLE2_OBJECT 339
L Open SQL 422
Laufzeitfehler 421
LIBID 335 P
Liste 421 PAI 422
Listenexport 250 Parameter 422
Literal 421 Parameterschnittstelle 422
Literale PBO 422
Vermeidung 65 Polymorphie 134
Logische Datenbank 421 Polymorphie 422
Lokale Daten 421 Präsentationsserver 422
LUW 421 ProgID 335
LVC_T_FCAT 216 Programme
generieren 140
M persistente 152
Makro 375 transiente 141
Makro 421 Programmierung
Mandant 421 dynamisch 95
Mandantenbehandlung 421 generisch 95
Mehrfachinstanziierung 24 Prozedur 422
Menu Painter 421
Metadaten 421 Q
Methode 421 QS-Assessment 69
Methoden
dynamisch Aufrufen 126 R
Parametertabelle 130 Referenzvariable 422
Modularisierung 421 regedit.exe 339
Modulpool 421 Registry 258, 335
auslesen 258
N beschreiben 261
Namenskonventionen 60 Registry-Editor 335
Formroutinen 64 regsvr32.exe 339
Funktionsbausteine 64 Remote Function Call 290
Methoden 64 Report 422
Variablen 61 Repository 422
Native SQL 421 Repository-Objekt 422

Index 445
 RFC API 291 Struktur 423
Bibliotheken 298 Subquery 423
Headerdateien 298 sy-abcde 435
RFC_PARAMETER 295 sy-batch 434
RfcDispatch 314 sy-binpt 434
RfcEnvironment 299 sy-calld 434
RfcInstallStructure 301 sy-callr 437
RfcListen 317 sy-colno 436
RFC-Server 309, 313 sy-cpage 437
RTTI 158 sy-cprog 434
Running Object Table 393 sy-cucol 436
sy-curow 436
S sy-datar 436
SAP GUI 422 sy-datlo 433
sapftp 319 sy-datum 433
SAPFunctionsOCX 367, 372 sy-dayst 433
SAPLogonCtrl 367 sy-dbcnt 435
SAP-LUW 422 sy-dbname 434
SAPTabFactoryCtrl 367 sy-dbsys 433
Schlüssel 422 sy-dyngr 434
Screen Painter 423 sy-dynnr 434
Screenhandling sy-fdayw 433
kapseln 265 sy-fdpos 435
Script sy-host 433
Abspielen 384 sy-index 435
Aufzeichnen 383 sy-langu 433
Scripting API sy-ldbpg 434
findById 381, 387 sy-lilli 437
GuiApplication 376 sy-linct 436
GuiComponent 387 sy-linno 436
GuiConnection 377, 395 sy-linsz 436
GuiMainWindow 377 sy-lisel 437
GuiSession 377, 387, 398 sy-listi 437
Navigieren 388 sy-loopc 436
Objekt-ID 378 sy-lsind 437
sendVKey 386, 390 sy-macol 437
Scripting-Applikationen 391 sy-mandt 433
Script-Recorder 383 sy-marow 437
alternativer 388 sy-modno 433
Selektionsbild 423 sy-msgid 437
SQL-Performance 169 sy-msgno 437
Standard SQL 423 sy-msgty 437
Standarddialoge 240 sy-msgv1...sy-msgv4 437
Standardtabelle 423 sy-opsys 433
String sy-pagno 436
einlesen 187 sy-pfkey 436
zerlegen 186 sy-prdsn 437
String 423 sy-repid 434

446 Index
sy-saprl 433 T
sy-scols 436 TCP/IP-Modell 318
sy-slset 436 Textelement 423
sy-spono 437 Top-Include 423
sy-srows 436 Transaktion 423
sy-staco 437 Transaktionscode 423
sy-staro 437
sy-stepl 436 U
sy-subrc 435 Übungsdaten 17
sy-sysid 433 Unterklasse 423
sy-tabix 435 Unterprogramm 423
sy-tcode 434
sy-tfill 435 V
sy-timlo 433 Variable 423
sy-title 436 VBA-Makro 368
sy-tleng 435 Verarbeitungsblock 423
sy-toccu 435 Verarbeitungslogik 423
sy-tvar0...sy-tvar9 436 Vererbung 423
sy-tzone 434 View 423
sy-ucomm 436 virtuelle Keys 390
sy-uline 435
sy-uname 433 W
sy-uzeit 434 Wiederverwendbarkeit 30, 34
sy-vline 435 Word
sy-wtitl 436 Objekthierarchie 357
sy-zonlo 434 Word-Makros 365

Z
Zeichenketten
einfügen 190
Zeichenkettenverarbeitung 182

Index 447