Klasse om MySQL-databases te beheren met MySQLi en pHp

De MySQLi-extensie is een relationeel databasestuurprogramma, het wordt gebruikt in de pHp-programmeertaal om een ​​interface te bieden met MySQL-databases.
Voordelen van het gebruik van MySQLi
Voorbereide statements: het is makkelijker om queries te maken, het biedt veel beveiliging tegen SQL-injectie, met de functie:

 $ mysqli-> voorbereiden ();

Meerdere vragen of vragen
Mogelijkheid om meerdere query's of query's in een verbinding uit te voeren.
Voorbeeld

 $ sqla = "SELECTEER * van klanten;" $ sqlb. = "SELECT * FROM facturen ***** BY customerid" $ mysqli-> multi_query ($ sqla; sqlb) 

Objectgericht
Met deze functie van MySQLi kan de ontwikkelaar objecten gebruiken om het gebruik, de prestaties en de zichtbaarheid van de broncode te verbeteren.
Het MySQLi Extension-stuurprogramma wordt gebruikt in de programmeertaal PHP om een ​​interface te bieden voor MySQL-databases. De ontwikkelaars van de programmeertaal PHP raden aan om MySQLi te gebruiken als het gaat om MySQL-serverversies 4.1.3 en hoger.
We gaan een klasse maken om te gebruiken van pHp met methoden en eigenschappen om een ​​database te manipuleren of te beheren.
De klas zal als volgt zijn:

 class dbmysqli {// declareer een variabele voor verbinding openbare $ verbinding; // We declareren de constructor van de klasse public function __construct ($ host, $ user, $ password, $ db) {} // function to create tabellen public function create table ($ sql) {} // Sla nieuwe gegevens op in de databasegegevens openbare functie invoegen ($ tabel, $ veldgegevens) {} // Verwijder gegevens uit de database openbare functie verwijderen ($ tabel, $ veldgegevens) {} openbare functie Update ($ tabel, $ veldset, $ veldvoorwaarde) {} / / functie Zoeken in een tabel openbare functie zoeken ($ tabel, $ velden) {}} 

MySQLi-verbinding en klasse
Om verbinding te maken met de MySQLi-server moeten we de constructormethode aanroepen en vier argumenten verzenden: de hostnaam, zoals localhost, gebruikersnaam, databasewachtwoord en de databasenaam.
In de constructor voegen we de verbinding met de server toe:

 openbare functie __construct ($ host, $ gebruiker, $ wachtwoord, $ db) {$ dit-> verbinding = nieuwe mysqli ($ host, $ gebruiker, $ clav); } 

Dan zullen we het als volgt aanroepen:

 // Verbinding maken met de server en de database $ conectb = new dbmysqli ("localhost", "root", "abc123" c, "Vehiculosdb"); 

We definiëren de methode om tabellen dynamisch te maken:

 // Functie die tabellen maakt public function createtable ($ sql) {if ($ this-> connection-> query ($ sql) === TRUE) {echo "Er is een tabel gemaakt"; } else {echo "Mislukt: tabel niet gemaakt" $ dit-> verbinding-> fout; }} 

Dan zullen we het op deze manier aanroepen, de sql-query maken en de functie aanroepen: creartabla ():

 $ sql = ”DROP TABLE IF EXISTS` clients`; MAAK TABEL INDIEN NIET BESTAAT `customers` (` customerid` int (11) NOT NULL AUTO_INCREMENT, `name` varchar (255) NOT NULL, PRIMARY KEY (` customerid`)) ”$ connectb -> creartabla ($ sql); 

We kunnen in pHpMyAdmin zien hoe de tabel is gemaakt bij het uitvoeren van de php-script.

We definiëren de methode om gegevens in te voegen / op te slaan
Vervolgens maken we de methoden genaamd ABM of CRUD, die verantwoordelijk zijn voor het beheer van de gegevens in de tabellen. Om parameters naar elke methode te sturen, gebruiken we een array waarbij de index van de array het veld van de tabel is en de waarde van die index de gegevens voor het veld van de tabel. Elke indexnaam moet tussen dubbele aanhalingstekens staan ​​en de waarde moet aan de volgende regels voldoen:

• Tekenreekswaarden moeten enkele aanhalingstekens hebben. Voorbeeld "naam" => 'Maria'
• Numerieke waarden mogen geen aanhalingstekens hebben. Voorbeeld "prijs" => 10,50
• Het woord NULL OF leeg mag geen aanhalingstekens bevatten. Voorbeeld "prijs" => NULL

 // We maken de functie die als parameter het arrayveld => data public function insert ($ table, $ field data) zal nemen {// we scheiden de gegevens als er meerdere zijn $ field = implode (",", array_keys ($ veldgegevens)); $ ik = 0; foreach ($ gegevensvelden als $ index => $ waarde) {$ data [$ i] = "'". $ waarde. "'"; $ ik ++; } $ data = imploderen (",", $ data); // We voegen de waarden in elk veld in if ($ this-> connection-> query ("INSERT INTO $ table ($ index) VALUES ($ data)") === TRUE) {echo "New client inserted"; } else {echo "De client is niet geplaatst, is mislukt" $ this-> connection-> error; }} 

We maken onze matrix met de gegevens die uit een formulier kunnen komen:

 // Gegevensmatrix om $ klanten = array in te voegen ("naam" => 'Carlos Moira', "naam" => 'Jose Triana', "naam" => 'Julia Ordoñez', "naam" => 'Carla Angelez ' ); 

Dan zullen we het als volgt aanroepen, we roepen de invoegfunctie op ("klanten", $ klanten) en voegen de parameters toe:

 $conedb -> invoegen ("klanten", $ klanten);

We definiëren de methode om gegevens te verwijderen
Om de verwijderbewerking uit te voeren, declareren we een array waarin we aangeven welke rij of id we willen verwijderen.

 // functie om gegevens uit een tabel te verwijderen openbare functie delete ($ table, $ datafields) {$ i = 0; foreach ($ gegevensvelden als $ index => $ waarde) {$ data [$ i] = "'". $ waarde. "'"; $ ik ++; } $ veld en data = imploderen ("AND", $ data); if ($ dit-> verbinding-> query ("DELETE FROM $ table WHERE $ fielddata") === TRUE) {if (mysqli_affected_rows ($ dit-> verbinding)) {echo "Record verwijderd"; } else {echo "Mislukt, de record kan niet worden verwijderd". $ this-> connection-> error;}} 

We maken onze matrix met de geselecteerde gegevens om te verwijderen die uit een formulier kunnen komen

 // Datamatrix om $ klanten delete = array te verwijderen ("klant-ID" => 1, "klant-ID" => 50, "klant-ID" => 8, "klant-ID" => 104); 

Dan zullen we het als volgt aanroepen, we roepen de verwijderfunctie op ("klanten", $ klanten verwijderen) en voegen de parameters toe

 $ conectadb -> verwijderen ("klanten", $ klanten verwijderen);

We definiëren de methode om gegevens bij te werken
Om de gegevens van de rij die we moeten wijzigen bij te werken, declareren we twee associatieve arrays, één voor de velden die moeten worden gewijzigd en de andere voor de voorwaarde waar in de SQL-query. De matrixregels moeten voldoen aan dezelfde syntaxis die we vanaf het begin voor de matrix hebben gedefinieerd.
Gezien de MySQL-updatesyntaxis:

 UPDATE Clients SET naam = 'nieuwenaam' WHERE clientid.id = idvalue; // We maken de functie die als parameter het arrayveld => data openbare functie Update ($ table, $ setfields, $ conditionfields) zal nemen {// we scheiden de SET-waarden om $ i = 0 te wijzigen; foreach ($ camposset als $ index => $ data) {$ dataset [$ i] = $ index. "= '". $ data. "'"; $ ik ++; } $ queryset = imploderen (",", $ datset); $ ik = 0; foreach ($ conditionfields als $ index => $ conditiondata) {$ condition [$ i] = $ index. "= '". $ conditiondata. "'"; $ ik ++; } $ querycondition = imploderen ("EN", $ voorwaarde); // Update records if ($ dit-> verbinding-> query ("UPDATE $ table SET $ queryset WHERE $ querycondition") === TRUE) {if (mysqli_affected_rows ($ dit-> verbinding)) {echo "Record bijgewerkt "; } else {echo "Mislukt, de record kan niet worden verwijderd". $ this-> connection-> error;}} 

We maken onze array met de SET-gegevens die de velden zijn die moeten worden bijgewerkt en nieuwe waarden, we maken ook een array voor de WHERE-voorwaarde met de id van de records die moeten worden bijgewerkt en die uit een formulier kunnen komen:

 // Datamatrix SET $ klantenset = array ("naam" => 'Carlos Juan Dolfo', "naam" => 'Pedro Dorien Triana', "naam" => 'Enrique Ordoñez', "naam" => 'Carla Dolores Angeles'); $ customerswhere = array ("klant-id" => 1, ”klant-id" => 2, "klant-id" => 5, "klant-id" => 10); 

Dan zullen we het zo aanroepen, we roepen de Update functie op ("customers", $ customersset, $ customerswhere) en voegen de parameters eraan toe.

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

In alle zoekopdrachten gebruiken we de native MySQLi-functie om fouten te detecteren $ mysqli-> fout, die een foutmelding toont voor elke SQL-query of MySQLi-functie die mogelijk is uitgevoerd en mislukt, zodat we kunnen weten waarom de fout is opgetreden.
We definiëren de methode om gegevens te zoeken
Om de gegevens uit de tabel te verkrijgen, maken we een querymethode met twee parameters, de ene is de naam van de tabel en de andere is een array die de naam van de kolommen en de te doorzoeken waarde bevat.
We kunnen aangeven welk type resultaatmatrix moet worden verkregen. De mogelijke waarden voor deze parameter zijn de constanten MYSQLI_ASSOC, MYSQLI_NUM.
Matrixtype MYSQLI_ASSOC

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

Matrixtype MYSQLI_NUM

 Array {0 => 'Carlos Juan Dolfo', 1 => 'Enrique Ordoñez'} openbare functie zoeken ($ tabel, $ velden) {$ velden = imploderen (",", $ velden); $ resultaat = $ dit-> verbinding-> query ("SELECT $ velden FROM $ tabel"); retourneer $ resultaat-> fetch_all (MYSQLI_ASSOC); } 

We maken onze matrix met de te zoeken gegevens die uit een formulier kunnen komen:

 // Array van gegevens om te zoeken $ clients search = array ("client-id", "naam"); 

Dan zullen we het als volgt aanroepen, we roepen de zoekfunctie op ("klanten", $ klanten zoeken) en voegen de parameters toe:

 $ connectdb -> zoeken ($ tabel, $ klanten zoeken);

Deze functie retourneert a herstellen die we als een array moeten doorlopen om de gegevens van elk veld te zien:Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven