SQLITE GROUP par

Sqlite donne à l'utilisateur un nouvel ensemble de clauses, dont l'un est un groupe par. Essentiellement, le groupe par déclaration est un composant supplémentaire de la requête sélectionnée qui fonctionne en conjonction avec d'autres commandes de sélection pour organiser le contenu différemment. Le groupe par déclaration est utilisé pour créer un ensemble de lignes en fonction de la requête de l'utilisateur. Il fournit également des lignes simples ou multiples pour chaque groupe. Nous pouvons utiliser des méthodes de comptabilité d'exercice comme SUM et compter comme paramètres dans le groupe par commande pour fournir plus d'informations sur le tableau donné. Le composant de la requête sélectionnée est suivi par le groupe par déclaration. Si une requête comprend une commande où le groupe par commande doit être placé après.

Si la requête de sélection est une déclaration accumulée avec un groupe par commande, alors chacune des variables fournies définies comme un élément du groupe par commande est évaluée pour chaque colonne des données. Chaque entrée est ensuite attribuée à une «collection» en fonction des résultats. Les inscriptions avec le même groupe par des résultats de commande sont attribuées à un groupe connexe. Les valeurs vides sont considérées comme identiques pour l'agrégation des lignes. Lors de l'évaluation d'un argument donné dans un groupe par commande, les critères habituels pour sélectionner une configuration de regroupement pour analyser les valeurs textuelles sont applicables. L'argument de groupe par commande n'aura pas à être un paramètre qui apparaît dans la sortie. Dans un groupe par commande, l'argument donné ne peut pas être une expression définie accumulée. Nous allons explorer comment utiliser le groupe par commande pour développer un ensemble de lignes résumées à partir d'une série de valeurs dans cet article.

Créer un tableau:

Tout d'abord, nous devons créer une table nommée «Doctor». Il y a différents attributs de ce tableau. Les colonnes incluent doc_id, doc_fname, doc_lname, salaire et ville. Les attributs ont des types de données différents. La colonne 'Doc_id' a un type de données entier, 'doc_fname', 'doc_lname' et 'ville' a un type de données texte. Tandis que l'attribut «salaire» contient le type de données numérique.

Créer un docteur de table (
Clé primaire DOC_ID INTEGER,
Texte doc_fname,
Texte doc_lname,
Salaire numérique,
Texte de la ville
));

La sortie affiche l'exécution effective du programme ci-dessus.

Tableau d'insertion:

Dans l'étape suivante, nous avons utilisé la requête d'insert pour insérer les données de différents médecins dans les colonnes (doc_id, doc_fname, doc_lname, salaire et ville) de la table 'docteur' '.

Insérer dans Doctor (DOC_ID, DOC_FNAME, DOC_LNAME, SALAIRE, CITY) VALEURS (764, 'ASMA', 'MUNEEB', '40000', 'ISLAMABAD'),
(381, «Laiba», «Ajmal», «90000», «Swat»),
(904, «Muhammad», «Ahmed», «50000», «Multan»),
(349, «Noor», «Zain», «120000», «Karachi»),
(557, «Kashaan», «Khalid», «70000», «Islamabad»);

Nous exécutons avec succès la requête de l'insert comme indiqué dans la figure ci-dessous.

Sélectionnez la requête:

Nous pouvons obtenir les données complètes du tableau ou acquérir des données à partir de quelques colonnes seulement. Chaque fois que nous voulons obtenir les informations de certaines colonnes, nous devons spécifier les noms de cette colonne dans la requête SELECT.

>> Sélectionner * parmi le médecin

Après avoir exécuté la requête sélectionnée, nous obtenons toutes les données du tableau «Doctor». Le tableau contient les identifiants, les prénoms, les noms de famille, les salaires et les villes de médecins.

Utiliser le groupe par clause:

Dans les requêtes SQLite, la clause Group By a été utilisée en association avec la commande Select pour organiser des données similaires. Dans une requête sélectionnée, la clause Group by vient après la déclaration où et juste avant la déclaration de l'ordre par. Dans ce cas, nous avons appliqué le groupe par clause sur la ville.

>> Sélectionner * parmi Doctor Group by City;

Les données de la sortie sont agrégées par la colonne de «ville».

Ici, nous voulons simplement acquérir les données des identifiants, des prénoms et des salaires des médecins. Le groupe par et l'ordre par les clauses sont utilisés sur la colonne «doc_id».

>> sélectionnez doc_id, doc_fname, salaire dans le groupe doctorant par ordonnance doc_id par doc_id desc;

Dans le tableau résultant, seules les données de la colonne «doc_id», «doc_fname» et le salaire seront obtenues. Les données du tableau sont triées en utilisant les identifiants des médecins en ordre décroissant.

Utilisez le groupe par commande avec SUM:

Pour la table «Doctor», nous allons démontrer l'utilisation de groupes par déclaration avec la fonction de somme. Que nous souhaitions considérer le montant exact de revenu payé à chaque médecin, nous utiliserons le groupe par commande comme vu ci-dessous. Ici, la clause Group By est utilisée sur la colonne 'doc_fname'.

>> sélectionnez doc_fname, sum (salaire) de Doctor Group by doc_fname;

Le tableau du résultat sera regroupé par colonne 'doc_fname'.

Utilisez Group By Command avec Count:

Nous allons modifier légèrement la requête ci-dessus en ajoutant simplement le nombre (doc_lname) dans l'instruction SELECT comme la capture d'écran suivante pour observer comment utiliser le groupe par commande avec la méthode de comptage.

>> sélectionnez doc_id, doc_fname, doc_lname, salaire, sum (salaire), count (doc_lname) de doctor groupe par doc_lname;

Si nous regardons le résultat, il calcule le nombre de médecins dans le tableau «Doctor» qui a le même nom de famille. Pour déterminer la somme pour chaque groupe, nous utiliserons la fonction de somme.

Utilisez la commande group by pour plusieurs colonnes:

Nous utiliserons également le groupe par déclaration pour plusieurs colonnes. Jetons un coup d'œil à l'instance dans laquelle nous utilisons le groupe par déclaration pour deux colonnes.

>> Sélectionner * parmi Doctor Group par salaire, ville;

La requête renvoie toutes les données du tableau «Doctor». Le groupe par clause est appliqué au salaire et à la ville.

Conclusion:

Avec l'aide de plusieurs illustrations, nous avons expliqué quand et comment utiliser le groupe par clause dans l'article précédent. Le groupe par déclaration de SQLite est appliqué pour combiner des données en un seul enregistrement dans lequel le résultat d'une ou même plus de colonnes définies est dupliquée. Cette fonctionnalité sera utilisée pour réduire l'étendue des entrées trouvées en recherchant simplement des valeurs de colonne distinctes. Nous avons également remarqué comment le groupe par déclaration pourrait être utilisé pour faire de nombreuses opérations en fonction de nos besoins. Nous pouvons utiliser le groupe par commande avec les fonctions de nombre et de somme. Et nous utilisons le groupe par commande pour plusieurs colonnes.