Commencer avec FluentPdo

Dites au revoir à la requête SQL ennuyeuse! Simplifiez les opérations de base de données avec FluentPdo

Êtes-vous fatigué d'écrire également des requêtes SQL? Surtout quand le temps est serré. Si vous êtes comme moi, nous apprendrons aujourd'hui un outil très cool: FluentPdo. Si vous n'êtes pas familier avec le terme "APD", ne vous inquiétez pas. C'est un concept très simple: dans le monde PHP, PDO signifie un objet de données persistant, qui vous aide à résumer certaines opérations de base de données de base (telles que l'insertion, la mise à jour, la suppression, etc.). Il s'agit d'une couche d'abstraction entre vous et la base de données.

quel est le résultat? Plus besoin d'écrire des requêtes SQL! Ce n'est peut-être pas le premier projet de ce type que vous avez jamais vu: il existe de nombreux projets similaires sur le marché, chacun avec ses caractéristiques clés. La caractéristique clé de FluentPdo est son puissant constructeur de requête de jointure.

points clés

• FluentPdo est un générateur de requête SQL PHP qui résume les opérations de base de données de base sans écrire des requêtes SQL. Sa caractéristique clé est un puissant constructeur de requête de jointure.
• L'installation de FluentPDO est effectuée via le compositeur sans aucune configuration supplémentaire. Instanciez l'objet PDO en le faisant passer en tant que paramètre au constructeur de l'objet FluentPDO.
• FLUENTPDO fournit une syntaxe simple et facile à lire pour les opérations de base, y compris des méthodes pour définir des tables, filtrer les résultats et spécifier les opérateurs de comparaison. Il permet également de sélectionner des champs spécifiques, de régler les paramètres de limite et de décalage, et d'utiliser les instructions ayant, groupe BY et Order By.
• FLUENTPDO prend également en charge les opérations de données à l'aide des classes d'insertion, de mise à jour et de suppression de l'opération. Ces opérations nécessitent la méthode EXECUTE () pour exécuter la requête et modifier la base de données.
• Les fonctionnalités avancées de FluentPDO incluent le générateur de requête de jointure (le code simplifie la requête de jointure) et un système de débogueur intégré (pour tester et vérifier les requêtes).

Notre projet de test FluentPDO

Tout d'abord, nous avons besoin d'un exemple de projet pour le faire. Pensons-y ... que diriez-vous d'une simple liste de souhaits multi-utilisateurs?

Il y aura de nombreux utilisateurs et chaque utilisateur a son propre produit préféré. Pour chaque utilisateur, nous stockons son prénom, son nom de famille et sa date d'enregistrement. Pour chaque article, nous stockons son nom, sa marque, son prix et son ID utilisateur connexe.

J'utiliserai une simple base de données MySQL. Voici notre structure de données:

Ce qui suit est un vidage SQL (y compris certaines données factices):

<code class="language-sql">CREATE TABLE IF NOT EXISTS items (   
        id int(11) NOT NULL AUTO_INCREMENT,   
        name varchar(100) NOT NULL,   
        brand varchar(100) NOT NULL,   
        price decimal(10,2) NOT NULL,   
        user_id int(10) unsigned NOT NULL,   
        PRIMARY KEY (id),   
        KEY user_id (user_id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;

    INSERT INTO items (id, name, brand, price, user_id) 
    VALUES 
    (1, 'Last Awesome Phone', 'Awesome Brand', '550.00', 1), 
    (2, 'Last Awesome TV', 'Awesome Brand', '1200.00', 1), 
    (3, 'Fantastic E-Car', 'E-Cars Inc.', '80000.00', 2), 
    (4, 'Fantastic E-Bike', 'E-Bikes Co. Ltd.', '16000.00', 2);

    CREATE TABLE IF NOT EXISTS users (
        id int(10) unsigned NOT NULL AUTO_INCREMENT,   
        first_name varchar(100) NOT NULL,   
        last_name varchar(100) NOT NULL,   
        signup_date datetime NOT NULL,   
        PRIMARY KEY (id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;

    INSERT INTO users (id, first_name, last_name, signup_date) 
    VALUES 
    (1, 'Francesco', 'Malatesta', '2014-06-29 13:00:00'), 
    (2, 'John', 'Foo Bar', '2014-06-20 11:16:39');

    ALTER TABLE items   ADD CONSTRAINT items_ibfk_1 FOREIGN KEY (user_id) REFERENCES users (id);</code>

Remarque: Comme vous pouvez facilement l'imaginer, ce n'est pas un projet "complet". Nous essayons simplement FluentPDO, donc nous ne couvrions pas des choses comme la connexion, l'enregistrement ou la structure d'application.

Installation

Vous pouvez installer FluentPDO à l'aide de composer et l'inclure comme dépendance:

<code class="language-json">"require": {
        ...
        "lichtner/fluentpdo": "dev-master"  
    }</code>

Lorsque vous avez terminé, vous devez l'instancier comme ceci:

<code class="language-sql">CREATE TABLE IF NOT EXISTS items (   
        id int(11) NOT NULL AUTO_INCREMENT,   
        name varchar(100) NOT NULL,   
        brand varchar(100) NOT NULL,   
        price decimal(10,2) NOT NULL,   
        user_id int(10) unsigned NOT NULL,   
        PRIMARY KEY (id),   
        KEY user_id (user_id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;

    INSERT INTO items (id, name, brand, price, user_id) 
    VALUES 
    (1, 'Last Awesome Phone', 'Awesome Brand', '550.00', 1), 
    (2, 'Last Awesome TV', 'Awesome Brand', '1200.00', 1), 
    (3, 'Fantastic E-Car', 'E-Cars Inc.', '80000.00', 2), 
    (4, 'Fantastic E-Bike', 'E-Bikes Co. Ltd.', '16000.00', 2);

    CREATE TABLE IF NOT EXISTS users (
        id int(10) unsigned NOT NULL AUTO_INCREMENT,   
        first_name varchar(100) NOT NULL,   
        last_name varchar(100) NOT NULL,   
        signup_date datetime NOT NULL,   
        PRIMARY KEY (id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;

    INSERT INTO users (id, first_name, last_name, signup_date) 
    VALUES 
    (1, 'Francesco', 'Malatesta', '2014-06-29 13:00:00'), 
    (2, 'John', 'Foo Bar', '2014-06-20 11:16:39');

    ALTER TABLE items   ADD CONSTRAINT items_ibfk_1 FOREIGN KEY (user_id) REFERENCES users (id);</code>

Vous devez spécifier vos détails de connexion dans la méthode du constructeur APD. Dans le premier paramètre, tapez votre nom de base de données après la section DBNAME = et écrivez respectivement votre nom d'utilisateur et votre mot de passe comme deuxième et troisième paramètres.

Vous passez ensuite l'objet PDO en tant que paramètre au constructeur de l'objet FluentPDO.

C'est tout, FluentPdo n'a besoin de rien d'autre pour travailler. Aucune configuration supplémentaire requise.

Opération de sélection de base

Nous avons déjà des données virtuelles. Commençons par "Hello World" de SQL Query. Une simple sélection avec une clause Where et l'ID de clé primaire de l'utilisateur comme paramètre pour récupérer les informations de base.

<code class="language-json">"require": {
        ...
        "lichtner/fluentpdo": "dev-master"  
    }</code>

Rien n'est difficile à comprendre ici. FluentPdo a une bonne syntaxe facile à lire, il est donc facile de comprendre ce que nous faisons.

La méthode

from () est utilisée pour définir la bonne table. La méthode où () est utilisée pour filtrer nos résultats avec la même clause de nom. Par défaut, dans la méthode WHERE (), vous simplement spécifiez le nom et la valeur du champ. "=" est implicite. Bien sûr, vous pouvez également utiliser différents opérateurs de comparaison. Dans ce cas, vous devez les écrire après le nom du champ.

<code class="language-php">$pdo = new PDO("mysql:dbname=wishlist", "root", "password");
    $fpdo = new FluentPDO($pdo);</code>

Obtenir les résultats est très facile: ils sont stockés dans l'objet $ Query que nous venons d'utiliser. Vous pouvez l'alléter dessus à l'aide d'une boucle FOREAK comme indiqué dans l'exemple.

Dans ce cas spécifique (rechercher l'élément par ID de clé primaire), nous pouvons également utiliser les raccourcis dans la méthode From ():

<code class="language-php">$user_id = 1;

    $query = $fpdo->from('users')->where('id', $user_id);

    foreach($query as $row){
        echo 'Hello, ' . $row['first_name'] . ' ' . $row['last_name'] . '!';    
    }</code>

Voyons quelque chose de plus compliqué que cela.

Sélectionnez un champ spécifique

Si vous le souhaitez, vous pouvez utiliser la méthode SELECT () après () pour sélectionner. Il vous suffit d'utiliser un tableau pour indiquer à FluentPDO quels champs vous souhaitez sélectionner.

Ceci est un exemple:

<code class="language-php">$fpdo->from('items')->where('price >', 1000);</code>

limite et décalage

La définition des paramètres de limite et de décalage pour récupérer uniquement un certain nombre de lignes de la base de données est très facile. Vous pouvez utiliser des méthodes Limit () et Offset () comme celle-ci.

<code class="language-php">$query = fpdo->from('users', $user_id);

    // 将与...相同
    $query = $fpdo->from('users')->where('id', $user_id);</code>

Le seul argument de ces deux méthodes est un entier qui spécifie la valeur requise (pour limite (), c'est le nombre d'éléments; pour offset (), c'est le nombre d'éléments à ignorer).

Avoir, groupe par et ordre par

Des méthodes

sont également fournies pour les instructions "Avoir", "Group By" et "Order by".

Voyons-les avec quelques exemples.

Ordre par

La méthode

orderBy () est utilisée pour trier les résultats en fonction de conditions spécifiques. Donnons un exemple: voici comment trier les résultats par prix (de bon marché à coûteux).

<code class="language-php">$query = $fpdo->from('users')->select(array('first_name', 'last_name'))->where('id', $user_id);</code>

Si vous souhaitez inverser la commande (obtenez le résultat du plus cher au moins cher), ajoutez simplement "DESC" après la colonne sélectionnée.

<code class="language-php">// 选择前十个结果...
    $query = $fpdo->from('users')->where('id', $user_id)->limit(10)->offset(0);</code>

ayant

La méthode

ayant () a une syntaxe très simple. Dans l'exemple ci-dessous, nous filtrons chaque article qui coûte moins de 2 000 $.

<code class="language-php">$query = $fpdo->from('items')->orderBy('price');</code>

très simple.

Vous pouvez utiliser n'importe quel opérateur de comparaison souhaité.

Groupe par

Utiliser la méthode groupBy (), vous pouvez regrouper les résultats en utilisant des champs spécifiques comme conditions. Ici, nous affichons la quantité de produits pour chaque marque.

<code class="language-sql">CREATE TABLE IF NOT EXISTS items (   
        id int(11) NOT NULL AUTO_INCREMENT,   
        name varchar(100) NOT NULL,   
        brand varchar(100) NOT NULL,   
        price decimal(10,2) NOT NULL,   
        user_id int(10) unsigned NOT NULL,   
        PRIMARY KEY (id),   
        KEY user_id (user_id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;

    INSERT INTO items (id, name, brand, price, user_id) 
    VALUES 
    (1, 'Last Awesome Phone', 'Awesome Brand', '550.00', 1), 
    (2, 'Last Awesome TV', 'Awesome Brand', '1200.00', 1), 
    (3, 'Fantastic E-Car', 'E-Cars Inc.', '80000.00', 2), 
    (4, 'Fantastic E-Bike', 'E-Bikes Co. Ltd.', '16000.00', 2);

    CREATE TABLE IF NOT EXISTS users (
        id int(10) unsigned NOT NULL AUTO_INCREMENT,   
        first_name varchar(100) NOT NULL,   
        last_name varchar(100) NOT NULL,   
        signup_date datetime NOT NULL,   
        PRIMARY KEY (id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;

    INSERT INTO users (id, first_name, last_name, signup_date) 
    VALUES 
    (1, 'Francesco', 'Malatesta', '2014-06-29 13:00:00'), 
    (2, 'John', 'Foo Bar', '2014-06-20 11:16:39');

    ALTER TABLE items   ADD CONSTRAINT items_ibfk_1 FOREIGN KEY (user_id) REFERENCES users (id);</code>

Remarque: vous pouvez spécifier un alias pour des champs comme dans SQL classique.

Obtenir la méthode

Fetch

L'utilisation de foreach n'est pas le seul moyen d'obtenir le résultat. Et si nous voulons juste récupérer le premier résultat de la collection?

Utilisez simplement la méthode fetch ():

<code class="language-json">"require": {
        ...
        "lichtner/fluentpdo": "dev-master"  
    }</code>

Vous pouvez également obtenir une seule colonne en spécifiant son nom en tant que paramètre.

<code class="language-php">$pdo = new PDO("mysql:dbname=wishlist", "root", "password");
    $fpdo = new FluentPDO($pdo);</code>

fetchpairs

En utilisant fetchPairs (), vous pouvez récupérer les résultats en tant que tableau associatif. Utilisez la syntaxe suivante:

<code class="language-php">$user_id = 1;

    $query = $fpdo->from('users')->where('id', $user_id);

    foreach($query as $row){
        echo 'Hello, ' . $row['first_name'] . ' ' . $row['last_name'] . '!';    
    }</code>

vous obtiendrez la sortie suivante:

<code class="language-php">$fpdo->from('items')->where('price >', 1000);</code>

Ceci est un exemple utilisant un ID et un nom Utilising Unique.

<code class="language-php">$query = fpdo->from('users', $user_id);

    // 将与...相同
    $query = $fpdo->from('users')->where('id', $user_id);</code>

fetchall

Le dernier mais non le moindre est la méthode fetchall ().

Ce qui suit est la syntaxe:

<code class="language-php">$query = $fpdo->from('users')->select(array('first_name', 'last_name'))->where('id', $user_id);</code>

En utilisant fetchall (), nous avons un contrôle complet sur ce que nous obtenons du résultat. Le premier paramètre $ index est le champ utilisé comme index, et $ SelectOlly est utilisé pour spécifier le champ à sélectionner.

Ceci est un exemple:

<code class="language-php">// 选择前十个结果...
    $query = $fpdo->from('users')->where('id', $user_id)->limit(10)->offset(0);</code>

Remarque: La colonne utilisée comme index (ID dans ce cas) est également incluse dans le tableau final.

D'accord, il suffit de sélectionner des opérations. Jetons un coup d'œil aux autres opérations CRUD.

insérer, mettre à jour et supprimer

FluentPdo ne consiste pas seulement à choisir quelque chose. Il dispose également de classes qui manipulent les données de manière simple.

Commençons par l'opération d'insertion.

INSERT

<code class="language-php">$query = $fpdo->from('items')->orderBy('price');</code>

La méthode

insertinto () est utilisée pour spécifier le tableau à utiliser pour l'opération. Vous devez ensuite attribuer les valeurs requises en utilisant la méthode VALEUR () (dans ce cas, elles sont stockées dans le tableau Associative $ VALEUR).

La dernière étape sera la méthode Execute (), qui renverra la clé principale du nouvel enregistrement.

Vous pouvez également utiliser ce raccourci si vous le souhaitez:

<code class="language-php">$query = $fpdo->from('items')->orderBy('price DESC');</code>

Mise à jour

La méthode de mise à jour est très similaire. Regardons un exemple.

<code class="language-php">$query = $fpdo->from('items')->having('price <', 2000);</code>

Utilisez la méthode set (), vous pouvez spécifier une nouvelle valeur pour l'opération de mise à jour.

Utilisez la méthode où (), nous filtrons les lignes affectées. Il y a aussi un raccourci, comme mentionné précédemment.

supprimer

Supprimer l'opération est plus facile. Voici un exemple rapide.

<code class="language-php">$query = $fpdo->from('items')->select('brand, COUNT(*) AS c')->groupBy('brand');</code>

Si vous souhaitez supprimer un enregistrement qui connaît sa clé principale, vous pouvez utiliser le raccourci DeleteFrom () ci-dessus.

Remarque: Comme vous pouvez le voir dans l'exemple ici, vous devez utiliser la méthode Execute () pour exécuter la requête de suppression. Si vous ne faites pas cela, vous ne changerez rien dans la base de données. Il en va de même pour l'insert et la mise à jour. Gardez cela à l'esprit.

fonctionnalités avancées

Comme je vous l'ai déjà dit, ces types de projets ont leurs propres fonctionnalités uniques. FluentPdo ne fait pas exception: nous analyserons deux de ces fonctionnalités: le générateur de requête de jointure et le débogueur.

Rejoignez le générateur de requête

est probablement la caractéristique unique la plus importante de FluentPdo. Le constructeur est très utile si vous souhaitez simplifier votre travail et écrire moins de code. Voyons comment l'utiliser.

Nous allons commencer par la requête de jointure "classique" écrite à l'aide de FluentPdo.

similaire à ceci:

<code class="language-php">$query = $fpdo->from('users');
    $row = $query->fetch();

    var_dump($row);
    // 将输出：
    // array(4) { ["id"]=> string(1) "1" ["first_name"]=> string(9) "Francesco" ["last_name"]=> string(9) "Malatesta" ["signup_date"]=> string(19) "2014-06-29 13:00:00" }</code>

OK: nous utilisons la syntaxe classique dans la méthode spéciale de gauche (). pas mal.

mais nous pouvons faire mieux. Si vous utilisez des conventions dans une structure de table, vous pouvez utiliser ce code:

<code class="language-sql">CREATE TABLE IF NOT EXISTS items (   
        id int(11) NOT NULL AUTO_INCREMENT,   
        name varchar(100) NOT NULL,   
        brand varchar(100) NOT NULL,   
        price decimal(10,2) NOT NULL,   
        user_id int(10) unsigned NOT NULL,   
        PRIMARY KEY (id),   
        KEY user_id (user_id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;

    INSERT INTO items (id, name, brand, price, user_id) 
    VALUES 
    (1, 'Last Awesome Phone', 'Awesome Brand', '550.00', 1), 
    (2, 'Last Awesome TV', 'Awesome Brand', '1200.00', 1), 
    (3, 'Fantastic E-Car', 'E-Cars Inc.', '80000.00', 2), 
    (4, 'Fantastic E-Bike', 'E-Bikes Co. Ltd.', '16000.00', 2);

    CREATE TABLE IF NOT EXISTS users (
        id int(10) unsigned NOT NULL AUTO_INCREMENT,   
        first_name varchar(100) NOT NULL,   
        last_name varchar(100) NOT NULL,   
        signup_date datetime NOT NULL,   
        PRIMARY KEY (id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;

    INSERT INTO users (id, first_name, last_name, signup_date) 
    VALUES 
    (1, 'Francesco', 'Malatesta', '2014-06-29 13:00:00'), 
    (2, 'John', 'Foo Bar', '2014-06-20 11:16:39');

    ALTER TABLE items   ADD CONSTRAINT items_ibfk_1 FOREIGN KEY (user_id) REFERENCES users (id);</code>

génial, non? Ok, Fast est vraiment cool… mais qu'en est-il intelligent?

Regardez ici:

<code class="language-json">"require": {
        ...
        "lichtner/fluentpdo": "dev-master"  
    }</code>

ça s'est amélioré.

En fait, FluentPdo comprend ce que vous voulez faire et construit automatiquement la requête en utilisant les données que vous fournissez dans la méthode SELECT () avec la chaîne de format Table.FieldName.

Vous pouvez lire la requête de construction finale pour le dernier exemple ici:

<code class="language-php">$pdo = new PDO("mysql:dbname=wishlist", "root", "password");
    $fpdo = new FluentPDO($pdo);</code>

Cela a l'air bien.

Bien sûr, vous pouvez créer un alias pour le champ si vous voulez:

<code class="language-php">$user_id = 1;

    $query = $fpdo->from('users')->where('id', $user_id);

    foreach($query as $row){
        echo 'Hello, ' . $row['first_name'] . ' ' . $row['last_name'] . '!';    
    }</code>

débogueur

FLUENTPDO est livré avec un système de débogueur intégré que vous pouvez utiliser pour tester les requêtes et les vérifier.

Il utilise un système de fermeture simple. Si vous souhaitez utiliser le débogage, placez simplement ce code après avoir connecté le code.

<code class="language-php">$fpdo->from('items')->where('price >', 1000);</code>

Vous pouvez personnaliser la fermeture comme vous le souhaitez, n'oubliez pas de prendre l'objet $ BaseQuery en tant que paramètre.

$ L'objet BaseQuery est une instance de la classe BaseQuery.

Conclusion

FluentPdo est un projet petit et simple. Il ne correspond certainement pas à tous les projets et peut être amélioré - surtout s'il est en sommeil depuis six mois - mais pour les applications de petite / moyenne / moyenne . C'est un bon compromis en raison de certaines de ses fonctionnalités, telles que le générateur de requête de jointure.

FAQ sur le démarrage avec FluentPdo (FAQ)

Qu'est-ce que FluentPdo et pourquoi devrais-je l'utiliser?

FLUENTPDO est un constructeur de requête SQL PHP qui utilise l'APD. Il fournit une interface simple et facile à utiliser pour créer des requêtes SQL, ce qui facilite l'interaction pour les développeurs avec les bases de données. FluentPdo est particulièrement utile pour ceux qui ne sont pas habitués à écrire des requêtes SQL brutes ou qui souhaitent accélérer le processus de développement. Il prend en charge toutes les fonctions SQL et fournit un moyen sûr de prévenir les attaques d'injection SQL.

Comment installer FluentPdo?

FLUENTPDO peut être installé à l'aide de Composer (PHP Dependency Manager). Vous pouvez l'installer en exécutant la commande composer require envms/fluentpdo. Après avoir exécuté cette commande, Composer téléchargera et installera FluentPdo et ses dépendances dans votre projet.

Comment se connecter à une base de données à l'aide de FluentPDO?

Pour vous connecter à la base de données à l'aide de FluentPDO, vous devez créer une nouvelle instance de la classe FLUENTPDO. Vous pouvez le faire en passant une instance APD au constructeur FluentPDO. Voici un exemple:

<code class="language-php">$query = fpdo->from('users', $user_id);

    // 将与...相同
    $query = $fpdo->from('users')->where('id', $user_id);</code>

Comment exécuter la requête sélectionnée à l'aide de FluentPDO?

FLUENTPDO fournit une interface simple pour effectuer des requêtes sélectionnées. Vous pouvez spécifier un tableau à l'aide de la méthode from et spécifier une colonne à l'aide de la méthode select. Voici un exemple:

<code class="language-php">$query = $fpdo->from('users')->select(array('first_name', 'last_name'))->where('id', $user_id);</code>

Comment exécuter des requêtes d'insert à l'aide de FluentPDO?

Pour effectuer une requête d'insertion, vous pouvez spécifier le tableau à l'aide de la méthode insertInto et spécifier la valeur à l'aide de la méthode values. Voici un exemple:

<code class="language-sql">CREATE TABLE IF NOT EXISTS items (   
        id int(11) NOT NULL AUTO_INCREMENT,   
        name varchar(100) NOT NULL,   
        brand varchar(100) NOT NULL,   
        price decimal(10,2) NOT NULL,   
        user_id int(10) unsigned NOT NULL,   
        PRIMARY KEY (id),   
        KEY user_id (user_id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;

    INSERT INTO items (id, name, brand, price, user_id) 
    VALUES 
    (1, 'Last Awesome Phone', 'Awesome Brand', '550.00', 1), 
    (2, 'Last Awesome TV', 'Awesome Brand', '1200.00', 1), 
    (3, 'Fantastic E-Car', 'E-Cars Inc.', '80000.00', 2), 
    (4, 'Fantastic E-Bike', 'E-Bikes Co. Ltd.', '16000.00', 2);

    CREATE TABLE IF NOT EXISTS users (
        id int(10) unsigned NOT NULL AUTO_INCREMENT,   
        first_name varchar(100) NOT NULL,   
        last_name varchar(100) NOT NULL,   
        signup_date datetime NOT NULL,   
        PRIMARY KEY (id) ) ENGINE=InnoDB  
        DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;

    INSERT INTO users (id, first_name, last_name, signup_date) 
    VALUES 
    (1, 'Francesco', 'Malatesta', '2014-06-29 13:00:00'), 
    (2, 'John', 'Foo Bar', '2014-06-20 11:16:39');

    ALTER TABLE items   ADD CONSTRAINT items_ibfk_1 FOREIGN KEY (user_id) REFERENCES users (id);</code>

Comment exécuter la requête de mise à jour à l'aide de FluentPDO?

Pour effectuer une requête de mise à jour, vous pouvez spécifier le tableau à l'aide de la méthode update, spécifier la nouvelle valeur à l'aide de la méthode set et spécifier les conditions à l'aide de la méthode where. Voici un exemple:

<code class="language-json">"require": {
        ...
        "lichtner/fluentpdo": "dev-master"  
    }</code>

Comment effectuer des requêtes de suppression à l'aide de FluentPdo?

Pour effectuer une requête de suppression, vous pouvez spécifier le tableau à l'aide de la méthode deleteFrom et spécifier les conditions à l'aide de la méthode where. Voici un exemple:

<code class="language-php">$pdo = new PDO("mysql:dbname=wishlist", "root", "password");
    $fpdo = new FluentPDO($pdo);</code>

Comment gérer les erreurs dans FluentPdo?

Lorsqu'une erreur se produit, FluentPdo lancera une exception. Vous pouvez utiliser le bloc d'essai pour assister à ces exceptions et les gérer en conséquence. Voici un exemple:

<code class="language-php">$user_id = 1;

    $query = $fpdo->from('users')->where('id', $user_id);

    foreach($query as $row){
        echo 'Hello, ' . $row['first_name'] . ' ' . $row['last_name'] . '!';    
    }</code>

Comment utiliser les transactions dans FluentPDO?

FLUENTPDO fournit des méthodes pour démarrer, engager et faire reculer les transactions. Vous pouvez utiliser des méthodes beginTransaction, commit et rollBack respectivement. Voici un exemple:

<code class="language-php">$fpdo->from('items')->where('price >', 1000);</code>

Comment utiliser FluentPDO pour rejoindre les tables?

FluentPdo fournit une interface simple pour connecter les tables. Vous pouvez utiliser la méthode join pour spécifier des tables et des conditions. Voici un exemple:

<code class="language-php">$query = fpdo->from('users', $user_id);

    // 将与...相同
    $query = $fpdo->from('users')->where('id', $user_id);</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!