Cet article a été initialement publié en juillet 2018 par Pedro Rolo et mis à jour en juin 2020 par Tiago Madere .
Il existe plusieurs fonctionnalités qui font Ruby on Rails attrayant, mais là où il brille vraiment, c'est lorsqu'il s'agit d'obtenir des informations à partir de bases de données relationnelles. C'est ORM -Actif recording - propose désormais une interface très mature, trouvant le juste équilibre entre concision et puissance.
Dans cet article, je vais fournir quelques exemples simples de la façon d'extraire des informations d'une base de données. Il ne s'agit pas d'un guide complet, mais plutôt d'un ensemble d'outils que je trouve utiles dans mon travail quotidien. De plus, ce que je présente ci-dessous est basé sur la dernière mise à jour de Rails (Rails 6).
Je vais commencer par définir un modèle de domaine par rapport auquel je vais exécuter mes requêtes :
Nous utilisons le modèle de domaine suivant dans nos exemples :
undefinedEn gros, undefined et undefined appartiennent à undefined, et undefined et undefined ont une relation plusieurs-à-plusieurs entre eux, qui est stockée dans la table des relations undefined.
Le undefined est ce qui lie le modèle dans notre application Ruby à sa table de base de données respective. L'objet Active record est livré avec un ensemble de méthodes qui nous aident à interroger les enregistrements de base de données. Il n'est donc pas nécessaire d'utiliser du SQL brut. À des fins de comparaison, nous présenterons la traduction de nos requêtes ActiveRecord en requêtes SQL. Vous pouvez facilement effectuer cette traduction en utilisant undefined.
Les requêtes les plus simples ne concernent qu'une seule table et tentent d'obtenir les enregistrements dont les colonnes comportent certaines valeurs spécifiques.
Par exemple, supposons que nous voulions savoir qui a pour prénom John :
undefined
undefined
Nous pouvons également utiliser des tableaux de valeurs souhaitables au lieu de valeurs uniques. Cela générera des requêtes utilisant le undefined Mot-clé SQL :undefined
undefined
Outre les tableaux, les plages sont également acceptées comme prédicats de valeur :
undefined
Vous pouvez également avoir des plages infinies :
undefined
qui, avec Rails 6, peut maintenant être simplement écrit comme :undefined
undefined
Il est possible de limiter nos requêtes à plusieurs prédicats simultanés. We may be provided undefined un hash avec plusieurs mots-clés ou nous pouvons enchaîner plusieurs invocations de undefined:
undefined
Dans le cas contraire, nous souhaitons composer nos prédicats avec un undefined nous pouvons utiliser undefined.
undefined
Lorsque nous recherchons uniquement une ligne spécifique, nous pouvons utiliser undefined à la place, qui arrête la recherche une fois qu'il trouve la première correspondance en utilisant undefined
undefined
Ou nous pouvons fournir notre propre limite personnalisée en enchaînant undefined à notre undefined requêtes :
Il est possible d'obtenir les enregistrements ne correspond pas une certaine condition en utilisant undefined en collaboration avec undefined:
undefined
Il est possible d'utiliser undefined pour trier les résultats par ordre croissant ou décroissant :
undefined
undefined
Plusieurs fonctions permettent de plier le résultat d'une requête en certaines valeurs, telles que undefined, undefined, undefined et undefined:
undefined
undefined
De plus, il est possible de regrouper des éléments par colonne donnée et de plier ces éléments avec ces fonctions de pliage, effectuant ainsi undefined requêtes :
undefined
Le cas d'utilisation le plus courant concernant plusieurs tables concerne le chargement rapide de certaines entités liées au modèle que nous avons sélectionné, qui peuvent être, par exemple, accessibles de manière itérative. Ce problème est communément appelé undefined et l'interaction suivante le met en évidence :
undefined
undefined
Comme nous le voyons, une nouvelle requête est effectuée chaque fois que nous demandons à une personne d'accéder à son pays.
undefined nous permet de charger rapidement toutes les données en une seule fois, optimisant ainsi ce qui est effectué ci-dessus. Il se comporte comme un undefined, chargeant ainsi toutes les entrées du modèle associé qui concernent nos principales entrées de modèle.
undefined
Mais attendez, ce n'est pas un undefined - pourrait-on dire ! Eh bien, comme il n'y a aucune contrainte supplémentaire sur les pays que nous sélectionnons, Rails préfère recourir à un undefined requête, en tirant parti de l'index de clé primaire. Cependant, si nous ajoutons des contraintes à notre requête, Active Record exécute un undefined au lieu de cela :
Ce qu'il faut remarquer dans l'exemple ci-dessus, c'est l'utilisation d'un hachage sur la condition where afin de spécifier des contraintes sur nos modèles référencés.
Nous pouvons également charger plusieurs relations à la fois :
undefined
Et il est également possible de le faire de manière imbriquée, en passant un hachage de relations à la place :
undefined
Parfois, nous ne sommes intéressés que par les enregistrements associés au module correspondant. Lorsque c'est le cas, nous utilisons undefined, qui possède la sémantique d'un undefined.
Nous illustrons la nécessité de cette fonctionnalité dans l'exemple suivant, où nous avons uniquement l'intention de faire appel à des personnes qui sont effectivement associées à un pays :
undefined
Si nous ne sommes intéressés que par les enregistrements associés à un modèle associé avec des valeurs d'attributs spécifiques, nous pouvons utiliser undefined et puis undefined pour spécifier les contraintes de nos modèles.
Eh bien, toutes les requêtes écrites jusqu'à présent sont assez longues. Lorsqu'ils se compliquent ou sont destinés à être réutilisés via notre code, il est pratique de leur donner un nom.
Dans les anciennes versions de rails, vous devez utiliser undefined méthode de classe pour créer de telles requêtes réutilisables. Vous pouvez obtenir les mêmes fonctionnalités en définissant simplement des méthodes de classe :
undefined
Après avoir défini les requêtes de cette manière, vous pouvez enchaîner ces abstractions de haut niveau.
undefined
Arel est un langage spécifique à un domaine qui permet d'exprimer vos requêtes en algèbre relationnelle. Dans les versions précédentes de Rails, il était assez courant de devoir recourir à Arel pour exécuter certaines fonctionnalités fréquemment demandées, bien qu'aujourd'hui, Active Record de Rails 6 couvre déjà la plupart de ces cas d'utilisation.
Je vais commencer par présenter certaines des requêtes Rails 6 déjà présentées en utilisant Arel au lieu d'un simple enregistrement actif. Et plus tard, concentrez-vous sur la façon d'écrire certains cas où l'on aurait encore besoin d'Arel.
Lors de la création de requêtes Arel, on commence généralement par obtenir le undefined objets des tables SQL avec lesquels nous voulons interagir :
undefined
undefined
Nous pouvons accéder aux colonnes de nos tables comme un hash. À partir de ces tableaux, il est possible de définir des prédicats (undefined) en invoquant des méthodes sur ses attributs, qui sont accessibles via la méthode undefined:
Les prédicats undefined, undefined, undefined, undefined, undefined, undefined are équivalents aux opérateurs =, ! =, <, >, <=, >= et travaillez comme ceci :
undefined
undefined
Le undefined & undefined peut être utilisé pour créer des prédicats multitables et fonctionner de la même manière, comme ceci :
undefined
Nous pouvons ensuite transmettre ces prédicats à undefined, et tant que les tables requises sont jointes, le prédicat sera converti avec succès en SQL :
Il s'agit d'un cas d'utilisation où il faut toujours recourir à Arel pour obtenir une requête indépendante de la base de données. Pour ce faire, il convient de combiner les undefined Prédicat Arel avec undefined SQL générique character :
Cela renvoie les personnes dont le nom de famille commence par le caractère « A ».
Arel et Active Record proposent bien plus de fonctionnalités que celles que j'ai présentées ici. Cependant, ils sont largement suffisants pour démarrer avec des applications aux exigences simples.
En fin de compte, il s'agit de choisir de préférence entre les méthodes de requête ActiveRecord ou Arel, lorsque nous effectuons nos requêtes quotidiennes. Je trouve la syntaxe ActiveRecord plus facile à lire et à utiliser, mais Arel peut toujours être utile pour traiter des requêtes complexes.
Développeur de rails avec plus de 10 ans d'expérience dans diverses technologies. Je m'intéresse à la programmation fonctionnelle.
Étudiant en informatique et à temps partiel d'ImaginaryCloud. Désireux d'apprendre de nouvelles technologies et techniques. Joueur de tennis et pianiste.
People who read this post, also found these interesting:
.webp)
