BCABA

ABAP Programmierung (BC-ABA)
Release 4.6C
HELP.BCABA
SAP AG
Copyright
Copyright 2001 SAP AG. Alle Rechte vorbehalten. Weitergabe und Vervielfltigung dieser Publikation oder von Teilen daraus sind, zu welchem Zweck und in welcher Form auch immer, ohne die ausdrckliche schriftliche Genehmigung durch SAP AG nicht gestattet. In dieser Publikation enthaltene Informationen knnen ohne vorherige Ankndigung gendert werden. Die von SAP AG oder deren Vertriebsfirmen angebotenen Software-Produkte knnen SoftwareKomponenten auch anderer Software-Hersteller enthalten. Microsoft , WINDOWS , NT , EXCEL , Word , PowerPoint und SQL Server sind eingetragene Marken der Microsoft Corporation. IBM , DB2 , OS/2 , DB2/6000 , Parallel Sysplex , MVS/ESA , RS/6000 , AIX , S/390 , AS/400 , OS/390 und OS/400 sind eingetragene Marken der IBM Corporation. ORACLE ist eine eingetragene Marke der ORACLE Corporation. INFORMIX -OnLine for SAP und Informix Dynamic Server Informix Software Incorporated.
TM
sind eingetragene Marken der
UNIX , X/Open , OSF/1 und Motif sind eingetragene Marken der Open Group. HTML, DHTML, XML, XHTML sind Marken oder eingetragene Marken des W3C , World Wide Web Consortium, Massachusetts Institute of Technology. JAVA ist eine eingetragene Marke der Sun Microsystems, Inc. JAVASCRIPT ist eine eingetragene Marke der Sun Microsystems, Inc., verwendet unter der Lizenz der von Netscape entwickelten und implementierten Technologie. SAP, SAP Logo, R/2, RIVA, R/3, ABAP, SAP ArchiveLink, SAP Business Workflow, WebFlow, SAP EarlyWatch, BAPI, SAPPHIRE, Management Cockpit, mySAP.com Logo und mySAP.com sind Marken oder eingetragene Marken der SAP AG in Deutschland und vielen anderen Lndern weltweit. Alle anderen Produkte sind Marken oder eingetragene Marken der jeweiligen Firmen.

April 2001
SAP AG
Symbole
Symbol Bedeutung Achtung Beispiel Hinweis Empfehlung Syntax
April 2001
SAP AG
Inhalt
ABAP Programmierung (BC-ABA) .................................................................. 17
ABAP Einfhrung ......................................................................................................................... 20 bersicht ber das R/3-Basis-System ....................................................................................... 21 Das Basis-System im Gesamtsystem ....................................................................................... 22 Applikationsserver ..................................................................................................................... 28 Workprozesse ........................................................................................................................... 33 bersicht ber die Komponenten von Anwendungsprogrammen ......................................... 39 Aufbau von Anwendungsprogrammen...................................................................................... 40 Mgliche Bildschirmbilder ......................................................................................................... 42 Aufbau von ABAP-Programmen ............................................................................................... 47 Verarbeitungsblcke in ABAP-Programmen............................................................................. 53 ABAP-Sprachelemente ............................................................................................................. 60 Logische Datenbanken und Contexte....................................................................................... 65 Speicherstrukturen eines ABAP-Programms............................................................................ 70 ABAP-Programme anlegen und ndern..................................................................................... 72 Programme im Object Navigator ffnen.................................................................................... 74 Programme mit dem ABAP-Editor ffnen ................................................................................. 77 Programme durch Vorwrtsnavigation ffnen........................................................................... 78 Programmeigenschaften pflegen .............................................................................................. 79 Programme editieren................................................................................................................. 82 ABAP Programmiersprache ........................................................................................................85 ABAP-Syntax ................................................................................................................................ 86 Typen und Objekte ....................................................................................................................... 90 Grundlegende Sprachelemente .................................................................................................. 93 Datentypen und Datenobjekte .................................................................................................. 94 Datentypen........................................................................................................................... 95 Definition von Datentypen............................................................................................. 100 Eingebaute ABAP-Typen......................................................................................... 101 Programmlokale Datentypen ................................................................................... 104 Datentypen im ABAP Dictionary.............................................................................. 109 Der TYPE-Zusatz.......................................................................................................... 117 Der LIKE-Zusatz ........................................................................................................... 121 Datenobjekte...................................................................................................................... 123 Literale .......................................................................................................................... 124 Textsymbole.................................................................................................................. 126 Variablen....................................................................................................................... 128 Konstanten.................................................................................................................... 134 Schnittstellen-Arbeitsbereiche ...................................................................................... 135 Vordefinierte Datenobjekte ........................................................................................... 137 Kompatibilitt...................................................................................................................... 138 Attribute von Datenobjekten bestimmen............................................................................ 140 Beispiele zu Datentypen und Objekten.............................................................................. 145 Daten verarbeiten.................................................................................................................... 148 Wertzuweisungen .............................................................................................................. 149
April 2001
SAP AG
Werte mit MOVE zuweisen........................................................................................... 150 Werte mit WRITE TO zuweisen.................................................................................... 153 Werte auf Initialwerte setzen ........................................................................................ 155 Numerische Operationen ................................................................................................... 156 Arithmetische Berechnungen........................................................................................ 157 Mathematische Funktionen........................................................................................... 161 Kaufmnnisches Rechnen............................................................................................ 164 Datums- und Zeitberechnungen ................................................................................... 165 Verarbeitung von Zeichenketten ........................................................................................ 167 Feldinhalte verschieben................................................................................................ 168 Feldinhalte ersetzen ..................................................................................................... 171 Gro-/Kleinschreibung oder Zeichen umsetzen ........................................................... 173 Konvertierung in ein sortierbares Format ..................................................................... 174 Zeichenketten berlagern ............................................................................................. 175 Zeichenketten suchen................................................................................................... 176 Lnge einer Zeichenkette ermitteln .............................................................................. 179 Feldinhalte verdichten................................................................................................... 180 Zeichenfolgen verketten ............................................................................................... 181 Zeichenketten zerlegen ................................................................................................ 182 Teile von Zeichenketten zuweisen ............................................................................... 183 Einzelbitverarbeitung in Hexadezimalfeldern..................................................................... 184 Bits setzen und lesen.................................................................................................... 185 Bitoperationen............................................................................................................... 187 Mengenoperationen mit Bitfolgen................................................................................. 189 Typkonvertierungen ........................................................................................................... 192 Konvertierungsregeln fr elementare Datentypen........................................................ 194 Konvertierungsregeln fr Referenzen........................................................................... 200 Konvertierungsregeln fr Strukturen............................................................................. 201 Konvertierungsregeln fr interne Tabellen ................................................................... 203 Ausrichtung von Datenobjekten.................................................................................... 204 Bearbeitung von Teilfeldern ............................................................................................... 205 Feldsymbole und Datenreferenzen......................................................................................... 208 Feldsymbole....................................................................................................................... 209 Feldsymbole deklarieren............................................................................................... 211 Zuweisung von Datenobjekten an Feldsymbole........................................................... 216 Grundformen der ASSIGN-Anweisung.................................................................... 217 Strukturen komponentenweise zuweisen................................................................ 223 Casting von Datenobjekten ..................................................................................... 224 Datenbereiche fr Feldsymbole .............................................................................. 230 Datenreferenzen ................................................................................................................232 Referenzvariable........................................................................................................... 233 Datenobjekte dynamisch erzeugen .............................................................................. 234 Referenzen auf Datenobjekte beschaffen .................................................................... 235 Datenreferenzen dereferenzieren................................................................................. 236 Beispiel zu Datenreferenzen......................................................................................... 237
April 2001
SAP AG
Logische Ausdrcke................................................................................................................ 238 Vergleiche zwischen verschiedenen Datentypen .............................................................. 239 Vergleiche zwischen Zeichenketten .................................................................................. 243 Vergleiche zwischen Bitfolgen ........................................................................................... 247 Intervallzugehrigkeit prfen.............................................................................................. 249 Initialwert prfen................................................................................................................. 250 Selektionskriterien prfen .................................................................................................. 251 Zuweisung zu einem Feldsymbol berprfen .................................................................... 252 Mehrere logische Ausdrcke verknpfen .......................................................................... 253 Programmablaufsteuerung...................................................................................................... 254 Bedingte Verzweigungen ................................................................................................... 256 Schleifen ............................................................................................................................ 259 Bearbeitung groer Datenmengen ........................................................................................... 264 Interne Tabellen ...................................................................................................................... 265 Interne Tabellen anlegen ................................................................................................... 268 Interne Tabellentypen ................................................................................................... 269 Interne Tabellenobjekte ................................................................................................ 273 Besonderheiten bei Standard-Tabellen ........................................................................ 275 Interne Tabellen bearbeiten ............................................................................................... 278 Operationen mit der gesamten internen Tabelle .......................................................... 279 Interne Tabellen zuweisen....................................................................................... 280 Interne Tabellen initialisieren................................................................................... 282 Interne Tabellen vergleichen ................................................................................... 284 Interne Tabellen sortieren........................................................................................ 286 Interne Tabellen als Schnittstellenparameter .......................................................... 291 Attribute interner Tabellen bestimmen .................................................................... 292 Operationen mit einzelnen Zeilen................................................................................. 293 Operationen fr alle Tabellenarten.......................................................................... 296 Tabellenzeilen einfgen ..................................................................................... 297 Tabellenzeilen verdichtet einfgen..................................................................... 300 Tabellenzeilen lesen........................................................................................... 302 Tabellenzeilen ndern ........................................................................................ 308 Tabellenzeilen lschen....................................................................................... 311 Tabellenzeilen in Schleifen bearbeiten .............................................................. 315 Operationen fr Index-Tabellen............................................................................... 323 Tabellenzeilen anhngen ................................................................................... 324 Tabellenzeilen ber den Index einfgen ............................................................ 328 Tabellenzeilen ber den Index lesen ................................................................. 331 Binre Suche bei Standard-Tabellen ................................................................. 332 Tabellenzeilen nach Zeichenketten durchsuchen.............................................. 333 Tabellenzeilen ber den Index ndern............................................................... 335 Tabellenzeilen ber den Index lschen.............................................................. 338 Indexangaben bei Schleifen............................................................................... 341 Zugriff ber Feldsymbole .............................................................................................. 343 Kopfzeilen als Arbeitsbereich ....................................................................................... 345
April 2001
SAP AG
Extrakte ................................................................................................................................... 347 Extrakt definieren ............................................................................................................... 348 Extrakt mit Daten fllen...................................................................................................... 350 Extrakte verarbeiten...........................................................................................................352 Extrakt auslesen ........................................................................................................... 353 Extrakt sortieren............................................................................................................ 356 Gruppenstufenverarbeitung .......................................................................................... 359 Anzahlen und Summen ermitteln ................................................................................. 363 Daten aufbereiten.................................................................................................................... 366 Beispiel fr aufbereitete Daten........................................................................................... 367 Daten beim Lesen aufbereiten........................................................................................... 369 Daten ber interne Tabellen aufbereiten ........................................................................... 371 Daten ber Extrakte aufbereiten ........................................................................................ 375 Externe Datenspeicherung........................................................................................................ 377 Datenobjekte als Cluster speichern ........................................................................................ 378 Daten-Cluster im ABAP-Memory ....................................................................................... 379 Datenobjekte im Memory speichern ............................................................................. 380 Datenobjekte aus dem Memory lesen .......................................................................... 381 Daten-Cluster im Memory lschen ............................................................................... 383 Daten-Cluster in Datenbanken .......................................................................................... 384 Cluster-Datenbanken.................................................................................................... 385 Struktur von Cluster-Datenbanken .......................................................................... 386 Beispiel einer Cluster-Datenbank............................................................................ 388 Datenobjekte in Cluster-Datenbanken speichern ......................................................... 390 Inhaltsverzeichnis eines Daten-Clusters erstellen........................................................ 392 Datenobjekte aus Cluster-Datenbanken lesen ............................................................. 394 Daten-Cluster in Cluster-Datenbanken lschen ........................................................... 396 Open SQL-Anweisungen und Cluster-Datenbanken.................................................... 398 Arbeiten mit Dateien................................................................................................................ 401 Arbeiten mit Dateien auf dem Anwendungsserver ............................................................ 402 Dateihandhabung in ABAP ........................................................................................... 403 ffnen einer Datei ................................................................................................... 404 Grundform der Anweisung OPEN DATASET .................................................... 405 ffnen einer Datei zum Lesen ........................................................................... 406 ffnen einer Datei zum Schreiben ..................................................................... 407 ffnen einer Datei fr das Schreiben an das Ende der Datei............................ 410 Binrmodus angeben ......................................................................................... 412 Textmodus angeben........................................................................................... 414 ffnen einer Datei an einer bestimmten Position .............................................. 416 Betriebssystemkommandos absetzen ............................................................... 418 Empfangen der Betriebssystemnachricht .......................................................... 419 Schlieen einer Datei .............................................................................................. 420 Lschen einer Datei................................................................................................. 421 Daten in Dateien schreiben .......................................................................................... 422 Daten aus Dateien lesen .............................................................................................. 424
April 2001
SAP AG
Automatische Prfungen bei Dateioperationen ............................................................ 426 Berechtigungsprfung fr bestimmte Programme und Dateien .............................. 427 Allgemeine Verprobung bei Dateizugriffen.............................................................. 430 Arbeiten mit Dateien auf dem Prsentationsserver ........................................................... 433 Daten mit Benutzerdialog auf den Prsentationsserver schreiben .............................. 434 Daten ohne Benutzerdialog auf den Prsentationsserver schreiben ........................... 437 Daten mit Benutzerdialog vom Prsentationsserver lesen........................................... 440 Daten ohne Benutzerdialog vom Prsentationsserver lesen ....................................... 443 Dateien auf dem Prsentationsserver berprfen........................................................ 446 Verwendung plattformunabhngiger Dateinamen ............................................................. 449 Syntaxgruppen pflegen................................................................................................. 450 Betriebssysteme Syntaxgruppen zuordnen.................................................................. 451 Logische Pfade anlegen und definieren ....................................................................... 453 Logische Dateinamen anlegen und definieren ............................................................. 455 Verwendung von logischen Dateien in ABAP-Programmen ........................................ 456 Modularisierungstechniken....................................................................................................... 459 Quelltext-Module ..................................................................................................................... 461 Makros ............................................................................................................................... 462 Include-Programme ........................................................................................................... 465 Prozeduren.............................................................................................................................. 467 Unterprogramme................................................................................................................ 469 Definition von Unterprogrammen.................................................................................. 470 Globale Daten des Rahmenprogramms.................................................................. 471 Lokale Daten des Unterprogramms ........................................................................ 473 Die Parameterschnittstelle....................................................................................... 477 Unterprogramme beenden ...................................................................................... 483 Aufruf von Unterprogrammen ....................................................................................... 485 Benennung des Unterprogramms ........................................................................... 486 Parameterbergabe an Unterprogramme ............................................................... 490 Beispiele zu Unterprogrammen............................................................................... 493 Gemeinsamer Datenbereich.................................................................................... 498 Funktionsbausteine............................................................................................................ 501 Funktionsgruppen ......................................................................................................... 502 Funktionsbausteine aufrufen ........................................................................................ 504 Funktionsbausteine anlegen......................................................................................... 510 Organisation von externen Prozeduraufrufen.................................................................... 516 Spezielle Techniken ................................................................................................................... 518 Abfangbare Laufzeitfehler ....................................................................................................... 519 Programmberprfungen................................................................................................... 520 Laufzeitfehler abfangen ..................................................................................................... 522 Berechtigungen berprfen..................................................................................................... 524 Berechtigungskonzept ....................................................................................................... 525 Berechtigungsprfungen.................................................................................................... 527 Laufzeitmessung von Programmsegmenten .......................................................................... 529 GET RUN TIME FIELD ...................................................................................................... 530 Laufzeitmessung von Datenbankzugriffen......................................................................... 532
April 2001
SAP AG
Programme dynamisch generieren und starten...................................................................... 534 Ein neues Programm dynamisch anlegen ......................................................................... 535 Bestehende Programme dynamisch ndern ..................................................................... 537 Dynamische angelegte Programme starten ...................................................................... 538 Temporre Unterprogramme anlegen und starten ............................................................ 541 ABAP Bildschirmbilder.............................................................................................................. 544 Dynpros ....................................................................................................................................... 545 Bestandteile von Dynpros .......................................................................................................547 Dynproattribute .................................................................................................................. 548 Bildschirmelemente............................................................................................................ 550 Dynprofelder....................................................................................................................... 552 Die Dynproablauflogik........................................................................................................ 555 Verarbeitung von Dynpros ...................................................................................................... 557 Benutzeraktionen auf Dynpros........................................................................................... 558 Ein- und Ausgabefelder verarbeiten ............................................................................. 560 Drucktasten auf dem Dynpro ........................................................................................ 565 Ankreuzfelder und Auswahlknpfe mit Funktionscodes............................................... 568 GUI-Status verwenden ................................................................................................. 571 Funktionscodes auswerten ........................................................................................... 580 Cursorposition bestimmen............................................................................................ 582 Aufruf von ABAP-Dialogmodulen....................................................................................... 585 Einfacher Modulaufruf................................................................................................... 587 Steuerung des Datentransports.................................................................................... 590 Unbedingter Modulaufruf .............................................................................................. 593 Bedingte Modulaufrufe.................................................................................................. 597 Eingabeberprfungen ...................................................................................................... 602 Automatische Eingabeberprfungen .......................................................................... 603 Eingabeberprfungen in der Ablauflogik .................................................................... 606 Eingabeberprfungen in Dialogmodulen .................................................................... 609 Feldhilfe, Eingabehilfe und Dropdown-Boxen.................................................................... 614 Feldhilfe ........................................................................................................................ 615 Eingabehilfe .................................................................................................................. 620 Eingabehilfen des ABAP Dictionary ........................................................................ 621 Eingabehilfen des Dynpro ....................................................................................... 627 Eingabehilfen in Dialogmodulen.............................................................................. 629 Dropdown-Boxen .......................................................................................................... 633 Bildschirmbilder dynamisch modifizieren........................................................................... 637 Attribute dynamisch setzen........................................................................................... 638 Die Funktion Feldauswahl ............................................................................................ 644 Cursorposition festlegen ............................................................................................... 656 Halten von Daten dynamisch ermglichen ................................................................... 658 Komplexe Bildschirmelemente................................................................................................ 660 Statusikonen ...................................................................................................................... 661 Kontextmens .................................................................................................................... 664 Subscreens ........................................................................................................................ 672
April 2001
SAP AG
TabStrips............................................................................................................................ 679 Custom Controls ................................................................................................................687 Table Controls.................................................................................................................... 695 Table Controls auf dem Bildschirmbild ......................................................................... 697 Table Controls in der Ablauflogik.................................................................................. 700 Table Controls im ABAP-Programm............................................................................. 702 Table Controls: Beispiel mit Blttern ............................................................................ 707 Table Controls: Beispiel mit Modifikationen.................................................................. 710 Anhang: Die Steploop-Technik ..................................................................................... 714 Selektionsbilder.......................................................................................................................... 720 Selektionsbilder und logische Datenbanken ........................................................................... 722 Selektionsbilder definieren ...................................................................................................... 725 Eingabefelder fr Einzelwerte definieren ........................................................................... 728 Grundform von Parametern .......................................................................................... 729 Dynamischer Dictionary-Bezug .................................................................................... 731 Vorschlagswerte fr Parameter .................................................................................... 733 SPA/GPA-Parameter als Vorschlagswerte................................................................... 734 Gro- und Kleinschreibung bei Parametern ................................................................. 735 Sichtbare Lnge verkleinern ......................................................................................... 736 Mufelder definieren..................................................................................................... 737 Suchhilfe fr Parameter ................................................................................................ 738 Eingabewerte berprfen ............................................................................................. 740 Ankreuzfelder definieren............................................................................................... 741 Auswahlknpfe definieren............................................................................................. 742 Eingabefelder ausblenden ............................................................................................ 744 Eingabefelder modifizieren ........................................................................................... 745 Komplexe Selektionen definieren ...................................................................................... 747 Selektionstabellen......................................................................................................... 748 Grundform von Selektionskriterien ............................................................................... 752 Selektionskriterien und logische Datenbanken ............................................................ 757 Vorschlagswerte fr Selektionskriterien ....................................................................... 759 Eingabe auf eine Zeile beschrnken ............................................................................ 761 Eingabe auf Einzelfelder beschrnken ......................................................................... 762 Weitere Zustze fr Selektionskriterien........................................................................ 763 Selektionsbilder aufbereiten............................................................................................... 764 Leerzeilen, Linien und Kommentare............................................................................. 765 Mehrere Elemente in einer Zeile .................................................................................. 768 Elementblcke .............................................................................................................. 770 Selektionsbilder aufrufen......................................................................................................... 772 Standardselektionsbilder aufrufen ..................................................................................... 773 Eigenstndige Selektionsbilder aufrufen ........................................................................... 775 Benutzeraktionen auf Selektionsbildern.................................................................................. 782 Drucktasten auf dem Selektionsbild .................................................................................. 783 Ankreuzfelder und Auswahlknpfe mit Funktionscodes .................................................... 785 Drucktasten in der Drucktastenleiste ................................................................................. 786
10
April 2001
SAP AG
Standard-GUI-Status ndern ............................................................................................. 788 Selektionsbildverarbeitung ...................................................................................................... 789 Grundform .......................................................................................................................... 792 PBO des Selektionsbilds.................................................................................................... 793 Einzelfeldverarbeitung ....................................................................................................... 795 Blockverarbeitung ..............................................................................................................796 Auswahlknpfe verarbeiten................................................................................................ 798 Mehrfachselektion verarbeiten........................................................................................... 800 Feldhilfe definieren............................................................................................................. 802 Eingabehilfe definieren ...................................................................................................... 804 Subscreens und TabStrips bei Selektionsbildern ................................................................... 807 Selektionsbilder als Subscreens ........................................................................................ 808 TabStrips auf Selektionsbildern ......................................................................................... 813 Subscreens auf Selektionsbildern ..................................................................................... 817 Selektionskriterien verwenden ................................................................................................ 819 Selektionstabellen in der WHERE-Klausel ........................................................................ 820 Selektionstabellen in logischen Ausdrcken...................................................................... 821 Selektionstabellen in GET-Ereignissen ............................................................................. 824 Listen ........................................................................................................................................... 827 Listenerstellung ....................................................................................................................... 829 Einfache Listen mit der WRITE-Anweisung erstellen ........................................................ 830 Die Anweisung WRITE ................................................................................................. 831 WRITE-Ausgabedaten auf der Liste positionieren ....................................................... 834 Aufbereitungsoptionen.................................................................................................. 836 Symbole und Ikonen auf der Liste ausgeben ............................................................... 839 Linien und Leerzeilen.................................................................................................... 840 Feldinhalt als Ankreuzfeld ausgeben............................................................................ 842 WRITE ber Anweisungsmuster verwenden................................................................ 843 Komplexe Listen erstellen.................................................................................................. 847 Die Standardliste .......................................................................................................... 848 Aufbau der Standardliste ......................................................................................... 849 GUI-Status der Standardliste................................................................................... 852 Listenaufbau selbst definieren ...................................................................................... 855 Seitenkopf gestalten ................................................................................................ 856 Listenbreite festlegen .............................................................................................. 858 Leerzeilen erzeugen ................................................................................................ 860 Seitenlnge festlegen .............................................................................................. 862 Seitenfu gestalten.................................................................................................. 864 Listen mit mehreren Seiten........................................................................................... 866 Seitenvorschbe programmieren ............................................................................ 867 Standardseitenkopf einzelner Seiten....................................................................... 870 Seitenlnge einzelner Seiten................................................................................... 872 Seitenbreite von Listenstufen .................................................................................. 876 In Listen blttern ........................................................................................................... 877 Fensterweise blttern .............................................................................................. 878
April 2001
11
SAP AG
Seitenweise blttern ................................................................................................ 880 Zu den Rndern der Liste blttern........................................................................... 882 Spaltenweise blttern .............................................................................................. 884 Bltterbaren Teil einer Seite festlegen .................................................................... 886 Listenseiten gestalten ................................................................................................... 890 Positionierung der Ausgabe .................................................................................... 891 Absolute Positionsangaben................................................................................ 892 Relative Positionsangaben................................................................................. 895 Formatierung der Ausgabe...................................................................................... 899 Die Anweisung FORMAT ................................................................................... 900 Farben in Listen ............................................................................................ 901 Felder eingabebereit machen ....................................................................... 907 Felder als Hotspot ausgeben ........................................................................ 909 Besondere Ausgabeformate .............................................................................. 911 Linien auf Listen ................................................................................................. 915 Benutzeraktionen auf Listen....................................................................................................923 Verzweigungslisten ............................................................................................................ 924 Dialogstatus fr Listen ....................................................................................................... 930 Kontextmens fr Listen .................................................................................................... 937 Listenereignisse im ABAP-Programm ............................................................................... 939 Listen in Dialogfenstern ..................................................................................................... 944 Datenbergabe von Listen an das Programm ................................................................... 946 Automatische Datenbergabe ...................................................................................... 947 Programmgesteuerte Datenbergabe .......................................................................... 950 Verzweigungslisten beeinflussen....................................................................................... 960 In Verzweigungslisten blttern...................................................................................... 961 Cursor vom Programm aus setzen............................................................................... 963 Listenzeilen modifizieren .............................................................................................. 967 Listen und Dynpros ................................................................................................................. 970 Aufruf von Listen aus der Dynproverarbeitung .................................................................. 971 Aufruf von Dynpros aus der Listenverarbeitung ................................................................ 975 Listen drucken und ablegen .................................................................................................... 979 Drucken einer Liste nach Ihrer Erstellung.......................................................................... 980 Drucken einer Liste whrend ihrer Erstellung.................................................................... 982 Druckparameter ............................................................................................................ 983 Ausfhren und Drucken ................................................................................................ 993 Programmgesteuertes Drucken.................................................................................... 996 Listen von aufgerufenen Programmen drucken ......................................................... 1000 Drucksteuerung................................................................................................................ 1003 Linken und oberen Rand festlegen............................................................................. 1004 Druckformat festlegen................................................................................................. 1006 Ablegen von Listen mit SAP ArchiveLink......................................................................... 1010 Nachrichten............................................................................................................................... 1016 Nachrichten verwalten........................................................................................................... 1017 Nachrichten senden .............................................................................................................. 1018 Nachrichtenverarbeitung ....................................................................................................... 1020
12
April 2001
SAP AG
Nachrichten ohne Bildschirmbezug ................................................................................. 1021 Nachrichten auf Dynpros ................................................................................................. 1022 Nachrichten auf Selektionsbildern ................................................................................... 1023 Nachrichten auf Listen ..................................................................................................... 1024 Nachrichten in Funktionsbausteinen und Methoden ....................................................... 1025 ABAP Programmausfhrung .................................................................................................. 1026 Verarbeitungsblcke definieren.............................................................................................. 1029 Ereignisblcke....................................................................................................................... 1030 Dialogmodule ........................................................................................................................ 1033 Direkte Ausfhrung - Reports ................................................................................................. 1034 Verknpfung mit logischen Datenbanken ............................................................................. 1036 Reporttransaktionen.............................................................................................................. 1040 Ereignisblcke in ausfhrbaren Programmen....................................................................... 1041 Beschreibung der Reporting-Ereignisse .......................................................................... 1042 INITIALIZATION ......................................................................................................... 1043 AT SELECTION-SCREEN.......................................................................................... 1046 START-OF-SELECTION ............................................................................................ 1047 GET............................................................................................................................. 1048 GET LATE.............................................................................................................. 1051 END-OF-SELECTION ................................................................................................ 1053 Ereignisblcke verlassen ................................................................................................. 1055 Ereignisblcke mit STOP verlassen ........................................................................... 1056 Ereignisblcke mit EXIT verlassen ............................................................................. 1059 Ereignisblcke mit CHECK verlassen ........................................................................ 1062 GET-Ereignisblcke mit REJECT verlassen .............................................................. 1067 Dialoggesteuerte Ausfhrung - Transaktionen..................................................................... 1070 bersicht zu Dialogprogrammen .......................................................................................... 1071 Eine Beispieltransaktion................................................................................................... 1075 Transaktionspflege................................................................................................................ 1083 Dialogtransaktion ............................................................................................................. 1084 Reporttransaktion............................................................................................................. 1085 Variantentransaktion ........................................................................................................ 1086 Parametertransaktion....................................................................................................... 1087 Dynprofolgen ......................................................................................................................... 1088 Statisches Folgedynpro ................................................................................................... 1090 Dynamisches Folgedynpro .............................................................................................. 1091 Dynpros programmgesteuert beenden ............................................................................ 1093 Dynprofolgen aufrufen ..................................................................................................... 1094 Modale Dialogfenster einbetten ....................................................................................... 1097 Beispieltransaktion fr Dynprofolgen ............................................................................... 1098 Programme aufrufen ................................................................................................................ 1103 Ausfhrbare Programme (Reports) aufrufen ........................................................................ 1105 Selektionsbild des aufgerufenen Programms fllen ........................................................ 1106 Listen des aufgerufenen Programms beeinflussen ......................................................... 1110 Aufgerufenes Programm programmgesteuert verlassen................................................. 1112 Transaktionen aufrufen .........................................................................................................1114
April 2001
13
SAP AG
Dynprofolgen als Module aufrufen ........................................................................................ 1115 Daten zwischen Programmen bergeben............................................................................. 1119 Einstiegsbilder ber SPA/GPA-Parameter fllen............................................................. 1121 ABAP Datenbankzugriffe.........................................................................................................1125 Datenbankzugriffe im R/3-System .......................................................................................... 1126 Open SQL .................................................................................................................................. 1129 Daten lesen ........................................................................................................................... 1131 Selektion definieren ......................................................................................................... 1133 Zielbereich angeben ........................................................................................................ 1140 Datenbanktabellen angeben ............................................................................................ 1147 Zeilen auswhlen ............................................................................................................. 1154 Zeilen gruppieren ............................................................................................................. 1162 Zeilengruppen auswhlen................................................................................................ 1165 Sortierreihenfolge angeben.............................................................................................. 1167 Subqueries ....................................................................................................................... 1170 Daten ber Cursor lesen.................................................................................................. 1174 Mgliche Sperrkonflikte.................................................................................................... 1180 Daten ndern......................................................................................................................... 1181 Tabellenzeilen einfgen ................................................................................................... 1182 Tabellenzeilen ndern...................................................................................................... 1185 Tabellenzeilen lschen .................................................................................................... 1188 Tabellenzeilen einfgen oder ndern .............................................................................. 1191 Datenbanknderungen festschreiben.............................................................................. 1193 Performance-Hinweise.......................................................................................................... 1194 Treffermenge klein halten ................................................................................................ 1198 bertragene Datenmenge klein halten ............................................................................ 1199 Zahl der Zugriffe klein halten ........................................................................................... 1201 Suchaufwand klein halten ................................................................................................ 1203 Datenbanklast klein halten............................................................................................... 1205 Native SQL ................................................................................................................................ 1208 Native SQL fr Oracle ........................................................................................................... 1213 Native SQL fr Informix......................................................................................................... 1230 Native SQL fr DB2 Common Server ................................................................................... 1246 Logische Datenbanken ............................................................................................................ 1257 Aufbau logischer Datenbanken ............................................................................................. 1260 Selektionsviews..................................................................................................................... 1267 Beispiel einer logischen Datenbank ...................................................................................... 1269 Logische Datenbanken verwenden....................................................................................... 1273 Verknpfung mit ausfhrbaren Programmen................................................................... 1276 Aufruf ber Funktionsbaustein ......................................................................................... 1280 Logische Datenbanken bearbeiten ....................................................................................... 1287 Logische Datenbank anlegen .......................................................................................... 1288 Struktur bearbeiten .......................................................................................................... 1290 Suchhilfen bearbeiten ...................................................................................................... 1292 Selektionen bearbeiten .................................................................................................... 1293 Datenbankprogramm bearbeiten ..................................................................................... 1297 Freie Abgrenzungen im Datenbankprogramm ........................................................... 1304
14
April 2001
SAP AG
Feldselektionen im Datenbankprogramm................................................................... 1309 Suchhilfen im Datenbankprogramm ........................................................................... 1312 Eigenstndiger Aufruf und Datenbankprogramm ....................................................... 1316 Weitere Komponenten bearbeiten ................................................................................... 1317 Performanceverbesserungen........................................................................................... 1318 Arbeiten mit Contexten............................................................................................................ 1320 Was ist ein Context? ............................................................................................................. 1321 Der Context Builder in der Workbench ................................................................................. 1323 Contexte anlegen und pflegen ......................................................................................... 1324 Tabellen als Module.................................................................................................... 1325 Funktionsbausteine als Module .................................................................................. 1328 Contexte als Module ................................................................................................... 1331 Contexte testen................................................................................................................1334 Contexte puffern .............................................................................................................. 1336 Felder ............................................................................................................................... 1339 Module ............................................................................................................................. 1341 Schnittstellen.................................................................................................................... 1343 Contexte in ABAP-Programmen verwenden......................................................................... 1344 Contexte suchen und anzeigen ....................................................................................... 1345 Context-Instanzen anlegen .............................................................................................. 1347 Context-Instanzen mit Schlsselwerten versorgen.......................................................... 1348 Daten von Context-Instanzen abfragen ........................................................................... 1349 Nachrichtenbehandlung in Contexten.............................................................................. 1351 Nachrichtenbehandlung in Tabellen-Modulen ............................................................ 1352 Nachrichtenbehandlung in Funktionsbaustein-Modulen ............................................ 1355 Tips zum Arbeiten mit Contexten .......................................................................................... 1358 SAP-Transaktionskonzept....................................................................................................... 1359 Transaktionen und Logical Units of Work ............................................................................. 1360 Datenbank-LUW .............................................................................................................. 1361 SAP-LUW......................................................................................................................... 1364 SAP-Transaktionen.......................................................................................................... 1368 Das R/3-Sperrkonzept...........................................................................................................1369 Beispielprogramm fr SAP-Sperren ................................................................................ 1373 Techniken der Verbuchung ................................................................................................... 1376 Asynchron verbuchen ...................................................................................................... 1377 Asynchron in Abschnitten verbuchen .............................................................................. 1380 Synchron verbuchen ........................................................................................................ 1381 Lokal verbuchen............................................................................................................... 1382 Verbuchungsfunktionsbausteine anlegen ............................................................................. 1383 Verbuchungsfunktionsbausteine aufrufen............................................................................. 1384 Verbuchungsfunktionsbausteine direkt aufrufen ............................................................. 1385 Aufrufe in einem Unterprogramm aufnehmen ................................................................. 1386 Spezielle berlegungen zu LUWs ........................................................................................ 1387 Transaktionen, die Verbuchungsfunktionsbausteine aufrufen......................................... 1388 Dialogbausteine, die Verbuchungsfunktionsbausteine aufrufen...................................... 1389 Fehlerbehandlung bei gebndelten Aktualisierungen........................................................... 1390 ABAP Objects ........................................................................................................................... 1392
April 2001
15
SAP AG
Was ist Objektorientierung? ................................................................................................... 1393 Was bedeutet ABAP Objects? ................................................................................................ 1397 Von Funktionsgruppen zu Objekten ...................................................................................... 1398 Beispiel zu Instanzen von Funktionsgruppen ....................................................................... 1401 Klassen...................................................................................................................................... 1403 bersichtsgrafik zu Klassen.................................................................................................. 1408 Einfhrendes Beispiel zu Klassen......................................................................................... 1409 Behandlung von Objekten....................................................................................................... 1410 bersichtsgrafik zu Objekten ................................................................................................ 1414 Einfhrendes Beispiel zu Objekten ....................................................................................... 1415 Methoden deklarieren und aufrufen ....................................................................................... 1416 Beispiel zu Methoden in ABAP Objects ................................................................................ 1421 Vererbung.................................................................................................................................. 1433 bersichtsgrafiken zur Vererbung......................................................................................... 1438 Einfhrendes Beispiel zur Vererbung ................................................................................... 1441 Interfaces................................................................................................................................... 1443 bersichtsgrafiken zu Interfaces........................................................................................... 1449 Einfhrendes Beispiel zu Interfaces...................................................................................... 1450 Ereignisse auslsen und behandeln ...................................................................................... 1452 bersichtsgrafik zu Ereignissen............................................................................................ 1455 Einfhrendes Beispiel zu Ereignissen................................................................................... 1458 Komplexes Beispiel zu Ereignissen ...................................................................................... 1460 Class- und Interface-Pools ...................................................................................................... 1466 Anhang ...................................................................................................................................... 1469 Programme, Bildschirmbilder, Verarbeitungsblcke ........................................................... 1470 Programmeinleitende Anweisungen ...................................................................................... 1474 bersicht ber ABAP-Aufrufe................................................................................................. 1476 Kontext der Aufrufe ............................................................................................................... 1477 Interne Aufrufe ................................................................................................................. 1478 Externe Prozeduraufrufe.................................................................................................. 1480 Externe Programmaufrufe................................................................................................ 1482 Aufrufbare Einheiten ............................................................................................................. 1484 ABAP-Programme ........................................................................................................... 1485 Prozeduren....................................................................................................................... 1487 Dynpros und Dynprofolgen .............................................................................................. 1489 bersicht ber alle ABAP-Anweisungen ............................................................................... 1492 ABAP-Systemfelder ................................................................................................................. 1556 ABAP-Glossar........................................................................................................................... 1580 Syntaxkonventionen ................................................................................................................ 1599
16
April 2001
SAP AG
ABAP Programmierung (BC-ABA) ABAP Programmierung (BC-ABA)

Diese Dokumentation beschreibt die Programmierung von Anwendungsprogrammen in der dreistufigen Client-Server-Architektur des R/3-Systems.
Prsentation
SAP GUI
SAP GUI
SAP GUI
SAP GUI
Applikation
ABAP ABAP
Datenbank
RDBMS
R/3-Anwendungsprogramme werden in der Programmiersprache ABAP erstellt und laufen in der Anwendungsschicht des R/3-Systems. ABAP-Programme kommunizieren mit dem Datenbank-Management-System der zentralen relationalen Datenbank (RDBMS) und mit der graphischen Benutzerschnittstelle (SAP GUI) der Prsentationsschicht.
Inhalt
Die Dokumentation ist in fnf Abschnitte unterteilt: ABAP Einfhrung [Seite 20] Hier werden die Grundlagen der Anwendungsprogrammierung in R/3 dargestellt, die fr das Verstndnis der ABAP-Programmierung unerllich sind. Nach einer bersicht ber das R/3-Basis System werden die wesentlichen Merkmale von Anwendungsprogrammen und der Programmiersprache ABAP vorgestellt. Schlielich wird in einer Kurzeinfhrung gezeigt, wie Anwendungsprogramme in der ABAP Workbench angelegt werden. ABAP Programmiersprache [Seite 85] Hier wird auf die Anweisungen der Programmiersprache ABAP eingegangen. Von elementaren Sprachkonstrukten, wie Datendeklarationen, Datenverarbeitung und Ablaufsteuerung bis Modularisierung und spezielle Techniken wird gezeigt, welche ABAP-Anweisungen fr welche Zwecke eingesetzt werden.
April 2001
17
ABAP Programmierung (BC-ABA) ABAP Programmierung (BC-ABA) ABAP Bildschirmbilder [Seite 544]
SAP AG
Hier werden die verschiedenen Bildschirmbilder dargestellt, die zu ABAP-Programmen gehren knnen. Es wird gezeigt, wie die Interaktion zwischen ABAP-Programmen und Benutzer in Form von Bildschirmbildern programmiert und gesteuert wird. ABAP Programmausfhrung [Seite 1026] Hier wird auf die Ausfhrung von ABAP-Programmen im R/3-System eingegangen. Der Abschnitt zeigt, wie ABAP-Programme im R/3-System gestartet werden knnen, welche Voraussetzungen dafr gegeben sein mssen, und welche verschiedenen Arten von Programmausfhrungen es gibt. ABAP Datenbankzugriffe [Seite 1125] Hier wird gezeigt, wie ABAP mit der zentralen Datenbank des R/3-Systems arbeitet. Es wird auf die Teile der Programmiersprache eingegangen, die in der Datenbank in SQLBefehle umgesetzt werden, und es wird gezeigt, wie nderungen auf der Datenbank programmiert werden. ABAP Objects [Seite 1392] Hier wird ABAP Objects, die objektorientierte Erweiterung von ABAP eingefhrt. Es werden Objekte, Klassen und Interfaces als die grundlegenden Elemente von ABAP Objects eingefhrt. Es wird gezeigt, wie Klassen selbstndig, mit Hilfe von Interfaces oder ber Vererbung definiert werden. Es wird die Behandlung von Methoden und Ereignisse als Komponenten von Klassen gezeigt. Anhang [Seite 1469] Der Anhang enthlt zusammenfassende Beschreibungen und bersichten, wie z.B. eine ABAP-Befehlsreferenz und ein ABAP-Glossar.
Beispielprogramme
Bitte beachten Sie, da die Beispielprogramme dieser Dokumentation in jedem R/3-System ab Release 4.5 in der Transaktion ABAPDOCU zum Testen zur Verfgung stehen. Die Gliederung der Programme entspricht dabei der Struktur dieser Dokumentation.
Weiterfhrende Dokumentation
SAP Style Guide [Extern] nderungen des SAP-Standards [Extern] ABAP Workbench: Werkzeuge [Extern] ABAP Dictionary [Extern]
18
April 2001
SAP AG
ABAP Programmierung (BC-ABA) ABAP Programmierung (BC-ABA)
Remote Communications [Extern] RFC-Programmierung in ABAP [Extern] ABAP als OLE-Automation-Controller [Extern] Basis-Programmierschnittstellen [Extern] ABAP Query [Extern]
April 2001
19
ABAP Programmierung (BC-ABA) ABAP Einfhrung
SAP AG
ABAP Einfhrung
aber bevor es so richtig losgeht, sollten Sie zuerst die folgenden Abschnitte lesen:
bersicht ber das R/3-Basis-System [Seite 21] bersicht ber die Komponenten von Anwendungsprogrammen [Seite 39] ABAP-Programme anlegen und ndern [Seite 72]
20
April 2001
SAP AG
ABAP Programmierung (BC-ABA) bersicht ber das R/3-Basis-System
bersicht ber das R/3-Basis-System

Einen wesentlichen Bestandteil des gesamten R/3-Systems mit seinen Anwendungen Finanzwirtschaft, Logistik, Personalwirtschaft bildet das R/3-Basis-System, die Plattform fr alle R/3-Anwendungen. In den folgenden Abschnitten zeigen wir Ihnen, was das R/3-Basis-System ist und wie es in das Gesamtsystem eingegliedert ist. Zuerst stellen wir Ihnen das gesamte Basis-System vor. Anschlieend wenden wir uns ausfhrlicher einer zentralen Komponente zu, dem Applikationsserver. Schlielich stellen wir Ihnen Workprozesse als Komponenten der Applikationsserver vor. Das Basis-System im Gesamtsystem [Seite 22] Applikationsserver [Seite 28] Workprozesse [Seite 33]
April 2001
21
ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem
SAP AG
Das Basis-System im Gesamtsystem

In den folgenden Abschnitten zeigen wir Ihnen drei verschiedene Sichten auf das R/3-System. Anhand dieser Sichten zeigen wir, welche Rolle das R/3-Basis-System im Gesamtsystem spielt.
Logische Sicht
Die folgende Abbildung zeigt die logische Sicht auf das R/3-System in Form eines Blockdiagramms.
R/3 Benutzer
...
Prsentationskomponenten Prsentationskomponenten
R/3 Benutzer
ABAP ABAP Workbench Workbench
R/3 Basis System
R/3 Anwendung 1
...
R/3 Anwendung n
Kernel & Basis Dienste Kernel & Basis Dienste Datenbank Management System
Datenbank
Die logische Sicht auf das R/3-System hebt sich von einer hardware- oder softwaretechnischen Sicht dahingehend ab, da die gezeigten Komponenten nicht unbedingt Hardware- oder Software-Einheiten zugeordnet werden knnen. Die Abbildung zeigt, wie sich das R/3-BasisSystem als zentrale Plattform in das gesamte R/3-System einfgt. Die folgende Aufzhlung fat die Aufgaben der drei im R/3-Basis-System enthaltenen logischen Komponenten kurz zusammen:
Kernel & Basisdienste

Die Komponente Kernel & Basisdienste dient als hardware-, betriebssystem- und datenbankunabhngige Laufzeitumgebung aller R/3-Anwendungen. Diese Laufzeitumgebung ist hauptschlich in C/C++ geschrieben. Einige systemnahe Teile sind aber auch in der SAPeigenen Programmiersprache programmiert. Im einzelnen erfllt die Komponente Kernel & Basisdienste dabei folgende Aufgaben:
22
April 2001
SAP AG
Ausfhren von Anwendungen Alle R/3-Anwendungen laufen auf Softwareprozessoren (Virtual Machines) dieser Komponente. Verwaltung von Benutzern und Prozessen An einem R/3-System knnen viele Benutzer gleichzeitig arbeiten und jeder Benutzer kann mehrere Anwendungen unabhngig voneinander ausfhren. Die Komponente bernimmt dabei die sonst blichen Aufgaben eines Betriebssystems. Benutzer melden sich am R/3-System an und fhren dort Anwendungen aus. Sie kommen mit dem eigentlichen Betriebssystem des jeweiligen Rechners nicht in Berhrung. Fr das Betriebssystem des Rechners ist das R/3-System der einzige Benutzer. Datenbankzugriffe Jedes R/3-System ist mit einem Datenbanksystem, bestehend aus Datenbank Management System (DBMS) und der eigentlichen Datenbank (Datenbestand) verknpft. Die Anwendungen greifen nicht direkt, sondern nur ber Basisdienste auf das Datenbanksystem zu. Kommunikation R/3-Anwendungen knnen sowohl mit anderen R/3-Systemen als auch mit Nicht-R/3Systemen kommunizieren. Ebenso ist der Zugriff von auerhalb auf die betriebswirtschaftliche Funktionalitt von R/3-Anwendungen mglich (BAPISchnittstelle). Die Komponente stellt alle hierfr ntigen Dienste zur Verfgung. Kontrolle und Administration des R/3-Systems Die Komponente umfat Programme, die es erlauben den laufenden Betrieb eines R/3Systems zu berwachen, zu steuern und Laufzeitparameter zu verndern.
ABAP Workbench
Die Komponente ABAP Workbench ist eine vollstndige Entwicklungsumgebung fr in ABAP geschriebenen Anwendungen. Sie dient der Erstellung oder Erweiterung, dem Test und der Organisation von Anwendungsprogrammen. Die Entwicklungsumgebung ist vollstndig in das R/3-Basis-System integriert und ist wie andere R/3-Anwendungen selbst in ABAP geschrieben.
Prsentationskomponenten
Die Prsentationskomponenten dienen der Interaktion des R/3-Systems mit dem Benutzer (Einund Ausgabe) und der Integration von Desktop-Anwendungen (z.B.Textverarbeitung, Tabellenkalkulation etc.) in das R/3-System.
Softwaretechnische Sicht
Die folgende Abbildung zeigt die softwaretechnische Sicht auf das R/3-System. Die softwaretechnische Sicht beschreibt aus welchen Softwarekomponenten das R/3-System zusammengesetzt ist. In der softwaretechnischen Sicht umfassen alle SAP GUI Komponenten und Applikationsserver eines R/3-Systems das R/3-Basis-System.
April 2001
23
SAP AG
...
SAP GUI
...
SAP GUI ... SAP GUI
... SAP GUI ...
Prsentationsschicht
Applikationsserver 1
Applikationsserver n
Messageserver
Applikationsschicht
Datenbank Management System
Datenbankschicht
Datenbank
Das R/3-Basis-System ist ein mehrstufiges Client/Server-System. Die einzelnen Softwarekomponenten sind auf einzelne Softwareschichten verteilt und arbeiten je nach Schicht als Client oder Server fr die Komponenten der darunter bzw. darberliegenden Schichten. In der Grundvariante umfat das R/3-System Softwareschichten: Datenbankschicht Ein zentrales Datenbanksystem, das alle Daten des R/3-Systems verwaltet, bildet die Datenbankschicht. Das zentrale Datenbanksystem besteht aus den Komponenten Datenbank Management System (DBMS) und der eigentlichen Datenbank (Datenbestand). SAP stellt selbst kein eigenes Datenbanksystem zur Verfgung. Das R/3-System untersttzt stattdessen folgende Datenbanksysteme anderer Hersteller: ADABAS D, DB2/400 (auf AS/400), DB2/Common Server, DB2/MVS,INFORMIX, Microsoft SQL Server, ORACLE und ORACLE Parallel Server. Die Datenbank enthlt nicht nur die betriebswirtschaftlichen Daten (Stammdaten und Bewegungsdaten) der Anwendungsprogramme, sondern ist die zentrale Datenablage fr das gesamte R/3-System. Insbesondere enthlt die Datenbank also auch Steuerungs- und Customizingdaten, die das Verhalten des R/3-Systems festlegen, sowie die Anwendungsprogramme selbst. Anwendungsprogramme bestehen aus Programmtexten, Bildschirmdefinitionen, Mens, Funktionsbausteinen usw. Diese Komponenten werden in einem speziellen Teil der Datenbank abgespeichert, der R/3-Repository genannt wird, und heien deshalb auch Repository-Objekte. Repository-Objekte werden mit der ABAP Workbench bearbeitet. Applikationsschicht DieSoftware-Komponenten der Applikationsschicht bestehen aus einem oder mehreren Applikationsservern und ein Message Server. Jeder Applikationsserver stellt eine Reihe von
24
April 2001
SAP AG
Diensten zum Betrieb des R/3-Systems zur Verfgung. Im Prinzip gengt ein einziger Applikationsserver, um ein R/3-System zu betreiben. In der Praxis werden die Dienste meistens auf mehrere Applikationsserver verteilt, so da nicht jeder Applikationsserver jeden Dienst zur Verfgung stellt. Der Message Server realisiert die Kommunikation zwischen den Applikationsservern. ber den Message Server knnen Auftrge zwischen den Applikationsservern innerhalb eines R/3-Systems weitergeleitetet werden. Weiterhin enthlt der Message Server Informationen ber die Gruppierung von Applikationsservern und die aktuelle Lastverteilung innerhalb der Gruppen und kann so die Anmeldung von Benutzern entsprechend beeinflussen. Prsentationsschicht Die Prsentationsschicht enthlt Software-Komponenten die R/3-spezifisch SAP GUI (Graphical User Interface) genannt werden. Die Prsentationsschicht bildet die Schnittstelle zu den Benutzern. Durch ihre SAP GUI-Komponenten bietet sie eine intuitiv bedienbare graphische Oberflche ber die Benutzer Daten eingeben oder Antworten in Form von Texten oder Graphiken erhalten. Die Prsentationsschicht sendet diese Daten an die Applikationsschicht bzw. empfngt sie von dieser. Eine SAP GUI Komponente ist whrend ihrer Laufzeit immer fest mit einer Benutzeranmeldung an das R/3-System verknpft. In weiteren Ausbaustufen knnen weitere Schichten, wie z.B. ein Internet Transaction Server (ITS), hinzukommen.
Softwaretechnische Sicht und Hardwaresicht

Die softwaretechnische Sicht hat zunchst einmal nichts mit der Verteilung auf die Hardware zu tun. Sowohl in vertikaler Richtung (Schichten) als auch in horizontaler Richtung (Komponenten) sind viele verschiedene Szenarien mglich. In vertikaler Richtung gibt es die mglichen Extreme, da alle Schichten auf einem einzigen Rechner installiert sind oder jede Schicht mindestens einen eigenen Rechner beansprucht. In horizontaler Richtung ist die Verteilung der Datenbankkomponenten vom jeweiligen Datenbankssystem abhngig. Die Komponenten von Applikationsschicht und Prsentationsschicht sind ber beliebig viele Rechner verteilbar, wobei auch mehrere Applikationsserver auf einem Rechner installiert sein knnen. Bei einer hufig vorzufindende Konfiguration laufen das Datenbanksystem und ein Applikationsserver, der spezielle Dienste fr die Datenbank zur Verfgung stellt, auf einem Rechner gemeinsam, whrend alle weiteren Applikationsserver auf eigene Rechner verteilt sind. Die Komponenten der Prsentationsschicht laufen meistens auf den Desktoprechnern jedes einzelnen Benutzers.
Vorteile der mehrstufigen Architektur

Die softwaretechnische Aufteilung des R/3-Systems auf drei Schichten sorgt durch die Verteilung der Systemlast auf die verschiedenen Schichten fr kurze Antwortzeiten. Da das Datenbanksystem die zentrale Datenablage fr das gesamte R/3-System enthlt, wird es beim Betrieb des System stark belastet. Deshalb ist es sinnvoll, die Ausfhrung von Anwendungsprogrammen nicht auf dem Rechner stattfinden zu lassen, auf dem auch das Datenbanksystem installiert ist. Die Architektur des R/3-Systems ermglicht es, durch die Trennung von Applikationsschicht und Datenbankschicht diese auf verschiedenenen Rechnern zu installieren, die ber ein Netzwerk kommunizieren. Es ist sinnvoll die Verarbeitung von Benutzereingaben und die Aufbereitung der Datenausgabe von der eigentlichen Programmausfhrung zu entkoppeln. Dies liefert die Architektur des R/3Systems durch die Trennung von Prsentations- und Applikationsschicht, die zur Entlastung der Applikationsserver fhrt. SAP GUI und Applikationsserver sind so aufgebaut, da mglichst wenig Daten zwischen den beiden Schichten hin und her bewegt werden mssen, so da die Komponenten der Prsentationsschicht auch auf Rechnern bedient werden knnen, die weit
April 2001
25
SAP AG
entfernt von den Rechnern stehen, auf denen die Applikationsschicht installiert ist, und die ber langsame Leitungen miteinander verbunden sind. Dadurch, da die Softwarekomponenten eines R/3-Systems beinahe beliebig auf verschiedene Hardware-Einheiten verteilt werden knnen, wird eine hohe Skalierbarkeit erreicht. Insbesondere in der Applikationsschicht kann ein R/3-System leicht durch die Installation weiterer Applikationsserver an steigende Anforderungen angepasst werden.
Konsequenzen fr die Anwendungsprogrammierung

Die Trennung von Anwendungs- und Prsentationsschicht hat eine wichtige Konsequenz fr die Programmierung von Anwendungsprogrammen. Bei der Ausfhrung eines Anwendungsprogramms, das mehrere Benutzeraktionen am Bildschirm erfordert, wechselt die Kontrolle ber das Anwendungsprogramm stndig zwischen den Schichten. Whrend ein Bildschirm eingabebereit ist, ist der entsprechende SAP GUI der Prsentationsschicht aktiv. Die Applikationsschicht ist in dieser Zeit nicht fr das Anwendungsprogramm aktiv. Die Applikationsserver sind dadurch fr andere Aufgaben frei. Nach einer Benutzereingabe am Bildschirm ist die Applikationsschicht wieder fr das Anwendungsprogramm aktiv. In dieser Zeit ist die Prsentationsschicht inaktiv. Der SAP GUI ist zwar fr den Benutzer aktiv und zeigt das Bildschirmbild noch an, ist in dieser Zeit aber nicht eingabebereit. Erst wenn das Anwendungsprogramm einen weiteren Bildschirm vorbereitet und an den SAP GUI geschickt hat, wird dieser wieder aktiv, wechselt die Bildschirmanzeige und wartet auf Eingaben. Als Konsequenz dieser Technik wird die Programmlogik eines Anwendungsprogramms zwischen zwei aufeinanderfolgenden Bildschirmbildern zu einem Dialogschritt zusammengefat.
Bild 1 Bild 1
SAP GUI nicht aktiv nicht aktiv Dialogschritt
Bild 2 Bild 2
SAP GUI nicht aktiv nicht aktiv Dialogschritt
Bild 3 Bild 3
Prsentationsschicht:
SAP GUI nicht aktiv
Interaktion des Benutzers
Applikationsschicht:
Bearbeitung der Dialogschritte durch das System
26
April 2001
SAP AG
Benutzersicht
Die folgende Abbildung zeigt die Benutzersicht auf das R/3-System:
R/3 Benutzer
SAP GUI SAP GUI SAP GUI Modus 11 SAP GUI SAP Modus Modus 6 ... Modus 6 GUI 1 SAP GUI SAP GUI SAP GUI Modus 11 SAP GUI SAP Modus Modus 6 ... Modus 6 GUI 2 SAP GUI SAP GUI SAP GUI Modus 11 SAP GUI SAP Modus Modus 6 ... Modus 6 GUI 3
...
Applikationsschicht Datenbankschicht R/3 System 1
Applikationsschicht Datenbankschicht R/3 System 2
Fr einen Benutzer sind die Komponenten des R/3-System unmittelbar sichtbar, die sich ihm als Fenster auf dem Bildschirm prsentieren. Diese Fenster werden von der Prsentationsschicht des R/3-Systems erstellt und sind auch Bestandteile des R/3-Basis-Systems. Vor der Anmeldung eines Benutzers an das R/3-System startet er zuerst ein Hilfsprogramm namens SAP Logon, das auf dem jeweiligen Frontend installiert ist. Im SAP Logon kann er eines der zur Verfgung stehenden R/3-Systeme auswhlen. Das Programm SAP Logon verbindet sich mit dem Message Server des ausgewhlten R/3-Systems und erhlt von diesem die Adresse eines geeigneten (wenig ausgelasteten) Applikationsservers. Schlielich startet SAP Logon einen SAP GUI, der mit diesem Applikationsserver verbunden ist. Das Programm SAP Logon wird fr diese Verbindung nicht mehr bentigt. Der SAP GUI ffnet erst das Anmeldebild und nach erfolgreicher Anmeldung das R/3Einstiegsbild in einem R/3-Fenster auf dem Bildschirm. Innerhalb des SAP GUI wird das R/3Fenster durch einen Modus reprsentiert. Der Benutzer kann nach seiner Anmeldung innerhalb eines SAP GUI bis zu fnf weitere Modi, also R/3-Fenster, ffnen, die sich untereinander fast wie unabhngige R/3-Anmeldungen verhalten. In den verschiedenen Modi knnen also parallele Anwendungen unabhngig voneinander ausgefhrt werden. Innerhalb eines Modus, kann der Benutzer Anwendungen ausfhren, die selbst weitere Fenster (z.B. Dialogfenster, Graphikfenster usw.) ffnen. Diese Fenster sind dann nicht unabhngig, sondern gehren zu diesem Modus. Sie knnen modal (das ursprngliche Fenster ist nicht eingabebereit) oder amodal (beide Fenster sind eingabebereit und wechselwirken miteinander) sein. Der Benutzer kann mit dem Programm SAP Logon weitere SAP GUIs fr das gleiche oder auch andere zur Verfgung stehende R/3-Systeme ffnen. Die einzelnen SAP GUIs und die entsprechenden R/3-Anmeldungen eines Benutzers sind vollstndig unabhngig voneinander. Somit knnen zum Beispiel auf einem einzigen Desktoprechner die Prsentationsschichten mehrerer R/3-System durch SAP GUIs vertreten sein.
April 2001
27
ABAP Programmierung (BC-ABA) Applikationsserver
SAP AG
Applikationsserver
R/3-Programme laufen auf Applikationsservern ab. Applikationsserver sind also wichtige Softwarekomponenten des R/3-Systems. In den folgenden Abschnitten beschreiben wir die Applikationsserver genauer.
Aufbau eines Applikationsservers

Alle Applikationsserver eines R/3-Systems unter Einbeziehung des Message Servers bilden die Applikationsschicht der mehrstufigen Architektur des R/3-Systems . Die Anwendungsprogramme eines R/3-Systems werden auf den Applikationsservern ausgefhrt. Die Applikationsserver kommunizieren dabei mit den Prsentationskomponenten, mit der Datenbank und ber den Message Server auch untereinander . Das folgende Bild zeigt den Aufbau eines Applikationsservers:
Benutzer 1
...
SAP GUI
Benutzer n
...
SAP GUI
Applikationsserver
Dispatcher Dispatcher
Gateway Gateway
Kontext
Kontext
Shared Shared Memory Memory
WorkWorkprozess prozess 1 1
WorkWorkprozess prozess
2 2
3 3
Datenbank
Die einzelnen Komponenten sind:
Workprozesse
Applikationsserver enthalten Workprozesse, deren Anzahl und Typ beim Start des R/3-Systems festgelegt wird. Workprozesse sind Komponenten, die in der Lage sind, eine Anwendung (bzw. jeweils einen Dialogschritt) auszufhren. Jeder Workprozess hat Verbindung zu einem Speicherbereich in dem sich der Kontext der gerade ausgefhrten Anwendung befindet. Der Kontext beinhaltet die aktuellen Daten des laufenden Programms und mu fr jeden Dialogschritt
28
Kontext
April 2001
SAP AG
dieses Programms verfgbar sein. Weiter unten erfahren Sie mehr ber die unterschiedlichen Typen von Workprozessen.
Dispatcher
Jeder Applikationserver enthlt einen Dispatcher. Der Dispatcher ist das Bindeglied zwischen den Workprozessen und den an dem Applikationsserver angemeldeten Benutzern (bzw. deren SAP GUIs). Seine Aufgabe besteht darin, jedesmal, wenn eine Benutzerinteraktion dazu fhrt, da ein Dialogschritt ausgefhrt werden soll, diesen Auftrag vom SAP GUI entgegenzunehmen und ihn an einen freien Workprozess weiterzuleiten. Auf dem gleichen Wege gelangen die Bildschirmausgaben, die aus der Ausfhrung des Dialogschritts resultieren, wieder zum Benutzer zurck.
Gateway
Jeder Applikationserver enthlt ein Gateway. Das Gateway ist die Vermittlungsinstanz fr die Kommunikationsprotokolle des R/3-Systems (RFC, CPI/C) und kann mit anderen Applikationsservern des gleichen R/3-Systems, mit anderen R/3-Systemen, mit R/2-Systemen oder mit externen (nicht-SAP) Anwendungen kommunizieren. Der hier beschriebene Aufbau der Applikationsserver untersttzt die Performance und Skalierbarkeit des gesamten R/3-Systems. Die feste Anzahl von Workprozessen und das Dispatching von Dialogschritten auf die Workprozesse sorgen fr eine gute Ausnutzung des Hauptspeichers im verwendeten Rechner, da manche Komponenten und Speicherbereiche eines Workprozesses unabhngig von den Anwendungen sind und wiederverwendet werden. Da die einzelnen Workprozesse unabhngig voneinander arbeiten, bieten sie eine optimale Vorraussetzung fr Mehrprozessor-Architekturen. Auf die Arbeitsweise des Dispatchers und die Verteilung von anfallenden Aufgaben auf Workprozessen gehen wir im Abschnitt Dispatching von Dialogschritten noch nher ein.
Shared Memory
Alle Workprozesse eines Applikationsservers verwenden einen gemeinsamen Hauptspeicher, das Shared Memory, um Kontexte zu speichern oder um selten genderte Daten lokal zu puffern. Im Shared Memory stehen die von allen Workprozessen genutzten Ressourcen (wie Programme oder Tabelleninhalte) zur Verfgung. Die Speicherverwaltung des R/3-Systems sorgt dafr, da die Workprozesse immer den aktuellen Kontext, d.h. die Datenmengen, die den aktuellen Bearbeitungszustand eines laufenden Programms enthalten, adressieren. ber ein MappingVerfahren wird zu diesem Zweck der fr die Ausfhrung eines Dialogschritts erforderliche Kontext aus dem gemeinsamen Hauptspeicher in den Adreraum des bearbeitenden Workprozessses projeziert. Dadurch sind die tatschlichen Kopiervorgnge auf ein Minimum reduziert. Die lokale Pufferung von Daten im Shared Memory des Applikationsservers entlastet die Datenbank, da mehrfaches Lesen vermieden wird. Dadurch verkrzen sich die Zugriffszeiten fr die Anwendungsprogramme erheblich. Durch die Konzentration einzelner Anwendungen (Finanzwirtschaft, Logistik, Personalwirtschaft) auf getrennte Applikationsservergruppen kann eine optimale Ausnutzung der Puffer erreicht werden.
Datenbankanbindung
Whrend des Starts eines R/3-Systems meldet jeder Applikationsserver seine Workprozesse an die Datenbankschicht an und erhlt dadurch fr jeden Workprozess genau einen fest definierten Kanal. Jeder Workprozess ist fr die gesamte Laufzeit des R/3-Systems ein Benutzer (Client) des Datenbanksystems (Server). Whrend der Laufzeit des Systems erfolgen keine
April 2001
29
SAP AG
Ummeldungen und ein Datenbank-Kanal kann nicht von einem Workprozess zum anderen weitergereicht werden. Aus diesem Grund kann ein Workprozess Datenbanknderungen immer nur im Rahmen genau einer Datenbank-LUW (Logical Unit of Work) ausfhren. Eine DatenbankLUW ist eine nicht teilbare Folge von Datenbankoperationen. Dies hat wichtige Konsequenzen fr das Programmiermodell, auf die wir unten noch nher eingehen.
Dispatching von Dialogschritten

Die Anzahl der Benutzer, die sich an einem Applikationsserver anmelden, ist hufig um ein Vielfaches grer als die Anzahl der zur Verfgung stehenden Workprozesse und nicht durch die Architektur des R/3-System begrenzt. Jeder Benutzer kann wiederum mehrere parallele Anwendungen ausfhren. Der Dispatcher hat dabei die wichtige Aufgabe alle anfallenden Dialgschritte auf die Workprozesse des Applikationsservers zu verteilen. Wie der zeitliche Ablauf des Dispatching aussehen kann, zeigen wir Ihnen am folgenden Beispiel:
Benutzer 1
Benutzer 2
SAP GUI SAP GUI Applikationsserver
SAP GUI SAP GUI
1 4 5 3
Dispatcher
Shared Shared Memory Memory
WorkWorkprozess prozess 1 1
Kontext
2 2
3 3
1. Der Dispatcher empfngt von Benutzer 1 die Anforderung zur Ausfhrung eines Dialogsschritts und leitet diese an den gerade freien Workprozess 1 weiter. Der Workprozess adressiert den Kontext des entsprechenden Anwendungsprogramms im Shared Memory und fhrt den Dialogschritt aus. Danach ist der Workprozess wieder frei. 2. Der Dispatcher empfngt von Benutzer 2 die Anforderung zur Ausfhrung eines anderen Dialogschritts und leitet diese an den wieder freien Workprozess 1 weiter. Der Workprozess bearbeitet den Dialogschritt analog zu Schritt 1. 3. Whrend Workprozess 1 noch mit Schritt 2 beschftigt ist, empfngt der Dispatcher von Benutzer 1 die Anforderung zur Ausfhrung eines weiteren Dialogschritts und leitet diese an den gerade freien Workprozess 2 weiter. 4. Nachdem Workprozess 1 und 2 ihre Verarbeitung beendet haben, empfngt der Dispatcher wieder von Benutzer 1 eine Anforderung und leitet diese an den wieder freien Workprozess 1 weiter.
30
Kontext
Kontext
April 2001
SAP AG
5. Whrend Workprozess 1 noch mit Schritt 4 beschftigt ist, empfngt der Dispatcher von Benutzer 2 eine Anforderung zur Ausfhrung und leitet diese an den wieder freien Workprozess 2 weiter. Dem Beispiel entnehmen wir, da

ein Dialogschritt eines Programms whrend seiner Ausfhrung genau einem Workprozess zugeordnet ist. die einzelnen Dialogschritte eines Programms whrend dessen Laufzeit auf verschiedenen Workprozessen ausgefhrt werden knnen, und der Kontext des Programms fr jeden neuen Workprozess neu adressiert werden mu. ein Workprozess aufeinanderfolgend die Dialogschritte verschiedener Programme und verschiedener Benutzer ausfhrt.
Aus dem Beispiel geht nicht hervor, da der Dispatcher die Auftrge so auf die Workprozesse zu verteilen versucht, da mglichst oft der gleiche Workprozess fr aufeinanderfolgende Dialogschritte einer Anwendung verwendet wird. Dadurch kann die Neuadressierung des Programmkontexts im Shared Memory eingespart werden.
Dispatching und Programmiermodell

Nachdem die die Trennung von Anwendungs- und Prsentationsschicht die Aufteilung von Anwendungsprogrammen in Dialogschritte erforderlich machte, fhrt das im vorhergehenden Abschnitt vorgestellte Dispatching der Dialogschritte auf einzelne Workprozesse zu weiteren wichtigen Konsequenzen fr das Programmiermodell. Wie schon oben erwhnt, kann ein Workprozess Datenbanknderungen immer nur im Rahmen genau einer Datenbank-LUW (Logical Unit of Work) ausfhren. Eine Datenbank-LUW ist eine nicht teilbare Folge von Datenbankoperationen an deren Anfang und Ende ein konsistenter Datenbestand auf der Datenbank stehen mu. Anfang und Ende einer Datenbank-LUW werden durch einen Commit-Befehl an das Datenbanksystem definiert (Datenbank-Commit). Whrend einer Datenbank-LUW, also zwischen zwei Datenbank-Commits, sorgt das Datenbanksystem selbst fr die Konsistenz (Widerspruchsfreiheit) des Datenbestands. Das heit, es bernimmt selbstndig Aufgaben wie Datenbankeintrge whrend ihrer Bearbeitung zu sperren oder den alten Zustand nach einem fehlerhaften Abbruch wiederherzustellen (Rollback). Typische SAP-Anwendungsprogramme erstrecken sich ber einige Bildschirmbilder und die zugehrigen Dialogschritte. Der Benutzer fordert auf den einzelnen Bildschirmen Datenbanknderungen an, die nach Ablauf einer Bildschirmfolge zu einem konsistenten Datenbestand auf der Datenbank fhren sollen. Die einzelnen Dialogschritte laufen auf unterschiedlichen Workprozessen und ein einzelner Workprozess bearbeitet nacheinander Dialogschritte unabhngiger Anwendungen. Es ist klar, da voneinander unabhngige Anwendungen, deren Dialogschritte nacheinander auf einem Workprozess ausgefhrt werden, nicht mit der gleichen Datenbank-LUW arbeiten drfen. Daraus folgt, da ein Workprozess fr jeden Dialogschritt eine eigene Datenbank-LUW ffnen mu. Der Workprozess sendet also am Ende jedes Dialogschritts, whrend dem Datenbanknderungen ausgefhrt werden, einen Commit-Befehl (Datenbank-Commit) an die Datenbank. Diese Commit-Befehle sind nicht explizit in der Anwendung programmiert und wir nennen sie deshalb implizite Datenbank-Commits. Durch diesen impliziten Datenbank-Commit wird die Zeit, in der ein Benutzer eine DatenbankLUW aufrechterhalten kann auf maximal einen Dialogschritt beschrnkt. Dies bedeuted eine erhebliche Entlastung der Datenbank, verringert die Hufigkeit von Serialisierungen und Deadlocks und ermglicht daher eine sehr groe Zahl von Benutzern an einem System.
April 2001
31
SAP AG
Bild 1 Bild 1
SAP GUI
Bild 2 Bild 2
SAP GUI
Bild 3 Bild 3
SAP GUI Prsentationsschicht
Dialogschritt
Dialogschritt
Applikationsschicht
Datenbank LUW
Datenbankschicht
Es stellt sich jetzt die Frage, wie sich die Verknpfung jedes einzelnen Dialogschritts mit einer Datenbank-LUW mit der Anforderung in Einklang bringen lt, da das Festschreiben (Commit) oder Zurcknehmen von Datenbanknderungen (Rollback) vom logischen Ablauf der Anwendungsprogramme abhngen sollte und nicht von der technischen Verteilung auf Dialogschritte. Wenn Aktualisierungsanforderungen voneinander abhngen, bilden sie logische Einheiten im Programmverlauf, die sich ber mehrere Dialogschritte erstrecken knnen. Die Datenbanknderungen solcher logischer Einheiten mssen zusammen ausgefhrt und entsprechend auch zusammen zurckgesetzt werden. Das SAP-Programmiermodell bietet fr diese Anforderung eine Reihe von Bndelungstechniken an, die es ermglichen, da Datenbankaktualisierungen in solchen logischen Einheiten ablaufen knnen. Die Teile von R/3-Anwendungsprogramms, die eine logisch zusammengehrende Menge von Datenbank-Operationen bndeln, bezeichnen wir als SAP-LUW. Im Gegensatz zur Datenbank-LUW umfat eine SAP-LUW die Gesamtheit der Dialogschritte einer logischen Einheit inklusive der Fortschreibung auf der Datenbank (Verbuchung).
32
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Workprozesse
Workprozesse
Workprozesse fhren die einzelnen Dialogschritte der R/3-Anwendungen aus. In den nchsten beiden Abschnitten zeigen wir einerseits den Aufbau eines Workprozesses und gehen andererseits auf die verschiedenen Typen von Workprozessen im R/3-System ein.
Aufbau eines Workprozesses

Workprozesse fhren als Komponenten von Applikationsservern die Dialogschritte von Anwendungsprogrammen aus. Das folgende Bild zeigt Ihnen, welche Komponenten jeder Workprozess enthlt, damit er R/3-Anwendungsprogramme ausfhren kann:
Workprozess
Dynpro-Prozessor Dynpro-Prozessor ABAP-Prozessor ABAP-Prozessor Datenbankschnittstelle Datenbankschnittstelle Kontext Kontext
Datenbank
Ein Workprozess enthlt zwei Softwareprozessoren und eine Datenbankschnittstelle:
Dynpro-Prozessor
In R/3-Anwendungsprogrammen unterscheiden wir zwischen Benutzerinteraktionen und Verarbeitungslogik. Programmtechnisch wird die Benutzerinteraktion durch Dynpros (dynamische Programme) realisiert. Ein Dynpro besteht aus einer Bildschirmmaske und der zugehrigen Dynproablauflogik. Die Dynproablauflogik kontrolliert einen Groteil der Benutzerinteraktionen. Das R/3-Basis-System enthlt fr die Erstellung von Dynpros eine eigene Sprache mit Sprachelementen fr die Programmierung der Dynproablauflogik. Der DynproProzessor fhrt die Dynproablauflogik des Anwendungsprogramms aus. Er bernimmt dabei die Kommunikation zwischen Workprozess und SAP GUI (ber den Dispatcher), ruft Module der Verarbeitungslogik auf und sorgt fr die Weitergabe von Feldinhalten an die Verarbeitungslogik.
ABAP-Prozessor
Die eigentliche Verarbeitungslogik von Anwendungsprogrammen ist in der SAP-eigenen Programmiersprache ABAP geschrieben. Der ABAP-Prozessor fhrt die Verarbeitungslogik des Anwendungsprogramms aus und kommuniziert mit der Datenbankschnittstelle. Der ABAP-
April 2001
33
SAP AG
Prozessor wird vom Dynpro-Prozessor informiert, welcher Programmteil (Modul) entsprechend des Fortgangs der Dynproablauflogik abzuarbeiten ist. Das folgende Bild verdeutlicht die Zusammenarbeit zwischen Dynpro- und ABAP-Prozessor bei der Ausfhrung von Anwendungsprogrammen.
Workprozess
Dynpro-Prozessor Dynpro-Prozessor Dynpro Dynpro
ABAP-Prozessor ABAP-Prozessor
Modul 3 Modul 3 Modul 2 Modul 2 Modul 1 Modul 1
Datenbankschnittstelle Datenbankschnittstelle
Datenbankschnittstelle
Die Datenbankschnittstelle stellt folgende Dienste zur Verfgung:

Verbindungsauf- und -abbau eines Workprozesses zur Datenbank Zugang zu Datenbanktabellen Zugang zu R/3-Repository-Objekten (ABAP-Programme, Dynpros etc.) Zugang zu Kataloginformationen (ABAP Dictionary) Transaktionskontrolle (Commit- und Rollback-Behandlung) Verwaltung von Tabellenpuffern auf dem Applikationsserver
Die folgende Abbildung zeigt die einzelnen Komponenten der Datenbankschnittstelle:
34
April 2001
SAP AG
Workprozess
Dynpro-Prozessor Dynpro-Prozessor ABAP-Prozessor ABAP-Prozessor Datenbankschnittstelle Datenbankschnittstelle
Native SQL
Open SQL
Native SQL Native SQL Modul Modul
TabellenTabellenModul Modul
PufferPufferManagement Management
Datenbankabhngige Schicht Datenbankabhngige Schicht Standard SQL (dynamic, embedded)
Datenbank
Die Abbildung zeigt, da es zwei unterschiedliche Mglichkeiten gibt aus ABAP-Programmen auf Datenbanken zuzugreifen, nmlich Open SQL und Native SQL. Die Anweisungen von Open SQL sind eine vollstndig in ABAP integrierte Untermenge von Standard SQL. Sie erlauben dem ABAP-Programmierer einen einheitlichen Zugriff auf Daten, unabhngig vom installierten Datenbanksystem. Open SQL umfat den DML-Anteil (Data Manipulation Language) des Standards, erlaubt es also Daten zu lesen (SELECT) und zu verndern (INSERT, UPDATE, DELETE). Die im Standard definierten bereiche der DDL (Data Definition Language) und DCL (Data Control Language) werden im R/3-System vom ABAP Dictionary bzw. der Berechtigungsverwaltung bernommen, die jeweils die Funktionalitt der Datenbanken vereinheitlichen bzw, stark erweitern. Open SQL geht aber auch ber den Standard hinaus, indem es einige Anweisungen anbietet, die im Zusammenhang mit den brigen ABAP-Konstrukten, bestimmte Zugriffe vereinfachen oder beschleunigen knnen. Zustzlich bietet Open SQL die Mglichkeit, bestimmte Tabellen auf dem Applikationsserver zu puffern und dadurch Datenbankzugriffe einzusparen. Dabei bernimmt die Datenbankschnittstelle die Kontrolle ber die Abgleichung der Puffer mit der Datenbank. Die Puffer sind teilweise im Arbeitsspeicher des aktuellen Workprozesses und teilweise im gemeinsamen Speicher aller Workprozesse eines Anwendungsservers abgelegt. Bei R/3Systemen die auf mehrere Anwendungsserver verteilt sind, werden die Daten in den verschiedenen Puffern durch das Puffer-Management in festgelegten Zeitabschnitten synchronisiert. Bei der Datenbankpufferung mu man also in Kauf nehmen, da die Daten in den Puffern nicht immer aktuell sind. Deshalb wendet man Datenbankpufferung eher bei wenig vernderlichen Daten an. Native SQL ist nur sehr lose in ABAP eingebunden und erlaubt Zugriff auf den gesamten Umfang der Funktionalitt, der von der Programmierschnittstelle des Datenbanksystems zur Verfgung gestellt wird. Native SQL Anweisungen werden im Gegensatz zu Open SQL nicht geprft und bersetzt, sondern direkt an das Datanbanksystem gereicht. Ein Programm, das Native SQL
April 2001
Tabellenpuffer auf Applikationsserver

35
SAP AG
verwendet, ist abhngig vom installierten Datenbanksystem. Bei der Entwicklungen der R/3Anwendungen wird auf den Einsatz von Native SQL weitestgehend verzichtet. Nur in einigen Basis-Komponenten wird Native SQL verwendet (z.B.: im ABAP Dictionary zum Anlegen oder ndern von Tabellen). Die im Bild gezeigte datenbankabhngige Schicht verbirgt die Unterschiede zwischen den Datenbanksystemen vor dem Rest der Datenbankschnittstelle. Sie wird bei der Installation des Basis-Systems entsprechend der verwendeten Datenbank ausgewhlt. Dank der Standardisierung von SQL sind die Unterschiede im Hinblick auf die Syntax der Anweisungen gering, Semantik und Verhalten unterliegen jedoch nicht ganz dem Standard und weisen daher grere Unterschiede auf. Im Falle von Native SQL ist die Funktionalitt der datenbankabhngigen Schicht nur minimal.
Mgliche Typen von Workprozessen

Obwohl alle Workprozesse die im vorhergehenden Abschnitt beschriebenen Komponenten enthalten, knnen wir einzelnen Workprozessen verschiedene Typen zuordnen. Der Typ bestimmt, welche Arten von Aufgaben ein Workprozess im Applikationsserver erledigen soll. Der Typ bestimmt nicht die technischen Eigenschaften eines Workprozesses, sondern dient der Aufgabenverteilung auf dem Applikationsserver. Die Verteilung der Aufgaben auf die verschiedenen Workprozesse nimmt der Dispatcher vor. Fr jeden Applikationsserver wird vor dem Start des R/3-Systems festgelegt, wieviele Workprozesse er enthlt und von welchem Typ diese sind. Der Dispatcher startet die Workprozesse und verteilt an jeden Workprozess nur die Auftrge, die mit seinem Typ korrespondieren. Das erlaubt die optimierte Verteilung von Workprozesstypen hinsichtlich der Ressourcenausnutzung von Applikationsservern. Das folgende Bild zeigt nochmals den Aufbau eines Applikationsservers, wobei jetzt auch die verschiedenen mglichen Workprozesstypen dargestellt werden:
36
April 2001
SAP AG
Benutzer 1
...
SAP GUI
Benutzer n
...
SAP GUI
Dispatcher Dispatcher
Dialog Dialog Dialog Dialog WorkWorkWorkWorkprozesse VerVerbuchungs Dialog buchungs Dialog WorkWorkWorkWorkBatch Batch Dialog Dialog WorkWorkWorkWorkprozesse
prozesse prozess prozess
prozesse prozess prozesse prozess
prozesse prozess prozess
Enqueue Enqueue WorkWorkprozess prozess
Spool Spool WorkWorkprozess prozess
Applikationsserver
Datenbank
Im folgenden beschreiben wir die einzelnen Workprozesstypen nur kurz, da im weiteren Verlauf dieser Dokumentation nher auf einzelne Komponenten des Applikationsservers bzw. R/3Systems eingegangen wird.
Dialog-Workprozesse
Dialog-Workprozesse erledigen alle Auftrge zum Ausfhren von Dialogschritten, die durch einen aktiven Benutzer ausgelst werden.
Verbuchungs-Workprozesse
Verbuchungs-Workprozesse fhren Verbuchungsauftrge aus. Verbuchungsauftrge sind die Teile einer SAP-LUW, die smtliche aus dem Dialog resultierenden Datenbankoperationen in einer Datenbank-LUW bndeln und im Hintergrund ausfhren.
Hintergrund-Workprozesse
Hintergrund-Workprozesse verarbeiten Programme, die ohne Benutzerinteraktion ausgefhrt werden sollen (Hintergrundprogramme).
Enqueue-Workprozess
Der Enqueue-Workprozess verwaltet eine Sperrtabelle im Shared Memory. Die Sperrtabelle enthlt die logischen Datenbanksperren des R/3-Systems und spielt eine wichtige Rolle im
April 2001
37
SAP AG
Zusammenhang mit SAP-LUWs. Es darf fr ein R/3-System nur eine einzige Sperrtabelle und somit nur einen einzigen Applikationsserver mit Enqueue-Workprozessen geben.
Spool-Workprozess
Der Spool-Workprozess gibt sequentielle Datenstrme an einen Drucker oder an die optische Archivierung aus. Jeder Applikationsserver kann nur einen einzigen Spool-Workprozess enthalten. Die Dienste, die ein Applikationsserver zur Verfgung stellen kann, werden durch den Typ seiner Workprozesse bestimmt. Ein Applikationsserver kann dann entsprechend mehrere Rollen annehmen, z.B. als Dialog-Server und gleichzeitig als Enqueue-Server, wenn er aus mehreren Dialog-Workprozessen und einem Enqueue-Workprozess besteht. Die Systemadministration kann whrend des laufenden Workprozesse zwischen den Typen Dialog und Hintergrund umhngen. Damit kann ein R/3-System beispielsweise von Tag- auf Nachtbetrieb umgestellt werden, wobei es tagsber mehr Dialog- als Hintergrund-Workprozesse gibt und umgekehrt.
38
April 2001
SAP AG
ABAP Programmierung (BC-ABA) bersicht ber die Komponenten von Anwendungsprogrammen
bersicht ber die Komponenten von Anwendungsprogrammen

Diese bersicht beschreibt die Anwendungsprogrammierung im R/3-System. Alle Anwendungsprogramme und Teile des R/3-Basis-Systems werden innerhalb der Entwicklungsumgebung ABAP Workbench mit der SAP-eigenen Programmiersprache ABAP geschrieben. Die einzelnen Objekte von Anwendungsprogrammen werden in einem speziellen Teil der Datenbank abgespeichert, dem R/3-Repository. Das R/3-Repository dient als zentrale Ablage fr smtliche Entwicklungsobjekte des R/3-Systems. In den folgenden Abschnitten gehen wir auf die Grundlagen und Eigenschaften der Anwendungsprogrammierung ein. Aufbau von Anwendungsprogrammen [Seite 40] Mgliche Bildschirmbilder [Seite 42] Aufbau der Verarbeitungslogik [Seite 47] Verarbeitungsblcke in ABAP-Programmen [Seite 53] ABAP-Sprachelemente [Seite 60] Logische Datenbanken und Contexte [Seite 65] Speicherstrukturen eines ABAP-Programms [Seite 70]
April 2001
39
ABAP Programmierung (BC-ABA) Aufbau von Anwendungsprogrammen
SAP AG
Aufbau von Anwendungsprogrammen

R/3-Anwendungsprogramme laufen auf den Workprozessen der Applikationserver des R/3Basis-Systems ab. Aus diesem Grund sind R/3-Anwendungsprogramme unabhngig von Hardware und Betriebssystem. Sie sind aber nicht auerhalb eines R/3-Systems einsetzbar. Wie wir in bersicht ber das R/3-Basis-System [Seite 21] gesehen haben, stellt ein Workprozess einen Dynpro-Prozessor zur Bearbeitung von Benutzerinteraktionen, einen ABAPProzessor zur Bearbeitung von Verarbeitungslogik und eine Datenbankschnittstelle fr die Verbindung zum Datenbanksystem zur Verfgung. Diese Komponenten eines Workprozesses bestimmen wie folgt den Aufbau von Anwendungsprogrammen:
SAP GUI SAP GUI
Ablauflogik Ablauflogik (Dynpros) (Dynpros)
Verarbeitungslogik Verarbeitungslogik (ABAP-Programme) (ABAP-Programme)
Weitere Weitere Schnittstellen Schnittstellen
DatenbankDatenbankschnittstelle schnittstelle
Anwendungsprogramme bestehen aus zwei Komponenten mit unterschiedlichen Aufgaben:
Ablauflogik
Die Komponente von Anwendungsprogrammen, die auf Benutzeraktionen auf Bildschirmen reagieren werden durch Dynpros (dynamische Programme) realisiert. Dynpros laufen auf dem Dynpro-Prozessor eines Workprozesses ab. Sie sind definiert durch eine Ablauflogik, die mit einer speziellen Teilmenge von ABAP, der Dynprosprache, programmiert wird, und durch ihre Verknpfung mit Bildschirmmasken. Der SAP GUI prsentiert dem Benutzer die Bildschirmmasken und bermittelt die Benutzeraktionen an die zugehrigen Teile der Ablauflogik. Dynpros reagieren beim Programmablauf auf Benutzeraktionen und geben Sie durch den Aufruf von Programm-Modulen an die Verarbeitungslogik weiter.
Verarbeitungslogik
Die Komponente von Anwendungsprogrammen, welche speziell die Datenverarbeitung im R/3System erledigt, wird durch ABAP-Programme (Advanced Business Application Programming) realisiert. ABAP-Programme laufen auf dem ABAP-Prozessor eines Workprozesses ab. Sie
40
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Aufbau von Anwendungsprogrammen
erhalten Bildschirmeingaben vom Dynproprozessor und senden Bildschirminhalte an den Dynproprozessor. Die Verarbeitungslogik greift ber die Datenbankschnittstelle des jeweiligen Workprozesses auf das Datenbanksystem zu. Hierfr enthlt ABAP enthlt einen speziellen Befehlssatz namens Open SQL, mit dem unabhngig von der verwendeten Datenbank lesend und schreibend auf Daten zugegriffen werden kann. Die Open SQL-Befehle werden in der Datenbankschnittstelle in die Befehle der verwendeten Datenbank umgesetzt. Weiterhin gibt es die Mglichkeit ber sogenannte Native SQL-Befehle die Datenbank ohne Umsetzung anzusprechen. Weitere Datenschnittstellen wie z. B. Speicher, sequentielle Dateien und externe Schnittstellen bieten zustzliche Mglichkeiten zum Senden und Empfangen von Daten in ABAPProgrammen. In der Zusammenarbeit mit Dynpros spielen ABAP-Programme beim Programmablauf eher eine passive Rolle, da sie Module zur Verfgung stellen, die von der Ablauflogik aufgerufen werden.
April 2001
41
ABAP Programmierung (BC-ABA) Mgliche Bildschirmbilder
SAP AG
Mgliche Bildschirmbilder
Jedes Bildschirmbild, das ein Benutzer im R/3-System angezeigt bekommt, gehrt zu einem Dynpro eines Anwendungsprogramms. Dynpros reagieren auf Benutzereingaben auf den Bildschirmen, senden Daten zum Bildschirm und empfangen Daten vom Bildschirm. Es gibt drei Mglichkeiten die Bildschirmein- und -ausgabe zu organisieren. Diese unterscheiden sich in der Art, wie sie programmiert werden und in der Art und Weise welche Benutzerinteraktionen typischerweise auf ihnen ausgefhrt werden.
Dynpros
Im allgemeinsten Fall erstellt der Anwendungsprogrammierer die Dynpros seiner Programme vollstndig selbst, das heit er programmiert alle Details der Ablauflogik und verknpft sie mit selbstdefinierten Bildschirmmasken. Die Erstellung beider Anteile findet ausschlielich mit dem Werkzeug Screen Painter der ABAP Workbench statt.
Selektionsbilder und Listen
Fr hufige Anwendungsflle bietet das R/3 System zwei spezialisierte Dynpros, nmlich Selektionsbilder und Listen an. Die Bildschirme und die Bildschirmablauflogik dieser Dynpros werden aus ABAP-Befehlen der Verarbeitungslogik generiert. Der Programmierer mu in diesem Fall nicht mit dem Werkzeug Screen Painter arbeiten, sondern er definiert den gesamten Interaktionsteil dieser Bildschirme in der Verarbeitungslogik. Bildschirme im R/3-System enthalten Menuleisten, Symbolleisten und Drucktastenleisten. Diese drei Objekte, dienen der direkten Eingabe von Benutzeranweisungen auf Bildschirmen und werden unter dem Begriff Status zusammengefat. Jeder Status ist ein Entwicklungsobjekt des zugehrigen Anwendungsprogramms und bildet einen eigenstndigen Teil der Bildschirmbilder. Ein Status ist somit kein interner Teil eines Dynpros und kann in verschiedenen Dynpros wiederverwendet werden. Fr die Definition von Status enthlt die ABAP Workbench das Werkzeug Menu Painter. Fr Dynpros und Listen kann der Status vom Programmierer frei definiert werden. Bei Selektionsbildern ist der Status fest vordefiniert. Im folgenden gehen wir etwas nher auf die drei Bildschirmarten ein.
Dynpros
Jedes Dynpro enthlt eine frei programmierbare Bildschirmmaske zur Datenein- und -ausgabe. Bei der Darstellung der Bildschirmmaske durch den SAP GUI werden zwei Ereignisse ausgelst: Das Ereignis PBO (Process Before Output) tritt vor der Darstellung der Bildschirmmaske auf dem Bildschirm auf. Das Ereignis PAI (Process After Input) tritt durch eine Benutzeraktionen auf dem Bildschirm ein. Jede Bildschirmmaske ist mit genau zwei Verarbeitungsblcken der Ablauflogik verknpft, die auf diese Ereignisse reagieren, nmlich der PBO-Block und der PAI-Block. Die Zusammenfassung des PAI-Blocks eines Dynpros mit dem PBO-Block des darauf folgenden Dynpros bildet einen Dialogschritt des Anwendungsprogramms. Die Dynprosprache zur Programmierung der Ablauflogik ist eine spezielle Teilmenge von ABAP und enthlt nur wenige Sprachelemente. Die Anweisungen sind syntaktisch zwar hnlich zu den brigen ABAP-Anweisungen, es drfen aber keine Dynproanweisungen in ABAP-Programmen verwendet werden und umgekehrt. Die wichtigsten Dynprosprachelemente sind MODULE, FIELD, CHAIN, und LOOP. Sie dienen ausschlielich der Anbindung der Verarbeitungslogik an
42
April 2001
SAP AG
die Ablauflogik, d.h. dem Aufruf von Modulen in der Verarbeitungslogik und der Steuerung der Datenbergabe z.B. in Abhngigkeit von Fehlerberprfungen. Die Bildschirmmasken von Dynpros enthalten alle blichen Elemente grafischer Oberflchen (Ein- und Ausgabefelder, Drucktasten, Auswahlknpfe etc.). Die folgende Abbildung zeigt ein Beispiel fr eine Bildschirmmaske eines Dynpros:
Alle aktiven Elemente einer Bildschirmmaske haben Namen und sind mit sogenannten Dynprofeldern im Shared Memory verknpft. Dynprofelder knnen an das ABAP-Dictionary angebunden werden und erhalten dadurch automatische Feld- und Wertehilfefunktionen, sowie Konsistenzprfungen. Benutzeraktionen ndern die Feldinhalte der entsprechenden Dynprofelder. Der Wertetransport zwischen Dynpros und Verarbeitungslogik erfolgt dadurch, da beim PAI-Ereignis die Inhalte der Dynprofelder an gleichnamige Variablen im ABAP-Programm bergeben werden. Jedes Dynpro ruft im zugehrigen ABAP-Programm sogenannte Dialogmodule auf, welche die Inhalte der Bildschirmmasken vorbereiten (PBO) und die Benutzereingaben verarbeiten (PAI). Es gibt zwar ABAP-Anweisungen zum ndern von Bildschirmeigenschaften, wie z.B. das Ein- und Ausblenden von Bildschirmelementen, aber keine ABAP-Anweisungen fr deren Definition. Dynpros dienen dem Dialog zwischen Benutzer und Anwendungsprogrammen. Typischerweise werden Dynpros in stark dialogorientierten Programmen eingesetzt und dienen der Ausfhrung einer Anwendung, die aus der Bearbeitung einer Folge von Bildschirmen besteht. Sie kommen insbesondere immer dann zum Tragen, wenn die Mglichkeiten der spezialisierten Dynpros, nmlich des Selektionsbilds oder der Liste, nicht ausreichen.
Selektionsbilder
Selektionsbilder sind spezialisierte Dynpros zur Werteingabe in ABAP-Programmen. Sie werden allerdings nicht mit dem Werkzeug Screen Painter sondern ausschlielich ber ABAP-Befehle in
April 2001
43
SAP AG
der Verarbeitungslogik definiert. Das Selektionsbild wird entsprechend dieser Befehle generiert. Die Bildschirmablauflogik bleibt dabei fr den Anwendungsprogrammierer verborgen. Die Definition von Selektionsbildern erfolgt im Deklarationsteil von ABAP-Programmen ber spezielle Deklarationsanweisungen wie PARAMETERS, SELECT-OPTIONS und SELECTIONSCREEN. Diese Anweisungen deklarieren und formatieren die Eingabefelder eines Selektionsbilds. Die folgende Abbildung zeigt ein Beispiel fr ein Selektionsbild:
Die wichtigsten Elemente von Selektionsbildern sind Eingabefelder fr Einzelwerte und fr sogenannte Selektionstabellen. Selektionstabellen dienen dazu, komplexere BenutzerAbgrenzungen aufzunehmen. Bei Verwendung von Selektionstabellen in ABAP bernimmt das System vollstndig deren Verarbeitung. Wie bei jedem Dynpro stehen fr Eingabefelder, die einen Bezug zum ABAP-Dictionary haben, auch auf Selektionsbildern automatische Feld- und Wertehilfefunktionen zur Verfgung. Der Benutzer kann auf Selektionsbildern vorgefertigte Stze von Eingabewerten in der Form sognannter Varianten verwenden. Selektionsbilder werden aus ABAP-Programmen ber die Anweisung CALL SELECTIONSCREEN aufgerufen. Bei ausfhrbaren Programmen (Typ 1) ruft die ABAP-Laufzeitumgebung das im Deklarationsteil definierte Selektionsbild automatisch auf. Selektionsbilder lsen Ereignisse aus und knnen damit in ABAP-Programmen sogenannte Ereignisblcke aufrufen. Da auf Selektionsbildern hauptschlich Eingabefelder definiert werden, ist der Dialog von Selektionsbildern eingabebezogener als der von frei definierten Dynpros. Auf Dynpros sind Einund Ausgabe gleichberechtigt. Selektionsbilder knnen deshalb immer dann sinnvoll eingesetzt werden, wenn Benutzereingaben fr den weiteren Programmverlauf wesentlich sind. Beispielsweise werden Selektionsbilder vor Datenbankzugriffen eingesetzt, um die einzulesende Datenmenge einzuschrnken.
44
April 2001
SAP AG
Listen
Listen sind Bildschirme zur formatierten und strukturierten Darstellung von Daten. Listen werden ausschlielich ber ABAP-Befehle definiert, gestaltet und gefllt. Das System stellt eine in ABAP definierte Liste auf einem speziellen Listen-Dynpro dar. Wie bei Selektionsbildern bleibt dabei die Bildschirmablauflogik fr den Anwendungsprogrammierer verborgen. Die wichtigste Aufgabe von Listen ist die Datenausgabe. Sie erlauben aber auch Benutzerinteraktionen. Sie reagieren auf Mausklick und knnen Eingabefelder enthalten. Die Listendarstellung erfolgt aber mit einer vllig anderen Technik als die Dynprodarstellung. Eingabefelder auf Listen sind nicht mit Dynprofeldern gleichzusetzen denn der Datentransport zwischen Listen und ABAP-Programm geht anders vonstatten als bei Dynprofeldern. Wenn Eingabefelder auf Listen mit dem ABAP-Dictionary verknpft sind stehen auch bei ihnen automatische Feld- und Wertehilfefunktionen zur Verfgung. Die folgende Abbildung zeigt ein Beispiel fr eine Liste:
Die Definition von Listen erfolgt ber einen speziellen Satz von Anweisungen (Listenanweisungen WRITE, SKIP, ULINE, NEW-PAGE etc.) in den Verarbeitungsblcken von ABAP-Programmen. Bei der Ausfhrung dieser Anweisungen wird systemintern eine Liste beschrieben. Die Anzeige von Listen auf Bildschirmen und die Behandlung von Benutzeraktionen auf Listen erledigt ein systeminternes Programm, welches wir als Listenprozessor bezeichnen. Im R/3-System knnen nur Daten, die intern als Liste abgespeichert sind an das Spoolsystem z.B. zwecks Druckausgabe gesendet werden. In ABAP-Programmen kann mit der Anweisung LEAVE TO LIST-PROCESSING das Listendynpro als Folgebild definiert und eine beschriebene Liste damit zur Anzeige gebracht werden. Bei ausfhrbaren Programmen vom Typ 1 ruft die ABAP-Laufzeitumgebung die im Programm definierte Liste automatisch auf. Ein Programm kann einen Stapel von bis zu 21 Listen verwalten. Beispielsweise knnen ber einer Grundliste bis zu 20 Detaillisten erzeugt werden. Benutzeraktionen auf Listen lsen Ereignisse aus und knnen damit im ABAPProgramm sogenannte Ereignisblcke aufrufen.
April 2001
45
SAP AG
Listen sind hauptschlich ausgabeorientiert. Benutzeraktionen auf Listen dienen meistens der bernahme von Listeninhalten in die weitere Programmverarbeitung und nicht der direkten Eingabe von Werten. Der Einsatz von Listen ist deshalb immer dann sinnvoll, wenn mit Ausgabedaten gearbeitet wird, wenn Daten gedruckt werden sollen und wenn Benutzeraktionen sich auf Ausgabedaten beziehen.
46
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Aufbau von ABAP-Programmen
Aufbau von ABAP-Programmen

Die ABAP-Programme der Verarbeitungslogik bernehmen die zentrale Rolle der Datenverarbeitung in der R/3-Anwendungsprogrammierung. Die Programmiersprache ABAP ist speziell fr dialogorientierte Datenbankanwendungen konzipiert. In den folgenden Abschnitten gehen wir detailliert auf Aufbau und Ausfhrung von ABAP-Programmen ein.
Programmaufbau
ABAP-Programme dienen der Datenverarbeitung whrend der einzelnen Dialogschritte eines Anwendungsprogramms. Das bedeutet, da ABAP-Programme nicht als eine einzige sequentielle Einheit aufgebaut sein knnen, sondern in Abschnitte unterteilt sein mssen, die den einzelnen Dialogschritten zugeordnet werden knnen. Um dieser Anforderung gerecht zu werden, sind ABAP-Programme modular aus Verarbeitungsblcken aufgebaut. Ein Verarbeitungsblock besteht aus (normalerweise mehreren) ABAP-Anweisungen. Verarbeitungsblcke sind nicht schachtelbar und die Programmausfhrung beruht auf dem Aufruf von Verarbeitungsblcken. Das folgende Bild zeigt den Aufbau eines ABAP-Programms:
Deklarationsteil fr globale Daten
Dialogmodule
Ereignisblcke
Unterprogramme
etc.
Jedes ABAP-Programm besteht aus den folgenden zwei Teilen:

Deklarationsteil fr globale Daten, Klassen und Selektionsbilder
Der erste Teil eines ABAP-Programms ist der Deklarationsteil fr globale Daten, Klassen und Selektionsbilder. Dieser Teil wird gebildet aus:
allen Datendeklarationsanweisungen fr globale Daten. Globale Daten sind in allen internen Verarbeitungsblcken sichtbar. Sie werden durch die Datendeklarationsanweisungen definiert, die vor dem ersten Verarbeitungsblock, in Dialogmodulen oder in Ereignisblcken stehen. In den letztgenannten beiden Verarbeitungsblcken sind mit zwei Ausnahmen keine lokalen Daten deklarierbar. allen Definitionen von Selektionsbildern. allen Deklarationen von programminternen Klassen (Anweisung CLASS DEFINITION). Programminterne Klassen sind Teil von ABAP Objects, der objektorientierten Erweiterung von ABAP.
Datendeklarationsanweisungen, die Prozeduren (Methoden, Unterprogramme, Funktionsbausteine) aufgefhrt sind, bilden den Deklarationsteil fr die lokalen Daten dieser Verarbeitungsblcke. Diese Daten sind auch nur innerhalb der Prozeduren sichtbar.
April 2001
47
ABAP Programmierung (BC-ABA) Aufbau von ABAP-Programmen Container fr Verarbeitungsblcke
SAP AG
Der zweite Teil eines ABAP-Programms umfat alle Verarbeitungsblcke des Programms. Folgende Typen von Verarbeitungsblcken sind mglich:

Dialogmodule (kein lokaler Datenbereich) Ereignisblcke (bis auf zwei Ausnahmen kein lokaler Datenbereich) Prozeduren (Methoden, Unterprogramme und Funktionsbausteine mit jeweils lokalem Datenbereich)
Whrend Dialogmodule und Prozeduren durch definierende ABAP-Schlsselwrter eingeschlossen sind, werden Ereignisblcke durch Ereignisschlsselwrter eingeleitet und durch den nchsten Verarbeitungsblock beendet.
Alle ABAP-Anweisungen (bis auf die deklarativen Anweisungen des Deklarationsteils) sind Teil eines Verarbeitungsblocks. Nichtdeklarative ABAP-Anweisungen, die zwischen dem Deklarationsteil fr globale Daten und einem Verarbeitungsblock stehen, werden automatisch dem Ereignisblock START-OF-SELECTION zugeordnet. Aufruf von Verarbeitungsblcken
Der Aufruf von Verarbeitungsblcken kann werden entweder von auerhalb des ABAPProgramms oder durch ABAP-Befehle, die selbst wieder in Verarbeitungsblcken stehen, erfolgen. Dialogmodule und Ereignisblcke werden von auerhalb des ABAP-Programms aufgerufen, Prozeduren werden durch ABAP-Befehle in ABAP-Programmen aufgerufen. Der Aufruf von Ereignissblcken unterscheidet sich wie folgt von den Aufrufen von anderen Verarbeitungsblcken: Ereignisblcke werden aufgrund von Ereignissen aufgerufen. Benutzeraktionen auf Selektionsbildern und Listen aber auch die Laufzeitumgebung lsen Ereignisse aus, die in ABAP-Programmen behandelt werden knnen. Nur fr Ereignisse, auf die das Programm reagieren soll, mssen Ereignisblcke definiert sein (whrend z.B. zu einem Unterprogrammaufruf sehr wohl ein Unterprogramm existieren mu). Das bedeutet, da ein ABAP-Programm auf bestimmte Ereignisse reagieren kann, aber nicht mu.
Programmausfhrung und Programmtypen

Ein ABAP-Programm auszufhren bedeutet, seine Verarbeitungsblcke aufzurufen. ABAPProgramme werden von auerhalb des Programms gesteuert. Die Steuerung erfolgt durch die Prozessoren des aktuellen Workprozesses. Fr den zeitlichen Ablauf fassen wir DynproProzessor und ABAP-Prozessor der beteiligten Workprozesse zur ABAP-Laufzeitumgebung zusammen. Die Laufzeitumgebung steuert Bildschirme und ABAP-Verarbeitungsblcke. Die Laufzeitumgebung enthlt einige spezialisierte Steuerungsablufe, die Bildschirme und ABAPVerarbeitungsblcke in bestimmten, zweckgebundenen Reihenfolgen aufrufen knnen. Wir bezeichnen diese zeitlich aufeinanderfolgenden Abschnitte auch als Prozessoren. Bei der Ausfhrung eines ABAP-Programms wechseln sich die einzelnen Prozessoren hintereinander ab und es hat immer ein bestimmter Prozessor die Kontrolle.
48
April 2001
SAP AG
Bildschirm Bildschirm SAP GUI Prozessor ABAP-Laufzeitumgebung PBOLogik Dynpro-Ablauflogik PAILogik Prozessor Prozessor
Deklarationsteil fr globale Daten ABAP-Programm
Verarbeitungsblock
Verarbeitungsblock
Verarbeitungsblock
Im R/3-System unterscheiden wir zwischen verschiedenen Typen von ABAP-Programmen. Die Programmtypen mssen bei der Programmerstellung festgelegt werden. Sie definieren die grundlegenden technische Eigenschaften des Programms. Das wesentliche Unterscheidungsmerkmal zwischen den einzelnen Programmtypen ist die Art und Weise wie die Verarbeitungsblcke der Programme von der Laufzeitumgebung aufgerufen werden. Bei der Ausfhrung eines Anwendungs-Programms mu zumindest der erste Verarbeitungsblock eines ABAP-Programms von auerhalb des Programms, also aus der Laufzeitumgebung aufgerufen werden. Aus diesem Verarbeitungsblock heraus knnen dann weitere Verarbeitungsblcke aufgerufen oder die Kontrolle wieder an die Laufzeitumgebung abgegeben werden. Beim Start eines ABAP-Programms wird ein vom Programmtyp abhngiger Prozessor in der Laufzeitumgebung gestartet, der den ersten ABAP-Verarbeitungsblock aufruft. Der Start eines ABAP-Programms kann durch den Benutzer, aber auch durch das System, z.B. bei der Hintergrundverarbeitung, oder durch externe Schnittstellen, z.B. bei Remote-Function-Calls (RFC) erfolgen. Beim Programmstart durch Benutzer unterscheiden wir zwischen der direkten Ausfhrung durch Angabe des Programmnamens und dem Start ber Transaktionscodes. Sie knnen jedes Anwendungsprogramm mit einem Transaktionscode versehen. Der Benutzer kann das Programm dann ber die direkte Eingabe des Transaktionscodes starten. Weiterhin werden in der Regel alle Transaktionscodes auch mit Menpfaden auf den Bildschirmen des R/3-Systems verknpft. Folgende Programmtypen sind fr Anwendungsprogramme von Bedeutung:
Typ 1
Ein Typ 1-Programm hat die wichtige technische Eigenschaft, da es nicht unmittelbar ber selbstdefinierte Dynpros gesteuert werden mu. Bei einem Typ 1-Programm bernehmen Prozessoren der Laufzeitumgebung automatisch und in einer vorgegebenen Reihenfolge die
April 2001
49
SAP AG
Aufrufe von Verarbeitungsblcken und gegebenenfalls von Bildschirmen (Selektionsbilder und Listen). Benutzeraktionen auf den Bildschirmen knnen den Aufruf weiterer Verarbeitungsblcke vernanlassen. Ein Typ 1-Programm und damit der zugehrige Prozessor in der Laufzeitumgebung wird ausschlielich ber die Anweisung SUBMIT aus anderen ABAP-Programm heraus gestartet. Das R/3-System bietet verschiedene Mglichkeiten, die Ausfhrung von Typ 1-Programmen durch Angabe des Programmnamens auf Bildschirmbildern zu starten. Deshalb sprechen wir bei Typ 1Programmen auch von ausfhrbaren Programmen. Bei Typ 1-Programmen luft in der Laufzeitumgebung eine vordefinierte Folge von ProzessSchritten ab. Der Ablauf ermglicht erst eine Eingabe von Selektionsparametern auf einem Selektionsbild, dann eine Datenselektion und Datenverarbeitung und schlielich die Datenausgabe auf einer Liste, ohne da der Programmierer eigene Dynpros definieren mu. Weiterhin steuert die Laufzeitumgebung die Zusammenarbeit mit einer logischen Datenbank. Eine logische Datenbank ist ein spezielles ABAP-Programm zum Lesen von Daten aus Datenbanktabellen. Der vorgegebene Ablauf eines Typ 1-Programms orientiert sich somit an den Aufgaben des Reporting. Dazu zhlen Selektionseingabe, das Lesen von Daten, die Datenverarbeitung und die Darstellung der Daten. Aus diesem Grund werden ausfhrbare Programme vom Typ 1 im R/3-System oft als Report und das Starten von ausfhrbaren Programmen als Reporting bezeichnet. Da die Definition von Ereignisblcken nicht vorgeschrieben ist, kann der Programmierer entscheiden, auf welche Ereignisse das ausfhrbare Programm reagieren soll. Weiterhin kann er jederzeit eigene Dynpros oder Verarbeitungsblcke aufrufen, um den vorgegebenen Ablauf zu verlassen, z.B. um Daten statt auf einer Liste in einer Tabelle auf einem Dynpro darzustellen. Das einfachste ausfhrbare Programm enthlt z.B. nur den Standardverarbeitungsblock STARTOF-SELECTION. Fr die Ausfhrung von ausfhrbaren Programmen ist kein Benutzerdialog notwendig. Das Selektionsbild kann ber Varianten gefllt werden und Ausgabedaten knnen statt auf die Liste direkt ins Spool-System gestellt werden. Deshalb sind ausfhrbare Programme Voraussetzung fr die Hintergrundverarbeitung im R/3-System. Wenn ein ausfhrbares Programme vom Typ 1 mit Transaktionscodes versehen wird, kann der Benutzer das Programm auch ber den Transaktionscode starten. Auch in diesem Fall findet in der Laufzeitumgebung der reporting-orientierte Ablauf statt, weshalb wir solche Transaktionen auch als Report-Transaktionen bezeichnen. Der Einsatz von ausfhrbaren Programmen ist immer dann sinnvoll, wenn der Programmablauf ganz oder teilweise dem vordefinierten Ablauf in der Laufzeitumgebung entspricht. Vor Release 4.5A waren ausfhrbare Programme die Voraussetzung fr den Einsatz von logischen Datenbanken. Inzwischen knnen logische Datenbanken aber auch selbstndig aufgerufen werden.
Typ M
Die wichtigste technische Eigenschaft von Typ M-Programmen ist die Tatsache, da sie ausschlielich ber die Ablauflogik von Dynpros gesteuert werden. Diese Programme mssen ber Transaktionscodes aufgerufen werden, die mit einem Dynpro (Startdynpro) des Programms verknpft sind. Bei diesen Programmen mu der Programmierer also eigene Dynpros definieren, wobei das Startdynpro auch ein Selektionsbild sein kann. Beim Start des Programms ber den Transaktionscode wird in der Laufzeitumgebung ein Prozessor gestartet, der zunchst das Startdynpro aufruft, welches dann ein Dialogmodul des zugehrigen ABAP-Programms aufruft. Der weitere Ablauf ist vllig beliebig. Das Dialogmodul kann beispielsweise
50
April 2001
SAP AG
die Kontrolle an das Dynpro zurckgeben, dann verzweigt der Ablauf zu einem Folgedynpro. Jedes Dynpro hat ein statisches oder dynamisches Folgedynpro. Dynpros und ihre Folgedynpros sind die Bestandteile von frei definierbaren Dynprofolgen. andere Dynprofolgen, Selektionsbilder oder Listen aufrufen, von denen dann wiederum die entsprechenden Verarbeitungsblcke im ABAP-Programm gestartet werden. andere interne oder externe Verarbeitungsblcke aufrufen. andere Anwendungsprogramme ber CALL TRANSACTION oder SUBMIT aufrufen.
Da ABAP-Programme mit dem Programmattribut Typ M hauptschlich Dialogmodule der zugehrigen Dynpros enthalten, bezeichnen wir sie als Modulpool. Die Arbeit mit Modulpools ist bei stark dialogorientierten Programmen mit vielen Dynpros sinnvoll, in denen der Programmablauf weitgehend durch die Ablauflogik von Dynprofolgen definiert wird.
Typ F
Typ F-Programme knnen nicht ber Transaktionscodes oder Eingabe des Namens gestartet werden, sondern dienen ausschlielich als Container fr Funktionsbausteine. Funktionsbausteine sind spezielle Prozeduren im R/3-System, die aus anderen ABAPProgrammen aufgerufen werden knnen. Wir bezeichnen Typ F-Programme auch als Funktionsgruppen. Funktionsbausteine drfen nur in Funktionsgruppen programmiert werden. Zur Erstellung von Funktionsbausteinen und Funktionsgruppen enthlt die ABAP Workbench das spezielle Werkzeug Function Builder. Auer Funktionsbausteinen knnen Funktionsgruppen globale Datendeklarationen und Unterprogramme enthalten, die fr alle Funktionsbausteine sichtbar sind. Wie Programme vom Typ 1 und M knnen Funktionsgruppen Bildschirme, also eigene Dynpros, Selektionsbilder und Listen enthalten. Die Verarbeitung dieser Bildschirme, d,h. die Reaktion auf Benutzeraktionen in Ereignisblcken und Dialogmodulen, findet ebenfalls in der Funktionsgruppe statt. Der Aufruf der Bildschirme erfolgt aus den Funktionsbausteinen der Gruppe. Eine Funktionsgruppe mit Bildschirmen und einem einzigen Funktionsbaustein ermglicht also die Modularisierung von Bildschirmablufen.
Typ K
Typ K-Programme knnen nicht ber Transaktionscodes oder Eingabe des Namens gestartet werden, sondern ein Typ K-Programm dient ausschlielich als Container fr eine globale Klasse in ABAP Objects. Wir bezeichnen Typ K-Programme als Klassen-Definitionen. Zur Erstellung von Klassen-Definitionen enthlt die ABAP Workbench das spezielle Werkzeug Class Builder.
Typ J
Typ J-Programme knnen nicht ber Transaktionscodes oder Eingabe des Namens gestartet werden, sondern ein Typ J-Programm dient ausschlielich als Container fr ein globales Inrterface in ABAP Objects. Wir bezeichnen Typ J-Programme als Interface-Definitionen. Interface-Definitionen werden wie Klassen-Definitionen mit dem Werkzeug Class Builder der ABAP Workbench erstellt.
Typ S
Typ S-Programme knnen nicht ber Transaktionscodes oder Eingabe des Namens gestartet werden, sondern ein Typ S-Programm dient ausschlielich als Container fr Unterprogramme, die extern aus anderen ABAP-Programmen aufgerufen werden knnen. Wir bezeichnen Typ SProgramme als Subroutinenpool. Subroutinenpools knnen keine Bildschirme enthalten.
April 2001
51
ABAP Programmierung (BC-ABA) Aufbau von ABAP-Programmen Typ I
SAP AG
Typ I-Programme sind nicht ausfhrbar, sondern dienen ausschlielich als Mittel um Programmtexte in kleine editierbare Einheiten zu gliedern. Wir nennen Typ-I Programme Include-Programme. Der Programmtext in Include-Programmen kann ber die Anweisung INCLUDE an beliebigen Stellen anderer ABAP-Programm eingefgt werden. Include-Programme stehen technisch in keinerlei Zusammenhang mit Verarbeitungsblcken. Es bietet sich aber an logische Programmeinheiten, wie den Deklarationsteil fr globale Daten, mehrere gleichartige oder einzelne Verarbeitungsblcke in jeweils eigene Include-Programme aufzuteilen. Die ABAP Workbench untersttzt die automatische Aufteilung von Modulpools und Funktionsgruppen auf Include-Programme.
52
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Verarbeitungsblcke in ABAP-Programmen
Verarbeitungsblcke in ABAP-Programmen
Die folgenden Abschnitten fhren die mglichen Verarbeitungsblcke von ABAP-Programmen und ihren Aufruf ein.
Programm-Konstruktor
Direkt nach dem Laden eines Programms vom Typ 1, M, F und S kann ein spezieller Verarbeitungsblock genau einmal ausgefhrt werden. Dieser Verarbeitungsblock wird mit dem Ereignisschlsselwort LOAD-OF-PROGRAM als Ereignisblock definiert. Der Verarbeitungsblock zu LOAD-OF-PROGRAM spielt fr diese ABAP-Programme in etwa die gleiche Rolle, wie ein Konstruktor fr Klassen in ABAP Objects.
Dialog-Module
Dialogmodule werden aus der Ablauflogik aufgerufen (Dynpro-Befehl MODULE). Fr die verschiedenen Zustnde eine Dynpros (PAI, PBO, Benutzereingaben) knnen somit im zugeordneten ABAP-Programm Dialogmodule programmiert werden. Die Zusammenfassung aller PAI- und PBO-Module zweier aufeinanderfolgender Dynpros ist die Verarbeitungslogik eines Dialogschritts. Das Zusammenspiel zwischen Ablauflogik und Bildschirmen steuert ein Dialogprozessor. Syntaktisch werden Dialogmodule durch die Anweisung MODULE eingeleitet und durch die Anweisung ENDMODULE beendet.
Bildschirm Bildschirm SAP GUI
Bildschirm Bildschirm
Dialogprozessor ABAP-Laufzeitumgebung PBOLogik Dynpro-Ablauflogik PAILogik PBOLogik PAILogik
Deklarationsteil fr globale Daten ABAP-Programm
PBODialogmodul
PBODialogmodul
PAIDialogmodul
PAIDialogmodul
Die Datenbergabe zwischen Dynpros und ABAP-Programm erfolgt dadurch, da in Dynpros und ABAP-Programm namensgleiche Felder verwendet werden. Die Dynpros werden nicht im ABAP-Programm definiert.
April 2001
53
SAP AG
Ereignisblcke zu Selektionsbildern
Das Selektionsbild ist ein spezielles Dynpro, das vollstndig mit ABAP-Befehlen im Deklarationsteil gestaltet wird. Die verschiedenen Zustnden des Selektionsdynpros (PAI, PBO, Benutzereingaben) werden von einem Selektionsbildprozessor in bestimmte Ereignisse verwandelt und fr diese knnen im Programm die Ereignisblcke zu Selektionsbildern programmiert werden. Der Selektionsbildprozessor umfat auch die Dynproablauflogik des Selektionsbilds.
SAP GUI
SelektionsSelektionsbild bild
ABAP-Laufzeitumgebung
Selektionsbildprozessor PBOLogik PAILogik
Dynpro-Ablauflogik Deklarationsteil
PARAMETERS SELECT-OPTIONS SELECTION-SCREEN
Ereignisblock
AT SELECTIONSCREEN OUTPUT
Ereignisblock
AT SELECTIONSCREEN
Ereignisblock
AT SELECTIONSCREEN ON <field>
ABAP-Programm
Der Programmierer erstellt die Dynproablauflogik eines Selektionsbilds nicht selbst und fr die entsprechenden Dynpro-Ereignisse PBO und PAI knnen keine eigenen Dialogmodule angelegt werden. Die Datenbergabe zwischen Selektionsbildern und ABAP-Programm erfolgt ber die Felder (Parameter und Selektionstabellen), die bei der Definition des Selektionsbilds im Deklarationsteil des ABAP-Programms angelegt werden.
Ereignisblcke zu Listen
Listen sind spezielle Bildschirme zur formatierten Datenausgabe. Listen werden in beliebigen Verarbeitungsblcken eines ABAP-Programms ber einen speziellen Befehlssatz erzeugt (Listen-Anweisungen sind z.B. WRITE, NEW-PAGE). Ein Listenprozessor erledigt die Anzeige von Listen auf Bildschirmen und die Behandlung von Benutzeraktionen auf Listen. Der Listenprozessor umfat auch die Dynproablauflogik der Listen. Der Programmierer erstellt die Dynproablauflogik einer Liste nicht selbst und fr die entsprechenden Dynpro-Ereignisse PBO und PAI knnen keine eigenen Dialogmodule angelegt werden.
54
April 2001
SAP AG
Liste SAP GUI Listenprozessor PBOLogik Dynpro-Ablauflogik Verarbeitungsblock

WRITE ULINE SKIP
ABAP-Laufzeitumgebung
PAILogik
Ereignisblock
TOPOFPAGE
Ereignisblock
AT LINESELECTION
Ereignisblock
AT USERCOMMAND
ABAP-Programm
Whrend der Listenerstellung kann es zum Aufruf von bestimmten Ereignisblcken kommen, die der Seitengestaltung dienen. In obigen Bild ist das der Ereignisblock TOP-OF-PAGE, der sozusagen aus dem ABAP-Programm selbst aufgerufen wird. Whrend der Listenanzeige kann der Benutzer Interaktionen ausfhren, welche der Listenprozessor in Ereignisse (z.B AT LINESELECTION) verwandelt. Im Programm knnen Ereignisblcke fr diese interaktiven Listenereignissen programmiert werden. Die Datenbergabe von der Liste zu dem ABAPProgramm erfolgt ber spezielle Variablen oder ber einen internen Speicherbereich, den sogenannten HIDE-Bereich.
Ereignisblcke fr ausfhrbare Programme

Beim Start von ausfhrbaren Programmen vom Typ 1 bernimmt ein in der Laufzeitumgebung vorgegebener Ablauf die Kontrolle. Es werden eine Reihe bestimmter Prozessoren hintereinander ausgefhrt. Diese Prozessoren lsen bestimmte Ereignisse aus, fr die Ereignisblcke definiert werden knnen. ABAP-Programme vom Typ 1 sind also ereignisorientiert.
April 2001
55
SAP AG
SAP GUI Initialisierung Laufzeitumgebung
SelektionsSelektionsbild bild Reportingprozessor Selektionsbildprozessor
Liste
Listenprozessor
Ablauflogik
Deklarationsteil fr globale Daten Ereignisblock INITIALIZATION Ereignisblock AT SELECTION SCREEN Ereignisblock STARTOFSELECTION Ereignisblock ENDOFSELECTION Ereignisblock AT LINESELECTION
ABAP-Programm
Der Ablauf ist wie folgt: 1. Die Laufzeitumgebung erzeugt das Ereignis INITIALIZATION und ruft damit den entsprechenden Ereignisblock auf, falls er im ABAP-Programm definiert ist. 2. Falls im Deklarationsteil des Programms ein Selektionsbild deklariert ist, geht die Kontrolle an den Selektionsbildprozessor ber. Dieser erzeugt die entsprechenden Ereignisse und ruft dadurch die zugehrigen Ereignisblcke auf. 3. Die Kontrolle geht an den sogenannten Reportingprozessor ber. Dieser erzeugt ein Ereignis START-OF-SELECTION und ruft damit den entsprechenden Ereignisblock auf, falls er im ABAP-Programm definiert ist. 4. Falls eine logische Datenbank verwendet wird, ruft die logische Datenbank an dieser Stelle weitere Ereignisblcke auf. 5. Der Reportingprozessoer erzeugt ein Ereignis END-OF-SELECTION und ruft damit den entsprechenden Ereignisblock auf falls er im ABAP-Programm definiert ist. 6. Falls im Programm eine Liste beschrieben wurde, geht die Kontrolle an den Listenprozessor ber. Der Listenprozessor stellt die im ABAP-Programm beschriebene Liste dar. Er verwandelt Benutzeraktionen auf der Liste in Ereignisse und ruft dadurch die zugehrigen Ereignisblcke auf. 7. Falls im Deklarationsteil des Programms ein Selektionsbild deklariert ist, wird nach Beendigung des Programms (Verlassen der Liste), das gleiche Programm automatisch wieder aufgerufen.
56
April 2001
SAP AG
Unterprogramme
Unterprogramme werden aus ABAP-Programmen (Anweisung PERFORM) aufgerufen. Syntaktisch werden Unterprogramme durch die Anweisung FORM eingeleitet und durch die Anweisung ENDFORM beendet.
Verarbeitungsblock
PERFORM
Unterprogramm
FORM ... ENDFORM
Unterprogramm
FORM ... ENDFORM
ABAP-Programm Unterprogramm
FORM ... ENDFORM
Unterprogramm
FORM ... ENDFORM
ABAP-Programm
Unterprogramme knnen in beliebigen ABAP-Programmen definiert werden. Der Aufruf von Unterprogrammen ber die Anweisung PERFORM erfolgt entweder innerhalb eines ABAPProgramms als interne Unterprogramme oder ber Programmgrenzen hinweg als externe Unterprogramme. Bei internen Performs knnen globale Daten zur Datenbergabe verwendet werden. Bei externen Aufrufen mu eine parametrisierte bergabe von Aktual- an Formalparameter erfolgen.
Funktionsbausteine
Funktionsbausteine sind externe Funktionen mit fest definierter Schnittstelle. Funktionsbausteine werden aus ABAP-Programmen mit der Anweisung CALL FUNCTION aufgerufen. Syntaktisch werden Funktionsbausteine durch die Anweisung FUNCTION eingeleitet und durch die Anweisung ENDFUNCTION beendet.
April 2001
57
SAP AG
Verarbeitungsblock
CALL FUNCTION
ABAP-Programm Deklarationsteil fr globale Daten Funktionsgruppe

Funktionsbausteine werden ausschlielich mit dem Werkzeug Function Builder der ABAP Worbench innerhalb spezieller ABAP-Programme namens Funktionsgruppen definiert. Aus anderen ABAP-Programmen sind sie also nur extern aufrufbar. Im Unterschied zu Unterprogrammen erfolgt die Datenbergabe daher immer ber eine explizit definierte Parameter-Schnittstelle.
Funktionsbaustein
FUNCTION ... ENDFUNCTION
Funktionsbaustein
FUNCTION ... ENDFUNCTION
Methoden
Methoden enthalten die Funktionalitt von Klassen in ABAP Objects. Wie Funktionsbausteinen haben sie eine fest definierte Schnittstelle. Methoden werden aus ABAP-Programmen mit der Anweisung CALL METHOD aufgerufen. Syntaktisch werden Funktionsbausteine durch die Anweisung METHOD eingeleitet und durch die Anweisung ENDMETHOD beendet.
58
April 2001
SAP AG
Verarbeitungsblock
CALL METHOD
ABAP-Programm
Deklarationsteil von Attributen und Methoden Definition Klasse
Methode
METHOD ... ENDMETHOD
Methode
METHOD ... ENDMETHOD
Implementierung
Methoden werden ausschlielich im Implemetierungsteil von Klassen definiert. Dies geschieht entweder global mit dem Werkzeug Class Builder der ABAP Worbench oder lokal innerhalb von ABAP-Programmen. Methoden arbeiten mit Attributen ihrer Klasse oder mit Daten, die ber die explizit definierte Parameter-Schnittstelle bergeben werden.
April 2001
59
ABAP Programmierung (BC-ABA) ABAP-Sprachelemente
SAP AG
ABAP-Sprachelemente
Der Quelltext eines ABAP-Programms besteht aus Kommentaren und ABAP-Anweisungen. Kommentare unterscheiden sich durch die voranstehenden Zeichen * (am Zeilenanfang) und " (an beliebiger Zeilenposition) von den ABAP-Anweisungen. ABAP-Anweisungen beginnen immer mit einem ABAP-Schlsselwort und werden durch einen Punkt (.) abgeschlossen. Anweisungen knnen sich ber mehrere Programmzeilen erstrecken und es knnen mehrere Anweisungen in einer Zeile stehen. ABAP-Anweisungen arbeiten mit ABAP-Datentypen und -objekten.
Anweisungen und Schlsselwrter

Die erste Position einer ABAP-Anweisung nimmt ein ABAP-Schlsselwort ein. Dieses bestimmt die Kategorie der Anweisungen. Wir unterscheiden folgende Kategorien von Anweisungen:
Deklarative Anweisungen
Diese Anweisungen definieren Datentypen oder deklarieren Datenobjekte, mit denen die anderen Anweisungen eines Programms oder einer Routine arbeiten. Die Gesamtheit aller deklarativen Anweisungen eines Programms oder einer Routine bilden den Deklarationsteil des Programms oder der Routine. Beispiele fr Schlsselwrter deklarativer Anweisungen sind:
TYPES, DATA, TABLES Modularisierungs-Anweisungen
Diese Anweisungen definieren Verarbeitungsblcke in einem ABAP-Programm. Schlsselwrter fr Modularisierungs-Anweisungen teilen sich auf in:
Zeitpunkt-Schlsselwrter Anweisungen mit diesen Schlsselwrtern definieren Ereignisblcke. Ereignisblcke werden nicht durch spezielle Anweisungen beendet, sondern durch die Modularisierungs-Anweisung des nchsten Verarbeitungsblocks. Beispiele fr Zeitpunkt-Schlsselwrter sind:
AT SELECTION SCREEN, START-OF-SELECTION, AT USER-COMMAND
Definierende Schlsselwrter Anweisungen mit diesen Schlsselwrter definieren Unterprogramme, Funktionsbausteine, Dialogmodule und Methoden. Diese Verarbeitungsblcke werden durch entsprechende END-Anweisungen abgeschlossen. Beispiele fr definierende Schlsselwrter:
FORM ... ENDFORM, FUNCTION ... ENDFUNCTION, MODULE ... ENDMODULE.
Steuernde Anweisungen
Diese Anweisungen steuern den Ablauf eines ABAP-Programms innerhalb eines Verarbeitungsblocks abhngig von bestimmten Bedingungen.
60
April 2001
SAP AG
Beispiele fr Schlsselwrter steuernder Anweisungen sind:

IF, WHILE, CASE Aufrufende Anweisungen
Diese Anweisungen rufen Verarbeitungsblcke (durch Modularisierungs-Anweisungen definiert) im gleichen oder einem externen ABAP-Programm auf oder verzweigen vollstndig in andere Programme. Beispiele fr Schlsselwrter aufrufender Anweisungen sind:
PERFORM, CALL, SET USER-COMMAND, SUBMIT, LEAVE TO Operationale Anweisungen
Diese Anweisungen bearbeiten die Daten, die durch deklarative Anweisungen definiert werden. Beispiele fr Schlsselwrter operationaler Anweisungen sind:
WRITE, MOVE, ADD Datenbank-Anweisungen
Diese Anweisungen greifen ber die Datenbankschnittstelle auf Datenbanktabellen des zentralen Datenbanksystems zu. In ABAP hat der Programmierer Zugriff auf zwei Arten von Anweisungen, nmlich Open SQL und Native SQL. Open SQL Open SQL ist eine Teilmenge von Standard SQL92 und beschrnkt sich auf DML-Anweisungen (Data Manipulation Language), wie z.B. SELECT, INSERT und DELETE. DDL-Anweisungen (Data Definitionion Language), wie z.B. CREATE TABLE oder CREATE INDEX, sind nicht in Open SQL enthalten, sondern in dem Werkzeug ABAP Dictionary der ABAP Workbench verborgen. Open SQL stellt die Schnittmenge der DML-Funktionalitt von SQL92 zur Verfgung, fr die alle von SAP untersttzten Datenbanksystemen eine gemeinsame Programmierschnittstelle haben. Weiterhin enthlt Open SQL einige SAP-spezifische Erweiterungen. ABAP-Programme, die ausschlielich Open SQL-Befehle fr Datenbankzugriffe verwenden, sind unabhngig vom Datenbanksystem. Die Open SQL-Befehle werden in der Datenbankschnittstelle in herstellerspezifisches Standard SQL umgesetzt. Native SQL Native SQL-Anbweisungen werden in der Datenbankschnittstelle ohne Umsetzung direkt an die Datenbank bergeben. ber Native SQL knnen ABAP-Programme alle Eigenschaften der verwendeten Datenbank nutzen. Insbesondere erlauben Native SQL-Anweisungen auch DDL (Data Definition Language) Operationen. Das Werkzeug ABAP Dictionary verwendet solche Native SQL-Anweisungen z.B. zum Anlegen von Datenbanktabellen. In ABAP-Programmen selbst sind DDL-Anweisungen dagegen nicht sinnvoll, da dann die zentrale Verwaltung der angelegten Objekte durch das ABAP-Dictionary nicht gegeben ist. Wegen der mangelnden Standardisierung der Programmierschnittstellen von SQL92, sind ABAP-Programme, die Native SQL-Anweisungen enthalten, datenbankabhngig.
Datentypen und -objekte

Die physikalischen Einheiten, mit denen ABAP-Anweisungen zur Laufzeit arbeiten, nennen wir programmlokale Datenobjekte. Der Inhalt von Datenobjekten belegt Platz im Speicher des Programms. ABAP-Anweisungen greifen ber den Namen der Datenobjekte auf diesen Inhalt zu. Beispielsweise schreiben Anweisungen den Inhalt von Datenobjekten auf Listen oder in
April 2001
61
SAP AG
Datenbanken, bergeben ihn an Routinen, verndern ihn durch Zuweisungen oder vergleichen ihn in logischen Ausdrcken. Jedes ABAP-Datenobjekt hat bestimmte technische Eigenschaften, die zu jedem Zeitpunkt der Laufzeit eines ABAP-Programms vollstndig spezifiziert sind. Die technischen Eigenschaften eines Datenobjekts sind: Datentyp, Feldlnge und Anzahl der Nachkommastellen. Der Datentyp bestimmt wie der Inhalt eines Datenobjekts von ABAP-Anweisungen interpretiert wird. Datentypen treten in ABAP zum einen als Attribute von Datenobjekten auf, zum anderen knnen sie eigenstndig definiert werden fr eine sptere Verwendung mit einem Datenobjekt. Die Definition von eigenstndigen Datentypen kann programmintern im Deklarationsteil mit der Anweisung TYPES oder programmbergreifend im ABAP-Dictionary erfolgen. Die Verwendung bestimmter Datentypen richtet sich nach der Verwendung der Datenobjekte im Programm. Die Aufgaben von ABAP-Programmen reichen von der Weitergabe einzelner Eingabedaten an Datenbanken bis zur Verarbeitung und Ausgabe strukturierter Massendaten aus Datenbanken. Fr diesen Zweck bietet die Sprache ABAP folgende Datentypen an:
Vordefinierte und benutzerdefinierte elementare Datentypen
Es gibt fnf vordefinierte nichtnumerische Typen: Zeichenketten (C), numerische Zeichenketten (N), Datumsfelder (D), Zeitfelder (T) und Hexadezimalfelder (X) und drei vordefinierte numerische Typen: Integer (I), Gleitpunktzahlen (F) und gepackte Zahlen (P). Mit den Datentypen D, F, I, und T ist die Feldlnge fest vorgegeben. Die Feldlnge gibt den Speicherplatz in Bytes wieder, die von einem Datenobjekt im Speicher belegt wird. Bei den brigen Datentypen C, N, X und P ist die Feldlnge nicht implizit durch den Typ festgelegt, sondern wird bei der Deklaration eines Datenobjekts im Programm definiert. Der Datentyp P ist von besonderer Bedeutung fr exakte Berechnungen, z.B. im kaufmnnischen Bereich. Hierfr wird bei der Deklaration eines Datenobjekts vom Typ P die Anzahl der Nachkommastellen definiert. ABAP erlaubt mit der Anweisung TYPES die Definition von benutzerdefinierten elementaren Datentypen, die auf den vordefinierten elementaren Datentypen beruhen. Dabei werden smtliche technischen Merkmale des neuen Datentyps festgeschrieben. Beispielsweise kann man basierend auf dem vordefinierten Typ P einen neuen Typ P_2 definieren, der zwei Nachkommastellen hat, und diesen verwenden, um entsprechende Datenobjekte zu deklarieren. Elementare Datentypen verwendet man zur Definition einzelner elementarer Datenobjekte. Solche Objekte dienen z.B. dem Transfer von einzelnen Ein- und Ausgabewerten, als Hilfsfelder fr Berechnungen oder zum Speichern von Zwischenergebnissen. Die im folgenden beschriebenen aggregierten Datentypen werden aus den elementaren Datentypen aufgebaut. Bei den aggregierten Datentypen unterscheiden wir zwischen Strukturen (auch Feldleisten genannt) und internen Tabellen.
Strukturen (Feldleisten)
Strukturen bestehen aus einer Folge beliebiger Datentypen und spezifizieren ein Datenobjekt technisch vollstndig. Auf solche Datenobjekte kann sowohl komponentenweise als auch insgesamt zugegriffen werden. Es gibt in ABAP keine Strukturen. Der Aufbau einer Struktur mu entweder in ABAP-Programmen selbst oder im ABAP-Dictionary definiert werden.
62
April 2001
SAP AG
Strukturen dienen in ABAP-Programmen zur Zusammenfassung von logisch zusammengehrigen Arbeitsbereichen. Da die Einzelelemente von Strukturen beliebige Datentypen haben knnen, also wiederum Strukturen oder interne Tabellen sein knnen, sind die Einsatzmglichkeiten von Strukturen sehr umfassend. Beispielsweise dienen Strukturen mit elementaren Elementen der programminternen Darstellung von Zeilen aus Datenbanktabellen und Strukturen mit aggregierten Elementen werden eingesetzt, um alle Eigenschaften eines Bildschirms oder Controls in einem Datenobjekt zusammenzufassen.
Interne Tabellen
Interne Tabellen bestehen aus einer Folge von Zeilen gleichen Datentyps. Interne Tabellen sind charakterisiert durch
einen Zeilentyp. Der Zeilentyp einer internen Tabelle kann ein beliebiger ABAP-Datentyp sein, also ein elementarer Typ, eine Struktur oder eine interne Tabelle.
einen Schlssel Der Schlssel von internen Tabellen dient der Identifikation von Tabellenzeilen. Er lt sich aus den elementaren Feldern der Zeilen aufbauen. Wir knnen weiterhin zwischen eindeutigen und nichteindeutigen Schlsseln unterscheiden.
die Zugriffsart Die Zugriffsart definiert, wie ABAP auf die interne Tabelle zugreift. Bei der Zugriffsart lassen sich unsortierte und sortierte Indextabellen sowie Hash-Tabellen unterscheiden. Bei Index-Tabellen wird intern ein linearer Index gefhrt, so da der Zugriff auf Tabellenzeilen sowohl ber Indexangabe als auch ber den Schlssel erfolgen kann. Bei Hash-Tabellen wird kein linearer Index gefhrt. Der Zugriff auf Tabellenzeile erfolgt ausschlielich unter Angabe des Schlssels. Hierbei fhrt das System intern einen Hash-Algorithmus aus.
Interne Tabellen werden immer dann eingesetzt, wenn mehrfache Daten einer festen Struktur programmintern verwendet werden. Ein wichtiges Einsatzgebiet ist z.B. die programminterne Speicherung von Daten aus der Datenbank.
Datentyp fr Referenzen
Referenzen dienen zur Zeit ausschlielich als Objektreferenzen in ABAP Objects. Referenzen liegen in Referenzvariablen und der Datentyp der Referenzvariablen bestimmt, wie das Programm die Referenz behandelt. Wir unterscheiden zwischen Datentypen fr Klassen- und Interfacereferenzen. Referenzvariablen werden in ABAP wie andere Datenobjekte mit elementarem Datentyp behandelt. Das bedeuted, da eine Referenzvariable nicht nur als Einzelfeld, sondern auch als kleinste unteilbare Einheit komplexer Datenobjekte wie Strukturen oder interne Tabellen definiert werden kann.
Deklaration von Datenobjekten
Abgesehen von Schnittstellenparametern von Routinen werden alle Datenobjekte eines ABAPProgramms oder einer Routine mit deklarativen Anweisungen in deren Deklarationsteil. Diese deklarativen Anweisungen legen den Datentyp und gegebenenfalls die noch fehlenden technischen Eigenschaften nmlich Feldlnge und Nachkommastellen vor der eigentlichen Programmausfhrung fest. Eine Ausnahme bilden die internen Tabellen.
April 2001
63
SAP AG
Bei der Deklaration eines Datenobjekts als interne Tabelle werden genau alle technischen Eigenschaften festgelegt mit Ausnahme der Feldlnge des Datenobjekts. Bei internen Tabellen liegt nur die Lnge einer Zeile fest, whrend die Anzahl der Zeilen also die eigentliche Lnge des Datenobjekts im Speicher dynamisch whrend des Programmablaufs angepat wird. Interne Tabellen sind somit dynamisch erweiterbare Datenobjekte einer festen Struktur. Schnittstellenparameter von Routinen werden dagegen erst beim Aufruf der Routine als lokale Datenobjekte erzeugt. Die technischen Eigenschaften eines Schnittstellenparameters knnen entweder in der Routine selbst festgelegt werden oder sie werden beim Aufruf der Routine von den bergabeparametern bernommen.
64
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Logische Datenbanken und Contexte
Logische Datenbanken und Contexte

Dieser Abschnitt beschreibt fhrt logische Datenbanken und Contexte ein, die das Lesen von Daten von der Datenbank erleichtern. Bei beiden werden die eigentlichen Open SQLAnweisungen in eigenen ABAP-Programmen gekapselt.
Logische Datenbanken
Logische Datenbanken sind spezielle ABAP-Programme, die Daten aus Datenbanktabellen lesen und ausfhrbaren ABAP-Programmen (Typ 1) zur Verfgung stellen. Zur Laufzeit kann man sich logische Datenbank und ausfhrbares ABAP-Programm als ein einziges ABAP-Programm denken, dessen Verarbeitungsblcke in bestimmter vorgegebener Reihenfolge von der Laufzeitumgebung aufgerufen werden. Logische Datenbanken werden mit einen eigenen Tool der ABAP Workbench gepflegt und knnen mit ausfhrbaren Programmen bei der Festlegung der Programmattribute verknpft werden. Eine logische Datenbank kann mit beliebig vielen ausfhrbaren Programmen verknpft werden. Seit Release 4.5A knnen logische Datenbanken auch selbstndig aufgerufen werden.
Aufbau einer logischen Datenbank

Den Aufbau einer logischen Datenbank knnen wir in drei Teile gliedern, die im folgenden Bild dargestellt sind:
April 2001
65
SAP AG
Logische Datenbank
Struktur Selektionen Datenbankprogramm
Verarbeitungsblock
GET TABLE ...
Ausfhrbares Programm
Struktur
Die Struktur legt die Datenbanktabellen legt die Auswahl der Datenbanktabellen fest, auf welche die logische Datenbank zugreifen kann. Sie bernimmt die gegebene Hierarchie der Datenbanktabellen, die durch Fremdschlsselbeziehungen festgelegt ist und regelt die Reihenfolge des Zugriffs auf mehrere Datenbanktabellen.
Selektionsteil
Der Selektionsteil definiert Eingabefelder fr Abgrenzungen in der logischen Datenbank, welche die Laufzeitumgebung zu Beginn des ausfhrbaren Programms auf dem Selektionsbild zur Anzeige bringt. Die entsprechenden Felder sind auch im ausfhrbaren ABAP-Programm sichtbar und knnen dort fr eine eventuelle Vorbelegung des Selektionsbilds gendert werden.
Datenbankprogramm
Das Datenbankprogramm einer logischen Datenbank ist ein Container fr spezielle Unterprogramme, in denen unter anderem die Daten aus den Datenbanktabellen gelesen werden. Diese Unterprogramme werden vom Reportingprozessor der Laufzeitumgebung in einer von der Struktur vorgebenenen Reihenfolge aufgerufen.
66
April 2001
SAP AG
Ausfhrung von Typ 1-Programmen mit logischer Datenbank

Das folgende Bild zeigt die wichtigsten Verarbeitungsblcke, die bei der Ausfhrung eines ausfhrbaren Programms, das mit einer logischen Datenbank verknpft ist, aufgerufen werden.
SAP GUI Initialisierung Laufzeitumgebung
SelektionsSelektionsbild bild Reportingprozessor Selektionsbildprozessor
Liste
Listenprozessor
Ablauflogik
Unterprogramm FORM INIT. ... ENDFORM. Unterprogramme FORM PBO. FORM PAI. ... ENDFORM. Unterprogramm FORM PUT TABLE1. ..PUT.. ENDFORM. Unterprogramm FORM PUT TABLE2. ..PUT.. ENDFORM.
Datenbank-Programm
Ereignisblock INITIALIZATION Ereignisblock AT SELECTION SCREEN Ereignisblock STARTOFSELECTION Ereignisblock GET TABLE1 ... Ereignisblock GET TABLE2 ... Ereignisblock ENDOFSELECTION
Ausfhrbares Programm (Typ 1)
Die Aufrufe der Laufzeitumgebung hngen zum einen von der Struktur der logischen Datenbank und zum anderen von der Definition des ausfhrbaren Programms ab. Die Struktur der logischen Datenbank bestimmt, in welcher Reihenfolge die Unterprogramme der logischen Datenbank aufgerufen werden, die wiederum GET-Ereignisblcke im ausfhrbaren Programm aufrufen. Die im ausfhrbaren Programm definierten GET-Ereignisblcke bestimmen die Lesetiefe der logischen Datenbank. TABLES- oder NODES-Anweisungen im Deklarationsteil des ausfhrbaren Programms bestimmen welche der in der logischen Datenbank definierten Eingabefelder auf dem Selektionsbild aufgenommen werden und definieren Schnittstellen-Arbeitsbereiche fr die Datenbergabe zwischen logischer Datenbank und ausfhrbarem Programm.
April 2001
67
SAP AG
Der eigentliche Zugriff auf die Datenbank des R/3-Systems erfolgt ber Open SQL-Anweisungen, die in den PUT_<TABLE>-Unterprogrammen programmiert sind. Die eingelesenen Daten werden ber die Schnittstellen-Arbeitsbereiche an das ausfhrbare Programm bergeben. Nach dem Einlesen der Daten im logischen Datenbankprogramm hat das ausfhrbare Programm die Mglichkeit diese Daten in den GET-Ereignisblcken zu verarbeiten. Dadurch wird eine Trennung von Datenauslese und Datenverarbeitung erreicht.
Einsatz logischer Datenbanken

Logische Datenbanken dienen primr der Wiederverwendung vordefinierter Funktionalitt zum Lesen von Daten aus Datenbanktabellen. SAP liefert zu allen Anwendungen logische Datenbanken aus. Diese Datenbanken sind performanceoptimiert und enthalten weitere Funktionalitten wie z.B. Berechtigungsprfungen und Suchhilfen. Der Einsatz von logischen Datenbanken ist dann sinnvoll, wenn die auszulesenden Datenbanktabellen sich weitgehend mit der Struktur der logischen Datenbank decken und der Ablauf des Programms (DatenselektionDatenauslese-Datenverarbeitung-Datenanzeige) den Anforderungen der Anwendung entspricht.
Contexte
In der Anwendungsprogrammierung werden oft aus wenigen Grunddaten, die z.B. vom Benutzer beim Benutzerdialog eingegeben werden, weitere Daten abgeleitet. Zu diesem Zweck werden entweder die relationalen Beziehungen zwischen Daten in der Datenbank verwendet, um basierend auf den Grunddaten weitere Daten zu lesen, oder man leitet weitere Werte aus den Grunddaten durch ABAP-Anweisungen ab. Dabei kommt es hufig vor, da in einem Programm oder sogar ber mehrere Programme hinweg bestimmte Beziehungen zwischen Daten immer in der gleichen Form zur Datenbeschaffung verwendet werden. Somit werden die gleichen Datenbankzugriffe oder Berechnungen immer wieder neu ausgefhrt, obwohl das Ergebnis im System schon einmal vorhanden war. Dies fhrt zu einer unntigen Systembelastung, die durch den Einsatz von Contexten vermindert werden kann. Contexte werden im Werkzeug Context-Builder der ABAP Workbench definiert. Sie bestehen aus einzugebenden Schlsselfeldern, aus Beziehungen zwischen diesen Feldern und daraus ableitbaren weiteren Feldern bestehen. Contexte knnen die abgeleiteten Felder ber Fremdschlsselbeziehungen zwischen Tabellen, ber Funktionsbausteine oder aus anderen Contexten beziehen.
68
April 2001
SAP AG
Verarbeitungsblock Deklarationsteil
CONTEXTS CONTEXT_DEMO. DATA: DEMO_INST TYPE CONTEXT_DEMO. SUPPLY KEY1 = ... KEY2 = ... TO CONTEXT DEMO_INST. DEMAND RESULT1 = ... RESULT2 = ... RESULT3 = ... FROM CONTEXT DEMO_INST.
ABAP-Programm
CONTEXT_DEMO Fields: KEY1 KEY2 ... RESULT1 RESULT2 ...

Context
Modules: MODULE1 MODULE2 ...
Puffer
DB
In einem Anwendungs-Programm arbeitet man mit den Instanzen eines Contexts. Es knnen mehrere Instanzen zu einem Context verwendet werden. Das Anwendungs-Programm versorgt mit der Anweisung SUPPLY die Instanzen von Contexten mit Eingabewerten fr die Schlsselfelder und kann mit der Anweisung DEMAND die abhngigen Felder aus den Instanzen von Contexten abfragen. Zu jedem Context gehrt ein transaktionsbergreifender Puffer auf dem Anwendungsserver. Bei der Abfrage einer Instanz nach Werten sucht das Context-Programm zuerst im zugehrigen Puffer nach einem Datensatz mit den entsprechenden Schlsselfeldern. Falls vorhanden, wird die Instanz mit diesen Daten versorgt, ansonsten leitet das Context-Programm die abhngigen Daten aus den eingegebenen Schlsselfeldern ab und schreibt den Datensatz in den Puffer.
April 2001
69
ABAP Programmierung (BC-ABA) Speicherstrukturen eines ABAP-Programms
SAP AG
Speicherstrukturen eines ABAP-Programms

In der bersicht ber das R/3-Basis-System [Seite 21] haben wir gesehen, da jeder Benutzer innerhalb eines SAP GUI bis zu sechs R/3-Fenster ffnen kann. Jedes dieser Fenster entspricht einem Modus auf dem Applikationsserver der einen eigenen Speicherbereich im Shared Memory belegt. Das erste Anwendungsprogramm, das in einem Modus gestartet wird, ffnet innerhalb des Modus einen ersten internen Modus. Der Speicherbereich des internen Modus enthlt das Anwendungsprogramm und seine Arbeitsdaten. Beim Aufruf von externen Routinen werden deren Rahmenprogramme und Arbeitsdaten mit in den Speicherbereich des internen Modus geladen. Es ist immer nur ein interner Modus aktiv. Falls das aktive Anwendungsprogramm ein weiteres Anwendungsprogramm aufruft, wird ein weiterer interner Modus erffnet. Dabei mssen wir zwei Flle unterscheiden. Wenn nach der Ausfhrung des aufgerufenen Programms nicht in das vorherige Programm zurckgekehrt wird, ersetzt der interne Modus des aufgerufenen Programms den ersten internen Modus und dessen Speicherinhalt wird vollstndig gelscht. Wird aber in das aufrufende Programm zurckgekehrt, bleibt sein Modus whrend der Ausfhrung des aufgerufenen Programms erhalten. Er ist aber inaktiv und seine Speicherinhalte werden auf einem Stack abgelegt. Im Speicherbereich eines jeden Modus gibt es einen Bereich namens ABAP-Memory. Das ABAP-Memory steht allen internen Modi gemeinsam zur Verfgung. ABAP-Programme knnen ber die Anweisungen EXPORT und IMPORT auf diesen Speicherbereich zugreifen. Daten innerhalb dieses Speicherbereichs bleiben ber eine Abfolge von Programmaufrufen erhalten. Um Daten an ein aufgerufenes Programm zu bergeben, mssen diese vor dem Programmaufruf aus dem aufrufenden internen Modus mit der EXPORT-Anweisung in das ABAP-Memory gestellt werden. Dann ersetzt der interne Modus des aufgerufenen Programms den internen Modus des aufrufenden Programms und die Daten knnen mit der IMPORTAnweisung aus dem ABAP-Memory gelesen werden. Sollen bei Rckkehr ins aufrufende Programm wieder Daten bergeben werden, verluft die Prozedur umgekehrt. Schlielich hat jedes Anwendungsprogramm Zugriff auf das sogenannte SAP-Memory. Das SAP-Memory ist ein Speicherbereich, auf den smtliche Modi eines SAP-GUI gemeinsamen Zugriff haben. Im SAP-Memory knnen also Daten sowohl programmbergreifend innerhalb eines Modus als auch ber einen Modus hinaus bergeben werden. Im SAP-Memory stehen fr Anwendungsprogramme nur spezielle Parameter zur Verfgung, die sogenannten SPA/GPAParameter. Diese Parameter knnen z.B. bei der Systemanmeldung benutzerspezifisch oder aus Anwendungsprogrammen ablaufspezifisch gesetzt werden und dienen hufig der Vorbelegung von Eingabefeldern auf Bildschirmen. Das SAP-Memory ist die einzige Verbindung zwischen den unterschiedlichen Modi eines SAP GUI. Die folgende Abbildung zeigt wie ein Anwendungsprogramm auf die verschiedenen Speicherbereiche innerhalb des Shared Memory zugreift:
70
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Speicherstrukturen eines ABAP-Programms
Hauptmodus 1 (gebunden an ein GUI-Fenster) Interner Modus 3 Interner Modus 2 Hauptprogramm der Transaktion/ des Reports ABAP Memory
Hauptmodus 6
...
Funktionsgruppe 1
...
externe FORM 1
...
Interner Modus 1 Funktionsgruppe n Hauptprogramm der Transaktion/ des Reports Funktionsgruppe 1 Interner Modus 1
... ... ...
externe FORM n externe FORM 1
SAP Memory
In diesem Bild ist ein Anwendungsprogramm im zweiten internen Modus des ersten Modus aktiv. Es hat Zugriff auf den Speicherbereich seines internen Modus, auf das ABAP-Memory und das SAP-Memory. Das Programm im ersten internen Modus hat das gerade aktive Programm aufgerufen und seine Daten liegen inaktiv auf einem Stack. Falls das gerade aktive Programm ein weiteres Programm aufruft und nach dessen Ausfhrung fortfahren will, wird das aufgerufene Programm in einem neuen dritten internen Modus aktiviert.
April 2001
...
71
ABAP Programmierung (BC-ABA) ABAP-Programme anlegen und ndern
SAP AG
ABAP-Programme anlegen und ndern

ABAP-Programme sind Objekte des R/3 Repository. Sie pflegen daher ABAP-Programme wie alle anderen Repository-Objekte (z.B. ABAP Dictionary-Tabellen oder Benutzungsoberflchen von Bildschirmen) mit einem Werkzeug der ABAP Workbench [Extern], nmlich dem ABAPEditor. Dieser Abschnitt ist ein kurzer Ausflug zur ABAP Workbench und bietet Ihnen einen zusammenfassenden berblick darber, wie Sie neue ABAP-Programme anlegen und bestehende ABAP-Programme ndern knnen. Er beschreibt also die verschiedenen Mglichkeiten, den ABAP-Editor zu starten. Im folgenden ist mit dem Ausdruck 'ein Programm ffnen' immer 'den ABAP-Editor fr ein Programm aufrufen' gemeint.
ABAP-Editor starten
Um den ABAP-Editor zu starten, um damit ABAP-Programme anzulegen oder zu ndern, bietet Ihnen das R/3-System im wesentlichen drei Mglichkeiten:
Programme im Object Navigator ffnen [Seite 74] Der Object Navigator der ABAP Workbench (Transaktion SE80) bietet Ihnen auf der linken Bildschirmseite eine hierarchische bersicht ber alle R/3-Repository Objekte und zwar geordnet nach Entwicklungsklassen, Benutzernamen des Programmierers, Objekttypen und so weiter. Durch die Auswahl von Programmen erlaubt der Object Navigator Direktzugriff auf alle Einzelteile eines Programms wie z.B. Hauptprogramm, Include-Programme, Klassen oder globale Daten. ber die Auswahl eines Programmobjekts im Object Navigator und dem Aufruf einer Pflegefunktion ffnen Sie auf der rechten Bildschirmseite direkt das passende Werkzeug, nmlich den ABAP Editor, fr dieses Objekt. Dieser Einstieg eignet sich fr prinzipiell fr alle ABAP-Programme, da Sie im Object Navigator immer einen berblick ber alle zum Programm gehrigen Komponenten haben. Insbesondere Bildschirme und deren Benutzungsoberflchen werden angezeigt.
Programme mit dem ABAP-Editor ffnen [Seite 77] Um direkt ber das Werkzeug ABAP-Editor ein Programmobjekt zu ffnen, whlen Sie den Knoten ABAP Editor unter ABAP WorkbenchEntwicklung im SAP-Standardmen der Benutzungsoberflche SAP Easy Access [Extern] (bzw. starten Sie die Transaktion SE38). Bei der nderung von Programmen mssen Sie den Namen des zu pflegenden Programms und sein Umfeld genau kennen. Dieser Einstieg eignet sich ausschlielich fr die Pflege und das Anlegen von relativ einfachen oder kurzen Programmen, die nur wenige oder gar keine zugehrigen Komponenten haben.
Programme durch Vorwrtsnavigation ffnen [Seite 78] Immer wenn Sie beim Arbeiten mit einem Werkzeug der ABAP Workbench den Cursor auf den Namen eines R/3-Repository Objekts positionieren und das Objekt (z.B. durch einen Maus-Doppelklick) auswhlen, ffnet das System das Objekt mit dem zugehrigen Werkzeug. Dies gilt insbesondere also auch fr das Editieren von ABAP-Programmen. Die Vorwrtsnavigation per Doppelklick bietet sich an jeder Stelle an, an der Namen von ABAP-Programmen in der ABAP Workbench auftauchen.
72
April 2001
SAP AG
ABAP Programmierung (BC-ABA) ABAP-Programme anlegen und ndern
Namen von ABAP-Programmen

Der Name eines ABAP Programms mu aus mindestens einem Zeichen bestehen und kann eine maximale Lnge von 30 Zeichen haben. Folgende Zeichen sollen in Programmnamen nicht verwendet werden: Punkt (.), Komma (,), Leerzeichen (), Klammern ' ( ' '), Hochkomma ('), Anfhrungszeichen ("),Gleichheitszeichen (=),Stern (*),Umlaute und scharfes 's' (, , , , , und ), Prozentzeichen (%) und Bindestrich (-).
Programmeigenschaften
Wie viele Repository-Objekte haben ABAP-Programme Eigenschaften, die sehr wichtig fr ihre Funktion im R/3-System sind. Eine Einfhrung finden Sie unter Programmeigenschaften pflegen [Seite 79].
Quelltext
ABAP-Quelltexte definieren die Verarbeitungslogik von R/3-Anwendungsprogrammen. Programme editieren [Seite 82] gibt Ihnen eine Einfhrung zum Schreiben von ABAP-Quelltext.
April 2001
73
ABAP Programmierung (BC-ABA) Programme im Object Navigator ffnen
SAP AG
Programme im Object Navigator ffnen

Um ABAP-Programme im Object Navigator der ABAP Workbench zu ffnen, whlen Sie Object Navigator unter ABAP WorkbenchEbersicht im SAP-Standardmen der Benutzungsoberflche SAP Easy Access [Extern] (bzw. starten Sie die Transaktion SE80). Im Einstiegsbild des Object Navigators knnen Sie links oben Programm auswhlen und direkt einen Programmnamen eingeben oder sich smtliche Programme einer bestimmten Entwicklungsklasse anzeigen lassen.
Eine bestimmtes Programm ffnen

Geben Sie einen Programmnamen ein und besttigen sie mit whlen Sie Enter. Falls das Programm noch nicht existiert, werden Sie in einem Dialogfenster gefragt, ob Sie es anlegen wollen, ansonsten werden die Programmobjekte links als Knoten einer Baumstruktur angezeigt, ber die zu den betreffenden Werkzeugen navigiert werden kann.
Anlegen eines neuen Programms

1. Es erscheint das Dialogfenster Programm anlegen, das es Ihnen ermglicht ein TopInclude anzulegen. Ein Top-Include ist ein spezielles Include-Programm, in dem bei komplexen Programmen die globalen Deklarationen abgelegt werden knnen. Bei der Programmierung von Modulpools sollte der Programmnamen mit den vier Buchstaben 'SAPM' beginnen, denn nur dann schlgt das System einen Namen fr das TOP-Include vor, das automatisch in die vollstndige Navigation eingebunden ist. 2. Es erscheint das Bild ABAP: Programmeigenschaften, in dem Sie die Programmeigenschaften pflegen mssen (siehe unten). Die Pflege der Programmeigenschaften ist ein wichtiger Vorgang beim Anlegen eines Programms. Fllen Sie die Eingabefelder des Bilds ABAP: Programmeigenschaften sorgfltig aus. 3. Sichern Sie die Programmeigenschaften. Das Programm ist nun im R/3 Repository vorhanden und Sie knnen den Quelltext im ABAP Editor eingeben.
Programme einer Entwicklungsklasse ffnen

Geben Sie den Namen einer vorhandenen Entwicklungsklasse ein und besttigen Sie mit Enter. Der Object Navigator zeigt Ihnen in der Baumstruktur eine hierarchische bersicht ber smtliche zur angegebenen Entwicklungsklasse gehrigen R/3-Repository Objekte.
74
April 2001
SAP AG
Entwicklungsklasse
Objektarten Entw.Kl. DDIC-Objekte Programme Funktionsgruppen Includes Transaktionen Logische Datenbanken Nachrichtenklassen . . .
Programm
Objektarten Programm DDIC-Strukturen Typen Felder Ereignisse Unterprogramme Dynpros . . .
An dieser Stelle gibt es mehrere Mglichkeiten:
Falls auf diesem Bild der Knoten Programme nicht vorhanden ist, knnen Sie durch Auswahl des Knotens Objektarten Entwicklungsklasse diesen Knoten durch das Anlegen eines Programms erzeugen. Whlen Sie hierfr auf dem erscheinenden Dialogfenster (Objektauswahl) den Reiter Programm. Geben Sie einen Namen ein und whlen Anlegen. Es erscheint das Dialogfenster Programm anlegen. Ab hier verfahren Sie genauso wie beim Anlegen eines bestimmten Programms.
Falls auf diesem Bild der Knoten Programme vorhanden ist, knnen Sie auch hier durch Positionierung des Cursors auf den Knoten Programme und die Auswahl von Anlegen (rechte Maustaste) eine neues Programm anlegen. Falls auf diesem Bild der Knoten Programme vorhanden ist, knnen Sie sich smtliche Programme der Entwicklungsklasse als Verzweigungen dieses Knotens anzeigen lassen. Positionieren Sie den Cursor auf einen Programmnamen und doppelklicken Sie dort bzw. whlen Sie Anzeigen oder ndern (rechte Maustaste). Dadurch ffnen Sie auf der rechten Seite den ABAP-Editor fr das ausgewhlte Programm.
Der Object Navigator zeigt die bersicht ber alle zu einem Programm gehrigen Komponenten (Objektarten) als Verzweigungen eines Programmknotens an. Bei der Auswahl der Komponenten des Programms wird auf der rechten Seite nicht unbedingt der ABAP-Editor fr den Quelltext des Programms geffnet, sondern immer das passende Werkzeug fr die ausgewhlte Komponente. In Einzelfllen, z.B. fr Include-Programme, kann das wiederum der ABAP-Editor sein. Dann bearbeiten Sie aber nur die Komponente und nicht den Quelltext des Gesamtprogramms.
April 2001
75
SAP AG
76
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Programme mit dem ABAP-Editor ffnen
Programme mit dem ABAP-Editor ffnen

Um ABAP-Programme mit dem ABAP-Editor direkt zu ffnen, whlen Sie den Knoten ABAP Editor unter ABAP WorkbenchEntwicklung im SAP-Standardmen der Benutzungsoberflche SAP Easy Access [Extern] (bzw. starten Sie die Transaktion SE38).
Neues Programm anlegen

Falls das Programm noch nicht existiert, whlen Sie Anlegen. Es erscheint das Bild ABAP: Programmeigenschaften, in dem Sie die Programmeigenschaften pflegen mssen (siehe unten). Bei diesem Einstieg bietet Ihnen das System nicht das Anlegen eines Top-Includes an. Diese Art der Programmerzeugung eignet sich also hauptschlich fr kurze ausfhrbare Testprogramme. Nach der Eingabe und dem Sichern der Programmeigenschaften ist das neue Programm im R/3 Repository vorhanden.
Vorhandenes Programm pflegen

Fr ein vorhandenes Programm knnen Sie auf dem Einstiegsbild der Transaktion SE38 eines der folgenden Teilobjekt markieren und Anzeigen oder ndern whlen, um das Teilobjekt zu pflegen.
Quelltext
Hiermit starten Sie den ABAP-Editor.

Varianten
Hier pflegen Sie Varianten. Varianten ermglichen es Ihnen Fixwerte fr die Eingabefelder auf einem Selektionsbild zu definieren.
Eigenschaften
Hier pflegen Sie die Programmeigenschaften (siehe unten).

Dokumentation
Hier knnen Sie eine programmspezifische Dokumentation fr ein ausfhrbares Programm (Report) pflegen. Das System ffnet den SAPscript-Editor, wo Sie die Dokumentation entsprechend der vorgegebenen Maske eintragen knnen. Der Benutzer kann sich die Dokumentation beim Ausfhren des Programms ber System Dienste Reporting (Transaktion SA38) ber Springen Dokumentation ansehen. Falls das Programm als Knoten in einem Berichtsbaum abgelegt ist (Transaktion SERP), kann der Benutzer auch dort Springen Doku anzeigen whlen, um die Dokumentation zu sehen.
Textelemente
Hier pflegen Sie Textelemente. Textelemente sind eine Ablage fr alle Texte, die auf den Selektionsbildern oder den Ausgabelisten eines Programms erscheinen.. Sie gelangen auch im ABAP-Editor immer ber den Menpunkt Springen oder ber die Vorwrtsnavigation zu diesen Teilobjekten.
April 2001
77
ABAP Programmierung (BC-ABA) Programme durch Vorwrtsnavigation ffnen
SAP AG
Programme durch Vorwrtsnavigation ffnen

Wenn Sie beim Arbeiten in der ABAP Workbench den Cursor auf einen Programmnamen positionieren und das entsprechende Programm durch einen Doppelklick auswhlen, ffnet das System den ABAP-Editor fr dieses Programm. Weitere Mglichkeiten zur Vorwrtsnavigation finden Sie auch immer in den Menleisten der Werkzeuge der ABAP Workbench z.B. unter Springen oder Umfeld. Die folgenden Beispiele zeigen Ihnen einige Mglichkeiten der Vorwrtsnavigation.
Nehmen Sie an, da Sie gerade ein Programm editieren und die Zeile
SUBMIT ZZHKTST 1.
bearbeiten. Diese Anweisung ruft ein ausfhrbares Programm (Report) aus einem anderen ABAP-Programm heraus auf. Wenn Sie den Cursor auf den Namen ZZHKTST1 positionieren und doppelklicken gibt es zwei Mglichkeiten: 1. Das Programm ZZHKTST1 existiert schon. Das System ffnet den Editor fr ZZHKTST1 und Sie knnen das Programm lesen oder editieren. 2. Das Programm ZZHKTST1 existiert noch nicht. Das System zeigt ein Dialogfenster, das Ihnen erlaubt das Programm anzulegen. Nach der Bearbeitung von ZZHKTST1 knnen Sie ber die Auswahl von Back in die ABAP-Editor Sitzung des ursprnglichen Programms zurcknavigieren.
ffnen Sie in der Baumstruktur des Object Navigators den Knoten eines Programms, das mindestens ein Dynpro als Unterobjekt enthlt. Positionieren Sie den Cursor unter dem Knoten Dynpros auf einem Dynpro. Durch die Auswahl von Anzeigen, ndern oder Doppelklicken ffnen sie das Werkzeug Screen Painter und gelangen in die Bildschirmablauflogik dieses Dynpros: Hier sehen Sie normalerweise mehrere Dynpro-Anweisungen MODULE, welche die ABAP-Module im zugehrigen ABAP-Programm aufrufen. Positionieren Sie den Cursor auf ein Modul und klicken Sie doppelt. Das System ffnet den ABAP-Editor fr das zugehrige Include-Programm an der Stelle, an der das Modul programmiert ist. Das Include-Programm dient der QuelltextModularisierung des ABAP-Programms.
Wenn Sie im ABAP-Editor den Cursor hinter einer INCLUDE-Anweisung auf den Namen eines Include-Programms positionieren und dort doppelklicken, ffnen Sie das Include-Programm.
78
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Programmeigenschaften pflegen
Programmeigenschaften pflegen
Die Programmeigenschaften teilen der ABAP-Laufzeitumgebung mit, wie ein ABAP-Programm ausgefhrt wird. Das wichtigste Programmattribut hierfr ist der Typ, mit dem Sie entscheiden, wie ein ABAP-Programm ausgefhrt werden kann. Weiterhin bestimmen Sie in den Programmeigenschaften zu welcher Anwendung ein Programm gehrt und bestimmen gegebenenfalls die logische Datenbank fr ausfhrbare Programme (Reports). Sie mssen die Eigenschaften sorgfltig angeben, damit das System das Programm richtig verarbeiten kann. Sie pflegen die Programmeigenschaften auf dem Bild ABAP: Programmeigenschaften. Die Liste mglicher Programmtypen erhalten Sie ber die Auswahl der Eingabehilfe. Wenn Sie ein ausfhrbares Programm (Report, interner Typ = 1) auswhlen, ergnzt das System automatisch die Eingabefelder fr spezifische Eigenschaften. Nur dann sehen Sie die zustzlichen Eingabefelder Logische Datenbank und Selektionsbildversion.
bersicht ber alle Programmeigenschaften

Im folgenden finden Sie Informationen ber die Programmeigenschaften. Beachten Sie, da einige der Eigenschaften nur fr ausfhrbare Programme gelten und nicht fr andere ABAPProgramme. Zustzliche Informationen ber die Programmeigenschaften erhalten Sie, indem Sie in den jeweiligen Eingabefeldern des Bilds ABAP: Programmeigenschaften die Feldhilfe oder Eingabehilfe auswhlen.
Titel
Im Mufeld Titel geben Sie eine Programmbezeichnung an, die die Funktion des Programms beschreiben sollte. Das System nimmt den Titel automatisch in die Textelemente des Programms auf. Der Titel kann daher auch mit der Textelementpflege bearbeitet werden.
Originalsprache
Die Originalsprache ist die Anmeldesprache, unter der das Programm angelegt wird, und wird vom System gesetzt. Die Originalsprache ist nderbar, wenn ein Programmierer das Programm oder Komponenten des Programms unter einer anderen Anmeldesprache pflegt.
Typ
Im Feld Typ mssen Sie den Programmtyp spezifizieren. Mit Ausfhrbares Programm deklarieren Sie Ihr Programm als ausfhrbar. Das bedeutet, da das Programm eigenstndig ablauffhig ist und im R/3-System ohne Transaktionscode gestartet werden kann. Ausfhrbare Programme knnen auch im Hintergrund gestartet werden. Mit Modulpool deklarieren Sie Ihr Programm als einen Pool fr Dialogmodule. Das bedeutet, da Ihr Programm nicht eigenstndig ablauffhig ist, sondern als Rahmenprogramm fr Programmodule der Dialogprogrammierung dient. Diese Programmodule enthalten die Anwendungslogik einer Transaktion und werden von einer getrennt programmierten Bildschirmablauflogik (Dynpro-Programmierung mit dem Werkzeug Screen Painter) aufgerufen. Die Bildschirmablauflogik selbst kann nur ber einen Transaktionscode aufgerufen werden. Neben ausfhrbaren Programmen und Modulpools sollten Sie auch Include-Programme kennen. Ein Include-Programm ist ein unabhngiges Programm mit zwei Hauptfunktionen: Zum einen
April 2001
79
SAP AG
enthlt es Programmcode, der von verschiedenen Programmen genutzt werden kann. Zum anderen dient es zur Modularisierung von Programmquellcode, der aus verschiedenen logisch zusammenhngenden Teilen besteht. Jeder dieser Teile ist in einem anderen Include-Programm gespeichert. Include-Programme verbessern die Lesbarkeit des Quellcodes und vereinfachen seine Pflege.
Status
Diese optionale Angabe hat protokollarischen Character und beschreibt den Status der Programmentwicklung, wie z.B. Testprogramm oder Produktives Kundenprogramm
Anwendung
Dieses optionale Feld enthlt den Namen der Anwendung, in der das Programm bentigt wird, wie z.B. Finanzbuchhaltung.
Berechtigungsgruppe
In dieses Feld knnen Sie den Namen einer Programmgruppe eintragen. Dadurch knnen Sie verschiedene Programme in Gruppen fr Berechtigungsprfungen zusammenfassen. Der Gruppenname ist ein Feld der beiden Berechtigungsobjekte S_DEVELOP (Programmentwicklung und Programmausfhrung) und S_PROGRAM (Programmpflege). Berechtigungen knnen somit programmgruppenspezifisch an Benutzer vergeben werden. Mehr Informationen zu Berechtigungen finden Sie in der Dokumentation BC - Benutzer und Rollen [Extern].
Entwicklungsklasse
Die Entwicklungsklasse ist wichtig fr Transporte zwischen Systemen. Sie fassen WorkbenchObjekte, die einer Entwicklungsklasse zugeordnet sind, in einem Transportauftrag zusammen. Wenn Sie in einem Team arbeiten, mssen Sie Ihr Programm vielleicht einer bestehenden Entwicklungsklasse zuordnen oder eine neue anlegen. Programme, die der Entwicklungsklasse $TMP zugeordnet sind, sind private Objekte, die nicht in andere Systeme transportiert werden knnen. Sie knnen die Entwicklungsklasse direkt in dieses Feld eintragen. Ansonsten fordert das System die Entwicklungsklasse beim Abspeichern der Eigenschaften mit einem Dialogfenster an: Die Auswahl der Taste Lokales Objekt auf dem Dialogfenster ist gleichbedeutend mit der Eingabe $TMP im Feld Entwicklungsklasse. Sie knnen die Entwicklungsklasse eines Programms nachtrglich ndern.
Logische Datenbank Nur fr ausfhrbare Programme
Diese Eigenschaften legen fest, welche logische Datenbank das ausfhrbare Programm (Report) benutzt, um Daten zu lesen.
Selektionsbildversion Nur fr ausfhrbare Programme
Wenn Sie keine Selektionsbildversion angegeben haben, legt das System automatisch ein Standardselektionsbild an, das auf den Selektionskriterien der logischen Datenbank sowie den programmspezifischen Parametern und Selektionsoptionen beruht. Wenn Sie ein anderes Selektionsbild der logischen Datenbank verwenden wollen, geben Sie in diesem Feld eine Nummer an. Die Nummer mu kleiner als 1000 sein und einem zustzlichen
80
April 2001
SAP AG
Selektionsbild der logischen Datenbank entsprechen. Sie erhalten einen berblick ber eventuell vorhandene zustzliche Selektionsbilder mit der Wertehilfe oder im Selektions- Include der logischen Datenbank (Programm DBxxxSEL, wobei xxx der Name der logischen Datenbank ist.
Editorsperre
Wenn Sie dieses Attribut setzen, knnen andere Benutzer Ihr Programm nicht ndern, umbenennen oder lschen. Sie allein knnen das Programm ndern, Eigenschaften, Textelemente oder Dokumentation pflegen oder die Sperre zurcknehmen.
Festpunktarithmetik
Wenn Sie dieses Attribut setzen, rundet das System Felder des Datentyps P entsprechend der Anzahl der Dezimalstellen oder fllt sie mit Nullen. Das Dezimalzeichen ist in diesem Fall immer der Punkt (.), unabhngig von der Angabe im Benutzerstammsatz. SAP empfiehlt, immer das Attribut Festpunktarithmetik zu setzen.
Start ber Variante Nur fr ausfhrbare Programme
Wenn Sie dieses Attribut setzen, knnen Benutzer Ihr Programm nur ber eine Variante starten. Vor dem Starten des Programms mssen Sie mindestens eine Variante anlegen.
April 2001
81
ABAP Programmierung (BC-ABA) Programme editieren
SAP AG
Programme editieren
Sie editieren Programme mit dem Werkzeug ABAP Editor [Extern]. Ausfhrliche Informationen finden Sie in der entsprechenden Dokumentation. Hier folgen ein paar Tips fr den Einstieg:
Programmaufbau
Im folgenden finden Sie eine Kurzbersicht zum Programmaufbau. Bis auf die erste Anweisung ist die Reihenfolge nicht zwingend, sollte aber wegen der bersichtlichkeit eingehalten werden. 1. Die erste Programmanweisung Die erste Anweisung eines ABAP-Programms ist immer eine programmeinleitende Anweisung [Seite 1474]. Hufig sind REPORT und PROGRAM. Die Funktionalitt beider Anweisungen ist identisch Der Name in den Anweisungen REPORT und PROGRAM mu nicht unbedingt mit dem Programmnamen bereinstimmen, sollte es aber aus dokumentarischen Grnden. Wenn Sie ein neues Programm anlegen erzeugt das System automatisch die erste ABAP-Anweisung, zum Beispiel.
REPORT <name>. fr ausfhrbare Programme oder PROGRAM <name>. fr Modulpools

Als Report-/Programmnamen setzt das System den Namen ein, unter dem Sie das Programm angelegt haben. 2. Datendeklaration Als nchstes sollten Sie smtliche Deklarationen Ihres Programms durchfhren. Dazu gehren, die Definition von Selektionsbildern, die Deklaration von programmlokalen Klassen und Interfaces oder globale Datendeklarationen. 3. Verarbeitungslogik Danach folgt die Verarbeitungslogik, die aus einer Reihe von Verarbeitungsblcken besteht. 4. Unterprogramme Smtliche internen Prozeduren (z.B. Unterprogramme) eines ABAP-Programms sollten als letzte Einheiten am Ende des Programms aufgelistet sein. Die Modularisierung von Programmen in Quelltextmodule durch Include-Programme ndert nichts an obigem prinzipiellen Aufbau. Wenn Sie beispielsweise der Vorwrtsnavigation der ABAP Workbench beim Anlegen von Dialogprogrammen folgen, legt das Ihnen System automatisch eine Reihe von Includes an, welche die oben aufgefhrten Programmteile in der richtigen Reihenfolge enthalten. Das Top-Include enthlt meistens die Anweisung PROGRAM sowie die globalen Datendeklarationen. Danach folgen Includes fr die einzelnen Dialogmodule geordnet nach PBO und PAI. Weitere Includes knnen z.B. Unterprogramme enthalten. Diese Includes dienen der bersichtlichkeit und haben keinen Einflu auf die Funktionalitt.
Programmlayout
Um ein qualitativ einwandfreies Programm zu schreiben, sollten Sie sich an bestimmte Layoutstandards fr ABAP-Programme halten. Beachten Sie bitte die folgenden Vorschlge:
82
April 2001
SAP AG
Programme kommentieren
Kommetnieren Sie ihr Programm ausreichend. Erlutern Sie beispielsweise in der berschriftszeile fr ein Unterprogramm, wofr das aufgerufene Programm verwendet wird, und geben Sie die ntigen Informationen und Referenzen an. Der ABAP Editor [Extern] untersttzt die Kommentierung durch vordefinierte Kommentarblcke. Setzen Sie Kommentare innerhalb einer Programmzeile nur sparsam ein und wenn das Programm dadurch nicht unbersichtlich wird.
Anweisungsblcke einrcken
Fassen Sie zusammengehrige Anweisungen in einem Block zusammen. Rcken Sie jeden Block um mindestens zwei Spalten ein:
GET DO IF ENDIF ENDDO
Modularisieren
Modularisierung Sie ihre Programme. Wenn Sie grere Verarbeitungsblcke beispielsweise als Methoden schreiben, ist die logische Struktur Ihres Programms leichter zu erkennen. Programme mit Klassen und Methoden werden insgesamt vielleicht lnger, aber Sie werden bald feststellen, da dieses Verfahren die bersichtlichkeit betrchtlich erhht, besonders bei komplexen Programmen.
Pretty Printer
Verwenden Sie den Pretty Printer des ABAP Editor [Extern]. Er erleichtert es Ihnen, die Layoutrichtlinien einzuhalten.
Anweisungsmuster
Anweisungsmuster erleichtern es, ABAP-Programme zu schreiben. Sie liefern die genaue Syntax und entsprechen den ABAP-Layoutrichtlinien. Sie knnen zwei Arten von vordefinierten Strukturen in Ihren Programmcode im ABAP-Editor einfgen: Schlsselwortstrukturen und Kommentarzeilen. Whlen Sie Muster im ABAP-Editor. Eine Liste aller vordefinierten Schlsselwortstrukturen erhalten Sie, indem Sie den Cursor auf das Feld Anderes Muster stellen und die F4-Hilfe aufrufen.
Programm prfen
Wenn Sie mit dem Editieren fertig sind oder einen Zwischenstand erreicht haben, prfen Sie die Syntax, indem Sie Prfen anwhlen. Das System berprft den Programmcode auf Syntaxfehler und Kompatibilittsprobleme. Wenn es einen Fehler findet, erscheint eine Nachricht, die auf den Fehler hinweist und falls mglich eine Lsung oder Korrektur anbietet. Der Cursor kann auf die
April 2001
83
SAP AG
betreffende Stelle positioniert werden. Vor der vollstndigen Fertigstellung eines Programms sollte auf alle Flle eine erweiterte Programmprfung ber Programm Prfen Erweiterte Programmprfung im ABAP-Editor durchgefhrt werden. Die dort angezeigten Fehler und Warnungen sollten behoben werden. Manche Fehler, die von der erweiterten Programmprfung gefunden werden, zeigen an, da das Programm nicht ablauffhig ist. Andere verhindern zwar nicht unbedingt die Lauffhigkeit des Programms, weisen aber z.B. auf Unsauberkeiten hin, die einer geordneten Software-Entwicklung im Weg stehen. Auerdem knnen manche Warnungen in spteren Releases zu echten Syntax-Fehlern verschrft werden.
Programm sichern und aktivieren

Sichern Sie den Code durch Sichern. Der Quelltext wird in der Programmbibliothek gespeichert. Vor dem ersten Ausfhren des Programms auerhalb des ABAP-Editors mu eine aktive Fassung des Programms durch die Auswahl der Funktion Aktivieren erzeugt werden.
Programm testen
Sie knnen ausfhrbare Programme im Editor testen. Dazu whlen Sie Programm Ausfhren im ABAP-Editor. Dabei wird ein temporres aktives Laufzeitobjekt erzeugt, das nicht den gleichen Namen wie das Programm hat. Das System fhrt das Programm aber genauso aus, als htten Sie es auerhalb des ABAP-Editors gestartet. Wenn Sie beispielsweise einen Modulpool angelegt haben, knnen Sie ihr Programm nicht im Editor testen. Fr einen Modulpool mssen Sie einen Transaktionscode und eine Bildschirmablauflogik anlegen, bevor Sie das Programm ausfhren. Zum Testen eines Programms gehrt oft auch eine Laufzeitanalyse [Extern], die Ihnen zeigt wieviel Zeit Ihr Programm in der Client-Server-Umgebung des R/3-Systems verbraucht und wofr es diese Zeit braucht. Mehr Information zu diesem Thema finden Sie in der entsprechenden Dokumentation.
84
April 2001
SAP AG
ABAP Programmierung (BC-ABA) ABAP Programmiersprache
ABAP Programmiersprache
Prsentation
Applikation
ABAP ABAP
Datenbank
ABAP-Syntax [Seite 86] Typen und Objekte [Seite 90] Grundlegende Sprachelemente [Seite 93] Bearbeitung groer Datenmengen [Seite 264] Externe Datenspeicherung [Seite 377] Modularisierungstechniken [Seite 459] Spezielle Techniken [Seite 518]
April 2001
85
ABAP Programmierung (BC-ABA) ABAP-Syntax
SAP AG
ABAP-Syntax
Die Syntax der Programmiersprache ABAP besteht aus den folgenden Syntaxelementen:
Anweisungen
Ein ABAP-Programm besteht aus einzelnen Anweisungen. Jede Anweisung beginnt mit einem Schlsselwort und endet mit einem Punkt.
PROGRAM first_program. WRITE 'Erstes Programm'.

Dieses Beispiel enthlt zwei Anweisungen, jede in einer Zeile. Die Schlsselwrter sind PROGRAM und WRITE. Das Programm zeigt eine Liste am Bildschirm an. In diesem Fall enthlt die Liste die Zeile Erstes Programm. Das Schlsselwort bestimmt die Kategorie der Anweisung. Eine bersicht ber die verschiedenen Kategorien befindet sich unter ABAP-Sprachelemente [Seite 60].
PROGRAM FIRST_TEST. PROGRAM FIRST_TEST. NODES SPFLI. NODES SPFLI. GET SPFLI. GET SPFLI. WRITE SPFLI-CITYFROM. WRITE SPFLI-CITYFROM. WRITE SPFLI-CITYTO UNDER SPFLI-CITYFROM. WRITE SPFLI-CITYTO UNDER SPFLI-CITYFROM.
Schlsselwort
Operand
Zusatz
Operand
Die Abbildung zeigt die Struktur einer ABAP-Anweisung.
Formatierung von ABAP-Anweisungen

ABAP hat keine Formateinschrnkungen. Anweisungen knnen in freiem Format eingegeben werden, d.h., Anweisungen knnen eingerckt werden, mehrere Anweisungen knnen in eine Zeile geschrieben werden oder eine Anweisung in kann mehrere Zeilen geschrieben werden. Wrter innerhalb einer Anweisung mssen durch mindestens ein Leerzeichen getrennt werden. Das System interpretiert das Zeilenende ebenfalls als Leerzeichen.
Das folgende Programm
86
April 2001
SAP AG
PROGRAM test. WRITE 'Dies ist eine Anweisung'.

knnte auch so geschrieben werden:

oder so:

Die freie Formatierung sollte genutzt werden, um die Lesbarkeit eines Programms zu verbessern. Ein unbersichtliches Layout sollte dagegen vermieden werden.
Besonderheit bei Textliteralen

Textliterale [Seite 124] sind in Hochkommata eingeschlossene Folgen von alphanumerischen Zeichen im Programmtext. Wenn ein Textliteral innerhalb einer ABAP-Anweisung ber mehrere Zeilen ausgedehnt wird, fhrt dies zu folgenden Schwierigkeiten:

Alle Leerzeichen zwischen den Hochkommata werden als zum Textliteral gehrig interpretiert. Der Editor interpretiert Buchstaben in Textliteralen, die nicht innerhalb einer Zeile durch Hochkommata abgeschlossen sind, als Grobuchstaben.
Um Textliterale einzugeben, die nicht in eine Zeile passen, kann man im Editor mit dem Zeichen & aufeinanderfolgende Textliterale zu einem Textliteral verknpfen.
Das folgende Programm

fgt alle Leerzeichen zwischen den Hochkommata in das Literal ein und setzt die Buchstaben in Groschreibung um. Das Programm
PROGRAM test. WRITE 'Dies' & ' ist ' & 'eine Anweisung'.
bildet aus den drei Textliteralen ein einziges Textliteral.
Kettenstze
Die Sprache ABAP ermglicht es, aufeinanderfolgende Anweisungen, die den gleichen Anfang haben, miteinander zu verketten. Um eine Folge von getrennten Anweisungen miteinander zu verketten, schreibt man den fr alle Anweisungen identischen Anfang nur einmal, gefolgt von einem Doppelpunkt (:). Nach dem
April 2001
87
SAP AG
Doppelpunkt werden die brigen Teile der einzelnen Anweisungen angegeben und mit einem Komma (,) voneinander getrennt. Die Anweisungskette mu durch einen Punkt (.) abgeschlossen werden.
Anweisungsfolge:
WRITE spfli-cityfrom. WRITE spfli-cityto. WRITE spfli-airpto.

Anweisungskette:
WRITE: spfli-cityfrom, spfli-cityto, spfli-airpto.

In der Kette trennt ein Doppelpunkt den Anfang der Anweisung von den variablen Teilen. Nach dem Doppelpunkt oder Komma knnen beliebig viele Leerzeichen eingefgt werden. Die gleiche Anweisung kann z.B. auch so geschrieben werden:
WRITE:
spfli-cityfrom, spfli-cityto, spfli-airpto.
In einer Anweisungskette ist der Anfang (vor dem Doppelpunkt) nicht auf das Schlsselwort der Anweisungen beschrnkt.
Anweisungsfolge:
sum = sum + 1. sum = sum + 2. sum = sum + 3. sum = sum + 4.

Anweisungskette:
sum = sum + : 1, 2, 3, 4.
Kommentare
Kommentare sind Texte, die zur Erluterung zwischen die Anweisungen eines ABAP-Programms geschrieben werden knnen. Kommentare unterscheiden sich durch die voranstehenden Zeichen * (am Zeilenanfang) und " (an beliebiger Zeilenposition) von den ABAP-Anweisungen. Wenn die ganze Zeile Kommentar ist, wird am Anfang der Zeile ein Stern (*) eingegeben. Das System ignoriert die gesamte Zeile bei der Programmgenerierung. Wenn nur ein Teil der Zeile Kommentar sein soll, wird vor dem Kommentar ein Anfhrungszeichen eingegeben. Das System interpretiert Kommentare, die durch das Anfhrungszeichen gekennzeichnet sind, als Leerzeichen.
************************************************ * PROGRAM SAPMTEST * * WRITTEN BY KARL BYTE, 06/27/1995 *
88
April 2001
SAP AG
* LAST CHANGED BY RITA DIGIT, 10/01/1995 * * TASK: DEMONSTRATION * ************************************************ PROGRAM sapmtest. ************************************************ * DECLARATIONS * ************************************************ DATA: flag(1) TYPE c, number TYPE i. ...... ************************************************ * PROCESSING BLOCKS * ************************************************ ...... " global flag " counter
April 2001
89
ABAP Programmierung (BC-ABA) Typen und Objekte
SAP AG
Typen und Objekte

In ABAP unterscheiden wir zwischen Typen und Objekten. Typen sind reine Beschreibungen, an denen kein Speicher hngt. Objekte sind Instanzen von Typen und belegen Speicher. Ein Typ charakterisiert die technischen Eigenschaften aller Objekte des betreffenden Typs. Die ABAP Typen bilden die ABAP-Typenhierarchie. Die Hierarchie der ABAP Objekte spiegelt die ABAP-Typenhierarchie.
90
April 2001
SAP AG
Typen Objekte Typen Objekte Datentypen Datenobjekte Datentypen Datenobjekte Elementare Typen Elementare Datenobjekte Elementare Typen Elementare Datenobjekte Feste Lnge Statische Datenobjekte Feste Lnge Statische Datenobjekte C Textfeld C Textfeld N Numerisches Textfeld N Numerisches Textfeld D Datumsfeld D Datumsfeld T Zeitfeld T Zeitfeld X Hexadezimalfeld X Hexadezimalfeld P Gepackte Zahl P Gepackte Zahl I I Ganze Zahl Ganze Zahl F Gleitpunktzahl F Gleitpunktzahl Variable Lnge Dynamische Datenobjekte Variable Lnge Dynamische Datenobjekte STRING Zeichenfolge STRING Zeichenfolge XSTRING Bytefolge XSTRING Bytefolge Komplexe Typen Komplexe Datenobjekte Komplexe Typen Komplexe Datenobjekte Strukturtypen Strukturen Strukturtypen Strukturen Tabellentypen Interne Tabellen Tabellentypen Interne Tabellen Referenztypen Referenzvariablen Referenztypen Referenzvariablen Datenreferenzen Datenreferenzvariablen Datenreferenzen Datenreferenzvariablen Objektreferenzen Objektreferenzvariablen Objektreferenzen Objektreferenzvariablen Objekttypen Objekttypen Klassen Objekte Klassen Objekte Interfaces Interfaces Klassenreferenzen Klassenreferenzvariablen Klassenreferenzen Klassenreferenzvariablen Interfacereferenzen Interfacereferenzvariablen Interfacereferenzen Interfacereferenzvariablen
Zeichenartige Typen
Numerische Typen
Wir unterscheiden prinzipiell zwischen Daten- und Objekttypen.
Datentypen [Seite 95] dienen der Beschreibung von Datenobjekten [Seite 123]. Sie unterteilen sich weiter in elementare, Referenz- und komplexe Typen. Es gibt eingebaute (vordefinierte) Datentypen oder sie knnen lokal im Programm und systemweit im R/3Repository definiert werden.
April 2001
91
SAP AG
Objekttypen dienen der Beschreibung von Objekten in ABAP Objects [Seite 1392]. Sie unterteilen sich in Klassen und Interfaces. Objekttypen enthalten zum einen obige Datentypen zum anderen aber auch Funktionalitt. Objekttypen sind nicht eingebaut, sondern mssen im Programm oder im R/3-Repository definiert werden. Klassen beschreiben ein Objekt vollstndig. Sie definieren welche Datentypen und welche Funktionalitt ein Objekt enthlt. Interfaces beschreiben einen Teilaspekt eines Objekts. Die Datentypen und Funktionen eines Interfaces knnen von mehreren Klassen implementiert werden. Objekte (Instanzen) knnen nur von Klassen erzeugt werden. Objektreferenzen knnen aber sowohl mit Bezug auf Klassen, als auch mit Bezug auf Interfaces typisiert werden.
Bei den Objekten als Instanzen von ABAP Typen unterscheiden wir prinzipiell zwischen Datenobjekten und Objekten.

Datenobjekte [Seite 123] sind Felder im eigentlichen Sinn. Sie enthalten die programmlokalen Daten, mit denen ein Programm zur Laufzeit arbeitet. Objekte [Seite 1410] sind echte Software-Objekte in ABAP Objects [Seite 1392] und untersttzen die objektorientierte Programmierung indem sie auer Daten auch Methoden und Ereignisse enthalten.
92
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Grundlegende Sprachelemente
Grundlegende Sprachelemente
Datentypen und Datenobjekte [Seite 94] Daten verarbeiten [Seite 148] Feldsymbole und Datenreferenzen [Seite 208] Logische Ausdrcke [Seite 238] Programmablaufsteuerung [Seite 254]
April 2001
93
ABAP Programmierung (BC-ABA) Datentypen und Datenobjekte
SAP AG
Datentypen und Datenobjekte

Programme arbeiten mit programmlokalen Daten. Daten sind Bytefolgen im Arbeitsspeicher des Programms. Zusammengehrige Bytefolgen heien Felder. Jedes Feld hat eine Lnge, eine Identitt (Name) und als weiteres Attribut einen Datentyp. Jede Programmiersprache hat ein Konzept, das beschreibt, wie der Inhalt eines Felds, also die Bytefolge, in Abhngigkeit vom Datentyp interpretiert wird. Im ABAP-Typkonzept bezeichnen wir Felder als Datenobjekte. Datenobjekte sind sozusagen Instanzen von abstrakten Datentypen. Konsequenterweise tauchen Datentypen in ABAP nicht nur als Attribute von Feldern auf, sondern knnen auch eigenstndig definiert werden. Fr Datentypen und Datenobjekte gibt es es getrennte Namensrume. Das heit, ein Name kann gleichzeitig der Name eines Datenobjekts und der Name eines Datentyps sein.
Datentypen
Datentypen treten in ABAP zum einen als Attribute von Datenobjekten auf, zum anderen knnen sie eigenstndig definiert werden. Die Definition von eigenstndigen Datentypen baut auf einem Satz von vordefinierten elementaren Datentypen auf. Sie kann programmintern im Deklarationsteil eines Programms mit der Anweisung TYPES oder programmbergreifend im ABAP Dictionary erfolgen. Eigenstndige Datentypen knnen zur Deklaration von Datenobjekten und zur Typberprfung bei generischen Operationen verwendet werden.
Datenobjekte
Datenobjekte sind die physikalischen Einheiten, mit denen ABAP-Anweisungen zur Laufzeit arbeiten. Jedes ABAP-Datenobjekt hat bestimmte technische Eigenschaften, die zu jedem Zeitpunkt der Laufzeit eines ABAP-Programms vollstndig spezifiziert sind. Die technischen Eigenschaften eines Datenobjekts sind: Feldlnge, Anzahl der Nachkommastellen und Datentyp. ABAP-Anweisungen arbeiten mit dem Inhalt von Datenobjekten und interpretieren ihn entsprechend des Datentyps. Datenobjekte werden entweder statisch im Deklarationsteil eines ABAP-Programms (wichtigste Anweisung: DATA) oder dynamisch zur Laufzeit (z.B. beim Aufruf von Prozeduren) erzeugt. Zustzlich zu Feldern im Speicherbereich werden auch Literale aus dem Programmcoding wie Datenobjekte behandelt. Datentypen [Seite 95] Datenobjekte [Seite 123] Weitere Informationen zu Datentypen und Datenobjekten: Kompatibilitt [Seite 138] Attribute von Datenobjekten bestimmen [Seite 140] Beispiele zu Datentypen und Objekten [Seite 145]
94
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Datentypen
Datentypen
Die folgende Abbildung zeigt eine bersicht ber die Datentypen in ABAP. Datentypen sind ein Teilbaum der ABAP-Typenhierarchie [Seite 90].
Datentypen Datentypen Elementare Typen Elementare Typen Feste Lnge Feste Lnge C C N N D D T T X X P P II F F Variable Lnge Variable Lnge STRING STRING XSTRING XSTRING Komplexe Typen Komplexe Typen Strukturtypen Strukturtypen Tabellentypen Tabellentypen Referenztypen Referenztypen Datenreferenzen Datenreferenzen Objektreferenzen Objektreferenzen Klassenreferenzen Klassenreferenzen Interfacereferenzen Interfacereferenzen
Zeichenartige Typen
Numerische Typen
Datentypen unterteilen sich in elementare, Referenz- und komplexe Typen.
Elementare Typen
Elementare Typen sind atomar in dem Sinn, da sie nicht aus anderen Typen zusammengesetzt sind. Sie sind nochmals in solche fixer und solche variabler Lnge unterteilt.
April 2001
95
SAP AG
Elementare Typen fixer Lnge

Es gibt acht in ABAP eingebaute elementare Typen fixer Lnge:

Vier zeichenartige Typen: Zeichenfelder (C), numerische Zeichenfelder (N), Datumsfelder (D) und Zeitfelder (T). Ein hexadezimaler Typ: Bytefelder (X). Drei numerische Typen: Integer (I), Gleitpunktzahlen (F) und gepackte Zahlen (P).
Elementare Typen variabler Lnge

Es gibt zwei in ABAP eingebaute elementare Typen variabler Lnge:

STRING fr Zeichenfolgen XSTRING fr Bytefolgen
Referenztypen
Referenztypen beschreiben Datenobjekte, die Referenzen (Zeiger) auf andere Objekte (Datenobjekte und Objekte aus ABAP Objects) enthalten. Referenztypen bilden eine Hierarchie, welche die Hierarchie der Objekte abbildet, auf welche die Referenzen zeigen knnen. Es gibt keine vordefinierten Referenzen, sondern sie mssen im Programm definiert werden.
Komplexe Typen
Komplexe Typen sind aus anderen Typen zusammengesetzt. Sie erlauben die Verwaltung und Bearbeitung von semantisch zusammengehrigen Datenmengen unter einem Namen. Auf ein Datenobjekt eines komplexen Typs kann insgesamt oder komponentenweise zugegriffen werden. Es gibt in ABAP keine eingebauten komplexen Datentypen. Ein komplexer Datentyp mu entweder im ABAP-Programm oder im ABAP Dictionary definiert werden. Sie sind in Strukturen und interne Tabellen unterteilt.
Strukturen
Eine Struktur (auch Feldleiste genannt) ist eine Folge beliebiger elementarer Typen, Referenztypen oder komplexer Datentypen. Strukturen dienen in ABAP-Programmen zur Zusammenfassung von logisch zusammengehrigen Arbeitsbereichen. Da die Einzelelemente von Strukturen beliebige Datentypen haben knnen, sind die Einsatzmglichkeiten von Strukturen sehr umfassend. Beispielsweise dienen Strukturen mit elementaren Elementen der Darstellung von Zeilen aus Datenbanktabellen und Strukturen mit komplexen Elementen werden eingesetzt, um alle Eigenschaften eines Bildschirms oder Controls in einem Datenobjekt zusammenzufassen. Bei Strukturen spielen folgende Begriffe eine Rolle:

Geschachtelte und nicht-geschachtelte Strukturen. Flache und tiefe Strukturen.
96
April 2001
SAP AG
Geschachtelte Strukturen sind Strukturen, die wiederum Strukturen als Komponenten enthalten. Flache Strukturen enthalten nur elementare Datentypen fixer Lnge, also keine internen Tabellen, Referenztypen oder Strings. Fr den Begriff tiefe Struktur spielt es keine Rolle, ob die Struktur geschachtelt oder nicht geschachtelt ist. Geschachtelte Strukturen sind solange flach, wie keiner der obigen Typen in irgendeiner Schachtelungsebene enthalten ist. Jede Struktur, die unabhngig von der Schachtelung mindestens eine interne Tabelle, einen Referenztyp oder einen String als Komponente enthlt bezeichnen wir als tief. Dementsprechend heien interne Tabellen, Referenzen und Strings auch tiefe Datentypen. Der technische Unterschied zwischen den tiefen und den brigen Datentypen ist der, da beim Anlegen eines tiefen Datenobjekts im Speicher, an der Stelle, an der bei einem flachen Typ der tatschliche Feldinhalt abgelegt wird, bei tiefen Typen nur ein Zeiger angelegt wird, der auf den wirklichen Feldinhalt bzw. auf weitere Verwaltungsinformationen zeigt. Nur bei flachen Strukturen befindet sich also der Dateninhalt der Struktur innerhalb der Speichergrenzen der Struktur selbst. Tiefe Strukturen enthalten an der Position der tiefen Komponenten dagegen Zeiger auf die Daten. Aus diesem Grund werden tiefe Strukturen bei Zuweisungen, Offset-/Lngenzugriffen etc. auch anders behandelt als flache Strukturen.
Interne Tabellen
Interne Tabellen bestehen aus einer Folge von Zeilen gleichen Datentyps. Interne Tabellen sind charakterisiert durch

den Zeilentyp, der ein beliebiger elementarer Typ, ein Referenztyp oder komplexer Datentyp sein kann. einen Schlssel, welcher der Identifikation von Tabellenzeilen dient. Er lt sich aus den elementaren Feldern der Zeilen aufbauen. Wir unterscheiden weiterhin zwischen eindeutigen und nicht eindeutigen Schlsseln. die Zugriffsart, die definiert, wie ABAP auf die Tabelle zugreift. Bei der Zugriffsart lassen sich unsortierte und sortierte Indextabellen sowie Hash-Tabellen unterscheiden. Bei Index-Tabellen wird intern ein linearer Index gefhrt, so da der Zugriff auf Tabellenzeilen sowohl ber Indexangabe als auch ber den Schlssel erfolgen kann. Bei Hash-Tabellen wird kein linearer Index gefhrt. Der Zugriff auf Tabellenzeilen erfolgt ausschlielich unter Angabe des Schlssels. Hierbei fhrt das System intern einen Hash-Algorithmus aus.
Interne Tabellen werden immer dann eingesetzt, wenn mehrfache Daten einer festen Struktur programmintern verwendet werden. Ein wichtiges Einsatzgebiet ist z.B. die programminterne Speicherung von Daten aus der Datenbank.
Beispiele komplexer Datentypen

Die folgende Liste enthlt einige Beispiele fr komplexe Datentypen, geordnet nach steigender Komplexitt: 1. Strukturen, die aus einer Serie von elementaren Datentypen fixer Lnge bestehen (nichtgeschachtelte, flache Strukturen). 2. Interne Tabellen, deren Zeilentyp ein elementarer Typ ist (Vektor). 3. Interne Tabellen, deren Zeilentyp eine nicht-geschachtelte Struktur ist ('echte' Tabellen) 4. Strukturen mit Strukturen als Komponenten (geschachtelte Strukturen, flach oder tief). 5. Strukturen mit internen Tabellen als Komponenten (Beispiel fr tiefe Strukturen) 6. Interne Tabellen, deren Zeilentyp wiederum interne Tabellen enthlt.
April 2001
97
SAP AG
1 1 2 2 3 3
4 4
5 5
6 6
Die Abbildung zeigt, wie aus Einzelfeldern komplexe Typen beliebiger Komplexitt aufgebaut werden knnen.
Weitere Themen zu Datentypen

Die verschiedenen Datentypen knnen auf unterschiedlichen Ebenen des R/3-Systems definiert werden. Nhere Informationen hierzu finden sich unter Definition von Datentypen [Seite 100] In bestimmten ABAP-Anweisungen kann man sich mit dem Zusatz TYPE auf vorhandene Datentypen beziehen. Dies setzt voraus, da die Datentypen an der gewnschten Stelle sichtbar sind. Nhere Informationen hierzu finden sich unter Sichtbarkeit von Datentypen [Seite 117] Bei der Arbeit mit Daten ist es wichtig zu wissen, ob die Datentypen kompatibel sind oder nicht. Nhere Informationen hierzu finden sich unter Kompatibilitt von Datentypen [Seite 138].
98
April 2001
SAP AG
April 2001
99
ABAP Programmierung (BC-ABA) Definition von Datentypen
SAP AG
Definition von Datentypen

Die folgende Abbildung zeigt wo die Datentypen in ABAP definiert werden knnen:
Datentypen Eingebaute ABAP-Typen Programmlokale Typen im Typen ABAP Dictionary ABAP Dictionary Typen Objekte in Typgruppen
Wir unterscheiden zwischen

Eingebauten ABAP-Typen [Seite 101], die im Kernel vordefiniert sind. Programmlokalen Datentypen [Seite 104], die in ABAP-Programmen definiert werden knnen Datentypen im ABAP Dictionary [Seite 109], die systemweit allen Programmen zur Verfgung stehen. Im ABAP Dictionary knnen Typen entweder als Dictionary-Objekt oder in sogenannten Typgruppen definiert werden.
100
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Eingebaute ABAP-Typen
Eingebaute ABAP-Typen
Diese Datentypen sind im Kernel des R/3-Systems eingebaut und in jedem ABAP-Programm sichtbar. Die eingebauten Typen knnen zum einen bei der Definition von programmlokalen Datentypen und Datenobjekten zum anderen bei der Typisierung von Schnittstellenparametern und Feldsymbolen verwendet werden. Vor Release 4.5A wurden eingebaute Datentypen auch als vordefinierte Datentypen bezeichnet. Seit Release 4.5A kann man aus der Sicht eines ABAP Programms Datentypen auch programmbergreifend im ABAP Dictionary (vor)definieren. Deshalb ist der Begriff 'vordefiniert' nicht mehr eindeutig und wird durch 'eingebaut' ersetzt.
Eingebaute elementare ABAP-Typen fixer Lnge

Diese eingebauten elementaren Datentypen dienen der Typisierung von Einzelfeldern, deren Lnge zur Laufzeit immer festgelegt ist. Die folgende Tabelle fat die elementaren eingebauten Datentypen fixer Lnge zusammen. Die Feldlngen sind in Bytes angegeben.
Datentyp Initiale Gltige Initialwert Bedeutung Feldlnge Feldlnge
Numerische Typen I F P Zeichenartige Typen C D N T Hexadezimaler Typ X 1 1 - 65535 X'0 0' Hexadezimalfeld Die Datentypen D, F, I und T beschreiben die technischen Eigenschaften eines Datenobjekts vollstndig. Die Datentypen C, N, P und X sind generisch. Wenn ein generischer Typ zur Definition eines programmlokalen Datentyps oder bei der Deklaration eines Datenobjekts verwendet wird, mssen Feldlnge und beim Typ P die Anzahl der Dezimalstellen im Programm festgelegt werden. Bei Verwendung der generischen Datentypen fr die Typisierung von Schnittstellenparametern oder Feldsymbolen mssen die technischen Eigenschaften nicht spezifiziert werden. 1 8 1 6 1 - 65535 8 1 - 65535 6 ' ' '00000000' '0 0' '000000' Textfeld (alphanumerische Zeichen) Datumsfeld (Format: JJJJMMTT) Numerisches Textfeld (numerische Zeichen) Zeitfeld (Format HHMMSS) 4 8 8 4 8 1 - 16 0 0 0 Ganze Zahl Gleitpunktzahl Gepackte Zahl
April 2001
101
SAP AG
Der Initialwert, und bei den generischen Typen die initiale Feldlnge, sind Werte, die bei Verwendung von Kurzformen der Anweisungen TYPES und DATA implizit eingesetzt werden. Die eingebauten Typen fixer Lnge sind unterteilt in:
Numerische Typen
Neben fnf nichtnumerischen Typen, Texfelder (C), numerische Textfelder (N), Datumsfelder (D), Zeitfelder (T) und Hexadezimalfelder (X), gibt es drei numerische Typen, die der Reprsentation und Berechnung von Zahlen in ABAP dienen. Der Datentyp N ist kein numerischer Typ. Daten vom Typ N knnen nur numerische Zeichen (0,1,2,,9) enthalten, werden intern aber nicht als Zahlen reprsentiert. Typische N-Felder sind Kontonummern und Postleitzahlen.
Ganze Zahlen - Typ I Der Wertebereich reicht von -2**31 bis zu 2**31-1 und bercksichtigt nur ganze Zahlen. Bei arithmetischen Rechnungen (z.B. Divisionsrechnungen), die keine ganzen Zahlen ergeben, wird das Ergebnis gerundet, nicht abgeschnitten. Daten vom Typ I werden u.a. fr Zhler, Stckzahlen, Indizes oder Zeitrume verwendet.
Gepackte Zahlen - Typ P Daten vom Typ P knnen Ziffern nach dem Dezimalpunkt aufweisen. Die Anzahl der Dezimalstellen ist generisch und wird im Programm festgelegt. Der Wertebereich von Typ P Daten hngt sowohl von ihrer Gre als auch von der Anzahl der Stellen hinter dem Dezimalpunkt ab. Die gltige Gre liegt zwischen 1 und 16 Bytes. Zwei Dezimalstellen werden in ein Byte gepackt, wobei das letzte Byte nur eine Stelle und das Vorzeichen enthlt. Hinter dem Dezimalpunkt sind bis zu 14 Stellen erlaubt. Der Initialwert ist Null. Bei der Arbeit mit Daten vom Typ P empfiehlt es sich, im ABAP-Editor das Programmattribut Festpunktarithmetik zu setzen, sonst werden P-Zahlen wie ganze Zahlen behandelt. Daten vom Typ P werden fr die Angabe von Entfernungen, Gewichten, Geldbetrgen usw. verwendet.
Gleitpunktzahlen - Typ F Der Wertebereich von Gleitpunktzahlen reicht von 1x10**-307 bis zu 1x10**308 fr positive und negative Zahlen, einschlielich der 0 (null). Der Genauigkeitsbereich ist ungefhr 15 Stellen, abhngig von der Gleitpunktarithmetik der Hardware-Plattform. Da Daten vom Typ F intern in ein binres System konvertiert werden, knnen Rundungsfehler auftreten. Obwohl der ABAP-Prozessor versucht, diese Fehler auf ein Minimum zu beschrnken, sollten Sie diesen Datentyp nicht einsetzen, wenn es Ihnen auf Genauigkeit ankommt. In diesem Fall benutzen Sie besser Daten vom Typ P. Daten vom Typ F werden benutzt, wenn sehr groe Wertebereiche bentigt werden und es auf Rundungsfehler nicht ankommt.
Berechungen mit I- und F-Feldern sind schneller als mit P-Feldern. Arithmetische Operationen mit I- und F-Feldern sind eng verwandt mit Maschinensprache-Anweisungen, whrend P-Felder grere Software-Untersttzung erfordern. Dennoch gibt es zu Daten vom Typ P keine Alternative, wenn es um Genauigkeit oder bestimmte Anforderungen an den Wertebereich geht.
Zeichenartige Typen
Von den fnf nichtnumerischen Typen bezeichnen wir die vier Typen C, D, N, T als zeichenartige Typen und Felder mit solch einem Typ als Zeichenfeld. Jede Stelle eines
102
April 2001
SAP AG
solchen Felds belegt im Speicher den Platz fr den Code eines Zeichens. Zur Zeit arbeitet ABAP nur mit Einbyte-Codes wie ASCII und EBCDI. Die Erweiterung auf UNICODE, wo ein Zeichen zwei oder vier Bytes belegt ist in Vorbereitung.
Hexadezimaltyp
Der brige nichtnumerische Typ X interpretiert immer einzelne Bytes im Speicher. Ein Byte wird durch die zweistellige Hexadezimaldarstellung dargestellt. Die Felder dieses Typs heien Hexadezimalfelder. In Hexadezimalfeldern kann auch eine Einzelbitverarbeitung [Seite 184] durchgefhrt werden.
Eingebaute elementare ABAP-Typen variabler Lnge

Diese eingebauten elementaren Datentypen dienen der Typisierung von Einzelfeldern, deren Lnge erst zur Laufzeit festgelegt wird. Es gibt zwei in ABAP eingebaute elementare Typen variabler Lnge, die zusammenfassend auch Strings genannt werden:
STRING fr Zeichenfolgen Eine Zeichenfolge ist ein zeichenartiger Typ variabler Lnge. Eine Zeichenfolge kann beliebig viele alphanumerische Zeichen aufnehmen. Die Lnge einer Zeichenfolge ist die Anzahl der Zeichen multipliziert mit der Lnge der internen Darstellung des Zeichens.
XSTRING fr Bytefolgen Eine Bytefolge ist ein Hexadezimaltyp variabler Lnge. Eine Bytefolge kann beliebig viele Bytes aufnehmen. Die Lnge einer Bytefolge entspricht der Anzahl der Bytes.
Beim Anlegen von Strings als Datenobjekte wird nur ein Verwaltungseintrag namens StringHeader statisch vereinbart wird. Die eigentlichen Datenobjekte werden zur Laufzeit durch operationale Anweisungen dynamisch erzeugt und verndert. Der Initialwert eines Strings ist der leere String mit der Lnge 0. Eine Struktur, die einen String enthlt wird intern als tiefe Struktur behandelt. Das bedeutet, da es keine Konvertierungsregeln fr Strukturen [Seite 201] gibt, die Strings enthalten.
Eingebaute komplexe Datentypen

ABAP enthlt keine eingebauten komplexen Datentypen, die bei der Definition von programmlokalen Datentypen oder von Datenobjekten verwendet werden knnen. Alle komplexen Datentypen beruhen auf den elementaren ABAP-Typen und werden erst im ABAPProgramm oder im ABAP Dictionary konstruiert.
April 2001
103
ABAP Programmierung (BC-ABA) Programmlokale Datentypen
SAP AG
Programmlokale Datentypen
Jedes ABAP-Programm kann seine eigenen Datentypen definieren und innerhalb eines Programms knnen Prozeduren [Seite 467] nochmals eigene lokale Datentypen definieren. Programmlokale Datentypen werden mit der Anweisung
TYPES <t> ... [TYPE <type>|LIKE <obj>] ...

definiert. Der Name des Datentyps <t> kann bis zu 30 Zeichen lang sein. Es knnen alle Ziffern, Buchstaben und der Unterstrich verwendet werden. Der Name darf nicht aus Ziffern alleine bestehen. Die Sonderzeichen + . , : ( ) - < > drfen nicht verwendet werden. Die brigen Sonderzeichen sind fr den internen Gebrauch reserviert. Die Namen der eingebauten ABAPTypen (C, D, F, I, N, P, T, X, STRING, XSTRING) drfen nicht verwendet werden, ebensowenig der Name des generischen Typs TABLE. Es sollten keine Namen verwendet werden, die mit einem Schlsselwort oder einem Zusatz von ABAP-Anweisungen bereinstimmen. Es sollten

Namen verwendet werden, die die Bedeutung des Typs verstndlich machen, ohne da zustzliche Kommentare erforderlich werden. zur Gliederung zusammengesetzter Name der Unterstrich verwendet werden. als erstes Zeichen stets ein Buchstaben verwendet werden.
Programmlokale Datentypen werden entweder mit Bezug auf bekannte Datentypen definiert oder neu konstruiert. Ein bekannter Typ kann sein

ein eingebauter ABAP-Typ, auf den mit dem TYPE-Zusatz verwiesen wird. ein bereits vorhandener programmlokaler Datentyp, auf den mit dem TYPE-Zusatz verwiesen wird. der Datentyp eines programmlokalen Datenobjekts, auf den mit dem LIKE-Zusatz verwiesen wird. ein Datentyp im ABAP Dictionary, auf den mit dem TYPE-Zusatz verwiesen wird. Aus Kompatibilittsgrnden zu vorhergehenden Releases kann auch mit dem LIKE-Zusatz auf Datenbanktabellen und flache Strukturen des ABAP Dictionary verwiesen werden. In neuen Programmen sollte aber auch hier der TYPE-Zusatz verwendet werden.
Die bekannte Typen mssen an der Definitionstelle sichtbar [Seite 117] sein. Falls der bekannte Datentyp generisch ist, knnen mit weiteren Zustzen die noch offenen Eigenschaften des Typs <t> spezifiziert werden.
Elementare Datentypen
Programmlokale elementare Datentypen werden ausschlielich durch Bezug auf eingebaute elementare Typen definiert. Die Syntax fr die Definition elementarer Datentypen ist:
TYPES <t>[(<length>)] [TYPE <type>|LIKE <obj>] [DECIMALS <dec>].

Dabei ist <type> entweder einer der eingebauten ABAP-Typen C, D, F, I, N, P, T, X, STRING oder XSTRING, ein vorher definierter elementarer programmlokaler Typ oder ein im ABAP Dictionary definiertes Datenelement. Beim Bezug auf ein Datenelement aus dem Dictionary wird dieses in einen elementaren ABAP Typ konvertiert. Beim LIKE-Bezug kann <obj> ein vorher deklariertes Datenobjekt mit elementarem Datentyp sein.
104
April 2001
SAP AG
Ohne TYPE- oder LIKE-Zusatz wird implizit der eingebaute Typ C verwendet. Falls <type> einer der generischen elementaren eingebauten ABAP-Typen fixer Lnge (C, N, P, X) ist, sollte mit der Option <length> die Feldlnge festgelegt werden. Ohne die Angabe von <length> wird die Feldlnge auf den entsprechenden Initialwert der Tabelle unter Eingebaute ABAP-Typen [Seite 101] gesetzt. Falls <type> gleich P ist, kann mit der Option DECIMALS die Anzahl der Dezimalstellen festgelegt werden. Ohne die Angabe von DECIMALS wird die Anzahl der Dezimalstellen auf Null gesetzt. Die implizite Anweisung
TYPES <t>.
Definiert also ein Characterfeld <t> der Lnge 1. Sie ist eine Kurzform der expliziten Anweisung
TYPES <t>(1) TYPE C.

Es sollte aber immer die explizite Anweisung verwendet werden. Insbesondere ist die Kurzform im Umfeld von ABAP Objects, also innerhalb von Klassen, verboten. Elementare programmlokale Datentypen knnen Programme transparenter und lesbarer machen. Wenn man einen programmlokalen Datentyp zur Typisierung mehrerer Datenobjekten verwendet hat, lt sich der Datentyp all dieser Datenobjekte auf einmal ndern, indem man die Definition des Datentyps in der TYPES-Anweisung ndert. Oder wenn eine bestimmte Menge von Datentypen regelmig in verschiedenen Programmen benutzt werden soll, die Datentypen aber nicht systemweit im ABAP Dictionary abgelegt werden sollen, kann man sich ein IncludeProgramm [Seite 465] fr die Typdefinition anlegen und in die Programme einbetten.
TYPES: number TYPE i, length TYPE p DECIMALS 2, code(3) TYPE c. ...

In diesem Beispiel wird ein Datentyp mit dem Namen NUMBER definiert. Er ist bis auf den Namen identisch mit dem eingebauten ABAP-Typ I und dient somit nur zur Erhhung der Lesbarkeit des Programms. Es wird ein Datentyp LENGTH definiert, der auf dem eingebauten generischen ABAP-Typ P basiert. LENGTH wird mit einer gegebenen Zahl von Dezimalstellen definiert. Wre es zum Beispiel erforderlich die Genauigkeit von Lngenangaben zu ndern, mte man lediglich die TYPES-Anweisung des Programms ndern. Es wird ein dritter Datentyp CODE definiert. CODE basiert auf dem eingebauten generischen ABAP-Typ C. Die Feldlnge wird hier mit 3 Bytes festgelegt.
DATA counts TYPE i. TYPES: company TYPE spfli-carrid, no_flights LIKE counts.
Dieses Beispiel zeigt, wie mit dem Zusatz TYPE auf die Spalte CARRID der Datenbanktabelle SPFLI verwiesen wird. Der Zusatz LIKE verweist auf ein bereits vorhandenes Datenobjekt.
April 2001
105
SAP AG
Referenztypen
Referenztypen sind programmlokal und im ABAP Dictionary definierbar. Die Syntax fr die Definition von Referenztypen ist:
TYPES <t> TYPE REF TO ...

Hier steht hinter dem TYPE-Zusatz kein Verweis auf einen anderen Datentyp, sondern ein sogenannter Typkonstruktor.
Mit dem Typkonstruktor
REF TO DATA
definiert die TYPES-Anweisung eine Referenz <t> auf ein Datenobjekt. Felder des Datentyps <t> knnen Referenzen (Zeiger) auf Datenobjekte also auf Instanzen von Datentypen enthalten (siehe auch Datenreferenzen [Seite 232]).
Mit dem Typkonstruktor
REF TO <class>|<interface>
definiert die TYPES-Anweisung eine Referenz <t> auf die Klasse <class> oder das Interface <interface>. Felder des Datentyps <t> knnen Referenzen (Zeiger) auf Instanzen der Klasse <class> oder ihrer Unterklassen bzw. von Klassen, die das Interface <interface> implementieren, enthalten (siehe auch Behandlung von Objekten [Seite 1410]).
Komplexe Typen
Ein komplexer programmlokaler Datentyp setzt sich immer aus obigen elementaren Datentypen oder Referenztypen zusammen. Die TYPES-Anweisung ist in diesem Fall ein Konstruktionsvorschrift fr den komplexen Datentyp. Beim TYPE- oder LIKE-Bezug auf einen bekannten komplexen Typ:
TYPES <t> [TYPE <type>|LIKE <obj>].

wird der neue komplexe Typ nach Vorlage des bekannten Typs konstruiert. Beim Bezug auf die komplexen Dictionary-Typen Struktur oder Tabellentyp, die sich aus elementaren Datenelementen des Dictionarys zusammensetzen, wird der Aufbau aus dem Dictionary bernommen und die Datenelemente werden in elementare ABAP-Typen konvertiert. Die TYPES-Anweisung ermglicht es auch neue komplexe Datentypen ohne Bezug auf bekannte Strukturen und Tabellen zu definieren.
Strukturtypen
Fr die Konstruktion eines neuen programmlokalen Strukturtyps verwendet man mehrere TYPES-Anweisungen wie im folgenden Kettensatz:
TYPES: BEGIN OF <structure>, .............. <ti> ..., .............. END OF <structure>.

Dieser Kettensatz fat zwischen den Anweisungen
TYPES BEGIN OF <structure>. und TYPES END OF <structure>.
106
April 2001
SAP AG
die in den Anweisungen
TYPES <ti>... .
definierten Datentypen <ti> zu einem Strukturtyp zusammen. Die einzelnen Komponenten <ti> knnen elementare Typen, Referenztypen oder durch Bezug auf bekannte komplexe Typen selber komplex sein. Die Anweisungsblcke TYPES BEGIN OF - TYPES END OF sind auch schachtelbar, um nichtflache Strukturtypen zu konstruieren. Die einzelnen Komponenten eines Strukturtyps werden im Programm mit einem Bindestrich zwischen Strukturname und Komponentenname benannt: <structure>-<ti>.
TYPES: spfli_type TYPE spfli, surname(20) TYPE c, BEGIN OF address, name TYPE surname, street(30) TYPE c, city TYPE spfli_type-cityfrom, END OF address, town TYPE address-city.
Dieses Beispiel zeigt die programmlokalen Definitionen zweier Strukturtypen SPFLI_TYPE und ADDRESS. Die Struktur des Datentyps SPFLI_TYPE wird von der Datenbanktabelle SPFLI aus dem ABAP Dictionary bernommen. Die einzelnen Komponenten von SPFLI_TYPE spiegeln die Spalten von SPFLI wieder. Die einzelnen Datentypen der Komponenten sind die ABAP-Entsprechungen der Datentypen der Spalten im ABAP Dictionary. Der Strukturtyp ADDRESS wird neu definiert. Die Komponente ADDRESS-NAME bernimmt den Datentyp vom vorher definierten Typ SURNAME, die Komponente ADDRESS-STREET wird neu definiert, die Komponente ADDRESS-CITY bernimmt den Datentyp der Spalte CITYFROM des Strukturtyps SPFLI_TYPE.
TYPES: BEGIN OF struct1, col1 TYPE i, BEGIN OF struct2, col1 TYPE i, col2 TYPE i, END OF struct2, END OF struct1. TYPES mytype TYPE struct1-struct2-col2.
Das Beispiel zeigt, wie ein geschachtelter Strukturtyp STRUCT1 mit einer komplexen Komponente STRUCT2 durch Schachtelung der Anweisungsblcke TYPES BEGIN OF - TYPES END OF konstruiert werden kann und wie die inneren Komponenten angesprochen werden.
* Programmlokale Typen, * die auf eingebaute ABAP-Typen verweisen:
April 2001
107
SAP AG
TYPES: surname(20) street(30) zip_code(10) city(30) phone(20) date
TYPE TYPE TYPE TYPE TYPE LIKE
c, c, n, c, n, sy-datum.
* Programmlokale Struktur, * die auf obige Typen verweist: TYPES: BEGIN of address, name TYPE surname, code TYPE zip_code, town TYPE city, str TYPE street, END OF address. * Programmlokale geschachtelte Struktur, * die auf obige Typen verweist: TYPES: BEGIN of phone_list, adr TYPE address, tel TYPE phone, END OF phone_list.
Dieses Beispiel zeigt, wie man aus einfachen Typdefinitionen komplexe Datentypen aufbauen kannn. Nachdem eine Menge von elementaren Datentypen mit eingebauten ABAP-Typen angelegt wurde, wird ein Strukturtyp ADDRESS mit den vorher definierten Datentypen definiert. Schlielich wird ein geschachtelter Strukturtyp PHONE_LIST angelegt, dessen erste Komponente den Typ ADDRESS hat.
Tabellentypen
Programmlokale Tabellen werden auch interne Tabellen genannt. Die Syntax fr die Konstruktion eines neuen internen Tabellentyps ist:
TYPES <t> TYPE|LIKE <tabkind> OF <linetype> [WITH <key>].

Wie bei Referenzen steht hier hinter dem TYPE-Zusatz kein Verweis auf einen anderen Datentyp, sondern ein Typkonstruktor. Mit dem Typkonstruktor
<tabkind> OF <linetype> [WITH <key>]

wird ein interner Tabellentyp der Zugriffsart <tabkind>, dem Zeilentyp <linetype> und dem Schlssel <key> definiert. Der Zeilentyp <linetype> ist ein beliebiger bekannter Datentyp. Die Angaben zum Schlssel sind optional. Interne Tabellen knnen also generisch sein. Fr ausfhrliche Informationen zur Definition interner Tabellen siehe Interne Tabellen [Seite 265].
108
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Datentypen im ABAP Dictionary
Datentypen im ABAP Dictionary

Im ABAP Dictionary knnen programmbergreifende Datentypen definiert werden. Auf diese Datentypen kann in jedem ABAP-Programm des R/3-Systems mit dem TYPE-Zusatz entsprechender ABAP-Anweisungen Bezug genommen werden. Die Definition der Dictionary-Datentypen erfolgt mit dem Werkzeug Dictionary [Extern] der ABAP Workbench. Dort sind folgende Eingabefelder von Bedeutung fr Datentypen:
Weitere Dictionary-Objekte Dictionary: Einstieg Hilfsmittel Weitere Dictionary-Objekte Dictionary-Objekt Datenbanktabelle View Typ ... anlegen Datentyp Datenelement Struktur Tabellentyp Domne Anzeigen ndern Anlegen Typgruppe
Metabeschreibungen
Datentypen
Technische Eigenschaften
Auf dem Einstiegsbild sind drei Gruppen zu unterscheiden:
Datenbanktabellen und Views

Eine der wichtigsten Aufgaben des ABAP Dictionarys [Extern] ist die Verwaltung von Datenbanktabellen in der zentralen Datenbank des R/3-Systems. Hierfr werden im Dictionary Metabeschreibungen von Datenbanktabellen angelegt und daraus physische Datenbanktabellen auf der Datenbank erzeugt. Views sind logische Sichten auf eine oder mehrere Tabellen. Bei der Beschreibung einer Datenbanktabelle, werden die Tabellenzeilen aus Einzelfeldern bzw. Spalten zusammengesetzt. Jeder Spalte mu dabei ein elementarer Datentyp zugewiesen werden. Die elementaren Datentypen des Dictionarys sind die Datenelemente. hnlich wie
April 2001
109
SAP AG
Datenobjekte in ABAP-Programmen, haben Datenbanktabellen und Views somit Datentypen als Attribute. Eine Zeile einer Datenbanktabelle bzw. Views hat immer den Datentyp einer flachen Struktur, der sich aus einzelnen Datenelementen zusammensetzt. In ABAP-Programmen kann mit dem TYPE-Zusatz auf den Datentyp einer Datenbanktabelle oder eines Views Bezug genommen werden. Dabei kann entweder auf die gesamte Struktur oder auf deren Komponenten zugegriffen werden:
... TYPE <dbtab> ...

bezieht sich auf den komplexen Datentyp der Struktur,
... TYPE <dbtab>-<ci> ...

bezieht sich auf den elementaren Datentyp der Komponente <ci>. Wenn ein komplexer Datentyp <t> mit
TYPES <t> TYPE <dbtab>.

als Struktur definiert wird, erben die Komponenten des Datentyps <t> die Namen der Komponenten der Datenbanktabelle bzw. Views und sind im Programm ber <t>-<ci> ansprechbar. Aus Kompatibilittsgrnden mit vorhergehenden Releases kann in allen Programmen auer innerhalb von Klassen auch mit dem LIKE-Zusatz auf Datenbanktabellen bzw. Views Bezug genommen werden. Dies kommt daher, da das Dictionary zwar nur reine Metabeschreibungen bzw. Datentypen enthlt, da in frheren Releases aber mehr die physische Prsenz der Datenbanktabellen als Objekte auf der Datenbank im Vordergrund stand. Die Definition programmlokaler Datentypen mit Bezug auf Datenbanktabellen bzw. Views ist ein Grundpfeiler der Bearbeitung von Daten aus Datenbanktabellen in ABAP. Datenobjekte mit solchen Datentypen dienen als typgerechte Arbeitsbereiche fr Daten, die aus Datenbanktabellen in ABAP-Programme eingelesen werden und umgekehrt. ABAP Open SQL untersttzt dabei die gesamte Bandbreite vom Einlesen einzelner Felder bis zur bernahme gesamter Datenbanktabellen oder Views in interne Tabellen.
TYPES: city type spfli-cityfrom, spfli_type TYPE STANDARD TABLE OF spfli WITH DEFAULT KEY. DATA: wa_city TYPE city, wa_spfli TYPE spfli_type. ... SELECT SINGLE cityfrom FROM spfli INTO wa_city WHERE carrid = 'LH' AND connid = '400'. ... SELECT * FROM spfli INTO TABLE wa_spfli. ...
In diesem Beispiel werden ein elementarer Datentyp CITY mit Bezug auf ein einzelnes Feld der Datenbanktabelle SPFLI und eine interne Tabelle SPFLI_TYPE, deren Zeilentyp der Struktur der Datenbanktabelle entspricht, definiert. Mit der Open
110
April 2001
SAP AG
SQL-Anweisung SELECT werden Daten in entsprechend deklarierte Datenobjekte eingelesen.
Datentypen
Dies sind die eigentlichen Datentypen im ABAP Dictionary. Sie ermglichen die programmbergreifende Definition der elementaren Typen, Referenztypen und komplexen Typen des ABAP-Typkonzepts. Die Datentypen von Datenbanktabellen sind eine Teilmenge aller mglichen Typen, nmlich flache Strukturen. Programmbergreifende Objekttypen (Klassen und Interfaces) werden nicht im ABAP Dictionary, sondern in der Klassenbibliothek verwaltet und mit dem Werkzeug Class Builder erstellt. Ein detaillierte Beschreibung der Datentypen und ihrer Definition im Dictionary findet sich unter Typen [Extern] in der Dokumentation zum ABAP Dictionary. Im folgenden wird nur kurz auf die einzelnen Typen eingegangen und wie aus ABAP-Programmen auf sie verwiesen wird.
Datenelemente
Die Datenelemente des Dictionarys beschreiben Einzelfelder. Sie sind die kleinsten nichtzerlegbaren Einheiten der unten aufgefhrten komplexen Typen und sie dienen der Typisierung von Spalten in Datenbanktabellen. Datenelemente sind entweder elementare Typen oder Referenztypen.
Elementare Typen
Elementare Typen sind Teil des zweistufigen Domnenkonzepts fr Einzelfelder im Dictionary. Der elementare Typ trgt semantische Eigenschaften wie Texte, Wertetabellen und Dokumentation und hat einen Datentyp. Der Datentyp kann auf zwei verschiedene Mglichkeiten festgelegt werden:
-
Direkte Zuweisung eines Dictionary-Typs. Elementaren Typen kann ein eingebauter Typ des ABAP Dictionarys und die Anzahl der Stellen zugewiesen werden. Das ABAP Dictionary kennt wesentlich mehr eingebaute Typen als die Programmiersprache ABAP. Auerdem bedeutet die Anzahl der Stellen hier nicht die Feldlnge in Bytes, sondern die Anzahl der gltigen Positionen ohne Aufbereitungszeichen. Der Unterschied zwischen den Datentypen rhrt daher, da die eingebauten Datentypen des Dictionarys mit den externen Datentypen der von R/3 untersttzten Datenbanktabellen vertrglich sein mssen. Beim Bezug von Datentypen auf Datentypen des Dictionarys in ABAP-Programmen, werden die eingebauten Dictionary-Typen wie folgt in eingebaute ABAP-Typen konvertiert:
Dictionary Typ Bedeutung Zulssige Stellen n ABAP Typ
DEC INT1 INT2 INT4 CURR CUKY QUAN
Rechen-/Betragsfeld 1-Byte-Integer 2-Byte-Integer 4-Byte-Integer Whrungsfeld Whrungsschlssel Menge
1-31, in Tabellen 1-17 3 5 10 1-17 5 1-17
P((n+1)/2) Nur intern Nur intern I P((n+1)/2) C(5) P((n+1)/2)
April 2001
111
SAP AG
UNIT PREC FLTP NUMC CHAR LCHR STRING RAWSTRING DATS ACCP TIMS RAW LRAW CLNT LANG
Einheit Genauigkeit Gleitpunktzahl Numerischer Text Character Long Character variable lange Zeichenfolge variable lange Bytefolge Datum Buchungsperiode JJJJMM Zeit HHMMSS Bytefolge Lange Bytefolge Mandant Sprache
2-3 2 16 1-255 1-255 256-max 1-max 1-max 8 6 6 1-255 256-max 3 intern 1, extern 2
C(n) X(2) F(8) N(n) C(n) C(n) STRING XSTRING D N(6) T X(n) X(n) C(3) C(1)
(Bei LCHR und LRAW ist max der Wert eines vorangehenden INT2-Felds, bei LANG bedeutet intern im Dictionary und extern Darstellung auf der Benutzerschnittstelle).
-
Zuweisung einer Domne. Die technischen Eigenschaften werden von einer Domne bernommen. Domnen sind eigenstndige Repository-Objekte des Dictionary. Sie knnen die technischen Eigenschaften von Datenelementen tragen. Eine Domne kann von beliebig vielen Datenelementen verwendet werden. Beim Anlegen einer Domne mssen ein Dictionary Datentyp (siehe Tabelle oben) und die Anzahl der Stellen angegeben werden.
Referenztypen
Referenztypen beschreiben Einzelfelder, die Referenzen auf globale Klassen und Interfaces der ABAP Klassenbibliothek enthalten knnen. In ABAP-Programmen kann mit dem TYPE-Zusatz direkt auf ein Datenelement verwiesen werden. Dabei werden die eingebauten Dictionary-Datentypen der Domne in die entsprechenden eingebauten ABAP-Typen konvertiert. Wenn ein programmlokaler Datentyp mit Bezug auf ein Datenelement definiert wird:
TYPES <t> TYPE <data element>.

werden die semantischen Eigenschaften des Datenelements ebenfalls bernommen und sind beispielsweise bei der Darstellung eines Datenobjekts vom Typ <t> auf einem Bildschirm nutzbar. Da alle Datentypen im Dictionary auf Datenelementen beruhen, enthalten auch alle Datentypen die entsprechenden semantischen Eigenschaften.
TYPES company TYPE s_carr_id.
112
April 2001
SAP AG
DATA wa_company TYPE company. wa_company = 'UA '. WRITE: 'Company:', wa_company.
In diesem Beispiel wird ein programmlokaler Typ COMPANY mit Bezug auf das Datenelement S_CARR_ID definiert. Das Datenelement ist mit der gleichnamigen Domne S_CARR_ID verknpft. Diese Domne definiert die technischen Eigenschaften als Datentyp CHAR der Lnge 3. Der programmlokale Datentyp COMPANY hat daher den eingebauten ABAP-Typ C(3). Weiterhin bernimmt COMPANY die semantischen Eigenschaften des Datenelements. Im obigen Beispiel wird ein Datenobjekt WA_COMPANY mit diesem Typ deklariert und auf einer Liste ausgegeben. Wenn der Benutzer auf dem Ausgabefeld die F1-Hilfe whlt, erscheint der im ABAP Dictionary hinterlegte Hilfetext in einem Dialogfenster.
Liste
Company: UA Hilfe Kurzbezeichnung der Fluggesellschaft Kurzbezeichnung der Fluggesellschaft Das Feld beinhaltet die ID der Fluggesellschaft Das Feld beinhaltet die ID der Fluggesellschaft
Strukturen
Strukturen sind Folgen von beliebigen anderen Datentypen des ABAP Dictionarys, also von Datenelementen, Strukturen, Tabellentypen oder Datenbanktabellen. Beim Anlegen einer Struktur im Dictionary mu jeder Komponente ein Name und ein Datentyp gegeben werden. In ABAP-Programmen kann mit dem TYPE-Zusatz direkt auf eine Struktur verwiesen werden. Wenn ein programmlokaler Datentyp mit Bezug auf eine Struktur im Dictionary definiert wird:
TYPES <t> TYPE <structure>.

wird die Konstruktionsvorschrift der Struktur in eine programmlokale Struktur (Feldleiste) <t> umgesetzt und die eingebauten Dictionary-Datentypen aus den Domnen der in der Struktur enthaltenen Datenelemente werden in die entsprechenden eingebauten ABAP-Typen konvertiert. Die semantischen Eigenschaften der Datenelemente werden fr die entsprechenden Komponenten der programmlokalen Struktur bernommen. Die Komponenten der programmlokalen Struktur <t> erben die Namen der Struktur aus dem Dictionary.
April 2001
113
SAP AG
Aus Kompatibilittsgrnden mit vorhergehenden Releases kann in ABAP-Programmen (aber nicht in Klassen) auch mit dem LIKE-Zusatz auf Strukturen im Dictionary verwiesen werden.
Die Struktur STRUCT sei im Dictionary wie folgt definiert:

Feldname Typname Kurzbeschreibung
COL1 COL2 COL3
CHAR01 CHAR08 CHAR10
Characterfeld der Lnge 1 Characterfeld der Lnge 8 Characterfeld der Lnge 10
Die Typen CHAR01 bis CHAR10 sind Datenelemente mit entsprechenden Domnen. In ABAP kann auf die Struktur verwiesen werden:
TYPES struct_type TYPE struct. DATA wa TYPE struct_type. wa-col1 = '1'. wa-col2 = '12345678'. wa-col3 = '1234567890'.
Es wird eine programmlokale Struktur STRUCT_TYPE und ein entsprechendes Datenobjekt WA angelegt. Die einzelnen Komponenten sind ber ihren ursprnglichen Namen ansprechbar.
Tabellentypen
Tabellentypen sind im Dictionary abgelegte Konstruktionsvorschriften fr interne Tabellen. Beim Anlegen eines Tabellentyps im Dictionary wird der Zeilentyp, die Zugriffsart und der Schlssel festgelegt. Der Zeilentyp ein beliebiger Datentyp des Dictionarys, also ein Datenelement, eine Struktur, ein Tabellentyp oder der Typ einer Datenbanktabelle sein. Weiterhin knnen als Zeilentyp wie in einer Domne auch direkt eingebaute Dictionary-Typen angegeben werden. In ABAP-Programmen kann mit dem TYPE-Zusatz direkt auf einen Tabellentyp verwiesen werden. Wenn ein programmlokaler Datentyp mit Bezug auf einen Tabellentyp im Dictionary definiert wird:
TYPES <t> TYPE <table>.

wird die Konstruktionsvorschrift des Tabellentyps in eine interne Tabelle <t> umgesetzt und die eingebauten Dictionary-Datentypen aus den Domnen der in dem Tabellentyp enthaltenen Datenelemente werden in die entsprechenden eingebauten ABAP-Typen konvertiert. Die semantischen Eigenschaften der Datenelemente werden fr die entsprechenden Komponenten in den Zeilen der internen Tabelle bernommen.
Der Tabellentyp STRUCT_TABLE sei im Dictionary mit dem Zeilentyp STRUCT des obigen Beispiels definiert worden. In ABAP kann auf den Tabellentyp verwiesen werden:
TYPES table_type TYPE struct_table.
114
April 2001
SAP AG
DATA: table_wa TYPE table_type, line_wa LIKE LINE OF table_wa. ... LOOP AT table_wa INTO line_wa. ... WRITE: line_wa-col1, line_wa-col1, line_wa-col1. ... ENDLOOP.
Es wird eine interne Tabelle TABLE_TYPE definiert. Mit diesem Typ werden Datenobjekte TABLE_WA und daraus folgend LINE_WA deklariert. LINE_WA entspricht dem Zeilentyp des Tabellentyps im Dictionary, ist also kompatibel zur Struktur STRUCT.
Typgruppen
Vor Release 4.5A gab es im Dictionary keine eigenstndigen Datentypen, auf die in ABAPProgrammen mit dem TYPE-Zusatz verwiesen werden konnte. Einen Bezug zwischen programmlokalen Datentypen und Dictionary-Datentypen gab es bis dahin nur fr flache Strukturen. Dem programmlokalen Datentyp Feldleiste entsprachen im Dictionary die Struktur von Datenbanktabellen und eigenstndige Strukturen. Aus ABAP-Programmen konnte man nur mit dem LIKE-Zusatz auf Datenbanktabellen und Strukturen des Dictionary verweisen. Dabei war auch der Verweis auf einzelne Komponenten der Dictionary-Typen mglich. Komplexe programmlokale Datentypen wie interne Tabellen oder tiefe Strukturen hatten bis dahin keine Entsprechung im Dictionary. Als Zwischenlsung standen seit Release 3.0 auf der IncludeTechnik basierenden Typgruppen (englisch Type Pools) zur Verfgung, um beliebige mit TYPES definierte Datentypen programmbergreifend im Dictionary ablegen zu knnen. Die Definition einer Typgruppe ist ein Stck ABAP-Code, das im ABAP-Editor gepflegt wird. Die erste Anweisung fr die Typgruppe <pool> ist immer:
TYPE-POOL <pool>.
Danach folgt die Definition von Datentypen mit der Anweisung TYPES, wie unter Programmlokale Datentypen [Seite 104] beschrieben. Weiterhin knnen programmbergreifende Konstanten mit der Anweisung CONSTANTS deklariert werden. Alle Namen dieser Datentypen und Konstanten mssen mit dem Namen der Typgruppe und einem Unterstrich beginnen: <pool>_ In einem ABAP-Programm mssen Typgruppen vor ihrer Verwendung mit folgender Anweisung bekanntgemacht werden:
TYPE-POOLS <pool>.
Bei Verwendung dieser Anweisung knnen alle Datentypen und Konstanten, die in der Typgruppe <pool> definiert sind, im Programm verwendet werden. Es knnen mehrere Typgruppen in einem Programm verwendet werden.
Die Typgruppe HKTST sei wie folgt im ABAP-Dictionary angelegt:
TYPE-POOL hktst. TYPES: BEGIN OF hktst_typ1, col1(10) TYPE c,
April 2001
115
SAP AG
col2 TYPE i, END OF hktst_typ1. TYPES hktst_typ2 TYPE p DECIMALS 2. CONSTANTS hktst_eleven TYPE i VALUE 11.
In dieser Typgruppe sind zwei Datentypen HKTST_TYP1 und HKTST_TYP2 sowie eine Konstante HKTST_ELEVEN mit dem Wert 11 definiert. Jedes ABAP-Programm kann diese Definition ber die Anweisung TYPE-POOLS verwenden:
TYPE-POOLS hktst. DATA: dat1 TYPE hktst_typ1, dat2 TYPE hktst_typ2 VALUE '1.23'. WRITE: dat2, / hktst_eleven.
Die Ausgabe ist:
1,23 11
Die in der Typgruppe definierten Datentypen werden zur Deklaration von Datenobjekten mit der Anweisung DATA verwendet und der Wert der Konstanten ist, wie die Ausgabe zeigt, im Programm bekannt.
116
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Der TYPE-Zusatz
Der TYPE-Zusatz
Der TYPE-Zusatz wird in verschiedenen ABAP-Anweisungen zur Definition von Datentypen und zur Typisierung von Schnittstellenparametern oder von Feldsymbolen verwendet. Je nach Syntax und Kontext kann der TYPE-Zusatz dabei eine andere Bedeutung haben:
Bezug auf bekannte Datentypen

Mit dem Zusatz
TYPE <type>
kann in den unten aufgefhrten ABAP-Anweisungen auf alle an dieser Stelle sichtbaren Datentypen <type> verwiesen werden. Dabei ist der Ausdruck <type> entweder der Name eines Datentyps oder der Ausdruck
LINE OF <table-type>
In diesem Fall bezieht sich der TYPE-Zusatz sinngem auf den Zeilentyp eines an dieser Stelle sichtbaren Tabellentyps <table-type>.
ABAP-Anweisungen mit TYPE-Bezug
Definition von programmlokalen Typen mit
TYPES <t> TYPE <type>.

Der neue Datentyp <t> entspricht vollstndig dem bekannten Typ <type>.
Deklaration von Datenobjekten mit
DATA <f> TYPE <type>. CLASS-DATA <f> TYPE <type>. CONSTANTS <f> TYPE <type>. STATICS <f> TYPE <type>. PARAMETERS <f> TYPE <type>.
Das Datenobjekt <f> erhlt einen Datentyp, der vollstndig dem bekannten Typ <type> entspricht.

Dynamische Erzeugung von Datenobjekten mit
CREATE DATA <dref> TYPE <type>.

Typisierung von Formalparametern in Unterprogrammen mit
FORM <sub> ... USING|CHANGING <p> TYPE <type> ...

Die technischen Eigenschaften des Formalparameters <p> sind vollstndig durch die Eigenschaften des bekannten Typs <type> festgelegt. Es drfen nur Aktualparameter des gleichen Typs bergeben werden.
Typisierung von Formalparametern in Methoden mit
METHODS <meth> ... IMPORTING|EXPORTING|CHANGING <p> TYPE <type> ...
April 2001
117
SAP AG
Die technischen Eigenschaften des Formalparameters <p> sind vollstndig durch die Eigenschaften des bekannten Typs <type> festgelegt. Es drfen nur Aktualparameter des gleichen Typs bergeben werden.
Typisierung von Feldsymbolen
FIELD-SYMBOLS <fs> TYPE <type>.

Die technischen Eigenschaften des Feldsymbols <FS> sind vollstndig durch die Eigenschaften des bekannten Typs <type> festgelegt. Es drfen nur Datenobjekte des gleichen Typs zugewiesen werden.
Sichtbarkeit von Datentypen

Beim Bezug auf bekannte Datentypen mit dem TYPE-Zusatz spielt die Sichtbarkeit der Datentypen eine Rolle.
Die eingebauten ABAP-Typen (C, D, F, I, N, P, T, X) sind immer sichtbar. Es knnen keine gleichnamigen programmlokalen Typen oder Typen im ABAP Dictionary angelegt werden. Bei der Sichtbarkeit von programmlokalen Datentypen ist zwischen lokalen Datentypen in Prozeduren und globalen Datentypen zu unterscheiden. In Prozeduren definierte Datentypen verschatten gleichnamige Datentypen, die im globalen Deklarationsteil definiert werden. Alle programmlokalen Datentypen verschatten wiederum gleichnamige Datentypen im ABAP Dictionary. Dies gilt auch fr Datentypen aus Typgruppen. Bei der Sichtbarkeit von Datentypen im ABAP Dictionary ist zur Zeit noch zwischen eigenstndigen Datentypen und Datentypen in Typgruppen zu unterscheiden. Datentypen in Typgruppen verschatten gleichnamige eigenstndige Datentypen. Dies sollte jedoch eine Ausnahmesituation sein. Alle Datentypen des Dictionarys sollten in einem Namensraum liegen. Beim Anlegen eines eigenstndigen Datentyps gibt das System eine Warnung aus, falls der Name mit dem Namen einer Typgruppe gefolgt von einem Unterstrich beginnt. Umgekehrt knnen keine Typgruppen angelegt werden, wenn es schon einen eigenstndigen Datentyp mit dem gleichen Namen gefolgt von einem Unterstrich gibt.
Die Abbildung veranschaulicht die Sichtbarkeit von programmlokalen und Dictionary-Datentypen:
118
April 2001
SAP AG
Sichtbarkeit von Datentypen
TYP1 TYP1 TYP2 TYP2 Prozedur ABAP-Rahmenprogramm ABAP Dictionary

Das System sucht von innen nach auen. Wenn im Programm TYP1 in einem TYPE-Zusatz angegeben ist, wird sowohl in der Prozedur als auch im Rahmenprogramm der Typ aus dem Dictionary verwendet. Wird TYP2 in der Prozedur angegeben, wir der lokale Typ der Prozedur verwendet. Wird TYP2 im Rahmenprogramm angegeben, wird der Typ des Rahmenprogramms verwendet. TYP2 aus dem Dictionary ist unsichtbar. Wird TYP3 angegeben, wird sowohl in der Prozedur als auch im Rahmenprogramm der Typ des Rahmenprogramms verwendet. TYP3 aus dem Dictionary ist unsichtbar.
TYP2 TYP2 TYP3 TYP3
TYP2 TYP2 TYP3 TYP3
Konstruktion neuer Datentypen

Mit dem Zusatz TYPE knnen in den ABAP-Anweisungen TYPES, DATA, CONSTANTS und STATICS neue Datentypen konstruiert werden. In der Anweisung TYPES sind dies eigenstndige programmlokale Datentypen. In den anderen Anweisungen sind es Attribute von neuen Datenobjekten. Fr die Konstruktion neuer Datentypen kann der TYPE-Zusatz mit folgenden Typ-Konstruktoren verwendet werden:

Konstruktion von Referenzen
REF TO <class>|<interface>
Konstruktion von Strukturen
BEGIN OF <struct>. ... END OF <struct>.
Konstruktion von Tabellen
<tabkind> OF <linetype> [WITH <key>]

Solche Datentypen sind nur whrend der Laufzeit eines ABAP Programms vorhanden.
April 2001
119
SAP AG
Bezug auf generische Typen bei der Typisierung

Fr die Typisierung von Schnittstellenparametern und Feldsymbolen ist ein Satz vordefinierter generischer Typen in die Syntax eingebaut worden, die nur in den Anweisungen FORM, METHODS und FIELD-SYMBOLS hinter TYPE verwendet werden knnen.
Generische Typen fr die Typisierung
ANY ANY TABLE INDEX TABLE TABLE STANDARD TABLE SORTED TABLE HASHED TABLE
Vollstndig generischer Typ. Generischer Typ fr alle Tabellen Generischer Typ fr Tabellen mit linearem Index. Generische Typen fr unsortierte Tabellen mit linearem Index. Generischer Typ fr sortierte Tabellen mit linearem Index. Generischer Typ fr Tabellen mit Hash-Verwaltung.
Diese Typen knnen nicht bei der Definition von programmlokalen Datentypen oder von Datenobjekten verwendet werden. Sie ermglichen ausschlielich die berprfung des Datentyps von Feldern, die an Prozeduren bergeben oder Feldsymbolen zugewiesen werden.
120
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Der LIKE-Zusatz
Der LIKE-Zusatz
Der LIKE-Zusatz wird hnlich wie der TYPE-Zusatz in verschiedenen ABAP-Anweisungen zur Definition von Datentypen und zur Typisierung von Schnittstellenparametern oder von Feldsymbolen verwendet. Mit dem Zusatz LIKE <obj> kann in den gleichen ABAP-Anweisungen wie beim TYPE-Zusatz [Seite 117] auf alle an dieser Stelle sichtbaren Datenobjekte <obj> verwiesen werden. Dabei ist der Ausdruck <obj> entweder der Name eines Datenobjekte oder der Ausdruck LINE OF <table-object> In diesem Fall bezieht sich der LIKE-Zusatz sinngem auf den Zeilentyp eines an dieser Stelle sichtbaren Tabellenobjekts <table-object>. LIKE zieht sozusagen die technischen Eigenschaften (Attribute) eines Datenobjekts ab und verwendet sie zur Typisierung anderer Objekte bzw. Typen.
ABAP-Anweisungen mit LIKE-Bezug
Definition von programmlokalen Typen mit TYPES <t> LIKE <obj>. Der neue Datentyp <t> bernimmt vollstndig die technischen Eigenschaften des Datenobjekts <obj>.
Deklaration von Datenobjekten mit DATA <f> LIKE <obj>. CLASS-DATA <f> LIKE <obj>. CONSTANTS <f> LIKE <obj>. STATICS <f> LIKE <obj>. PARAMETERS <f> LIKE <obj>. Das Datenobjekt <f> bernimmt alle technischen Eigenschaften des Datenobjekts <obj>.
Dynamische Erzeugung von Datenobjekten mit CREATE DATA <dref> LIKE <obj>. Typisierung von Formalparametern in Unterprogrammen mit FORM <sub> ... USING|CHANGING <p> LIKE <obj> ... Die technischen Eigenschaften des Formalparameters <p> sind vollstndig durch die Eigenschaften des bekannten Datenobjekts <obj> festgelegt. Es drfen nur Aktualparameter mit diesen Eigenschaften bergeben werden.
Typisierung von Formalparametern in Methoden mit METHODS <meth> ... IMPORTING|EXPORTING|CHANGING <p> LIKE <obj> ... Die technischen Eigenschaften des Formalparameters <p> sind vollstndig durch die Eigenschaften des bekannten Typs <type> festgelegt. Es drfen nur Aktualparameter des gleichen Typs bergeben werden.
April 2001
121
ABAP Programmierung (BC-ABA) Der LIKE-Zusatz
SAP AG
Typisierung von Feldsymbolen FIELD-SYMBOLS <fs> LIKE <obj>. Die technischen Eigenschaften des Feldsymbols <FS> sind vollstndig durch die Eigenschaften des bekannten Datenobjekts <obj> festgelegt. Es drfen nur Datenobjekte dieser Eigenschaften zugewiesen werden.
Sichtbarkeit von Datenobjekten

Als Faustregel kann gelten, da man sich mit LIKE auf alle mit DATA (oder hnlichen Anweisungen) deklarierten Datenobjekte beziehen kann, die im aktuellen Kontext sichtbar sind. Dabei mu nur die Deklaration des Datenobjekts bekannt sein. Es ist vllig unerheblich, ob das Datenobjekt whrend dem LIKE-Bezug schon physisch im Speicher existiert oder nicht.
Prinzipiell sind die programmlokale Datenobjekte des gleichen Programms sichtbar. Dabei ist wie bei programmlokalen Datentypen zwischen lokalen Datenobjekten in Prozeduren und globalen Datenobjekten zu unterscheiden. In Prozeduren definierte Datenobjekte verschatten gleichnamige Datenobjekte, die im globalen Deklarationsteil definiert werden. Weiterhin kann man sich auch auf die Datenobjekte anderer sichtbarer ABAPProgramme beziehen. Dies sind z.B. die sichtbaren Attribute von globalen Klassen in Class-Pools. Wenn eine globale Klasse <cl_global> beispielsweise ein ffentliches Instanzattribut oder statisches Attribut <attr> enthlt, kann man sich in einem beliebigen ABAP-Programm wie folgt darauf beziehen:
DATA <ref> TYPE REF TO <cl_global>. DATA: f1 LIKE <cl_global>=><attr>, f2 LIKE <ref>-><attr>.
Es kann also ber den Klassennamen auf die Eigenschaften von Instanzattributen zugegriffen werden und eine Referenzvariable kann fr den gleichen Zweck verwendet werden, ohne da zuvor ein Objekt zu erzeugt wird. Die Eigenschaften der Attribute einer Klasse gehren sind also instanzunabhngig und gehren zu den statischen Eigenschaften einer Klasse.
Aus Kompatibilittsgrnden mit vorhergehenden Releases, kann man sich mit dem LIKEZusatz auch auf die Datentypen von Datenbanktabellen und von flachen Strukturen im ABAP Dictionary beziehen. Der LIKE-Zusatz sucht erst programmlokal nach einem Datenobjekt <obj> und dann im ABAP Dictionary nach einer gleichnamigen Datenbanktabelle oder flachen Struktur. Dieser Typbezug auf das ABAP Dictionary ist in den Klassen von ABAP Objects nicht mehr mglich. Der LIKE-Zusatz sollte auch in anderen ABAP-Programmen nur noch fr den Bezug auf Datenobjekte eingesetzt werden. Fr den Bezug auf Datentypen sollte statt LIKE der TYPE-Zusatz verwendet werden.
122
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Datenobjekte
Datenobjekte
Datenobjekte enthalten die Daten, mit denen ABAP-Programme zur Laufzeit arbeiten knnen. Datenobjekte sind nicht persistent, sondern leben maximal solange wie die Laufzeit eines Programms. Persistent abgespeicherte Daten, wie z.B. Daten aus Datenbanktabellen oder aus sequentiellen Dateien mssen vor ihrer Verarbeitung immer erst in Datenobjekte gelesen werden. Umgekehrt mu der Inhalt von Datenobjekten persistent abgespeichert werden, wenn er ber die Laufzeit eines Programms bestehen bleiben soll. Wir unterscheiden folgende Arten von Datenobjekten:
Literale
Literale [Seite 124] werden nicht durch deklarative Anweisungen erzeugt, sondern sind schon im Programmtext vorhanden. Sie haben wie alle Datenobjekte feste technische Eigenschaften (Feldlnge, Anzahl der Nachkommastellen, Datentyp) aber keinen Namen. Sie heien deshalb auch unbenannte Datenobjekte.
Benannte Datenobjekte
Diese Datenobjekte werden statisch oder dynamisch zur Laufzeit eines Programms deklariert. Ihre technischen Eigenschaften Feldlnge, Anzahl der Nachkommastellen und der Datentyp sind zu jedem Zeitpunkt ihrer Lebensdauer festgelegt. -Solche Datenobjekte haben einen Namen, ber den sie das ABAP-Programm ansprechen kann. Sie heien deshalb auch benannte Datenobjekte. Es gibt folgende benannten Datenobjekte: Textsymbole [Seite 126] sind Zeiger auf Texte im Textpool des ABAP-Programms. Beim Programmstart werden zugehrige Datenobjekte in Abhngigkeit von den im Textpool abgelegten Texten generiert und ber den Namen des Textsymbols angesprochen. Variablen [Seite 128] sind Datenobjekte, deren Inhalt von Variablen durch ABAP-Anweisungen nderbar ist. Variablen werden mit den Anweisungen DATA, CLASS-DATA, STATICS, PARAMETERS, SELECT-OPTIONS und RANGES deklariert. Konstanten [Seite 134] sind Datenobjekte, deren Inhalt nicht nderbar ist. Konstanten werden mit der Anweisung CONSTANTS deklariert. Schnittstellen-Arbeitsbereiche [Seite 135] sind spezielle Variablen, die als programmbergreifende Schnittstelle zwischen Programmen und Dynpros und zwischen Programmen und logischen Datenbanken dienen knnen. Schnittstellen-Arbeitsbereiche werden mit den Anweisungen TABLES und NODES deklariert.
Vordefinierte Datenobjekte
Vordefinierte Datenobjekte [Seite 137] mssen nicht explizit deklariert werden, sondern sind zur Programmlaufzeit immer automatisch vorhanden.
Dynamische Datenobjekte
Dynamische Datenobjekte [Seite 234]werden nicht statisch im Deklarationsteil deklariert, sondern ber Datenreferenzen dynamisch erzeugt. Sie haben keinen Namen.
April 2001
123
ABAP Programmierung (BC-ABA) Literale
SAP AG
Literale
Literale sind unbenannte Datenobjekte, die im Quelltext eines Programms angelegt werden und durch ihren Wert vollstndig bestimmt sind. Der Wert von Literalen ist unvernderbar. Wir unterscheiden Zahlenliterale und Textliterale.
Zahlenliterale
Ein Zahlenliteral ist eine Folge von Ziffern im Programmtext, die ein Vorzeichen enthalten kann. Zahlenliterale knnen alle Zahlen darstellen, deren Wert im Wertebereich des eingebauten ABAP-Typs P mit einer Feldlnge von 16 liegt, also Zahlen mit maximal 31 Ziffern zuzglich 31 31 Vorzeichen. Zahlenliterale, deren Wert zwischen -2 +1 und 2 -1 liegt, haben den eingebauten ABAP-Typ I. Alle brigen Zahlenliterale haben den Typ P ohne Nachkommastellen. Zahlenliterale mit maximal 15 Stellen zuzglich Vorzeichen haben dabei eine Feldlnge von 8 Bytes, die brigen eine Feldlnge von 16 Bytes.
Beispiele fr Zahlenliterale:
123 -93 +456

Zahlenliterale in Anweisungen:
DATA number TYPE i VALUE -1234. WRITE 6789. MOVE 100 TO number.
Um einen nichtganzzahligen Wert oder eine lngere Zahl zu reprsentieren, mu ein Textliteral (Datentyp C) verwendet werden. Ebenso mu ein Textliteral des Formats
'[<mantissa>][E][<exponent>]'
fr Gleitpunktzahlen verwendet werden. Bei Verwendung solcher Textliterale in ABAPAnweisung findet eine Typkonvertierung [Seite 192] in den entsprechenden numerischen Datentyp statt.
Beispiele fr Textliterale, die in numerische Typen konvertiert werden knnen:
'12345678901234567890' '+0.58498' '-8473.67' '-12.34567' '-765E-04' '1234E5' '+12E+23' '+12.3E-4' '1E160'
124
April 2001
SAP AG
ABAP Programmierung (BC-ABA) Literale
Textliterale
Ein Textliteral ist eine Folge von alphanumerischen Zeichen im Programmtext, die in Hochkommata eingeschlossen sind. Textliterale haben immer den eingebauten ABAP-Typ C. Die Feldlnge wird durch die Anzahl der Zeichen festgelegt.
Beispiele fr Textliterale
'Anton Schmitt' '69190 Walldorf'

Textliterale knnen bis zu 255 Zeichen lang sein. Ein Textliteral ist immer mindestens ein Zeichen lang (Die Angabe von '' ist gleichbedeutend zu ' '). Um Textliterale im ABAP Editor einzugeben, die lnger als eine Editorzeile sind, erlaubt es die ABAP-Syntax [Seite 86], mehrere Textliterale mit dem Zeichen & zu einem Textliteral zu verknpfen. Enthlt ein Textliteral ein Hochkomma, mu dieses Hochkomma doppelt eingegeben werden, um dem System mitzuteilen, da es zum Textliteral gehrt und nicht das Ende des Literals darstellt.
WRITE: / 'Das ist John''s Fahrrad'.

Diese Anweisung erzeugt folgende Ausgabe:
Das ist John's Fahrrad
April 2001
125
ABAP Programmierung (BC-ABA) Textsymbole
SAP AG
Textsymbole
Textsymbole sind benannte Datenobjekte, die beim Programmstart aus Texten im Textpool des ABAP-Programms generiert werden. Der Datentyp ist immer der eingebaute ABAP-Typ C und die Feldlnge richtet sich nach der Lnge des Texts im Textpool. Textsymbole sind neben Programmtitel, Listenberschriften und Selektionstexten Teil der Textelemente eines ABAP-Programms. Textelemente ermglichen das Anlegen und Pflegen von mehrsprachigen Programmen. Alle Texte, die das Programm z.B. an Bildschirmbilder sendet knnen als Textelemente in Textpools abgelegt werden. Fr verschiedene Sprachen knnen jeweils eigene Textpools angelegt werden. Um Texte zu ndern oder zu bersetzen, mu dann nicht der Programmtext gendert werden, sondern die entsprechenden Textelemente. Die Textelemente eines ABAP-Programms werden im ABAP Editor der ABAP Workbench verwaltet (siehe Textelementpflege [Extern]). Textsymbole haben im Textpool eine dreistellige Kennung, einen Text als Inhalt, eine belegte Lnge und eine maximale Lnge.
Beispiel fr Textsymbole eines ABAP-Programms

Kennung Inhalt Belegte Lnge Maximale Lnge
010 030 AAA TEXT-<idt>
Text Symbol 010 Text Symbol 030 Text Symbol AAA
15 15 15
132 100 15
Im Programm werden Textsymbole mit folgenden Namen angesprochen: Dieses Datenobjekt enthlt den Text des Textsymbols der Kennung <idt> fr die jeweilige Anmeldesprache und hat eine Feldlnge, die der maximalen Lnge des Textsymbols entspricht. Die unbelegten Stellen sind mit Leerzeichen aufgefllt. Textsymbole knnen an allen Stellen angesprochen werden, an der auch eine Varia

Sprache

BCABA

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

BCABA

Hochgeladen von

Copyright:

Verfügbare Formate

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

sind eingetragene Marken der

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA) ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA) ABAP Programmierung (BC-ABA)

ABAP Programmierung (BC-ABA) ABAP Einfhrung

ABAP Programmierung (BC-ABA) bersicht ber das R/3-Basis-System

bersicht ber das R/3-Basis-System

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

Das Basis-System im Gesamtsystem

ABAP ABAP Workbench Workbench

R/3 Basis System

Kernel & Basisdienste

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

... SAP GUI ...

Datenbank Management System

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

Softwaretechnische Sicht und Hardwaresicht

Vorteile der mehrstufigen Architektur

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

Konsequenzen fr die Anwendungsprogrammierung

SAP GUI nicht aktiv

Interaktion des Benutzers

ABAP Programmierung (BC-ABA) Das Basis-System im Gesamtsystem

Applikationsschicht Datenbankschicht R/3 System 1

Applikationsschicht Datenbankschicht R/3 System 2

ABAP Programmierung (BC-ABA) Applikationsserver

Aufbau eines Applikationsservers

Shared Shared Memory Memory

Datenbank Management System

ABAP Programmierung (BC-ABA) Applikationsserver

ABAP Programmierung (BC-ABA) Applikationsserver

Dispatching von Dialogschritten

SAP GUI SAP GUI Applikationsserver

SAP GUI SAP GUI

Shared Shared Memory Memory

ABAP Programmierung (BC-ABA) Applikationsserver

Dispatching und Programmiermodell

ABAP Programmierung (BC-ABA) Applikationsserver

ABAP Programmierung (BC-ABA) Workprozesse

Aufbau eines Workprozesses

Datenbank Management System

ABAP Programmierung (BC-ABA) Workprozesse

Modul 3 Modul 3 Modul 2 Modul 2 Modul 1 Modul 1

Die Datenbankschnittstelle stellt folgende Dienste zur Verfgung:

Die folgende Abbildung zeigt die einzelnen Komponenten der Datenbankschnittstelle:

ABAP Programmierung (BC-ABA) Workprozesse