Csapattag rendelés vendég php. A PHP MySqli használatának alapjai. Régi bejegyzések törlése
A támogatás megszűnése miatt PHP MySQL 2011-ben OEM vagy MySqli. Jobb funkcionalitással rendelkeznek (mint a MySQL), és OOP (Object Oriented Interface) API-t kínálnak. Hogy melyik a jobb, az egy másik cikk témája, ebben a cikkben megpróbáljuk megérteni a MySqli használatának alapjait. Ezért minden további nélkül folytassuk a rekordok (adatok/dokumentumok/információ) összekapcsolását, kiválasztását, beszúrását, frissítését és törlését a PHP MySqli használatával. Remélem, hogy ez a cikk hasznos lesz a PHP MySqli használata során felmerülő problémák megoldásában.
MySqli telepítése
Használata PHP verziók 5.3.0+, a MySqli alapértelmezés szerint elérhető; régebbi verziók esetén, hogy elérhető legyen, a php_mysqli.dll DLL-t bele kell foglalnia a fájlba php.iniés szerkessze a php.ini fájlt az extension=php_mysqli.dll sor megjegyzésének törlésével. Linuxon a MySQLIi automatikusan települ a PHP5 mysql csomag telepítésekor. Több részletes információk a beépítésről windows rendszerekés linux is megtalálható.
Adatbázis kapcsolat
A MySqli két módot kínál az adatbázishoz való csatlakozásra: eljárási és objektumorientált. Objektumorientált használata javasolt. A procedural hasonló a (régi) MySql-hez, ezért lehet, hogy az újoncok számára előnyösebb, de érdemes megjegyezni, hogy nem ajánlott.
PHP
//eljárási stílus $mysqli = mysqli_connect("host","felhasználónév","jelszó","adatbázis_neve"); //objektum-orientált stílus (ajánlott) $mysqli = new mysqli("host","felhasználónév","jelszó","adatbázis_neve");Az alábbiakban bemutatjuk, hogyan lehet objektumorientált módon megnyitni egy kapcsolatot egy adatbázissal. Ezt a módszert alkalmazzuk az alábbi példákban.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) ?>Az eredményül kapott sorozat kiválasztása (SELECT) asszociatív tömbként
mysqli_fetch_assoc() : Az alábbi kód lekéri az eredménysorozatot, mint asszociatív tömb. A visszaadott tömb az adatbázisból visszakeresett sorokat tartalmazza, ahol az oszlopnevek lesznek a belső adatok eléréséhez használt kulcsok. Az alábbiak szerint az adatok HTML-táblázatként jelennek meg.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) //MySqli Select Query $results = $mysqli->| ".$row["id"]." | "; nyomtat"".$row["product_code"]." | "; nyomtat"".$row["terméknév"]." | "; nyomtat"".$row["product_desc"]." | "; nyomtat"".$sor["ár"]." | "; nyomtat"
Az eredményül kapott sorozat kiválasztása (SELECT) tömbként (asszociatív, reguláris vagy mindkettő)
fetch_array() függvény: egy tömböt ad vissza a mysqli_fetch_row és a mysqli_fetch assoc kombinált funkcióival. Ez a függvény a mysqli_fetch_row() függvény kiterjesztett változata; Az adatok eléréséhez karakterláncot vagy számokat használhat.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) //MySqli Select Query $results = $mysqli->query("SELECT id, product_code, product_desc , ár A termékektől"); nyomtatni"| ".$row["id"]." | "; nyomtat"".$row["product_code"]." | "; nyomtat"".$row["terméknév"]." | "; nyomtat"".$row["product_desc"]." | "; nyomtat"".$sor["ár"]." | "; nyomtat"
Az eredménysorozat objektumként való kiválasztása (SELECT).
fetch_object() : Ahhoz, hogy az eredménykészletet objektumként kapja meg, a MySqli fetch_object() parancsot kell használnia. Az objektum attribútumai megjelenítik az eredménykészletben található mezők nevét.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) //MySqli Select Query $results = $mysqli->query("SELECT id, product_code, product_desc , ár A termékektől"); nyomtatni"| ".$row->id." | "; nyomtat"".$row->product_code." | "; nyomtat"".$sor->terméknév." | "; nyomtat"".$row->product_desc." | "; nyomtat"".$sor->ár." | "; nyomtat"
Egyetlen érték kiválasztása (SELECT).
Egyetlen érték lekérhető az adatbázisból a fetch_object (Cameron Spear módszer) segítségével.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) //láncolt PHP függvények $product_name = $mysqli->query("SELECT terméknév A termékekből WHERE id = 1")->fetch_object()->product_name; nyomtatás $termék_neve; //kimeneti érték $mysqli->close(); ?>A táblázatban lévő sorok számának lekérése (SELECT COUNT).
Néha tudnia kell egy táblázat sorainak számát, különösen az oldalak számozásánál.
PHP
connect_error) ( die("Hiba: (". $mysqli->connect_errno .") ". $mysqli->connect_error); ) //rekordok teljes számának lekérése $results = $mysqli->query("SELECT COUNT(* ) A felhasználóktól"); $get_total_rows = $eredmények->fetch_row(); //összes rekord tartása a $mysqli->close(); ?>KIVÁLASZTÁS előkészített utasítások segítségével
elkészített nyilatkozatok- egy speciális DBMS eszköz, amely lehetővé teszi az ugyanazon sablon szerint felépített ismétlődő lekérdezések szekvenciális végrehajtásának felgyorsítását.
A MySqli egyik jellemzője a már megírt sablonok használatának lehetősége: vagyis csak egyszer kell egy lekérdezést megírni, ami után sokszor végrehajtható különböző paraméterekkel. A már megírt sablonok használata javítja a teljesítményt nagy táblák és összetett lekérdezések esetén. A rosszindulatú kódok bejutásának megakadályozása érdekében a szerver minden kérést külön-külön elemz.
Az alábbi kód egy sablont (Előkészített utasítás) használ az adatok lekéréséhez az adatbázisból. Összesített ? SQL lekérdezésben jelölőként működik, és egy paraméter helyettesíti, ami viszont lehet karakterlánc, egész szám, kettős vagy blob. Esetünkben ez a $keresési_termék karakterlánc.
PHP
$keresés_termék = "PD1001"; //termékazonosító //elkészített utasítás létrehozása $query = "SELECT id, product_code, product_desc, price FROM products WHERE product_code=?"; $nyilatkozat = $mysqli->prepare($query); //meghatározási paraméterek jelölőkhöz, ahol (s = string, i = egész szám, d = double, b = blob) $utasítás->bind_param("s", $kereső_termék); //lekérdezés végrehajtása $statement->execute(); //eredményváltozók összerendelése $utasítás->| ".$id." | "; nyomtat"".$product_code." | "; nyomtat"".$product_desc." | "; nyomtat"".$ár." | "; nyomtat"
Ugyanaz a kérés több paraméterrel:
PHP
$keresés_azonosító = 1; $keresés_termék = "PD1001"; $query = "SELECT id, product_code, product_desc, price FROM products WHERE ID=? AND product_code=?"; $nyilatkozat = $mysqli->prepare($query); $utasítás->bind_param("is", $keresés_azonosító, $kereső_termék); $utasítás->végrehajtás(); $kimutatás->bind_result($id, $termékkód, $termékleírás, $ár); nyomtatni"| ".$id." | "; nyomtat"".$product_code." | "; nyomtat"".$product_desc." | "; nyomtat"".$ár." | "; nyomtat"
BEHELYEZÉS egy rekordot
Az alábbi bejegyzés új sort szúr be a táblázatba.
PHP
real_escape_string("P1234")."""; $termék_neve = """.$mysqli->real_escape_string("42 hüvelykes TV")."""; $product_price = """.$mysqli->real_escape_string("600 ")."""; //MySqli beszúrási lekérdezés $beszúrás_sor = $mysqli->query("INSERT INTO termékek (termékkód, terméknév, ár) VALUES($termékkód, $terméknév, $termék_ára)"); if($beszúrás_sor )( print "Siker! Az utolsó beillesztett rekord azonosítója: " .$mysqli->insert_id .""; )else( die("Hiba: (". $mysqli->errno .") ". $mysqli->error); ) ?>
Az alábbi kivonat ugyanazokat a jelentéseket szúrja be az Előkészített nyilatkozatok használatával. Ahogy már mondtuk, a minták rendkívül hatékonyak ellene SQL injekció. A megadott példában ezek használata a legjobb megoldás.
PHP
//az adatbázistáblába beillesztendő értékek $product_code = "P1234"; $product_name = "42 hüvelykes TV"; $termékár = "600"; $query = "INSERT INTO products (product_code, product_name, price) VALUES(?, ?, ?)"; $nyilatkozat = $mysqli->prepare($query); //a jelölők paramétereinek kötése, ahol (s = string, i = egész szám, d = double, b = blob) $utasítás->bind_param("sss", $termékkód, $terméknév, $termékár); if($statement->execute())( print "Siker! Az utolsó beillesztett rekord azonosítója: " .$statement->insert_id .""; )else( die("Hiba: (". $mysqli->errno .") ". $mysqli->error); ) $statement->close();
INSERT több rekordot
Egyszerre több sor beszúrása úgy történik, hogy egy sor oszlopértéket ad meg úgy, hogy minden értéksort zárójelek vesznek körül, és vesszővel választják el a többitől. Néha meg kell találnia, hogy hány rekordot szúrt be, frissített vagy törölt, ehhez használhatja a mysqli_affected_rows-t.
PHP
//product 1 $product_code1 = """.$mysqli->real_escape_string("P1")."""; $product_name1 = """.$mysqli->real_escape_string("Google Nexus")."""; $product_price1 = """.$mysqli->real_escape_string("149")."""; //2. termék $product_code2 = """.$mysqli->real_escape_string("P2")."""; $product_name2 = """.$mysqli->real_escape_string("Apple iPad 2")."""; $product_price2 = """.$mysqli->real_escape_string("217")."""; //product 3 $product_code3 = """.$mysqli->real_escape_string("P3")."""; $product_name3 = """.$mysqli->real_escape_string("Samsung Galaxy Note")."""; $product_price3 = """.$mysqli->real_escape_string("259")."""; //Több sor beszúrása $insert = $mysqli->query("INSERT INTO products(product_code, product_name, price) ÉRTÉKEK ($termékkód1, $terméknév1, $termékár1), ($termékkód2, $terméknév2, $termékár2), ($ termék_kód3, $termék_neve3, $termék_ára3)"); if($insert)( //visszaadja az összes beszúrt rekordot a mysqli_affected_rows használatával print "Siker! Összesen " .$mysqli->affected_rows ." sor hozzáadva."; )else( die("Hiba: (". $mysqli->errno .") ". $mysqli->error); )
Bejegyzések frissítése/törlése
A rekordok frissítésének és törlésének elve ugyanaz. A lekérdezési karakterláncot elég lecserélni MySql frissítésre vagy törlésre (nem értem, nézd meg magad).
PHP
//MySqli frissítési lekérdezés $results = $mysqli->query("UPDATE products SET product_name="52 inch TV", product_code="323343" WHERE ID=24"); //MySqli törlési lekérdezés //$results = $mysqli->query("DELETE FROM FROM products WHERE ID=24"); if($results)( print "Siker! rekord frissítve / törölve"; )else( print "Hiba: (". $mysqli->errno .") ". $mysqli->error; )Frissítés előkészített kimutatások segítségével
Az alábbiakban látható egy példa egy rekord elkészített kimutatások segítségével történő frissítésére.
PHP
$product_name = "52 hüvelykes TV"; $termékkód = "9879798"; $keresés_azonosító = 24; $query = "TERMÉKEK FRISSÍTÉSE: termék_név=?, termék_kód=? WHERE ID=?"; $nyilatkozat = $mysqli->prepare($query); //a jelölők paramétereinek kötése, ahol (s = string, i = egész szám, d = dupla, b = blob) $eredmények = $utasítás->bind_param("ssi", $termék_neve, $termékkód, $keresőazonosító); if($results)( print "Siker! rekord frissítve"; )else( print "Hiba: (". $mysqli->errno .") ". $mysqli->error; )Régi bejegyzések törlése
Minden olyan rekord törlődik, amely több mint 1 napja van a szerveren; A napok számát saját maga állíthatja be.
PHP
//MySqli lekérdezés törlése $results = $mysqli-Kétségtelen, hogy a MySqli lényegesen jobb, mint a szokásos MySql PHP kiterjesztés, bár működési elveik meglehetősen hasonlóak. Remélem, hogy a fenti információk hasznosak lesznek a projektek jövőbeni létrehozásakor és áttelepítésekor. A kényelem érdekében az alábbiakban lehetőség van példafájlok letöltésére. Ezt a letöltés gombra kattintva teheti meg.
A kiforrottabb adatbázisok közül sok támogatja az elkészített kimutatások koncepcióját. Kik ők? Felfoghatók egyfajta lefordított sablonnak az SQL-hez, amelyet egy alkalmazás futtatni szeretne, és amely változó paraméterekkel testreszabható. Az elkészített nyilatkozatoknak két fő előnye van:
- A lekérdezést csak egyszer kell elemezni (vagy előkészíteni), de ugyanazzal vagy eltérő paraméterekkel többször is végrehajtható. A lekérdezés elkészítésekor az adatbázis elemzi, összeállítja és optimalizálja a lekérdezés végrehajtására vonatkozó tervet. Összetett lekérdezések esetén ez a folyamat elég időt vehet igénybe ahhoz, hogy észrevehetően lelassítsa az alkalmazást, ha ugyanazt a lekérdezést többször meg kell ismételni különböző paraméterekkel. Egy előkészített utasítás használatával az alkalmazás elkerüli az elemzés/összeállítás/optimalizálás ciklus megismétlését. Ez azt jelenti, hogy az elkészített kimutatások kevesebb erőforrást igényelnek, és így gyorsabban futnak.
- Az előkészített utasítások paramétereit nem kell idézni, ezt az illesztőprogram automatikusan kezeli. Ha egy alkalmazás kizárólag előkészített utasításokat használ, a fejlesztő biztos lehet abban, hogy nem történik SQL injekció (ha azonban a lekérdezés más részei készülnek fel nem szabadított bemenettel, az SQL injekció továbbra is lehetséges).
Az elkészített utasítások annyira hasznosak, hogy az egyetlen olyan funkció, amelyet a PDO emulál az azokat nem támogató illesztőprogramok számára. Ez biztosítja, hogy az alkalmazások ugyanazt az adatelérési paradigmát használják, függetlenül az adatbázis képességeitől.
1. példa Ismételt beszúrások előkészített utasításokkal
névés a érték a megnevezett helyőrzőknek.
$stmt = $dbh -> előkészíti ( "INSERT INTO REGISTRY (név, érték) ÉRTÉKEK (:név, :érték)");
$stmt -> bindParam (":név" , $név );
$stmt -> bindParam (":érték" , $érték);
// beszúr egy sort
$név = "egy" ;
$érték = 1 ;
$stmt -> execute();
$név = "kettő" ;
$érték = 2 ;
$stmt -> execute();
?>
2. példa Ismételt beszúrások előkészített utasításokkal
Ez a példa egy INSERT lekérdezést hajt végre az a helyettesítéssel névés a érték a pozicionálisnak ? helyőrzők.
$stmt = $dbh -> előkészíti ( "INSERT INTO REGISTRY (név, érték) ÉRTÉKEK (?, ?)");
$stmt -> bindParam(1, $név);
$stmt -> bindParam (2 , $érték );
// beszúr egy sort
$név = "egy" ;
$érték = 1 ;
$stmt -> execute();
// beszúr egy másik sort különböző értékekkel
$név = "kettő" ;
$érték = 2 ;
$stmt -> execute();
?>
3. példa Adatok lekérése előkészített utasítások segítségével
4. példa Tárolt eljárás hívása kimeneti paraméterrel
Ha az adatbázis-illesztőprogram támogatja, akkor egy alkalmazás paramétereket is köthet a kimenethez és a bemenethez. A kimeneti paramétereket általában a tárolt eljárásokból származó értékek lekérésére használják. A kimeneti paraméterek használata valamivel bonyolultabb, mint a bemeneti paraméterek, mivel a fejlesztőnek tudnia kell, hogy egy adott paraméter mekkora lehet, amikor összekapcsolja azt. Ha az érték nagyobb, mint az általuk javasolt méret, hiba lép fel.
$stmt = $dbh -> előkészít ("CALL sp_returns_string(?)" );
$stmt -> bindParam(1, $visszatérési_érték, PDO::PARAM_STR, 4000);
// meghívja a tárolt eljárást
$stmt -> execute();
print "procedure return $return_value \n" ;
?>
5. példa Tárolt eljárás hívása bemeneti/kimeneti paraméterrel
A fejlesztők olyan paramétereket is megadhatnak, amelyek mind bemeneti, mind kimeneti értékeket tartalmaznak; a szintaxis hasonló a kimeneti paraméterekhez. Ebben a következő példában a "hello" karakterlánc átkerül a tárolt eljárásba, és amikor visszatér, a hello az eljárás visszatérési értékére kerül.
$stmt = $dbh -> előkészíti ( "CALL sp_takes_string_returns_string(?)");
$value = "hello"
;!}
$stmt -> bindParam (1 , $érték , PDO :: PARAM_STR | PDO :: PARAM_INPUT_OUTPUT , 4000 );
// meghívja a tárolt eljárást
$stmt -> execute();
print "az eljárás $értéket adott vissza \n" ;
?>