Instructions de cas SQLite

SQLite a une instruction de cas qui nous permet d'inclure la logique conditionnelle dans nos instructions SQL. Les expressions de cas Sqlite exécutent une liste de conditions et renvoient une expression basée sur les résultats. Les instructions de cas SQLite se comportent de manière identique à des instructions si - alors - Else comme les autres langues de script. Si la phrase est valide, nous pouvons utiliser la déclaration de cas SQLite dans l'une des clauses ou des instructions SQL. En général, l'instruction SQLITE Case commence par une expression facultative et un ou plusieurs quand… puis les clauses, une clause Else facultative, et un mot-clé final nécessaire.

Syntaxe de l'instruction de cas dans SQLite:

Dans SQLite, l'instruction de cas a généralement l'une des deux formes.

Instruction de cas simple SQLITE:

Case test_statement
Lorsque [condition1] alors [Statement1]
Lorsque [condition2] alors [instruction2]
…
…
…
Lorsque [condition (n)] alors [instruction (n)]
Else [déclaration]
FIN

Nous utilisons la syntaxe ci-dessus pour établir de nombreuses conditions pour atteindre le résultat souhaité. Quand puis des clauses sont utilisées dans la syntaxe ci-dessus. Ils fonctionnent dans un ordre logique. Pour retourner la sortie finale, cette méthode compare chaque instruction à la liste des instructions. Il s'agit d'une approche assez facile pour exécuter la déclaration de cas en fonction des exigences de l'utilisateur. Chaque condition et instruction sont interdépendantes, ce qui signifie que lorsque la première condition est vraie, l'instruction n'est exécutée qu'après cela. De cette façon, toutes les conditions et déclarations sont exécutées. Si une condition est fausse, le contrôle est transféré à la partie else comme indiqué dans la syntaxe ci-dessus.

Pour choisir le résultat, la déclaration de cas de requête évalue une liste des déclarations. Il convient de noter que l'expression de cas simple recherche simplement les capitaux propres. Tandis que la déclaration de cas regardée peut utiliser n'importe quelle forme d'inspection.

Instruction de cas de recherche SQLite:

Case test_statement
Lorsque [Boolean Statement1] alors [Statement1]
Lorsque [Boolean Statement2] alors [Statement2]
Fin [déclaration] fin

Si l'instruction booléenne dans le regroupement spécifié est valide, l'instruction de cas de recherche l'évalue et renvoie le résultat correspondant. Lorsqu'aucune déclaration valide n'est trouvée, l'instruction de cas de requête renvoie la déclaration dans la condition ELSE. Si la clause ELSE est négligée, la déclaration de cas regardée renvoie nul. Lorsque les critères indiqués sont remplis, la déclaration de cas de recherche met fin à l'évaluation et à l'exécution.

Création de table pour l'instruction de cas dans SQLite:

Tout d'abord, nous avons créé une table et donné le nom «étudiant» avec la requête Create. La table est définie avec les différentes colonnes telles que ID avec le type de données entier et Create ID en tant que clé principale, nom et e-mail sont définis avec le texte du type de données. La dernière colonne CGPA se voit attribuer un type de données de texte. L'élève de table et ses attributs sont indiqués dans le shell SQLite comme suit:

Créer un étudiant de table (
…> Id int clé primaire ,
…> Nom du texte ,
…> Texte par e-mail ,
…> Float CGPA
…>);

Maintenant, nous devons insérer les valeurs contre chaque colonne de l'étudiant de la table. Avec la requête SQLite Insert, nous avons inséré cinq lignes dans chacune des colonnes spécifiées dans l'étudiant de la table. La capture d'écran ci-dessous montre la façon d'insérer des enregistrements dans les colonnes de table.

sqlite> insérer dans les valeurs des étudiants (2, 'Ibrahim', 'ibrahim31 @ gmail.com ', 3.20);
sqlite> insérer dans les valeurs des étudiants (3, «maha», «maha89 @ gmail.com ', 3.9);
sqlite> insérer dans les valeurs des étudiants (4, 'Jennifer', 'jennifer22 @ gmail.com ', 2.5);
sqlite> Insérer dans les valeurs des étudiants (5, «rehan», «rehan99 @ gmail.com ', 3.dix );

Voyons si les données sont enregistrées dans le tableau Student. En utilisant l'instruction SELECT, nous avons récupéré toutes les données de l'élève de la table dans un format de table. La déclaration susmentionnée est représentée dans la capture d'écran ci-dessous:

SQLITE> SELECT * FROM Student;

Exemple 1: Programme d'utilisation de l'instruction de cas simple SQLite:

Nous avons utilisé une instruction de cas simple avec l'instruction SELECT pour afficher le fonctionnement de l'instruction de cas dans SQLite.

Ici, nous avons utilisé une instruction sélectionnée et sélectionné un ID de colonne, un nom et un CGPA de l'étudiant de la table. Après cela, nous avons utilisé une déclaration de cas qui compare le CGPA de l'étudiant. Il correspond au CGPA avec la condition si le CGPA est supérieur ou égal à 4.00 ou pas. Si c'est le cas, alors cela donne à ce cgpa un+. Mais si la condition est fausse, le cas passera à la déclaration suivante et vérifiera si le CGPA est supérieur à 3.5. Si la condition est vraie, alors elle attribue à ce CGPA une note «A».

Comme ceci, le contrôle est transmis à chaque déclaration de cas jusqu'à ce que le CGPA ne réponde pas à la condition donnée. Si tous les cas sont faux, alors la clause ELSE sera exécutée et imprimera une déclaration échoue.

SQLITE> SELECT ID, nom, CGPA,
…> Cas
…> Quand Cgpa> = 4.00 puis "A +"
…> Quand Cgpa> = 3.5 puis "A"
…> Quand Cgpa> = 3.0 alors "b"
…> Quand Cgpa> = 2.5 alors "C"
…> Sinon "échouer"
…> Terminer comme "grade"
…> De l'étudiant;

Maintenant, nous allons effectuer la requête et regarder le résultat. Cela devrait ressembler à ceci: la colonne de grade est incluse dans l'étudiant de la table ainsi que les valeurs de l'énoncé de cas.

Exemple 2: Programme d'utilisation de l'instruction de cas de recherche SQLite:

Pour déterminer le résultat, la déclaration de cas fouille analyse un ensemble d'expressions. La simple expression de cas se compare simplement pour l'égalité. Tandis que l'expression de cas de recherche peut comparer de quelque manière que ce soit.

Une déclaration de cas booléenne est utilisée dans l'exemple donné. Pour cela, nous avons une requête sélectionnée à travers laquelle nous avons sélectionné trois attributs ID, nom et CGPA de l'étudiant de la table. Seuls ces attributs et leurs valeurs correspondantes apparaîtront comme la sortie. Ensuite, nous avons un mot-clé de cas pour l'instruction SQLITE Case. La condition est appliquée avec le mot-clé quand. Premièrement, la déclaration de cas vérifie si le CGPA est supérieur à 3.5 puis attribue le grade A. Si la condition n'est pas satisfaite ici, alors nous passerons à notre deuxième énoncé de cas qui vérifie la condition si elle est satisfaite ici ou non. Si nos deux cas sont faux, alors la partie ELSE exécutera et imprimera le grade C.

SQLITE> SELECT ID, nom, CGPA,
…> Cas
…> Quand CGPA> 3.5 puis "A"
…> Quand CGPA> 3.0 et CGPA < 2.5 THEN "B"
…> D'autre
…> "C"
…> Fin "grade"
…> De l'étudiant;

Lors de l'exécution de la requête de cas ci-dessus, les résultats sont obtenus comme ceci:

Conclusion:

Nous avons étudié la syntaxe de base des instructions de cas dans cet article. Nous avons également vu une variété d'instances de déclaration de cas. Les règles pour les déclarations de cas ont également été enseignées. Nous avons appris en utilisant l'instruction SQLITE Case dans ce post et quand le faire.