A kérdés nagyon népszerű a kezdők körében, és helytelen lenne nem szentelni ennek külön cikket. Mint vele PHP használatával létrehozni egy kapcsolatot az adatbázissal? Azonnal elmondom, hogy a PHP-eszközök elégségesek az adatbázisokkal való teljes körű munkához és a MySQL-lel való interakcióhoz. Most pedig próbáljunk csatlakozni!
Mi kell a PHP és a MySQL összekapcsolásához?
1. Telepített DBMS és létrehozott működő adatbázist. Például a MySQL-ben (Mi az a DBMS és a MySQL?).2. Felhasználói fiók a MySQL-hez megfelelő jogosultságokkal (Mik azok a jogok és kiváltságok a MySQL-ben?)
3. Ennek megfelelően egy szerver PHP-vel
Ha nem hajtja végre a fenti lépések egyikét, nem tud csatlakozni.
Algoritmus a PHP és a MySQL közötti interakcióhoz
1. Csatlakozás az adatbázishoz2. Kérelem küldése és az eredmény kézhezvétele
3. (Preferált) A kapcsolat lezárása
Most PHP segítségével csatlakozunk az adatbázishoz:
PHP kód
$db = mysql_connect("localhost", "Admin", "pass"); // felhasználói adatok
mysql_select_db("alapnév",$db); // válassza ki, hogy melyik adatbázishoz csatlakozzon
?>
Mint látható, négy paraméter van megadva a csatlakozáshoz:
1.
Gazdanév. Sok esetben elég a localhost megadása (ugyanazon a tárhelyen).
2.
A MySQL használatához regisztrált felhasználó neve.
3.
A MySQL használatához regisztrált felhasználó jelszava.
4.
Annak az adatbázisnak a neve, amelyhez csatlakozni szeretnénk. Ennek megfelelően az általunk megadott felhasználónak rendelkeznie kell jogosultsággal az adatbázisban való munkavégzésre.
Ennek eredményeként, ha valamit hibásan jeleznek, akkor semmi bűncselekmény nem történik, de valószínűleg hibát fog látni. De legyünk optimisták, mondjuk mindent helyesen adott meg.
Egy másik típusú kapcsolat:
PHP kód
$host="localhost"; /*házigazda*/
$user="admin"; /*Felhasználónév*/
$password="12345"; /*Felhasználói jelszó*/
$db="alapnév"; /*Adatbázis neve*/
Mysql_connect($host, $felhasználó, $jelszó); /*Csatlakozás a szerverhez*/
mysql_select_db($db); /*Csatlakozás a szerveren lévő adatbázishoz*/
?>
Itt vizuálisan létrehozok változókat példaadatokkal a felhasználó és a gazdagép számára, majd létrehozok egy kapcsolatot.
Hogyan lehet megszakítani (bezárni) egy kapcsolatot egy adatbázissal PHP-ben?
Vannak esetek, amikor a csatlakozási információ helytelenül van megadva. Ebben az esetben a szkript folytatja a PHP-fájl feldolgozását, és bizonyos számú hibát és figyelmeztetést jelenít meg az oldalon. Ilyen esetekben azt javaslom, hogy használjon hibakezelőt az adatbázishoz való csatlakozáskor. Ha a kapcsolat sikertelen, figyelmeztetést kap, amely megmondja, hogy melyik szakaszban van a probléma:PHP kód
$user="admin";
$password="12345";
$db="alapnév";
// ha hiba történt
mysql_connect($host, $user, $password) or die("A MySQL szerver nem elérhető!".mysql_error());
mysql_select_db($db) or die("Nincs kapcsolat az adatbázissal."mysql_error());
?>
Nagyon fontos az is, hogy a forgatókönyv fejlesztése leálljon, ami sok hibás adattól kíméli meg Önt.
Gratulálok! Most már tudja, hogyan csatlakozhat egy adatbázishoz PHP-ben, és zárja be a kapcsolatot!
Köszönöm a figyelmet!
A MySQL szerver telepítése után csak ugyanarról a gépről tud csatlakozni hozzá. Erre rendszerbiztonsági okokból került sor, mivel a legtöbb esetben MySQL-t használnak a weben, és ott ritka esetekben a webszerver és az adatbázisszerver elválik egymástól.
A vállalati szegmensben minden hasonló feladatra helyesebb 1 szervert használni. Hülyeség a MySQL-t egy adatbázissal tartani minden szerveren, amelyiknek szüksége lehet rá. Ezért egy adatbázis-kiszolgálónak kell lennie, amelyre a különböző feladatokhoz szükséges számú adatbázis telepítve van.
A weben egyébként az adatbázisszervert és a webszervert csak olyan esetekben választják el, amikor egy szerver teljesítménye nem elég. Bérel egy dedikált szervert, és azon tárolod az adatbázist. Szeretném tisztázni, hogy ezt csak egy DC-n belül célszerű megtenni.
A MySQL-hez való távoli csatlakozás engedélyezése
A MySQL konfigurációs fájljában van egy paraméter kötési cím aki ezért felelős, tehát:
- nyitott konfigurációs fájl szerkesztéshez:
sudo nano /etc/mysql/my.cnf - kommentálja a sort:
# kötési cím = 127.0.0.1 - indítsa újra a MySQL-t:
sudo szolgáltatás mysql újraindítás
Ennek a sornak a megjegyzése egyenértékű az IP-cím hozzárendelésével 0.0.0.0 , azaz mindenki csatlakozhat. Ebben a sorban nem adhat meg 2 IP-címet. Ha korlátozni kell a kapcsolatot a MySQL szerverrel, akkor az iptables képességeit kell használnia.
Most már csatlakozhat az adatbázis-kiszolgálóhoz egy telnet kliensen keresztül, de ahhoz, hogy belépjen a rendszerbe, szüksége van rá fiókot, amely nem csak a localhost-ról csatlakozhat. Ehhez magáról a szerverről kell csatlakoznia a MySQL-hez, és létre kell hoznia a következő felhasználót:
Mysql -u root -p
És hozzon létre egy felhasználót a következő paranccsal:
MINDEN KIVÁLTSÁG ELADÁSA A *.* SZÁMÁRA: "új_felhasználó"@"távoli_cím" A "jelszó" ALAPJÁN AZONOSÍTJA A BRANT OPTION;
Ez a sor korlátlan jogokkal rendelkező felhasználót hoz létre, ami nem teljesen helyes. Helyesebb a lehető legnagyobb mértékben korlátozni a távolról csatlakozó felhasználó hozzáférését. Tehát a parancs így nézhet ki:
KIVÁLASZTÁS, BEHELYEZÉS, TÖRLÉS, FRISSÍTÉS, LÉTREHOZÁS, MÓDOSÍTÁS AZ "adatbázis_neve"-en.* AZ "ÚJ_FELHASZNÁLÓ"@"Távoli_cím" A "JELSZÓ" AZONOSÍTÁSA ENGEDÉLYEZÉSI OPCIÓVAL;
Ezzel a paranccsal csak egy adatbázisra és a vele végzett műveletekre korlátoztuk a felhasználó jogosultságait.
A felhasználó számára megadható jogok teljes listája:
- MINDEN KIVÁLTSÁG– minden jog a megadott objektumhoz, kivéve a jogok hozzárendelését ehhez az objektumhoz;
- TEREMT– táblázat létrehozásának joga;
- VÁLTOZTAT– az asztalváltás joga;
- CSEPP– az asztal megsemmisítésének joga;
- LOCK ASZTALOK– az asztal lezárásának joga;
- IDEIGLENES TÁBLÁZATOK LÉTREHOZÁSA– ideiglenes táblák létrehozásának joga;
- RUTIN LÉTREHOZÁSA– tárolt eljárások és funkciók létrehozásának joga;
- ALTER RUTINE– a tárolt eljárások és funkciók megváltoztatásának vagy megsemmisítésének joga;
- NÉZET LÉTREHOZÁSA– képviselet létrehozásának joga;
- TRIGGER– a kiváltó okok létrehozásának és megsemmisítésének joga;
- INDEX– indexek létrehozásának és megsemmisítésének joga;
- VÉGREHAJTÁS– a tárolt eljárások és funkciók végrehajtásának joga;
- ESEMÉNY– rendezvények létrehozásának joga;
- FELHASZNÁLÓ LÉTREHOZÁSA– jogosultság egy felhasználó létrehozására, megsemmisítésére, átnevezésére és az összes jog eltávolítására. Csak globális szinten nevezik ki;
- KIVÁLASZTÁS– mintavételi jog;
- TÖRÖL– törléshez való jog;
- BESZÁLLÍTÁS– beillesztési jog;
- FRISSÍTÉS– frissítés joga;
- FÁJL– a SELECT ... INTO OUTFILE és LOAD DATA INFILE parancsok használatának joga;
- FOLYAMAT– az összes folyamat megtekintésének joga a SHOW PROCESSLIST paranccsal;
- ADATBÁZISOK MUTATÁSA– a programok listájának megtekintésének joga;
- NÉZET MEGUTATÁSA– a nézetek listájának megtekintésének joga;
- LEÁLLÍTÁS– bezáráshoz való jog.
Ebben a mai cikkben az adatbázisokkal való kapcsolat létrehozásáról fogunk beszélni, és megvitatjuk, hogy melyik opciót érdemesebb eljárási vagy objektumorientált használni. Először is nézzük meg, hogy milyen szinten állunk, ha ez egy teljesen kezdő szint, akkor kivétel nélkül azt tanácsolom, hogy kezdjük el az adatbázishoz való csatlakozás procedurális stílusát használni. Korábban írtam egy cikket erről a témáról a blogomban, ha többet szeretne megtudni az adatbázishoz való csatlakozás eljárási stílusáról, olvassa el a következő cikket: „Hogyan kapcsolódjunk a MySQL-hez PHP segítségével”. Ha már van némi tapasztalata az adatbázishoz való kapcsolódás eljárási stílusával kapcsolatban, akkor valószínűleg Ön is, mint én, most vette át a projektjeimet, és objektum-orientált megközelítés alkalmazására kényszerítette őket.
Így vagy úgy, most elemezzük egy osztály felépítésének szakaszait az adatbázishoz való kapcsolat létrehozásához MySQL adatok-on PHP nyelv. Két PHP fájlra lesz szükségünk, az egyik fájlba „betesszük” az adatbázis-kapcsolat létrehozásához szükséges osztályt, a másikba pedig ezzel az osztállyal fogunk dolgozni.
Hozzunk létre két fájlt:
- index.php;
- adatbázis.osztály.php;
Azt hiszem, már nem vagyunk kisgyerekek, és tudjuk, mire van szükségünk a PHP fájlokkal való munkához. Telepített web- Apache szerver, PHP, MySQL DBMS és tudja, hova kell ezeket a fájlokat elhelyezni - (azoknak, akik nem ismerik vagy elfelejtették).
Beraktam azt a fájlt, amiben az osztály van tárolva külön fájlés a következő formátumban nevezem el: osztálynév.osztály.php, és tudom, hogy mi van ebben a fájlban. Ha sok osztály van egy projektben, eltévedhet, ezért azt javaslom, hogy a fájlokat osztályokkal nevezze el a fent leírt formátumban.
Database.class.php fájl:
Most nézzük meg, mi alapján készült ezt a lépést. A "class" kulcsszó, az osztálynév - DataBase és a kapcsos zárójelek felhasználásával létrehoztuk az osztály törzsét. A létrehozott osztályban két tulajdonságot hoztunk létre, a $mConnect-ben - ahol az adatbázishoz való kapcsolódás eredménye és a $mSelectDB-ben - ahol az adatbázis kiválasztásának eredménye tárolódik. Lehet, hogy észrevette a kulcsszavakat minden ingatlanban – nyilvános és statikus. miről beszélnek? Nyilvános azt jelenti, hogy a tulajdonság elérhető az osztályon kívülről, a static pedig lehetővé teszi a tulajdonság elérését vagy felhívását anélkül, hogy az osztályból példányt hozna létre, ami nagyon gyakran kényelmes a munkában.
Adjuk hozzá a Connect() metódust az adatbázishoz való kapcsolat létrehozásához:
".mysql_error()."
"; exit(); return false; ) // Az eredmény visszaadása return self::$mConnect; ) ) ?>- $host - szerver IP-címe, helyi PC-n localhost;
- user - adatbázis felhasználónév;
- $pass - adatbázis felhasználói jelszó;
- $name - annak az adatbázisnak a neve, amelyhez csatlakozunk;
A mysql_connect() függvény kapcsolatot hoz létre az adatbázissal, és a végrehajtás eredményét a $mConnect mappában tárolja. Ezután jön az IF konstrukció ellenőrzése: Ha a kapcsolat nem volt sikeres, jelenítsen meg egy hibaüzenetet... Ellenkező esetben a PHP figyelmen kívül hagyja az IF blokkot, és továbblép az adatbázis kiválasztásához. A mysql_select_db() függvény kiválasztja az adatbázis nevét, ha a kért adatbázis nem létezik az adatbázisban, ebben az esetben a program hibáról értesíti a felhasználót. Ha minden sikeres, az adatbázis-kapcsolat visszatér.
Adja hozzá a Close() metódust:
Sajnáljuk, nem tudtunk csatlakozni a MySQL szerverhez
"; exit(); return false; ) // Próbáljon meg kiválasztani egy saját adatbázist::$mSelectDB = mysql_select_db($name, self::$mConnect); // Ha az adatbázis nincs kiválasztva, hibaüzenetet jelenítsen meg. if( !self::$mSelectDB) ( echo "".mysql_error()."
"; exit(); return false; ) // Az eredmény visszaadása return self::$mConnect; ) // A metódus lezárja a kapcsolatot az adatbázissal nyilvános statikus függvény Close() ( // Az eredményt adja vissza mysql_close(self: :$mConnect) ; ) ) ?>Az osztály következő és utolsó metódusa, a Close() lezárja a kapcsolatot az adatbázissal a mysql_close() függvény bezárja a kapcsolatot a MySQL szerverrel, és visszaadja az eredményt.
Index.php fájl:
A define() függvény segítségével konstansokat hoztunk létre az adatbázis-kapcsolat paramétereinek tárolására. A Require_once tartalmazza a DataBase osztályunkat az index.php fájlban.
Emlékezzünk kulcsszó static, amelyet a DataBase osztályban használtak ennek az osztálynak a tulajdonságaiban és metódusaiban. Ez lehetővé teszi számunkra, hogy hozzáférjünk az osztálytulajdonságokhoz és metódusokhoz a "::" (két kettőspont) használatával. A DataBase::Connect(DB_SERVER, DB_USERNAME, DB_PASSWORD, DB_DATABASE) metódus 4 paramétert vesz fel - a define() függvény által létrehozott konstansokat, amelyek információkat tárolnak az adatbázishoz való csatlakozásról. Ha a kapcsolat sikeres, a Connect() metódus visszaad nekünk egy adatbázis-kapcsolatot. Ezután már dolgozhatunk és lekérdezéseket hajthatunk végre az adatbázisban. mysql_query() függvény – lekérdezést hajt végre az adatbázisban. A mysql_fetch_assoc() függvény egy sor lekérdezési eredményt dolgoz fel, és egy asszociatív tömböt ad vissza. Az echo konstrukció a MySQL szerver verzióját jeleníti meg. És végül a DataBase::Close() metódus lezárja az adatbázishoz való kapcsolatot.
php használatával...
Adatbázishoz való kapcsolat létrehozása PHP-ben különböző módokon:
1) a MySQL-hez való csatlakozás régimódi módja:
$conn=mysql_connect($db_hostname, $db_username, $db_password) vagy die ("Nincs kapcsolat a szerverrel");
mysql_select_db($db_database,$conn) or die ("Nem, nem lehetett csatlakozni az adatbázishoz");
A változók magyarázata alább.
A következő funkciókat használják:
- mysql_connect()- csatlakozni a szerverhez;
- mysql_select_db()- csatlakozni az adatbázishoz;
Ugyanakkor folyamatosan ilyen módon ellenőrizzük a hibákat: or die ("A hiba ilyen és olyan"); - lefordítva vagy meghalni ilyen-olyan hibával -, hogy azonnal megtalálják, hol van a hiba.
config.php
// változók az adatbázishoz való csatlakozáshoz
$host = "localhost"; /házigazda
$felhasználónév = "root"; // jelszó az adatbázishoz való csatlakozáshoz
$jelszó = ""; // jelszó az adatbázishoz való csatlakozáshoz - be helyi számítógép lehet, hogy üres az értéke.
$adatbázis_neve = "saját-dolgi"; // adatbázis neve
// régi módja az adatbázishoz való kapcsolódásnak
mysql_connect($host, $felhasználónév, $jelszó) or die("Nem lehet csatlakozni kapcsolat létrehozása");
// válassza ki az adatbázist. Ha hiba van, adja ki
mysql_select_db($adatbázis_neve) vagy die(mysql_error());
index.php
request_once "config.php";
$result = mysql_query("SELECT Név, Pénz FROM Dolgból ORDER BY Money DESC LIMIT 5") or die(mysql_error());
";
while ($sor = mysql_fetch_assoc($eredmény)) (
";
}
mysql_free_result($eredmény);
// Zárja be a kapcsolatot
mysql_close();
2) Progresszívebb eljárási stílus - csatlakozás az adatbázishoz mysqli használatával:
Ez a módszer:
- kényelmesebb;
- akár 40-szer gyorsabb;
- fokozott biztonság;
- új szolgáltatások és funkciók vannak;
Példa egy adatbázishoz való csatlakozásra PHP-ben egy táblázatból történő kijelöléssel
config.php
// kapcsolatok az adatbázishoz
$link = mysqli_connect("localhost", "felhasználónév", "jelszó", "név-adatbázis"); // itt közvetlenül megadjuk az adatait: felhasználónév, jelszó és adatbázisnév, az első mező általában localhost
// kimeneti csatlakozási hiba
if (!$link) (
echo "Hiba az adatbázishoz való csatlakozáskor. Hibakód: " . mysqli_connect_error();
kijárat;
}
Figyelem, a mysqli-t mindenhol használják, nem a mysql-t!!!
index.php
request_once "config.php";
// Hajtsa végre a kérést. Ha hiba van, megjelenítjük
if ($eredmény = mysqli_query($link,"VÁLASZTÁSA Név, Pénz az adósságból ORDER BY Money DESC LIMIT 5")) (
Echo "Kinek tartozom csökkenő sorrendben:
";
// Lekérdezés eredményeinek lekérése
while ($sor = mysqli_fetch_assoc($eredmény)) (
echo $row["Név"] . "tartozással". $row["Pénz"] . "rubelt.
";
}
// használt memória felszabadítása
mysqli_free_result($eredmény);
// Zárja be a kapcsolatot
mysqli_close($link);
}
Mint látható, néhány pont megváltozott (dőlt betűvel).
3) Objektum-orientált módszer a MySQL adatbázishoz való csatlakozáshoz - metódusok és osztályok használatával:
Hátrányok: Bonyolultabb és kevésbé érzékeny a hibákra.
Előnyök: rövidség és kényelem a tapasztalt programozók számára.
$conn = new mysqli($db_hosztnév, $db_felhasználónév, $db_jelszó, $db_adatbázis);
if($conn->connect_errno)(
die($conn->connect_error);
) else (echo "Az adatbázishoz való kapcsolat sikeresen létrejött";)
itt elvileg minden intuitív:
- $db_hostname van házigazda(többnyire localhost),
- $db_adatbázis - db név;
- $db_username és $db_password - felhasználónév és jelszó rendre!
Példa adatbázishoz való csatlakozásra php OOP stílusban táblából való mintavételezéssel
config.php
// kapcsolatok az adatbázishoz
$mysqli = new mysqli("localhost", "felhasználónév", "jelszó", "név-adatbázis"); // itt közvetlenül megadjuk az adatait: felhasználónév, jelszó és adatbázisnév, az első mező általában localhost
// kimeneti csatlakozási hiba
if ($mysqli->connect_error) (
die ("DB kapcsolódási hiba: (" . $mysqli->connect_errno . ") " . mysqli_connect_error) ;
}
Figyelem - mysqli-t használnak mindenhol, nem mysql-t!!! és az előző módszerrel ellentétben megjelennek a „->” nyilak, amelyek jelzik, hogy ez egy OOP stílus.
index.php
request_once "config.php";
// Hajtsa végre a kérést. Ha hiba van, megjelenítjük
if ($eredmény = $ mysqli-> lekérdezés("Válasszon nevet, pénzt az adósságból ORDER BY Money DESC LIMIT 5")) (
Echo "Kinek tartozom csökkenő sorrendben:
";
// Lekérdezés eredményeinek lekérése
while ($sor = $eredmény-> fetch_assoc()) {
echo $row["Név"] . "tartozással". $row["Pénz"] . "rubelt.
";
}
// használt memória felszabadítása
$eredmény->bezárás();
// Zárja be a kapcsolatot
$mysqli-> bezár();
}
Az Ön feladata, hogy megtalálja a különbségeket.
4) Kommunikáció az adatbázissal OEM használatával:
Amikor MySQL adatbázishoz csatlakozunk, előkészített kifejezéseket használunk (a előkészítő módszerrel), aminek eredményeként nagyobb biztonság és nagymértékben nő a teljesítmény.
konfigurációs fájl az előző módszerből! - ugyanaz
index.php
// PDO stílus a MySQL-lel való kommunikációhoz
if ($stmt = $mysqli->prepare("SELECT Név, Voney FROM Dolg ORDER BY Money< ? LIMIT 5")) {
$stmt->bind_param("i", $summa);
$summa = 100000;
//végrehajtás indítása
$stmt->execute();
// Változók deklarálása előkészített értékekhez
$stmt->bind_result($col1, $col2);
Echo "Kinek tartozom csökkenő sorrendben:
";
// Lekérdezés eredményeinek lekérése
while ($stmt->fetch()) (
echo $col1 . "tartozással". $col2 . "rubelt.
";
}
// használt memória felszabadítása
$stmt->close();
// Zárja be a kapcsolatot
$mysqli->close();
Amint látja, ez sokkal bonyolultabb, és tanulmányoznia kell az OEM - ez egy külön téma.
3 módszer a MySQL-hez való csatlakozáshoz PHP-vel, kódpéldákkal
A MySQL adatbázis használatának megkezdéséhez először meg kell értenie, hogyan csatlakozhat egyéni PHP programjából (script) ehhez a MySQL adatbázishoz.
Ez a cikk a következő három módszert írja le, valamint a megfelelő PHP kódpéldákat, amelyek elmagyarázzák, hogyan lehet csatlakozni az adatbázishoz PHP-ből.
Az összes alábbi példa esetében egy meglévő MySQL adatbázishoz fogunk kapcsolódni. Megjegyzés: Az itt leírtak a MariaDB-vel is működni fognak, akárcsak a MySQL.
1. Csatlakozás PHP-hez a mysqli kiterjesztéssel
*A mysqli azt jelenti, hogy MySQL javított
Hozd létre a következő mysqli.php fájlt
connect_error) ( die("Hiba: nem lehet csatlakozni: " . $conn->connect_error); ) echo "Csatlakozva az adatbázishoz.
"; $eredmény = $conn->query("SELECT id FROM goroda"); echo "Sorok száma: $eredmény->sorok száma"; $result->close(); $conn->close(); ?> A fenti kódban:
- mysqli – Ez a függvény új kapcsolatot kezdeményez a mysqli kiterjesztéssel. A függvénynek négy argumentuma van:
- A localhost annak a gazdagépnek a neve, amelyen a MySQL adatbázis fut
- név – MySQL felhasználónév a csatlakozáshoz
- pass - jelszó a mysql felhasználó számára
- db - MySQL adatbázis, amelyhez csatlakozni kell.
- qvery - függvény MySQL lekérdezés. Ebben a példában az id oszlopot választjuk ki a város adatbázisából.
- Végül megmutatjuk a kiválasztott sorok számát a sorszám_szám változó segítségével az eredményben. Az eredményt és a kapcsolódási változót is bezárjuk a fentiek szerint.
Csatlakozva az adatbázishoz. Sorok száma: 6 2. Csatlakozás innen PHP MySQL OEM kiterjesztése
*A PDO a PHP Data Objects rövidítése
A PDO_MYSQL illesztőprogram a PHP által biztosított PDO interfészt valósítja meg a PHP szkriptből a MySQL adatbázishoz való csatlakozáshoz.
Hozza létre a következő mysql-pdo.php fájlt:
setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Csatlakoztatva az adatbázishoz.
"; $sql = "VÁLASZTÁS IDŐT A gorodából"; nyomtatás "Az azonosítók listája:
"; foreach ($conn->query($sql) mint $row) ( print $row["id"] . "
- "; ) $conn = null; ) catch(PDOException $err) ( echo "Hiba: Nem lehet csatlakozni: " . $err->getMessage(); ) ?> A fentiekben:
- new PDO - létrehoz egy új PDO objektumot, amely a következő három argumentumot veszi fel:
- mysql connect string: „mysql:host=localhost;dbname=db” formátumban lesz. A fenti példában a db localhoston fut, és mi csatlakozunk a db adatbázishoz.
- MySQL felhasználónév a csatlakozáshoz
- Mysql felhasználói jelszó $sql változó - létrehozás sql lekérdezés
- amelyet végrehajtani szeretne. Ebben a példában kiválasztjuk az id oszlopot a városok táblázatából.
- query($sql). Itt az imént létrehozott sql lekérdezést hajtjuk végre.
- foreach. Itt iteráljuk a fenti lekérdezési parancs eredményét, és tároljuk a $row változóban, majd echo segítségével kiadjuk.
Csatlakozva az adatbázishoz. Listaazonosító: 1 2 3 4 5 6 3. Csatlakozás PHP-ről elavult mysql függvényekkel
Ezt a módszert csak akkor használja, ha többet használ régi verzió PHP és valamiért nem tudod frissíteni új verzió. E módszer helyett javasolt a fent bemutatott 2. és 3. módszer használata. Ezt a módszert csak referenciaként adtam meg, nem pedig használati ajánlásként.
Ezt a bővítményt megszüntette PHP verziók 5.5. De a PHP 7.0-tól kezdve ez nem is működik, mivel eltávolították. A PHP 5.5 óta, amikor ezeket a függvényeket használja, E_DEPRECATED hibát generál.
Hozzon létre egy mysql.php fájlt:
"; $eredmény = mysql_query("SELECT ID FROM goroda"); $row = mysql_fetch_row($result); echo "id 1: ", $row, "
\n"; mysql_close($conn); ?> A fentiekben:
- A mysql_connect függvénynek három argumentuma van:
- annak a gazdagépnek a neve, ahol a MySQL adatbázis fut;
- MySQL felhasználónév a csatlakozáshoz;
- mysql felhasználó jelszava. Itt csatlakozik a MySQL adatbázishoz, amely a helyi szerveren fut a felhasználónév és a jelszó használatával.
- mysql_select_db függvény. Ahogy a neve is sugallja, kiválasztja azt az adatbázist, amelyhez csatlakozni kíván. Egyenértékű a "use" paranccsal. Ebben a példában egy db adatbázishoz kapcsolódunk.
- mysql_query függvény – a MySQL lekérdezés megadására szolgál. Ebben a példában az id oszlopot választjuk ki a városi adatbázisból. mysql_fetch_row. Ezzel a funkcióval sorokat vonhat ki az imént létrehozott SQL-lekérdezésből.
- Végül zárja le a kapcsolatot a mysql_close paranccsal a fent látható módon.
Csatlakozva az adatbázishoz. id 1: 1 Így csatlakozhat a MySQL-hez. Ismétlem, jobb az első két módszert használni; O