L'administration du système

Comment configurer et utiliser l'OPD pour l'accès à la base de données sur Linux

Comment configurer et utiliser l'OPD pour l'accès à la base de données sur Linux

Objectif

Apprenez à configurer et à utiliser l'APD pour l'accès à la base de données: à partir des modes d'erreur pour récupérer les méthodes.

Exigences

  • Une connaissance standard de mysql et mysql Client de ligne de commande;
  • Connaître les concepts fondamentaux de la programmation orientée objet
  • Php> = 5.1
  • Avoir une base de données MySQL / MARIADB fonctionnelle

Difficulté

MOYEN

Conventions

  • # - nécessite que les commandes Linux soient exécutées avec des privilèges racine
    directement en tant qu'utilisateur racine ou en utilisant Sudo commande
  • $ - Exige que les commandes Linux soient exécutées en tant qu'utilisateur non privilégié régulier

Introduction

L'OPD est un acronyme pour Objets de données PHP: Il s'agit d'une extension PHP pour interagir avec les bases de données via l'utilisation d'objets. L'une de ses forces réside dans le fait qu'elle n'est pas strictement liée à une base de données particulière: son interface fournit un moyen courant d'accéder à plusieurs environnements différents, entre autres:

  • Mysql
  • Sqlite
  • Postgresql
  • Microsoft SQL Server

Ce guide vise à fournir un aperçu assez complet de l'APD, guidant le lecteur étape par étape de l'établissement d'une connexion à la base de données, au choix du mode de fetch le plus approprié, montrant comment créer des instructions préparées et décrire les modes d'erreur possibles.

Créer une base de données et un tableau de test

La première chose que nous allons faire est de créer une base de données pour ce tutoriel:

Créer une base de données Solar_System; Accorder tous les privilèges sur Solar_System.* À 'TesUser' @ 'localhost' identifié par 'TestPassword';
Copie

Nous avons accordé à l'utilisateur testeur Tous les privilèges sur le système solaire base de données, en utilisant TestPassword comme mot de passe. Créons maintenant une table et remplissons-la avec certaines données (aucune précision astronomique prévue):

Utilisez Solar_System; Créer des planètes de table (id tinyint (1) non signé non nuls auto_increment, clé primaire (id), nom varchar (10) pas nul, couleur varchar (10) non nul); Insérer dans les planètes (nom, couleur) valeurs («terre», «bleu»), («Mars», «rouge»), («Jupiter», «étrange»);
Copie

DSN: Nom de la source de données

Maintenant que nous avons une base de données, nous devons définir un DSN. DSN représente Nom de la source de données, Et c'est essentiellement un ensemble d'informations nécessaires pour se connecter à la base de données, représentée sous la forme d'une chaîne. La syntaxe peut être différente en fonction de la base de données à laquelle vous souhaitez vous connecter, mais comme nous interagissons avec MySQL / MARIADB, nous fournirons:

  • Le type de conducteur à utiliser pour la connexion
  • Le nom d'hôte de la machine hébergeant la base de données
  • Le port à utiliser pour la connexion (facultatif)
  • Le nom de la base de données
  • Le charme (facultatif)

Le format de la chaîne, dans notre cas, serait le suivant (nous allons le stocker dans le $ dsn variable):

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

Tout d'abord, nous avons fourni le Préfixe de base de données. Dans ce cas, puisque nous nous connectons à une base de données MySQL / MARIADB, nous avons utilisé mysql. Nous avons ensuite séparé le préfixe du reste de la chaîne par un côlon et chacune des autres sections par un point-virgule.

Dans les deux sections suivantes, nous avons spécifié le nom d'hôte de la machine sur laquelle la base de données est hébergée et le port à utiliser pour la connexion. Si ce dernier n'est pas fourni, le par défaut sera utilisé, qui, dans ce cas, est 3306. Immédiatement après avoir fourni le nom de la base de données, Et après, le charbon utiliser.

Création de l'objet PDO

Maintenant que notre DSN est prêt, nous allons construire le Objet PDO. Le constructeur PDO prend la chaîne DSN comme premier paramètre, le nom de l'utilisateur sur la base de données comme deuxième paramètre, son mot de passe comme troisième et éventuellement un tableau d'options comme le quatrième:

$ options = [PDO :: att_errMode => PDO :: errMode_Exception, PDO :: att_default_fetch_mode => pdo :: fetch_assoc]; $ PDO = new PDO ($ dsn, 'TesUser', 'TestPassword', $ options);
Copie

Cependant, les options peuvent également être spécifiées après la construction de l'objet, via le SetAttribute () méthode:

$ PDO-> SetAttribute (PDO :: ATTR_ERRMODE, PDO :: errMode_Exception);
Copie

Définir le comportement de l'OPD sur les erreurs

Jetons un coup d'œil à certaines des options disponibles pour APD :: att_errMode. Cette option est vraiment importante, car définit le comportement de l'APD en cas d'erreurs. Les options possibles sont:

PDO :: errmode_silent

C'est la valeur par défaut. L'OPD définira simplement le code d'erreur et le message d'erreur. Ils peuvent être récupérés en utilisant le code d'erreur() et errorInfo () méthodes.

PDO :: errmode_exception

C'est, à mon avis, le recommandé. Avec cette option, en plus de définir le code d'erreur et les informations, PDO lancera un PDOException, ce qui brisera le flux de script, et il est particulièrement utile dans le cas de Transactions APD (Nous allons voir quelles transactions sont plus tard dans ce tutoriel).

PDO :: errmode_warning

Avec cette option, PDO définira le code d'erreur et les informations comme indexées PDO :: errmode_silent, mais sortira également un AVERTISSEMENT, qui ne brisera pas le flux du script.

Réglage du mode de récupération par défaut

Un autre paramètre important peut être spécifié via le PDO :: default_fetch_mode. constant. Il vous permet de spécifier la méthode de récupération par défaut à utiliser lors de la récupération des résultats d'une requête. Ce sont les options les plus couramment utilisées:

PDO :: fetch_both:

C'est la valeur par défaut. Avec lui, le résultat récupéré par une requête Fetch sera indexé à la fois par entier et par nom de colonne. L'application de ce mode de récupération lors de la récupération d'une ligne à partir du tableau des planètes nous donnerait ce résultat:

$ stmt = $ pDo-> query ("SELECT * FROM PANETS"); $ results = $ stmt-> fetch (pdo :: fetch_both);
Copie 
Array ([id] => 1 [0] => 1 [nom] => terre [1] => terre [couleur] => bleu [2] => bleu)

PDO :: fetch_assoc:

Avec cette option, le résultat sera stocké dans un tableau associatif dans lequel chaque clé sera le nom de la colonne, et chaque valeur sera la valeur correspondante dans une ligne:

$ stmt = $ pDo-> query ("SELECT * FROM PANETS"); $ results = $ stmt-> fetch (PDO :: fetch_assoc);
Copie 
Array ([id] => 1 [nom] => terre [couleur] => bleu)

PDO :: fetch_num

Ce mode de récupération renvoie la ligne récupérée dans un 0-baisses indexées:

Array ([0] => 1 [1] => terre [2] => bleu)

PDO :: fetch_column

Cette méthode de récupération est utile lors de la récupération uniquement des valeurs d'une colonne et renvoie tous les résultats dans un tableau unidimensionnel simple. Par exemple, cette requête:

$ stmt = $ PDO-> Query ("SELECT Name From Planets");
Copie

Retournerait ce résultat:

Array ([0] => Terre [1] => Mars [2] => Jupiter)

PDO :: fetch_key_pair

Cette méthode de récupération est utile lors de la récupération des valeurs de seulement 2 colonnes. Il renverra les résultats sous la forme d'un tableau associatif dans lequel les valeurs récupérées de la base de données pour la première colonne spécifiée dans la requête seront utilisées comme touches de tableau, tandis que les valeurs récupérées pour la deuxième colonne, représenteront l'associatif Valeurs du tableau:

$ stmt = $ pDo-> query ("SELECT Name, Color From Planets"); $ result = $ stmt-> fetchall (PDO :: fetch_key_pair);
Copie

Retournerais:

Array ([Terre] => Blue [Mars] => Red [Jupiter] => Strange)

PDO :: fetch_object:

Lorsque vous utilisez le PDO :: fetch_object constant, un objet anonyme sera créé pour chaque ligne récupérée. Ses propriétés (publiques) seront nommées d'après les colonnes, et les résultats de la requête seront utilisés comme valeurs. L'application de ce mode de récupération à la même requête ci-dessus nous rendrait un résultat dans le formulaire:

$ results = $ stmt-> fetch (PDO :: fetch_obj);
Copie 
objet stdclass ([nom] => terre [couleur] => bleu)

PDO :: fetch_class:

Ce mode de récupération, comme ce qui précède, affectera la valeur des colonnes aux propriétés d'un objet, mais dans ce cas, nous devons spécifier une classe existante qui devrait être utilisée pour créer l'objet. Voyons-le, nous allons d'abord créer une classe:

Class Planet private $ name; Couleur de $ privé; fonction publique setName ($ planet_name) $ this-> name = $ planet_name;  fonction publique setColor ($ planet_color) $ this-> color = $ planet_color;  fonction publique getName () return $ this-> name;  fonction publique getColor () return $ this-> couleur;
Copie

Veuillez ignorer la naïveté du code ci-dessus et notez simplement que les propriétés de la classe de la planète sont privé Et la classe n'a pas de constructeur. Essayons maintenant de récupérer les résultats.

Lors de l'utilisation aller chercher() avec PDO :: fetch_class vous devez utiliser le setFechMode () Méthode sur l'objet Instruction avant d'essayer de récupérer les données, par exemple:

$ stmt = $ pDo-> query ("SELECT Name, Color From Planets"); $ stmt-> setFetchMode (PDO :: fetch_class, 'Planet');
Copie

Nous avons fourni la constante de l'option de récupération PDO :: fetch_class comme le premier argument de la méthode setfetchmode (), et le nom de la classe qui doit être utilisé pour créer l'objet ('Planet' dans ce cas) comme le second. Maintenant nous courons:

$ planet = $ stmt-> fetch ();
Copie

Un objet Planet aurait dû être créé:

var_dump ($ planet);
Copie 
Planet Object ([Nom: Planet: Private] => Terre [Couleur: Planète: Private] => Bleu)

Remarquez comment les valeurs récupérées résultant de la requête ont été attribuées aux propriétés correspondantes de l'objet même si elles sont privées.

Attribution de propriétés après la construction de l'objet

La classe Planet n'a pas de constructeur explicite défini, donc aucun problème lors de l'attribution des propriétés; Mais que se passe-t-il si la classe avait un constructeur dans lequel la propriété était attribuée ou manipulée? Étant donné que les valeurs sont attribuées avant l'appel du constructeur, ils auraient été écrasés.

L'APD aide à fournir le Fetch_props_late Constante: lors de l'utilisation, les valeurs seront affectées aux propriétés après L'objet est construit. Par exemple:

Class Planet private $ name; Couleur de $ privé; Fonction publique __Construct ($ name = moon, $ color = gris) $ this-> name = $ name; $ this-> color = $ couleur;  fonction publique setName ($ planet_name) $ this-> name = $ planet_name;  fonction publique setColor ($ planet_color) $ this-> color = $ planet_color;  fonction publique getName () return $ this-> name;  fonction publique getColor () return $ this-> couleur;
Copie

Nous avons modifié notre classe de planète, fournissant un constructeur qui prend deux arguments: le premier est nom Et le second est couleur. Ces arguments ont respectivement une valeur par défaut de lune et gris: Cela signifie que si aucune valeur n'est explicitement fournie.

Dans ce cas, si nous n'utilisons pas Fetch_props_late, Peu importe les valeurs extraites de la base de données, les propriétés auront toujours les valeurs par défaut, car elles seront écrasées lorsque l'objet sera construit. Voyons-le. Nous exécutons d'abord la requête:

$ stmt = $ PDO-> Query ("Select Name, Color From Solar_System où name = 'Earth'"); $ stmt-> setFetchMode (PDO :: fetch_class, 'Planet'); $ planet = $ stmt-> fetch ();
Copie

Ensuite, nous jetons le Planète Object et vérifiez quelles valeurs ont ses propriétés:

var_dump ($ planet); objet (planète) # 2 (2) ["Name": "Planet": privé] => String (4) "Moon" ["Color": "Planet": privé] => String (4) "Gray"
Copie

Comme prévu, les valeurs récupérées de la base de données ont été remplacées par les défauts. Maintenant, nous démontrons comment ce problème peut être résolu en utilisant Fetch_props_late (La requête est la même que ci-dessus):

$ stmt-> setFetchMode (PDO :: fetch_class | pdo :: fetch_props_late, 'planet'); $ planet = $ stmt-> fetch (); var_dump ($ planet); objet (planète) # 4 (2) ["Name": "Planet": privé] => String (5) "Earth" ["Color": "Planet": Private] => String (4) "Blue"
Copie

Enfin, nous avons obtenu les résultats souhaités. Mais que se passe-t-il si le constructeur de classe n'a pas de valeurs par défaut, et elles doivent être fournies ? Simple: nous pouvons spécifier les paramètres du constructeur sous la forme d'un tableau comme troisième argument, après le nom de classe, dans la méthode setfetchmode (). Par exemple, laissez changer le constructeur:

Class Planet private $ name; Couleur de $ privé; Fonction publique __Construct ($ name, $ couleur) $ this-> name = $ name; $ this-> color = $ couleur;  […]
Copie

Les arguments du constructeur sont désormais obligatoires, nous courions donc:

$ stmt-> setFetchMode (PDO :: fetch_class | PDO :: fetch_props_late, 'Planet', ['Moon', 'Gray']);
Copie

Dans ce cas, les paramètres que nous avons fournis servent des valeurs par défaut, nécessaires pour initialiser l'objet sans erreur: ils seront écrasés par les valeurs récupérées à partir de la base de données.

Récupérer plusieurs objets

Bien sûr, il est possible de récupérer plusieurs résultats comme objets, soit en utilisant aller chercher() Méthode à l'intérieur d'une boucle de temps:

while ($ planet = $ stmt-> fetch ()) // faire des choses avec les résultats
Copie

ou en récupérant tous les résultats à la fois. Dans ce cas, comme dit ci-dessus, en utilisant le fetchall () Méthode, vous n'avez pas à spécifier le mode de récupération avant d'appeler la méthode elle-même, mais au moment où vous l'appelez:

$ stmt-> fetchall (pdo :: fetch_class | pdo_fetch_props_late, 'planet', ['lune', 'gris']);
Copie

PDO :: fetch_into

Avec cet ensemble de méthode de récupération, l'OPD ne créera pas un nouvel objet, il mettra à jour les propriétés d'un existant, mais seulement s'ils sont public, ou si vous utilisez le __ensemble Méthode magique à l'intérieur de l'objet.

Préparement vs instructions directes

L'OPD a deux façons d'exécuter des requêtes: l'une est la manière directe et une étape. L'autre, plus sécurisé est d'utiliser déclarations préparées.

Requêtes directes

Lorsque vous utilisez des requêtes directes, vous avez deux méthodes principales: mettre en doute() et exec (). Les premiers retours reviennent un Pdostatemnt objet que vous pouvez utiliser pour accéder aux résultats via le aller chercher() ou fetchall () Méthodes: vous l'utilisez pour une instruction qui ne modifie pas un tableau, comme SÉLECTIONNER.

Ce dernier, à la place, renvoie le nombre de lignes qui ont été modifiées par la requête: nous l'utilisons pour des instructions qui modifient les lignes, comme INSÉRER, SUPPRIMER ou MISE À JOUR. Les déclarations directes ne doivent être utilisées que lorsqu'il n'y a pas de variables dans la requête et vous avez absolument confiance qu'il est sûr et correctement échappé.

Déclarations préparées

L'APD prend également en charge les déclarations préparées en deux étapes: ceci est utile lorsque vous utilisez des variables dans la requête, et c'est plus sécurisé en général, car le préparer() La méthode effectuera toute la fuite nécessaire pour nous. Voyons comment les variables sont utilisées. Imaginez que nous voulons insérer les propriétés d'un objet de planète dans le Planètes tableau. Nous préparerions d'abord la requête:

$ stmt = $ PDO-> PREPREA?, ?) ");
Copie

Comme dit précédemment, nous utiliserions d'abord le préparer() Méthode qui prend la requête SQL comme argument, en utilisant des espaces réservés pour les variables. Maintenant, les espaces réservés peuvent être de deux types:

Espaces réservés positionnels

Lors de l'utilisation ? Planifications positionnelles, nous pouvons obtenir du code plus concis, mais nous devons fournir les valeurs à substituer dans le même ordre des noms de colonne, dans un tableau prévu comme argument à l'argument exécuter() méthode:

$ stmt-> exécuter ([$ planet-> name, $ Planet-> couleur]);
Copie

Des espaces réservés nommés

En utilisant des espaces réservés nommés, Nous n'avons pas à respecter un ordre particulier, mais nous allons créer plus de code verbeux. Lors de l'exécution du exécuter() Méthode Nous devons fournir les valeurs sous la forme d'un tableau associatif dans lequel chaque clé serait le nom de l'espace réservé utilisé, et la valeur associée serait celle à substituer dans la requête. Par exemple, la requête ci-dessus deviendrait:

$ stmt = $ PDO-> Préparer ("Insérer dans les planètes (nom, couleur) valeurs (: nom ,: couleur)"); $ stmt-> exécuter (['name' => $ planet-> name, 'colore' => $ planet-> colore]);
Copie

Les méthodes de préparation et d'exécution peuvent être utilisées à la fois lors de la réalisation de requêtes qui modifient ou récupèrent simplement les données de la base de données. Dans le premier cas, nous utilisons les méthodes de récupération que nous avons vues ci-dessus pour récupérer les données, tandis que dans ce dernier, nous pouvons récupérer le nombre de lignes affectées en utilisant le RowCount () méthode.

Les méthodes bindvalue () et bindparam ()

Pour fournir les valeurs à substituer dans la requête, nous pouvons également utiliser le bindValue () et bindParam () méthodes. Le premier lie la valeur de la variable fournie à l'espace réservé positionnel ou nommé utilisé lors de la préparation de la requête. En utilisant l'exemple ci-dessus, nous aurions fait:

$ stmt-> bindValue ('name', $ planet-> name, pdo :: param_str);
Copie

Nous lions la valeur de $ Planet-> Nom au :nom espace réservé. Remarquez que l'utilisation de méthodes BindValue () et BindParam () que nous pouvons spécifier, comme troisième argument, le taper de la variable, en utilisant la constante APD associée, dans ce cas PDO :: param_str.

En utilisant bindParam (), Au lieu de cela, nous pouvons lier la variable à l'espace réservé connexe utilisé lors de la préparation de la requête. Notez que dans ce cas, la variable est liée par référence, et sa valeur ne sera substituée qu'à l'espace réservé exécuter() Méthode que s'appelle. La syntaxe est la même que ci-dessus:

$ stmt-> bindParam ('name', $ planet-> name, PDO :: param_str)
Copie

Nous avons lié la variable $ Planet-> Nom au :nom place d'espace, pas sa valeur actuelle! Comme dit ci-dessus, la conversion sera effectuée juste au moment exécuter() La méthode sera appelée, donc l'espace réservé sera par la valeur de la variable à ce moment-là.

Transactions APD

Les transactions fournissent un moyen de préserver la cohérence lors de l'émission de requêtes multiples. Toutes les requêtes sont effectuées dans un «lot» et engagées dans la base de données uniquement si toutes sont réussies. Les transactions ne fonctionneront pas dans toutes les bases de données et non pour toutes SQL Constructions, car certaines d'entre elles provoquent et sont implicites (liste complète ici)

Avec un exemple extrême et étrange, imaginez que l'utilisateur doit sélectionner une liste de planètes, et chaque fois qu'il soumet une nouvelle sélection, vous souhaitez supprimer le précédent de la base de données avant d'insérer le nouveau. Que se passerait-il si la suppression réussissait, mais pas l'insertion? Nous aurions un utilisateur sans planètes! En règle générale, c'est ainsi que les transactions sont implémentées:

$ pDo-> beginTransaction (); essayez $ stmt1 = $ pDo-> exec ("supprimer des planètes"); $ stmt2 = $ PDO-> PRÉPET ("INSERT INTO PLANETS (nom, couleur) Valeurs (?, ?) "); ForEach ($ planètes comme $ planet) $ stmt2-> exécuter ([$ planet-> getName (), $ planet-> getColor ()]); $ pDo-> commit (); catch ( PDoException $ e) $ pDo-> rollback ();
Copie

Tout d'abord le BeginTransaction () La méthode de l'objet PDO désactive la requête AutoCommit, puis à l'intérieur d'un bloc d'essai, les requêtes sont exécutées dans l'ordre recherché. À ce stade si non PDOException est soulevé, les requêtes sont commises avec le commettre() Méthode, sinon, via le retour en arriere() Méthode, les transactions sont restées et autocommit sont restaurés.

De cette façon, il y aura toujours une cohérence lors de la publication de plusieurs requêtes. Il est assez évident que vous ne pouvez utiliser des transactions APD APD :: att_errMode est réglé sur PDO :: errmode_exception.

Tutoriels Linux connexes:

  • Choses à installer sur Ubuntu 20.04
  • Comment changer le mot de passe de l'utilisateur de MariaDB
  • Comment créer une pile de lampe basée sur Docker à l'aide de Docker sur…
  • Ampache Raspberry Pi Installation
  • Une introduction à l'automatisation Linux, des outils et des techniques
  • Installation de WordPress OpenLitesPeed
  • Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
  • Ubuntu 20.04 WordPress avec installation Apache
  • Ubuntu 20.04: WordPress avec l'installation de Nginx
  • Installez MySQL sur Ubuntu 20.04 LTS Linux