Sagatavoti vaicājumi un saglabātās procedūras. MySQL papildu līdzekļi Kāpēc ne myqli vai mysql

ACVN ir sava gudrā savienojuma metode, ko sauc par . Turklāt savienojuma laikā varat iestatīt ļoti daudz iespēju, no kurām dažas ir ļoti noderīgas. Pilnu sarakstu var atrast, taču svarīgi ir tikai daži.

Pareiza savienojuma piemērs:

$host = "127.0.0.1" ;
$db = "pārbaude" ;
$user = "sakne" ;
$pass = "" ;
$charset = "utf8" ;

$dsn = "mysql:host= $host ;dbname= $db ;charset= $charset" ;
$opt = [
ACVN::ATTR_ERRMODE => ACVN::ERRMODE_EXCEPTION,
ACVN::ATTR_DEFAULT_FETCH_MODE => ACVN::FETCH_ASSOC,
ACVN::ATTR_EMULATE_PREPARES => nepatiess,
];
$pdo = jauns ACVN ($dsn, $user, $pass, $opt);

Kas te notiek?

$dsn norāda datu bāzes veidu, ar kuru mēs strādāsim (mysql), resursdatoru, datu bāzes nosaukumu un rakstzīmju kopu.
- seko lietotājvārds un parole
- pēc tam tiek norādīts opciju masīvs, par ko nav rakstīts nevienā no rokasgrāmatām.

Neskatoties uz to, ka šis masīvs ir ārkārtīgi noderīga lieta, kā minēts iepriekš. Vissvarīgākais ir tas, ka kļūdu režīms jāiestata tikai izņēmumu veidā.
- Pirmkārt, tāpēc, ka visos citos režīmos ACVN neziņo neko saprotamu par kļūdu,
- otrkārt, tāpēc, ka izņēmums vienmēr satur neaizvietojamu steka izsekojumu,
- treškārt, izņēmumi ir ārkārtīgi ērti apstrādājami.

Turklāt ir ļoti ērti pēc noklusējuma iestatīt FETCH_MODE, lai to nerakstītu KATRAM pieprasījumā, kā to mīl čakli kāmji.
Arī šeit jūs varat iestatīt pconnect režīmu, sagatavoto izteicienu emulāciju un daudzus citus biedējošus vārdus.

Rezultātā mēs iegūstam mainīgo $ pdo, ar kuru mēs strādājam visā skriptā.

Vaicājumu izpildei varat izmantot divas metodes.
Ja pieprasījumam netiek nodoti mainīgie, varat izmantot funkciju query(). Tas izpildīs pieprasījumu un atgriezīs īpašu objektu - ACVN paziņojumu. Ļoti aptuveni, jūs varat to salīdzināt ar mysql resursu, ko atgrieza mysql_query(). Jūs varat iegūt datus no šī objekta tradicionālā veidā, izmantojot while vai foreach(). Varat arī lūgt atgriezt saņemtos datus īpašā formātā, kas ir apspriests tālāk.
$stmt = $pdo -> vaicājums ("ATLASĪT vārdu FROM lietotājiem" );
while ($rinda = $stmt -> fetch())
{
}

Ja pieprasījumam tiek nodots vismaz viens mainīgais, tad šis pieprasījums ir jāizpilda tikai caur sagatavoti izteicieni. Kas tas ir? Šis ir parasts SQL vaicājums, kurā mainīgā vietā tiek ievietots īpašs marķieris - vietturis. ACVN atbalsta pozicionālos vietturus (?), kuriem ir svarīga nodoto mainīgo secība, un nosauktos vietturus (:name), kuriem secība nav svarīga. Piemēri:
$sql = ;
$sql = ;
Lai izpildītu šādu vaicājumu, tas vispirms ir jāsagatavo, izmantojot ready() funkciju. Tas arī atgriež ACVN paziņojumu, bet vēl bez jebkādiem datiem. Lai tos iegūtu, jums ir jāizpilda šis pieprasījums, iepriekš nododot tajā mainīgos. Varat to pārsūtīt divos veidos:
Visbiežāk jūs varat vienkārši izpildīt execute() metodi, nododot tai mainīgo lielumu masīvu:
$stmt = $pdo -> sagatavot ( "SELECT name FROM users WHERE email = ?");
$stmt -> izpildīt (masīvs($email ));

$stmt = $pdo -> sagatavot ( "ATLASĪT vārdu FROM lietotājiem WHERE e-pasts = :email");
$stmt -> izpildīt (masīvs("email" => $email ));
Kā redzat, nosauktu vietturu gadījumā masīvs, kurā atslēgām ir jāatbilst vietturu nosaukumiem, ir jānodod izpildei ().

Dažreiz ļoti reti var būt nepieciešama otrā metode, kad mainīgie vispirms tiek piesaistīti pieprasījumam pa vienam, izmantojot bindValue() / bindParam(), un tikai pēc tam tiek izpildīti. Šajā gadījumā nekas netiek nodots izpildei (). Piemēru var atrast rokasgrāmatā.
Vai, izmantojot šo metodi, vienmēr vajadzētu dot priekšroku bindValue()? jo bindParam() darbība iesācējiem nav acīmredzama un radīs problēmas.

Pēc tam varat izmantot ACVN paziņojumu tāpat kā iepriekš. Piemēram, izmantojot foreach:
$stmt = $pdo -> sagatavot ( "SELECT name FROM users WHERE email = ?");
$stmt ->
foreach ($stmt kā $row )
{
atbalss $rinda [ "nosaukums" ] . "\n" ;
}

SVARĪGI: Sagatavoti izteicieni ir galvenais ACVN lietošanas iemesls, jo tas vienīgais drošs veids izpildot SQL vaicājumus, kas ietver mainīgos.

Tāpat sagatavo() / execute() var izmantot, lai atkārtoti izpildītu vienreiz sagatavotu vaicājumu ar dažādām datu kopām. Praksē tas ir nepieciešams ārkārtīgi reti, un tas nedod lielu ātruma pieaugumu. Bet, ja jums ir jāveic daudzi viena veida vaicājumi, varat to rakstīt šādi:

$dati = masīvs(
1 => 1000,
5 => 300,
9 => 200,
);

$stmt = $pdo -> sagatavot ( "ATJAUNINĀT lietotājus IESTATĪT bonusu = bonuss + ? WHERE id = ?");
foreach ($data kā $id => $bonuss)
{
$stmt -> izpildīt ([ $bonuss , $id ]);
}

Šeit mēs sagatavojam pieprasījumu vienu reizi un pēc tam izpildām to vairākas reizes.

Mēs jau esam iepazinušies ar fetch() metodi, kas tiek izmantota, lai secīgi iegūtu rindas no datu bāzes. Šī metode ir analoga funkcijai mysq_fetch_array() un līdzīgām, taču tā darbojas savādāk: daudzu funkciju vietā šeit tiek izmantota viena, bet tās uzvedību nosaka nodotais parametrs. Par šiem parametriem es sīkāk rakstīšu vēlāk, bet kā īsu ieteikumu es ieteiktu izmantot fetch() režīmā FETCH_LAZY:
$stmt = $pdo -> sagatavot ( "SELECT name FROM users WHERE email = ?");
$stmt -> izpildīt([ $_GET [ "e-pasts" ]]);
while ($rinda = $stmt -> atnest (ACVN :: FETCH_LAZY ))
{
atbalss $rinda [ 0 ] . "\n" ;
atbalss $rinda [ "nosaukums" ] . "\n" ;
atbalss $rinda -> nosaukums . "\n" ;
}
Šajā režīmā netiek tērēta papildu atmiņa, turklāt kolonnām var piekļūt jebkurā no trim veidiem – izmantojot indeksu, nosaukumu vai rekvizītu.

ACVN paziņojumam ir arī palīgfunkcija vienas kolonnas vērtības iegūšanai. Tas ir ļoti ērti, ja pieprasām tikai vienu lauku - šajā gadījumā tiek ievērojami samazināts rakstīšanas apjoms:
$stmt = $pdo -> sagatavot ( "SELECT name FROM table WHERE id=?");
$stmt -> izpildīt (masīvs($id ));
$nosaukums = $stmt -> fetchColumn();

Bet visinteresantākā funkcija ar vislielāko funkcionalitāti ir fetchAll(). Tas padara PDO par augsta līmeņa bibliotēku darbam ar datu bāzi, nevis tikai par zema līmeņa draiveri.

FetchAll() atgriež masīvu, kas sastāv no visām rindām, kuras vaicājums atgrieza. No tā var izdarīt divus secinājumus:
1. Šo funkciju nevajadzētu izmantot, ja vaicājums atgriež daudz datu. Šajā gadījumā labāk ir izmantot tradicionālo cilpu ar fetch()
2. Tā kā mūsdienu PHP lietojumprogrammās dati nekad netiek izvadīti uzreiz pēc saņemšanas, bet tiek pārsūtīti uz veidni šim nolūkam, fetchAll() kļūst vienkārši neaizvietojams, ļaujot izvairīties no cilpu rakstīšanas manuāli un tādējādi samazinot koda daudzumu.

Vienkārša masīva iegūšana.
Šī funkcija tiek izsaukta bez parametriem, un tā atgriež parastu indeksētu masīvu, kas satur rindas no datu bāzes formātā, kas pēc noklusējuma norādīts FETCH_MODE. Konstantes PDO::FETCH_NUM, PDO::FETCH_ASSOC, PDO::FETCH_OBJ var mainīt formātu lidojuma laikā.

Kolonnas iegūšana.
Dažreiz jums ir jāiegūst vienkāršs viendimensijas masīvs, pieprasot vienu lauku no virkņu kopas. Lai to izdarītu, izmantojiet režīmu PDO::FETCH_COLUMN
$data = $pdo -> vaicājums ("SELECT name FROM users" ) -> fetchAll (ACVN :: FETCH_COLUMN );
masīvs (
0 => "Jānis",
1 => "Maiks",
2 => "Mērija",
3 => "Kathy",
)

Notiek atslēgu un vērtību pāru izgūšana.
Arī populārs formāts, kad vēlams iegūt vienu un to pašu kolonnu, bet indeksētu nevis pēc cipariem, bet pēc kāda no laukiem. Par to ir atbildīga konstante PDO::FETCH_KEY_PAIR.
$data = $pdo -> vaicājums ("SELECT id, name FROM users" ) -> fetchAll (ACVN :: FETCH_KEY_PAIR );
masīvs (
104 => "Jānis",
110 => "Maiks",
120 => "Marija",
121 => "Kathy",
)

Iegūstiet visas rindas, kuras indeksē lauks.
Tāpat bieži vien ir nepieciešams iegūt visas rindas no datu bāzes, bet arī indeksētas nevis pēc skaitļiem, bet pēc unikāla lauka. ACVN::FETCH_UNIQUE konstante to dara.
$data = $pdo -> vaicājums ("SELECT * FROM users") -> fetchAll (ACVN :: FETCH_UNIQUE );
masīvs (
104 => masīvs (
"name" => "Jānis" ,
"automašīna" => "Toyota",
),
110 => masīvs (
"name" => "Maiks" ,
"car" => "Ford" ,
),
120 => masīvs (
"name" => "Marija" ,
"car" => "Mazda" ,
),
121 => masīvs (
"name" => "Kathy",
"car" => "Mazda" ,
),
)
Jāatceras, ka kolonnā vispirms ir jāatlasa unikāls lauks.

ACVN ir vairāk nekā pusotrs ducis dažādu datu iegūšanas režīmu. Turklāt jūs varat tos apvienot! Bet šī ir atsevišķa raksta tēma.

Strādājot ar sagatavotām izteiksmēm, jums jāsaprot, ka vietturis var aizstāt tikai virkni vai skaitli. Ne atslēgvārdu, ne identifikatoru, ne virknes daļu vai virkņu kopu nevar aizstāt, izmantojot vietturi. Tāpēc LIKE vispirms ir jāsagatavo visa meklēšanas virkne un pēc tam jāaizstāj tā vaicājumā:

$name = "% $name %" ;
$stm = $pdo -> sagatavot ( "SELECT * FROM table WHERE nosaukums PATĪK?");
$stm -> izpildīt (masīvs($nosaukums ));
$dati = $stm -> fetchAll();

Nu, jūs sapratāt domu. Arī šeit viss ir slikti. ACVN nenodrošina vispār nekādus rīkus darbam ar identifikatoriem, un tie ir jāformatē vecmodīgi, manuāli (vai tomēr jāskatās uz SafeMysql, kurā tas, tāpat kā daudzas citas problēmas, tiek atrisināts vienkārši un eleganti).
Jāatceras, ka identifikatoru formatēšanas noteikumi dažādām datu bāzēm atšķiras.

Mysql, lai manuāli formatētu identifikatoru, jums ir jāveic divas darbības:
- ievietojiet to aizmugurē ("`").
- meklējiet šīs rakstzīmes identifikatorā, dubultojot.

$lauks = "`" . str_replace ("`" , "``" , $_GET [ "lauks" ]). "`";
$sql = $lauks " ;

Tomēr šeit ir viens brīdinājums. Ar formatēšanu vien var nepietikt. Iepriekš minētais kods pasargā mūs no klasiskās injekcijas, taču dažos gadījumos ienaidnieks joprojām var ierakstīt kaut ko nevēlamu, ja mēs nepārdomāti aizstājam lauku un tabulu nosaukumus tieši vaicājumā. Piemēram, lietotāju tabulā ir administratora lauks. Ja ienākošie lauku nosaukumi netiek filtrēti, jebkurš muļķis, automātiski ģenerējot pieprasījumu no POST, šajā laukā ierakstīs jebkādas nepatīkamas lietas.

Tāpēc ir ieteicams pārbaudīt lietotāja saņemto tabulu un lauku nosaukumu derīgumu, kā parādīts zemāk esošajā piemērā.

Jebkurš iegulšanas kods, ko var redzēt daudzās pamācībās, rada melanholiju un vēlmi nogalināt apstenu. Vairāku kilometru konstrukcijas ar vienādu nosaukumu atkārtošanos - $_POST indeksos, mainīgo nosaukumos, lauku nosaukumos pieprasījumā, vietturu nosaukumos pieprasījumā, vietturu nosaukumos un mainīgo nosaukumos, kad tie ir saistoši.
Skatoties uz šo kodu, man rodas vēlme kādu nogalināt vai vismaz nedaudz saīsināt.

To var izdarīt, pieņemot vienošanos, ka veidlapas lauku nosaukumi atbilst lauku nosaukumiem tabulā. Tad šos nosaukumus var uzskaitīt tikai vienu reizi (lai aizsargātos pret aizstāšanu, kas tika minēts iepriekš), un vaicājuma salikšanai var izmantot nelielu palīgfunkciju, kas mysql īpatnību dēļ ir piemērota gan INSERT, gan ATJAUNINĀT vaicājumus:

funkcija pdoSet ($allowed , & $values ​​, $source = masīvs()) (
$set = "" ;
$vērtības = masīvs();
if (! $avots ) $avots = & $_POST ;
foreach ($allowed kā $field) (
if (isset($source [ $field ])) (
$set .= "`" . str_replace ("`" , "``" , $lauks ). "`". "=: $lauks , " ;
$vērtības ​​[ $lauks] = $avots [ $lauks];
}
}
return substr ($set, 0, - 2);
}

Attiecīgi iegulšanas kods būs

$allowed = array("vārds" , "uzvārds" , "e-pasts" ); // atļautie lauki
$sql = "INSERT INTO users SET" . pdoSet ($atļauts, $vērtības);
$stm = $dbh -> sagatavot ($sql );
$stm -> izpildīt ($vērtības);

Un atjauninājumam - šis:

$allowed = array("vārds" , "uzvārds" , "e-pasts" , "parole" ); // atļautie lauki
$_POST ["parole"] = MD5 ($_POST [ "pieteikšanās"]. $_POST [ "parole"]);
$sql = "ATJAUNINĀT lietotājus SET" . pdoSet ($allowed, $values). "KUR ID = :id" ;
$stm = $dbh -> sagatavot ($sql );
$vērtības ​​["id"] = $_POST ["id"];
$stm -> izpildīt ($vērtības);

Nav ļoti iespaidīgs, bet ļoti efektīvs. Ļaujiet man, starp citu, atgādināt, ka, ja jūs izmantojat Class drošam un ērtam darbam ar MySQL, tad tas viss tiek darīts divās rindās.

ACVN un atslēgvārdi
Šeit nav iespējams izdomāt neko citu kā tikai filtrēšanu. Tāpēc ir muļķīgi palaist visus operatorus, kas nav tieši norādīti pieprasījumā, izmantojot balto sarakstu:

$dirs = masīvs("ASC" , "DESC");
$key = masīva_meklēšana($_GET["direktors"], $dirs));
$dir = $pasūtījumi [ $key ];
$sql = "ATLASĪT * NO `galda` PASŪTĪT$lauks $dir " ;

Termiņš ACVN ir jēdziena saīsinājums PHP datu objekti. Kā norāda nosaukums, šī tehnoloģija ļauj strādāt ar datu bāzes saturu, izmantojot objektus.

Kāpēc ne myqli vai mysql?

Visbiežāk attiecībā uz jaunajām tehnoloģijām rodas jautājums par to priekšrocībām salīdzinājumā ar vecajiem labajiem un pārbaudītajiem instrumentiem, kā arī par pašreizējo un veco projektu nodošanu tām.

Objektorientācija ACVN

PHP Tas attīstās ļoti aktīvi un cenšas kļūt par vienu no labākajiem rīkiem straujai tīmekļa aplikāciju attīstībai gan masu, gan korporatīvā līmenī.

Runājot par PHP, mēs domājam mūsdienu objektorientētu PHP, kas ļauj rakstīt universālu kodu, kas ir ērts testēšanai un atkārtotai izmantošanai.

Lietošana ACVNļauj pārvietot datu bāzes darbu uz objektu orientētu līmeni un uzlabot koda pārnesamību. Patiesībā lietošana ACVN nav tik grūti, kā varētu domāt.

Abstrakcija

Iedomāsimies, ka mēs jau ilgu laiku esam izstrādājuši lietojumprogrammu, izmantojot MySQL. Un tad vienā jaukā brīdī rodas nepieciešamība nomainīt MySQL ieslēgts PostgreSQL.

Mums būs vismaz jāaizstāj visi zvani mysqli_connect() (mysql_connect()) ieslēgts pg_connect() un pēc analoģijas citas funkcijas, ko izmanto datu vaicāšanai un apstrādei.

Lietojot ACVN, mēs aprobežosimies ar dažu parametru maiņu konfigurācijas failos.

Parametru saistīšana

Saistīto parametru izmantošana nodrošina lielāku elastību vaicājumu izstrādē un uzlabo aizsardzību pret SQL injekcijas.

Datu saņemšana kā objekti

Tie, kas jau lieto ORM(objektu relāciju kartēšana — datu objektu relāciju kartēšana), piemēram, Doktrīna, zināt, cik ērti ir attēlot datus no datu bāzes tabulām objektu veidā. ACVNļauj saņemt datus objektu veidā un neizmantojot ORM.

Mysql paplašinājums vairs netiek atbalstīts

Paplašinājuma atbalsts mysql neatgriezeniski noņemts no jaunā PHP 7. Ja plānojat projektu pārcelt uz jaunā versija PHP, tagad tajā vajadzētu izmantot vismaz mysqli. Protams, labāk ir sākt lietot ACVN ja vēl neesat to izdarījis.

Man šķiet, ka šie iemesli ir pietiekami, lai nosvērtu svaru par labu lietošanai ACVN. Turklāt jums nav jāinstalē nekas papildu.

ACVN klātbūtnes pārbaude sistēmā

Versijas PHP 5.5 un augstāks, visbiežāk jau satur paplašinājumu darbam ar ACVN. Lai pārbaudītu, vienkārši palaidiet vienkāršu komandu konsolē:

php -i | grep "pdo"

Tagad atveram to jebkurā pārlūkprogrammā un, meklējot pēc rindas, atradīsim nepieciešamos datus ACVN.

Iepazīšanās ar ACVN

Darba process ar ACVN ne pārāk atšķiras no tradicionālā. Kopumā lietošanas process ACVN izskatās šādi:

1. Izveidojiet savienojumu ar datu bāzi;
2. Ja nepieciešams, sagatavot pieprasījumu un sasaistīt parametrus;
3. Pieprasījuma izpilde.

Savienojuma izveide ar datu bāzi

Lai izveidotu savienojumu ar datu bāzi, jāizveido jauns objekts ACVN un nododiet tam datu avota nosaukumu, kas pazīstams arī kā DSN.

Kopumā DSN sastāv no draivera nosaukuma, kas ir atdalīts ar kolu no savienojuma virknes, kas raksturīga katram draiverim ACVN.

Par MySQL, savienojums tiek izveidots šādi:

$savienojums = new ACVN("mysql:host=localhost;dbname=mydb;charset=utf8", "sakne", "sakne");

Šajā gadījumā DSN satur draivera nosaukumu mysql, saimniekdatora indikācija (iespējamais formāts resursdators=HOST_NAME:PORT), datu bāzes nosaukums, kodējums, lietotājvārds MySQL un viņa paroli.

Pieprasījumi

Atšķirībā no mysqli_query(), V ACVN ir divu veidu pieprasījumi:

• Atgriežot rezultātu ( atlasīt, parādīt);
• Neatgriež rezultātu ( ievietot, detaļa un citi).

Vispirms apsvērsim otro iespēju.

Vaicājumu izpilde

Apskatīsim pieprasījuma izpildes piemēru, izmantojot piemēru ievietot.

$connection->exec("INSERT INTO lietotāju VĒRTĪBAS (1, "somevalue"");

Protams, šis vaicājums atgriež ietekmēto rindu skaitu, un to var redzēt šādi.

$affectedRows = $connection->exec("INSERT INTO user VALUES (1, "somevalue""); atbalss $affectedRows;

Vaicājuma rezultātu iegūšana

Lietošanas gadījumā mysqli_query(), kods varētu būt šāds.

$rezultāts = mysql_query("SELECT * FROM lietotājiem"); while($row = mysql_fetch_assoc($result)) (echo $row["id"] . " " . $row["nosaukums"]; )

Par ACVN, kods būs vienkāršāks un kodolīgāks.

foreach($connection->query("SELECT * FROM users") as $row) ( echo $row["id"] . " " . $row["nosaukums"]; )

Datu iegūšanas režīmi

Kā iekšā mysqli, ACVNļauj saņemt datus dažādos režīmos. Lai noteiktu režīmu, klase ACVN satur atbilstošās konstantes.

• ACVN::FETCH_ASSOC— atgriež masīvu, kas indeksēts pēc kolonnas nosaukuma datu bāzes tabulā;
• ACVN::FETCH_NUM— atgriež masīvu, kas indeksēts pēc kolonnas numura;
• ACVN::FETCH_OBJ- atgriež anonīmu objektu ar rekvizītu nosaukumiem, kas atbilst kolonnu nosaukumiem. Piemēram, $rinda->id ietvers vērtību no id kolonnas.
• ACVN::FETCH_CLASS— atgriež jaunu klases gadījumu ar rekvizītu vērtībām, kas atbilst datiem no tabulas rindas. Ja parametrs ir norādīts ACVN::FETCH_CLASSTYPE(Piemēram ACVN::FETCH_CLASS | ACVN::FETCH_CLASSTYPE

), klases nosaukums tiks noteikts pēc pirmās kolonnas vērtības. Piezīme : tā nav pilns saraksts

, visas iespējamās konstantes un to kombinācijas opcijas ir pieejamas dokumentācijā.

Asociatīvā masīva iegūšanas piemērs:

), klases nosaukums tiks noteikts pēc pirmās kolonnas vērtības. while ($rinda = $paziņojums -> atnest (ACVN::FETCH_ASSOC) ) ( : Ieteicams vienmēr norādīt izlases režīmu, jo režīms ACVN::FETCH_BOTH

prasīs divreiz vairāk atmiņas – faktiski tiks izveidoti divi masīvi, asociatīvie un regulārie. ACVN::FETCH_CLASS Apsveriet iespēju izmantot izlases režīmu . Izveidosim klasi:

Lietotājs

$this -> name = $name ;

Tagad atlasīsim datus un parādīsim datus, izmantojot klases metodes:

echo $row -> getId() . " ". $row -> getName () ;

Sagatavoti vaicājumi un parametru saistīšana ACVN Lai izprastu parametru saistīšanas būtību un visas priekšrocības, jums ir sīkāk jāizpēta mehānismi . Zvanot$paziņojums -> vaicājums() ACVN augstāk esošajā kodā,

sagatavos pieprasījumu, izpildīs to un atgriezīs rezultātu. Zvanot$savienojums -> sagatavot() tiek izveidots sagatavots pieprasījums. Sagatavotie vaicājumi ir datu bāzes pārvaldības sistēmas iespēja saņemt vaicājuma veidni, to apkopot un izpildīt pēc veidnē izmantoto mainīgo vērtību izgūšanas. Veidņu dzinēji darbojas līdzīgi. Gudrs Un.

sagatavos pieprasījumu, izpildīs to un atgriezīs rezultātu. Zars aizstāšanas vērtības tiek pārsūtītas uz vaicājuma veidni, un DBVS izpilda vaicājumu. Šī darbība ir līdzīga veidnes dzinēja funkcijas izsaukšanai renderēt ().

Sagatavotu vaicājumu izmantošanas piemērs PHP ACVN:

Iepriekš minētajā kodā tiek sagatavots ieraksta atlases pieprasījums ar lauku id vienāda ar vērtību, kas tiks aizstāta : id. Šajā posmā DBVS analizēs un apkopos pieprasījumu, iespējams, izmantojot kešatmiņu (atkarībā no iestatījumiem).

Tagad jums ir jānodod trūkstošais parametrs un jāizpilda pieprasījums:

$id = 5; $paziņojums->izpildīt([ ":id" => $id ]);

Saistīto parametru izmantošanas priekšrocības

Iespējams, pārskatot sagatavoto vaicājumu darbību un saistītos parametrus, to izmantošanas priekšrocības kļūst acīmredzamas.

ACVN nodrošina ērtu veidu, kā izvairīties no lietotāja datiem, piemēram, šāds kods vairs nav vajadzīgs:

Tā vietā tagad ir ieteicams rīkoties šādi:

Varat pat vēl vairāk saīsināt kodu, izmantojot numurētus parametrus, nevis nosauktos:

Tajā pašā laikā sagatavotu vaicājumu izmantošana uzlabo veiktspēju, vairākas reizes izmantojot vienu vaicājuma veidni. Piemērs piecu nejaušu lietotāju atlasei no datu bāzes:

$numberOfUsers = $connection->query("SELECT COUNT(*) FROM users")->fetchColumn(); $lietotāji = ; $paziņojums = $connection->prepare("SELECT * FROM users WHERE id = ? LIMIT 1"); priekš ($i = 1; $i<= 5; $i++) { $id = rand(1, $numberOfUsers); $users = $statement->izpildīt([$id])->atnest(ACVN::FETCH_OBJ); )

Izsaucot metodi sagatavot (), DBVS analizēs un apkopos pieprasījumu, vajadzības gadījumā izmantojot kešatmiņu. Vēlāk ciklā priekš, tiek atlasīti tikai dati ar norādīto parametru. Šī pieeja ļauj ātrāk izgūt datus, samazinot lietojumprogrammas darbības laiku.

Iegūstot kopējo lietotāju skaitu datu bāzē, tika izmantota metode fetchColumn(). Šī metode izgūst vienas kolonnas vērtību un ir noderīga, izgūstot skalārās vērtības, piemēram, skaitīšanas, summas, maksimālās vai minimālās vērtības.

Saistītās vērtības un IN operators

Bieži vien, sākot strādāt ar ACVN, rodas grūtības ar operatoru IN. Piemēram, iedomājieties, ka lietotājs ievada vairākus vārdus, atdalot tos ar komatiem. Lietotāja ievade tiek saglabāta mainīgajā $names.

Lielākā daļa datu bāzu atbalsta sagatavotu vaicājumu koncepciju. Kas tas ir? To var raksturot kā sava veida kompilētu SQL vaicājuma veidni, ko palaidīs lietojumprogramma un konfigurēs, izmantojot ievades parametrus. Sagatavotiem vaicājumiem ir divas galvenās priekšrocības:

• Pieprasījums jāsagatavo vienu reizi un pēc tam to var palaist tik reižu, cik nepieciešams, gan ar vienādiem, gan dažādiem parametriem.
• Kad vaicājums ir sagatavots, DBVS to analizē, apkopo un optimizē tā izpildes plānu. Sarežģītiem vaicājumiem šis process var aizņemt ievērojamu laiku un var ievērojami palēnināt lietojumprogrammas darbību, ja vaicājums ir jāizpilda vairākas reizes ar dažādiem parametriem. Izmantojot sagatavotu vaicājumu, DBVS tikai vienu reizi analizē/kompilē/optimizē jebkuras sarežģītības vaicājumu, un lietojumprogramma palaiž izpildei jau sagatavoto veidni. Šādi sagatavoti vaicājumi patērē mazāk resursu un darbojas ātrāk.

Sagatavotie vaicājuma parametri nav jāliek ar pēdiņām; vadītājs to dara automātiski. Ja lietojumprogramma izmanto tikai sagatavotus vaicājumus, izstrādātājs var būt drošs, ka nekādas SQL injekcijas nevar notikt (tomēr, ja citas vaicājuma pamatteksta daļas ir rakstītas ar bezatslēgām rakstzīmēm, SQL injekcijas joprojām ir iespējamas; šeit mēs runājam par parametriem).

Sagatavotie vaicājumi ir noderīgi arī tāpēc, ka ACVN var tos emulēt, ja datu bāzes draiverim nav līdzīgas funkcionalitātes. Tas nozīmē, ka lietojumprogramma var izmantot vienu un to pašu datu piekļuves paņēmienu neatkarīgi no DBVS iespējām.

1. piemērs Atkārtota ievietošana datu bāzē, izmantojot sagatavotus vaicājumus Gudrs nosaukums vērtību

, kas tiek aizstāti atbilstošo pseidomainīgo vietā: $stmt = $dbh -> sagatavot ();
"IEVIETOT REĢISTRĀ (nosaukums, vērtība) VĒRTĪBAS (:nosaukums, :vērtība)"
$stmt -> bindParam (":name" , $name );

$stmt -> bindParam (":value" , ​​​​$value );
// ievieto vienu rindiņu
$nosaukums = "viens" ;
$vērtība = 1 ;

$stmt -> izpildīt();
$nosaukums = "divi" ;
$vērtība = 1 ;
?>

$vērtība = 2 ;

2. piemērs Atkārtota ievietošana datu bāzē, izmantojot sagatavotus vaicājumus Šajā piemērā INSERT vaicājums tiek izpildīts 2 reizes ar 1. piemērs Atkārtota ievietošana datu bāzē, izmantojot sagatavotus vaicājumus Gudrs nosaukums dažādas nozīmes ? .

, kas tiek aizstāti atbilstošo pseidomainīgo vietā: kas tiek aizvietoti pseidomainīgo vietā);
"INSERT INTO REGISTRY (nosaukums, vērtība) VĒRTĪBAS (?, ?)"
$stmt -> bindParam(1, $nosaukums);

$stmt -> bindParam (":value" , ​​​​$value );
// ievieto vienu rindiņu
$nosaukums = "viens" ;
$vērtība = 1 ;

$stmt -> bindParam (2 , $value );
// tagad vēl viena rinda ar dažādām vērtībām
$nosaukums = "divi" ;
$vērtība = 1 ;
?>

3. piemērs Datu izgūšana, izmantojot sagatavotus vaicājumus

Šajā piemērā atlase tiek veikta no datu bāzes, izmantojot atslēgu, ko lietotājs ievada, izmantojot veidlapu. Lietotāja ievade tiek citēta automātiski, tāpēc nepastāv SQL injekcijas risks.

Ja DBVS atbalsta izvades parametrus, lietojumprogramma var tos izmantot tāpat kā ievades parametrus. Izvades parametrus parasti izmanto, lai izgūtu datus no saglabātajām procedūrām. Izvades parametru izmantošana ir nedaudz grūtāka, jo izstrādātājam tas ir jāzina maksimālais izmērs iegūtās vērtības šo parametru iestatīšanas stadijā. Ja izgūtā vērtība ir lielāka, nekā paredzēts, tiks parādīta kļūda.

4. piemērs Saglabātas procedūras izsaukšana ar izvades parametriem

$stmt = $dbh -> sagatavot ("CALL sp_returns_string(?)" );
$stmt -> bindParam(1, $return_value, ACVN::PARAM_STR, 4000);

// izsaukt saglabāto procedūru
$vērtība = 1 ;

drukāt "procedūra atgriezās$return_value \n" ;
?>

Varat iestatīt, lai parametrs būtu gan ievade, gan izvade; Sintakse ir tāda pati kā izvades parametriem. Nākamajā piemērā virkne "sveiki" tiek nodota saglabātajai procedūrai, un pēc tam virkne tiks aizstāta ar atgriezto vērtību.

5. piemērs Saglabātas procedūras izsaukšana ar ievades/izejas parametru

, kas tiek aizstāti atbilstošo pseidomainīgo vietā: "CALL sp_takes_string_returns_string(?)");
$value = "labdien" ;!}
$stmt -> bindParam (1 , $vērtība , ACVN :: PARAM_STR | PDO :: PARAM_INPUT_OUTPUT , 4000 );

// izsaukt saglabāto procedūru
$vērtība = 1 ;

drukāt "procedūra atgriezās$vērtība\n" ;
?>

Šajā pēdējā rakstā mēs apskatīsim, kādi ir sagatavoti vaicājumi, kā pieļaut kļūdas Gudrs kas ir darījumi ar ACVN.

Sagatavoti vaicājumi

Kad mēs izpildām vaicājumu datu bāzē, tas tiek analizēts un optimizēts, kas, protams, prasa laiku. Ja mums ir daudz sarežģītu vaicājumu, tas var aizņemt ļoti ilgu laiku. Izmantojot to pašu sagatavoti vaicājumi, tas tiek darīts vienreiz, un tad mēs varam izmantot savu vaicājumu tik reižu, cik vēlamies. Tāpat mums nav jāizvairās no parametriem, jo datu bāzes draiveris visu izdarīs pats. Apskatīsim, kā tos izmantot.

$stmt = $db->prepare("INSERT INTO rakstos (nosaukums, teksts) VĒRTĪBAS (:title, :text)");
$stmt->bindParam(":nosaukums", $nosaukums);
$stmt->bindParam(":teksts", $teksts);

$stmt->izpildīt();

$stmt->izpildīt();

Lai sagatavotu pieprasījumu, mēs to ierakstām metodē sagatavoties, kur vērtību vietā mēs norādām šādu rindu: ": Vārds". Metodē bindParam mēs norādām, kurai rindai kādus datus pievienot. Mūsu gadījumā uz līniju : virsraksts dati no mainīgā ir saistīti $title, un uz līniju :teksts- dati no mainīgā $teksts. Lai izpildītu pieprasījumu, jums ir jāizsauc metode izpildīt. Tādus parametrus sauc nosaukts, tagad paskatīsimies nenosaukts.

$stmt = $db->prepare("INSERT INTO rakstos (nosaukums, teksts) VĒRTĪBAS (?, ?)");
$stmt->bindParam(1, $title);
$stmt->bindParam(2, $teksts);

$title = "1. panta nosaukums";!}
$text = "Daži teksta pirmajam rakstam";
$stmt->izpildīt();

$title = "2. panta nosaukums";!}
$text = "Daži teksta otrajam rakstam";
$stmt->izpildīt();

Šeit viss ir identisks, izņemot to, ka līnijas vietā : Vārds ir norādīta jautājuma zīme, un metodē bindParam numuru 1 nozīmē vispirms jautājuma zīme un skaitlis 2 - otrais jautājuma zīme. Izmantojiet metodi, kas jums patīk vislabāk.

Kļūdu uztveršana

Lai uztvertu kļūdas, mēs izmantojam mums jau pazīstamu konstrukciju mēģināt-ķert un klase PDOIzņēmums.

Mēģiniet (
$db = jauns ACVN("myql:host=$host;dbname=$dbname", $lietotājs, $pass);
) nozveja (PDOIzņēmums $e) (
echo "Jums ir kļūda: ".$e->getMessage()."
";
echo "On line: ".$e->getLine();
}

Piemēram, es kļūdījos un uzrakstīju myql, nē mysql. Šī kļūda tiks uztverta, un mums tiks parādīts tās teksts un rindiņa, kurā radusies kļūda.

Darījumi

Paskatīsimies darījumiem uzreiz ar piemēru.

Mēģiniet (
$db = jauns ACVN("mysql:host=$host;dbname=$dbname", $lietotājs, $pass);
$db->beginTransaction();

$stmt = $db->exec("IEVIETOT `rakstos`(`nosaukums`) VALUES("nosaukums1"));
$stmt = $db->exec("IEVIETOT `rakstos`(`nosaukums`) VALUES("nosaukums2"));
iziet ("kļūda");

$stmt = $db->exec("IEVIETOT `rakstos`(`nosaukums`) VALUES("nosaukums3"));
$db->commit();

) nozveja (PDOIzņēmums $e) (
$db->atgriešanās();
}

sākt Darījumu nozīmē, ka mēs sākam darījumu. Apņemties apstiprina izmaiņas un atgriešanās atceļ visu.

Darījumu būtība ir tāda, ka mēs vai nu darām visu, vai nedarām neko. Mūsu piemērā mēs ievietojam tabulā rakstus vērtības virsraksts1, virsraksts2, virsraksts3. Bet pēc otrās vērtības ievietošanas mēs simulējām kļūdu, apturot skripta izmantošanu iziet. Ja mēs neizmantotu darījumiem, tad mums ir pirmie divi virsraksts būtu ievietots, bet pēdējais nebūtu. Mūsu piemērā tas nav būtiski, taču ir gadījumi, kad tas var izraisīt nopietnas lietojumprogrammas kļūmes. Tāpēc, lai tas nenotiktu, mēs izmantojam darījumiem, kur metode atgriešanās atgriezīs visu sākotnējā formā un mūsu pirmās divas virsraksts arī netiks ievietots, un ja viss gāja labi, bez kļūdām, tad metode apņemties apstiprinās izmaiņas un visas trīs virsraksts tiks veiksmīgi ievietots.

Secinājums

Tātad, mūsu trīs rakstos, kas veltīti mācīšanās ACVN, mēs esam iekļāvuši visu, kas jums nepieciešams, lai ērti izmantotu šo saskarni. Es domāju, ka jūs saprotat, kā ACVN atvieglo mūsu dzīvi, un jūs to izmantosit savos projektos. Lai veicas!