Page d'accueil>Code source PHP>Autres catégories
Télécharger

QuéBEE: un constructeur de requête PHP SQL 

            ███████╗ ██╗   ██╗███████╗                               ...vvvv)))))).
            ██╔═══██╗██║   ██║██╔════╝    /~~               ,,,c(((((((((((((((((/
            ██║██╗██║██║   ██║█████╗     /~~c .         .vv)))))))))))))))))))``
            ███████╔╝██║   ██║██╔══╝         G_G__   ,,(((KKKK//////////////'
             ╚═██╔═╝ ╚██████╔╝███████╗     ,Z~__ '@,gW@@AKXX~MW,gmmmz==m_.
               ╚═╝    ╚═════╝ ╚══════╝    iP,dW@!,A@@@@@@@@@@@@@@@A` ,W@@Ac
            ██████╗ ███████╗███████╗       ]b_.__zf !P~@@@@@*P~b.~+=m@@@*~ g@Ws.
            ██╔══██╗██╔════╝██╔════╝          ~`    ,2W2m. '[ ['~~c'M7 _gW@@A`'s
            ██████╦╝█████╗  █████╗              v=XX)====Y-  [ [    c/*@@@*~ g@@i
            ██╔══██╗██╔══╝  ██╔══╝             /v~           !.!.     'c7+sg@@@@@s.
            ██████╦╝███████╗███████╗          //              'c'c       'c7*X7~~~~
            ╚═════╝ ╚══════╝╚══════╝         ]/                 ~=Xm_       '~=(Gm_.

Introduction

Le package Qᴜᴇᴇbᴇᴇ (QB) ou Builder de requête est un package léger pour la construction de requêtes MySQL. Il s'agit d'un package PHP qui simplifie la construction de requêtes SQL. Il fournit une approche orientée objet pour construire des requêtes SQL, ce qui facilite la création, la modification et l'exécution d'instructions SQL dans vos applications PHP.

Installation

1. Compositeur

Québelle peut être installé via Composer, un gestionnaire de dépendances PHP. Si vous n'avez pas encore installé Composer, visitez le site Web du compositeur pour des instructions.

Exécutez la commande suivante pour installer le QuéBEE: 

composer require hindbiswas/quebee

2. Autochaterie

Assurez-vous que l'autoloader du compositeur est inclus dans les fichiers PHP de votre projet. Utilisez votre chemin à la place du path/to/ : 

 require_once __DIR__ . DIRECTORY_SEPARATOR . ' path/to ' . ' /vendor/autoload.php ' ;

Caractéristiques

Québee fournit des fonctionnalités suivantes pour travailler avec MySQL:

  1. Requêtes: classe Query pour SELECT , INSERT , UPDATE et DELETE les requêtes.
  2. Tableau: classe Table pour CREATE TABLE avec une classe Col pour les colonnes.
  3. Colonnes: Col Class a un tas de données comme INT , VARCHAR , DATETIME et bien d'autres pour créer des colonnes selon vos exigences.
  4. Déclarations: Classe Stmt pour UNION , UNION ALL , CUBE , SET et GROUPING SETS CONDUTATIONS.

Il comprend également des contraintes de clés étrangères, une clé primaire unique et une indexation ainsi que le regroupement. Voir le répertoire /tests/ pour toutes les façons possibles d'utiliser le QueBee ;

Usage

Vous trouverez ci-dessous des exemples d'utilisation de chaque constructeur de requêtes.

1. Sélectionnez la requête

Pour créer une requête SELECT , utilisez la méthode Query::select() : 

 use Hindbiswas  QueBee  Query ;

$ aliased_cols = [ ' alias1 ' => ' column1 ' , ' alias2 ' => ' column2 ' , ' column3 ' => ' column3 ' ];
$ query = Query:: select ( $ aliased_cols )-> from ( ' table ' )-> build ();

// Resulting SQL query
// SELECT column1 AS alias1, column2 AS alias2, column3 AS column3 FROM table;

Ou, 

 use Hindbiswas  QueBee  Query ;

$ query = Query:: select ([ ' column1 ' , ' column2 ' ])
    -> from ( ' table ' )
    -> where ( ' column1 ' , ' value ' )
    -> orderBy ( ' column2 ' , ' desc ' )
    -> limit ( 10 )
    -> build ();

// Resulting SQL query
// SELECT column1, column2 FROM table WHERE column1 = 'value' ORDER BY column2 DESC LIMIT 0, 10;

Alias ​​de condition pour les déclarations conditionnelles

SQL Littéral Symbolique
> gt >
>= gte >=
< lt <
<= lte <=
= eq == ou =
!= ne != ou <>
<=> ns <=>
LIKE like ??

Vous pouvez utiliser littéral ou symbolique.

2. Insérer des requêtes

Pour créer une requête INSERT , utilisez la méthode Query::insert() (Pour insérer plusieurs lignes à la fois, utilisez la méthode Query::insertMultiple() ): 

 use Hindbiswas  QueBee  Query ;

$ data = [ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ];

$ query = Query:: insert ( $ data )
    -> into ( ' table ' )
    -> build ();

// Resulting SQL query
// INSERT INTO table (column1, column2) VALUES ('value1', 'value2');

3. Mettre à jour les requêtes

Pour créer une requête UPDATE , utilisez la méthode Query::update() : 

 use Hindbiswas  QueBee  Query ;

$ data = [ ' column1 ' => ' new_value1 ' , ' column2 ' => ' new_value2 ' ];

$ query = Query:: update ( ' table ' )
    -> set ( $ data )
    -> where ( ' column1 ' , ' value1 ' )
    -> build ();

// Resulting SQL query
// UPDATE table SET column1 = 'new_value1', column2 = 'new_value2' WHERE column1 = 'value1';

4. Supprimer les requêtes

Pour créer une requête DELETE , utilisez la méthode Query::delete() : 

 $ query = Query:: delete ( ' table ' )-> where ( ' column1 ' , 1 , ' gt ' )-> build () // Here `gt` is alias for `>`

// Resulting SQL query
// DELETE FROM table WHERE column1 > '1';

5. Créer des requêtes de table

Pour créer une requête CREATE TABLE , utilisez la méthode Table::create() :

Sans aucune clé étrangère 

 use Hindbiswas  QueBee  Col ;
use Hindbiswas  QueBee  Table ;
use Hindbiswas  QueBee  Table  Values  DefaultVal ;

$ usersTable = Table:: create ( ' users ' )-> columns ([
    ' id ' => Col:: integer ( 11 )-> unsigned ()-> pk ()-> ai (),
    ' username ' => Col:: varchar ()-> unique (),
    ' email ' => Col:: varchar ()-> unique (),
    ' password ' => Col:: varchar (),
    ' is_superadmin ' => Col:: integer ( 2 )-> default ( ' 0 ' ),
    ' create_time ' => Col:: dateTime ()-> default (DefaultVal:: CURRENT_TIME ),
    ' update_time ' => Col:: dateTime ()-> setOnUpdate ()-> default (DefaultVal:: CURRENT_TIME ),
]);

$ query = $ usersTable -> build ();

// Resulting SQL query
// CREATE TABLE IF NOT EXISTS users (`id` INT(11) UNSIGNED NULL AUTO_INCREMENT, `username` VARCHAR(255) NOT NULL, `email` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `is_superadmin` INT(2) NOT NULL DEFAULT '0', `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, `update_time` DATETIME on update CURRENT_TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, CONSTRAINT users_PK PRIMARY KEY (id), CONSTRAINT username_UC UNIQUE (`username`), CONSTRAINT email_UC UNIQUE (`email`)) ENGINE = InnoDB;

Avec des clés étrangères 

 use Hindbiswas  QueBee  Col ;
use Hindbiswas  QueBee  Table ;
use Hindbiswas  QueBee  Table  Values  DefaultVal ;
use Hindbiswas  QueBee  Table  Values  FK ;

// $usersTable = create a table to constrain with

$ table = Table:: create ( ' tokens ' )-> columns ([
    ' id ' => Col:: integer ()-> unsigned ()-> pk ()-> ai (),
    ' selector ' => Col:: varchar (),
    ' hashed_validator ' => Col:: varchar (),
    ' user_id ' => Col:: integer ( 11 )-> unsigned (),
    ' expiry ' => Col:: dateTime (),
])-> foreign ( ' user_id ' )-> onDelete ( FK :: CASCADE )-> reference ( $ usersTable , ' id ' );

// Resulting SQL query
// CREATE TABLE IF NOT EXISTS tokens (`id` INT UNSIGNED NULL AUTO_INCREMENT, `selector` VARCHAR(255) NOT NULL, `hashed_validator` VARCHAR(255) NOT NULL, `user_id` INT(11) UNSIGNED NOT NULL, `expiry` DATETIME NOT NULL, CONSTRAINT tokens_PK PRIMARY KEY (id), FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE) ENGINE = InnoDB;

Types de données disponibles à v1.2.0

  • Chaîne
    • Text => Col::text()
    • Varchar => Col::varchar(225)
  • Numérique
    • Bit => Col::bit()
    • Int => Col::integer()
    • Bigint => Col::bigInt()
    • MIDEDINT => Col::mediumInt()
    • SmallInt => Col::smallInt()
    • Tinyint => Col::tinyInt()
    • Décimal => Col::decimal(11, 6)
    • Float => Col::float(6, 2)
    • Double => Col::double(11, 6)
    • Réel => Col::real(11, 6)
  • Temps
    • Date => Col::date()
    • DateTime => Col::dateTime()

Meilleures pratiques

Voici quelques meilleures pratiques lorsque vous utilisez le Québée :

  1. Désinfecter les entrées des utilisateurs: toujours désinfecter les entrées des utilisateurs avant de les utiliser dans les requêtes.

  2. Gestion des erreurs: gérez les exceptions de manière appropriée, en particulier lors de la construction de requêtes. Québelle peut lancer des exceptions pour les appels ou les appels de méthode non valides.

  3. Abstraction de la base de données: envisagez d'utiliser une couche d'abstraction de base de données aux côtés de Québee pour des interactions de base de données plus étendues.

  4. Organisation de code: organisez votre code logiquement, en séparant le renforcement des requêtes de l'exécution et de la gestion des résultats.

Conclusion

Québee simplifie la construction de requêtes SQL en PHP, ce qui facilite la construction d'interactions de base de données propres, sécurisées et efficaces. Avec son API courante, il fournit un moyen convivial de créer des requêtes SQL pour divers systèmes de base de données.

Pour des options d'utilisation et de personnalisation plus détaillées, reportez-vous au référentiel GitHub Québée.

C'est ça! Vous êtes prêt à commencer à utiliser le Québee pour construire des requêtes SQL dans vos applications PHP.

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout