3 giugno 2018 Andrey Chernyshov Tutorial di traduzione 2025 0

PDO è l'acronimo di PHP Data Objects: è un'estensione PHP per lavorare con i database utilizzando oggetti. Uno dei suoi vantaggi sta nel fatto che non è direttamente legato ad un database specifico: la sua interfaccia permette di accedere a diversi ambienti, tra cui: MySQL, SQLite, PostgreSQL, Microsoft SQL Server.

Questa guida mira a fornire una panoramica completa di PDO e accompagnare il lettore passo dopo passo dalla creazione e connessione a un database, alla scelta dei metodi di recupero più appropriati, dimostrando come creare query preparate e descrivendo le possibili modalità di errore.

Creazione di un database e di una tabella di test

Innanzitutto creeremo un database:

CREA DATABASE sistema_solare; CONCEDI TUTTI I PRIVILEGI SU solar_system.* A "testuser"@"localhost" IDENTIFICATO DA "testpassword";

Abbiamo concesso all'utente testuser tutti i privilegi nel database solar_system utilizzando testpassword come password. Ora creiamo una tabella e riempiamola con alcune informazioni:

USA sistema_solare; CREATE TABLE pianeti (id TINYINT(1) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), nome VARCHAR(10) NOT NULL, colore VARCHAR(10) NOT NULL); INSERISCI IN pianeti(nome, colore) VALORI("terra", "blu"), ("marte", "rosso"), ("giove", "strano");

Descrizione della connessione DSN (nome origine dati).

Ora che abbiamo un database, dobbiamo impostare il DSN. DSN sta per Data Source Name ed è un insieme di informazioni necessarie per connettersi a un database, DSN è sotto forma di una stringa. La sintassi varia a seconda del database a cui devi connetterti, ma poiché stiamo utilizzando MySQL/MariaDB, dobbiamo impostare quanto segue:

• Tipo di driver utilizzato per la connessione;
• Il nome del computer host su cui è in esecuzione il database;
• Porta di connessione (opzionale);
• Nome della banca dati;
• Codifica (opzionale).

Il formato della stringa nel nostro caso sarà così (lo memorizzeremo nella variabile $dsn):

$dsn = "mysql:host=localhost;porta=3306;dbname=solar_system;charset=utf8";

Prima di tutto, impostiamo il prefisso del database o il prefisso del database. In questo caso, poiché ci stiamo connettendo a un database di tipo MySQL/MariaDB, stiamo utilizzando mysql. Abbiamo poi separato il prefisso dal resto della riga con i due punti, e ogni sezione successiva è stata separata dal resto con un punto e virgola.

Nelle due sezioni successive abbiamo specificato il nome host su cui è in esecuzione il database e la porta utilizzata per la connessione. Se non viene specificata alcuna porta, verrà utilizzata la porta predefinita, in questo caso 3306. Subito dopo il nome del database è charset .

Creazione di un oggetto DOP

Ora che il nostro DSN è pronto, inizieremo a creare l'oggetto PDO. Il costruttore PDO utilizza la stringa DSN come primo parametro, il nome utente del database come secondo parametro, la password come terzo e un array di impostazioni facoltativo come quarto.

$opzioni = [ PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ]; $pdo = nuovo PDO($dsn, "testuser", "testpassword", $opzioni);

Le impostazioni possono essere impostate anche dopo la creazione dell'oggetto, utilizzando il metodo SetAttribute():

$pdo->SetAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

Impostazione PDO per la visualizzazione degli errori

Diamo un'occhiata ad alcune delle opzioni disponibili per PDO::ATTR_ERRMODE. Queste opzioni sono estremamente importanti perché determinano il comportamento del PDO quando si verificano errori. Opzioni possibili:

PDO::ERRMODE_SILENT

Opzione predefinita. PDO genererà semplicemente un codice di errore e un messaggio di errore. Possono essere ottenuti utilizzando i metodi errorCode() e errorInfo().

PDO::ERRMODE_EXCEPTION

Questa opzione è, a mio parere, consigliata da utilizzare. Con il suo aiuto, oltre a emettere un codice di errore e informazioni, PDO lancerà una PDOException, che interromperà l'esecuzione dello script, ed è utile anche per le transazioni PDO (le vedremo tra poco).

PDO::ERRMODE_WARNING

Con questa opzione, PDO visualizzerà un codice di errore e un messaggio proprio come PDO::ERRMODE_SILENT , ma visualizzerà anche un avviso di AVVISO che non interrompe lo script.

Impostazione del metodo di campionamento predefinito

Un'altra impostazione importante viene regolata utilizzando la costante PDO::DEFAULT_FETCH_MODE. Permette di configurare il funzionamento predefinito del metodo fetch(), che verrà utilizzato per ottenere i risultati della richiesta. Ecco le opzioni più comunemente utilizzate:

PDO::FETCH_BOTH

Quando lo si utilizza, i risultati ottenuti verranno indicizzati sia tramite numeri interi che tramite nomi di colonna. Usandolo in un metodo per ottenere una riga da una tabella di pianeti ci darà i seguenti risultati:

$stmt = $pdo->query("SELECT * FROM pianeti"); $risultati = $stmt->fetch(PDO::FETCH_BOTH);

Array ( => 1 => 1 => terra => terra => blu => blu)

PDO::FETCH_ASSOC

Con questa costante, i risultati verranno scritti in un array associativo in cui ciascuna chiave sarà un nome di colonna e ciascun valore rappresenterà un valore specifico nella riga:

$stmt = $pdo->query("SELECT * FROM pianeti"); $risultati = $stmt->fetch(PDO::FETCH_ASSOC);

Array ( => 1 => terra => blu)

PDO::FETCH_NUM

Utilizzando la costante PDO::FETCH_NUM otteniamo un array con indice 0:

Array ( => 1 => terra => blu)

PDO::FETCH_COLUMN

Questa costante è utile per ottenere solo i valori da una colonna e il metodo restituirà tutti i risultati all'interno di un semplice array unidimensionale. Ad esempio, ecco una richiesta:

$stmt = $pdo->query("SELEZIONA nome DA pianeti");

Di conseguenza:

Array ( => terra => Marte => Giove)

PDO::FETCH_KEY_PAIR

Questa costante è utile per ottenere solo i valori da una colonna e il metodo restituirà tutti i risultati all'interno di un semplice array unidimensionale. Ad esempio, ecco una richiesta:

Questa costante è utile quando è necessario ottenere valori da due colonne. Il metodo fetchAll() restituirà i risultati come un array associativo. In questo array, i dati della prima colonna verranno specificati sotto forma di chiavi e della seconda come valori:

$stmt = $pdo->query("SELEZIONA nome, colore DA pianeti"); $risultato = $stmt->fetchAll(PDO::FETCH_KEY_PAIR);

Array ( => blu => rosso => ​​strano)

PDO::FETCH_OBJECT

Quando si utilizza la costante PDO::FETCH_OBJECT, verrà creato un oggetto anonimo per ogni riga recuperata. Le sue proprietà (pubbliche) avranno lo stesso nome delle colonne e i risultati della query verranno utilizzati come valori. L'utilizzo di questo metodo per la stessa query di cui sopra produrrà il seguente risultato:

$risultati = $stmt->fetch(PDO::FETCH_OBJ);

Oggetto stdClass ( => terra => blu)

Non farci caso alla semplicità del codice, guardiamo meglio la classe Planet che abbiamo creato: ha private nelle sue proprietà e la classe non ha un costruttore. Ora proviamo a ottenere risultati.

Quando si utilizza fetch() con PDO::FETCH_CLASS è necessario utilizzare il metodo setFetchMode() sull'oggetto prima di tentare di recuperare i dati, ad esempio:

$stmt = $pdo->query("SELEZIONA nome, colore DA pianeti"); $stmt->setFetchMode(PDO::FETCH_CLASS, "Pianeta");

Specifichiamo la costante PDO::FETCH_CLASS come primo argomento del metodo setFetchMode() e il nome della classe utilizzata per creare l'oggetto (nel nostro caso “Planet”) come secondo argomento. Ora eseguiamo il codice:

$pianeta = $stmt->fetch();

Ciò dovrebbe risultare in un oggetto Pianeta:

Var_dump($pianeta);

Oggetto pianeta ( => terra => blu)

Si noti come i valori restituiti dalla query siano stati assegnati alle corrispondenti caratteristiche dell'oggetto, pur essendo private.

Assegnazione delle caratteristiche dopo la creazione di un oggetto

La classe “Planet” non aveva un costruttore specifico, quindi non ci sono stati problemi con l'assegnazione delle caratteristiche; ma cosa succede se la classe ha un costruttore in cui le caratteristiche vengono impostate e modificate? Poiché i valori vengono assegnati prima dell'esecuzione del costruttore, verranno sovrascritti.

PDO aiuta a fornire la costante FETCH_PROPS_LATE: se utilizzata, i valori verranno assegnati dopo la creazione dell'oggetto. Esempio:

Classe Pianeta ( private $name; private $color; public function __construct($name = moon, $color = grey) ( $this->name = $name; $this->color = $color; ) public function setName($ planet_name) ( $this->name = $planet_name; ) funzione pubblica setColor($planet_color) ( $this->color = $planet_color; ) funzione pubblica getName() ( return $this->name; ) funzione pubblica getColor() (restituisci $questo->colore;))

Abbiamo modificato la nostra classe Planet per creare un costruttore che accetterà due argomenti: name name e color . Questi argomenti hanno i valori base luna e grigio, il che significa che se non vengono forniti altri valori, questi verranno impostati.

In questo caso, se non utilizziamo FETCH_PROPS_LATE, indipendentemente dai valori ottenuti dal database, tutte le caratteristiche rimarranno basilari, poiché durante il processo di creazione dell'oggetto verranno sovrascritte. Per verificarlo, eseguiamo la seguente query:

Ora diamo un'occhiata all'oggetto Pianeta e controlliamo quali valori corrispondono alle sue caratteristiche:

Var_dump($pianeta);

oggetto(Pianeta)#2 (2) ( ["name":"Pianeta":privato]=> string(4) "luna" ["color":"Pianeta":privato]=> string(4) "grigio" )

Come previsto, i valori recuperati dal database sono stati sovrascritti dai valori predefiniti. Ora dimostreremo la soluzione ai problemi utilizzando la costante FETCH_PROPS_LATE (e la stessa query della precedente):

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Pianeta"); $pianeta = $stmt->fetch(); var_dump($pianeta);

oggetto(Pianeta)#4 (2) ( ["name":"Pianeta":privato]=> string(5) "terra" ["color":"Pianeta":privato]=> string(4) "blu" )

Alla fine si è ottenuto il risultato desiderato. Ma cosa succede se il costruttore della classe non ha valori di base e devono essere specificati? Questo è già più semplice: possiamo impostare i parametri del costruttore sotto forma di array, come terzo argomento dopo il nome della classe, utilizzando il metodo setFetchMode(). Ad esempio, cambiamo il costruttore:

Classe Pianeta ( private $name; private $color; public function __construct($name, $color) ( $this->name = $name; $this->color = $color; ) [...] )

Gli argomenti del costruttore ora sono obbligatori, quindi eseguiamo:

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Pianeta", ["luna", "grigio"]);

In questo caso, i parametri che specifichiamo servono solo come valori di base necessari affinché l'oggetto funzioni senza errori: verranno sovrascritti dai valori del database.

Recupero di più oggetti

Ovviamente è possibile ottenere più risultati contemporaneamente sotto forma di oggetti, utilizzando il metodo fetch() o tramite un ciclo:

While ($planet = $stmt->fetch()) ( // Qualcosa a che fare con i risultati )

Oppure ottenere tutti i risultati in una volta. In questo caso, come accennato in precedenza, quando si utilizza il metodo fetchAll() sarà necessario specificare la modalità di recupero non prima di eseguire il metodo, ma nel momento in cui viene eseguito:

$stmt->fetchAll(PDO::FETCH_CLASS|PDO_FETCH_PROPS_LATE, "Pianeta", ["luna", "grigio"]);

PDO::FETCH_INTO

Utilizzando questa costante, PDO non crea un nuovo oggetto ma aggiorna le caratteristiche di uno esistente, ma solo se è pubblico o se all'interno dell'oggetto viene utilizzato il metodo __set().

Preparato contro richieste dirette

Esistono due metodi principali per utilizzare le query dirette: query() e exec() . Il primo crea un oggetto PDOStatemnt, a cui è possibile accedere tramite i metodi fetch() o fetchAll(): se li usi nei casi in cui la tabella non cambia, come SELECT .

Il secondo metodo, invece, restituisce il numero della riga che è stata modificata dalla query: lo usiamo nei casi che sostituiscono righe, come INSERT, DELETE o UPDATE. Le query dirette dovrebbero essere utilizzate solo nei casi in cui non sono presenti variabili nelle query e non vi sono dubbi sulla sicurezza del metodo.

Domande preparate

PDO supporta anche query preparate in due passaggi: queste sono utili quando le query hanno variabili e sono più sicure in generale poiché il metodo prepare() farà tutto il lavoro necessario per noi. Diamo un'occhiata a come vengono utilizzate le variabili. Immaginiamo di voler inserire le caratteristiche di un pianeta nella tabella Pianeti. Per prima cosa prepariamo una richiesta:

$stmt = $pdo->prepare("INSERT INTO planets(name, color) VALUES(?, ?)");

Come affermato in precedenza, utilizziamo il metodo prepare() che prende come argomento la query SQL, utilizzando valori temporanei per le variabili. I valori temporanei possono essere di due tipi: posizionali e nominali.

Posizionale

Usando? valori temporanei posizionali, il codice è più conciso, ma dobbiamo specificare i dati da inserire nello stesso ordine dei nomi delle colonne nell'array fornito come argomento al metodoexecute():

$stmt->execute([$planet->nome, $planet->colore]);

Personalizzato

Utilizzando i segnaposto con nome, non abbiamo bisogno di un ordine specifico, ma di conseguenza otteniamo più codice. Quando eseguiamo il metodoexe(), dobbiamo fornire i dati sotto forma di un array associativo, dove ogni chiave è il nome del valore temporaneo utilizzato e il valore associato è ciò che viene portato nella query. Ad esempio, la richiesta precedente diventerebbe:

$stmt = $pdo->prepare("INSERT INTO planets(name, color) VALUES(:name, :color)"); $stmt->execute(["nome" => $pianeta->nome, "colore" => $pianeta->colore]);

I metodi prepare() ed executive() possono essere entrambi utilizzati per query che modificano o semplicemente recuperano informazioni dal database. Nel primo caso utilizziamo i metodi fetch sopra elencati per ottenere informazioni, nel secondo utilizziamo il metodo rowCount().

metodi bindValue() e bindParam()

I metodi bindValue() e bindParam() possono essere utilizzati anche per fornire i valori che verranno inseriti nella richiesta. Il primo lega il valore di una determinata variabile a un valore posizionale o temporaneo denominato utilizzato nella preparazione della richiesta. Prendendo come esempio il caso precedente, faremo:

$stmt->bindValue("nome", $planet->nome, PDO::PARAM_STR);

Associamo il valore di $planet->name a un valore temporaneo:name . Si noti che utilizzando entrambi i metodi bindValue() e bindParam() possiamo anche specificare il tipo della variabile come terzo argomento utilizzando una costante PDO adeguata, in questo caso PDO::PARAM_STR .

Usando bindParam() invece possiamo associare la variabile ad un valore temporaneo adatto utilizzato nella preparazione della query. Tieni presente che in questo caso la variabile è legata al riferimento e il suo valore verrà modificato in temporaneo solo quando viene eseguito il metodoexe(). La sintassi è la stessa dell'ultima volta:

$stmt->bindParam("nome", $planet->nome, PDO::PARAM_STR)

Abbiamo associato la variabile, non il suo valore, $planet->name a:name ! Come detto sopra, la sostituzione avverrà solo quando verrà eseguito il metodoexe(), quindi il valore temporaneo verrà sostituito con il valore della variabile in quel momento.

Transazioni DOP

Le transazioni consentono di mantenere la coerenza durante l'esecuzione di più query. Tutte le query vengono eseguite in batch e applicate al database solo se hanno tutte esito positivo. Le transazioni non funzioneranno con tutti i database e non con tutti i costrutti SQL, poiché alcuni di essi causano problemi.

Come esempio estremo e strano, immaginiamo che l'utente debba selezionare una lista di pianeti e ogni volta che effettua una nuova selezione, si debba cancellare quella precedente dal database prima di inserirne una nuova. Cosa succede se avviene la cancellazione ma l'inserimento no? Avremo un utente senza pianeti! Fondamentalmente, le transazioni vengono applicate in questo modo:

$pdo->beginTransaction(); try ( $stmt1 = $pdo->exec("DELETE FROM planets"); $stmt2 = $pdo->prepare("INSERT INTO planets(name, color) VALUES (?, ?)"); foreach ($planets as $planet) ( $stmt2->execute([$planet->getName(), $planet->getColor()]); ) $pdo->commit() ) catch (PDOException $e) ( $pdo-> rollBack ();

Innanzitutto il metodo BeginTransaction() sull'oggetto PDO disabilita l'autocommit della richiesta, poi le richieste vengono avviate nell'ordine richiesto. A questo punto, a meno che non si verifichi una PDOException, le richieste vengono automaticamente passate tramite il metodo commit(), altrimenti le transazioni vengono annullate tramite il metodo rollBack() e l'autocommit viene ripristinato;

In questo modo, con più richieste, ci sarà sempre coerenza. Questo è abbastanza ovvio, ma le transazioni PDO possono essere utilizzate solo da PDO::ATTR_ERRMODE impostato su PDO::ERRMODE_EXCEPTION .

Termine DOPè un'abbreviazione del concetto Oggetti dati PHP. Come suggerisce il nome, questa tecnologia consente di lavorare con i contenuti del database tramite oggetti.

Perché non myqli o mysql?

Molto spesso, per quanto riguarda le nuove tecnologie, sorge la questione dei loro vantaggi rispetto ai buoni vecchi e collaudati strumenti, nonché del trasferimento ad essi di progetti attuali e vecchi.

DOP di orientamento agli oggetti

PHP Si sta sviluppando molto attivamente e si sforza di diventare uno dei migliori strumenti per il rapido sviluppo di applicazioni web, sia a livello di massa che aziendale.

Parlando di PHP, intendiamo il moderno orientato agli oggetti PHP, consentendoti di scrivere codice universale comodo da testare e riutilizzare.

Utilizzo DOP consente di spostare il lavoro del database a un livello orientato agli oggetti e migliorare la portabilità del codice. In effetti, l'uso DOP non così difficile come si potrebbe pensare.

Astrazione

Immaginiamo di sviluppare un'applicazione da molto tempo utilizzando MySQL. E poi, ad un certo punto, diventa necessario sostituire MySQL SU PostgreSQL.

Come minimo, dovremo sostituire tutte le chiamate mysqli_connect() (mysql_connect()) SU pg_connect() e, per analogia, altre funzioni utilizzate per interrogare ed elaborare dati.

Quando si utilizza DOP, ci limiteremo a modificare alcuni parametri nei file di configurazione.

Associazione dei parametri

L'utilizzo di parametri collegati fornisce una maggiore flessibilità nella progettazione delle query e migliora la protezione contro SQL iniezioni.

Ricevere dati come oggetti

Coloro che stanno già utilizzando ORM(mappatura relazionale di oggetti - mappatura relazionale di oggetti dei dati), ad esempio, Dottrina, conoscere la comodità di rappresentare i dati dalle tabelle del database sotto forma di oggetti. DOP consente di ricevere dati sotto forma di oggetti e senza utilizzarli ORM.

L'estensione mysql non è più supportata

Supporto per l'estensione mysql rimosso definitivamente dal nuovo PHP7. Se prevedi di migrare il progetto a una nuova versione PHP, dovresti usare almeno mysqli adesso. Certo, è meglio iniziare a usare DOP se non lo hai già fatto.

Mi sembra che queste ragioni siano sufficienti a far pendere la bilancia a favore dell'utilizzo DOP. Inoltre, non è necessario installare nulla di aggiuntivo.

Verifica della presenza di PDO nel sistema

Versioni PHP5.5 e superiori, molto spesso, contengono già un'estensione con cui lavorare DOP. Per verificare basta eseguire un semplice comando nella console:

php -i | grep "pdo"

Ora apriamolo in un browser qualsiasi e troviamo i dati necessari effettuando una ricerca per riga DOP.

Conoscere la DOP

Processo di lavoro con DOP non troppo diverso da quello tradizionale. In generale, il processo di utilizzo DOP assomiglia a questo:

1. Connettersi al database;
2. Se necessario, preparare una richiesta e collegare i parametri;
3. Esecuzione della richiesta.

Connessione al database

Per connettersi al database è necessario creare un nuovo oggetto DOP e passargli il nome dell'origine dati, noto anche come DSN.

Generalmente, DSNè costituito dal nome del driver separato da due punti da una stringa di connessione specifica per ciascun driver DOP.

Per MySQL, il collegamento viene effettuato in questo modo:

$connessione = nuovo PDO("mysql:host=localhost;dbname=mydb;charset=utf8", "root", "root");

$connessione = nuovo PDO ( "mysql:host=localhost;dbname=miodb;charset=utf8", "radice", "radice");

In questo caso, DSN contiene il nome del driver mysql, indicazione dell'host (possibile formato host=NOME_HOST:PORTA), nome del database, codifica, nome utente MySQL e la sua password.

Richieste

A differenza di mysqli_query(), V DOP ci sono due tipi di richieste:

• Restituendo il risultato ( seleziona, mostra);
• Non restituisce un risultato ( inserire, dettaglio e altri).

Innanzitutto consideriamo la seconda opzione.

Esecuzione di query

Diamo un'occhiata ad un esempio di esecuzione di una richiesta utilizzando l'esempio inserire.

$connection->exec("INSERT INTO users VALUES (1, "somevalue"");

$connessione -> exec () ;

Naturalmente, questa query restituisce il numero di righe interessate e puoi vederlo come segue.

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

$affectedRows = $connessione -> exec ( "INSERISCI I VALORI degli utenti (1, "qualchevalore"") ; echo $righeaffette;

Ottenere i risultati della query

In caso di utilizzo mysqli_query(), il codice potrebbe essere il seguente.

$risultato = mysql_query("SELECT * FROM utenti"); while($riga = mysql_fetch_assoc($risultato)) ( echo $riga["id"] . " " . $riga["nome"]; )

$risultato = mysql_query ("SELECT * FROM utenti"); while ($riga = mysql_fetch_assoc ($risultato) ) (

Per DOP, il codice sarà più semplice e conciso.

foreach($connessione->query("SELECT * FROM utenti") as $riga) ( echo $riga["id"] . " " . $riga["nome"]; )

foreach ($connessione -> query ("SELECT * FROM utenti") as $row ) ( echo $riga [ "id" ] . " " . $riga["nome"];

Modalità di acquisizione dei dati

Come in mysqli, DOP consente di ricevere dati in diverse modalità. Per determinare la modalità, class DOP contiene le costanti corrispondenti.

• DOP::FETCH_ASSOC— restituisce un array indicizzato in base al nome della colonna nella tabella del database;
• PDO::FETCH_NUM— restituisce un array indicizzato per numero di colonna;
• DOP::FETCH_OBJ- restituisce un oggetto anonimo con nomi di proprietà corrispondenti ai nomi di colonna. Ad esempio, $row->id conterrà il valore della colonna id.
• PDO::FETCH_CLASS— restituisce una nuova istanza della classe, con valori di proprietà corrispondenti ai dati della riga della tabella. Se il parametro è specificato PDO::FETCH_CLASSTYPE(Per esempio PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE

), il nome della classe sarà determinato dal valore della prima colonna. Nota

: Questo non è un elenco completo; tutte le possibili costanti e le relative combinazioni sono disponibili nella documentazione.

Un esempio per ottenere un array associativo:

$istruzione = $connessione->query("SELECT * FROM utenti"); while($riga = $istruzione->fetch(PDO::FETCH_ASSOC)) ( echo $riga["id"] . " " . $riga["nome"]; ) $istruzione = $connessione -> echo $riga [ "id" ] . " " . $riga["nome"];

), il nome della classe sarà determinato dal valore della prima colonna. while ($riga = $istruzione -> recupera (PDO::FETCH_ASSOC) ) ( : Si consiglia di specificare sempre la modalità di campionamento poiché la modalità PDO::FETCH_BOTH

richiederà il doppio della memoria: verranno infatti creati due array, associativo e regolare. PDO::FETCH_CLASS Prendi in considerazione l'utilizzo della modalità di campionamento . Creiamo una classe:

Utente

class Utente ( protected $id; protected $name; public function getId() ( return $this->id; ) public function setId($id) ( $this->id = $id; ) public function getName() ( return $questo->nome; ) funzione pubblica setName($nome) ( $questo->nome = $nome; ) ) utente della classe $id protetto; $nome protetto; funzione pubblica getId() return $questo -> id; funzione pubblica setId ($id) $questo -> id = $id; funzione pubblica getName() return $questo -> nome; funzione pubblica setName ($nome)

$questo -> nome = $nome;

Ora selezioniamo i dati e visualizziamo i dati utilizzando i metodi della classe:

$istruzione = $connessione->query("SELECT * FROM utenti"); while($riga = $istruzione->fetch(PDO::FETCH_CLASS, "Utente")) ( echo $riga->getId() . " " . $riga->getNome(); ) $istruzione = $connessione -> query ("SELECT * FROM utenti"); echo $riga -> getId() . " " . $riga -> getNome () ;

Query preparate e associazione di parametri

Per comprendere l'essenza e tutti i vantaggi del collegamento dei parametri, è necessario dare un'occhiata più da vicino ai meccanismi DOP. Quando chiami $istruzione -> query() nel codice qui sopra, DOP preparerà una richiesta, la eseguirà e restituirà il risultato.

Quando chiami $connessione -> prepara() viene creata una richiesta preparata. Le query preparate sono la capacità di un sistema di gestione del database di ricevere un modello di query, compilarlo ed eseguirlo dopo aver recuperato i valori delle variabili utilizzate nel modello. I motori dei modelli funzionano in modo simile. Intelligente E Ramoscello.

Quando chiami $istruzione -> esegui() i valori per la sostituzione vengono trasferiti al modello di query e il DBMS esegue la query. Questa azione è simile alla chiamata della funzione del motore del modello rendere().

Un esempio di utilizzo delle query preparate in PHP DOP:

Nel codice sopra viene preparata una richiesta per la selezione di un record con un campo id uguale al valore che verrà sostituito : id. In questa fase il DBMS analizzerà e compilerà la richiesta, eventualmente utilizzando il caching (a seconda delle impostazioni).

Ora devi passare il parametro mancante ed eseguire la richiesta:

$id = 5; $istruzione->execute([ ":id" => $id ]);

Vantaggi dell'utilizzo dei parametri collegati

Forse dopo aver esaminato il funzionamento delle query preparate e i parametri associati, i vantaggi derivanti dal loro utilizzo diventano evidenti.

DOP fornisce un modo conveniente per sfuggire ai dati utente, ad esempio, un codice come questo non è più necessario:

Invece adesso è consigliabile fare così:

Puoi anche abbreviare ulteriormente il codice utilizzando parametri numerati invece di quelli denominati:

Allo stesso tempo, l'utilizzo di query preparate migliora le prestazioni quando si utilizza più volte lo stesso modello di query. Un esempio di selezione di cinque utenti casuali da un database:

$numberOfUsers = $connection->query("SELECT COUNT(*) FROM users")->fetchColumn(); $utenti = ; $istruzione = $connessione->prepare("SELECT * FROM utenti WHERE id = ? LIMIT 1"); per ($i = 1; $i<= 5; $i++) { $id = rand(1, $numberOfUsers); $users = $statement->esegui([$id])->fetch(PDO::FETCH_OBJ); )

$numberOfUsers = $connection -> query ("SELECT COUNT(*) FROM users" ) -> fetchColumn () ; $utenti = ; per ($i = 1 ; $i<= 5 ; $i ++ ) { $id = rand (1, $numeroUtenti) ; $utenti = $istruzione -> esegui ([$id]) -> recupera (PDO::FETCH_OBJ);

Quando si chiama un metodo preparare(), il DBMS analizzerà e compilerà la richiesta, utilizzando la memorizzazione nella cache se necessario. Più avanti nel ciclo per, vengono campionati solo i dati con il parametro specificato. Questo approccio consente di recuperare i dati più velocemente, riducendo i tempi di esecuzione dell'applicazione.

Per ottenere il numero totale di utenti nel database, è stato utilizzato il metodo recuperareColonna(). Questo metodo recupera il valore di una singola colonna ed è utile quando si recuperano valori scalari come conteggio, somma, valori massimi o minimi.

Valori vincolati e operatore IN

Spesso, quando si inizia a lavorare DOP, sorgono difficoltà con l'operatore IN. Ad esempio, immagina che l'utente inserisca diversi nomi separati da virgole. L'input dell'utente viene memorizzato in una variabile $nomi.

Termine DOPè un'abbreviazione del concetto Oggetti dati PHP. Come suggerisce il nome, questa tecnologia consente di lavorare con i contenuti del database tramite oggetti.

Perché non myqli o mysql?

Molto spesso, per quanto riguarda le nuove tecnologie, sorge la questione dei loro vantaggi rispetto ai buoni vecchi e collaudati strumenti, nonché del trasferimento ad essi di progetti attuali e vecchi.

DOP di orientamento agli oggetti

PHP Si sta sviluppando molto attivamente e si sforza di diventare uno dei migliori strumenti per il rapido sviluppo di applicazioni web, sia a livello di massa che aziendale.

Parlando di PHP, intendiamo il moderno orientato agli oggetti PHP, consentendoti di scrivere codice universale comodo da testare e riutilizzare.

Utilizzo DOP consente di spostare il lavoro del database a un livello orientato agli oggetti e migliorare la portabilità del codice. In effetti, l'uso DOP non così difficile come si potrebbe pensare.

Astrazione

Immaginiamo di sviluppare un'applicazione da molto tempo utilizzando MySQL. E poi, ad un certo punto, diventa necessario sostituire MySQL SU PostgreSQL.

Come minimo, dovremo sostituire tutte le chiamate mysqli_connect() (mysql_connect()) SU pg_connect() e, per analogia, altre funzioni utilizzate per interrogare ed elaborare dati.

Quando si utilizza DOP, ci limiteremo a modificare alcuni parametri nei file di configurazione.

Associazione dei parametri

L'utilizzo di parametri collegati fornisce una maggiore flessibilità nella progettazione delle query e migliora la protezione contro SQL iniezioni.

Ricevere dati come oggetti

Coloro che stanno già utilizzando ORM(mappatura relazionale di oggetti - mappatura relazionale di oggetti dei dati), ad esempio, Dottrina, conoscere la comodità di rappresentare i dati dalle tabelle del database sotto forma di oggetti. DOP consente di ricevere dati sotto forma di oggetti e senza utilizzarli ORM.

L'estensione mysql non è più supportata

Supporto per l'estensione mysql rimosso definitivamente dal nuovo PHP7. Se prevedi di migrare il progetto a una nuova versione PHP, dovresti usare almeno mysqli adesso. Certo, è meglio iniziare a usare DOP se non lo hai già fatto.

Mi sembra che queste ragioni siano sufficienti a far pendere la bilancia a favore dell'utilizzo DOP. Inoltre, non è necessario installare nulla di aggiuntivo.

Verifica della presenza di PDO nel sistema

Versioni PHP5.5 e superiori, molto spesso, contengono già un'estensione con cui lavorare DOP. Per verificare basta eseguire un semplice comando nella console:

php -i | grep "pdo"

Ora apriamolo in un browser qualsiasi e troviamo i dati necessari effettuando una ricerca per riga DOP.

Conoscere la DOP

Processo di lavoro con DOP non troppo diverso da quello tradizionale. In generale, il processo di utilizzo DOP assomiglia a questo:

1. Connettersi al database;
2. Se necessario, preparare una richiesta e collegare i parametri;
3. Esecuzione della richiesta.

Connessione al database

Per connettersi al database è necessario creare un nuovo oggetto DOP e passargli il nome dell'origine dati, noto anche come DSN.

Generalmente, DSNè costituito dal nome del driver separato da due punti da una stringa di connessione specifica per ciascun driver DOP.

Per MySQL, il collegamento viene effettuato in questo modo:

$connessione = nuovo PDO("mysql:host=localhost;dbname=mydb;charset=utf8", "root", "root");

$connessione = nuovo PDO ( "mysql:host=localhost;dbname=miodb;charset=utf8", "radice", "radice");

In questo caso, DSN contiene il nome del driver mysql, indicazione dell'host (possibile formato host=NOME_HOST:PORTA), nome del database, codifica, nome utente MySQL e la sua password.

Richieste

A differenza di mysqli_query(), V DOP ci sono due tipi di richieste:

• Restituendo il risultato ( seleziona, mostra);
• Non restituisce un risultato ( inserire, dettaglio e altri).

Innanzitutto consideriamo la seconda opzione.

Esecuzione di query

Diamo un'occhiata ad un esempio di esecuzione di una richiesta utilizzando l'esempio inserire.

$connection->exec("INSERT INTO users VALUES (1, "somevalue"");

$connessione -> exec () ;

Naturalmente, questa query restituisce il numero di righe interessate e puoi vederlo come segue.

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

$affectedRows = $connessione -> exec ( "INSERISCI I VALORI degli utenti (1, "qualchevalore"") ; echo $righeaffette;

Ottenere i risultati della query

In caso di utilizzo mysqli_query(), il codice potrebbe essere il seguente.

$risultato = mysql_query("SELECT * FROM utenti"); while($riga = mysql_fetch_assoc($risultato)) ( echo $riga["id"] . " " . $riga["nome"]; )

$risultato = mysql_query ("SELECT * FROM utenti"); while ($riga = mysql_fetch_assoc ($risultato) ) (

Per DOP, il codice sarà più semplice e conciso.

foreach($connessione->query("SELECT * FROM utenti") as $riga) ( echo $riga["id"] . " " . $riga["nome"]; )

foreach ($connessione -> query ("SELECT * FROM utenti") as $row ) ( echo $riga [ "id" ] . " " . $riga["nome"];

Modalità di acquisizione dei dati

Come in mysqli, DOP consente di ricevere dati in diverse modalità. Per determinare la modalità, class DOP contiene le costanti corrispondenti.

• DOP::FETCH_ASSOC— restituisce un array indicizzato in base al nome della colonna nella tabella del database;
• PDO::FETCH_NUM— restituisce un array indicizzato per numero di colonna;
• DOP::FETCH_OBJ- restituisce un oggetto anonimo con nomi di proprietà corrispondenti ai nomi di colonna. Ad esempio, $row->id conterrà il valore della colonna id.
• PDO::FETCH_CLASS— restituisce una nuova istanza della classe, con valori di proprietà corrispondenti ai dati della riga della tabella. Se il parametro è specificato PDO::FETCH_CLASSTYPE(Per esempio PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE

), il nome della classe sarà determinato dal valore della prima colonna. Nota

: Questo non è un elenco completo; tutte le possibili costanti e le relative combinazioni sono disponibili nella documentazione.

Un esempio per ottenere un array associativo:

$istruzione = $connessione->query("SELECT * FROM utenti"); while($riga = $istruzione->fetch(PDO::FETCH_ASSOC)) ( echo $riga["id"] . " " . $riga["nome"]; ) $istruzione = $connessione -> echo $riga [ "id" ] . " " . $riga["nome"];

), il nome della classe sarà determinato dal valore della prima colonna. while ($riga = $istruzione -> recupera (PDO::FETCH_ASSOC) ) ( : Si consiglia di specificare sempre la modalità di campionamento poiché la modalità PDO::FETCH_BOTH

richiederà il doppio della memoria: verranno infatti creati due array, associativo e regolare. PDO::FETCH_CLASS Prendi in considerazione l'utilizzo della modalità di campionamento . Creiamo una classe:

Utente

class Utente ( protected $id; protected $name; public function getId() ( return $this->id; ) public function setId($id) ( $this->id = $id; ) public function getName() ( return $questo->nome; ) funzione pubblica setName($nome) ( $questo->nome = $nome; ) ) utente della classe $id protetto; $nome protetto; funzione pubblica getId() return $questo -> id; funzione pubblica setId ($id) $questo -> id = $id; funzione pubblica getName() return $questo -> nome; funzione pubblica setName ($nome)

$questo -> nome = $nome;

Ora selezioniamo i dati e visualizziamo i dati utilizzando i metodi della classe:

$istruzione = $connessione->query("SELECT * FROM utenti"); while($riga = $istruzione->fetch(PDO::FETCH_CLASS, "Utente")) ( echo $riga->getId() . " " . $riga->getNome(); ) $istruzione = $connessione -> query ("SELECT * FROM utenti"); echo $riga -> getId() . " " . $riga -> getNome () ;

Query preparate e associazione di parametri

Per comprendere l'essenza e tutti i vantaggi del collegamento dei parametri, è necessario dare un'occhiata più da vicino ai meccanismi DOP. Quando chiami $istruzione -> query() nel codice qui sopra, DOP preparerà una richiesta, la eseguirà e restituirà il risultato.

Quando chiami $connessione -> prepara() viene creata una richiesta preparata. Le query preparate sono la capacità di un sistema di gestione del database di ricevere un modello di query, compilarlo ed eseguirlo dopo aver recuperato i valori delle variabili utilizzate nel modello. I motori dei modelli funzionano in modo simile. Intelligente E Ramoscello.

Quando chiami $istruzione -> esegui() i valori per la sostituzione vengono trasferiti al modello di query e il DBMS esegue la query. Questa azione è simile alla chiamata della funzione del motore del modello rendere().

Un esempio di utilizzo delle query preparate in PHP DOP:

Nel codice sopra viene preparata una richiesta per la selezione di un record con un campo id uguale al valore che verrà sostituito : id. In questa fase il DBMS analizzerà e compilerà la richiesta, eventualmente utilizzando il caching (a seconda delle impostazioni).

Ora devi passare il parametro mancante ed eseguire la richiesta:

$id = 5; $istruzione->execute([ ":id" => $id ]);

Vantaggi dell'utilizzo dei parametri collegati

Forse dopo aver esaminato il funzionamento delle query preparate e i parametri associati, i vantaggi derivanti dal loro utilizzo diventano evidenti.

DOP fornisce un modo conveniente per sfuggire ai dati utente, ad esempio, un codice come questo non è più necessario:

Invece adesso è consigliabile fare così:

Puoi anche abbreviare ulteriormente il codice utilizzando parametri numerati invece di quelli denominati:

Allo stesso tempo, l'utilizzo di query preparate migliora le prestazioni quando si utilizza più volte lo stesso modello di query. Un esempio di selezione di cinque utenti casuali da un database:

$numberOfUsers = $connection->query("SELECT COUNT(*) FROM users")->fetchColumn(); $utenti = ; $istruzione = $connessione->prepare("SELECT * FROM utenti WHERE id = ? LIMIT 1"); per ($i = 1; $i<= 5; $i++) { $id = rand(1, $numberOfUsers); $users = $statement->esegui([$id])->fetch(PDO::FETCH_OBJ); )

$numberOfUsers = $connection -> query ("SELECT COUNT(*) FROM users" ) -> fetchColumn () ; $utenti = ; per ($i = 1 ; $i<= 5 ; $i ++ ) { $id = rand (1, $numeroUtenti) ; $utenti = $istruzione -> esegui ([$id]) -> recupera (PDO::FETCH_OBJ);

Quando si chiama un metodo preparare(), il DBMS analizzerà e compilerà la richiesta, utilizzando la memorizzazione nella cache se necessario. Più avanti nel ciclo per, vengono campionati solo i dati con il parametro specificato. Questo approccio consente di recuperare i dati più velocemente, riducendo i tempi di esecuzione dell'applicazione.

Per ottenere il numero totale di utenti nel database, è stato utilizzato il metodo recuperareColonna(). Questo metodo recupera il valore di una singola colonna ed è utile quando si recuperano valori scalari come conteggio, somma, valori massimi o minimi.

Valori vincolati e operatore IN

Spesso, quando si inizia a lavorare DOP, sorgono difficoltà con l'operatore IN. Ad esempio, immagina che l'utente inserisca diversi nomi separati da virgole. L'input dell'utente viene memorizzato in una variabile $nomi.

Connessione al database viene impostato quando viene creata un'istanza della classe PDO. Non importa quale driver scegli di utilizzare; Sarà sempre necessario utilizzare la classe PDO. Il suo costruttore accetta parametri per specificare l'origine del database (noto come DSN) e parametri facoltativi per nome utente e password.

Connessione a MySQL:

$dbh = nuovo PDO("mysql:host=localhost;dbname=test", $utente, $pass);

Se si verificano errori di connessione, verrà lanciata un'eccezione: un oggetto della classe PDOException. Puoi prenderlo se vuoi gestire questa situazione, oppure puoi lasciarlo per il gestore delle eccezioni globali, che è impostato tramite set_exception_handler().

Gestione degli errori di connessione:

try ( $dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass); foreach($dbh->query('SELECT * from FOO') as $row) ( print_r($ row); ) $dbh = null; ) catch (PDOException $e) ( die("Errore! Questo è tutto. Eccoci qui... ".$e->getMessage()); )

Attenzione: Se non rilevi l'eccezione lanciata dal costruttore PDO, l'azione predefinita intrapresa dal motore zend è interrompere lo script e mostrare un traceback. Questa schifezza rivelerà tutti i tuoi dettagli intimi di comunicazione con il database. Questo è mostrerà i dettagli dettagliati della connessione al database inclusi nome utente e password! Spetta a te rilevare questa eccezione, in modo esplicito (tramite una dichiarazione prova a prendere), o implicitamente tramite set_exception_handler().

Una volta che la connessione a un database ha esito positivo, rimane attiva per l'intera vita dell'istanza dell'oggetto PDO. Per chiudere una connessione è necessario distruggere l'oggetto, assicurandosi che tutti i rimanenti riferimenti ad esso vengano rimossi: ciò può essere fatto assegnando il valore NULL alla variabile che contiene l'oggetto. Se non lo fai esplicitamente, PHP chiuderà automaticamente la connessione all'uscita dello script.

Chiusura di una connessione:

$dbh = nuovo PDO("mysql:host=localhost;dbname=test", $utente, $pass);

// Stiamo facendo qualcosa qui: ... // E ora, attenzione: fine della connessione!

$dbh = nullo;

Molte applicazioni Web traggono vantaggio dalla creazione di connessioni persistenti ai server di database. Le connessioni persistenti non vengono chiuse alla chiusura dello script, ma vengono memorizzate nella cache e riutilizzate quando un altro script richiede connessioni utilizzando le stesse credenziali di connessione. Una cache di connessione persistente evita il sovraccarico di stabilire una nuova connessione ogni volta che uno script deve comunicare con il database, con il risultato che le applicazioni web vengono eseguite più velocemente.

Configurazione di una connessione permanente:$dbh = nuovo PDO("mysql:host=localhost;dbname=test", $utente, $pass, array(PDO::ATTR_PERSISTENT => true)); Tieni presente: Se si desidera utilizzare una connessione persistente, è necessario impostare PDO::ATTR_PERSISTENT nell'array delle opzioni del driver, che viene passato al costruttore della classe PDO. Impostando questo attributo tramite PDO::setAttribute() dopo aver creato un'istanza dell'oggetto, il driver non utilizzerà collegamenti persistenti. Inoltre, in questo caso, non sarai in grado di estendere la classe PDOStament per alcune delle tue esigenze, ad es.

non sarà possibile installare:

DOP::ATTR_STATEMENT_CLASS

Le funzioni mysql in PHP per lavorare con i database sono ormai obsolete da tempo; oggi è consigliabile utilizzare mysqli o PDO (PHP Data Objects); Inoltre, mysqli è una libreria che, in generale, non è destinata ad essere utilizzata direttamente nel codice. Può servire come buon materiale da costruzione per creare una libreria di livello superiore. Quando lavori con mysqli, dovresti anche ricordarti di garantire la sicurezza della tua applicazione, in particolare la protezione contro le SQL injection. Nel caso dell'utilizzo di PDO (con le relative query preparate), tale protezione è immediata; la cosa principale è applicare correttamente i metodi necessari;

Testare il database con la tabella

// Dalla console Windows mysql> CREATE DATABASE `pdo-test` CHARACTER SET utf8 COLLATE utf8_general_ci; UTILIZZARE il test pdo; Categorie CREATE TABLE (id INT(11) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), nome VARCHAR(255) NOT NULL); INSERISCI IN `categorie` (`nome`) VALORI ("Laptop e tablet"), ("Computer e periferiche"), ("Componenti PC"), ("Smartphone e smartwatch"), ("TV e media") , ("Giochi e console"), ("Apparecchiature audio"), ("Apparecchiature foto e video"), ("Attrezzature e mobili per ufficio"), ("Apparecchiature di rete"), ("Grandi elettrodomestici"), ( "Prodotti per la Cucina"), ("Bellezza e Salute"), ("Prodotti per la Casa"), ("Strumenti"), ("Prodotti per l'Auto");

Installazione DOP

// Installazione su Linux sudo apt update sudo apt install php7.2-mysql sudo apt-get install pdo-mysql // In php.ini aggiungi extension=pdo.so extension=pdo_mysql.so // Su Windows, di regola, il driver è già installato, devi solo verificare se è abilitato in php.ini extension=php_pdo_mysql.dll

Controlla i driver disponibili

print_r(PDO::getAvailableDrivers());

Connessione al database

Le connessioni vengono stabilite automaticamente quando un oggetto PDO viene creato dalla relativa classe base.

// Esempio n.1. Connessione semplice $db = new PDO("mysql:host=localhost;dbname=pdo", "root", "password");

Se si verifica un errore di connessione, PHP genererà un errore:

Errore irreversibile: PDOException non rilevata: ... // Esempio n.2. Gestione degli errori di connessione try ( $dbh = new PDO("mysql:host=localhost;dbname=pdo", "root", "password"); ) catch (PDOException $e) ( print "Errore!: " . $e- >getMessaggio();

In questo esempio di connessione utilizziamo il costrutto try...catch. Molti discutono sull'opportunità del suo utilizzo. Personalmente utilizzo try...catch , non mi dà fastidio.

Richieste preparate e dirette

Esistono due modi per eseguire query in PDO:

• Diretto: consiste in un passaggio;
• Preparato: consiste di due passaggi.

Richieste dirette

• query() viene utilizzato per istruzioni che non apportano modifiche, come SELECT. Restituisce un oggetto PDOStatemnt da cui vengono recuperati i risultati della query utilizzando i metodi fetch() o fetchAll. Puoi confrontarlo con la risorsa mysql, che è stata restituita da mysql_query().
• exec() viene utilizzato per le istruzioni INSERT, DELETE, UPDATE. Restituisce il numero di righe elaborate dalla richiesta.

Le query dirette vengono utilizzate solo se non sono presenti variabili nella query e si è certi che la query sia sicura e correttamente sottoposta a escape.

$stmt = $db->query("SELECT * FROM categorie"); while ($riga = $stmt->fetch()) ( echo "

"; print_r($riga); )
Domande preparate
Se alla richiesta viene passata almeno una variabile, questa richiesta deve essere eseguita solo tramite espressioni preparate.  Cosa significa?  Questa è una normale query SQL, in cui al posto della variabile viene inserito un indicatore speciale: un segnaposto.  PDO supporta segnaposto posizionali (?), per i quali l'ordine delle variabili passate è importante, e segnaposto denominati (:name), per i quali l'ordine non è importante.  Esempi:
$sql = "SELEZIONA nome DALLE categorie WHERE id =?";  $sql = "SELEZIONA nome DALLE categorie WHERE nome = :nome";
Per eseguire una query di questo tipo, è necessario prima prepararla utilizzando il metodo prepare().  Restituisce anche un'istruzione PDO, ma senza ancora alcun dato.  Per ottenerli dobbiamo eseguire questa richiesta, dopo avervi precedentemente passato le nostre variabili.  Puoi passarlo in due modi: nella maggior parte dei casi puoi semplicemente eseguire il metodoexecute(), passandogli un array con variabili:
$stmt = $pdo->prepare("SELEZIONA `nome` DALLE categorie WHERE `id` = ?");  $stmt->execute([$id]);  $stmt = $pdo->prepare("SELEZIONA `nome` FROM categorie WHERE `nome` = :nome");  $stmt->execute(["nome" => $nome]);
Come puoi vedere, nel caso dei segnaposto con nome, un array in cui le chiavi devono corrispondere ai nomi dei segnaposto deve essere passato aexecute().  È quindi possibile recuperare i risultati della query:
$id = 1;  $stmt = $db->prepare("SELECT * FROM categorie WHERE `id` = ?");  $stmt->execute([$id]);  $categoria = $stmt->fetch(PDO::FETCH_LAZY);  eco" 
"; print_r($categoria);

IMPORTANTE! Le query preparate sono il motivo principale per utilizzare PDO perché è l'unico modo sicuro per eseguire query SQL che coinvolgono variabili.

Ricezione dei dati.  metodo fetch()
Abbiamo già conosciuto il metodo fetch(), che viene utilizzato per ottenere righe in sequenza dal database.  Questo metodo è un analogo della funzione mysq_fetch_array() e simili, ma agisce in modo diverso: invece di molte funzioni, qui ne viene utilizzata una, ma il suo comportamento è specificato dal parametro passato.  Verranno scritti i dettagli su questi parametri e, come breve raccomandazione, ti consiglio di utilizzare fetch() nella modalità FETCH_LAZY
$id = 1;  $stmt = $db->prepare("SELECT * FROM categorie WHERE `id` = ?");  $stmt->execute([$id]);  while ($riga = $stmt->fetch(PDO::FETCH_LAZY)) ( echo "Nome categoria: ".$riga->nome; )
In questa modalità, non viene sprecata memoria aggiuntiva e inoltre è possibile accedere alle colonne in tre modi: tramite indice, nome o proprietà (tramite ->).  Lo svantaggio di questa modalità è che non funziona con fetchAll()
Ricezione dei dati.  metodo fetchColumn()
L'istruzione PDO dispone anche di un metodo per ottenere il valore di una singola colonna.  È molto comodo se richiediamo un solo campo: in questo caso la quantità di codice è notevolmente ridotta:
$id = 1;  $stmt = $db->prepare("SELEZIONA `nome` DALLE categorie DOVE `id` = ?");  $stmt->execute([$id]);  $nome = $stmt->fetchColumn();  echo "Nome della categoria: ".$nome;
Ricezione dei dati.  metodo fetchAll()
$data = $db->query("SELECT * FROM categorie")->fetchAll(PDO::FETCH_ASSOC);  foreach ($data as $k => $v)( echo "Nome categoria: ".$v["nome"]." 
";
}
PDO e l'operatore LIKE
Quando lavori con query preparate, dovresti comprendere che un segnaposto può sostituire soltanto stringa o numero.  Non una parola chiave, non un identificatore, non parte di una stringa o di un insieme di stringhe tramite un segnaposto non puoi sostituire.  Pertanto, per LIKE, devi prima preparare l'intera stringa di ricerca e poi sostituirla nella query:
$cerca = "comp";  $query = "SELEZIONA * DA categorie DOVE `nome` MI PIACE?";  $parametri = ["%$ricerca%"];  $stmt = $db->prepara($query);  $stmt->execute($params);  $dati = $stmt->fetchAll(PDO::FETCH_ASSOC);  $i = 1;  foreach ($dati come $categoria)( echo $i++ . ". " . $categoria["nome"]." 
";
}

È qui che potrebbe sorgere un problema!  La ricerca potrebbe non funzionare perché stai ricevendo dati dal database con la codifica sbagliata.  È necessario aggiungere la codifica alla connessione se non è elencata lì!
$db = nuovo PDO("mysql:host=localhost;dbname=pdo;charset=utf8", "root", "");
PDO e l'operatore LIMIT
Importante! Quando PDO è in esecuzione in modalità di emulazione, tutti i dati passati direttamente aexecute() vengono formattati come stringhe.  Cioè, sono sfuggiti e racchiusi tra virgolette.  Quindi LIMITE?,?  si trasforma in LIMIT "10", "10" e ovviamente provoca un errore di sintassi e, di conseguenza, un array di dati vuoto.
Soluzione n. 1: disabilita la modalità di emulazione:
$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
Soluzione n. 2: associare questi numeri utilizzando bindValue() , forzandoli ad essere di tipo PDO::PARAM_INT:
$limite = 3;  $stm = $db->prepare("SELECT * FROM categorie LIMIT ?");  $stm->bindValue(1, $limit, PDO::PARAM_INT);  $stm->esegui();  $dati = $stm->fetchAll();  eco" 
"; stampa_r($dati);
Operatore PDO e IN
Quando si seleziona da una tabella, è necessario recuperare i record che corrispondono a tutti i valori dell'array.
$arr = ;  $in = str_repeat("?,", count($arr) - 1) .  "?";  $sql = "SELEZIONA * DA categorie DOVE `id` IN ($in)";  $stm = $db->prepara($sql);  $stm->esegui($arr);  $dati = $stm->fetchAll();  eco" 
"; stampa_r($dati);
Aggiunta di voci
$nome = "Nuova categoria";  $query = "INSERISCI IN VALORI `categorie` (`nome`) (:nome)";  $params = [ ":nome" => $nome];  $stmt = $pdo->prepare($query);  $stmt->execute($params); 
Modifica delle voci
$id = 1;  $nome = "Voce modificata";  $query = "AGGIORNA `categorie` SET `nome` = :nome DOVE `id` = :id";  $params = [ ":id" => $id, ":nome" => $nome ];  $stmt = $pdo->prepare($query);  $stmt->execute($params); 
Eliminazione di voci
$id = 1;  $query = "ELIMINA DA `categorie` DOVE `id` = ?";  $parametri = [$id];  $stmt = $pdo->prepare($query);  $stmt->execute($params); 
Utilizzo delle transazioni
try ( // Inizio della transazione $pdo->beginTransaction(); // ... codice // Se tutto ha avuto successo come risultato dell'esecuzione del nostro codice, // registreremo questo risultato $pdo->commit() ; ) catch (Exception $e) ( // Altrimenti, ripristina la transazione. $pdo->rollBack(); echo "Errore: " . $e->getMessage(); ) 

Importante!  Le transazioni in PDO funzionano solo su tabelle InnoDB

In questa nota abbiamo conosciuto i concetti di base di PDO, la sua installazione, la connessione al database e le opzioni più semplici per selezionare, modificare ed eliminare i dati.  Tratteremo alcuni altri argomenti relativi alla PDO nei post futuri.