Téléchargement php dbhandler - Téléchargement du code source php dbhandler

PHP-DbHandler

Statut de l'action CI GitHub

PHP-DbHandler est une bibliothèque PHP conçue pour simplifier les interactions avec les bases de données MySQL. Il offre un ensemble complet d'outils pour créer et exécuter des requêtes, gérer des transactions et gérer le schéma de base de données via des connexions PDO.

Contenu

Caractéristiques
Installation
Installation
Créer des clauses Where et Having
- Opérateurs de comparaison
- Opérateurs logiques
- or et and opérateurs
Création et exécution de requêtes
- SÉLECTIONNER
- INSÉRER
- MISE À JOUR
- SUPPRIMER
- PROCÉDURES STOCKÉES
Transactions
- Gestion des transactions globales
Contribuer
- Processus de contribution
- Utilisation du conteneur de développement
- Test avec Pest
- Soumettre des contributions
- Processus d'examen
- Questions et discussions
Licence
Soutien

Caractéristiques

Création de requêtes : créez facilement des requêtes SQL à l'aide d'une syntaxe fluide et intuitive.
Gestion des transactions : gérez efficacement les transactions de base de données avec un support intégré.
Gestion des schémas : gérez facilement le schéma de la base de données, y compris les tables et les procédures stockées.
Intégration du cache : exploitez la mise en cache des résultats des requêtes afin d'améliorer les performances.
Journalisation et gestion des erreurs : journalisation et gestion des erreurs intégrées pour un meilleur débogage et une meilleure surveillance.
Conformité aux normes PSR : adhère aux normes PSR, garantissant un code PHP interopérable et de haute qualité.

Installation

Installez le package via Composer :

composer require tribal2/db-handler

Installation

Commencez par créer une instance Db :

 use Tribal2  DbHandler  Core  PDOWrapper ;
use Tribal2  DbHandler  Db ;
use Tribal2  DbHandler  DbConfig ;

$ config = DbConfig:: create ( ' my_database ' )
  -> withUser ( ' username ' )
  -> withPassword ( ' password ' )
  -> withHost ( ' localhost ' )   // Optional. Default: 'localhost'
  -> withPort ( 3306 )          // Optional. Default: 3306
  -> withCharset ( ' utf8mb4 ' ); // Optional. Default: 'utf8mb4'

$ pdoWrapper = new PDOWrapper (
  $ config ,
  // Optional PsrLogLoggerInterface instance.
  // $logger, // Default: PsrLogNullLogger
);

$ db = new Db (
  $ pdoWrapper ,
  // Optional PsrSimpleCacheCacheInterface instance.
  // $cache,  // Default: NULL
);

Créer des clauses `Where` et `Having`

La classe Where offre un moyen flexible et intuitif de créer des conditions de requête. Il prend en charge une variété d'opérateurs de comparaison et logiques, vous permettant de définir précisément les critères de sélection ou de filtrage des données de votre base de données.

Les méthodes renvoient un objet Where encapsulant la condition, ainsi qu'une valeur paramétrée pour une interrogation sécurisée et efficace.

Les clauses Where simplifient non seulement la construction de la syntaxe des requêtes, mais améliorent également la sécurité en gérant en interne les risques associés à l'injection SQL. Cette bibliothèque remplace automatiquement les valeurs par des paramètres nommés PDO et effectue la liaison en utilisant les types de données PDO appropriés. En gérant ces aspects cruciaux, il garantit que vos requêtes sont non seulement propres et maintenables, mais également sécurisées.

Vous n'avez plus à vous soucier de nettoyer manuellement vos entrées pour les requêtes de base de données. La bibliothèque se charge de préparer les instructions de manière à protéger contre l'injection SQL, l'une des vulnérabilités de sécurité les plus courantes dans les applications basées sur des bases de données. Cette approche vous permet de vous concentrer sur la logique métier de votre application, en étant sûr que les interactions avec la base de données sont gérées de manière sûre et efficace.

Opérateurs de comparaison

 $ where = Where:: equals ( ' status ' , ' active ' );
// Output: `status` = :status___1

$ where = Where:: notEquals ( ' category ' , ' archived ' );
// Output: `category` <> :category___1

$ where = Where:: greaterThan ( ' price ' , 100 );
// Output: `price` > :price___1

$ where = Where:: greaterThanOrEquals ( ' price ' , 100 );
// Output: `price` >= :price___1

$ where = Where:: lessThan ( ' price ' , 50 );
// Output: `price` < :price___1

$ where = Where:: lessThanOrEquals ( ' price ' , 50 );
// Output: `price` <= :price___1

$ where = Where:: isNull ( ' description ' );
// Output: `description` IS NULL

$ whereNotNull = Where:: isNotNull ( ' description ' );
// Output: Output: `description` IS NOT NULL

Opérateurs logiques

 $ where = Where:: like ( ' name ' , ' %Apple% ' );
// Output: `name` LIKE :name___1

$ where = Where:: notLike ( ' name ' , ' %Apple% ' );
// Output: `name` NOT LIKE :name___1

$ where = Where:: between ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` BETWEEN :date___1 AND :date___2

$ where = Where:: notBetween ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` NOT BETWEEN :date___1 AND :date___2

$ where = Where:: in ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` IN (:status___1, :status___2, :status___3)

$ where = Where:: notIn ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` NOT IN (:status___1, :status___2, :status___3)

`or` et `and` opérateurs

 $ where1 = Where:: equals ( ' status ' , ' active ' );
$ where2 = Where:: greaterThan ( ' price ' , 100 );
$ orWhere = Where:: or ( $ where1 , $ where2 );
// Output: (`status` = :status___1 OR `price` > :price___1)

$ andWhere = Where:: and ( $ where1 , $ where2 );
// Output: (`status` = :status___1 AND `price` > :price___1)

Vous pouvez également imbriquer les opérateurs or et and :

 $ where3 = Where:: equals ( ' category ' , ' archived ' );
$ combinedWhere = Where:: and ( $ where3 , $ orWhere );
// Output: (`category` = :category___1 AND (`status` = :status___1 OR `price` > :price___1))

Création et exécution de requêtes

Dans les sous-sections suivantes, nous explorerons comment créer et exécuter des requêtes à l'aide de cette bibliothèque. Par souci de simplicité, nous supposerons que la variable $db est une instance de la classe Db .

Dans tous les exemples ci-dessous, nous avons séparé la construction de la requête de l'exécution. Cette approche vous permet de réutiliser l'objet requête et de l'exécuter plusieurs fois avec différents paramètres, mais vous pouvez également enchaîner les méthodes pour créer et exécuter la requête dans une seule instruction comme celle-ci :

 $ results = $ db
  -> select ()
  -> columns ([ ' column1 ' , ' column2 ' ])
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column2 ' , 1 ))
  -> fethAll ();

SÉLECTIONNER

 $ select = $ db -> select ()
  -> columns ([ ' column1 ' , ' column2 ' ])
  -> column ( ' column3 ' )
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column2 ' , 1 ))  // See "Where Clauses" section above
  -> groupBy ( ' column1 ' )
  -> having (Where:: equals ( ' sum(column2) ' , 5 ))
  -> orderBy ( ' column3 ' , ' ASC ' )
  -> limit ( 10 )
  -> offset ( 5 );

$ sql = $ select -> getSql ();
// $sql:
// SELECT
//     `column1`,
//     `column2`,
//     `column3`
// FROM
//     `table_name`
// WHERE
//     `column2` = :column2___1
// GROUP BY
//     `column1`
// HAVING
//     `sum(column2)` = :sum_column2____1
// ORDER BY
//     `column3` ASC
// LIMIT
//     10
// OFFSET
//     5;

Récupération des résultats :

Par défaut, la méthode fetchAll() renvoie un tableau d'objets (en utilisant PDO::FETCH_OBJ par défaut), où chaque objet représente une ligne de données. Vous pouvez également récupérer les résultats sous forme de tableau de tableaux associatifs en passant la constante PDO::FETCH_ASSOC comme argument à la méthode de création fetchMethod() avant d'exécuter la requête.

 $ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );

// Output: object(FetchResult) {
//     data => array(n) {
//         [0]...
//         [1]...
//         [n-1]...
//     },
//     count => int(n)
// }

Vous pouvez également récupérer le nombre de résultats avec :

 $ countResults = $ select -> fetchCount ();
// Output: 5

Pagination:

La gestion efficace de grands ensembles de données et la fourniture d’une interface conviviale pour la navigation dans les données sont essentielles à toute application robuste. La fonctionnalité de pagination de PHP-DbHandler répond à ces besoins avec élégance. Il simplifie le processus de division de vos données en morceaux gérables, ou « pages », ce qui facilite le travail avec de grands ensembles de données sans surcharger le système ou l'utilisateur.

Configuration de la pagination

Il existe deux manières de configurer la pagination de vos requêtes :

Utilisation de la méthode paginate : Cette méthode vous permet de définir le nombre d'éléments par page de manière concise. C'est un moyen efficace de préparer votre requête pour la pagination.
```
 $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> paginate (itemsPerPage: 10 );
```
Définition manuelle de la limite et du décalage : pour plus de contrôle, vous pouvez spécifier manuellement la limite (nombre d'éléments par page) et le décalage (point de départ dans l'ensemble de données) de votre requête.
```
 $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> limit ( 10 )
  -> offset ( 0 );
```

Récupération des résultats avec la pagination

Une fois la pagination configurée, vous pouvez récupérer les résultats de différentes manières, en naviguant facilement dans votre ensemble de données :

fetchPage(?int $page) : Récupère une page actuelle ou spécifique.
fetchNextPage() : Récupère les résultats de la page suivante.
fetchPreviousPage() : Récupère les résultats de la page précédente.
fetchFirstPage() : Récupère les résultats de la première page.
fetchLastPage() : Récupère les résultats de la dernière page.

Chacune de ces méthodes renvoie un objet FetchPaginatedResult , qui contient les propriétés suivantes :

data : Un tableau des enregistrements sur la page actuelle.
count : Le nombre total d’enregistrements dans l’ensemble de données.
page : Le numéro de la page actuelle.
perPage : Le nombre d'enregistrements par page.
totalPages : Le nombre total de pages.

 // Example output structure of FetchPaginatedResult
object (FetchPaginatedResult) {
    data => array (n) {
        [ 0 ]. . .
        [ 1 ]. . .
        [n- 1 ]. . .
    },
    count => int(n),
    page => int( 10 ),
    perPage => int( 10 ),
    totalPages => int( 23 )
}

Ce système de pagination dans PHP-DbHandler garantit que vous pouvez gérer et naviguer efficacement dans de grands ensembles de données, améliorant ainsi les performances globales et l'expérience utilisateur de votre application.

Mise en cache :

Dans les applications actuelles basées sur les données, l'efficacité et les performances sont essentielles. Pour améliorer ces aspects dans les interactions avec les bases de données, la bibliothèque inclut une fonctionnalité de mise en cache dans ses requêtes Select . Cette fonctionnalité améliore les performances en mettant en cache les résultats des requêtes, réduisant ainsi la charge de la base de données et améliorant les temps de réponse pour les requêtes fréquemment exécutées. Surtout, il est conçu pour être entièrement conforme à la norme PSR-16 (Simple Cache), garantissant une compatibilité et une flexibilité étendues.

Mise en cache conforme PSR-16
La fonctionnalité de mise en cache dans les requêtes Select accepte toute instance de cache qui implémente PsrSimpleCacheCacheInterface. Cette conformité aux normes PSR-16 signifie que vous pouvez intégrer de manière transparente un large éventail de bibliothèques de mise en cache qui adhèrent à cette interface, vous offrant ainsi la flexibilité de choisir la solution de mise en cache la mieux adaptée aux besoins de votre application.

Configuration du cache : si une instance de PsrSimpleCacheCacheInterface est fournie lors de l'initialisation de la classe Db , vous pouvez ignorer cette étape. Si vous ne l'avez pas fait, vous pouvez utiliser la méthode setCache :

 $ select = $ db -> select ()-> setCache ( $ simpleCacheInstance );

Remarques :
Si vous n'avez pas fourni d'instance de cache lors de l'initialisation de la classe Db , vous devez la définir pour chaque requête Select que vous souhaitez mettre en cache.
Vous pouvez également utiliser cette méthode si vous souhaitez définir une instance de cache spécifique pour une requête Select . Cela vous permet d'utiliser différentes solutions de mise en cache pour différentes requêtes, en fonction des besoins de votre application.

Configuration du cache : activez et configurez la mise en cache pour votre requête à l'aide de la méthode withCache . Vous pouvez spécifier une valeur de retour par défaut pour les entrées de cache manquantes et un TTL (Time To Live) pour les données mises en cache.

 $ select -> withCache (defaultValue, ttl);

Remarques :
L'argument defaultValue est facultatif. S'il n'est pas fourni, la bibliothèque renverra NULL pour les entrées de cache manquantes.
L'argument ttl est facultatif. Si elle n'est pas fournie, la bibliothèque utilisera la valeur TTL définie par l'instance PsrSimpleCache.

Gestion automatisée du cache : lors de l'exécution d'une requête avec la mise en cache activée, la bibliothèque vérifie d'abord la présence des résultats mis en cache. S'il est disponible, il est extrait du cache, en ignorant la requête de la base de données. Sinon, il exécute la requête, met en cache le résultat, puis le renvoie.

 $ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );

Avantages clés

Flexibilité : choisissez parmi une variété d’implémentations de mise en cache conformes au PSR-16.
Performances : réduisez la fréquence des requêtes de base de données en utilisant les données mises en cache pour les requêtes répétées.
Facilité d'utilisation : la mise en œuvre de la mise en cache est simple et s'intègre facilement aux structures de requêtes existantes.
Génération de clés de cache fiable : la bibliothèque génère des clés de cache uniques pour chaque requête, garantissant l'exactitude et la pertinence des données mises en cache.

INSÉRER

La classe Insert de la bibliothèque PHP-DbHandler rationalise le processus de création et d'exécution de requêtes d'insertion dans une base de données. Cette classe, dotée de plusieurs traits et interfaces, offre une approche sophistiquée de la gestion des opérations d'insertion avec diverses fonctionnalités avancées.

Génération de requêtes

Affectation de valeurs dynamiques : la classe Insert vous permet d'attribuer dynamiquement des valeurs aux colonnes pour l'insertion. Vous pouvez ajouter une seule valeur ou plusieurs valeurs à la fois :

 $ insert = $ db -> insert ()
  -> into ( ' table_name ' )
  -> value ( ' column1 ' , ' value1 ' )
  -> values ([ ' column2 ' => ' value2 ' , ' column3 ' => ' value3 ' ]);

La classe vérifiera si la colonne existe dans la table avant d'ajouter la valeur, et s'occupera également de la liaison PDO nécessaire.

Insertion de plusieurs lignes : insérez sans effort plusieurs lignes à la fois en fournissant un tableau de valeurs :

 $ rows = [
  [ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ],
  [ ' column1 ' => ' value3 ' , ' column2 ' => ' value4 ' ],
  // ...
];
$ insert -> rows ( $ rows );

Exécution

 $ success = $ insert -> execute ();

Chèques
Avant d'exécuter une opération d'insertion, la classe vérifiera automatiquement :
Si la base de données est en mode lecture seule , cela empêche les opérations d'écriture involontaires.
S'il y a des collisions dans les clés primaires non auto-incrémentées , garantissant l'intégrité des données.

La classe Insert est une solution globale pour gérer les opérations d'insertion dans une base de données, offrant à la fois une facilité d'utilisation et des fonctionnalités avancées pour gérer efficacement les tâches d'insertion complexes.

MISE À JOUR

La classe Update de la bibliothèque PHP-DbHandler fournit un moyen sophistiqué et flexible de construire et d'exécuter des requêtes de mise à jour dans une base de données. Il est conçu pour s'intégrer de manière transparente à la structure de base de données existante tout en offrant des fonctionnalités robustes pour gérer efficacement les opérations de mise à jour.

Génération de requêtes

Définition des valeurs de mise à jour : spécifiez facilement les colonnes à mettre à jour et leurs nouvelles valeurs. La classe garantit que seules les colonnes existantes sont mises à jour, évitant ainsi les erreurs et préservant l'intégrité des données.

 $ update = $ db -> update ()
  -> table ( ' table_name ' )
  -> set ( ' column1 ' , ' newValue1 ' )
  -> set ( ' column2 ' , ' newValue2 ' );
    ```

2. **Conditional Updates**: Incorporate conditions into your update queries using the `where` method. This allows for precise targeting of records to be updated.

``` php
$ update -> where (Where:: equals ( ' column3 ' , ' conditionValue ' ));

Exécution

 $ success = $ update -> execute ();

Vérification du mode lecture seule : avant l'exécution, la classe vérifie si la base de données est en mode lecture seule, empêchant ainsi les opérations d'écriture involontaires.

La classe Update représente une solution complète pour construire et exécuter des opérations de mise à jour dans une base de données. Sa combinaison de flexibilité, de robustesse et de facilité d'utilisation en fait un choix idéal pour gérer les mises à jour de bases de données dans les applications PHP.

SUPPRIMER

La classe Delete de la bibliothèque PHP-DbHandler offre une approche sophistiquée pour construire et exécuter des requêtes de suppression dans des bases de données. Cette classe garantit que les opérations de suppression sont effectuées avec précision et sécurité, en intégrant des contrôles et des fonctionnalités essentielles pour une gestion optimale des requêtes.

Génération de requêtes

La classe permet un ciblage précis des enregistrements à supprimer à l'aide d'expressions conditionnelles. Ceci est réalisé grâce à la méthode where , permettant de sélectionner des lignes spécifiques pour la suppression en fonction des critères donnés.

 $ delete = $ db -> delete ()
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column ' , ' value ' ));

Clause Where obligatoire : Pour éviter la suppression accidentelle de tous les enregistrements d'une table, la classe nécessite qu'une clause WHERE soit spécifiée. Cela sert de protection contre les suppressions massives involontaires.

Exécution

 $ success = $ delete -> execute ();

La classe effectue des vérifications essentielles avant d'exécuter l'opération de suppression, notamment en vérifiant l'existence de la table et en s'assurant que la base de données n'est pas en mode lecture seule.

La classe Delete est conçue pour gérer les opérations de suppression avec un degré élevé de contrôle et de sécurité. Il garantit que les suppressions sont effectuées avec précision, dans le respect de la structure et des contraintes de la base de données. Que vous effectuiez des tâches de suppression simples ou complexes, cette classe fournit les outils nécessaires pour les exécuter de manière fiable et sécurisée.

PROCÉDURES STOCKÉES

La classe StoredProcedure de la bibliothèque PHP-DbHandler offre une approche simplifiée et efficace pour exécuter des procédures stockées dans des bases de données. Cette classe fournit un moyen robuste d'interagir avec les procédures stockées, en gérant facilement la gestion des paramètres, l'exécution et la récupération des résultats.

Génération de requêtes

Configuration des appels de procédures stockées : configurez facilement des appels aux procédures stockées avec une gestion dynamique des paramètres. Spécifiez le nom de la procédure et les paramètres requis.

 $ procedure = $ db -> storedProcedure ()
  -> call ( ' procedure_name ' )
  -> with ( ' paramName ' , $ value )
  // ...
  -> with ( ' paramName2 ' , $ value );

Exécution

 $ results = $ procedure -> execute ();

Vérifications du mode lecture seule : avant l'exécution, la classe vérifie si la base de données est en mode lecture seule, garantissant ainsi que les opérations d'écriture ne sont pas effectuées par inadvertance.

La classe StoredProcedure est un outil indispensable pour gérer les appels de procédures stockées dans les applications PHP. Il simplifie l'interaction avec les procédures stockées, rendant le processus plus intuitif et moins sujet aux erreurs, en particulier dans les applications qui s'appuient fortement sur des opérations de bases de données complexes.

Transactions

La gestion des transactions de base de données est un aspect crucial pour garantir l’intégrité des données, en particulier dans les applications traitant de manipulations de données complexes. PHP-DbHandler simplifie ce processus, offrant un moyen intuitif et simple de gérer les transactions.

Grâce aux fonctionnalités de gestion des transactions fournies, vous pouvez facilement démarrer, valider ou annuler des transactions, vous donnant ainsi un contrôle total sur les opérations de votre base de données. Cela garantit qu'une série d'opérations de base de données peuvent être traitées comme une seule unité atomique, qu'elles soient entièrement ou pas du tout terminées, préservant ainsi la cohérence et la fiabilité de vos données.

 $ db -> transaction -> begin ();
$ db -> transaction -> commit ();
$ db -> transaction -> rollback ();

Cette fonctionnalité est particulièrement utile dans les scénarios dans lesquels plusieurs opérations de base de données associées doivent être exécutées ensemble. Si une opération au sein de la transaction échoue, la méthode de restauration peut être utilisée pour annuler toutes les modifications apportées depuis le début de la transaction, empêchant ainsi les mises à jour partielles pouvant entraîner des incohérences de données. À l’inverse, si toutes les opérations réussissent, la méthode commit enregistrera toutes les modifications apportées à la base de données.

En utilisant ces contrôles de transaction, PHP-DbHandler garantit que la gestion des données de votre application est robuste, cohérente et résistante aux erreurs. Que vous ayez affaire à des saisies de données complexes, des mises à jour ou des processus par lots, ces capacités transactionnelles fournissent les outils nécessaires pour gérer efficacement les opérations de votre base de données.

Gestion des transactions globales

La classe Transaction introduit également une fonctionnalité puissante pour gérer des scénarios de transactions complexes. Cette fonctionnalité vous permet de contrôler globalement les validations de transactions, ce qui est particulièrement utile lorsque vous souhaitez englober plusieurs méthodes qui utilisent des transactions dans un contexte transactionnel unique et global.

Gérer les transactions à l'échelle mondiale

Vous pouvez gérer plusieurs opérations transactionnelles dans le cadre d'une transaction plus importante en désactivant les validations automatiques. Ceci est particulièrement utile dans les scénarios où plusieurs opérations, chacune capable de gérer des transactions de manière indépendante, doivent être exécutées dans le cadre d'une seule transaction atomique.

 // Begin a transaction
$ db -> transaction -> begin ();

// Disable automatic commits
$ db -> transaction -> setCommitsModeOff ();

// Execute other methods that use transactions
// $db->transaction->begin();
// ...
// $db->transaction->commit();

// Re-enable automatic commits
$ db -> transaction -> setCommitsModeOn ();

// Commit the transaction
$ db -> transaction -> commit ();

Cette fonctionnalité améliore le contrôle des opérations transactionnelles, permettant des scénarios de manipulation de données plus complexes et plus fiables. Il garantit que toutes les modifications apportées dans le cadre de la transaction globale sont soit validées ensemble, soit annulées, préservant ainsi l'intégrité et la cohérence des données.

Contribuer

Nous apprécions grandement et apprécions les contributions au projet ! Si vous souhaitez contribuer, veuillez lire notre fichier CONTRIBUTING.md pour obtenir des informations détaillées sur la façon de commencer, des directives pour soumettre des contributions et des conseils pour rendre le processus aussi simple et efficace que possible.

Qu'il s'agisse de corriger un bug, d'ajouter une fonctionnalité ou d'améliorer la documentation, vos contributions sont grandement appréciées et ont un impact significatif sur le projet.

Questions et discussions

Si vous avez des questions ou souhaitez discuter d'idées avant de coder, n'hésitez pas à ouvrir un problème sur notre page Problèmes GitHub pour en discuter.

Nous apprécions votre volonté de contribuer et attendons avec impatience vos soumissions !

Licence

Cette bibliothèque est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

Soutien

Pour obtenir de l'aide, veuillez visiter la page des problèmes sur le référentiel GitHub : Problèmes GitHub

Développer

php dbhandler

PHP-DbHandler

Contenu

Caractéristiques

Installation

Installation

Créer des clauses `Where` et `Having`

Opérateurs de comparaison

Opérateurs logiques

`or` et `and` opérateurs

Création et exécution de requêtes

SÉLECTIONNER

INSÉRER

MISE À JOUR

SUPPRIMER

PROCÉDURES STOCKÉES

Transactions

Gestion des transactions globales

Contribuer

Questions et discussions

Licence

Soutien

stripe php

PHPCsv

QCMS PHP

QCMS PHP

QCMS PHP

QCMS PHP

chat.petals.dev

GPT Prompt Templates

GPTyped

wp functions

termwind

slugify

waymo open dataset

wp functions

termwind

php dbhandler

PHP-DbHandler

Contenu

Caractéristiques

Installation

Installation

Créer des clauses Where et Having

Opérateurs de comparaison

Opérateurs logiques

or et and opérateurs

Création et exécution de requêtes

SÉLECTIONNER

INSÉRER

MISE À JOUR

SUPPRIMER

PROCÉDURES STOCKÉES

Transactions

Gestion des transactions globales

Contribuer

Questions et discussions

Licence

Soutien

Créer des clauses `Where` et `Having`

`or` et `and` opérateurs