Classe per gestire database MySQL con MySQLi e pHp

Il Estensione MySQLi è un driver di database relazionale, viene utilizzato nel linguaggio di programmazione pHp per fornire un'interfaccia con i database MySQL.
Vantaggi dell'utilizzo di MySQLi
Dichiarazioni preparate: è più facile creare query, offre molta sicurezza contro SQL injection, con la funzione:

 $ mysqli-> prepara ();

Richieste o domande multiple
Possibilità di eseguire più interrogazioni o interrogazioni in una connessione.
Esempio

 $ sqla = "SELEZIONA * dai client;" $ sqlb. = "SELECT * FROM fatture ***** BY customerid" $ mysqli-> multi_query ($ sqla; sqlb) 

Orientato agli oggetti
Questa funzionalità di MySQLi consente allo sviluppatore di utilizzare oggetti per migliorare l'uso, le prestazioni e la visibilità del codice sorgente.
Il driver MySQLi Extension viene utilizzato nel linguaggio di programmazione PHP per fornire un'interfaccia ai database MySQL. Gli sviluppatori del linguaggio di programmazione PHP consigliano di utilizzare MySQLi quando si tratta di server MySQL versioni 4.1.3 e successive.
Creeremo una classe da usare da pHp con metodi e proprietà per manipolare o gestire qualsiasi database.
La classe sarà la seguente:

 class dbmysqli {// dichiara una variabile per la connessione public $ connection; // Dichiariamo il costruttore della classe public function __construct ($ host, $ user, $ password, $ db) {} // funzione per creare tabelle public function create table ($ sql) {} // Salva i nuovi dati nella database data public function insert ($ table, $ field data) {} // Elimina i dati dal database public function delete ($ table, $ field data) {} public function Update ($ table, $ field set, $ field condition) {} // funzione Cerca in una tabella ricerca funzione pubblica ($ tabella, $ campi) {}} 

Connessione e classe MySQLi
Per connettere il server MySQLi dobbiamo invocare il metodo del costruttore e inviare quattro argomenti sono il nome host come localhost, nome utente, password del database e il nome del database.
Nel costruttore aggiungiamo la connessione al server:

 public function __construct ($ host, $ user, $ password, $ db) {$ this-> connection = new mysqli ($ host, $ user, $ clav); } 

Quindi lo invocheremo in questo modo:

 // Connessione al server e al database $ conectb = new dbmysqli ("localhost", "root", "abc123" c, "Vehiculosdb"); 

Definiamo il metodo per creare tabelle dinamicamente:

 // Funzione che crea tabelle public function createtable ($ sql) {if ($ this-> connection-> query ($ sql) === TRUE) {echo "Una tabella è stata creata"; } else {echo "Fallito: tabella non creata" $ this-> connection-> error; }} 

Quindi lo invocheremo in questo modo, creeremo la query sql e invocheremo la funzione creartabla ():

 $ sql = ”RILASCIA LA TABELLA SE ESISTE` client`; CREATE TABLE IF NOT EXISTS `customers` (` customerid` int (11) NOT NULL AUTO_INCREMENT, `name` varchar (255) NOT NULL, PRIMARY KEY (` customerid`)) ”$ connectb -> creartabla ($ sql); 

Possiamo vedere da pHpMyAdmin come è stata creata la tabella durante l'esecuzione del script php.

Definiamo il metodo per inserire/salvare i dati
Successivamente creiamo i metodi chiamati ABM o CRUD, che avranno il compito di gestire i dati nelle tabelle. Per inviare parametri a ciascun metodo utilizzeremo un array in cui l'indice dell'array sarà il campo della tabella e il valore di quell'indice saranno i dati per il campo della tabella. Ciascun nome di indice deve essere racchiuso tra virgolette e il valore deve soddisfare le seguenti regole:

• I valori stringa devono avere virgolette singole. Esempio "nome" => 'Maria'
• I valori numerici non devono avere virgolette. Esempio "prezzo" => 10,50
• La parola NULL OR vuoto non deve contenere virgolette. Esempio "prezzo" => NULL

 // Creiamo la funzione che prenderà come parametro il campo array => data public function insert ($ table, $ field data) {// separiamo i dati se ci sono diversi $ field = implode (",", array_keys) ($ dati del campo)); $ io = 0; foreach ($ campi dati come $ indice => $ valore) {$ dati [$ i] = "'". $ valore. "'"; $i++; } $ dati = implodere (",", $ dati); // Inseriamo i valori in ogni campo if ($ this-> connection-> query ("INSERT INTO $ table ($ index) VALUES ($ data)") === TRUE) {echo "Nuovo client inserito"; } else {echo "Il client non è stato inserito in errore" $ this-> connection-> error; }} 

Creiamo la nostra matrice con i dati che possono provenire da un form:

 // Data Matrix da inserire $ clienti = array ("name" => 'Carlos Moira', “name” => 'Jose Triana', “name” => 'Julia Ordoñez', “name” => 'Carla Angelez ' ); 

Quindi lo invocheremo in questo modo, invochiamo la funzione di inserimento ("clienti", $ clienti) e aggiungiamo i parametri:

 $conedb -> inserisci ("clienti", $ clienti);

Definiamo il metodo per eliminare i dati
Per eseguire l'operazione di cancellazione, dichiariamo un array dove indicheremo quale riga o id vogliamo cancellare.

 // funzione per eliminare i dati da una tabella public function delete ($ table, $ datafields) {$ i = 0; foreach ($ campi dati come $ indice => $ valore) {$ dati [$ i] = "'". $ valore. "'"; $i++; } $ campo e dati = implodere ("AND", $ dati); if ($ this-> connection-> query ("DELETE FROM $ table WHERE $ fielddata") === TRUE) {if (mysqli_affected_rows ($ this-> connection)) {echo "Record cancellato"; } else {echo "Fallito, il record non può essere cancellato”. $ this-> connection-> error;}} 

Creiamo la nostra matrice con i dati selezionati da eliminare che possono provenire da un form

 // Data Matrix da eliminare $ clienti delete = array ("id cliente" => 1, ”id cliente” => 50, “id cliente” => 8, “id cliente” => 104); 

Quindi lo invocheremo in questo modo, invochiamo la funzione di eliminazione ("clienti", $ clienti elimina) e aggiungiamo i parametri

 $ conectadb -> elimina (“clients”, $ client elimina);

Definiamo il metodo per aggiornare i dati
Per aggiornare i dati della riga che dobbiamo modificare, dichiareremo due array associativi, uno sarà per i campi da modificare e l'altro per la condizione dove nella query SQL. Le regole della matrice devono aderire alla stessa sintassi che abbiamo definito per la matrice dall'inizio.
Considerando la sintassi di aggiornamento di MySQL:

 AGGIORNA Clienti SET nome = 'nuovonome' WHERE clientid.id = idvalue; // Creiamo la funzione che prenderà come parametro il campo array => data public function Update ($ table, $ setfields, $ conditionfields) {// separiamo i valori di SET da modificare $ i = 0; foreach ($ camposset as $ index => $ data) {$ dataset [$ i] = $ index. "= '". $ data. "'"; $i++; } $ queryset = implodere (",", $ datoset); $ io = 0; foreach ($ conditionfields as $ index => $ conditiondata) {$ conditiondata [$ i] = $ index. "= '". $ conditiondata. "'"; $i++; } $ querycondition = implodere ("AND", $ condizione); // Aggiorna i record if ($ this-> connection-> query ("UPDATE $ table SET $ queryset WHERE $ querycondition") === TRUE) {if (mysqli_affected_rows ($ this-> connection)) {echo "Record aggiornato "; } else {echo "Fallito, il record non può essere cancellato”. $ this-> connection-> error;}} 

Creiamo il nostro array con i dati SET che saranno i campi da aggiornare e nuovi valori, creiamo anche un array per la condizione WHERE con l'id dei record da aggiornare che possono provenire da un form:

 // Data matrix SET $ clientsset = array ("name" => 'Carlos Juan Dolfo', “name” => 'Pedro Dorien Triana', “name” => 'Enrique Ordoñez', “name” => 'Carla Dolores Angeles'); $ customerdove = array ("customerid" => 1, ”customerid” => 2, “customerid” => 5, “customerid” => 10); 

Quindi lo invocheremo in questo modo, invochiamo la funzione di aggiornamento ("clienti", $ clientiset, $ clientidove) e aggiungiamo i parametri ad essa.

 $ dbconnect-> Aggiorna ("clients", $ clientsset, $ clientswhere);

In tutte le query utilizziamo la funzione nativa MySQLi per rilevare gli errori $ mysqli-> errore, che mostrerà un messaggio di errore per qualsiasi query SQL o funzione MySQLi che potrebbe essere stata eseguita e non è riuscita, quindi possiamo sapere perché si è verificato l'errore.
Definiamo il metodo per cercare i dati
Per ottenere i dati dalla tabella creiamo un metodo di query con due parametri, uno è il nome della tabella e l'altro è un array che contiene il nome delle colonne e il valore da cercare.
Possiamo indicare il tipo di matrice di risultato da ottenere. I possibili valori per questo parametro sono le costanti MYSQLI_ASSOC, MYSQLI_NUM.
Tipo di matrice MYSQLI_ASSOC

 Array {name => 'Carlos Juan Dolfo', nome ”=> 'Enrique Ordoñez'} 

Tipo di matrice MYSQLI_NUM

 Array {0 => 'Carlos Juan Dolfo', 1 => 'Enrique Ordoñez'} ricerca funzione pubblica ($ tabella, $ campi) {$ campi = implodere (",", $ campi); $ risultato = $ questo-> connessione-> query ("SELECT $ campi FROM $ tabella"); return $ risultato-> fetch_all (MYSQLI_ASSOC); } 

Creiamo la nostra matrice con i dati da ricercare che possono provenire da un form:

 // Array di dati da ricercare $ clients search = array ("ID cliente", ”nome”); 

Quindi lo invocheremo in questo modo, invochiamo la funzione di ricerca ("clienti", $ ricerca clienti) e aggiungiamo i parametri:

 $ connectdb -> cerca ($ tabella, $ ricerca client);

Questa funzione restituisce a recorse che dovremo percorrere come un array per vedere i dati di ogni campo:Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo