Insérer, supprimer, mettre à jour des enregistrements dans la base de données. Comment envoyer une requête à une base de données à l'aide de VBA Access Création de requêtes SQL dans les homonymes d'accès
Travail de laboratoire n°1
SQL: EXTRAIT DE DONNÉES - commandeSÉLECTIONNER
Objectif du travail :
- se familiariser avec les instructions SQL ;
- découvrez comment créer des requêtes SQL simples dans Access à l'aide de la commande SELECT ;
· utilisation des opérateurs IN, BETWEEN, LIKE, IS NULL.
Exercice№1. Créez une requête pour sélectionner en mode SQL toutes les valeurs des champs PRENOM et NOM de la table ÉTUDIANTS.
CHOISIR PRENOM, NOM
DES ÉTUDIANTS ;
Exercice№2 . Créez une requête pour sélectionner en mode SQL toutes les colonnes de la table STUDENTS.
SÉLECTIONNER *
DES ÉTUDIANTS ;
Tâche n°3. Créez une requête pour sélectionner en mode SQL les noms des villes où vivent les étudiants, dont les informations se trouvent dans la table DONNÉES PERSONNELLES.
CHOISIR UNE VILLE DISTINCTE
À PARTIR DE [DONNÉES PERSONNELLES] ;
Tâche n°4. Créez une requête de sélection en mode SQL qui récupère les noms de tous les étudiants portant le nom de famille Ivanov, dont les informations se trouvent dans la table STUDENTS.
CHOISIR NOM, PRÉNOM
DES ÉTUDIANTS
OÙ NOM="Ivanov";
Tâche n°5. Créez une requête de sélection en mode SQL pour obtenir les noms et prénoms des étudiants qui étudient dans le groupe UIT-22 sur une forme d'enseignement budgétaire.
CHOISIR NOM, PRÉNOM
DES ÉTUDIANTS
OÙ GROUPE="UIT-22" ET BUDGET=true ;
Tâche n°6. Créez une requête en mode SQL. pour un échantillon du tableau EXAMEN, des informations sur les étudiants qui n'ont que les notes 4 et 5.
SÉLECTIONNER *
DEPUIS [CHANGEMENTEXAMENS]
OÙGRADEDANS(4,5);
Tâche n°7. Créez un mode zanpoc et SQL pour sélectionner des informations sur les étudiants qui ont une note d'examen de 3 dans la matière IOSU.
SÉLECTIONNER *
DEPUIS [CHANGEMENTEXAMENS]
OÙARTICLE=" IOSU"EtGRADEPas dans (4,5);
Tâche n°8. Créez une requête en mode SQL pour sélectionner les enregistrements pour les éléments dont les heures sont comprises entre 100 et 130.
SÉLECTIONNER *
DEPUISARTICLES
OÙMONTREENTRE 100 ET 130 ;
Tâche n°9. Créez une requête en mode SQL pour sélectionner dans la table ÉTUDIANTS les informations sur les étudiants dont le nom commence, par exemple, par la lettre « C ».
SÉLECTIONNER *
DEPUISÉTUDIANTS
OÙNOM DE FAMILLECOMME"AVEC*";
Conclusion: Pendant travail de laboratoire je me suis familiarisé avec les instructions SQL, j'ai appris à créer des requêtes SQL simples dans Access à l'aide de la commande SELECT à l'aide des opérateurs IN, BETWEEN, LIKE.
Cette leçon est dédiée à Requêtes SQLà la base de données sur Accès VBA. Nous verrons comment les requêtes INSERT, UPDATE, DELETE sont effectuées sur la base de données dans VBA, et nous apprendrons également comment obtenir une valeur spécifique à partir d'une requête SELECT.
Ceux qui programment en Accès VBA en travaillant avec la base de données Serveur SQL, très souvent, ils sont confrontés à une tâche aussi simple et nécessaire que d'envoyer une requête SQL à une base de données, qu'il s'agisse d'INSERT, UPDATE ou d'une simple requête SQL SELECT. Et comme nous sommes des programmeurs débutants, nous devrions également être capables de le faire, c'est donc exactement cela que nous ferons aujourd'hui.
Nous avons déjà abordé le sujet de l'obtention de données à partir d'un serveur SQL, où nous avons écrit du code en VBA pour obtenir ces données, par exemple, dans l'article sur le téléchargement de données vers un fichier texte depuis MSSql 2008, ou nous l'avons également abordé un peu dans le matériel Téléchargement de données depuis Access vers un modèle Word et Excel, mais d'une manière ou d'une autre, nous avons examiné cela superficiellement, et aujourd'hui je propose d'en parler un peu plus en détail.
Note! Tous les exemples ci-dessous sont considérés en utilisant le projet ADP Access 2003 et la base de données MSSql 2008. Si vous ne savez pas ce qu'est un projet ADP, nous l'avons examiné dans le matériel Comment créer et configurer un projet Access ADP
Données sources pour exemples
Disons que nous avons une table test_table, qui contiendra les numéros et les noms des mois de l'année (requêtes effectuées à l'aide de Studio de gestion)
CRÉER UNE TABLE. (NOT NULL, (50) NULL) ON GO
Comme je l'ai déjà dit, nous utiliserons un projet ADP configuré pour fonctionner avec MS SQL 2008, dans lequel j'ai créé un formulaire de test et ajouté un bouton de démarrage avec une signature "Courir", dont nous aurons besoin pour tester notre code, c'est-à-dire Nous écrirons tout le code dans le gestionnaire d'événements " Appuyez sur le bouton».
Requêtes à la base de données INSERT, UPDATE, DELETE en VBA
Afin de ne pas trop tarder, commençons tout de suite, disons que nous devons ajouter une ligne à notre table de test ( code commenté)/
Private Sub start_Click() "Déclarez une variable pour stocker la chaîne de requête Dim sql_query As String "Écrivez-y la requête dont nous avons besoin sql_query = "INSERT INTO test_table (id, name_mon) VALUES ("6", "June")" "Exécuter il DoCmd.RunSQL sql_query End Sub
Dans ce cas, la requête est exécutée en utilisant les paramètres de connexion à la base de données actuels. Nous pouvons vérifier si les données ont été ajoutées ou non.
Comme vous pouvez le constater, les données ont été insérées.
Afin de supprimer une ligne, nous écrivons le code suivant.
Private Sub start_Click() "Déclarez une variable pour stocker la chaîne de requête Dim sql_query As String "Écrivez-y une requête de suppression sql_query = "DELETE test_table WHERE id = 6" "Exécutez-la DoCmd.RunSQL sql_query End Sub
Si nous vérifions, nous verrons que la ligne souhaitée a été supprimée.
Pour mettre à jour les données, écrivez dans la variable sql_query demande de mise à jour, j'espère que le sens est clair.
Requête SELECT vers une base de données en VBA
Ici, les choses sont un peu plus intéressantes qu'avec d'autres constructions SQL.
Tout d'abord, disons que nous devons obtenir toutes les données de la table et, par exemple, nous les traiterons et les afficherons dans un message, et vous pouvez bien sûr les utiliser à d'autres fins, pour cela nous écrivons ce qui suit code
Private Sub start_Click() "Déclarer les variables "Pour un ensemble d'enregistrements de la base de données Dim RS As ADODB.Recordset "Chaîne de requête Dim sql_query As String "Chaîne pour afficher les données récapitulatives dans un message Dim str As String "Créer un nouvel objet pour les enregistrements set RS = New ADODB .Recordset "Ligne de requête sql_query = "SELECT id, name_mon FROM test_table" "Exécutez la requête en utilisant les paramètres de connexion du projet actuel RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Parcourez les enregistrements sans le faire ( RS.EOF) "Remplissez la variable pour afficher le message str = str & RS.Fields("id") & "-" & RS.Fields("name_mon") & vbnewline "aller à l'enregistrement suivant RS.MoveNext Wend " Afficher le message msgbox str End Sub
Ici, nous utilisons déjà des boucles VBA Access pour parcourir toutes les valeurs de notre jeu d'enregistrements.
Mais bien souvent, il est nécessaire d'obtenir non pas toutes les valeurs d'un ensemble d'enregistrements, mais une seule, par exemple le nom du mois par son code. Et pour ce faire, c'est assez cher d'utiliser une boucle, donc on peut simplement écrire une requête qui ne retournera qu'une seule valeur et y accéder, par exemple, on obtiendra le nom du mois en utilisant le code 5
Private Sub start_Click() "Déclarer les variables" Pour un ensemble d'enregistrements de la base de données Dim RS As ADODB.Recordset "Chaîne de requête Dim sql_query As String "Chaîne pour afficher la valeur finale Dim str As String "Créer un nouvel objet pour l'ensemble d'enregistrements RS = New ADODB.Recordset "Ligne de requête sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "Exécutez la requête en utilisant les paramètres de connexion actuels du projet RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Obtenez notre valeur str = RS. Fields(0) msgbox str End Sub
Pour l'universalité, nous avons déjà abordé ici non pas le nom de la cellule, mais son index, c'est-à-dire 0, et c'est la toute première valeur de Jeu d'enregistrements, à la fin nous avons obtenu la valeur "Peut".
Comme vous pouvez le constater, tout est assez simple. Si vous avez souvent besoin d'obtenir une valeur spécifique de la base de données ( comme dans le dernier exemple), alors je recommande de sortir tout le code dans une fonction distincte (Comment écrire une fonction dans VBA Access 2003) avec un paramètre d'entrée, par exemple, le code du mois ( si l'on considère notre exemple) et simplement, là où il est nécessaire d'afficher cette valeur, appelez la fonction dont nous avons besoin avec le paramètre requis et c'est tout, en faisant cela nous réduirons considérablement le code VBA et améliorerons la perception de notre programme.
C'est tout pour aujourd'hui. Bonne chance!
Description du projet pédagogique "Boutique"Diagramme de liens de table
Description des tableaux
m_category - catégories de produits
m_revenu - entrée de marchandises
m_outcome - consommation de biens
m_product - répertoire, descriptions de produits
m_supplier - répertoire ; informations sur le fournisseur
m_unit - répertoire ; unités
Pour tester pratiquement les exemples donnés dans ce support de formation, vous devez disposer des logiciels suivants :
Microsoft Access 2003 ou plus récent.
Requête SQL dans MS Access. Commencer
Pour voir le contenu de la table, double-cliquez sur le nom de la table dans le panneau de gauche :
Pour passer en mode d'édition des champs de table, cliquez sur panneau du haut sélectionnez le mode Conception :
Pour afficher le résultat d'une requête SQL, double-cliquez sur le nom de la requête dans le volet de gauche :
Pour passer en mode d'édition de requête SQL, sélectionnez le mode SQL dans le panneau supérieur :
Requête SQL. Exemples dans MS Access. SÉLECTIONNER : 1-10
Dans une requête SQL, l'instruction SELECT est utilisée pour sélectionner parmi les tables de base de données.Requête SQL Q001. Exemple de requête SQL pour obtenir uniquement les champs requis dans l'ordre souhaité :
SELECT dt, product_id, montant
DE m_revenu ;
Requête SQL Q002. Dans cet exemple de requête SQL, le caractère astérisque (*) permet de lister toutes les colonnes de la table m_product, autrement dit, d'obtenir tous les champs de la relation m_product :
SÉLECTIONNER *
DE m_produit ;
DemandeSQL Q003. L'instruction DISTINCT est utilisée pour éliminer les entrées en double et obtenir plusieurs entrées uniques :
SELECT DISTINCT product_id
DE m_revenu ;
Requête SQL Q004. L'instruction ORDER BY est utilisée pour trier (ordonner) les enregistrements selon les valeurs d'un champ spécifique. Le nom du champ est spécifié après l'instruction ORDER BY :
SÉLECTIONNER *
DE m_revenu
COMMANDER PAR prix ;
Requête SQL Q005. L'instruction ASC est utilisée en complément de l'instruction ORDER BY et sert à spécifier un tri croissant. L'instruction DESC est utilisée en plus de l'instruction ORDER BY et permet de spécifier le tri décroissant. Dans le cas où ni ASC ni DESC ne sont spécifiés, la présence d'ASC (par défaut) est supposée :
SÉLECTIONNER *
DE m_revenu
COMMANDE PAR dt DESC , prix ;
Requête SQL Q006. Pour sélectionner les enregistrements nécessaires dans la table, diverses expressions logiques sont utilisées pour exprimer la condition de sélection. L'expression booléenne apparaît après l'instruction WHERE. Un exemple d'obtention de tous les enregistrements de la table m_ Income pour lesquels la valeur du montant est supérieure à 200 :
SÉLECTIONNER *
DE m_revenu
OÙ montant>200 ;
Requête SQL Q007. Pour s'exprimer conditions difficiles utilisez les opérateurs logiques ET (conjonction), OU (disjonction) et NON (négation logique). Un exemple d'obtention de la table m_outcome tous les enregistrements pour lesquels la valeur du montant est 20 et la valeur du prix est supérieure ou égale à 10 :
Prix
DE m_résultat
OÙ montant=20 ET prix>=10 ;
Requête SQL Q008. Pour joindre des données de deux tables ou plus, utilisez les instructions INNER JOIN, LEFT JOIN, RIGHT JOIN. L'exemple suivant récupère les champs dt, product_id, montant, prix de la table m_revenu et le champ titre de la table m_product. L'enregistrement de la table m_ Income est joint à l'enregistrement de la table m_product lorsque la valeur de m_ Income.product_id est égale à la valeur de m_product.id :
SUR m_ Income.product_id=m_product.id ;
Requête SQL Q009. Il y a deux choses à noter dans cette requête SQL : 1) le texte que vous recherchez est entouré Guillemets simples("); 2) la date est indiquée au format #Mois/Jour/Année#, ce qui est vrai pour MS Access. Dans d'autres systèmes, le format d'écriture de la date peut être différent. Un exemple d'affichage d'informations sur le reçu de lait le 12 juin 2011. Veuillez noter le format de date #6/12/2011# :
SELECT dt, product_id, titre, montant, prix
FROM m_revenu INNER JOIN m_product
WHERE title="Lait" And dt=#6/12/2011#; !}
Requête SQL Q010. L'instruction BETWEEN est utilisée pour tester si une valeur appartient à une certaine plage. Un exemple de requête SQL qui affiche des informations sur les produits reçus entre le 1er et le 30 juin 2011 :
SÉLECTIONNER *
FROM m_revenu INNER JOIN m_product
SUR m_ Income.product_id=m_product.id
OÙ dt ENTRE le #6/1/2011# et le #6/30/2011# ;
Requête SQL. Exemples dans MS Access. SÉLECTIONNER : 11-20
Une requête SQL peut être imbriquée dans une autre. Une sous-requête n’est rien de plus qu’une requête dans une requête. En règle générale, une sous-requête est utilisée dans la clause WHERE. Mais il existe d'autres façons d'utiliser les sous-requêtes.Requête Q011. Des informations sur les produits de la table m_product sont affichées, dont les codes se trouvent également dans la table m_revenu :
SÉLECTIONNER *
DE m_produit
OÙ id IN (SELECT product_id FROM m_treatment);
Requête Q012. Une liste de produits de la table m_product s'affiche dont les codes ne sont pas dans la table m_outcome :
SÉLECTIONNER *
DE m_produit
OÙ id NOT IN (SELECT product_id FROM m_outcome) ;
Demande Q013. Cette requête SQL affiche une liste unique de codes et de noms de produits qui se trouvent dans la table m_ Income mais pas dans la table m_outcome :
SELECT DISTINCT product_id, titre
FROM m_revenu INNER JOIN m_product
SUR m_ Income.product_id=m_product.id
OÙ product_id NOT IN (SELECT product_id FROM m_outcome) ;
Requête Q014. Une liste unique de catégories dont les noms commencent par la lettre M est affichée à partir de la table m_category :
SÉLECTIONNER un titre DISTINCT
DE m_produit
OÙ le titre COMME "M*" ;
Requête Q015. Un exemple d'exécution d'opérations arithmétiques sur des champs dans une requête et de renommage des champs dans une requête (alias). Cet exemple calcule dépense = quantité*prix et bénéfice pour chaque entrée de dépense d'article, en supposant que le bénéfice est de 7 % des ventes :
montant*prix/100*7 AS bénéfice
DE m_résultat ;
Requête Q016. En analysant et en simplifiant les opérations arithmétiques, vous pouvez augmenter la vitesse d'exécution des requêtes :
SELECT dt, product_id, montant, prix, montant*prix AS result_sum,
result_sum*0,07 Bénéfice AS
DE m_résultat ;
Demande Q017. Vous pouvez utiliser l'instruction INNER JOIN pour joindre des données de plusieurs tables. Dans l'exemple suivant, en fonction de la valeur de ctgry_id, chaque entrée de la table m_revenu correspond au nom de la catégorie de la table m_category à laquelle appartient le produit :
SELECT c.titre, b.titre, dt, montant, prix, montant*prix AS revenu_sum
FROM (m_revenu AS a INNER JOIN m_product AS b ON a.product_id=b.id)
INNER JOIN m_category AS c ON b.ctgry_id=c.id
COMMANDER PAR c.titre, b.titre ;
Demande Q018. Des fonctions telles que SUM - somme, COUNT - quantité, AVG - valeur moyenne arithmétique, MAX - valeur maximale, MIN - valeur minimale sont appelées fonctions d'agrégation. Ils acceptent de nombreuses valeurs et, après les avoir traitées, renvoient une seule valeur. Un exemple de calcul de la somme du produit des champs montant et prix à l'aide de la fonction d'agrégation SOMME :
SELECT SUM(montant*prix) AS Total_Sum
DE m_revenu ;
Interrogez Q019. Un exemple d'utilisation de plusieurs fonctions d'agrégation :
SELECT Somme(montant) AS Montant_Somme, AVG(montant) AS Montant_AVG,
MAX(montant) AS Montant_Max, Min(montant) AS Montant_Min,
Nombre(*) AS Total_Number
DE m_revenu ;
Demandez Q020. Dans cet exemple, le montant de toutes les marchandises de code 1, capitalisées en juin 2011, est calculé :
SELECT Somme (montant*prix) AS revenue_sum
DE m_revenu
O product_id=1 ET dt ENTRE #6/1/2011# ET #6/30/2011#;.
Interrogez Q021. La requête SQL suivante calcule le montant des ventes des articles avec le code 4 ou 6 :
SELECT Sum(montant*prix) comme result_sum
DE m_résultat
OÙ product_id=4 OU product_id=6 ;
Interrogez Q022. On calcule la quantité de biens portant le code 4 ou 6 qui ont été vendus le 12 juin 2011 :
SELECT Somme (montant*prix) AS result_sum
DE m_résultat
OÙ (product_id=4 OU product_id=6) AND dt=#6/12/2011# ;
Interrogez Q023. La tâche est la suivante. Calculez le montant total des marchandises de la catégorie « Produits de boulangerie » qui ont été capitalisées.
Pour résoudre ce problème, vous devez opérer avec trois tables : m_revenu, m_product et m_category, car :
- la quantité et le prix des biens capitalisés sont stockés dans la table m_revenu ;
- le code catégorie de chaque produit est stocké dans la table m_product ;
- le nom de la catégorie du titre est stocké dans la table m_category.
Pour résoudre ce problème nous utiliserons l’algorithme suivant :
- déterminer le code de catégorie « Produits de boulangerie » à partir de la table m_category à l'aide d'une sous-requête ;
- relier les tables m_ Income et m_product pour déterminer la catégorie de chaque produit acheté ;
- calcul du montant de la réception (= quantité*prix) pour les marchandises dont le code catégorie est égal au code défini par la sous-requête ci-dessus.
SÉLECTIONNER
FROM m_product AS a INNER JOIN m_ Income AS b ON a.id=b.product_id
WHERE ctgry_id = (SELECT id FROM m_category WHERE title="Produits de boulangerie"); !}
Interrogez Q024. Nous allons résoudre le problème du calcul du montant total des biens capitalisés dans la catégorie « Produits de boulangerie » en utilisant l'algorithme suivant :
- pour chaque entrée de la table m_member, en fonction de la valeur de son product_id, de la table m_category, faire correspondre le nom de la catégorie ;
- sélectionner les enregistrements dont la catégorie est « Produits de boulangerie » ;
- calculer le montant de la réception = quantité*prix.
FROM (m_product AS a INNER JOIN m_revenu AS b ON a.id=b.product_id)
WHERE c.title="Produits de boulangerie";
!}
Interrogez Q025. Cet exemple calcule le nombre d'articles consommés :
SELECT COUNT (product_id) AS product_cnt
FROM (SELECT DISTINCT product_id FROM m_outcome) AS t;
Interrogez Q026. L'instruction GROUP BY est utilisée pour regrouper les enregistrements. En règle générale, les enregistrements sont regroupés en fonction de la valeur d'un ou plusieurs champs, et une opération d'agrégation est appliquée à chaque groupe. Par exemple, la requête suivante génère un rapport sur la vente de marchandises. C'est-à-dire qu'un tableau est généré contenant les noms des marchandises et le montant pour lequel elles ont été vendues :
SELECT titre, SUM(montant*prix) AS result_sum
FROM m_product AS a INNER JOIN m_outcome AS b
SUR a.id=b.product_id
GROUPER PAR titre ;
Demande Q027. Rapport de ventes par catégorie. Autrement dit, un tableau est généré contenant les noms des catégories de produits, le montant total pour lequel les produits de ces catégories ont été vendus et le montant moyen des ventes. La fonction ROUND permet d'arrondir la valeur moyenne au centième le plus proche (le deuxième chiffre après le séparateur décimal) :
SELECT c.titre, SUM(montant*prix) AS result_sum,
ROUND(AVG(montant*prix),2) AS result_sum_avg
FROM (m_product AS a INNER JOIN m_outcome AS b ON a.id=b.product_id)
INNER JOIN m_category AS c ON a.ctgry_id=c.id
GROUPER PAR c.titre ;
Requête Q028. Le nombre total et moyen de ses réceptions est calculé pour chaque produit et affiche des informations sur les produits dont le total des réceptions est d'au moins 500 :
SELECT product_id, SUM(montant) AS montant_sum,
Rond(Moyenne(montant),2) AS montant_moyenne
DE m_revenu
GROUPER PAR product_id
AVOIR Somme(montant)>=500 ;
Requête Q029. Cette requête calcule pour chaque produit le montant et la moyenne de ses recettes réalisées au deuxième trimestre 2011. Si le montant total du ticket de produit est d'au moins 1 000, alors les informations sur ce produit s'affichent :
SELECT titre, SUM(montant*prix) AS revenue_sum
FROM m_revenu a INNER JOIN m_product b ON a.product_id=b.id
OÙ dt ENTRE #4/1/2011# ET #6/30/2011#
GROUPER PAR titre
AVOIR SOMME(montant*prix)>=1000 ;
Interrogez Q030. Dans certains cas, vous devez faire correspondre chaque enregistrement d'une table avec chaque enregistrement d'une autre table ; ce qu’on appelle le produit cartésien. La table résultant d'une telle connexion est appelée table de Descartes. Par exemple, si une table A contient 100 enregistrements et une table B 15 enregistrements, alors leur table Descartes sera composée de 100*15=150 enregistrements. La requête suivante joint chaque enregistrement de la table m_ Income à chaque enregistrement de la table m_outcome :
DE m_revenu, m_outcome ;
Requête Q031. Un exemple de regroupement d'enregistrements par deux champs. La requête SQL suivante calcule pour chaque fournisseur la quantité et la quantité de marchandises reçues de sa part :
SUM(montant*prix) AS revenue_sum
Demande Q032. Un exemple de regroupement d'enregistrements par deux champs. La requête suivante calcule pour chaque fournisseur la quantité et la quantité de leurs produits vendus par nous :
SELECT supplier_id, product_id, SUM(amount) AS montant_sum,
GROUP BY supplier_id, product_id ;
Requête Q033. Dans cet exemple, les deux requêtes ci-dessus (q031 et q032) sont utilisées comme sous-requêtes. Les résultats de ces requêtes utilisant la méthode LEFT JOIN sont combinés en un seul rapport. La requête suivante affiche un rapport sur la quantité et le montant des produits reçus et vendus pour chaque fournisseur. Veuillez noter que si un produit a déjà été reçu, mais n'a pas encore été vendu, la cellule result_sum pour cette entrée sera vide. que cette requête n'est qu'un exemple d'utilisation de requêtes relativement complexes comme sous-requête. Les performances de cette requête SQL avec une grande quantité de données sont discutables :
SÉLECTIONNER *
DEPUIS
SUM(montant*prix) AS revenue_sum
ON a.product_id=b.id GROUP BY supplier_id, product_id) AS a
JOINT GAUCHE
(SELECT supplier_id, product_id, SUM(montant) AS montant_sum,
SUM(montant*prix) AS result_sum
FROM m_outcome AS a INNER JOIN m_product AS b
ON a.product_id=b.id GROUP BY supplier_id, product_id) AS b
ON (a.product_id=b.product_id) ET (a.supplier_id=b.supplier_id) ;
Requête Q034. Dans cet exemple, les deux requêtes ci-dessus (q031 et q032) sont utilisées comme sous-requêtes. Les résultats de ces requêtes utilisant la méthode RIGTH JOIN sont combinés en un seul rapport. La requête suivante affiche un rapport sur le montant des paiements de chaque client en fonction des systèmes de paiement qu'il a utilisés et du montant des investissements qu'il a réalisés. La requête suivante affiche un rapport sur la quantité et le montant des produits reçus et vendus pour chaque fournisseur. Veuillez noter que si un produit a déjà été vendu, mais n'est pas encore arrivé, la cellule revenue_sum pour cette entrée sera vide. La présence de telles cellules vides est un indicateur d'une erreur dans la comptabilité des ventes, car avant une vente il faut d'abord que le produit correspondant arrive :
SÉLECTIONNER *
DEPUIS
(SELECT supplier_id, product_id, SUM(montant) AS montant_sum,
SUM(montant*prix) AS revenue_sum
FROM m_revenu AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY supplier_id, product_id) EN TANT QUE
REJOINDRE À DROITE
(SELECT supplier_id, product_id, SUM(montant) AS montant_sum,
SUM(montant*prix) AS result_sum
FROM m_outcome AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY supplier_id, product_id) AS b
ON (a.supplier_id=b.supplier_id) ET (a.product_id=b.product_id) ;
Requête Q035. Un rapport s'affiche indiquant le montant des revenus et dépenses par produit. Pour ce faire, une liste de produits est créée selon les tables m_revenu et m_outcome, puis pour chaque produit de cette liste la somme de ses revenus est calculée selon la table m_revenu et le montant de ses dépenses selon la table m_outcome :
SELECT product_id, SUM(in_amount) AS revenue_amount,
SUM(out_amount) AS result_amount
DEPUIS
(SELECT product_id, montant AS in_amount, 0 AS out_amount
DE m_revenu
UNION TOUS
SELECT product_id, 0 AS in_amount, montant AS out_amount
DE m_résultat) COMME t
GROUPE PAR product_id ;
Requête Q036. La fonction EXISTS renvoie TRUE si l'ensemble qui lui est transmis contient des éléments. La fonction EXISTS renvoie FALSE si l'ensemble qui lui est transmis est vide, c'est-à-dire qu'il ne contient aucun élément. La requête suivante affiche les codes produit contenus dans les tables m_treatment et m_outcome :
SELECT DISTINCT product_id
DE m_revenu COMME un
O EXISTE (SELECT product_id FROM m_outcome AS b
Requête Q037. Les codes de produit contenus dans les tables m_treatment et m_outcome sont affichés :
SELECT DISTINCT product_id
DE m_revenu COMME un
OÙ product_id IN (SELECT product_id FROM m_outcome)
Requête Q038. Les codes de produit affichés sont contenus dans la table m_ Income, mais ne sont pas contenus dans la table m_outcome :
SELECT DISTINCT product_id
DE m_revenu COMME un
OÙ N'EXISTE PAS (SELECT product_id FROM m_outcome AS b
OÙ b.product_id=a.product_id);
Requête Q039. Une liste de produits avec le montant maximum de vente s'affiche. L'algorithme est le suivant. Pour chaque produit, le montant de ses ventes est calculé. Ensuite, le maximum de ces montants est déterminé. Ensuite, pour chaque produit, la somme de ses ventes est à nouveau calculée, et le code et le montant des ventes des biens dont le montant des ventes est égal au maximum sont affichés :
SELECT product_id, SUM(montant*prix) AS montant_sum
DE m_résultat
GROUPER PAR product_id
AVOIR SOMME(montant*prix) = (SELECT MAX(s_montant)
FROM (SELECT SUM(montant*prix) AS s_amount FROM m_outcome GROUP BY product_id));
Interrogez Q040. Mot réservé IIF ( opérateur conditionnel) permet d'évaluer une expression booléenne et d'effectuer une action en fonction du résultat (VRAI ou FAUX). Dans l'exemple suivant, la livraison d'articles est considérée comme « petite » si la quantité est inférieure à 500. Dans le cas contraire, c'est-à-dire que la quantité reçue est supérieure ou égale à 500, la livraison est considérée comme « importante » :
SELECT dt, product_id, montant,
IIF(montant DE m_revenu;
Requête SQL Q041. Dans le cas où l'opérateur IIF est utilisé plusieurs fois, il est plus pratique de le remplacer par l'opérateur SWITCH. L'opérateur SWITCH (opérateur de sélection multiple) est utilisé pour évaluer une expression logique et effectuer une action en fonction du résultat. Dans l'exemple suivant, le lot livré est considéré comme « petit » si la quantité de marchandises dans le lot est inférieure à 500. Dans le cas contraire, c'est-à-dire si la quantité de marchandises est supérieure ou égale à 500, le lot est considéré comme « grand ». " :
SELECT dt, product_id, montant,
SWITCH (montant = 500, "grand") AS marque
DE m_revenu ;
Interrogez Q042. Lors de la demande suivante, si la quantité de marchandises dans le lot reçu est inférieure à 300, alors le lot est considéré comme « petit ». Sinon, c'est-à-dire si la condition montant SELECT dt, product_id, montant,
IIF(montant IIF(montant FROM m_revenu;
Requête SQL Q043. Lors de la demande suivante, si la quantité de marchandises dans le lot reçu est inférieure à 300, alors le lot est considéré comme « petit ». Sinon, c'est-à-dire si la condition montant SELECT dt, product_id, montant,
SWITCH(montant montant>=1000,"grand") AS marque
DE m_revenu ;
Requête SQL Q044. Dans la requête suivante, les ventes sont divisées en trois groupes : petites (jusqu'à 150), moyennes (de 150 à 300), grandes (300 ou plus). Ensuite, le montant total est calculé pour chaque groupe :
SELECT Catégorie, SUM(outcome_sum) AS Ctgry_Total
FROM (SELECT montant*prix AS result_sum,
IIf(montant*prix IIf(montant*prix FROM m_outcome) AS t
GROUPER PAR Catégorie ;
Requête SQL Q045. La fonction DateAdd permet d'ajouter des jours, des mois ou des années à une date donnée et d'obtenir une nouvelle date. Demande suivante :
1) ajoute 30 jours à la date du champ dt et affiche la nouvelle date dans le champ dt_plus_30d ;
2) ajoute 1 mois à la date du champ dt et affiche la nouvelle date dans le champ dt_plus_1m :
SELECT dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m
DE m_revenu ;
Requête SQL Q046. La fonction DateDiff est conçue pour calculer la différence entre deux dates dans des unités différentes (jours, mois ou années). La requête suivante calcule la différence entre la date dans le champ dt et la date actuelle en jours, mois et années :
SELECT dt, DateDiff("d",dt,Date()) AS dernier_jour,
DateDiff("m",dt,Date()) AS derniers_mois,
DateDiff("aaaa",dt,Date()) AS dernières années
DE m_revenu ;
Requête SQL Q047. Le nombre de jours entre la date de réception de la marchandise (table m_revenu) et la date du jour est calculé à l'aide de la fonction DateDiff et la date de péremption est comparée (table m_product) :
DateDiff("d",dt,Date()) AS derniers_jours
FROM m_revenu AS a INNER JOIN m_product AS b
SUR a.product_id=b.id;
Requête SQL Q048. Le nombre de jours entre la date de réception de la marchandise et la date du jour est calculé, puis il est vérifié si cette quantité dépasse la date de péremption :
SELECT a.id, product_id, dt, jours de vie,
DateDiff("d",dt,Date()) AS derniers_jours, IIf(derniers jours>vie,"Oui","Non") AS date_expire
FROM m_revenu a INNER JOIN m_product b
SUR a.product_id=b.id;
Requête SQL Q049. Le nombre de mois entre la date de réception de la marchandise et la date du jour est calculé. La colonne Month_last1 calcule le nombre absolu de mois, la colonne Month_last2 calcule le nombre de mois complets :
SELECT dt, DateDiff("m",dt,Date()) AS mois_dernier1,
DateDiff("m",dt,Date())-iif(jour(dt)>jour(date()),1,0) AS mois_dernier2
DE m_revenu ;
Requête SQL Q050. Un rapport trimestriel est affiché sur la quantité et le montant des biens achetés pour 2011 :
SELECT kvartal, SUM(outcome_sum) AS Total
FROM (SELECT montant*prix AS result_sum, mois(dt) AS m,
COMMUTATEUR(m =10,4) COMME kvartal
FROM m_revenu OÙ année(dt)=2011) AS t
GROUPER PAR trimestre ;
Interrogez Q051. La requête suivante permet de savoir si les utilisateurs ont pu saisir dans le système des informations sur la consommation de biens en quantité supérieure à la quantité de biens reçus :
SELECT product_id, SUM(in_sum) AS revenue_sum, SUM(out_sum) AS result_sum
FROM (SELECT product_id, montant*prix comme in_sum, 0 comme out_sum
de m_revenu
UNION TOUS
SELECT product_id, 0 comme in_sum, montant*prix comme out_sum
de m_outcome) AS t
GROUPER PAR product_id
AVOIR SOMME(in_sum)
Interrogez Q052. La numérotation des lignes renvoyées par une requête est implémentée de différentes manières. Par exemple, vous pouvez renuméroter les lignes d'un rapport préparé dans MS Access à l'aide de MS Access lui-même. Vous pouvez également renuméroter à l'aide de langages de programmation, par exemple VBA ou PHP. Cependant, cela doit parfois être fait dans la requête SQL elle-même. Ainsi, la requête suivante numérotera les lignes de la table m_ Income selon l'ordre croissant des valeurs du champ ID :
SELECT COUNT (*) comme N, b.id, b.product_id, b.amount, b.price
FROM m_revenu a INNER JOIN m_revenu b ON a.id GROUP BY b.id, b.product_id, b.amount, b.price ;
Requête Q053. Les cinq premiers produits parmi les produits par montant des ventes sont affichés. Les cinq premiers enregistrements sont imprimés à l'aide de l'instruction TOP :
SELECT TOP 5, product_id, sum(montant*prix) AS summa
DE m_résultat
GROUPER PAR product_id
ORDER BY somme(montant*prix) DESC ;
Requête Q054. Les cinq premiers produits parmi les produits par montant des ventes sont affichés et les lignes sont numérotées en conséquence :
SELECT COUNT(*) AS N, b.product_id, b.summa
DEPUIS
FROM m_outcome GROUP BY product_id) AS a
JOINTURE INTERNE
(SELECT product_id, sum(montant*prix) AS summa,
summa*10000000+product_id AS identifiant
FROM m_outcome GROUP BY product_id) AS b
SUR a.id>=b.id
GROUPER PAR b.product_id, b.summa
AVOIR COUNT(*)ORDRE PAR COUNT(*);
Requête Q055. La requête SQL suivante montre l'utilisation des fonctions mathématiques COS, SIN, TAN, SQRT, ^ et ABS dans MS Access SQL :
SELECT (sélectionnez count(*) dans m_ Income) comme N, 3,1415926 comme pi, k,
2*pi*(k-1)/N comme x, COS(x) comme COS_, SIN(x) comme SIN_, TAN(x) comme TAN_,
SQR(x) comme SQRT_, x^3 comme "x^3", ABS(x) comme ABS_
DE (SELECT COUNT(*) AS k
FROM m_revenu AS a INNER JOIN m_revenu AS b ON a.idGROUP BY b.id) t;
Requête SQL. Exemples dans MS Access. MISE À JOUR : 1-10
Requête U001. La requête de modification SQL suivante augmente de 10 % les prix des marchandises portant le code 3 dans la table m_ Income :MISE À JOUR m_revenu SET prix = prix*1.1
OÙ id_produit=3 ;
Demande U002. La requête de mise à jour SQL suivante augmente la quantité de tous les produits dans la table m_ Income de 22 unités dont les noms commencent par le mot « Pétrole » :
MISE À JOUR m_revenu SET montant = montant+22
WHERE product_id IN (SELECT id FROM m_product WHERE title LIKE "Oil*");
Demande U003. La requête SQL suivante pour une modification de la table m_outcome réduit les prix de tous les produits fabriqués par Sladkoe LLC de 2 % :
UPDATE m_outcome SET prix = prix*0,98
OÙ ID_produit DANS
(SELECT a.id FROM m_product a INNER JOIN m_supplier b
SUR a.supplier_id=b.id OÙ b.title="LLC"Сладкое"");. !}
Insérer, supprimer, mettre à jour des enregistrements dans une base de données
La méthode ExecuteReader() récupère un objet lecteur de données qui vous permet d'afficher les résultats de l'instruction SQL Select à l'aide d'un flux d'informations en lecture seule. Cependant, si vous devez exécuter des instructions SQL modifiant la table de données, vous devez alors appeler la méthode ExécuterNonQuery() de cet objetéquipes. Cette méthode unique est conçue pour effectuer des insertions, des modifications et des suppressions, en fonction du format du texte de la commande.
Concept non-requête désigne une instruction SQL qui ne renvoie pas de jeu de résultats. Ainsi, Sélectionnez les déclarations sont des requêtes, mais les instructions Insert, Update et Delete ne le sont pas. Par conséquent, la méthode ExecuteNonQuery() renvoie un entier contenant le nombre de lignes affectées par ces instructions, plutôt qu'un nouvel ensemble d'enregistrements.
Pour montrer comment modifier le contenu d'une base de données existante à l'aide uniquement de la requête ExecuteNonQuery(), l'étape suivante consiste à créer votre propre bibliothèque d'accès aux données qui encapsule le processus de base de données AutoLot.
Dans un environnement de production réel, votre logique ADO.NET sera presque certainement isolée dans un assembly .NET .dll pour une raison simple : la réutilisation du code ! Cela n’a pas été fait dans les articles précédents afin de ne pas vous distraire des tâches à accomplir. Mais ce serait une perte de temps de développer la même logique de connexion, la même logique de lecture des données et la même logique d’exécution de commandes pour chaque application devant fonctionner avec la base de données AutoLot.
En isolant la logique d'accès aux données dans une bibliothèque de code .NET, différentes applications avec n'importe quelle interface utilisateur (style console, style bureau, style Web, etc.) peuvent accéder à la bibliothèque existante, quelle que soit la langue. Et si vous développez une bibliothèque d'accès aux données en C#, d'autres programmeurs .NET pourront créer la leur Les interfaces des utilisateurs dans n'importe quel langage (par exemple, VB ou C++/CLI).
Notre bibliothèque d'accès aux données (AutoLotDAL.dll) contiendra un seul espace de noms (AutoLotConnectedLayer) qui interagira avec la base de données AutoLot à l'aide des types connectés ADO.NET.
Commencez par créer un nouveau projet de bibliothèque de classes C# appelé AutoLotDAL (abréviation de « AutoLot Data Access Layer »), puis modifiez le nom du fichier de code C# d'origine en AutoLotConnDAL.cs.
Renommez ensuite la portée de l'espace de noms en AutoLotConnectedLayer et changez le nom de la classe d'origine en InventoryDAL, car cette classe définira divers membres conçus pour interagir avec la table Inventaire de la base de données AutoLot. Enfin, importez les espaces de noms .NET suivants :
Utilisation du système ; en utilisant System.Collections.Generic ; en utilisant System.Text ; en utilisant System.Data ; en utilisant System.Data.SqlClient ; espace de noms AutoLotConnectedLayer ( classe publique InventoryDAL ( ) )
Ajout d'une logique de connexion
Notre première tâche consiste à définir des méthodes qui permettent au processus appelant de se connecter et de se déconnecter de la source de données à l'aide d'une chaîne de connexion valide. Étant donné que notre assembly AutoLotDAL.dll sera codé en dur pour utiliser les types de classe System.Data.SqlClient, définissez une variable SqlConnection privée qui sera allouée lors de la création de l'objet InventoryDAL.
De plus, définissez une méthode OpenConnection() puis une autre CloseConnection() qui interagira avec cette variable :
Classe publique InventoryDAL ( private SqlConnection connect = null; public void OpenConnection(string connectionString) ( connect = new SqlConnection(connectionString); connect.Open(); ) public void CloseConnection() ( connect.Close(); ) )
Par souci de concision, le type InventoryDAL ne vérifiera pas toutes les exceptions possibles et ne lancera pas d'exceptions personnalisées lorsque diverses situations se produisent (par exemple, lorsque la chaîne de connexion est mal formée). Cependant, si vous construisiez une bibliothèque d'accès aux données de production, vous devrez probablement utiliser des techniques structurées de gestion des exceptions pour tenir compte des anomalies pouvant survenir au moment de l'exécution.
Ajout d'une logique d'insertion
Insérer nouvelle entréeà la table Inventaire revient à formater l'instruction SQL Insérer(en fonction de l'entrée de l'utilisateur) et en appelant la méthode ExecuteNonQuery() à l'aide de l'objet de commande. Pour ce faire, ajoutez une méthode publique InsertAuto() à la classe InventoryDAL qui prend quatre paramètres correspondant aux quatre colonnes de la table Inventory (CarID, Color, Make et PetName). Sur la base de ces arguments, générez une ligne pour ajouter une nouvelle entrée. Enfin, exécutez l'instruction SQL à l'aide de l'objet SqlConnection :
Public void InsertAuto(int id, string color, string make, string petName) ( // Instruction SQL string sql = string.Format("Insérer dans l'inventaire" + "(CarID, Make, Color, PetName) Values (@CarId, @Make, @Color, @PetName)"); using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( // Ajouter des paramètres cmd.Parameters.AddWithValue("@CarId", id); cmd.Parameters.AddWithValue("@Make", make); cmd. Parameters.AddWithValue("@Color", couleur); cmd.Parameters.AddWithValue("@PetName", petName); cmd.ExecuteNonQuery(); ) )
La définition de classes qui représentent des enregistrements dans une base de données relationnelle est un moyen courant de créer une bibliothèque d'accès aux données. En fait, ADO.NET Entity Framework génère automatiquement des classes fortement typées qui vous permettent d'interagir avec les données de la base de données. À propos, la couche autonome d'ADO.NET génère des objets DataSet fortement typés pour représenter les données d'une table donnée dans une base de données relationnelle.
La création d'une instruction SQL à l'aide de la concaténation de chaînes peut constituer un risque pour la sécurité (pensez aux attaques par insertion SQL). Il est préférable de créer le texte de commande à l'aide d'une requête paramétrée, qui sera décrite un peu plus loin.
Ajout d'une logique de suppression
Suppression enregistrement existant pas plus difficile que d'insérer un nouvel enregistrement. Contrairement au code InsertAuto(), une zone try/catch importante sera affichée pour gérer la situation possible dans laquelle une tentative est faite pour supprimer une voiture que quelqu'un a déjà commandée de la table Customers. Ajoutez la méthode suivante à la classe InventoryDAL :
Public void DeleteCar(int id) ( string sql = string.Format("Supprimer de l'inventaire où CarID = "(0)"", id); using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( essayez ( cmd.ExecuteNonQuery(); ) catch (SqlException ex) ( Exception error = new Exception("Désolé, cette machine est en rupture de stock!", ex); throw error; ) ) )
Ajout d'une logique de changement
Lorsqu'il s'agit de mettre à jour un enregistrement existant dans la table Inventaire, la question évidente se pose immédiatement : qu'est-ce que le processus d'appel peut exactement être autorisé à modifier : la couleur de la voiture, le nom convivial, le modèle, ou les trois ? Une façon de maximiser la flexibilité consiste à définir une méthode qui prend un paramètre de type chaîne, qui peut contenir n'importe quelle instruction SQL, mais c'est pour le moins risqué.
Idéalement, il est préférable d'avoir un ensemble de méthodes permettant au processus appelant de modifier les enregistrements. différentes façons. Cependant, pour notre bibliothèque d'accès aux données simple, nous définirons une méthode unique qui permet au processus appelant de modifier le nom convivial de la voiture spécifiée :
Public void UpdateCarPetName(int id, string newpetName) ( string sql = string.Format("Mettre à jour l'inventaire PetName = "(0)" Où CarID = "(1)"", newpetName, id); en utilisant (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( cmd.ExecuteNonQuery(); ) )
Ajout d'une logique d'échantillonnage
Nous devons maintenant ajouter une méthode pour sélectionner les enregistrements. Comme indiqué précédemment, l'objet lecteur de données d'un fournisseur de données spécifique vous permet de sélectionner des enregistrements à l'aide d'un curseur en lecture seule. En appelant la méthode Read(), vous pouvez traiter chaque enregistrement un par un. Tout cela est très bien, mais nous devons maintenant trouver comment renvoyer ces enregistrements à la couche d'application appelante.
Une approche consisterait à récupérer les données à l'aide de la méthode Read(), puis à remplir et renvoyer un tableau multidimensionnel (ou un autre objet comme la liste générique
Une autre méthode consiste à renvoyer un objet System.Data.DataTable, qui appartient en fait à la couche ADO.NET autonome. DataTable est une classe qui représente un bloc tabulaire de données (comme un papier ou une feuille de calcul).
La classe DataTable contient des données sous forme de collection de lignes et de colonnes. Ces collections peuvent être remplies par programme, mais le type DataTable possède une méthode Load() qui peut les remplir automatiquement à l'aide d'un objet lecteur de données ! Voici un exemple dans lequel les données de la table Inventory sont renvoyées sous forme de DataTable :
DataTable publique GetAllInventoryAsDataTable() ( DataTable inv = new DataTable(); string sql = "Select * From Inventory"; using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlDataReader dr = cmd.ExecuteReader(); inv .Load(dr); dr.Close(); ) return inv; )
Travailler avec des objets de commande paramétrés
Jusqu'à présent, dans la logique d'insertion, de mise à jour et de suppression pour le type InventoryDAL, nous avons utilisé des chaînes littérales codées en dur pour chaque requête SQL. Vous connaissez probablement l'existence de requêtes paramétrées, qui vous permettent de traiter les paramètres SQL comme des objets plutôt que comme un simple morceau de texte.
Travailler avec des requêtes SQL de manière plus orientée objet permet non seulement de réduire les fautes de frappe (avec des propriétés fortement typées), mais les requêtes paramétrées sont généralement beaucoup plus rapides que les requêtes littérales de chaîne car elles ne sont analysées qu'une seule fois (plutôt qu'à chaque fois). la propriété CommandText est définie sur une chaîne SQL). De plus, les requêtes paramétrées protègent contre les attaques par injection SQL (un problème bien connu de sécurité d’accès aux données).
Pour prendre en charge les requêtes paramétrées, les objets de commande ADO.NET gèrent une collection d'objets paramètres individuels. Par défaut, cette collection est vide, mais vous pouvez ajouter n'importe quel nombre d'objets paramètres correspondant paramètres d'espace réservé dans une requête SQL. Si vous devez associer un paramètre de requête SQL à un membre de la collection de paramètres d'un objet de commande, faites précéder le paramètre SQL du symbole @ (au moins lorsque vous travaillez avec Microsoft serveur SQL, bien que tous les SGBD ne prennent pas en charge cette désignation).
Définition des paramètres à l'aide du type DbParameter
Avant de commencer à créer des requêtes paramétrées, familiarisons-nous avec le type DbParameter (la classe de base pour les objets paramètres du fournisseur). Cette classe possède un certain nombre de propriétés qui vous permettent de spécifier le nom, la taille et le type du paramètre, ainsi que d'autres caractéristiques, telles que la direction d'affichage du paramètre. Certaines propriétés importantes du type DbParameter sont indiquées ci-dessous :
Type de base de donnéesObtient ou définit le type de données d'un paramètre, représenté sous la forme d'un type CLR
DirectionRenvoie ou définit le type de paramètre : entrée uniquement, sortie uniquement, entrée et sortie, ou paramètre pour renvoyer une valeur.
EstNullableRenvoie ou définit si un paramètre peut accepter des valeurs vides
Le nom du paramètreObtient ou définit le nom DbParameter
TailleProblèmes ou installations taille maximum données pour le paramètre (utile pour les données texte uniquement)
ValeurRenvoie ou définit la valeur d'un paramètre
Pour montrer comment remplir une collection d'objets de commande avec des objets compatibles DBParameter, réécrivons la méthode InsertAuto() afin qu'elle utilise des objets paramètres (toutes les autres méthodes peuvent être recréées de la même manière, mais le présent exemple nous suffira) :
Public void InsertAuto(int id, string color, string make, string petName) ( // Instruction SQL string sql = string.Format("Insert Into Inventory" + "(CarID, Make, Color, PetName) Values("(0) ","(1)","(2)","(3)")", id, make, color, petName); // Commande paramétrée utilisant (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlParameter param = new SqlParameter(); param.ParameterName = "@CarID"; param.Value = id; param.SqlDbType = SqlDbType.Int; cmd.Parameters.Add(param); param = new SqlParameter(); param. ParameterName = "@Make"; param.Value = make; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@Color "; param.Value = couleur; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@PetName"; param.Value = petName ; param.SqlDbType = SqlDbType.Char ; param.Size = 10 ; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); ) )
Notez que la requête SQL contient également quatre caractères fictifs, chacun précédé d'un symbole @. À l'aide de la propriété ParameterName sur le type SqlParameter, vous pouvez décrire chacun de ces espaces réservés et spécifier diverses informations (valeur, type de données, taille, etc.) de manière fortement typée. Une fois que tous les objets paramètres sont préparés, ils sont ajoutés à la collection d’objets de commande à l’aide de l’appel Add().
Diverses propriétés sont utilisées ici pour concevoir des objets paramètres. Notez cependant que les objets paramètres prennent en charge un certain nombre de constructeurs surchargés qui vous permettent de définir les valeurs de diverses propriétés (ce qui se traduit par une base de code plus compacte). Notez également que Visual Studio 2010 dispose de divers concepteurs graphiques qui généreront automatiquement pour vous une grande partie de ce code fastidieux de manipulation de paramètres.
La création d'une requête paramétrée entraîne souvent plus de code, mais le résultat est un moyen plus pratique d'ajuster par programmation les instructions SQL, ainsi que de meilleures performances. Cette technique peut être utilisée pour n'importe quelle requête SQL, bien que les requêtes paramétrées soient plus utiles si vous devez exécuter des procédures stockées.
Règles crochets représente [partie facultative] d'une construction. Une barre verticale indique un choix entre des options (var1|var2). Les points de suspension signifient une répétition possible plusieurs fois - 1 fois, 2 fois [, …]
Instruction SELECT
Demande au moteur de base de données Microsoft Access de renvoyer les informations de la base de données sous la forme d'un ensemble d'enregistrements.
Syntaxe
SÉLECTIONNER [ prédicat] { * | tableau.* | [tableau.]champ1
[, [tableau.]champ2 [, ...]]}
DEPUIS expression_table [, ...]
L'instruction SELECT comprend les éléments suivants.
Élément | Description |
Prédicat | L'un des prédicats suivants : ALL, DISTINCT, DISTINCTROW ou TOP. Les prédicats sont utilisés pour limiter le nombre d'enregistrements renvoyés. Si aucun prédicat n’est donné, la valeur par défaut est ALL. |
Indique que tous les champs sont sélectionnés dans la ou les tables spécifiées |
|
Tableau | Le nom de la table dans laquelle les champs sont sélectionnés |
champ1, champ2 | Les noms des champs contenant les données à récupérer. Si plusieurs champs sont spécifiés, les données seront récupérées dans l'ordre dans lequel leurs noms sont répertoriés |
pseudo1, pseudo2 | Noms utilisés comme en-têtes de colonnes au lieu des noms de colonnes d'origine les tables |
expression_table | Un ou plusieurs noms de table contenant les données à récupérer. |
base_de_données_externe | Le nom de la base de données contenant les tables spécifiées dans le composant expression_table s'ils ne sont pas dans la base de données actuelle |
Remarques
Pour effectuer cette opération, le moteur de base de données Microsoft Access recherche la ou les tables spécifiées, récupère les colonnes souhaitées, sélectionne les lignes qui répondent aux conditions spécifiées et trie ou regroupe les lignes résultantes dans l'ordre spécifié.
Les instructions SELECT ne modifient pas les données de la base de données.
L'instruction SELECT est généralement le premier mot de l'instruction SQL (instruction SQL (chaîne). Expression qui définit Commande SQL, comme SELECT, UPDATE ou DELETE, et incluant des clauses telles que WHERE ou ORDER BY. Les instructions/chaînes SQL sont couramment utilisées dans les requêtes et les fonctions statistiques.) La plupart des instructions SQL sont soit des instructions SELECT, soit des instructions SELECT...INTO.
La syntaxe minimale d'une instruction SELECT est la suivante :
SÉLECTIONNER des champs DEPUIS tableau
Vous pouvez utiliser un astérisque (*) pour sélectionner tous les champs d'un tableau. L'exemple suivant sélectionne tous les champs de la table Employés.
SELECT * FROM Employés ;
Si le nom du champ est inclus dans plusieurs tables de la clause FROM, faites-le précéder du nom de la table et de l'instruction «.» (point). Dans l'exemple suivant, le champ « Département » est présent dans les tables « Employés » et « Superviseurs ». L'instruction SQL sélectionne les services dans la table Employés et les noms des superviseurs dans la table Superviseurs.
SÉLECTIONNEZ les employés. Chefs de département. Nom du dirigeant FROM Employés INNER JOIN Dirigeants OÙ Employés. Département = Gestionnaires. Département;
Lorsque vous créez un objet RecordSet, le nom du champ de la table est utilisé par le moteur de base de données Microsoft Access comme nom de l'objet « Field » dans l'objet Ensemble d'enregistrements. Si le nom du champ doit être modifié ou n'est pas fourni par l'expression qui génère le champ, utilisez un mot réservé (Mot réservé. Un mot qui est un élément d'un langage, tel que Visual Basic. Les mots réservés incluent les noms d'instructions, fonctions et types de données intégrés, méthodes, opérateurs et objets.) AS. L'exemple suivant montre comment l'en-tête "Day" est utilisé pour nommer l'objet renvoyé Champ dans l'objet reçu Ensemble d'enregistrements.
SELECT Anniversaire AS Jour FROM Employés ;
Lorsque vous travaillez avec des fonctions d'agrégation ou des requêtes qui renvoient des noms d'objet ambigus ou identiques Champ, vous devez utiliser la clause AS pour créer un nom d'objet différent Champ. Dans l'exemple suivant, l'objet renvoyé Champ dans l'objet reçu Ensemble d'enregistrements reçoit le nom de « Recensement ».
SELECT COUNT(EmployeeCode) AS Recensement FROM Employés ;
Lorsque vous travaillez avec une instruction SELECT, vous pouvez utiliser des clauses supplémentaires pour restreindre et organiser davantage les données récupérées. Pour plus d’informations, consultez la rubrique d’aide de l’offre que vous utilisez.
Clause DE
Spécifie les tables et les requêtes qui contiennent les champs répertoriés dans l'instruction SELECT.
Syntaxe
SÉLECTIONNER liste de champ
DEPUIS expression_table
Une instruction SELECT contenant une clause FROM comprend les éléments suivants :
Élément | Description |
liste de champ | |
expression_table | Une expression définissant une ou plusieurs tables - sources de données. L'expression peut être un nom de table, un nom de requête stocké ou une expression de résultat construite à l'aide d'un opérateur INNER JOIN, LEFT JOIN ou RIGHT JOIN. |
base_de_données_externe | Le chemin complet vers la base de données externe contenant toutes les tables spécifiées dans expression_table |
Remarques
La présence d'une clause FROM après une instruction SELECT est requise.
L'ordre dans lequel les tables sont répertoriées dans expression_tableça n'a pas d'importance.
Utilisation de tables liées (Table liée. Table enregistrée dans un fichier qui ne fait pas partie de la base de données ouverte mais accessible à partir de Microsoft Access. L'utilisateur peut ajouter, supprimer et modifier des enregistrements dans la table liée, mais ne peut pas modifier sa structure. .) au lieu de la clause IN, vous pouvez rendre le processus de récupération de données à partir d'une base de données externe plus facile et plus efficace.
L'exemple ci-dessous montre comment récupérer les données de la table Employés.
SELECT Nom, Prénom
DES Employés ;
Indique les enregistrements sélectionnés pour les requêtes SQL ( Langage SQL(Langage de requêtes structurées). Un langage de programmation de requêtes et de bases de données structurées largement utilisé pour accéder, interroger, mettre à jour et gérer des données dans des SGBD relationnels.
Syntaxe
SÉLECTIONNER ]]
DEPUIS tableau
L'instruction SELECT contenant ces prédicats comprend les composants suivants :
Composant | Description |
Implicite si aucun prédicat n’est inclus. Le moteur de base de données Microsoft Access sélectionne tous les enregistrements qui correspondent aux conditions d'une instruction SQL (instruction SQL (chaîne). Expression qui définit une commande SQL, telle que SELECT, UPDATE ou DELETE, et inclut des clauses, telles que WHERE ou ORDER BY. Les instructions/chaînes SQL sont généralement utilisées dans les requêtes et les fonctions statistiques). Les deux exemples identiques suivants montrent comment renvoyer tous les enregistrements de la table Employees. DES Employés COMMANDER PAR EmployeeCode ; DES Employés COMMANDER PAR EmployeeCode ; |
|
Exclut les enregistrements contenant des données en double dans les champs sélectionnés. Seules les valeurs uniques de chacun des champs répertoriés dans l'instruction SELECT sont incluses dans les résultats de la requête. Par exemple, certains employés répertoriés dans la table Employés peuvent avoir le même nom de famille. Si deux enregistrements contiennent le nom de famille « Ivanov » dans le champ Nom de famille, l'instruction SQL suivante renvoie un seul enregistrement contenant le nom de famille « Ivanov ». SELECTIONNER UN NOM DISTINCT Si le composant DISTINCT est omis, la requête renvoie les deux enregistrements portant le nom de famille « Ivanov ». Si la clause SELECT contient plusieurs champs, la combinaison de toutes les valeurs de champ n'est incluse dans les résultats de la requête que si elle est unique pour cet enregistrement. Les résultats d'une requête qui utilise le composant DISTINCT ne sont pas mis à jour pour refléter les modifications ultérieures apportées par d'autres utilisateurs. |
|
Exclut les données des enregistrements qui sont répétés dans leur intégralité plutôt que de contenir des champs individuels contenant les mêmes données. Supposons qu'une requête ait été créée qui connecte les tables « Clients » et « Commandes » à l'aide du champ « Code client ». La table Clients ne contient pas de champs ID client en double, mais ils existent dans la table Commandes car chaque client peut avoir plusieurs commandes. L'instruction SQL suivante montre comment utiliser le composant DISTINCTROW pour répertorier les organisations qui ont passé au moins une commande, sans mentionner les détails de ces commandes. SELECT DISTINCTROW Titre FROM Clients INNER JOIN Commandes Sur les clients. CustomerId = Commandes. Code client COMMANDER PAR Titre ; Si le composant DISTINCTROW est omis, la requête génère plusieurs lignes pour chaque organisation ayant commandé plusieurs fois. Le composant DISTINCTROW ne prend effet que lors de la sélection de champs dans certaines des tables utilisées dans la requête. Le composant DISTINCTROW est ignoré si la requête inclut une seule table ou si les champs sont récupérés de toutes les tables. |
|
HAUT n | Renvoie le nombre spécifié d'enregistrements qui figurent parmi les premiers ou les derniers enregistrements de la plage spécifiée par la clause ORDER BY. Supposons que vous souhaitiez afficher les noms des 25 meilleurs élèves de la promotion 1994. Prénom nom de famille OÙ Année d'obtention du diplôme = 2003 COMMANDER PAR GradePointAverage DESC ; Si vous n'incluez pas la clause ORDER BY, la requête renverra un ensemble aléatoire de 25 enregistrements de la table Students qui satisfait à la clause WHERE. Le prédicat TOP n'implique pas de choix entre des valeurs égales. Si les 25e et 26e enregistrements de l’exemple précédent avaient le même GPA, la requête renverrait 26 enregistrements. Vous pouvez également utiliser le mot réservé PERCENT pour récupérer un certain pourcentage du premier ou du dernier enregistrement dans la plage spécifiée par la clause ORDER BY. Supposons qu'au lieu des 25 meilleurs, vous souhaitiez afficher les 10 % d'étudiants les plus pauvres de la promotion. SÉLECTIONNER LES 10 POUR CENT SUPÉRIEURS Prénom nom de famille OÙ Année d'obtention du diplôme = 2003 COMMANDER PAR GradePointAverage ASC ; Le prédicat ASC spécifie la sortie des valeurs de la partie inférieure de la plage. La valeur qui suit le prédicat TOP doit être un type de données Integer. Type de données de base utilisé pour stocker des valeurs entières. Une variable Integer est stockée sous la forme d'un nombre de 64 bits (8 octets) compris entre -32 768 et 32 767. ) non signé . Le prédicat TOP n'affecte pas si la requête peut être mise à jour. |
tableau | Le nom de la table à partir de laquelle les enregistrements sont récupérés. |
voir également
Instruction SELECT
Clause DE
Clause OÙ
Détermine quels enregistrements des tables répertoriées dans la clause FROM sont traités par les instructions SELECT, UPDATE ou DELETE.
Syntaxe
SÉLECTIONNER liste de champ
DEPUIS expression_table
OÙ conditions_de_sélection
Une instruction SELECT contenant une clause WHERE comprend les parties suivantes.
Partie | Description |
liste de champ | Le nom du ou des champs récupérés avec les alias (Alias (SQL). Un nom alternatif pour une table ou un champ dans une expression. Les alias sont généralement utilisés comme noms de table ou de champ plus courts pour faciliter la référence ultérieure dans programmes, pour éviter les références ambiguës et pour obtenir des noms plus descriptifs lors de l'affichage des résultats de requête.), des prédicats (ALL, DISTINCT, DISTINCTROW ou TOP) ou avec tout autre paramètre de l'instruction SELECT. |
expression_table | Le nom de la ou des tables à partir desquelles les données sont récupérées. |
conditions_de_sélection | Expression (Expression. Une combinaison d'opérateurs mathématiques et logiques, de constantes, de fonctions, de noms de champs, de contrôles et de propriétés qui aboutissent à une valeur unique. L'expression peut effectuer des calculs, traiter du texte ou valider des données.) qui doit correspondre aux enregistrements inclus. dans les résultats de la requête. |
Remarques
Le moteur de base de données Microsoft Access sélectionne les enregistrements qui répondent aux conditions répertoriées dans la clause WHERE. Si la clause WHERE n'est pas spécifiée, la requête renvoie toutes les lignes de la table. Si une requête spécifie plusieurs tables mais ne spécifie pas de clause WHERE ou JOIN, la requête produit un produit cartésien (produit cartésien. Est le résultat de l'exécution d'une instruction SQL SELECT qui a une clause FROM qui fait référence à deux tables ou plus et aucun WHERE ou Clause JOIN qui spécifie la méthode de jointure.) des tables.
La clause WHERE n'est pas obligatoire, mais si elle est utilisée, elle doit suivre la clause FROM. Par exemple, vous pouvez sélectionner tous les employés du service commercial (WHERE Department = "Sales") ou tous les clients âgés de 18 à 30 ans (WHERE Age Between 18 And 30).
Si une clause JOIN n'est pas utilisée pour une opération de jointure SQL sur plusieurs tables, l'objet résultant Ensemble de records il sera impossible de mettre à jour.
La clause WHERE est similaire à la clause HAVING et spécifie les enregistrements sélectionnés. Une fois les enregistrements regroupés par la clause GROUP BY, la clause HAVING détermine également l'enregistrement à afficher.
La clause WHERE est utilisée pour exclure les enregistrements qui n'ont pas besoin d'être regroupés à l'aide de la clause GROUP BY.
Utilisez diverses expressions pour déterminer quels enregistrements sont renvoyés par l'instruction SQL. Par exemple, l'instruction SQL suivante sélectionne tous les employés dont le salaire dépasse RUR.
SELECT Nom de famille, Salaire FROM Employés WHERE Salaire > 21 000 ;
La clause WHERE peut contenir jusqu'à 40 expressions connectées par des opérateurs logiques (par exemple, ET Et OU).
Si vous saisissez un nom de champ contenant des espaces ou des signes de ponctuation, vous devez le mettre entre crochets (). Par exemple, un tableau de détails client peut contenir des informations sur des clients spécifiques.
SELECT [Restaurant préféré du client]
Spécifier un argument conditions_de_sélection, les littéraux de date (littéral de date. Toute séquence de caractères dans un format valide, entourée de signes dièse (#). Les formats valides sont le format de date spécifié dans les paramètres Langue et Normes et le format de date universel.) doivent être représentés au format américain. , même si un format de date non américain est utilisé. version du moteur de base de données Microsoft Access. Par exemple, la date « 10 mai 1996 » s'écrit 10/5/96 au Royaume-Uni et 05/10/1996 en Russie. N'oubliez pas de placer les littéraux de date entre des signes dièse (#), comme indiqué dans les exemples ci-dessous.
Pour rechercher les enregistrements du 10 mai 1996 dans la base de données britannique, utilisez l'instruction SQL suivante :
SELECT * FROM Commandes WHERE Date d'expédition = #10.05.1996# ;
Vous pouvez également utiliser la fonction ValeurDate, reconnaissant les paramètres internationaux, installé par Microsoft Windows®. Par exemple, pour la Russie, utilisez ce code :
SELECT * FROM Commandes WHERE Date d'expédition = DateValue("05/10/1996");
Et le code suivant concerne le Royaume-Uni :
SELECT * FROM Commandes WHERE Date d'expédition = DateValue("10/5/96");
Note. Si la colonne spécifiée dans la ligne des critères de sélection est de type GUID (ID de réplica (GUID). Champ de 16 octets dans une base de données Microsoft Access utilisé pour identifier de manière unique la réplication. Les GUID sont utilisés pour identifier les réplicas, les jeux de réplicas, les tables, les enregistrements et autres objets. Dans les bases de données Microsoft Access, les codes GUID sont appelés codes de réplique.), les conditions de sélection utilisent une syntaxe légèrement différente.
OÙ ID de réplica = (GUID (AB-CDEF0ABCDEF))
Assurez-vous que les parenthèses et les traits d’union imbriqués sont correctement positionnés.
Page source : http://office. /ru-ru/access/HA.aspx? pid=CH
Clause GROUPE PAR
Combine les enregistrements avec les mêmes valeurs que celles de la liste de champs spécifiée en un seul enregistrement. Une valeur récapitulative est créée pour chaque enregistrement si une fonction d'agrégation SQL est incluse dans l'instruction SELECT, telle que Somme ou Compter.
Syntaxe
SÉLECTIONNER liste de champ
DEPUIS tableau
OÙ condition_sélection
Une instruction SELECT contenant une clause GROUP BY comprend les éléments suivants :
Élément | Description |
liste de champ | Les noms des champs qui sont récupérés avec tous les alias (Alias (SQL). Un nom alternatif pour une table ou un champ dans une expression. Les alias sont généralement utilisés comme noms de table ou de champ plus courts pour faciliter la référence ultérieure dans les programmes, pour éviter les références ambiguës et pour obtenir des noms plus informatifs lors de l'affichage des résultats de la requête.) et des statistiques Fonctions SQL, prédicats (ALL, DISTINCT, DISTINCTROW ou TOP) ou autres paramètres de l'instruction SELECT |
tableau | |
conditions_de_sélection | Condition de sélection. Si l'instruction contient une clause WHERE, une fois appliquée aux enregistrements, les valeurs seront regroupées par le moteur de base de données Microsoft Access. |
liste_champ_groupe | liste_champ_groupe |
Remarques
La clause GROUP BY est facultative.
Si les fonctions statistiques SQL ne sont pas incluses dans l'instruction SELECT, les valeurs récapitulatives ne sont pas calculées.
GROUP BY valeurs de champ qui sont Null (Null. Une valeur qui peut être saisie dans un champ ou utilisée dans des expressions et des requêtes pour indiquer des données manquantes ou inconnues. Dans Visual Basic, le mot clé Null spécifie une valeur Null. Certains champs, tels que en tant que champs de clé primaire, ne peuvent pas contenir de valeurs Null.), sont regroupés et ne sont pas omis. Cependant, les valeurs Nul ne sont évalués par aucune des fonctions statistiques SQL.
La clause WHERE est utilisée pour exclure les lignes qui n'ont pas besoin d'être regroupées. La clause HAVING est utilisée pour filtrer les enregistrements après le regroupement.
Champs de la liste de champs GROUP BY qui ne contiennent pas de type de données Mémo (type de données Champ Mémo. Un type de données de champ dans une base de données Microsoft Access. Un champ MÉMO peut contenir jusqu'à 65 535 caractères.) ou un objet OLE (type de données Champ). Objet OLE" Un type de données de champ utilisé pour enregistrer des objets provenant d'autres applications liées ou incorporées dans une base de données Microsoft Access.) peut référencer n'importe quel champ de n'importe quelle table spécifiée dans la clause FROM, même si le champ n'est pas inclus dans l'instruction SELECT. Pour ce faire, il suffit d'avoir au moins une fonction statistique SQL dans l'instruction SELECT. Le moteur de base de données Microsoft Access ne permet pas le regroupement par champs contenant des données de champ MEMO ou d'objet OLE.
Tous les champs de la liste de champs SELECT doivent être contenus dans une clause GROUP BY ou être des arguments d'une fonction d'agrégation SQL.
voir également
Instruction SELECT
Instruction SELECT...INTO
Prédicats ALL, DISTINCT, DISTINCTROW, TOP
Clause DE
AVOIR une offre
Clause ORDER BY
Clause OÙ
Fonctions statistiques SQL
Page source : http://office. /ru-ru/access/HA.aspx? pid=CH
AVOIR une offre
Définit les enregistrements groupés qui doivent apparaître dans une instruction SELECT avec une clause GROUP BY. Une fois les enregistrements regroupés par la clause GROUP BY, la clause HAVING affichera ceux qui remplissent ses conditions.
Syntaxe
SÉLECTIONNER liste de champ
DEPUIS tableau
OÙ conditions_de_sélection
PAR GROUPE liste_champ_groupe
Une instruction SELECT contenant une clause HAVING comprend les éléments suivants :
Élément | Description |
liste de champ | Les noms des champs chargés avec les alias (Alias (SQL). Un nom alternatif pour une table ou un champ dans une expression. Les alias sont généralement utilisés comme noms de table ou de champ plus courts pour faciliter la référence ultérieure dans les programmes, pour éviter les références ambiguës et pour obtenir des noms plus informatifs lors de l'affichage des résultats de requête.) et des fonctions statistiques SQL, des prédicats (ALL, DISTINCT, DISTINCTROW ou TOP) ou avec d'autres paramètres de l'instruction SELECT. |
tableau | Nom de la table à partir de laquelle les enregistrements sont chargés |
condition_sélection | Condition de sélection. Si l'instruction contient une clause WHERE, le moteur de base de données Microsoft Access regroupera les valeurs après son application aux enregistrements. |
liste_champ_groupe | Noms des champs (jusqu'à 10) utilisés pour regrouper les enregistrements. L'ordre des noms dans liste_champ_groupe détermine le niveau de regroupement - du plus élevé au plus bas |
condition_groupe | Une expression qui spécifie les enregistrements à afficher |
Remarques
La clause HAVING est facultative.
La clause HAVING est similaire à la clause WHERE qui détermine la sélection des enregistrements. Après avoir regroupé les enregistrements avec la clause GROUP BY, la clause HAVING détermine les enregistrements à afficher.
SELECT TypeCode,
Somme (en stock)
DE Produits
GROUPER PAR TypeCode
HAVING Sum(InStock) > 100 Et comme "TEL*" ;
La clause HAVING peut contenir jusqu'à 40 expressions liées par des opérateurs logiques tels que Et Et Ou.
Page source : http://office. /ru-ru/access/HA.aspx? pid=CH
Clause ORDER BY
Trie les enregistrements renvoyés par la requête par ordre croissant ou décroissant des valeurs du ou des champs spécifiés.
Syntaxe
SÉLECTIONNER liste de champ
DEPUIS tableau
OÙ condition_sélection
[, champ2 ][, ...]]]
Une instruction SELECT qui contient une clause ORDER BY comprend les éléments suivants.
Élément | Description |
liste de champ | Les noms des champs qui sont récupérés avec tous les alias (Alias (SQL). Un nom alternatif pour une table ou un champ dans une expression. Les alias sont généralement utilisés comme noms de table ou de champ plus courts pour faciliter la référence ultérieure dans les programmes, pour éviter les références ambiguës et pour obtenir des noms plus informatifs lors de l'affichage des résultats de requête.) et des fonctions statistiques SQL, des prédicats (ALL, DISTINCT, DISTINCTROW ou TOP) ou avec d'autres paramètres de l'instruction SELECT. |
tableau | Nom de la table à partir de laquelle les enregistrements sont récupérés |
conditions_de_sélection | Conditions de sélection. Si l'instruction contient une clause WHERE, une fois appliquée aux enregistrements, le moteur de base de données Microsoft Access ordonnera les valeurs des enregistrements |
champ1, champ2 | Noms des champs selon lesquels les enregistrements sont triés. |
Remarques
La clause ORDER BY est facultative. Il doit être utilisé lorsque vous devez afficher des données sous forme triée.
L'ordre de tri par défaut est (Ordre de tri. Un moyen d'organiser les données en fonction de leurs valeurs et de leur type. Les données peuvent être triées par ordre alphabétique, par valeurs numériques ou par date. L'ordre de tri peut être croissant (0 à 100, A à Z) ou descendant (de 100 à 0, de Z à A).) ascendant (de A à Z, de 0 à 9). Les exemples ci-dessous illustrent le tri des noms d'employés par nom de famille.
SELECT Nom, Prénom
DES Employés
COMMANDER PAR Nom de famille ;
SELECT Nom, Prénom
DES Employés
COMMANDER PAR Nom de famille ASC ;
Pour trier les champs par ordre décroissant (Z à A, 9 à 0), ajoutez le mot réservé DESC au nom de chaque champ. L'exemple suivant illustre le tri par ordre décroissant en fonction des salaires des employés.
SELECT Nom, Salaire
DES Employés
ORDRE PAR Salaire DESC, Nom de famille ;
Si vous spécifiez des champs dans la clause ORDER BY qui contiennent des données de type Champ MEMO (type de données Champ mémo. Un type de données de champ dans une base de données Microsoft Access. Un champ MEMO peut contenir jusqu'à 65 535 caractères.) ou Champ d'objet OLE (Objet OLE Type de données de champ "Un type de données de champ utilisé pour enregistrer des objets provenant d'autres applications liées ou intégrées dans une base de données Microsoft Access.), cela générera une erreur. Le moteur de base de données Microsoft Access ne peut pas trier ces types de champs.
La clause ORDER BY est généralement la dernière clause d'une instruction SQL (instruction SQL (chaîne). Expression qui définit une commande SQL, telle que SELECT, UPDATE ou DELETE, et inclut des clauses, telles que WHERE ou ORDER BY. Instructions SQL /strings sont couramment utilisés dans les requêtes et les fonctions statistiques.).
Vous pouvez inclure des champs supplémentaires dans la clause ORDER BY. Les enregistrements sont d'abord triés selon le champ spécifié en premier dans la clause ORDER BY. Les enregistrements ayant les mêmes valeurs dans le premier champ sont ensuite triés selon le champ spécifié par le second, et ainsi de suite.
voir également
Instruction SELECT
Instruction SELECT...INTO
Prédicats ALL, DISTINCT, DISTINCTROW, TOP
Clause DE
Clause GROUPE PAR
AVOIR une offre
Clause OÙ
Fonctions statistiques SQL
Page source : http://office. /ru-ru/access/HA.aspx? pid=CH
Opération de jointure interne
Joint les enregistrements de deux tables si les champs de connexion de ces tables contiennent les mêmes valeurs.
Syntaxe
DEPUIS Tableau 1 JOINTURE INTERNE Tableau 2 SUR Tableau 1.champ1 table_opérateur_comparaison2.champ2
L’opération INNER JOIN se compose des éléments suivants :
Élément | Description |
Tableau 1, Tableau 2 | Noms des tables contenant les enregistrements à joindre |
champ1, champ2 | Noms des champs à lier. Les champs non numériques doivent être du même type de données (Type de données. Caractéristique de champ qui définit le type de données que le champ peut contenir. Les types de données incluent : Booléen, Entier, Long, Devise, Simple, Double, Date, Chaîne, et Variant (par défaut).) et contiennent des données du même type. Cependant, les noms de ces champs peuvent être différents |
opérateur_de comparaison | Tout opérateur de comparaison : (=,<, >, <=, >= ou<>) |
