Assistant de base de données GreenPig

1. Entrée
2. Connexion à la bibliothèque
3. Où classe
   
   • Partie atomique de la demande
   • Requêtes compliquées
4. Rejoignez la classe
5. Requête de classe
   
   • Sélection à partir d'une base de données avec des paramètres imbriqués
   • Union multiple avec vous-même au nom de la recherche

╔═══╗╔═══╗╔═══╗╔═══╗╔╗─╔╗────╔═══╗╔══╗╔═══╗ ║╔══╝║╔═╗║║╔══╝║╔══╝║╚═╝║────║╔═╗║╚╗╔╝║╔══╝ ║║╔═╗║╚═╝║║╚══╗║╚══╗║╔╗─║────║╚═╝║─║║─║║╔═╗ ║║╚╗║║╔╗╔╝║╔══╝║╔══╝║║╚╗║────║╔══╝─║║─║║╚╗║ ║╚═╝║║║║║─║╚══╗║╚══╗║║─║║────║║───╔╝╚╗║╚═╝║ ╚═══╝╚╝╚╝─╚═══╝╚═══╝╚╝─╚╝────╚╝───╚══╝╚═══╝ 5HHHG HH HHHHHHH 9HHHA HHHHHHHH5 HHHHHHHHHHHHHHHHHH 9HHHHH5 5HHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHH ;HHHHHHHHHHHHHHHHHHHHHHHHHHA H2 HHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHH9 HHHHHHHHHHHHHHHHHHHHHHH AHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHH9 iHS HHHHHHHHHHHHHHHHHHHHHHhh HHHHHHHHHHHHHHHHHH AA HHHHHHHHHHHHHH3 &H Hi HS Hr & H& H& Hi 

Entrée

Je veux vous parler du développement de ma petite bibliothèque en php. Quelles tâches résout-elle? Pourquoi ai-je décidé de l'écrire et pourquoi pourrait-il vous être utile? Essayez bien de répondre à ces questions.

GreenPig (ci-après GP ) est un petit assistant de base de données qui peut compléter les fonctionnalités de n'importe quel framework php que vous utilisez.

Comme tout outil GP , il est affiné pour résoudre certains problèmes. Il vous sera utile si vous préférez écrire des requêtes de base de données en SQL pur et que vous n'utilisez pas Active record et d'autres technologies similaires. Par exemple, nous avons une base de données Oracle au travail et souvent les requêtes occupent plusieurs écrans avec des dizaines de jointures, les fonctions plsql, union all, etc. sont toujours utilisées. etc., donc il ne reste plus qu'à écrire des requêtes en SQL pur.

Mais avec cette approche, la question se pose: comment générer où la partie de la requête SQL lorsque les utilisateurs recherchent des informations? GP vise, tout d'abord, une compilation pratique au moyen de php où d'une demande de toute complexité.

Mais qu'est-ce qui m'a poussé à écrire cette bibliothèque (sauf, bien sûr, pour acquérir une expérience intéressante)? Ce sont trois choses:

Premièrement, la nécessité d'obtenir non pas une réponse plate standard de la base de données, mais un tableau imbriqué semblable à un arbre.

 [ [0] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [1] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [2] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ], [3] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [4] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [5] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [6] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [7] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [8] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [9] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [10] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [11] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [12] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [13] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [14] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ], [15] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [16] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [17] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ] ] 

Pour obtenir un tableau arborescent, nous devons soit apporter le résultat à la forme souhaitée nous-mêmes, soit effectuer N requêtes de base de données pour chaque produit. Et si nous avons besoin de pagination, et même de tri? GP est capable de résoudre ces problèmes. Voici un exemple d'échantillon avec GP :

 [ [1] => [ ['prod_type'] => 'car' ['properties'] => [ [1] => [ ['name'] => ' ()' ['value'] => 790 ] [2] => [ ['name'] => '   ' ['value'] => 24 ] [3] => [ ['name'] => ' ' ['value'] => 75 ] ] ] [4] => [ ['prod_type'] => 'phone' ['properties'] => [ [10] => [ ['name'] => ' ' ['value'] => 5 ] [8] => [ ['name'] => ' ()' ['value'] => 0.12 ] [9] => [ ['name'] => '   ' ['value'] => 1 ] ] ] ] 

Et bien sûr, en même temps, une pagination et un tri pratiques: ->pagination(1, 10)->sort('id') .

La deuxième raison n'est pas si fréquente, mais néanmoins elle se produit (et dans mon cas, c'est la raison principale). Si certaines entités sont stockées dans la base de données et que les propriétés de ces entités sont dynamiques et définies par les utilisateurs, alors lorsque vous devez rechercher des entités par leurs propriétés, vous devrez ajouter (joindre) la même table avec les valeurs de propriété (autant de fois qu'elles sont utilisées). propriétés lors de la recherche). Le GP vous aidera donc à connecter toutes les tables et à générer la requête where avec presque une fonction. Vers la fin de l'article, j'analyserai ce cas en détail.

Et enfin, tout cela devrait fonctionner à la fois pour la base de données Oracle et pour mySql. Il existe également un certain nombre de fonctionnalités décrites dans la documentation.

Il est possible que j'aie inventé un autre vélo, mais j'ai consciencieusement cherché et je n'ai pas trouvé de solution qui me convienne. Si vous connaissez une bibliothèque qui résout ces problèmes - veuillez écrire dans les commentaires.

Avant de passer directement à un examen de la bibliothèque elle-même et à des exemples, je dirai qu'il n'y aura que l'essentiel, sans explications détaillées. Si vous vous intéressez au fonctionnement du GP , vous pouvez consulter la documentation , j'ai essayé de tout expliquer en détail.

Connexion à la bibliothèque

La bibliothèque peut être installée via le compositeur: le composer require falbin/green-pig-dao

Ensuite, vous devez écrire une usine à travers laquelle vous utiliserez cette bibliothèque.

Où classe

En utilisant cette classe, vous pouvez composer la partie where de la requête sql de n'importe quelle complexité.

Partie atomique de la demande

Considérez la plus petite partie atomique d'une requête. Il est décrit par un tableau: [, , ]
Exemple: ['name', 'like', '%%']

• Le premier élément du tableau est juste une chaîne, insérée dans la requête sql sans modifications, et, par conséquent, vous pouvez y écrire des fonctions sql. Exemple: ['LOWER(name)', 'like', '%%']
• Le deuxième élément est également une chaîne insérée dans sql sans changement entre deux opérandes. Il peut prendre les valeurs suivantes: =,>, <,> =, <=, <>, comme, pas comme, entre, pas entre, dans, pas dans .
• Le troisième élément du tableau peut être de type numérique ou chaîne. Où la classe remplacera automatiquement l'alias généré dans la requête SQL.
• Élément de tableau avec clé sql. Parfois, il est nécessaire que la valeur soit insérée dans le code SQL sans modifications. Par exemple, pour appliquer des fonctions. Ceci peut être réalisé en spécifiant 'sql' comme clé (pour le 3ème élément). Exemple: ['LOWER(name)', 'like', 'sql' => "LOWER('$name')"]
• Un élément de tableau avec la clé de liaison est un tableau pour stocker des liaisons. L'exemple ci-dessus est faux du point de vue de la sécurité. Vous ne pouvez pas insérer de variables dans SQL - c'est trop d'injection. Par conséquent, dans ce cas, vous devrez spécifier vous-même des alias, par exemple comme ceci: ['LOWER(name)', 'like', 'sql' => "LOWER(:name)", 'bind'=> ['name' => $name] ]
• L'opérateur in peut s'écrire comme ceci: ['curse', 'not in', [1, 3, 5]] . La classe Where convertit une telle entrée dans le code SQL suivant: curse not in (:al_where_jCgWfr95kh, :al_where_mCqefr95kh, :al_where_jCfgfr9Gkh)
• L'instruction entre peut être écrite comme ceci: ['curse', ' between', 1, 5] . La classe Where convertit une telle entrée dans le code SQL suivant: curse between :al_where_Pi4CRr4xNn and :al_where_WiPPS4NKiG
  Mais attention, si les troisième et quatrième éléments du tableau sont des chaînes, une logique spéciale est appliquée. Dans ce cas, on pense que la sélection est à partir d'une plage de dates et, par conséquent, la fonction sql de transtyper une chaîne en une date est utilisée. La fonction de conversion en une date (mySql et Oracle en ont différentes) et ses paramètres sont tirés d'un tableau de paramètres (plus dans la documentation). Le tableau ['build_date', 'between', '01.01.2016', '01.01.2019'] sera converti en sql: build_date between TO_DATE(:al_where_fkD7nZg5lU, 'dd.mm.yyyy hh24:mi::ss') and TO_DATE(:al_where_LdyVRznPF8, 'dd.mm.yyyy hh24:mi::ss')

Requêtes compliquées

Créons une instance de la classe via la fabrique: $wh = GP::where();

Pour indiquer la connexion logique entre les "parties atomiques" de la demande, vous devez utiliser les fonctions linkAnd() ou linkOr() . Un exemple:

 // sql: (old > 18 and old < 50) $wh->linkAnd([ ['old', '<', 18], ['old', '>', 50] ]); // sql: (old < 18 or old > 50) $wh->linkOr([ ['old', '<', 18], ['old', '>', 50] ]); 

Lorsque vous utilisez les fonctions linkAnd / linkOr, toutes les données sont stockées dans une instance de la classe Where - $ wh. De plus, toutes les «parties atomiques» indiquées dans la fonction sont entre crochets .

Un SQL de toute complexité peut être décrit par trois fonctions: linkAnd(), linkOr(), getRaw() . Prenons un exemple:

 // sql: curse = 1 and (old < 18 or old > 50) $wh->linkAnd([ ['curse', '=', 1], $wh->linkOr([ ['old', '<', 18], ['old', '>', 50] ])->getRaw() ]); 

La classe Where a une variable privée qui stocke l'expression brute. Les linkAnd() et linkOr() cette variable, par conséquent, lors de la construction d'une expression logique, les méthodes sont imbriquées ensemble et la variable avec l'expression brute contient des données obtenues à partir de la dernière méthode exécutée.

Rejoindre la classe

Join est une classe qui génère un fragment de jointure de code SQL. Créons une instance de la classe via l'usine: $jn = GP::leftJoin('coursework', 'student_id', 's.id') , où:

• les cours sont la table que nous allons rejoindre.
• student_id - une colonne avec une clé étrangère de la table des cours .
• s.id - la colonne de la table avec laquelle join doit être écrite avec l'alias de la table (dans ce cas, l'alias de la table est s).

SQL généré: left JOIN coursework coursework_joM9YuTTfW ON coursework_joM9YuTTfW.student_id = s.id

Lors de la création d'une instance de la classe, nous avons déjà décrit la condition pour joindre des tables, mais il peut être nécessaire de clarifier et d'étendre la condition. Les fonctions linkAnd / linkOr vous aideront à faire ceci: $jn->linkAnd(['semester_number', '>', 2])

SQL généré: inner JOIN coursework coursework_Nd1n5T7c0r ON coursework_Nd1n5T7c0r.student_id = s.id and (semester_number > :al_where_M1kEcHzZyy)

S'il y a plusieurs tables à joindre, vous pouvez les combiner dans une classe: CollectionJoin .

Requête de classe

C'est la classe principale pour travailler avec la base de données, à travers elle il y a une sélection, un enregistrement, une mise à jour et une suppression des données. Vous pouvez également effectuer certains traitements de données obtenues à partir de la base de données.

Prenons un exemple typique.

Créons une instance de la classe via la fabrique: $qr = GP::query();

Maintenant, nous allons définir le modèle sql, remplacer les valeurs nécessaires pour le scénario donné dans le modèle sql et dire que nous voulons obtenir un enregistrement, et en particulier les données de la colonne average_mark .

 $rez = $qr->sql("select /*select*/ from student s inner join mark m on s.id = m.student_id inner join lesson l on l.id = m.lesson_id /*where*/ /*group*/") ->sqlPart('/*select*/', 's.name, avg(m.mark) average_mark', []) ->whereAnd('/*where*/', ['s.id', '=', 1]) ->sqlPart('/*group*/', 'group by s.name', []) ->one('average_mark'); 

Résultat: 3,16666666666666666666666666666666666667

Sélection à partir d'une base de données avec des paramètres imbriqués

Surtout, je n'ai pas eu l'occasion d'obtenir une sélection de la base de données dans une arborescence, avec des propriétés attachées. Par conséquent, la bibliothèque GP a une telle opportunité et la profondeur d'imbrication n'est pas limitée.

La manière la plus simple de considérer le principe de fonctionnement est basée sur un exemple. Pour examen, nous prenons le schéma de base de données suivant :

Contenu du tableau:

Souvent, lorsque vous interrogez une base de données, vous souhaitez obtenir une réponse arborescente et non plate. Par exemple, en exécutant cette requête:

 SELECT s.id, s.name, c.id title_id, c.title FROM student s INNER JOIN coursework c ON c. student_id = s.id WHERE s.id = 3 

Nous obtenons un résultat plat:

 [ 0 => [ 'id' => 3, 'name' => '', 'title_id' => 6, 'title' => '«»    ', ], 1=> [ 'id' => 3, 'name' => '', 'title_id' => 7, 'title' => '  ' ] ] 

En utilisant GP, vous pouvez obtenir ce résultat:

 [ 3 => [ 'name' => '', 'courseworks' => [ 6 => ['title' => '«»    '], 7 => ['title' => '  '] ] ] ] 

Pour obtenir ce résultat, vous devez passer un tableau avec des options à la fonction all (la fonction renvoie toutes les lignes de requête):

 all([ 'id'=> 'pk', 'name' => 'name', 'courseworks' => [ 'title_id' => 'pk', 'title' => 'title' ] ]) 

Le tableau $option dans l' agrégateur de fonctions ( $option , $ rawData) et all ( $options ) est construit selon les règles suivantes:

• Clés de tableau - noms de colonnes. Éléments de tableau - nouveaux noms pour les colonnes, vous pouvez entrer l'ancien nom.
• Il y a un mot réservé pour les valeurs du tableau - pk . Il indique que les données seront regroupées par cette colonne (la clé du tableau est le nom de la colonne).
• À chaque niveau, il ne devrait y avoir qu'un seul pk .
• Dans le tableau agrégé (résultant), les valeurs de la colonne déclarée par pk seront utilisées comme clés.
• S'il est nécessaire de placer une partie des colonnes à un niveau inférieur, un nouveau nom inventé est utilisé comme clé de tableau, et un tableau construit selon les règles décrites ci-dessus sera utilisé comme valeur.

Prenons un exemple plus complexe. Supposons que nous devions obtenir tous les étudiants avec le nom de leur cours et avec toutes les notes dans toutes les matières. Nous aimerions le recevoir non pas sous une forme plate, mais sous forme d'arbre, sans doublons. Vous trouverez ci-dessous la requête souhaitée dans la base de données et le résultat.

 SELECT s.id student_id, s.name student_name, s.semester_number, c.id coursework_id, c.semester_number coursework_semester, c.title coursework_title, l.id lesson_id, l.name lesson, m.id mark_id, m.mark FROM student s LEFT JOIN coursework c ON c.student_id = s.id LEFT JOIN mark m ON m.student_id = s.id LEFT JOIN lesson l ON l.id = m.lesson_id ORDER BY s.id, c.id, l.id, m.id 

Le résultat ne nous convient pas:

Pour réaliser la tâche, vous devez écrire le tableau $option suivant:

 $option = [ 'student_id' => 'pk', 'student_name' => 'name', 'courseworks' => [ 'coursework_semester' => 'pk', 'coursework_title' => 'title' ], 'lessons' => [ 'lesson_id' => 'pk', 'lesson' => 'lesson', 'marks' => [ 'mark_id' => 'pk', 'mark' => 'mark' ] ] ]; 

Requête de base de données:

 //    Query   .       // (    yii2) $qr = Yii::$app->gp->query( "SELECT s.id student_id, s.name student_name, s.semester_number, c.id coursework_id, c.semester_number coursework_semester, c.title coursework_title, l.id lesson_id, l.name lesson, m.id mark_id, m.mark FROM student s LEFT JOIN coursework c ON c.student_id = s.id LEFT JOIN mark m ON m.student_id = s.id LEFT JOIN lesson l ON l.id = m.lesson_id ORDER BY s.id, c.id, l.id, m.id"); //   1,  2   3  //  1 $result = $qr->all($option); //  2 $result = $qr->aggregator($option, $qr->all()); //  3 $qr->all(); $result = $qr->aggregator($option, $qr->rawData()); 

La fonction d' aggregator peut traiter n'importe quel tableau avec une structure similaire au résultat d'une requête de base de données, selon les règles décrites dans l' $option .

La variable $result contient les données suivantes:

 [ 1 => [ 'name' => '', 'courseworks' => [ 1 => ['title' => '    '], ], 'lessons' => [ 1 => [ 'lesson' => '', 'marks' => [ 1 => ['mark' => 3], 2 => ['mark' => 4] ] ], 2 => [ 'lesson' => '', 'marks' => [ 3 => ['mark' => 2], 4 => ['mark' => 2], 5 => ['mark' => 3] ] ], 4 => [ 'lesson' => '', 'marks' => [ 6 => ['mark' => 5] ] ] ] ], 3 => [ 'name' => '', 'courseworks' => [ 1 => ['title' => '«»    '], 2 => ['title' => '  '] ], 'lessons' => [ 1 => [ 'lesson' => '', 'marks' => [ 17 => ['mark' => 5] ] ], 2 => [ 'lesson' => '', 'marks' => [ 18 => ['mark' => 2] ] ], 3 => [ 'lesson' => '-', 'marks' => [ 20 => ['mark' => 4] ] ], 4 => [ 'lesson' => '', 'marks' => [ 16 => ['mark' => 2], 19 => ['mark' => 3] ] ], ] ] ] 

Soit dit en passant, avec la pagination avec une requête agrégée, seules les données les plus élémentaires sont prises en compte. Dans l'exemple ci-dessus, il n'y aura que 2 lignes pour la pagination.

Union multiple avec vous-même au nom de la recherche

Comme je l'ai écrit plus tôt, la tâche principale de ma bibliothèque est de simplifier la génération des parties where pour certaines requêtes. Donc, dans ce cas, nous devrons peut-être joindre à plusieurs reprises la même table pour quelle requête? L'une des options est lorsque nous avons un certain produit dont les propriétés ne sont pas connues à l'avance et qu'elles seront ajoutées par les utilisateurs, et nous devons avoir la possibilité de rechercher des produits par ces propriétés dynamiques. La façon la plus simple d'expliquer avec un exemple simplifié.

Supposons que nous ayons une boutique en ligne vendant des composants informatiques, que nous n'ayons pas d'assortiment strict et que nous achetions périodiquement un composant ou un autre. Mais nous aimerions décrire tous nos produits comme une entité unique et rechercher tous les produits. Alors, quelles entités peuvent être distinguées du point de vue de la logique métier:

1. Produit. L'entité la plus importante autour de laquelle tout est construit.
2. Type de produit. Cela peut être représenté comme la propriété racine de toutes les autres propriétés du produit. Par exemple, dans notre petit magasin, c'est seulement: RAM, SSD et HDD.
3. Propriétés du produit. Dans notre mise en œuvre, toute propriété peut s'appliquer à tout type de produit, le choix reste sur la conscience du manager. Dans notre magasin, les gestionnaires n'ont créé que 3 propriétés: la taille de la mémoire, le facteur de forme et le DDR.
4. La valeur des marchandises. La valeur que l'acheteur générera lors de la recherche.

Toute la logique métier décrite ci-dessus est reflétée en détail dans l'image ci-dessous.

Par exemple, nous avons un produit: 16 Go de RAM DDR 3 . Dans le diagramme, cela peut être affiché comme suit:

La structure et les données de la base de données sont clairement visibles dans la figure suivante:

Comme nous le voyons sur le diagramme, toutes les valeurs de toutes les propriétés sont stockées dans une table de valeurs (au fait, dans notre version simplifiée, toutes les propriétés ont des valeurs numériques). Par conséquent, si nous voulons rechercher simultanément plusieurs propriétés avec un tas de ET, nous obtenons une sélection vide.

Par exemple, un acheteur recherche des produits adaptés à une telle demande: la quantité de mémoire doit être supérieure à 10 Go et le facteur de forme doit être de 2,5 pouces . Si nous écrivons sql comme indiqué ci-dessous, nous obtenons une sélection vide:

 select * from product p inner join val v on v.product_id = p.id where (v.property_id = 1 and v.value > 10) AND (v.property_id = 3 and v.value = 2.5) 

Étant donné que les valeurs de toutes les propriétés sont stockées dans une table, pour rechercher plusieurs propriétés, vous devez joindre la valeur de table pour chaque propriété qui sera recherchée. Mais il y a une nuance, joindre les tables de jointures «horizontalement» (au mot union, toutes les jointures «verticales»), voici un exemple:

Ce résultat ne nous convient pas, nous aimerions voir toutes les valeurs dans une colonne. Pour ce faire, vous devez joindre la table val 1 fois plus que les propriétés par lesquelles la recherche est effectuée.

Nous sommes sur le point de générer automatiquement une requête SQL. Regardons la fonction
whereWithJoin ($aliasJoin, $options, $aliasWhere, $where) , qui fera tout le travail:

• $ aliasJoin - un alias dans le modèle de base, au lieu duquel la partie SQL avec jointures est remplacée.
• $ options - un tableau avec des descriptions des règles de génération de la pièce jointe.
• $ aliasWhere - un alias dans le modèle de base, qui remplace la partie where sql à la place.
• $ where est une instance de la classe Where.

Regardons un exemple: whereWithJoin('/*join*/', $options, '/*where*/', $wh) .

Créez d'abord la variable $ options : $options = ['v' => ['val', 'product_id', 'p.id']];

v est l'alias de la table. Si l'alias donné se trouve dans $ wh , une nouvelle table val sera connectée par jointure (où product_id est la clé étrangère de la table val , et p.id est la clé primaire de la table avec l'alias p ), un nouvel alias et cet alias sont générés pour cela remplacera v où.

$ wh est une instance de la classe Where. Nous formons la même demande: la mémoire doit être supérieure à 10 Go et le facteur de forme doit être de 2,5 pouces.

 $wh->linkAnd([ $wh->linkAnd([ ['v.property_id', '=', 1], ['v.value', '>', 10] ])->getRaw(), //    $wh->linkAnd([ ['v.property_id', '=', 3], ['v.value', '=', 2.5] ])->getRaw(),//    ]); 

Lors de la création d'une requête where, il est nécessaire d'envelopper la partie avec la propriété id et sa valeur entre crochets, cela indique à la fonction whereWithJoin() que l'alias de table sera le même dans cette partie.

 $qr->sql("select p.id, t.name type_name, pr.id prop_id, pr.name prop_name, v.id val_id, v.value from product p inner join type t on t.id = p.type_id inner join val v on v.product_id = p.id inner join properties pr on pr.id = v.property_id /*join*/ /*where*/") ->whereWithJoin('/*join*/', $options, '/*where*/', $wh) //     . ->all([ 'id' => 'pk', 'type_name' => 'type', 'properties' => [ 'prop_id' => 'pk', 'prop_name' => 'name', 'values' => [ 'val_id' => 'pk', 'value' => 'val' ] ] ]); 

Nous examinons le sql généré, les $qr->debugInfo() et le temps d'exécution de la requête: $qr->debugInfo() :

 [ [ 'type' => 'info', 'sql' => 'select p.id, t.name type_name, pr.id prop_id, pr.name prop_name, v.id val_id, v.value from product p inner join type t on t.id = p.type_id inner join val v on v.product_id = p.id inner join properties pr on pr.id = v.property_id inner JOIN val val_mIQWpnHhdQ ON val_mIQWpnHhdQ.product_id = p.id inner JOIN val val_J0uveMpwEM ON val_J0uveMpwEM.product_id = p.id WHERE ( val_mIQWpnHhdQ.property_id = :al_where_leV5QlmOZN and val_mIQWpnHhdQ.value > :al_where_ycleYAswIw ) and ( val_J0uveMpwEM.property_id = :al_where_dinxDraTOE and val_J0uveMpwEM.value = :al_where_wZJhUqs74i )', 'binds' => [ 'al_where_leV5QlmOZN' => 1, 'al_where_ycleYAswIw' => 10, 'al_where_dinxDraTOE' => 3, 'al_where_wZJhUqs74i' => 2.5 ], 'timeQuery' => 0.0384588241577 ] ] 

$qr->rawData() :

 [ [ 'id' => 3, 'type_name' => 'SSD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 5, 'value' => 512 ], [ 'id' => 3, 'type_name' => 'SSD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 6, 'value' => 2.5 ], [ 'id' => 4, 'type_name' => 'SSD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 7, 'value' => 256 ], [ 'id' => 4, 'type_name' => 'SSD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 8, 'value' => 2.5 ], [ 'id' => 6, 'type_name' => 'HDD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 11, 'value' => 1024 ], [ 'id' => 6, 'type_name' => 'HDD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 12, 'value' => 2.5 ] ] 

$qr->aggregateData() :

 [ 3 => [ 'type' => 'SSD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 5 => ['val' => 512] ] ], 3 => [ 'name' => '-', 'values' => [ 6 => ['val' => 2.5] ] ] ] ], 4 => [ 'type' => 'SSD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 7 => ['val' => 256] ] ], 3 => [ 'name' => '-', 'values' => [ 8 => ['val' => 2.5] ] ] ] ], 6 => [ 'type' => 'HDD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 11 => ['val' => 1024] ] ], 3 => [ 'name' => '-', 'values' => [ 12 => ['val' => 2.5] ] ] ] ] ] 

, , whereWithJoin() , .

whereWithJoin() , , n , m . n m 1 id . , AND .

GitHub .