9.17. PHP Adatbázis-kezelés

A PHP programozási nyelv úgy kezeli az adatbázisokat, hogy a nyelvbe beépítették az elterjedt és támogatott adatbázis-kezelők támogatását. Az adatbáziskezelők általában SQL rendszerek, és kliens-szerver minta szerint működnek együtt a PHP-val.

Egy PHP-val meghajtott adatbázis-kezelő rendszernek az alábbiakban lehet felrajzolni a működési sémáját:

Egyes adatbázis-kezelőket a PHP alapból támogatja, míg másokhoz be kell tölteni a PHP.INI-ben a megfelelő sorok segítségével a támogatást.

Természetesen minden esetben kell telepíteni egy adatbázis-szerver szoftvert, amely nem mindig ingyenes! Magyarországon elterjedt legfontosabb adatbáziskezelők az alábbiak

MySQL

A fenti adatbázis-kezelőkről annyit, hogy jelenleg a legelterjedtebb ilyen alkalmazás a Linuxon, Netware-en és Windows rendszereken is futó MySQL. Ez a rendszer talán a leggyorsabb az összes elterjedt adatbázis-kezelő között, de nem valósítja meg az SQL összes lehetőségét. A MySQL nagyon előnyös tulajdonsága, hogy GNU liszensszel lehet használni, azaz akkor is free, ha eladási céllal használjuk, de magát a MySQL adatbázis-kezelő programot nem adjuk el. A MySQL letölthető az alábbi címről:  http://www.mysql.com/downloads/ vagy majdnem minden AMP (LAMP, XAMPP) fejlesztői környezet része.

Telepítése egyszerű Windowson el kell indítani a ZIP-ből való kicsomagolás után a SETUP.EXE programot, a többit elkészíti ő. Ha firewall van a gépünkön, akkor a TCP/IP 3306-os portját kell szabaddá tennünk. Ha a szerver ugyanazon a gépen fut, mint amelyiken a WEB szervert és a PHP-t futtatjuk, akkor a Firewallon nem szabad (!) engedélyezni más gépről ehhez a porthoz való hozzáférést.

Ha fejlesztés közben az adatbázisunkat módosítani akarjuk, különböző dolgokat akarunk elvégezni, akkor ajánlhatjuk a free phpMyAdmin nevű programcsomagot. Ha feltesszük a MySQL ODBC  driverét, akkor viszont tetszőleges ODBC kompatibilis alkalmazásból el tudjuk végezni az adatok módosítását, feltöltését stb... Akár ez lehet egy Microsoft Access is.

A MySQL használatához dokumentációt innen lehet letölteni:

http://www.mysql.com/get/Downloads/

PostGreSQL

A PostGres SQL egy kicsit komolyabb alkalmazás, mint a fent említett adatbázis-kezelő. A telepítése egyszerű, mert 2005-ben megjelent a Windowsos verzió is.

A PostgresSQL használatához dokumentációt az alábbi helyen lehet elérni:

http://www.postgres.org/docs/

Itt HTML és PDF formátumban vannak meg a megfelelő dokumentumok.

Adatbázis-kezelés natív módon

Az adatbázis-kezelők használatához a PHP.INI-ben meg kell adni a megfelelő beállítást (vagy, mint például a MySQL-nél, eleve a támogatás a rendszer része), és programunkban használhatjuk az adatbázisra vonatkozó utasításokat.

A PHP az adatbázis-kezelésre általában az alábbi utasításfajtákat tartalmazza.

• Az adatbázis-kezelő szerverrel kapcsolatot teremtő, a kapcsolatot lezáró parancsok
• Az adatbázisokra vonatkozó lekérdező és adminisztrációs parancsok
• Egy megnyitott adatbázisra vonatkozó adminisztrációs és lekérdező parancsok
• Az SQL lekérdezéseket átküldő parancs
• A lekérdezés eredményét feldolgozó parancsok.

A továbbiakban a MySQL utasításai alapján mutatom be az adatbázis-kezeléssel kapcsolatos utasításokat. Más adatbázis-kezelő esetén a változás általában csak annyi, hogy a névben az előtag más. Például:

<?php
mysql_connect()     //MySQL adatbázis-kezelő esetén
pg_connect()        //PostgresSQL
// a PHP5 esetén a mysql függvények helyett mysqli függvényeket kell használni.
?>

Kapcsolódás egy adatbázis-kezelőhöz, amely vagy lokális gépen helyezkedik el, vagy egy távoli, IP címmel meghatározott gépen. A kapcsolat létrehozása meg kell adni a kapcsolódási helyet (localhost, vagy IP cím), a kapcsolódó user-t, és a user jelszavát.

$link = mysql_connect(”localhost”,$username,$password); 
//vagy
$link1 = mysql_connect(”127.0.0.1”,$username,$password);

vagy

$link = mysql_pconnect(”localhost”,$username,$password);

A fentiekhez egy kis magyarázat. A connect és pconnect között az a különbség, hogy a connect-tel megnyitott kapcsolat lezárul a kérdéses php oldal lefutása után, míg a pconnect kapcsolat nyitva marad (Persistent connection), és újbóli kapcsolódás során csak akkor kell egy viszonylag sokáig tartó kapcsolódási procedúrán átmennie a rendszernek, ha a kapcsolat nincsen nyitva. Egyébként a két függvény használata ugyanaz

A visszaadott érték a kapcsolat sorszáma. Ennek alapján lehet a továbbiakban azonosítani több megnyitott kapcsolat esetén, hogy éppen melyik kapcsolatot használjuk.

A kapcsolat bezárása:

mysql_close($link)

$link = mysql_connect ("127.0.0.1", "fz", "titok") or die ("Could not connect");
print ("Connected successfully");
mysql_close ($link);

Az adatbázis-kezelőn lévő adatbázisokra vonatkozó parancsok:

int mysql_list_dbs ([int link_identifier])
int mysql_create_db (string database name [, int link_identifier]) - adatbázis létrehozása
int mysql_drop_db (string database_name [, int link_identifier]) - adatbázis törlése
int mysql_select_db (string database_name [, int link_identifier]) - Lekérdezés adatbázison

<?php
    $link = mysql_pconnect("127.0.0.1", "fz", "titok") or die ("Could not connect");

    if (mysql_create_db ("my_db")) {
        print ("Database created successfully\n");
    } else {
        printf ("Error creating database: %s\n", mysql_error ());
    }
?>

Egy adatbázis (lekérdezés) oszlopneveinek listázása. Ugyanez az utasítás a lekérdezés eredményének tetszőleges adatait is kilistázza ...

object mysql_fetch_field (int result [, int result_type])

Mezőnevek kiírása, és tárolása a mezonev tömbben

<?php
$con = mysql_connect("127.0.0.1", "fz", "titok");
$query = "SELECT * FROM tabla;";
$rs = mysql_db_query($con,$query);
$m  = mysql_num_rows($rs);
$n  = mysql_num_fields($rs);

for($i=0;$i<$n;$i++)
{
    //Oszlopnév/mezőnév bemásolása tömbbe későbbi felhasználásra
    $mezok = mysql_fetch_field($result);
    $meznev[] = $mezok->name;

    //Oszlop/Mező adatainak kilistázása.

     echo "<PRE>

          blob:         $meta->blob
          max_length:   $meta->max_length
          multiple_key: $meta->multiple_key
          name:         $meta->name
          not_null:     $meta->not_null
          numeric:      $meta->numeric
          primary_key:  $meta->primary_key
          table:        $meta->table
          type:         $meta->type
          unique_key:   $meta->unique_key
          unsigned:     $meta->unsigned
          zerofill:     $meta->zerofill
          </PRE>";
}
mysql_close();
?>

Egy SQL parancs elküldése

resource mysql_query ( string query [, resource link_identifier])

Az adatbázis-kezelőnek adott SQL, vagy egyéb utasítás eredményének átvétele a pufferből. Az eredmény általában két dimenziós tömbbe vagy objektumba érkezik, amelyet vagy a tömbkezelő függvények segítségével lehet feldolgozni, vagy indexel és ciklussal végig kell szaladni rajta. A visszaadott paraméterről mindig meg tudjuk mondani, hogy hány sorból áll. Az alábbi függvény megadja az eredmény sorainak számát. Ha nincs eredmény sor, akkor az értéke 0.

int mysql_num_rows([resource link_identifier])

Ha Delete, Update utasítások eredményére vagyunk kiváncsiak, akkor az alábbi függvényt kell használnunk.

int mysql_affected_rows ( [resource link_identifier])

Egy sort ad vissza egy tömbbe az alábbi függvény. A tömb öt sorszámokkal lehet indexelni, a sorszámozás 0-val kezdődik. Akkor használhatjuk, ha egy lekérdezésről nem tudjuk előre, hogy hány sort ad majd vissza.

array mysql_fetch_row([resource link_identifier])

Ennél a függvénynél szükségünk lehet a visszaadott oszlopok számára is. Ezt az alábbi függvénnyel tudjuk meg:

int mysql_num_fields ( [resource result])

Ez a függvény a sort szintén egy tömbben adja vissza, de a tömbelemek sorszámozva és a mezőnévvel is, mint asszociatív tömb indexxel elérhetők.

array mysql_fetch_array([resource link_identifier)

Az alábbi példa elküld egy lekérdezést, az eredmény oszlopneveit lekérdezi, majd megjeleníti táblázatos formában.

int mysql_fetch_object([resource link_identifier]) 

Az alábbi példa elküld egy lekérdezést, az eredmény oszlopneveit lekérdezi, majd megjeleníti táblázatos formában.

<?php

$qry    = ”SELECT * FROM tabla”;
$result = mysql_db_query($qry,$query);
$m      = mysql_num_rows($result);
$n      = mysql_num_fields($result);

echo ”<TABLE><TR>”;

for($i=0;$i<$n;$i++)
{
    $mezok=mysql_fetch_field($result);
    echo "<TD>".$mezok->name."</TD>";
    $meznev[] = $mezok->name;
}

echo"</TR>"; // mezők kiírásának vége

// mezőkben lévő adatok kiírása
for($i=0;$i<$m;$i++)
{
   echo "<TR>";
   
   $adat=mysql_fetch_array($result);
   for($j=0;$j<$n;$j++)
       echo "<TD>".$adat[$meznev[$j]]."</TD>";  

   echo"</TR>";
}

echo ”</TABLE>”;

?>

Tipikus adatbázis-kezelési feladatok

Egy adatbázis-kezelő használata során az alábbi tipikusnak mondható feladatokat kell megoldani PHP-ban, (de hasonlóképpen más programozási nyelveken is).

• Kapcsolódunk a szerveren lévő adatbázishoz.(láttunk mintát hozzá)
• Elküldünk egy SQL lekérdezést az adatbázis-kezelő programnak (Láttunk mintát hozzá)
• Az elküldött lekérdezésre kapott válasz általában egy táblázattal, vagy két-dimenziós tömbbel reprezentálható. Ezt szokás rekordszet-nek hívni. Egy ilyen rekordszetet megjelenítünk, célszerűen táblázatos formában. Ha a rekordszet túl sok sorból áll, akkor vagy a lekérdezéskor adunk olyan feltételeket, amely kevesebb sort ad eredményül, vagy megalkotjuk annak a lehetőségét, hogy a táblázat eredményét görgetni, vagy lapozni lehessen. (később általános mintát láttunk, az előző fejezetben bizonyos speciális eseteket néztünk)
• A rekordszet egyes sorait „űrlap” formájában meg akarjuk jeleníteni (később látunk mintát a fejezetben)
• Az űrlap vagy a rekordset eredményét ki akarjuk nyomtatni
• Az adatbázisba új adatot akarunk bevinni.
  • Egy rekordszethez illeszkedő új sorral
  • Egy rekordszethez illeszkedő új sor-űrlap formájában bevitt adatokkal.
  • Minden adatbevitelnél valamilyen tipizálható ellenőrzési feladatot illik elvégezni, vagy a bevitt adatokat szintaktikailag és/vagy szemantikailag ellenőrizni illik.
  • Adatok bevitelekor vagy módosításkakor, amikor csak lehet az adatokat egy felkínált listából kelljen kiválasztani – a tévedések elkerülése miatt.
• Adatok módosítása lehetőség szerint az új adat bevitelével azonos formátumban és módon történjen.
• Egyes adatok, adatsorok, rekordok törlése, ellenőrzött módon.
• Az adatok bevitele vagy módosítása során, hibás adatfelvitel miatti ismétléskor a korábban bevitt vagy meglévő adat jelenjen meg a beviteli űrlapon.

A fenti feladatokhoz az alábbi nem igazán PHP-ben megvalósított fogalmakat társíthatunk:

Az adatok táblázatos megjelenéséhez az alábbi séma szerint érdemes eljárni abban az esetben, ha két dimenziós táblázatban kapom meg az adatokat.

<?php

print( ”<table>”);
For($i=0;i<$maxsor;$i++){
    Print(”<tr>”);
    for( $j=0; $j < $maxoszlop; $j++ )
    {
          print ( "<td>" . adat[$i][$j]) . "</td>" );
    }
    print(”</tr>”);
}

print(”</table>”);

?>

Természetesen a táblázat formázását, a szegélyeket, stb… mindenki a saját ízlése szerint alkothatja meg.

Ha az adatokat soronként veszem át az adatbázis-kezelőtől, akkor a fenti algoritmus kicsit megváltozik. Azt is megmutatom a következő példában, ha lekérdezett rekordszetben nem az oszlopok sorszáma szerint veszem át az adatokat -  bár ezt is mindig meg lehet tudni egy adott esetben - hanem a mezőnevekkel, asszociatív módon hivatkozom egy sorra. Erre az előző fejezetben láttunk példát.

<?php
//egyszerű rekord megjelenítése
$con    = mysql_connect("127.0.0.1","fz","titok");
$result = mysql_db_query("teszt","SELECT * FROM tabla");
$sor    = mysql_num_rows($result);
$n      = mysql_num_fields($result);

print(”<table>”);

for($i=0;$i<$n;$i++)
{
    print(”<tr>”);

    //Oszlopnév/mezőnév bemásolása tömbbe későbbi felhasználásra
    $mezok = mysql_fetch_field($result);
    $meznev[] = $mezok->name;
   

    //Oszlop/Mező adatainak kilistázása.
          print(”<td align=right>”);
               print($meznev[$i]);            //A mező neve
          print(”</td>”)
          print(”<td>”);
               print($sor[$meznev]);               //A mező értéke
          print(”</td>”)
    print(”</tr>”);
}

print(”</table>”);

mysql_close();
?>

A fenti megjelenítés még elemi módon sem alkalmas új adatok bevitelére, hiszen új adatokat WEB böngésző esetén csakis FORM-okon keresztül vihetünk fel. Mindezek mellett meg kell oldanunk a mezők ellenőrzését is. Ennek megfelelően módosítanunk kell a fenti megoldást kissé. A példáról annyit, hogy egy űrlap jelenik meg, amely a megjeleníti a mezőket egy INPUT HTML tag segítségével, amivel az értéket rögtön módosítani is lehet. A bevitt adatokat minden mező esetén a böngésző javascript kódja rögtön ellenőrzi is (Hogy egyáltalán ki van-e töltve). Ha nincsen kitöltve, akkor hibaüzenet érkezik.

<!Doctype HTML>
<HTML>
<HEAD>
</HEAD>

<SCRIPT LANGUAGE="JavaScript">
    function elenoriz()
    {
          var k=document.form1.text.value;
          if (k.length<1){
               alert("Nincs kitöltve az adat!!");
               return false;
          } else{
               return true;
          }
    }
</SCRIPT>
<BODY>
<?php

//egyszerű rekord megjelenítése
$con = mysql_connect("127.0.0.1", "fz", "titok");
       mysql_select_db("teszt",$con);
$rs  = mysql_db_query($querydb,$query);
$sor = mysql_num_rows($rs);
$n   = mysql_num_fields($rs);

print('<FORM name=”form1” ACTION=urlap.php method="get" '>

print(”<table>”);

for( $i=0;$i<$n;$i++ )
{
    print(”<tr>”);
    //Oszlopnév/mezőnév bemásolása tömbbe későbbi felhasználásra
    $mezok=mysql_fetch_field($rs);
    $meznev[]=$mezok->name;
   
    //Oszlop/Mező adatainak kilistázása.
          print(”<td align=right>”);
               print($meznev[$i]);            //A mező neve
          print(”</td>”);
          print(”<td>”);
          print('<INPUT name=”'.$meznev[$i].'” type="text" value=”'.$sor[$meznev].'\”   
                  onchange=”javascript:ellenoriz('.$meznev[$i].')”>');
               print($sor[$meznev]);               //A mező értéke
          print(”</td>”)
    print(”</tr>”);
}
    print(”<tr>”);
        print(”<td>”);
        print('<INPUT name="OK"  type="submit" value="Ok">');
        print('<INPUT name="Törlés"  type="reset"  value="Mégse">');
        print('</td>')
        print('<td>');
        print('</td>');
    print(”</tr>”);
print(”</table>”);
mysql_close();

?>
</BODY>
</HTML>

A MySQL szerver a lekérdezések során hibakódot és szöveges üzenetet is küld vissza a kliensnek. A hibák kezelésére az alábbi függvények használhatók:

string mysql_error ([int link_identifier])

A MySQL szerver által visszaadott hiba szövegesen

int mysql_errno ([int link_identifier])

A MySQL szerver által visszaadott hiba kódja.

<?php
     mysql_connect("marliesle");
     echo mysql_errno().": ".mysql_error()."<BR>";
      mysql_select_db("nincsadatbazis");
     echo mysql_errno().": ".mysql_error()."<BR>";

     $conn = mysql_query("SELECT * FROM nincsadattabla");
     echo mysql_errno().": ".mysql_error()."<BR>";
?>     

A fenti lehetőségek csak a MySQL-re vonatkoznak, de hasonlóan lehet használni őket más adatbázisok esetén is.

mysqli adatbázis kezelő PHP-ban

A PHP 5.3.0-tól a hagyományos mysql függvények nem javasoltak és a PHP 7.0.0-tól pedig kivették a PHP-ból. Innentől kezdve a mysqli változatot kötelező használni. Ennek alapvető szabálya az, hogy OOP stílusban kell programozni.

Itt található példa a mysqli függvények használatára

 <?php
$servername = "localhost";
$username = "username";
$password = "password";

// Kapcsolat létrehozása
$conn = mysqli_connect($servername, $username, $password);

// Kapcsolat ellenőrzése
if (!$conn) {
  die("Hibás kapcsolódás: " . mysqli_connect_error());
}
echo "Sikeres kapcsolódás";
...
...
...
...
//Adatbázis kapcsolat zárása
mysqli_close();
?> 

A mysqli driver használata szinte ugyanaz, mint az eredeti mysql használata, de a modernebb drivert lehet OOP módon is használni.

MySQL használata PDO drivereken keresztül

A MYSQL-nek és egyéb adatbázis kezelőknek az egyik tipikus problémája az, hogyha egy FORM adatait átküldjük és a szerver oldalon abból SQL utasítást készítünk, akkor nagy biztonsági rést ütünk a rendszerünkön, mert megfelelően preparált lekérdezésekkel nagyon sok kárt lehet okozni. Ezt hívják SQL injection-nak.

A PDO driverek - mindegyik adatbázis kezelőnek van saját drivere - ezen a problémán segítenek.

A PDO driverek egységes felületet hoznak létre a különböző adatbázis-kezelőkhöz, ezért a programozóknak a dolga egyszerűsödik. A másik előnye ennek a megoldásnak az, hogy a PDO driverekbe a bemenő adatok tisztítása is be van építve így csökkentve az SQL injection problémák lehetőségét.

Az alábbiakban a tipikus felhasználási módokat adom meg.

Kapcsolódás adatbázishoz

$host = '127.0.0.1';
$db   = 'test';
$user = 'root';
$pass = '';
$port = "3306";
$charset = 'utf8mb4';

$options = [
    \PDO::ATTR_ERRMODE            => \PDO::ERRMODE_EXCEPTION,
    \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
    \PDO::ATTR_EMULATE_PREPARES   => false,
];
//Kapcsolat:      szerver ip cím         adatbázis neve karakterkészlet  port
$dsn = "mysql:host=$host;dbname=$db;charset=$charset;port=$port";

try {
     $pdo = new \PDO($dsn, $user, $pass, $options);
} catch (\PDOException $e) {
     throw new \PDOException($e->getMessage(), (int)$e->getCode());
}

Egy létrehozott kapcsolat használata lekérdezéshez. Meghívjuk az alábbi függvényt a fent létrehozott PDO driver azonosítóval, és a lekérdezendő sor ID-jével. A függvény visszaadja a lekérdezett sor adatait

function getData($pdo, $id){
  $qry = $pdo->prepare("SELECT * FROM user WHERE id=?");
  $qry->execute([$id]);
  return  $qry->fetch();
}

Adatok lekérdezése

Lekérdezés paraméterek nélkül

// minden sor lekérdezése
$qry = $pdo->query("SELECT * FROM users");

Egy sor lekérdezése egy táblából

// Az utoljára regisztrált felhasználó lekérdezése
$qry = $pdo->query("SELECT * FROM users ORDER BY id DESC LIMIT 1");
$user = $qry->fetch();

A PHP az objektum orientált programozás használata során képes láncolni a metódusokat is az alábbi módon.

// Az utoljára regisztrált felhasználó lekérdezése
$user = $pdo->query("SELECT * FROM users ORDER BY id DESC LIMIT 1")->fetch();

Egy tábla összes sorának lekérdezése.

// Az utoljára regisztrált felhasználó lekérdezése
$qry = $pdo->query("SELECT * FROM users");
while ($row = $qry->fetch()) {
    echo $row['name']."<br />\n";
}

A while ciklus addig fut, amíg az összes sor adatait fel nem dolgozza.

Ugyanezt egy kicsit gyorsabban és egyszerűbben is meg lehet csinálni. A fetchAll() metódus gyorsabb, mint külön-külön lekérdezni a sorokat.

$data = $pdo->query("SELECT * FROM users")->fetchAll();

// és később ilyet futtatunk le
foreach ($data as $row) {
    echo $row['name']."<br />\n";
}

Lekérdezés paraméterezetten. ebben a megoldásban a ? karakter jelzi a behelyettesítendő string helyét. Ahány kérdőjel (?), annyi paramétert vár az execute() metódus tömbben. Ez nem túl szerencsés, mert hibakezelés esetén a kérdőjelek kicsit áttekinthetetlenné tehetik a kódot.

//egy Id-vel valéó kiválasztás
$qry = $pdo->prepare("SELECT * FROM users WHERE id=?");
$qry->execute([$id]); 
$user = $qry->fetch();

Egy helyörzővel végrehajtott lekérdezés. A nevesített helyörző jobb megoldás.

//egy helyörzővel valóó kiválasztás
$qry = $pdo->prepare("SELECT * FROM users WHERE id=:id");
$qry->execute( ['id' => $id] ); 
$user = $qry->fetch();

Több paraméter átadása a lekérdezésnek. Ha több átadandó paraméter van, akkor a nevesített helyörzők használata a célszerűbb.

$qry = $pdo->prepare("SELECT * FROM users LIMIT :limit, :offset");
$qry->execute(['limit' => $limit, 'offset' => $offset]); 
$data = $qry->fetchAll();

// később pedig ezt hívjuk:
foreach ($data as $row) {
    echo $row['name']."<br />\n";
}

Új adatok felvitele (INSERT)

$sql = "INSERT INTO users (name, surname, sex) VALUES (?,?,?)";
$qry= $pdo->prepare($sql);
$qry->execute([$name, $surname, $sex]);

Vagy a lekérdezések láncolásával

$sql = "INSERT INTO users (name, surname, sex) VALUES (?,?,?)";
$pdo->prepare($sql)->execute([$name, $surname, $sex]);

Adatok felvitele nevesített helyörzővel

$data = [
    'name' => $name,
    'surname' => $surname,
    'sex' => $sex,
];
$sql = "INSERT INTO users (name, surname, sex) VALUES (:name, :surname, :sex)";
$pdo->prepare($sql)->execute($data);

Adatok módosítása (UPDATE).

$data = [
    'name' => $name,
    'surname' => $surname,
    'sex' => $sex,
    'id' => $id,
];
$sql = "UPDATE users SET name=:name, surname=:surname, sex=:sex WHERE id=:id";
$qry= $pdo->prepare($sql);
$qry->execute($data);

Adatok törlése (DELETE FROM...)

$data = [ 'id' => $id ];
$sql = "DELET FROM users WHERE id=:id";
$qry= $pdo->prepare($sql);
$qry->execute($data);

Megjegyzések

• Az adatbázis-kezelés talán az egyik legfontosabb terület a PHP-ban, ugyanis "nagy" informatikai rendszerek (CMS, webáruház, portálok, stb.) az adatokat mindig adatbázisokban tárolják!
• A fent említett rendszerek gyakran saját burkoló osztályokat használnak az adatbázis kezelési feladatok megvalósítására, ez pedig átvezet az objektum orientált programozás területére.