PHP met en œuvre la conversion des conditions de filtrage Devextreme en clause MySQL où

Cet article détaille comment utiliser PHP pour convertir le tableau des conditions de filtrage NOSQL généré par le cadre frontal devextreme en toute sécurité et efficacement en clause où la base de données MySQL. L'article fournit des solutions de mise en œuvre pour deux extensions de base de données, notamment la génération d'instructions SQL avec des espaces réservées de paramètres et l'extraction des valeurs de paramètres correspondantes, visant à aider les développeurs à créer une interface de requête de données robuste.

Dans le développement d'applications Web moderne, les cadres frontaux tels que DevexTreme définissent souvent les conditions de filtrage des données sous forme de tableau structuré. Ce format est similaire à la syntaxe de requête NOSQL, mais les bases de données back-end sont généralement des bases de données relationnelles telles que MySQL. Convertir dynamiquement les conditions de filtrage frontal en SQL exécutable back-end où la clause est un lien clé pour créer une interface de données flexible.

Considérez la structure de la table MySQL suivante:

item_id	Stockno	Sizecd
1	12003	UNITÉ
2	12007	Jogo
3	12008	Pacote
4	12033	Jogo
5	12034	Jogo
6	12038	UNITÉ

Le cadre frontal devextreme peut envoyer le corps de demande de filtre suivant:

 {
  "From": "get_data",
  "Skip": 0,
  "Take": 50,
  "BesoinTotalCount": vrai,
  "filtre": [["sizecd", "=", "unit"], "ou", ["sizecd", "=", "jogo"]]
}

Où, le champ de filtre est un tableau qui définit les conditions de la requête. Notre objectif est de convertir ce tableau en une clause WHERE qui est conforme à la syntaxe MySQL, par exemple: whereSizecd = 'unit' orsizecd = 'jogo'. Pendant le processus de conversion, une attention particulière doit être accordée au nom du champ sans devis, tandis que la valeur de la chaîne doit être citée et s'assurer que l'injection SQL est empêchée.

Convertir avec PDO

L'utilisation de PDO (PHP Data Objectts) est le moyen recommandé de se connecter aux bases de données par PHP car il prend en charge les instructions de prétraitement et peut effectivement empêcher les attaques d'injection SQL. Nous devons écrire deux fonctions d'assistance: l'une pour générer des chaînes de requête SQL avec les espaces réservées des paramètres, et l'autre pour extraire les valeurs de ces paramètres du tableau filtré.

Supposons que nous ayons le tableau filtré de style Devextreme suivant:

 $ filterArray = [["sizecd", "=", "unité"], "ou", ["sizecd", "=", "jogo"], "ou", ["sizecd", "=", "pacote"]];

1. Générer une chaîne de requête SQL avec des espaces réservés des paramètres

La fonction ArraytoQuery est responsable de la traversée du tableau filtré et de la construction d'une clause SQL contenant un espace réservé d'interrogation (?).

 / **
 * Convertir les tableaux filtrés de style Devextreme en SQL où des clauses avec des espaces réservés.
 *
 * @param String $ Nom de la table TableName.
 * @param array $ filterArray Filter Condition Tableau.
 * @return String La chaîne de requête SQL générée.
 * /
fonction arraytoquery (chaîne $ tableName, array $ filterArray): chaîne 
{
    $ select = "select * from` {$ tablename} `où";

    foreach ($ filterArray comme $ item) {
        if (is_array ($ item)) {
            // gérer des conditions telles que ["sizecd", "=", "unit"] // Les noms de champ sont enfermés en backticks pour éviter les conflits avec les mots clés SQL $ SELECT. = "` {$ Item [0]} `{$ item [1]}?"; 
        } autre {
            // traite l'opérateur logique $ select. = "{$ Item}";
        }
    }

    retour $ select;
}

2. Extraire le tableau de valeur des paramètres

La fonction ArrayToparams est utilisée pour extraire toutes les valeurs qui doivent être liées aux requêtes SQL à partir d'un tableau filtré. Ces valeurs seront utilisées comme paramètres de l'instruction de prétraitement.

 / **
 * Extraire toutes les valeurs des paramètres à partir d'un tableau filtré de style Devextreme.
 *
 * @param array $ filterArray Filter Condition Tableau.
 * Tableau de valeur des paramètres extraits @return.
 * /
fonction arraytoparams (array $ filterArray): array  
{
    $ return = [];
    foreach ($ filterArray comme $ item) {
        if (is_array ($ item)) {
            // Extraire le troisième élément du tableau conditionnel en tant que valeur de paramètre $ return [] = $ item [2];
        }
    }
    retour $ return;
}

Exemple d'utilisation de l'APD

En combinant ces deux fonctions, nous pouvons construire et exécuter des requêtes PDO sécurisées:

 // Array de filtre supposé $ filterArray = [["sizecd", "=", "unit"], "ou", ["sizecd", "=", "jogo"], "ou", ["sizecd", "=", "pacote"]];

// Exemple de sortie var_dump (
    arraytoquery ("your_table_name", $ filterArray),
    Arraytoparams ($ filterArray)
));

/ *
Résultat de sortie:
String (66) "SELECT * From` your_table_name` où `sizecd` =? ou` sizecd` =? ou `sizecd` =?"
Array (3) {
  [0] =>
  chaîne (4) "unité"
  [1] =>
  String (4) "Jogo"
  [2] =>
  String (6) "Pacote"
}
* /

// Opération de base de données PDO réelle try {
    // Supposons que $ conn est un objet de connexion PDO établi $ dsn = 'mysql: host = localhost; dbname = testdb; charset = utf8';
    $ username = 'root';
    $ mot de passe = 'mot de passe';
    $ Conn = new PDO ($ dsn, $ username, $ mot de passe);
    $ Conn-> setAttribute (PDO :: att_errMode, PDO :: errMode_Exception);

    $ tableName = "your_table_name"; // Remplacez par le nom de votre table $ SQL = ArraytoQuery ($ TableName, $ filterArray);
    $ params = arraytoparams ($ filterArray);

    $ stmt = $ con-> prépare ($ sql);
    $ stmt-> Execute ($ params);

    $ results = $ stmt-> fetchall (PDO :: fetch_assoc);
    print_r ($ résultats);

} catch (pDoException $ e) {
    ECHO "Erreur de base de données:". $ e-> getMessage ();
}

Convertir avec MySQLI (non-processus)

Si le projet utilise toujours des extensions MySQLI et n'est pas pratique pour utiliser des instructions de prétraitement (bien que fortement recommandées), vous devez échapper manuellement les valeurs lors de la construction de chaînes SQL pour éviter l'injection SQL.

 / **
 * Convertir les tableaux filtrés de style Devextreme en clause SQL de style mysqli-sql.
 * Remarque: Cette méthode intègre directement la valeur dans SQL et doit être échappée à l'aide de MySQLI_REAL_ESCAPE_STRING pour empêcher l'injection SQL.
 * 
 * @param mysqli $ mysqli MySqli Connection Object.
 * @param String $ Nom de la table de table.
 * @param array $ filterArray Filter Condition Tableau.
 * @return String La chaîne de requête SQL générée.
 * /
fonction arraytoquerymysqli ($ mysqli, chaîne $ table, array $ filterArray): chaîne 
{
    $ select = "SELECT * FROM` {$ Table} `Where";
    foreach ($ filterArray comme $ item) {
        if (is_array ($ item)) {
            // Échappez la valeur et enfermez-le en devis uniques $ EscapEdValue = $ mysqli-> real_escape_string ($ item [2]);
            $ select. = "` {$ item [0]} `{$ item [1]} '". $ EscapedValue. "'";
        } autre {
            $ select. = "{$ item}";
        }
    }
    retour $ select;
}

// Exemple d'utilisation de MySQLI // Supposons $ mysqli est un objet de connexion MySQLI établi $ mysqli = new mysqli ("localhost", "root", "mot de passe", "testdb");

if ($ mysqli-> connect_error) {
    Die ("La connexion a échoué:". $ mysqli-> connect_error);
}

$ filterArray = [["sizecd", "=", "unité"], "ou", ["sizecd", "=", "jogo"], "ou", ["sizecd", "=", "pacote"]];
$ tableName = "your_table_name"; // Remplacez par le nom de votre table $ query = arraytoQueryMysqli ($ mysqli, $ tableName, $ filterArray);
Echo "généré SQL:". $ Query. "\ n";

$ result = $ mysqli-> requête ($ query);

if ($ result) {
    while ($ row = $ result-> fetch_assoc ()) {
        print_r ($ row);
    }
    $ result-> gratuit ();
} autre {
    Echo "La requête a échoué:". $ mysqli-> erreur;
}

$ mysqli-> close ();

Notes et résumé

1. Sécurité :
   • Les déclarations de prétraitement pour l'APD sont fortement recommandées . C'est le moyen le plus efficace de se défendre contre l'injection SQL en séparant la logique SQL des données. Les combinaisons ArraytoQuery et Arraytoparams sont conçues pour le prétraitement de l'APD.
   • Si vous devez utiliser MySQLI et n'utilisez pas de prétraitement, assurez-vous d'utiliser la fonction mysqli_real_escape_string () pour échapper à toutes les valeurs d'entrée utilisateur pour empêcher les caractères malveillants de la corruption de la structure de l'instruction SQL.
2. Nom de champ Référence : Dans le SQL généré, les noms de champ (tels que SIZECD) sont enfermés en backticks (`). C'est une bonne pratique pour éviter les conflits entre les noms de champ et les mots clés SQL.
3. Flexibilité et évolutivité :
   • L'implémentation actuelle convient aux chaînes simples et / ou conditionnelles. Pour un filtrage imbriqué plus complexe (par exemple (et b) ou c), une logique d'analyse plus avancée, telle que des fonctions récursives, peut être nécessaire pour gérer les tableaux imbriqués.
   • Si davantage d'opérateurs doivent être pris en charge (comme comme, dans, entre), vous devez étendre la logique de la fonction ArraytoQuery pour reconnaître et traiter correctement ces opérateurs et leur syntaxe SQL correspondante.
4. Gestion des erreurs : Dans les applications pratiques, les mécanismes de gestion des erreurs appropriés doivent toujours être inclus, tels que les exceptions de gestion de la gestion des blocs de couple d'essai, ou la vérification des résultats de la requête MySQLI.
5. Performances : la génération de chaînes SQL peut avoir une légère surcharge de performances pour des conditions de filtrage très complexes. Mais pour la plupart des scénarios d'application, cette surcharge est négligeable.

Grâce aux fonctions PHP ci-dessus, les développeurs peuvent convertir efficacement et en toute sécurité les conditions de filtrage du NOSQL des cadres frontaux tels que Devextreme en clause MySQL, réalisant ainsi un lien transparent entre les interactions de données frontal et back-end.

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!