2026. október 13., kedd
Wesselényi Miklósról
2026. október 12., hétfő
Elment a nagy vadász!
Üdv a vadásznak és tisztelet a vadnak...
PHP alapismeretek
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 konkrét adatbázis tábláinak kilistázása
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>
Adatbázis hibakezelés
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);
------------
<?php
session_start();
$jelszo = "titok123"; // Itt adhatja meg a kívánt jelszót
if (isset($_POST['password']) && $_POST['password'] === $jelszo) {
$_SESSION['belepve'] = true;
}
if (isset($_GET['kijelentkezes'])) {
session_destroy();
header("Location: index.php");
exit;
}
?>
<!DOCTYPE html>
<html lang="hu">
<head>
<meta charset="UTF-8">
<title>Belépés</title>
</head>
<body>
<?php if (empty($_SESSION['belepve'])): ?>
<!-- Bejelentkező űrlap -->
<form method="POST">
<input type="password" name="password" placeholder="Jelszó" required>
<button type="submit">Belépés</button>
</form>
<?php else: ?>
<!-- Védett tartalom -->
<h1>Sikeres belépés!</h1>
<p>Ez a szöveg csak bejelentkezés után látható.</p>
<a href="?kijelentkezes=1">Kijelentkezés</a>
<?php endif; ?>
</body>
</html>
----------------------
<form action="auth.php" method="POST">
<div>
<label for="username">Felhasználónév:</label>
<input type="text" id="username" name="username" required>
</div>
<div>
<label for="password">Jelszó:</label>
<input type="password" id="password" name="password" required>
</div>
<button type="submit">Belépés</button>
</form>
-------------
<?php
session_start();
// Példa statikus ellenőrzésre (élesben adatbázisból/hash-ből olvasd!)
$helyes_user = "admin";
$helyes_pass = "titok123";
if ($_SERVER["REQUEST_METHOD"] === "POST") {
$user = trim($_POST["username"] ?? "");
$pass = $_POST["password"] ?? "";
if ($user === $helyes_user && $pass === $helyes_pass) {
$_SESSION["belepve"] = true;
$_SESSION["user"] = $user;
header("Location: vedett_oldal.php");
exit;
} else {
echo "Hibás felhasználónév vagy jelszó!";
}
}
----------------
<?php
session_start();
if (!isset($_SESSION["belepve"]) || $_SESSION["belepve"] !== true) {
header("Location: login.php");
exit;
}
echo "Üdvözöllek, " . htmlspecialchars($_SESSION["user"]) . "!";
--------------
<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$user = $_POST['username'];
$pass = password_hash($_POST['password'], PASSWORD_DEFAULT); // Biztonságos jelszó titkosítás
if (!empty($user) && !empty($_POST['password'])) {
// Elmentjük a felhasználónevet és a titkosított jelszót a users.txt fájlba
file_put_contents('users.txt', $user . ":" . $pass . PHP_EOL, FILE_APPEND);
echo "Sikeres regisztráció!";
} else {
echo "Minden mezőt ki kell tölteni!";
}
}
?>
<form method="post">
<input type="text" name="username" placeholder="Felhasználónév" required><br>
<input type="password" name="password" placeholder="Jelszó" required><br>
<button type="submit">Regisztráció</button>
</form>
----------------
<?php
// 1. Kapcsolódás az adatbázishoz
$host = 'localhost';
$db = 'adatbazis_neve';
$user = 'felhasznalonev';
$pass = 'jelszo';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
try {
$pdo = new PDO($dsn, $user, $pass);
} catch (\PDOException $e) {
throw new \PDOException($e->getMessage(), (int)$e->getCode());
}
// 2. Keresendő kifejezés (pl. egy keresőmezőből érkezik)
$keresett_szo = "példa termék";
// 3. A kereső SQL lekérdezés előkészítése (biztonságos forma)
$sql = "SELECT * FROM termekek WHERE termek_neve LIKE :kereses";
$stmt = $pdo->prepare($sql);
// 4. Lekérdezés futtatása a paraméterrel
$stmt->execute(['kereses' => '%' . $keresett_szo . '%']);
// 5. Találatok kilistázása
$talalatok = $stmt->fetchAll();
foreach ($talalatok as $sor) {
echo $sor['termek_neve'] . "<br>";
}
?>
--------------
<?php
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
$felhasznalo = trim($_POST['user']);
$jelszo = password_hash($_POST['pass'], PASSWORD_BCRYPT);
$szerep = ($felhasznalo === 'admin') ? 'admin' : 'user';
if (!empty($felhasznalo) && !empty($_POST['pass'])) {
$sor = $felhasznalo . ";" . $jelszo . ";" . $szerep . "\n";
file_put_contents('felhasznalok.txt', $sor, FILE_APPEND);
echo "Sikeres regisztráció! <a href='login.php'>Bejelentkezés</a>";
} else {
echo "Minden mezőt tölts ki!";
}
}
?>
<form method="POST">
<h2>Regisztráció</h2>
<input type="text" name="user" placeholder="Felhasználónév" required><br><br>
<input type="password" name="pass" placeholder="Jelszó" required><br><br>
<button type="submit">Regisztráció</button>
</form>
-------------
<?php
session_start();
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
$be_user = trim($_POST['user']);
$be_pass = $_POST['pass'];
$siker = false;
if (file_exists('felhasznalok.txt')) {
$fajl = file('felhasznalok.txt', FILE_IGNORE_NEW_LINES);
foreach ($fajl as $sor) {
list($user, $pass, $szerep) = explode(';', $sor);
if ($user === $be_user && password_verify($be_pass, $pass)) {
$_SESSION['user'] = $user;
$_SESSION['role'] = $szerep;
$siker = true;
header("Location: admin.php");
exit;
}
}
}
echo $siker ? "" : "Hibás felhasználónév vagy jelszó!";
}
?>
<form method="POST">
<h2>Bejelentkezés</h2>
<input type="text" name="user" placeholder="Felhasználónév" required><br><br>
<input type="password" name="pass" placeholder="Jelszó" required><br><br>
<button type="submit">Belépés</button>
</form>
--------------
<?php
session_start();
// Ellenőrzés: be van-e lépve és admin-e?
if (!isset($_SESSION['user']) || $_SESSION['role'] !== 'admin') {
echo "Hozzáférés megtagadva! Csak adminisztrátorok léphetnek be. <a href='login.php'>Bejelentkezés</a>";
exit;
}
?>
<!DOCTYPE html>
<html>
<head>
<title>Admin Panel</title>
</head>
<body>
<h1>Üdvözöllek a titkos Admin Felületen, <?php echo htmlspecialchars($_SESSION['user']); ?>!</h1>
<p>Itt különböző adminisztrációs feladatokat láthatsz el.</p>
<br>
<a href="logout.php">Kijelentkezés (Exit)</a>
</body>
</html>
---------------
<?php
session_start();
session_unset();
session_destroy();
header("Location: login.php");
exit;
?>
-------------
2026. október 9., péntek
Mélyűri űrszondák pillanatnyi helyzete
Jelenleg 2026 októberében:
• A Voyager–1-et 1977. szeptember 5-én bocsátották fel, több mint 25,7–25,9 milliárd kilométerre jár a Földtől (kb. 165–171 csillagászati egységre), és már a csillagközi térben mozog. Az Ophiuchus (Kígyótartó) csillagkép irányában halad, és 2026 novemberében éri el az 1 fénynapos távolságot a Földtől. https://orbitalradar.com/deep-space körülbelül 2036-ra fogjuk végleg elveszíteni a kapcsolatot a Voyager–1 űrszondával Voyager–1 energiaellátását biztosító plutóniumalapú generátor (RTG) évente nagyjából 4 wattal kevesebb áramot termel. Az egyre szűkösebb energiakeret miatt a mérnökök folyamatosan kapcsolják le a berendezéseket. 2026 tavaszán például leállították a töltött részecskéket vizsgáló műszert (LECP), így az eredeti 10 tudományos eszközből mára mindössze 2 maradt aktív szeretnénk ha legalább egy tudományos műszer a 2030-as évek elejéig működjön. Ezután a szonda már csak mérnöki-állapotadatokat fog küldeni, amíg az adóegységének van elég tápellátása. A kritikus határvonal 2036 körül jön el, amikor a jel túl gyengévé válik a NASA Deep Space Network antennái számáraA Voyager–1 már most is több mint 25 milliárd kilométerre van tőlünk. 2026 novemberében éri el a történelmi 1 fénynapnyi távolságot, ami azt jelenti, hogy a tőle érkező rádiójelnek kerek 24 órára lesz szüksége ahhoz, hogy elérje a Földet.
• A Voyager–2-t 1977. augusztus 20-án bocsátották fel, körülbelül 21,4 milliárd kilométerre van a Földtől (kb. 138–143 csillagászati egységre), szintén a csillagközi térben utazik, a déli égbolton (az Andromeda irányába). https://science.nasa.gov/mission/voyager/where-are-voyager-1-and-voyager-2-now/
• New Horizons: 2006. január 19-én bocsátották fel, körülbelül 9,6 milliárd kilométerre (közel 64 csillagászati egységre) jár a Kuiper-övben, miután 2026 júniusában kilépett a leghosszabb hibernációs időszakából.
• Pioneer 10: 1972. március 3-án bocsátották fel, történelmi/inaktív űrszonda, amely mintegy 21,2–21,3 milliárd kilométerre van a Naptól és a Földtől, a Bika (Taurus) csillagkép irányában sodródik.
• Parker Solar Probe: August 12, 2018 jelenleg a belső Naprendszerben, a Mérleg (Libra) csillagkép irányában kering, ismételten rekordközelben elrepülve a Nap koronája mellett (kb. 125 millió km-re a Földtől, miközben a Naptól mindössze néhány millió kilométerre száguld).
• Nancy Grace Roman űrtávcső: 2026. augusztus 30-i indítása óta tart felé a Nap–Föld L2-es Lagrange-pont irányába (kb. 1,5 millió kilométerre a Földtől)
Adatok szűrése és rendezése az Accessben
Az Accessben az adatok szűrése és rendezése a relációs adatbázisok kezelésének legfontosabb feladata. Enélkül a releváns információk megtalálása megoldhatatlan feladat. A nézeteket, lekérdezéseket és jelentések és szűrések csak a szükséges információkat jelenítik meg. A szűrők és a rendezés lehetővé teszik az adatok strukturálását.
Szűrő Ez azt jelenti, hogy a képernyőn csak azokat a rekordokat jelenítjük meg, amelyek megfelelnek egy vagy több kritériumnak, a többit pedig ideiglenesen épen elrejtjük. Rendelés Ez a rekordok elrendezésének egy vagy több mező értéke szerinti átrendezéséből áll, növekvő vagy csökkenő sorrendben. Mindkét művelet fizikailag nem módosítja a táblázatban tárolt adatokat, csak azt változtatja meg, hogy azok hogyan jelennek meg a munkanézetben. 
Hol alkalmazhatok szűrőket és rendezéseket az Accessben? Gyakorlatilag bármilyen Access-objektum – táblázatok, lekérdezések, űrlapok és jelentések – lehetővé teszi az adatok szűrését és/vagy rendezését. Az objektumtól függően egyes függvények könnyebben elérhetők,
vagy eltérő testreszabási lehetőségeket kínálnak. Például:
vagy eltérő testreszabási lehetőségeket kínálnak. Például:
Lekérdezések: A szűrés maga a lekérdezés része lehet (feltételek a tervezési sorban).
Űrlapok: Nagyon kényelmes vizuális vagy űrlap szerinti szűréshez, a végfelhasználó számára tervezve.
jelentések: lehetővé teszi szűrők alkalmazását az előnézetben nyomtatás vagy exportálás előtt.
Az Access által kínált különböző szűrőtípusok hozzáférési szűrők Az Access számos szűrőmechanizmust integrál, hogy alkalmazkodjon a különböző forgatókönyvekhez és tapasztalati szintekhez. Válassza ki a legmegfelelőbb szűrőtípust a keresés összetettsége alapján:
Gyakori szűrők
Ezek a leggyorsabbak és legközvetlenebbek, mivel az Access előre beállított beállításokat kínál az oszlop adattípusa alapján. Nem kell feltételeket vagy képleteket írni. Egyszerűen: Kattintson a szűrni kívánt oszlop vagy mező fejlécében található legördülő menüre. Kijelölhet/megszüntethet bizonyos elemeket, szűrhet tartományok vagy adott feltételek, például „egyenlő”, „tartalmaz”, „ezzel kezdődik”, „nagyobb, mint” stb. szerint. Dátummezők esetén szűrőket találhat időszak, hónap, dátumok közötti idő, ma, tegnap, múlt hét stb. szerint. Ha az „(Üresek)” lehetőséget választja, kiszűri az üres vagy null rekordokat az adott mezőben. Mire használhatók az F1–F12 billentyűk a billentyűzeten: teljes útmutató Ez a módszer ideális gyors áttekintésekhez, vagy ha csak egy egyszerű kritérium alapján kell szűrni. Szűrés kijelölés szerint Lehetővé teszi egy adott érték alapján szűrést egyszerűen a cellában való kijelöléssel. Ha például egy adott névre kattint, és a „Szűrés kijelölés szerint” lehetőséget választja, az Access elrejti az összes rekordot, kivéve azokat, amelyek pontosan ezt az értéket tartalmazzák az adott mezőben. A következőket teheti: Jelöljön ki egy szót, a szöveg egy részét, egy dátumot vagy egy számot, és szűrjön a kijelölés szerint (kezdet, vég, tartalmazza stb.).
Több szűrő kombinálásával további mezőket választhat ki az eredmény finomításához.
A szűrő eltávolításához egyszerűen kattintson a „Szűrő be-/kikapcsolása” vagy az „Összes szűrő törlése” gombra a Kezdőlap lapon, a Rendezés és szűrés csoportban.
Szűrés űrlap szerint
Ez a szűrőtípus különösen hatékony olyan rekordok keresésére, amelyek több feltételnek is megfelelnek különböző mezőkben. Az Access létrehoz egy üres űrlapot vagy adatlapot, ahol kitöltheti a mezőket a keresni kívánt értékekkel (néhányat üresen hagyhat, és csak a szükségeseket töltheti ki). Ideális összetett keresésekhez, például:
Minden olyan személy, akinek a városa „Madrid”, és akinek a beosztása „Menedzser”.
Az „VAGY” fül segítségével alternatív kereséseket is végezhet, azaz megjelenítheti azokat a rekordokat, amelyek megfelelnek az egyik vagy a másik kritériumkészletnek (pl.: Ország = „Spanyolország” VAGY Ország = „Franciaország”).
Mint minden más módban, a szűrő eltávolítása olyan egyszerű, mint a „Szűrő be-/kikapcsolása” gomb újbóli megnyomása. Speciális szűrő A speciális mód áll legközelebb a lekérdezések tervezéséhez, lehetővé téve összetett és egyéni feltételek megadását a tervezőrácsban. Ajánlott, ha van tapasztalata a kifejezésekkel és kritériumokkal. Nyissa meg a „Rendezés és szűrés” csoporton belüli „Speciális szűrő vagy rendezés” opciót. Adja hozzá a szűrni kívánt mezőket a rácshoz, és adja meg a feltételeket a „Feltételek” sorban (logikai operátorokat, függvényeket, kifejezéseket használhat, mint a lekérdezésekben). Használja az „VAGY” sort, ha alternatív kritériumokat szeretne megadni.
Betölthet feltételeket egy korábbi lekérdezésből, vagy mentheti ezt a szűrőt új lekérdezésként későbbi használatra. Szűrők alkalmazása lépésről lépésre az objektum típusa szerint Szűrés táblázatokban
Tegyük fel, hogy van egy táblázatod az alkalmazottakról, és csak azokat szeretnéd látni, akiknek a fizetése meghaladja az 50.000 eurót: Nyissa meg a táblázatot Adatlap nézetben. Kattintson a „Fizetés” oszlopfejlécben található nyílra. Válassza a „Számszűrők” lehetőséget, majd a „Nagyobb, mint” lehetőséget, és írja be az 50000 értéket. Az Access csak azokat az alkalmazottakat fogja megjeleníteni, akik megfelelnek a feltételnek. Más oszlopok szűrőit is kombinálhatja, például: részleg = 'Értékesítés' ÉS fizetés > 50000, az űrlapszűrő használatával.
Szűrés lekérdezésekben
A lekérdezések lehetővé teszik a feltételek közvetlen beépítését a tervezősorba, így a lekérdezés minden futtatásakor az Access csak a szűrt adatokat jeleníti meg. Például az 1000 eurónál nagyobb eladások megtekintéséhez:
Nyissa meg a lekérdezést tervező nézetben.
A „Kritériumok” sorban az „Összeg” mező alatt írja be: „>1000”.
Futtassa a lekérdezést úgy, hogy csak az egyező eredményeket adja vissza.
Több kritériumot kombinálhatsz az „ÉS” vagy „VAGY” operátorral a további finomítás érdekében.
Adatok szűrése űrlapokon
Az űrlapok intuitív felhasználói élményt nyújtanak. A szűrés innen egyszerűen elvégezhető: kattintson az Önt érdeklő adatokra, és alkalmazza a szűrőt, vagy használja az űrlapszűrőt a speciális keresésekhez.
VirtualBox mester: Alapvető parancsok és gyakorlati példák magyarázata
Szűrők a jelentésekben Ha van egy jelentésed (például egy alkalmazotti lista), akkor a nyomtatás előtt szűrhetsz a jelentésnézetből:
Kattintson jobb gombbal az adatra (pl. vezetéknév), és válassza a „Szövegszűrők > Ezzel kezdődik” lehetőséget. Írd be a betűt vagy szöveget, és fogadd el. A jelentést úgy nyomtathatja ki, hogy csak a pillanatnyilag szükséges adatokat szűri ki. A szűrő lekérdezésként való mentéséhez és újbóli felhasználásához használja a menüszalag „Szűrő vagy speciális rendezés” funkcióját.
Szűrők eltávolítása vagy újbóli alkalmazása
Egy szűrő eltávolítása azonnal elvégezhető: egyszerűen kattintson a felső eszköztáron található „Szűrő be-/kikapcsolása” gombra. Ez ideiglenesen eltávolítja a szűrőt, de menti, így egy másik kattintással újraaktiválhatja. Ha a szűrő törlését választja (az „Összes szűrő törlése” paranccsal), az Access elfelejti a kijelölést, és újra kell alkalmaznia, ha a jövőbeni munkamenetekben szüksége lesz rá.
Szűrők mentése újrafelhasználáshoz
Az Access megjegyzi az aktív szűrőket, amikor bezárja a táblázatokat, űrlapokat vagy jelentéseket, így a következő munkamenetben automatikusan újra alkalmazhatja ugyanazt a szűrőt.
Annak biztosítására, hogy egy szűrő mindig alkalmazásra kerüljön egy objektum megnyitásakor, lépjen a tulajdonságlapra, és engedélyezze a „FilterOnLoad” opciót.
További információ az Accessben az adatok szűrésére és rendezésére szolgáló speciális lekérdezésekről..
Gyakorlati példák az Accessben a szűrésre
Egyszerű szűrés
Ha van rendelési táblázatod, és csak az elmúlt hónapban leadottakat szeretnéd látni:
Szűrje a „Rendelés dátuma” oszlopot a megfelelő hónap kiválasztásával a dátumszűrőkben.
Összetett vagy egyéni szűrés
Csak azokat az alkalmazottakat lásd, akiknek a fizetése meghaladja az 50.000 XNUMX eurót és akik értékesítési területen dolgoznak:
Alkalmazd az összetett szűrőt a speciális menüből: fizetés > 50000 ÉS részleg = 'Értékesítés'.
Vagy, ha úgy tetszik, használhatja a lehetőséget, mindkét mezőt kitöltve a kívánt értékekkel.
Jelentések szűrése nyomtatáshoz
Jelentés szűrése úgy, hogy csak egy adott városból származó ügyfelek jelenjenek meg:
Nyissa meg a jelentést nyomtatási nézetben, kattintson a város mezőre, és használja az „Egyenlő” vagy a „Tartalmaz” szövegszűrőt.
Szükség szerint nyomtassa ki vagy exportálja a szűrt jelentést.
Adatok rendezése az Accessben
Az adatok rendezése ugyanolyan fontos a megjelenítés és a megértés szempontjából, legyen szó táblázatokról, lekérdezésekről vagy jelentésekről.
Táblázatok szerinti rendezés
Nyissa meg a táblázatot Adatlap nézetben.
Kattintson a rendezni kívánt oszlop fejlécére.
Kattintson a növekvő (AZ) vagy csökkenő (ZA) rendezés ikonra.
Több oszlop szerint is rendezhet, de a fő oszlop lesz először kiválasztva.
Rendezés lekérdezések szerint
Tervező nézetben, a „Rendezés” sorban válassza ki, hogy egy vagy több mező szerint növekvő vagy csökkenő sorrendben szeretne-e rendezni.
Például: Rendezze először a termék nevét (növekvő), majd a dátumot (csökkenő) a termékek legutóbbi eladásainak elemzéséhez.
Rendezés a jelentésekben
A rendezési beállításokat a jelentés tulajdonságainál érheti el, vagy a Tervező nézetben adhat meg többmezős rendezési feltételeket.
Szűrők és rendezések kombinálása a speciális elemzéshez
Az Access igazi ereje a szűrés és a rendezés kombinálásában rejlik, így testreszabott nézeteket hozhat létre, amelyek lehetővé teszik a trendek feltárását vagy a vállalkozás mélyreható elemzését.
Először szűrje le a kulcsfontosságú adatokat a nézet szűkítéséhez, például a 2000 euró feletti eladásokra.
Ezután rendezzen dátum, alkalmazott, termék vagy bármely más releváns mező szerint.
Ezt a konfigurációt lekérdezésként mentheti, hogy szükség esetén újra felhasználhassa.
Hogyan javítsuk ki az írásvédett fájlrendszer hibáját
Konfiguráció megőrzése és újrafelhasználása
Sok felhasználó nincs tisztában azzal, hogy az Access lehetővé teszi a szűrési és rendezési beállítások mentését, név hozzárendelését, és a jövőbeli munkamenetekben a közvetlen hozzáférést ehhez az egyéni nézethez. Használja ki ezt a funkciót, hogy mindig elemezze a kulcsfontosságú adatokat anélkül, hogy mindent újra kellene konfigurálnia a nulláról.
Űrlapok szűrői és rendezési lehetőségei, valamint felhasználói élményük
Az űrlapokon szűrőket alkalmazhat magáról a felületről, intuitív menük vagy közvetlen keresési mezők segítségével.
Jelölje ki a mezőt vagy értéket, és szűrje le a helyi menüből.
Használjon űrlapszűrőket, ha több mezőben kell kombinálnia a feltételeket.
A beállítások az eszköztáron, a gyors elérésű menüszalagokon vagy az űrlapspecifikus menükben találhatók. Gyakorlatok és esettanulmányok a szűrés és rendezés elsajátításához
Hogy teljes mértékben megértsd az Access sokoldalúságát, íme néhány gyakorlat és esettanulmány, amelyek segíthetnek a gyakorlásban:
interaktív gyakorlatok
Üzlet készlete: Szűrje le a 10 darabnál kevesebb raktáron lévő termékeket, és rendezze őket csökkenő ár szerint. Projektmenedzsment: Csak a függőben lévő feladatokat jelenítse meg, és rendezze őket növekvő határidő szerint. Ügyfélkövetés: Szűrje ki azokat az ügyfeleket, akiknek az utolsó vásárlása több mint három hónapja történt, és rendezze őket tagsági állapot szerint.
Tanulmányi esetek
HR: Szűrje az értékesítési osztály alkalmazottait, és rendezze őket csökkenő fizetés szerint.
Értékesítési elemzés: Csak az utolsó negyedév eladásait szűrheti, és rendezheti őket csökkenő mennyiség szerint.
Haladó tippek és bevált gyakorlatok a big data kezeléséhez Ha az adatbázis növekedni kezd, és a szűrés vagy a rendezés eltart egy ideig, vegye figyelembe az alábbi javaslatokat: Jól konfigurált indexek: Indexelje azokat az oszlopokat, amelyek a leggyakrabban szűrnek és rendeznek a keresések felgyorsítása érdekében. Először a szűrőt alkalmazd, majd a rendezést: Kevesebb rekord feldolgozása mindig gyorsabb. Kerüld a túl bonyolult szűrőket egyetlen lekérdezésben. Bontsd le őket egyszerűbb lekérdezésekre, és szükség esetén később kombináld őket. Csak a megjeleníteni kívánt oszlopokat jelölje ki; a hatékonyság növelése érdekében kerülje az „összes kijelölése” lehetőséget. Tervező nézetben tiltsa le az automatikus frissítést nagyon összetett lekérdezések esetén, és dolgozzon egy mintával. Ha sok adatot kezel, érdemes lehet az információkat több kapcsolódó táblázatba osztani. Az Access szűrőinek további funkciói Ne felejtsd el, hogy az Access egy tölcsér ikonnal mutatja az oszlopfejlécben és a rekord navigációs sávján, ha van aktív szűrő. Ha egy szűrt mező fejléce fölé viszi az egérmutatót, egy elemleírás jelenik meg az aktuálisan alkalmazott szűrőfeltételekkel. Ez hasznos a feltételek gyors előhívásához anélkül, hogy az összes beállítást át kellene tekinteni.
2026. október 8., csütörtök
SQL alapismeretek Érettségizőknek
Az SQL nyelv
Az SQL (Structured Query Language) 1986-ban az Amerikai Szabványügyi Hivatal (ANSI) által szabványosított strukturált lekérdezônyelv, mely relációs adatmodell alapján felépülô adatbázisok kezelésére képes. Az SQL három résznyelvre bontható :
• SQL DDL, azaz az SQL adatdefiníciós nyelv; • SQL DML, azaz az SQL adatmanipulációs nyelv;
• SQL DCL, azaz az SQL adatvezérlô nyelv.
A továbbiakban a példákat mindig az alábbi adatbázisra vonatkoztatjuk:
Az SQL DDL alapjai
Adatbázis parancsok
Az adatbázis-parancsokat az alábbi táblázatban foglalhatjuk össze:
A parancs alakja: | A parancs funkciója: |
CREATE DATABASE adatbázisnév; | Adatbázis létrehozása |
SHOW DATABASE; | Információ egy adatbázisról |
START DATABASE adatbázisnév; | Adatbázis megnyitása |
STOP DATABASE; | Adatbázis bezárása |
DROP DATABASE adatbázisnév; | Adatbázis törlése |
Táblaparancsok
A táblázat létrehozása
A táblázat létrehozása
A táblázat definiálását az SQL-ben a CREATE TABLE parancs végzi. Általános alakja
CREATE TABLE táblanév (oszlopnév adattípus (méret) [,oszlopnév adattípus (méret)] );
Az oszlopneveknél az adattípus mellé beírható a NULL illetve a NOT NULL opció. Ez utóbbi azt jelenti, hogy a definiált táblában az adott oszlop kitöltése kötelezô. A gyakoribb SQL adattípusokat a következô táblázat tünteti fel:
Adattípus neve: | Jelentése: |
CHAR(n) | N hosszúságú string |
INTEGER | Egész szám -9 999 999 999 és 99 999 999 999 között |
SMALLINT | Egész szám -99 999 és 999 999 között |
DECIMAL(x,y) | Elôjellel együtt x számjegyû, fixpontos decimális szám y tizedesjeggyel, ahol x 1 és 19, y 0 és 18 közötti értéket vehet fel |
FLOAT(x,y) | Elôjellel együtt x számjegyû, lebegôpontos decimális szám y tizedes- jeggyel, ahol x 1 és 20, y 0 és 18 közötti értéket vehet fel |
DATE | Dátum típus |
LOGICAL | Logikai típus, értéke .T. és .F. lehet |
A különbözô adatbázis-kezelô programok SQL motorjai általában megengednek más adattípusokat is.Az Acces ’97 SQL pl. megengedi a BYTE, CURRENCY típusok használatát.
Lehetséges eltérés a szabvány táblakészítô utasítástól is. Az Access ’97 SQL például az elsôdleges kulcs kijelölésére más utasítást használ:
CREATE TABLE auto_csop (auto_csop_nev CHAR(6)NOT NULL PRIMARY KEY,km_dij INTEGER,napi_dij INTEGER);
CREATE TABLE auto_csop (auto_csop_nev CHAR(6)NOT NULL,km_dij
INTEGER,napi_dij INTEGER CONSTRAINT auto_csop_nev PRIMARY
KEY);
A táblázat módosítása
A táblázat módosítására az ALTER TABLE parancs szolgál. Általános alakja:
ALTER TABLE táblanév
ADD/MODIFY (oszlopnév adattípus [, oszlopnév adattípus]); Az Access’97 SQL itt is egy kicsit más:
ALTER TABLE auto_csop ADD megjegyzes CHAR(20);
ALTER TABLE auto_csop ADD COLUMN megjegyzes CHAR(20);
A tábla törlése
A tábla törlésére a katalógusból a DROP TABLE parancs szolgál. Alakja:
DROP TABLE táblanév;
Indextábla létrehozása
Az indexállomány egy adott táblából kiemelt néhány rendezett oszlopból áll. Az SQL-ben rendezett oszlopokból álló indextáblát a következô alakú parancs hozza létre:
CREATE [UNIQUE] INDEX indextábla-név ON táblanév
(oszlopnév [[ASC/DESC][,oszlopnév[ASC/DESC]]..);
A parancs hatása: Az ON után adott tábla felsorolt oszlopait rendezi (növekedôen ASC esetén és csökkenôen DESC esetén) és belôlük egy az INDEX szó után megadott nevû táblát készít. Az UNIQUE azt jelenti, hogy az oszlop értékei egyediek, s ha ez esetben ismétlôdô értékek is vannak az oszlopban, a rendszer hibát jelez.
Az SQL DML alapjai
Az SQL lekérdezôparancsa a SELECT parancs összetett parancs, több részparancsból áll.
A SELECT ... FROM alparancs
A SELECT ... FROM alparancs a projekció megvalósítására alkalmas. Általános alakja:
SELECT [DISTINCT] oszlopnév-lista FROM [táblanév];
A SELECT parancs hatására egy ideiglenes eredménytábla keletkezik. Amennyiben a DISTINCT szerepel, úgy az azonos értékek közül csak egyet választ ki az adott oszlopba. Az oszlopnév-lista elemei nemcsak oszlopnevek, hanem oszlopokból álló kifejezések, aggregáló (egyesítô) függvények, s más kifejezések is lehetnek.
A WHERE alparancs
A WHERE alparancs a szelekciót valósítja meg. Általános alakja:
WHERE feltétel
A parancs hatására az eredménytáblában a SELECT után felsorolt oszlopokba azoknak a soroknak az értékei kerülnek, amelyekre teljesül a feltétel. A feltételre vonatkozó szabályokat az alábbi táblázattal foglalhatjuk össze:
A feltétel típusa: | A feltétel alakja: | Az operátor: |
Egyszerû összehasonlítás | oszlopnév operátor kifejezés | =; != ;< ;> ;<> ;^= ; >=; <= |
Összehasonlítás egy halmaz eleme ivel | oszlopnév operátor halmazdef. | BETWEEN szám1 AND szám2; IN (lista) LIKE karakterminta |
Összehasonlítás NULL értékkel | oszlopnév IS NULL | |
Összetett kereséséi feltétel | feltétel1 operátor feltétel2 | AND; OR; NOT |
Néhány példa:
SELECT tipus_nev,ar FROM autok WHERE ar>1350000;
SELECT * FROM alkalmazott WHERE alk_nev LIKE ”H*”;
SELECT * FROM autok WHERE futott_km BETWEEN 120000 AND 200000;
A GROUP BY alparancs
A GROUP BY alparancs alakja:
GROUP BY oszlopnév [,oszlopnév] [HAVING feltétel]
A parancs hatására a megadott oszlop azonos értékei szerint csoportosítja a rekordokat.
Amennyiben szerepel a HAVING, az azt jelenti, hogy a GROUP BY által kialakított eredménytáblából kiválasztja azon sorokat, amelyek eleget tesznek a HAVING utáni feltételnek.
Fontosabb (csoport)függvények
INITCAP(kifejezés) | Nagy kezdôbetû, karakteres kifejezésekre vonatkozik |
LOWER(kifejezés) | Kisbetûs, karakteres kifejezésekre vonatkozik |
UPPER(kifejezés) | Nagybetûs, karakteres kifejezésekre vonatkozik |
AVG([DISTINCT|ALL] kifejezés) | Átlag, numerikus vonatkozik, a Null értéket figyelmen kívül hagyja. |
COUNT([DISTINCT|ALL] {*|kifejezés}) | Számláló, numerikus dátum és karakteres kifejezésre is vonatkozik, a Null értéket figyelmen kívül hagyja. |
MAX([DISTINCT|ALL] kifejezés) | Maximum, numerikus dátum és karakteres kifejezésre is vonatkozik. |
MIN([DISTINCT|ALL] kifejezés) | Minimum, numerikus dátum és karakteres kifejezésre is vonatkozik. |
SUM([DISTINCT|ALL] kifejezés) | Összeg, numerikus kifejezésre vonatkozik. |
ABS(kifejezés) | Abszolútérték, numerikus kifejezésre vonatkozik. |
SQRT(kifejezés) | Négyzetgyök, numerikus kifejezésre vonatkozik. |
Néhány példa:
SELECT reszleg_kod, COUNT(*) FROM alkamazott
GROUP BY reszleg_kod;
SELECT reszleg_kod,MIN(fizetes),
MAX(fizetes),SUM(fizetes),AVG(fizetes)
FROM alkamazott GROUP BY reszleg_kod;
Az ORDER BY alparancs
Az ORDER BY alparancs az eredménytábla rendezésére szolgál. Általános alakja:
ORDER BY oszlopnév [ASC/DESC][,oszlopnév [ASC/DESC]];
A parancs a megadott oszlop (vagy oszlopok) szerint rendezi az eredménytáblát, ASC megadása esetén növekedô sorrendben (ez az alapértelmezés is), DESC esetén csökkenô sorrendben. Példa:
SELECT * FROM alkalmazott
WHERE beosztas=”Elado” OR beosztas=”Szerelo”
ORDER BY fizetes DESC;
Virtuális tábla létrehozása
A virtuális tábla létrehozására a CRERATE VIEW parancs szolgál. Általános alakja:
CREATE VIEW táblanév [oszlopnévlista] AS SELECT [WITH CHECK OPTION]; A parancs hatására a SELECT parancs által generált eredménytáblának a VIEW után írt táblanevet adja az SQL és ennek a táblának az oszlopai az oszlopnévlistában felsorolt oszlopok lesznek. Amennyiben nem adunk meg oszlopnévlistát, akkor az eredménytábla nevei lesznek a VIEW tábla oszlopnevei.
Sorok bevitele a táblába
A parancs alakja:
INSERT INTO táblanév [(oszlopnév-lista)] VALUES (értéklista)/szelekciós utasítás; Példa:
INSERT INTO auto_csop (auto_csop_nev,km_dij,napi_dij)
VALUES ("Luxus",6000,8000);
A tábla rekordjainak módosítása
A parancs alakja:
UPDATE táblanév SET oszlopnév=kifejezés[,oszlopnév=kifejezés] [WHERE logikai kifejezés]; Példa:
UPDATE auto_csop SET napi_dij=8500
WHERE auto_csop_nev=”Luxus”;
A tábla rekordjainak törlése
A parancs alakja:
DELETE FROM táblanév [WHERE feltétel];
Az SQL DCL nyelv alapjai
Hozzáférési jogok adományozása
A táblákra vonatkozó jogosultság adományozása
A parancs formája:
GRANT ALL [PRIVILEGES]/ jogosultságlista ON [TABLE] táblalista
TO PUBLIC/felhasználólista [WITH GRANT OPTION];
A parancs minden jogot (ALL PRIVILEGES) vagy a jogosultságlistában szereplô mûveletekre való jogot adja a táblalistában szereplô táblákra mindenkinek (PUBLIC esetén) vagy a felhasználólistában szereplô személyeknek. Amennyiben a WITH GRANT OPTION szerepel, akkor az e jogokat kapók át is adhatják ezeket a jogokat másoknak. A jogosultságlista elemeit a következô táblázatban foglalhatjuk össze:
A jogosultság neve: | A jogosultság jelentése: |
ALTER | Jogosultság a tábla módosítására |
DELETE | Jogosultság a tábla törlésére |
INDEX | Jogosultság indextábla létrehozására |
INSERT | Jogosultság új sor felvételére a táblázatba |
SELECT | Jogosultság lekérdezésre |
UPDATE | Jogosultság a tábla módosítására |
Jogosultság adományozása az adatbázison végzett mûveletekre
A parancs formája:
GRANT adatbázisjog TO PUBLIC/felhasználólista
A parancs jogosultságot ad az adatbázisra vonatkozóan vagy mindenkinek (PUBLIC) vagy adott felhasználóknak a felhasználólista szerint.
Az adatbázisjogokat a következô táblázatban foglalhatjuk össze:
A jog neve: | A jog jelentése: |
CONNECT | - Hozzáférés a teljes adatbázishoz - Jog arra, hogy SELECT, INSERT, DELETE, UPDATE mûveleteket végezzen más felhasználók tábláin, ha ilyen jogosultságot kapott a táblákra vonatkozó GRANT-tal - Jog nézettáblák és szinonim táblák létrehozására. |
RESOURCE | - Minden CONNECT jogosultság - Jogosultság táblák és indextáblák létrehozására, jogosultságok adományozása ezekre a táblákra |
DBA | -Teljes adatbázis-adminisztrátori jogkör |
Jogosultságok visszavonása
Táblákra vonatkozó jogosultság visszavonása
A parancs formája:
REVOKE ALL [PRIVILEGES]/ jogosultságlista ON [TABLE] táblalista
TO PUBLIC/felhasználólista ;
A parancs hatása: Az összes jogosultságot (ALL PRIVILEGES vagy csak a jogosultságlistában felsoroltakat a megadott táblákra vonatkozóan mindenkitôl (PUBLIC) vagy csak a listában szereplô felhasználóktól visszavonja.
Adatbázis-jogosultságok visszavonása
A parancs formája:
REVOKE adatbázisjog FROM PUBLIC/felhasználólista ;
A parancs adatbázisjogokat mindenkitôl (PUBLIC) vagy a listában szereplôktôl visszavonja;
Minták feladatok megoldására;
Lekérdezésre példa
-- Az összes adat lekérése a "dolgozok" táblából
SELECT * FROM dolgozok;
-- Bizonyos oszlopok lekérése
SELECT nev, fizetes FROM dolgozok;
-----------------
Szűrésre példa
-- Pontos egyezés és numerikus összehasonlítás
SELECT * FROM dolgozok WHERE fizetes > 500000;
-- Mintaillesztés (pl. 'K' betűvel kezdődő nevek)
SELECT * FROM dolgozok WHERE nev LIKE 'K%';
-- Értéktartomány vizsgálata
SELECT * FROM dolgozok WHERE kor BETWEEN 25 AND 40;
-- Értékhalmaz megadása
SELECT * FROM dolgozok WHERE varos IN ('Budapest', 'Debrecen', 'Nyíregyháza');
---------------------
Rendezésre példa
-- Csökkenő fizetés szerinti rendezés, az első 10 találat
SELECT nev, fizetes FROM dolgozok
ORDER BY fizetes DESC
LIMIT 10;
--------------
Adatok összesítése és csoportosítása (GROUP BY, COUNT, AVG, SUM)
-- Átlagos fizetés városonként
SELECT varos, AVG(fizetes) AS atlag_fizetes
FROM dolgozok
GROUP BY varos;
-- Hány dolgozó van az egyes városokban
SELECT varos, COUNT(*) AS dolgozok_szama
FROM dolgozok
GROUP BY varos;
---------------
Táblák összekapcsolása (INNER JOIN)
-- Dolgozók és a hozzájuk tartozó részlegek lekérése
SELECT dolgozok.nev, reszlegek.reszleg_nev
FROM dolgozok
INNER JOIN reszlegek ON dolgozok.reszleg_id = reszlegek.id;
------------------
SQL WHERE szintaktika
A szintaktika alapvetően nagyon egyszerű, először jönnie kell a SELECT záradéknak, majd a FROM-nak és ezeket követi a WHERE.
SELECT oszlop(ok)
FROM tábla
WHERE feltétel(ek);
Code language: SQL (Structured Query Language) (sql)
A WHERE utasítás után kell meghatároznunk azokat a feltételt vagy feltételeket, amelyeket szeretnénk, ha teljesülni. Csak azok a rekordok kerülnek majd kilistázásra, amelyek teljesítik a feltételeket.
Természetesen a WHERE záradékot nem csak SELECT esetében lehet használni, hanem UPDATE, DELETE és egyéb utasítások esetében is. De ezek a későbbi leckékben részletesebben is kifejtésre kerülnek majd.
SQL WHERE operátorok
Fentebb pár szóban már említésre került, hogy a WHERE záradék esetében használhatók operátorok, lentebb egy részletes listát találtok az összes használható operátorról egy leírással és példával együtt.
De előtte soroljuk fel tételesen az SQL operátorait:
egyenlő operátor
nagyobb operátor
kisebb operátor
nagyobb vagy egyenlő operátor
kisebb vagy egyenlő operátor
nem egyenlő (NOT) operátor
AND operátor
OR operátor
BETWEEN operátor
LIKE operátor
IN operátor
Példa lekérdezésre
Másik példa
Az SQL (Structured Query Language) egy szabványos nyelv, amellyel adatokat kérdezhetünk le és módosíthatunk relációs adatbázisokban.
Egy alapvető SQL-lekérdezés (SELECT) szerkezete a következő részekből áll:
Alapvető szerkezet
• SELECT: Megadja, hogy mely oszlopokat szeretnénk megjeleníteni.
• FROM: Megjelöli azt a táblát vagy táblákat, ahonnan az adatokat lekérjük.
• WHERE: Opcionális feltétel, amellyel szűrhetjük a sorokat.
Egyszerű példa
sql
SELECT nev, kor
FROM felhasznalok
WHERE kor > 18;
Ez a parancs lekérdezi a felhasznalok táblából azon személyek nevét és korát, akiknek a kora nagyobb, mint 18.
Fontosabb kulcsszavak
• DISTINCT: Csak a egyedi (nem duplikált) értékeket mutatja.
• ORDER BY: Rendezés a megadott oszlop szerint (pl. ASC növekvő, DESC csökkenő).
• GROUP BY: Adatok csoportosítása aggregáló függvényekhez (pl. COUNT, SUM, AVG).
• JOIN: Több tábla összekapcsolása közös mezők alapján
Feliratkozás:
Bejegyzések (Atom)