Manipuler des requêtes brutes dans Django

Nous apprendrons, avec cette explication, ce que fait la méthode raw() et comment nous pouvons manipuler des requêtes brutes, et nous apprendrons également comment injecter du SQL dans nos applications dans Django.

Manipuler des requêtes brutes à l’aide de la méthode raw() dans Django

L’utilisation de la méthode raw() dans Django nous permet de prendre ou de construire des requêtes SQL et de les exécuter. Mais ce n’est pas la seule façon d’exécuter des requêtes SQL dans Django ; au lieu d’utiliser la configuration de formulaire par défaut, nous pouvons également, si nous le souhaitons, contourner le formulaire et simplement exécuter des requêtes SQL.

Mais pourquoi avons-nous mentionné cela? Parce que la méthode raw() du gestionnaire de modèles devrait généralement être votre première option lorsque vous souhaitez exécuter des requêtes SQL brutes.

En effet, la structure de l’instance de classe d’ensemble de requêtes brutes est très similaire à ce que vous avez travaillé avec l’instance de classe d’ensemble de requêtes. Nous pouvons effectuer d’autres actions dans les requêtes brutes, telles que l’indexation et le découpage.

Commençons donc par un exemple très simple. Continuons et créons la nouvelle fonction appelée STUDENT_DATA().

Nous utiliserons le jeu de données simple et le modèle Student dans notre fichier models.py.

class Student(models.Model):

    FIRST_NAME = models.CharField(max_length=100)
    SR_NAME = models.CharField(max_length=100)
    age = models.IntegerField()
    CLASS_ROOM = models.IntegerField()
    TEACHER = models.CharField(max_length=100)

    def __str__(self):
        return self.FIRST_NAME

Nous allons maintenant revenir au fichier views.py et créer une fonction appelée STUDENT_DATA() pour démontrer le SQL brut.

A l’intérieur de la fonction, nous prendrons toutes les données de la table Student en utilisant Student.objects.all(). Cela renverra toutes les données des étudiants de cette table et les stockera dans SD_DATA.

Imprimons cet objet. Nous utiliserons également connection.queries qui donnera la sortie de SQL et quelques mesures de performance.

def STUDENT_DATA(request):

    SD_DATA = Student.objects.all()

    print(SD_DATA)
    print(connection.queries)
    return render(request, "output.html", {"data": SD_DATA})

Allons-y et exécutons le serveur. Le navigateur affichera toutes les données, puis ci-dessous, nous pouvons voir que nous avons obtenu la requête SQL que nous avons exécutée.

Continuons et créons un équivalent en utilisant la méthode raw(). Donc, encore une fois, nous utiliserons student et ses objets, mais cette fois nous utiliserons raw().

Nous devrons exécuter la requête SQL à l’intérieur de cette méthode : SELECT * FROM étudiant_étudiant.

Nous n’avons pas besoin de sélectionner tous ces éléments individuels, nous pouvons donc utiliser l’étoile pour sélectionner tous les champs de la table, puis la clause suivante est FROM, qui aide à trouver la table. Ensuite nous définirons le nom de la table qui s’appelle étudiant_étudiant.

SD_DATA = Student.objects.raw("SELECT * FROM student_student")

Retournons dans le navigateur et actualisons-le. Ensuite, nous verrons que nous renvoyons ces éléments de la base de données à l’aide d’une instruction Select.

Maintenant, nous allons avancer et développer légèrement cela et sélectionner un élément individuel. Pour ce faire, nous aurons besoin d’utiliser la clause WHERE ; après un espace, on sélectionne l’attribut age et on le passe comme valeur 21.

SD_DATA = Student.objects.raw("SELECT * FROM student_student WHERE age=21")

Réexécutons le serveur Django et actualisons le navigateur. Ensuite, nous verrons que le SQL fonctionne et renvoie un seul élément de la base de données.

Nous avons vu comment injecter notre SQL dans la fonction raw() de Django et comment effectuer des actions sur la base de données.

Dans la documentation de Django, si vous parcourez la référence instantanée du modèle et que vous la lisez, cela vous donnera des informations sur un modèle différé. Le terme instances de modèle différées désigne les champs émis par la requête jusqu’à ce que nous les chargeons à la demande.

Pour imprimer les données, nous devons spécifier quelles données nous voulons voir dans la sortie, donc pour ce faire, nous devrons utiliser une boucle for.

for d in Student.objects.raw("SELECT * FROM student_student"):
    print(d)

Si nous réexécutons cela, regardez dans la console car nous imprimons ceci et renvoyons les trois noms de la table.

Vous pouvez trouver des requêtes plus complexes ici. Par exemple, un concept appelé création d’un ensemble de requêtes signifie que nous pouvons limiter le nombre d’objets que nous voulons renvoyer.

Maintenant, nous allons déclarer une nouvelle variable appelée sql, puis y stocker la requête SQL et la passer à l’intérieur de la fonction raw(). Après la fonction raw(), nous allons limiter deux lignes en découpant les objets.

sql = "SELECT * FROM student_student"
SD_DATA = Student.objects.raw(sql)[:2]

Lorsque nous examinons la sortie, elle renvoie simplement les deux lignes.

Code source complet du fichier views.py :

from django.shortcuts import render
from .models import Student
from django.db import connection


def STUDENT_DATA(request):

    SD_DATA = Student.objects.all()
    sql = "SELECT * FROM student_student"
    SD_DATA = Student.objects.raw(sql)[:2]
    # for d in Student.objects.raw('SELECT * FROM student_student'):
    #     print(d)

    print(SD_DATA)
    # print(connection.queries)
    return render(request, "output.html", {"data": SD_DATA})

Nous avons utilisé le code suivant dans notre modèle.

{{data}}

<hr/>

{% for i in data %}
    <div>{{ i.FIRST_NAME }} - {{ i.age }}</div>
{% endfor %}