Java adatbázis-kezelő tanfolyam - szakmai blog - Oldal 3 a 4-ből

Doktoranduszok programoznak

2023. december 22.2018. november 16. Szerző: Kaczur Sándor

Saját doktorandusz csoporttársaimmal többször beszélgettünk már arról, hogyan tudnák/tudják használni a programozás eszköztárát, módszereit, lehetőségeit saját kutatási munkájukban, beépítve a kutatási folyamat egyes lépéseibe, illetve disszertációjuk elkészítésébe.

Mivel a 10 fős csoportban mindenkinek más az alapvégzettsége, így szoftverfejlesztéshez, programozáshoz közös szókincs és terminológia haladó szinten természetesen nincs, viszont közös bennünk, hogy mindannyian alkotunk különféle modelleket és elemzünk adatokat.

Különféle modelleket alkotunk

a mérnökök, fizikusok, geográfusok, biológusok többféle kísérletet végeznek el, szimulációkat terveznek és futtatnak, mérőeszközöket és műszereket használnak,
az informatikusok különböző matematikai eszközöket alkalmazva objektumorientált – vagy másféle – modellezést végeznek, szoftvereket terveznek, javítanak, újraírnak.

Adatokat is elemzünk, ki-ki előképzettségének megfelelően

kérdőívező szoftverekből exportálva valamit,
Excel munkalapokon, függvényekkel, adatbázis-kezelő funkciókkal, kimutatásokkal (Pivot táblák),
különböző fájlformátumokkal (CSV, XML, JSON, egyedi) dolgozunk és konvertálunk A-ból B-be,
távoli adatbázisokhoz, felhőbeli adattárházakhoz csatlakozunk, lekérdezünk és kapunk valamilyen – többnyire szabványos – adathalmazt,
matematikai, statisztikai szoftvereket használunk, például: MATLAB, Derive, Maple, SPSS.

Önszerveződően összeállítottunk egy olyan két részből álló tematikát, ami mindannyiunk számára hasznos. A 64 óra két 32 órás modulból áll: Java programozás és SPSS programrendszer.

Java programozás modul

1-8. óra: Objektumorientált modellezés, MVC rétegek, algoritmus- és eseményvezérelt programozás
9-16. óra: Fájlkezelés és szövegfeldolgozás (XLS, CSV, XML, JSON formátumú adatok írása, olvasása, feldolgozása)
17-24. óra: Adatbázis-kezelés JDBC alapon (SQL parancsok, CRUD műveletek, hierarchikus lekérdezések)
25-32. óra: Komplex adatfeldolgozási feladatok megoldása programozási tételek használatával

SPSS programrendszer modul

1-8. óra: Bevezetés az SPSS-be, interakciós eszközök, adatmátrix, menük: Transform, Analyze, szkriptek futtatása
9-16. óra: Alapstatisztikák kérése, kereszttáblázatok készítése, hipotéziselmélethez kötődő funkciók, normalitásvizsgálat, minták összehasonlítása t-próbával
17-24. óra: Regresszió-analízis: lineáris, nemlineáris, többváltozós; Idősorok elemzése: szűrés, periodogram, trendelemzés
25-32. óra: Mesterséges neuronhálózatok: matematikai modell és működése

Mivel mindenki doktorandusz a csoportban, így a különböző MSc-s alapvégzettsége ellenére mindannyiunknak vannak strukturális programozáshoz kötődő alapismeretei, valamint adatok elemzéséhez szükséges elméleti matematikai/statisztikai alapjai. Az én részem a 32 órás Java programozás modul, ami 2018.10.28-án kezdődött és 2018.12.09-ig fog tartani hétvégi napokon. Ez nagyban lefedi a Java SE szoftverfejlesztő tanfolyamunk tematikáját és kapcsolódik a Java EE szoftverfejlesztő tanfolyamunk és a Java adatbázis-kezelő tanfolyamunk tematikájához is.

A koncepciót once-in-a-lifetime jelleggel dolgoztuk ki azzal a fő szándékkal, hogy hatékonyabban működjünk együtt a jövőben.

Stream API lambda kifejezésekkel

2022. február 22.2018. augusztus 26. Szerző: Balogh Péter

Korábban blogoltunk már a Stream API-ról és a lambda kifejezésekről: Ismerkedjünk lambda kifejezésekkel! Most másképpen közelítve újra foglalkozunk a témával.

Tanfolyamainkon szinte minden adatszerkezethez, tömbhöz, kollekcióhoz, fájlkezeléshez kötődő témakörben használjuk mindkettőt. Áttekintjük az ezekhez szükséges minimális verziószámot, a szintaktika fejlődését, az együttes használat elvi és gyakorlati lehetőségeit. A szükséges alapfogalmakat definiáljuk: hozzárendelési szabály, funkcionális interfész, metódus referencia, alapértelmezett metódusok, típus kikövetkeztetés képessége, generikus és funkcionális programozás. párhuzamos adatfeldolgozás lehetőségei.

Összehasonlításokat is végzünk: a lambda előtti verziók lehetőségei, korlátai, tipikus lambda hibák, mikor mit érdemes és mit nem érdemes használni, paraméterek típusait megadjuk vagy elhagyjuk, hagyományos kollekciós műveletek (azért a generikusság előtti időkre már nem térünk ki) és folyam feldolgozás (adatforrás meghatározása, közbenső és végső műveletek).

Most azokat a Stream API-hoz és lambda kifejezésekhez kötődő bevezető mintapéldákat ismertetjük, amiket részletesen elemzünk tanfolyamaink szakmai moduljának kontakt óráin. Ezek közül közösen meg is írunk néhányat, kombinálunk is néhányat egy-egy összetett adatfeldolgozó művelet megvalósítása során. Programozási tételenként specifikáljuk a feladatokat és megmutatunk néhány megoldást.

1. Adatforrás

100 db olyan véletlen kétjegyű számot állítunk elő generikus listában, amelyek között biztosan előfordul legalább egyszer a 80.

List<Integer> list=new Random().ints(100-1, 10, 99+1).

boxed().collect(Collectors.toList());

list.add(80);

System.out.println("100 db kétjegyű véletlenszám\n"+

list.stream().sorted().map(Number::toString).

collect(Collectors.joining(", ")));

2. Elemi programozási tételek

2.1. Sorozatszámítás

Kiírjuk, hogy mennyi a listában lévő számok összege:

System.out.print("Mennyi a számok összege? ");

System.out.print("V1: "+

list.stream().reduce(0, Integer::sum)+", ");

System.out.print("V2: "+

list.stream().reduce(0, (a, b) -> a+b)+", ");

System.out.print("V3: "+

list.stream().mapToInt(Integer::intValue).sum()+", ");

System.out.println("V4: "+

list.stream().collect(Collectors.summingInt(Integer::intValue)));

2.2. Eldöntés

Két kérdésre adunk választ. Van-e a listában lévő számok között 35 (konkrét elem), illetve páros (adott tulajdonságú elem)?

System.out.print("Van-e a számok között 35? ");

System.out.print("V1: "+

(list.stream().anyMatch(n -> n==35)?"Van.":"Nincs.")+", ");

System.out.print("V2: "+

(list.stream().filter(n -> n==35).count()>0)+", ");

System.out.print("V3: "+

(list.stream().filter(n -> list.contains(35)).count()>0)+", ");

System.out.println("V4: "+

list.stream().filter(n -> n==35).findFirst().isPresent());

System.out.println("Van-e a számok között páros? "+

(list.stream().anyMatch(n -> n%2==0)?"Van.":"Nincs."));

2.3. Kiválasztás

Kiírjuk, hogy a biztosan előforduló (legalább 1 db közül balról az első) 80, hányadik helyen (index) található meg:

System.out.println("Melyik a(z első) 80 sorszáma? "+

IntStream.range(0, list.size()).

filter(i -> list.get(i)==80).mapToObj(i -> i).findFirst().get());

2.4. Keresés

Keressük a 35-öt az eldöntés és a kiválasztás összeépítésével:

System.out.println("Van-e 35? Ha igen, melyik a(z első) sorszáma? "+

(list.stream().anyMatch(n -> n==35) ?

"Van, a(z első) sorszáma: " + IntStream.range(0, list.size()).

filter(i -> list.get(i)==35).mapToObj(i -> i).findFirst().get() :

"Nincs."));

2.5. Megszámolás

Kiírjuk, hogy hány db öttel osztható szám (adott tulajdonságú elem) található a listában:

1 2	System.out.println("Az öttel osztható számok száma: "+ list.stream().filter(n -> n%5==0).count());

2.6. Szélsőérték-kiválasztás

Kiírjuk a listában lévő legkisebb számot (értéket, nem indexet):

1 2	System.out.println("A legkisebb szám: "+ list.stream().mapToInt(n -> n).min().getAsInt());

3. Összetett programozási tételek

3.1. Másolás

Készítünk egy másolatot a lista elemeiről (közben esetleg mindegyiket meg is változtathatjuk):

List<Integer> copyList=

list.stream()./*map(n -> 2*n).*/collect(Collectors.toList());

System.out.println("Másolat a listáról: "+

copyList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.2. Kiválogatás

A listában lévő számok közül kiválogatjuk az öttel osztható számokat:

List<Integer> selectedList=new ArrayList<>();

list.stream().filter(n -> n%5==0).forEach(selectedList::add);

System.out.println("Az öttel osztható számok (V1): "+

selectedList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

System.out.println("Az öttel osztható számok (V2): "+

list.stream().filter(n -> n%5==0).

map(Number::toString).collect(Collectors.joining(", ")));

3.3. Szétválogatás

Külön-külön szétválogatjuk a listában lévő páros és páratlan számokat:

List<Integer> evenList=new ArrayList<>(); //páros

List<Integer> oddList=new ArrayList<>(); //páratlan

list.stream().forEach(n -> ((n%2==0) ? evenList : oddList).add(n));

System.out.println("Szétválogatás után:\n"+

"párosak: "+

evenList.stream().map(Number::toString).

collect(Collectors.joining(", "))+"\n"+

"páratlanok: "+

oddList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.4. Unió

A korábban szétválogatott páros és páratlan számokat tartalmazó halmazok unióját állítjuk elő:

List<Integer> unionList=new ArrayList<>();

Stream.concat(evenList.stream().distinct(),

oddList.stream().distinct()).

distinct().forEach(unionList::add);

System.out.println("Párosak és páratlanok uniója:\n"+

unionList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.5. Metszet

A korábban szétválogatott páros és páratlan számokat tartalmazó halmazok metszetét állítjuk elő:

List<Integer> intersectionList=new ArrayList<>();

evenList.stream().distinct().filter(oddList::contains).

forEach(intersectionList::add);

System.out.println("Párosak és páratlanok metszete:\n"+

intersectionList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.6. Összefésülés

A korábban szétválogatott páros és páratlan számokat összefésüljük:

List<Integer> mergedList=new ArrayList<>();

Stream.concat(evenList.stream(),

oddList.stream()).forEach(mergedList::add);

System.out.println("Párosak és páratlanok összefésülve:\n"+

mergedList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

4. A program eredménye a konzolon

100 db kétjegyű véletlenszám

10, 10, 10, 11, 13, 14, 16, 16, 18, 19, 19, 20, 21, 22, 23, 23, 24, 25, 25, 25, 26, 29, 29, 30, 30, 31, 32, 33, 34, 35, 36, 38, 38, 39, 39, 40, 42, 45, 45, 46, 47, 48, 49, 49, 50, 50, 51, 51, 53, 53, 54, 54, 54, 55, 56, 59, 61, 62, 62, 63, 63, 64, 67, 67, 68, 68, 69, 70, 72, 72, 73, 77, 77, 77, 77, 77, 79, 79, 79, 80, 81, 83, 84, 85, 85, 87, 87, 89, 89, 89, 89, 93, 95, 95, 95, 96, 97, 97, 98, 99

Mennyi a számok összege? V1: 5430, V2: 5430, V3: 5430, V4: 5430

Van-e a számok között 35? V1: Van., V2: true, V3: true, V4: true

Van-e a számok között páros? Van.

Melyik a(z első) 80 sorszáma? 99

Van-e 35? Ha igen, melyik a(z első) sorszáma? Van, a(z első) sorszáma: 22

Az öttel osztható számok száma: 23

A legkisebb szám: 10

Másolat a listáról: 20, 69, 48, 96, 19, 98, 11, 77, 49, 81, 79, 95, 70, 77, 67, 36, 23, 72, 38, 38, 54, 89, 35, 51, 83, 64, 26, 25, 51, 30, 89, 50, 22, 62, 95, 39, 42, 14, 10, 87, 54, 84, 24, 89, 16, 72, 97, 25, 85, 61, 59, 19, 13, 68, 55, 31, 79, 32, 47, 29, 18, 56, 10, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 40, 50, 29, 77, 16, 46, 99, 63, 45, 77, 97, 87, 89, 23, 30, 93, 95, 49, 68, 10, 34, 54, 33, 62, 79, 73, 80

Az öttel osztható számok (V1): 20, 95, 70, 35, 25, 30, 50, 95, 10, 25, 85, 55, 10, 25, 85, 45, 40, 50, 45, 30, 95, 10, 80

Az öttel osztható számok (V2): 20, 95, 70, 35, 25, 30, 50, 95, 10, 25, 85, 55, 10, 25, 85, 45, 40, 50, 45, 30, 95, 10, 80

Szétválogatás után:

párosak: 20, 48, 96, 98, 70, 36, 72, 38, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 54, 84, 24, 16, 72, 68, 32, 18, 56, 10, 40, 50, 16, 46, 30, 68, 10, 34, 54, 62, 80

páratlanok: 69, 19, 11, 77, 49, 81, 79, 95, 77, 67, 23, 89, 35, 51, 83, 25, 51, 89, 95, 39, 87, 89, 97, 25, 85, 61, 59, 19, 13, 55, 31, 79, 47, 29, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 29, 77, 99, 63, 45, 77, 97, 87, 89, 23, 93, 95, 49, 33, 79, 73

Párosak és páratlanok uniója:

20, 48, 96, 98, 70, 36, 72, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 84, 24, 16, 68, 32, 18, 56, 40, 46, 34, 80, 69, 19, 11, 77, 49, 81, 79, 95, 67, 23, 89, 35, 51, 83, 25, 39, 87, 97, 85, 61, 59, 13, 55, 31, 47, 29, 53, 21, 45, 63, 99, 93, 33, 73

Párosak és páratlanok metszete:

Párosak és páratlanok összefésülve:

20, 48, 96, 98, 70, 36, 72, 38, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 54, 84, 24, 16, 72, 68, 32, 18, 56, 10, 40, 50, 16, 46, 30, 68, 10, 34, 54, 62, 80, 69, 19, 11, 77, 49, 81, 79, 95, 77, 67, 23, 89, 35, 51, 83, 25, 51, 89, 95, 39, 87, 89, 97, 25, 85, 61, 59, 19, 13, 55, 31, 79, 47, 29, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 29, 77, 99, 63, 45, 77, 97, 87, 89, 23, 93, 95, 49, 33, 79, 73

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam, a Java EE szoftverfejlesztő tanfolyam és a Java adatbázis-kezelő tanfolyam szakmai moduljának több alkalmához és az orientáló moduljának 1-4. óra: Programozási tételek alkalmához is kötődik. A Stream API-val és a lambda kifejezésekkel sokszor foglalkozunk.

Korábban is blogoltunk már a Stream API-ról és a lambda kifejezésekről: Ismerkedjünk lambda kifejezésekkel!

Gyűjtsünk össze adatokat névjegykártya készítéshez!

2023. július 5.2018. január 23. Szerző: Kaczur Sándor

Induljunk ki az Oracle HR sémából!

Az EMPLOYEES táblából szükséges adatok: alkalmazottak neve konkatenálva a FIRST_NAME és LAST_NAME mezőkből, illetve a meglévő elérhetőségek: EMAIL (kiegészítve), PHONE_NUMBER és a hozzáadott WEBSITE. A JOBS táblából szükséges a munkakör megnevezése a JOB_TITLE mezőből, és a részleg neve a DEPARTMENTS tábla DEPARTMENT_NAME mezőből.

Építeni kell a DEPARTMENTS és EMPLOYEES táblák közötti 1:N kapcsolatra (azaz egy adott részlegben több alkalmazott is dolgozik), amelyet a DEPARTMENT_ID mező valósít meg. Nem szükséges az EMPLOYEES és DEPARTMENTS táblák közötti 1:N kapcsolat (azaz egy adott alkalmazott vezetőként több részleget is vezethet). Szükséges a JOBS és az EMPLOYEES táblák közötti 1:N kapcsolat, ami a JOB_ID mezővel valósul meg.

Hasznosak a köztes/átmeneti elnevezések a tábláknál ( D, J, E) és a mezőknél (például EMPLOYEE_NAME) egyaránt. Előbbieknél a mezőnevek minősítéséhez és egyértelmű hivatkozásaihoz kellenek, utóbbinál a metaadatokba kerülnek és utólag kiolvashatók ( ResultSetMetaData) és megjelenítéstől függően tartozhatnak például egy JTable vizuális komponens mögötti DefaultTableModel-hez.

A CONCAT függvénynek két paramétere lehet, ezért csak ott használtam, ahol ez kézenfekvő volt és elegendőnek bizonyult (az EMPLOYEE_NAME-nél nem akartam egymásba ágyazni két CONCAT-ot).

Az első lekérdezés a 107-ből 106 alkalmazott adatait adja vissza.
A második lekérdezés a hiányzó 1 alkalmazott adatai miatt szükséges, akinek nincs beállított részlege ( DEPARTMENT_ID IS NULL). Neki hiányos a COMPANY_DEPARTMENT_NAME adata, de így is egységes lehet az eredménytáblaként kapott adathalmaz (például oszlopok sorrendje és adattípusa).
A két lekérdezés eredményét egyesíteni kell ( UNION).

A lekérdező parancs

A lekérdező utasítást bele kell építeni egy Java kliensprogramba (MVC architekturális tervezési minta szerint a modell rétegbe), ami JDBC alapon kapcsolódik az Oracle adatbázis-szerver HR sémájához olyan felhasználó nevében, aki csatlakozhat és lekérdezhet. Meg kell tervezni és felügyelni kell a biztonságos kapcsolatot (kivételkezeléssel), annak életciklusát (nyit, lekérdez, zár), valamint gondoskodni kell az eredménytábla megjelenítéséről.

A keletkező eredménytábla exportálható Excel-be (XLS, XLSX formátumokba), és kiegészíthető például még egy oszloppal/mezővel (darabszám). Ezután átadható a grafikusnak, aki például felhasználja azt adatforrásként saját névjegykártya tervező szoftverében, vagy használja a Word körlevél varázslóját. Az adatforrás sorrendje ( ORDER BY) megkönnyítheti az elkészült névjegykártyák szétosztását.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam 45-48. óra: Adatbázis-kezelés JDBC alapon, 1. rész alkalmához, illetve a Java adatbázis-kezelő tanfolyam 9-12. óra: Oracle HR séma elemzése, 13-16. óra: Konzolos kliensalkalmazás fejlesztése JDBC alapon, 1. rész, 33-36. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon, 2. rész alkalomhoz kapcsolódik.

Az SQL forráskód formázásához a Free Online SQL Formatter-t használtam.

Fát építünk

2023. január 1.2018. január 7. Szerző: Kaczur Sándor

Az adatok strukturális és könnyen értelmezhető formában való megjelenítése egy szoftver felhasználói felületén átgondolt tervezést igényel. Az adatokhoz hozzá kell jutni, ki kell választani a megfelelő grafikus komponenst, a mögötte lévő adatmodellt, össze kell ezeket kötni. Gyakran előforduló feladat, hogy táblázatosan is ábrázolható adatokból – felhasználva az adatok közötti összefüggéseket és kapcsolatokat – csoportosítva jelenítsünk meg hierarchikusan, fa struktúrában, kinyitható-becsukható formában, ahogyan ezt a felhasználók jól ismerik a fájl- és menürendszereket használva.

Fát építünk kétféleképpen

Adatbázisból, az Oracle HR sémából lekérdezünk két összetartozó nevet: részleg és alkalmazott. A lekérdezés során figyelünk a megfelelő sorrendre, ami a későbbi feldolgozást megkönnyíti. Adatainkat részlegnév szerint növekvő, azon belül alkalmazott neve szerint is növekvő – ábécé szerinti – sorrendbe rendezzük. A vezérlő rétegben két függvényt írunk, amely a modell rétegtől jut hozzá az adatokat tartalmazó generikus listához – átvett paraméterként –, és a visszaadott érték a nézet réteghez kerül.

A csoportváltás algoritmust használjuk, amely 5 blokkból épül fel. A külső ciklus előtti 1. blokk és utáni 5. blokk egyszer hajtódik végre, az előkészítő és lezáró tevékenységek tartoznak ide. A külső ciklus elején és végén található 2. és 4. blokk a belső cikluson kívül fut le, csoportonként, kategóriánként, részlegenként egyszer (most összesen 11-szer mindkettő). A 3. blokk a belső cikluson belül található, és alkalmazottanként egyszer hajtódik végre (most összesen 106-szor).

Háromszintű fát építünk: a gyökérbe (0. szint) fix, beégetett szövegként kerül a cég neve és a teljes létszám. Az 1. szinten jelennek meg a részlegek nevei és a hozzájuk tartozó létszámok. A 2. szint az alkalmazottak neveiből áll.

1. megoldás

A megoldás faKeszit1() függvénye szöveges adatot eredményez. Ez jól használható teszteléshez: megvan-e az összes adat, megfelelő-e a részlegek sorrendje azon belül az alkalmazottak sorrendje, működik-e a csoportosítás, rendben van-e a megszámolás?

public String faKeszit1(ArrayList lista) {

//1

StringBuilder faGyoker=

new StringBuilder("Cég ("+lista.size()+" fő)");

int i=0;

while(i<lista.size()) {

//2

String aktReszleg=lista.get(i).getReszleg();

ArrayList faReszlegAlkalmazott=new ArrayList<>();

while(i<lista.size() &&

lista.get(i).getReszleg().equals(aktReszleg)) {

//3

faReszlegAlkalmazott.add(lista.get(i).getNev());

i++;

}

//4

String faReszleg="\n "+aktReszleg+

" ("+faReszlegAlkalmazott.size()+" fő)\n ";

faGyoker.append(faReszleg+" "+

String.join("\n ",faReszlegAlkalmazott));

}

//5

return faGyoker.toString();

}

A faKeszit1() függvény egy sok lépésben összefűzött (konkatenált) szöveget ad vissza. Az 1. blokkban előkészítjük a fa gyökerét, ami StringBuilder típusú, hiszen sokszor manipuláljuk és inicializáljuk a lista indexelésére használt i ciklusváltozót. A 2. blokkban megjegyezzük az aktuális részleget és előkészítjük az ehhez tartozó alkalmazottak nevét tároló generikus listát ( faReszlegAlkalmazott). Az aktReszleg-hez tartozó alkalmazottak neveit összegyűjtjük a 3. blokkban. Egy részleg feldolgozását a 4. blokkban fejezzük be a fa aktuális 1. és 2. szinten lévő elemeinek szövegbe való beszúrásával. A belső ciklushoz kötődően megszámolást nem kell alkalmaznunk, hiszen az adott részlegben dolgozó alkalmazottak száma a generikus listától elkérhető ( size()). Építünk arra, hogy a külső ciklusból nézve az egymás után végrehajtódó 2. és 4. blokkban az aktReszleg nem változik meg. A 2. blokkban még nem tudjuk a fa aktuális 1. szintjét hozzáfűzni a szöveghez, hiszen a létszám csak a belső ciklusban felépülő kollekciótól kérhető el utólag. Szükséges némi késleltetés, hiszen a szöveg összefűzése és lényegesen egyszerűbb (mint utólag manipulálni megfelelő helyeken). Az 5. blokkban a csoportváltás algoritmushoz kötődő tevékenységünk nincs.

Az 1. megoldás eredménye

Cég (106 fő)

Accounting (2 fő)

Shelley Higgins

William Gietz

Administration (1 fő)

Jennifer Whalen

Executive (3 fő)

Lex De Haan

Neena Kochhar

Steven King

...

2. megoldás

A faKeszit2() függvénynél alkalmazkodunk ahhoz, hogy a JTree vizuális komponenshez DefaultTreeModel observable típusú modell szükséges, így ezzel térünk vissza ( faModell). A fa csomópontjai DefaultMutableTreeNode osztályú objektumok lesznek, amelyeknek a userObject tulajdonsága szükség esetén manipulálható. Az 1 blokkban beszúrjuk a fa gyökerét ( faGyoker), amihez a későbbiekben csatlakozik a fa többi eleme. A 2. blokkban megjegyezzük az aktuális részleget és előkészítjük – megjelenítendő szöveg nélkül – a faReszleg csomópontot. A 3. blokkban fabeli csomópontként a fa 1. szintjén megjelenő részleghez névtelenül hozzáadjuk a fa 2. szintjére kerülő – aktuális részleghez tartozó – alkalmazottak nevét. A 4. blokkban utólag módosítjuk a faReszleg csomópont megjelenítendő szövegét. Az aktuális részleg létszámát itt sem kell külön megszámolni, mert a faReszleg-től elkérhető ( getChildCount()). Az 5. blokkban itt sincs különösebb teendőnk.

public DefaultTreeModel faKeszit2(ArrayList<Alkalmazott> lista) {

//1

DefaultMutableTreeNode faGyoker=

new DefaultMutableTreeNode("Cég ("+lista.size()+" fő)");

DefaultTreeModel faModell=new DefaultTreeModel(faGyoker);

int i=0;

while(i<lista.size()) {

//2

String aktReszleg=lista.get(i).getReszleg();

DefaultMutableTreeNode faReszleg=new DefaultMutableTreeNode();

while(i<lista.size() &&

lista.get(i).getReszleg().equals(aktReszleg)) {

//3

faReszleg.add(new DefaultMutableTreeNode(lista.get(i).getNev()));

i++;

}

//4

faReszleg.setUserObject(

aktReszleg+" ("+faReszleg.getChildCount()+" fő)");

faGyoker.add(faReszleg);

}

//5

return faModell;

}

A 2. megoldás eredménye

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Attól függően, hogyan jutunk hozzá a megjelenítéshez szükséges adatokhoz, több tanfolyamunkhoz is kapcsolódik a feladat és a modell rétegben mindig másképpen tervezünk és implementálunk:

A Java SE szoftverfejlesztő tanfolyam 45-48. óra: Adatbázis-kezelés JDBC alapon, 1. rész alkalmán hagyományos SQL lekérdező utasítást készítünk JDBC környezetben.
A Java EE szoftverfejlesztő tanfolyam 25-32. óra: Adatbázis-kezelés JPA alapon alkalommal a perzisztencia szolgáltatásait vetjük be.
A Java adatbázis-kezelő tanfolyam 13-16. óra: Konzolos kliensalkalmazás fejlesztése JDBC alapon, 1. rész, 33-36. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon, 2. rész alkalmain hierarchikus lekérdezéseket használunk.

Ki kinek a vezetője?

2023. augusztus 4.2017. augusztus 8. Szerző: Kaczur Sándor

Az SQL lekérdezések újabb típusát adják a hierarchikus lekérdezések. Az Oracle adatbázis-szerver már régóta támogatja ezt a lehetőséget. A hierarchia legtöbbször valamilyen fa adatszerkezethez kötődik. Ezek természetesen nem közvetlenül tárolódnak egy normalizált, relációs adatbázisban, de az adatok közötti kapcsolat értelmezése során felépíthető rekurzív módon a fa struktúra.

Hasonló feladat: Organogram készítése, reflexióra építve. Érdemes összehasonlítani a kétféle szemléletmódot.

Ki kinek a vezetője?

Az Oracle HR sémában az EMPLOYEES és DEPARTMENTS táblák között kétirányú 1:N kapcsolat van. Egy EMPLOYEE_ID egyedi kulccsal azonosított alkalmazotthoz tartozik egy nem kötelező DEPARTMENT_ID külső kulcs az EMPLOYEES táblában. Egy kivétellel minden alkalmazott részleghez hozzárendelt.

Egy DEPARTMENT_ID egyedi kulccsal azonosított részleghez tartozik egy nem kötelező MANAGER_ID külső kulcs a DEPARTMENTS táblában. Minden olyan részlegnek van vezetője, amelyikhez legalább egy alkalmazott hozzárendelt. A DEPARTMENTS táblában csak olyan MANAGER_ID szerepelhet, amelyik megtalálható az EMPLOYEES táblában EMPLOYEE_ID-ként. A „legfelsőbb” szinten lévő vezetőnek nincs vezetője.

Előfordulhat, hogy egy-egy részlegen belül többszintű hierarchiát találunk az organogramban, ha a részlegek helyett az alkalmazottak oldaláról közelítjük meg a problémát. Ekkor építhetünk arra, hogy az EMPLOYEES tábla saját magával is kapcsolatban áll (reflexió): egy MANAGER_ID-hez több EMPLOYEE_ID is tartozhat. Másképpen: egy adott vezetőnek több beosztottja is lehet.

A hierarchikus (rekurzív) lekérdező parancs

Az eredménytábla (részlet)

A keletkező eredménytábla exportálható Excel-be (XLS, XLSX formátumokba). Az első vagy utolsó oszlop adatait feldolgozva könnyen készíthető egy dinamikus adatmodellel rendelkező, fa struktúrát megjeleníteni képes komponens/felület, ahol szabadon böngészhető a szervezeti hierarchia.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java adatbázis-kezelő tanfolyam 9-12. óra: Oracle HR séma elemzése, 13-16. óra: Konzolos kliensalkalmazás fejlesztése JDBC alapon, 1. rész, 33-36. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon, 2. rész alkalomhoz kapcsolódik.

Az SQL forráskód formázásához a Free Online SQL Formatter-t használtam.