Bevezete s az SAP vila ga ba: Mie rt ABAP?

12 Pages·2012·1.04 MB·Hungarian

Bevezete s az SAP vila ga ba:

Mie rt ABAP?

Készítette: Horváth Zsófia (HOZSAAI.ELTE)
2011 – 2012 – 2. félév
1952-ben készült el Neumann János tervei alapján az EDVAC nevet viselő számítógép, amely
az első Neumann-elvek alapján épített gép volt. Innen kezdődik a programozási nyelvek története.
Az évek során igen sok programozási nyelv alakult ki, amelyeket szemléletük és fontosabb
jellemzőik alapján négy generációba soroltak.
 1. generációs nyelvek: Gépi kód, Assembler
 2. generációs nyelvek: FORTRAN, ALGOL, COBOL, BASIC
 3. generációs nyelvek: PL/1, APL, PASCAL, MODULA 2, ADA, C-nyelv
o objektumorientált nyelvek: SmallTalk, Eiffel, Turbo Pascal, Borland C++
o Specializált programozási nyelvek
i. Rendszer- és fordítóprogramok fejlesztése: B, C, BCPL, Pascal
ii. Formulakezelő nyelvek: FORMAC, REDUCE, MACSYMA
iii. Szimbólum-feldolgozó nyelvek: PROLOG, CONVERT, LISP, SNOBOL, COGENT
iv. Szimulációs nyelvek: SIMSCRIPT, SIMULA, GPSS
v. Adatbázis-kezelő nyelvek
vi. Kiterjeszthető programnyelvek: LOGO, FORTH
 4. generációs nyelvek: XX. század második fele

Az SAP szoftvercégnek a saját programozási nyelve az ABAP (angolul Advanced Business
Application Programming, németül Allgemeiner Berichts-Aufbereitungs-Prozessor), melyet a 70-es évektől
kezdve a cég folyamatosan bővít.
Az első verziói (SAP R/1, SAP R/2 rendszerek) még assembly nyelven íródtak, majd megjelentek
a COBOL-ban használatos parancsokhoz hasonló utasítások az ABAP/3. Végül 1983-ban megjelent az
ABAP/4, amely már strukturált, procedurális programnyelvnek számít (egyfázisú programokkal). Nem
sokkal később létrejött az ABAB Objects, amely már tényleges objektumorientált programozásra ad
lehetőséget.
Az ABAP-ra hatással volt az Objective-C, COBOL, SQL.
Vajon az SAP miért nem a C++, a JAVA vagy az ADA nyelvvel kezdett el fejleszteni? Minden
programnyelvnek megvan a maga sajátossága, ami csak az övé, csak ő tudja kihasználni az előnyeit…
Miért kellett az SAP-nak megalkotnia egy „teljesen új” programozási nyelvet?
Ha összehasonlítjuk pár nyelvekkel, rögtön kiderül, hogy nem csak a felsorolt három nyelv volt
rá hatással, hanem azok is, amelyeknek az Assembler a „közös őse”.
Hogy válaszolt tudjunk adni a kérdésre, hasonlítsuk össze az SAP nyelvét a fent említett
nyelvekkel a következő szempontok szerint.
A nyelv megszületése:
Az ABAP első verziója körülbelül akkortájt jelent meg, mint az ADA vagy a C++, azaz a80-as
években. Az objektumorientált verziója ABAP Objects pedig a JAVA-val egyidőben született meg a 90-
es évek végén.
Szintaxis:
Ami számomra meglepő volt, ABAP-ban egy utasítássorozat végét egy ponttal (.) fejezzük ki,
mely más nyelvekben ugyebár a pontosvessző. Ez olyan hatást keltett bennem, mintha egy mondatot
olvasnék egy könyvből. Érthetően lezár egy szakaszt.
Szekvenciák, avagy mit szabad:
Mind az ADA, mind a C++ s még az ABAP-ban is van lehetőség arra, hogy egymás után soroljuk
fel az azonos típusú változókat, nem kell külön-külön.
ABAP szekvencia C++ szekvencia ADA (Pascal, Delphi)
<Kulcsszó><Adatobjektum1>. <típus1> <változoónév1>; <típus1> <változoónév1>;
<Kulcsszó><Adatobjektum2>. <típus1> <változoónév2>; <típus1> <változoónév2>;
… … …
<Kulcsszó><AdatobjektumN>. <típus1> <változoónév3>; <típus1> <változoónév3>;
ekvivalens ezzel:
<Kulcsszó><Adatobjektum1>, <típus1> <változoónév1>, <típus1> <változoónév1>,
<Adatobjektum2>,<AdatobjektumN>. <változoónév2>, <változoónév3>; <változoónév2>, <változoónév3>;
Ha ADÁban a felsorolt verzióban értéket is megadunk, akkor az az összes adattagra fog
vonatkozni, míg C++ban erre nincs lehetőség, ott csak a legutolsó elem kapja meg a megadott
értéket.
Ciklusok:
Két féle ciklust különböztetünk meg, a számlálós és a feltételes ciklust.
ABAP ciklusok C++ ciklusok ADA (Pascal, Delphi) ciklusok JAVA
DO [<n> TIMES]. for (int i = 0, i<10, i++) for I in 1..10 loop mint a C++ban:
<végrehajtási blokk> { <végrehajtási <végrehajtási blokk>; for (előkészítő szakasz,
feltételes sz.; növekményes
ENDDO. blokk>;} end loop;
szakasz) {ciklusmag}
WHILE <feltétel>. while (feltetel) while <feltétel> loop mint a C++ban és:
<végrehajtási blokk> {<vegrehajtási blokk>; <végrehajtási blokk>; do {ciklusmag} while
(logikai kifejezés)
ENDWHILE. } end loop;
Elágazások:
Ebből is kétféle verziót különböztetünk meg az if és case elágazást. Számomra az ABAP és ADA
között egyszerre van hasonlóság és különbség is ebben. A hasonlóság valószínűleg a Fortran – Algol –
Pascal egymás utániságából jön, a különbség pedig a case felépítésén. Meglep, hogy csak a Rubyban
láttam eddig untill-es elágyazást, amely a normál if ellentéte lenne.
ABAP elágazások: ADA elágazások
if <feltetel1>. case <mezőnév> if (felt) then case i is
<do sth> when <érték1>. <do sth>; when <a> => <sth>;
elseif <feltetel2>. <blokk> elsif when <b> => <sth>;
<do sth> when <érték2>. <do sth>; ….
else. <blokk> else when others =>
<do sth> when others. <do sth>; <sth>;
endif. <blokk> end if; end case;
endcase.
Ruby scriptnyelv C++ if elágazása: C++ case elágazása
unless 1 < 2 if(feltétel) switch(c) {
er = 1 utasítás; case 'i':
else else case 'I': <utasítás>; break; //break; nélkül
utasítás; "átesne" a következő case-be is
er = 2
default: cout << "I/i vagy N/n!\n"; break;
//ez
end
}
nem kötelező, ha semelyik sem igaz, ide ugrik
Igazából, minden programnyelvben előfordulnak ezek az elágazások, kisebb-nagyobb különbségekkel.
Kulcsszavak, kommentek
Minden egyes nyelvben megvannak a lefoglalt szavak, melyeket nem tudunk (nem kéne)
felüldefiniálnunk. Összeszedtem egy párat, melyek között átfedések is vannak:
ABAP kulcs szavai: C++ ADA JAVA
EXIT, CONTINUE, CHECK break, try – catch, default, abort, abstract, acces, break,
<feltétel>, GOTO (nincs delete, enum, goto, accept, new, reverse, continue,
ABAP/4-ben) inline,void, xor, namespace, subtype, protected, public,
DATA , DEMAND, operator, protected, register, interface, untill, limited, protected,
DATABASE, DELETE, DEFINE, signed, sizeof, static, switch – digits, declare, delay, @ , stb…
ENDLOOP, EXPORT, stb…
case, throw, stb… body, terminate, stb…

ABAP kommentek jele: C++ kommentek jele: ADA (Pascal, Delphi)
* a sor elején // vagy /* … */ --

Eljárások – alprogramok:
Ég és föld a különbség ABAP, ADA, C++ eljárásai / alprogramjai között. Nem meglepő, hiszen
ezt az SAP az adatbázis kezelés résznél használja. Viszont akkor egy SQR-SQL és ABAP közötti
hasonlóság megfigyelhető. A mellékelt képen látszik is, ez a hasonló felépítés és elnevezés is.
Milyen meglepő, hogy mindhárom megemlített nyelvben külön kezeljük ezeket az eljárásokat.
ABAP Alprogram1: ABAP Alprogram2:külső form ADA Eljárás: C++
FORM <fnév> PERFORM <form neve> [<melyik procedure
v
o
[TABLES <formális param> …] programból>] <valami> is id
[USING < form. param > …] [TABLES <aktuális param> …] --deklarálások fü
g
[USING VALUES < form. param [USING < akt. param > …] begin g
v
> …] [CHANGING < akt param > …] … én
[CHANGING < form param > …] [IT FOUND]. <feladat> ye
k
[CHANGING VALUE < form.
…
param > …].
másik verzió: PERFORM (<form neve>) end;
<végrehajtási blokk>
[IN PROGRAM (<melyik programból>)]
ENDFORM. [...] [IF FOUND].

Függvények
a „kivételkezelés” is
ADA függvények C++ függvények
function <fv név> void <fvnév> () { int <fvnév> () { bool <fvnév> () {
return <típus> is // <do sth>; // < do sth> //<do sth>
--deklarációk; } } }
begin
<to do>
end <fv név>;
Kivételkezelés:
Kivételkezelés a C++ban: try – catch Kivételkezelés az
class exception { ADAban: raise
public: Constraint_Error,
exception () throw(); Program_Error,
exception (const exception&) throw(); Storage_Error,
exception& operator= (const exception&) throw(); Tasking_Error
virtual ~exception() throw(); és „include-olni kell a
virtual const char* what() const throw();
következőt:”
}
Ada.Exceptions (with & use)
Nem meglepő, hogy az ABAP raise <kivétel> nagyon hasonlít az ADA verziójára, bizonyára a Pascal
hatása miatt.
Adattípusok:
Adatok tulajdonságai, mely tényleg minden nyelvben azonosan megvannak és működnek:
o Láthatóság: globális, lokális
o Élettartam: statikus, temporális
Azonban az ABAP-ban vannak különleges típusok, nemcsak a megszokott Integer és Bool értékek.
ABAP-ban a szöveg típusa a karakter, míg más nyelvekben ez tényleg string-nek van elnevezve, de
általában van lehetőség karakterláncként is reprezentálni a stringeket.
Szerencsére, ma már szinte bármilyen típust képesek vagyunk létrehozni (az objektumelvűség miatt)
és túl tudunk lépni a nyelvek, keretrendszerek által ránk szabott határokat.

Objektumorientáltság
ABAP és Objective-C
Az objektumorientált programozást úgy lehet felvázolni, mint egy utat a gyors és hatékony
programozáshoz. Alapeleme az osztály. Az osztályok létrehozásakor új adattípust hozunk létre,
melyeket ugyanúgy használhatunk, mint más beépített adattípusokat. Emellett az osztálydefinícióban
megadunk váltózókat, és a feladathoz kapcsolódó függvénykódot is. Az osztály nem más, mint
tagváltozók és a tagfüggvények gyűjteménye.
Az Objective-C nyelvre hatással volt maga a C és a Smalltalk. Befolyásolt nyelvei a Tom, Java,
Objective-J, ABAP és egyéb C alapú nyelvek.
Mikor megnéztem egy Objective C kódot, rögtön a Java és a C++ jutott először eszembe, hiába
ered a szintaxisa a Smalltalkból. Számomra a C++ az a nyelv, amellyel régebb óta foglalkozok, mint
bármely más, így mikor megláttam egy Objective C-ben megalkotott osztályt, elmosolyodtam, hiszen
a két nyelv igencsak hasonlít egymásra ( a @ jelek, pedig az ember eszébe juttatják a Java-s jelölést).
De akkor hogy kerül ide az ABAP?
Úgy, hogyha megnézzük az Objective C és az ABAP-ban létrehozott osztályokat, megláthatjuk a
hasonlóságokat. Mindkettő a saját szintaxisa és kulcsszavai szerint ugyanúgy implementálja a kívánt
típust. A következő oldalon lévő két képen ez nagyon jól látszik.
Hasonlóságok:
Objective C-ben az osztály adattagjainak láthatóságának szabályozására a @public, @private,
@protected és a @package direktívák adnak lehetőséget. ABAP-ban az első három használható.
Az interfészekről: Objective C-ben az interfész deklarálja az osztály adattagjait, metódusait, és
megnevezi az ősosztályát, az implementációban pedig definiáljuk a metódusokat, ezzel
tulajdonképpen az osztályt. ABAP-ban ha egy osztály implementál egy, vagy több interfészt, akkor
azok minden metódustörzsét meg kell adni. Interfészek között is lehetséges öröklődés. (Ez Java-s).
1. ABAP kód

1. Objective-C kód
ABAP és COBOL
Általánosan a COBOL-ról: Harmadik generációs programozási nyelv. Bár általános célú, mégis
FORTRAN és a PL/I mellett elsősorban az üzleti, pénzügyi élet rendszereiben használatos.
Megjelentek benne a strukturált programozás bizonyos vezérlő szerkezetei is. A nyelv tervezésénél
kísérletet tettek a hordozhatóság, a portabilitás megteremtésére. 1959-ben deklarálták, első
változata a COBOL 60 volt.
Egy COBOL program 4 jól elkülöníthető részre, COBOL szóhasználattal Divisionre (Főrészre) oszlik:
 1. Azonosítási főrész, (IDENTIFICATION DIVISION.)
 2. Környezet leíró főrész, (ENVIRONMENT DIVISION.)
 3. Adatleíró főrész, (DATA DIVISION.)
 4. Eljárási főrész (PROCEDURE DIVISION.)
Talán, ami hasonlít a bonyolultnak látszó, de mégis áttekinthető felépítés:
A Cobolban a változóknak nincs típusa, van A Cobolban az adatok definíciójánál kell
viszont egy maszkja (PIC), hogy milyen értékek megmondanunk az adat nyomtatási képét. Ezt
tárolhatók benne. (ABAP-ban van a DATA szintén a PICTURE segítségével tehetjük meg.
kulcsszó a változók deklarálásánál.) Szerkesztett adatmező csak output adatként
A fontosabb elemek: szerepelhet. (Nincs ABAP-ban) Szerkesztőjelek:
 A: az angol ABC betűi vagy a szóköz.  Z: Vezető nullák elnyomása.
 B: szóköz.  B: Szóköz.
 V: tizedespont helye az adaton belül (a  0: Nulla.
tizedespont nem tárolódik).  ,: Vessző.
 S: az adat előjeles  + vagy -: Plusz jel, ha az adat pozitív,
 P: tizedespont helye az adaton kívül, és "P" mínuszjel, ha negatív.
helyén 0-k állnak. Ezek a 0-k nem tárolódnak.  A vezető nullák helyén "*"-ot kérünk
 X: alfanumerikus karakter. nyomtatni (a hamisítások elkerülése végett).
 9 számjegy  .: A ténylegesen nyomtatott tizedespont
A maszkban az ismétlődő karaktereket rövidíteni helye.
lehet: XXXX helyett X(4) írható stb.  +,$ Egyéb jelek.
Meglepődve tapasztaltam, hogy mennyire eltérőek az elágazások a két nyelvben:
COBOL if és case ABAP if és case COBOL (teljesen más, mint az ABAP-é)
IF feltétel if <feltetel1>.
THEN utasítások1 <do sth>
ELSE utasítások2 elseif <feltetel2>.
END-IF. <do sth>
else.
<do sth>
endif.
case <mezőnév>
EVALUATE X when <érték1>.
WHEN 1 THRU 12 <blokk>
utasítások1 when <érték2>.
WHEN 13 utasítások2 <blokk>
WHEN OTHER utasítások3 when others.

END-EVALUATE. <blokk>
endcase.
COBOLban az egyetlen vezérlésátadó utasítás a GO TO, amit ugye az ABAP nem támogat.
A Cobolban nincs hagyományos értelemben vett eljárás, viszont két címke közti kódrészletet
meg lehet hívni úgy, mintha eljárás lenne. ABAPban viszont már kétféle – igazi – eljárás (alprogram) is
létezik.
A Cobolban lehetőség van beágyazott programok írására. Ekkor az eljárási főrész STOP RUN
utasítása és END PROGRAM programnév közé egy teljes programot (mind a négy főrésszel)
beírhatunk. Erre a vezérlést a CALL programnév utasítással adhatjuk át. Engem ABAPban ez a
függvényhívásra emlékeztet.
A Cobol mondatokból szakaszokat készíthetünk, melyek általában a feldolgozás egy-egy
elkülöníthető részének programkódját tartalmazzák. Minden szakasz szakasznévvel kezdődik, ezt
pont követi. (ABAP szintaktika is ilyen, nem véletlenül.) Szegmentált program esetében a résznévvel
együtt még a prioritásszám is szerepel. A szakaszokból pedig fejezeteket készíthetünk. A szakaszokat
és fejezeteket, mint eljárásokat használhatjuk. ABAP kód hasonlóképpen felépíthető.
Az ABAP-pal ellentétben a Cobol nem támogatja az absztrakt adattípusokat, a sablonokat sem
eljárás, sem típus szinten.
Míg az ABAP-ban szerepel, addig valódi kivételkezelés nincs a Cobol-ban, azonban egyes
utasítások esetén lehetőség van hibakezelésre.
Az eredeti Cobol nem tartalmaz objektum-orientált eszközöket. Ez nem meglepő, hiszen a
nyelv sokkal korábbi, mint maga az objektumelvűség. Ugyanakkor a modernizálás szelleme a Cobolt
sem kerülte el, így megalkotásra került az OO Cobol, azaz a COBOL 2002. Azt hiszem, itt már
kimondhatjuk, hogy a COBOL 2002 hasonlít az ABAP Objectsre, hiszen az már 1999-ben létrejött.
Párhuzamosság
Az ABAP nem támogatja a párhuzamosságot, hiszen igen nagy kárt tudna tenni az adatkezelő
rendszerben. Azonban, hogy ezt a problémát megoldják, és mégis lehessen esély a párhuzamosságra,
létrehozták a számköröket. Egy számkörnek meg lehet adni egy intervallumot, típust és amikor
szükség van rá, egy függvény segítségével - NUMBER_GET_NEXT - generálhatunk értéket belőle. Ez
garantálja, hogy egy értéket egyszer oszt ki a rendszer.
Az első párhuzamosságot taglaló mondataim között volt olyan, hogy meg lehet oldani, (de
adatvesztéssel is járhat, ) csupán egy SELECT lekérdezéssel tudjuk elérni. Ezt a select kulcsszót
ADÁban a taszkoknál használjuk, mely akár többszálúság, párhuzamos programozásra is ad
lehetőséget, hiszen „időre írunk kódot”.
A COBOL nem támogatja párhuzamos programok készítését. Objective-C viszont sajátosan
kezeli a párhuzamosságot, illetve inkább a többszálúságot abban az értelemben, hogy a különböző
taszkokban vagy szálakban futó objektumok tudnak egymással kommunikálni és egymás metódusait
meg tudják hívni.
Java-ban az első - s talán kevésbé használt verziója – az, amely a Java.lang.Thread osztályt
használja, s ebből örökít új objektumokat. Az ebből örökített objektumok külön szálként fognak
viselkedni. A szálakat a Start() metódus indítja el az osztály Run() metódusát használva. Így nekünk az