A propos de ce cours

Ce cours est conçu pour familiariser les étudiants avec Transact-SQL. Il est conçu de manière à ce que les trois premiers jours puissent être enseignés sous forme de cours aux étudiants ayant besoin de connaissances pour d’autres cours du curriculum de SQL Server. Les jours 4 et 5 enseignent les compétences restantes nécessaires pour passer l’examen 70-761.

Profil du public

L’objectif principal du cours est de donner aux étudiants une bonne compréhension du langage Transact-SQL utilisé par toutes les disciplines liées à SQL Server. à savoir, l’administration de bases de données, le développement de bases de données et l’intelligence d’affaires. En tant que tel, le public cible principal de ce cours est le suivant: administrateurs de bases de données, développeurs de bases de données et professionnels de la veille économique.

A l’issue de ce cours, les étudiants seront capables de:

  • Décrire les fonctionnalités et composants clés de SQL Server.
  • Décrire T-SQL, les ensembles et la logique des prédicats.
  • Écrivez une seule instruction SELECT dans la table.
  • Écrivez une instruction SELECT multi-table.
  • Écrire des instructions SELECT avec filtrage et tri.
  • Décrivez comment SQL Server utilise les types de données.
  • Ecrire des déclarations DML.
  • Écrire des requêtes qui utilisent des fonctions intégrées.
  • Écrire des requêtes qui agrègent des données.
  • Ecrire des sous-requêtes.
  • Créer et implémenter des vues et des fonctions table.
  • Utilisez les opérateurs de jeu pour combiner les résultats de la requête.
  • Écrivez des requêtes qui utilisent les fonctions de classement, d’offset et d’agrégation de fenêtre.
  • Transformez les données en implémentant pivot, unpivot, rollup et cube.
  • Créer et implémenter des procédures stockées.
  • Ajouter des constructions de programmation telles que des variables, des conditions et des boucles au code T-SQL

Module 1: Introduction à Microsoft SQL Server:

Ce module présente SQL Server, les versions de SQL Server, y compris les versions cloud, et explique comment se connecter à SQL Server à l’aide de SQL Server Management Studio.

Cours:

  • L’architecture de base de SQL Server
  • Editions et versions de SQL Server
  • Premiers pas avec SQL Server Management Studio

Atelier: Utilisation des outils SQL Server

  • Travailler avec SQL Server Management Studio
  • Création et organisation de scripts T-SQL
  • Utilisation de la documentation en ligne

Après avoir terminé ce module, vous pourrez:

  • Décrire les bases de données relationnelles et les requêtes Transact-SQL.
  • Décrivez les éditions et les versions sur site et dans le cloud de SQL Server.
  • Décrire comment utiliser SQL Server Management Studio (SSMS) pour se connecter à une instance de SQL Server, explorer les bases de données contenues dans l’instance et utiliser des fichiers de script contenant des requêtes T-SQL.

Module 2: Introduction à la requête T-SQL

Ce module décrit les éléments de T-SQL et leur rôle dans la rédaction de requêtes. Décrire l’utilisation des ensembles dans SQL Server. Décrire l’utilisation de la logique de prédicat dans SQL Server. Décrire l’ordre logique des opérations dans les instructions SELECT.

Cours:

  • Présentation de T-SQL
  • Comprendre les ensembles
  • Comprendre la logique des prédicats
  • Compréhension de l’ordre logique des opérations dans les instructions SELECT

Atelier: Introduction à la requête T-SQL

  • Exécution d’instructions SELECT de base
  • Exécution de requêtes filtrant les données à l’aide de prédicats
  • Exécution de requêtes qui trient des données à l’aide de ORDER BY

Après avoir terminé ce module, vous pourrez:

  • Décrire le rôle de T-SQL dans l’écriture des instructions SELECT.
  • Décrire les éléments du langage T-SQL et quels éléments seront utiles pour la rédaction de requêtes.
  • Décrire les concepts de la théorie des ensembles, l’un des fondements mathématiques des bases de données relationnelles, et vous aider à l’appliquer à la façon dont vous envisagez d’interroger SQL Server.
  • Décrire la logique du prédicat et examiner son application pour interroger SQL Server.
  • Expliquer les éléments d’une instruction SELECT, définir l’ordre dans lequel les éléments sont évalués, puis appliquer cette compréhension à une approche pratique de l’écriture de requêtes.

Module 3: Écrire des requêtes SELECT

Ce module présente les principes de base de l’instruction SELECT, en se concentrant sur les requêtes sur une seule table.

Cours:

  • Écrire des instructions SELECT simples
  • Éliminer les doublons avec DISTINCT
  • Utilisation d’alias de colonnes et de tables
  • Écrire des expressions CASE simples

Atelier: Écriture d’instructions SELECT de base

  • Écrire des instructions SELECT simples
  • Éliminer les doublons avec DISTINCT
  • Utilisation d’alias de colonnes et de tables
  • Utiliser une expression CASE simple

Après avoir terminé ce module, vous pourrez:

  • Décrire la structure et le format de l’instruction SELECT, ainsi que les améliorations permettant d’ajouter des fonctionnalités et de la lisibilité à vos requêtes.
  • Décrire comment éliminer les doublons à l’aide de la clause DISTINCT
  • Décrire l’utilisation des alias de colonnes et de tables
  • Comprendre et utiliser les expressions CASE

Module 4: Interrogation de plusieurs tables

Ce module explique comment écrire des requêtes combinant des données provenant de plusieurs sources dans Microsoft SQL Server.

Cours:

  • Comprendre les jointures
  • Interrogation avec des jointures internes
  • Interrogation avec des jointures externes
  • Interroger avec Cross Joins et Self Joins

Laboratoire: Interrogation de plusieurs tables

  • Rédaction de requêtes utilisant des jointures internes
  • Écrire des requêtes qui utilisent des jointures internes à plusieurs tables
  • Écrire des requêtes qui utilisent des auto-jointures
  • Rédaction de requêtes utilisant des jointures externes
  • Écrire des requêtes qui utilisent des jointures croisées

Après avoir terminé ce module, vous pourrez:

  • Expliquer les bases des jointures dans SQL Server
  • Écrire des requêtes de jointure interne
  • Écrire des requêtes qui utilisent des jointures externes
  • Utiliser des types de jointures supplémentaires

Module 5: Tri et filtrage des données

Ce module explique comment implémenter le tri et le filtrage.

Cours:

  • Tri des données
  • Filtrage des données avec des prédicats
  • Filtrage des données avec TOP et OFFSET-FETCH
  • Travailler avec des valeurs inconnues

Laboratoire: Tri et filtrage des données

  • Écriture de requêtes filtrant des données à l’aide d’une clause WHERE
  • Écriture de requêtes qui trient des données à l’aide d’une clause ORDER BY
  • Écrire des requêtes qui filtrent des données à l’aide de l’option TOP
  • Écrire des requêtes qui filtrent les données à l’aide de la clause OFFSET-FETCH

Après avoir terminé ce module, vous pourrez:

  • Expliquez comment ajouter une clause ORDER BY à vos requêtes pour contrôler l’ordre des lignes affichées dans la sortie de votre requête.
  • Expliquez comment construire des clauses WHERE pour filtrer les lignes qui ne correspondent pas au prédicat.
  • Expliquez comment limiter les plages de lignes dans la clause SELECT à l’aide d’une option TOP.
  • Expliquez comment limiter les plages de lignes à l’aide de l’option OFFSET-FETCH d’une clause ORDER BY.
  • Expliquez comment la logique à trois valeurs rend compte des valeurs inconnues et manquantes, comment SQL Server utilise NULL pour marquer les valeurs manquantes et comment tester NULL dans vos requêtes.

Module 6: Utilisation des types de données SQL Server

Ce module présente les types de données que SQL Server utilise pour stocker les données.

Cours:

  • Présentation des types de données SQL Server
  • Travailler avec des données de personnage
  • Utilisation des données de date et d’heure

Atelier: Utilisation des types de données SQL Server

  • Écrire des requêtes qui renvoient des données de date et d’heure
  • Écrire des requêtes qui utilisent des fonctions de date et d’heure
  • Écrire des requêtes qui renvoient des données de personnage
  • Écrire des requêtes qui renvoient des fonctions de caractère

Après avoir terminé ce module, vous pourrez:

  • Explorez de nombreux types de données utilisés par SQL Server pour stocker des données et la conversion des types de données entre types.
  • Expliquez les types de données SQL Server basés sur les caractères, le fonctionnement des comparaisons de caractères et certaines fonctions courantes pouvant vous être utiles dans vos requêtes.
  • Décrire les types de données utilisés pour stocker des données temporelles, comment entrer des dates et des heures pour être correctement analysés par SQL Server et comment manipuler des dates et des heures à l’aide de fonctions intégrées

Module 7: Utilisation de DML pour modifier des données

Ce module explique comment créer des requêtes DML et pourquoi vous le souhaitez.

Cours:

  • Ajout de données aux tables
  • Modification et suppression de données
  • Génération de valeurs de colonne automatiques

Laboratoire: Utilisation de DML pour modifier des données

  • Insérer des enregistrements avec DML
  • Mise à jour et suppression d’enregistrements à l’aide de DML

Après avoir terminé ce module, vous pourrez:

  • Utilisez les instructions INSERT et SELECT INTO
  • Utiliser UPDATE, MERGE, DELETE et TRUNCATE

Module 8: Utilisation des fonctions intégrées

Ce module présente certaines des nombreuses fonctions intégrées de SQL Server.

Cours:

  • Écrire des requêtes avec des fonctions intégrées
  • Utiliser les fonctions de conversion
  • Utiliser les fonctions logiques
  • Utilisation de fonctions pour travailler avec NULL

Laboratoire: Utilisation des fonctions intégrées

  • Écrire des requêtes qui utilisent des fonctions de conversion
  • Écrire des requêtes qui utilisent des fonctions logiques
  • Écrire des requêtes qui testent la nullité

Après avoir terminé ce module, vous pourrez:

  • Décrire les types de fonctions fournies par SQL Server, puis se concentrer sur l’utilisation de fonctions scalaires.
  • Expliquer comment convertir explicitement des données entre types à l’aide de plusieurs fonctions SQL Server
  • Décrire comment utiliser des fonctions logiques qui évaluent une expression et renvoient un résultat scalaire.
  • Décrire des fonctions supplémentaires pour travailler avec NULL

Module 9: Regroupement et agrégation de données

Ce module explique comment utiliser les fonctions d’agrégat.

Cours:

  • Utilisation des fonctions d’agrégation
  • Utilisation de la clause GROUP BY
  • Filtrage des groupes avec HAVING

Laboratoire: Regroupement et agrégation de données

  • Écriture de requêtes utilisant la clause GROUP BY
  • Écrire des requêtes qui utilisent des fonctions d’agrégation
  • Écrire des requêtes qui utilisent des fonctions d’agrégation distinctes
  • Écriture de requêtes filtrant des groupes avec la clause HAVING

Après avoir terminé ce module, vous pourrez:

  • Décrivez la fonction d’agrégat intégrée dans SQL Server et écrivez des requêtes à l’aide de celle-ci.
  • Écrivez des requêtes qui séparent les lignes à l’aide de la clause GROUP BY.
  • Écrivez des requêtes qui utilisent la clause HAVING pour filtrer des groupes.

Module 10: Utilisation des sous-requêtes

Ce module décrit plusieurs types de sous-requêtes et indique comment et quand les utiliser.

Cours:

  • Écriture de sous-requêtes autonomes
  • Écriture de sous-requêtes corrélées
  • Utilisation du prédicat EXISTS avec des sous-requêtes

Laboratoire: Utilisation de sous-requêtes

  • Écrire des requêtes qui utilisent des sous-requêtes autonomes
  • Écriture de requêtes utilisant des sous-requêtes scalaires et à résultats multiples
  • Écriture de requêtes utilisant des sous-requêtes corrélées et une clause EXISTS

Après avoir terminé ce module, vous pourrez:

  • Décrivez où les sous-requêtes peuvent être utilisées dans une instruction SELECT.
  • Écrire des requêtes qui utilisent des sous-requêtes corrélées dans une instruction SELECT
  • Écrire des requêtes qui utilisent des prédicats EXISTS dans une clause WHERE pour vérifier l’existence de lignes qualifiantes
  • Utilisez le prédicat EXISTS pour vérifier efficacement l’existence de lignes dans une sous-requête.

Module 11: Utilisation des expressions de table

Auparavant, vous avez appris à utiliser les sous-requêtes en tant qu’expression renvoyant les résultats à une requête d’appel externe. Comme les sous-requêtes, les expressions de table sont des expressions de requête, mais les expressions de table étendent cette idée en vous permettant de les nommer et de travailler avec leurs résultats, comme vous le feriez avec des données dans toute table relationnelle valide. Microsoft SQL Server prend en charge quatre types d’expressions de table: les tables dérivées, les expressions de table communes (CTE), les vues et les fonctions TVF (inline table-values). Dans ce module, vous apprendrez à utiliser ces formes d’expressions de table et à les utiliser pour créer une approche modulaire de l’écriture de requêtes.

Cours:

  • Utiliser des vues
  • Utilisation de fonctions inline de table
  • Utilisation de tables dérivées
  • Utilisation d’expressions de table communes

Atelier: Utilisation des expressions de table

  • Écrire des requêtes qui utilisent des vues
  • Écrire des requêtes qui utilisent des tables dérivées
  • Écrire des requêtes qui utilisent des expressions de table communes (CTE)
  • Écriture de requêtes utilisant des expressions de table inline (TVF)

Après avoir terminé ce module, vous pourrez:

  • Écrivez des requêtes qui renvoient les résultats des vues.
  • Utilisez l’instruction CREATE FUNCTION pour créer des fichiers TVF en ligne simples.
  • Écrivez des requêtes qui créent et extraient des résultats de tables dérivées.
  • Écrivez des requêtes qui créent des CTE et renvoient les résultats de l’expression de la table.

Module 12: Utilisation des opérateurs de sets

Ce module explique comment utiliser les opérateurs d’ensemble UNION, INTERSECT et EXCEPT pour comparer des lignes entre deux ensembles d’entrée.

Cours:

  • Écrire des requêtes avec l’opérateur UNION
  • Utilisation de EXCEPT et INTERSECT
  • Utilisation de APPLY

Laboratoire: Utilisation des opérateurs de sets

  • Rédaction de requêtes utilisant les opérateurs de jeux UNION et UNION ALL
  • Rédaction de requêtes utilisant les opérateurs CROSS APPLY et OUTER APPLY
  • Écriture de requêtes utilisant les opérateurs EXCEPT et INTERSECT

À la fin de ce module, les étudiants seront en mesure de:

  • Écrivez des requêtes qui utilisent UNION pour combiner des jeux d’entrées.
  • Écrire des requêtes qui utilisent UNION ALL pour combiner des jeux d’entrées
  • Écrivez des requêtes qui utilisent l’opérateur EXCEPT pour renvoyer uniquement les lignes d’un jeu mais pas d’un autre.
  • Écrire des requêtes qui utilisent l’opérateur INTERSECT pour renvoyer uniquement les lignes présentes dans les deux ensembles
  • Rédigez des requêtes à l’aide de l’opérateur CROSS APPLY.
  • Écrire des requêtes à l’aide de l’opérateur OUTER APPLY

Module 13: Utilisation des fonctions de classement, de décalage et d’agrégation Windows

Ce module décrit les avantages de l’utilisation des fonctions de fenêtre. Limitez les fonctions de la fenêtre aux lignes définies dans une clause OVER, y compris les partitions et les cadres. Écrivez des requêtes qui utilisent des fonctions de fenêtre pour opérer sur une fenêtre de lignes et renvoyer des résultats de classement, d’agrégation et de comparaison de décalage.

Cours:

  • Créer Windows avec OVER
  • Exploration des fonctions de la fenêtre

Atelier: Utilisation des fonctions de classement, de décalage et d’agrégation Windows

  • Écrire des requêtes qui utilisent des fonctions de classement
  • Écrire des requêtes qui utilisent des fonctions de décalage
  • Écrire des requêtes qui utilisent des fonctions d’agrégat de fenêtre

À la fin de ce module, les étudiants seront en mesure de:

  • Décrivez les composants T-SQL utilisés pour définir les fenêtres et leurs relations.
  • Écrire des requêtes qui utilisent la clause OVER, avec partitionnement, ordre et cadrage pour définir des fenêtres
  • Écrire des requêtes qui utilisent des fonctions d’agrégation de fenêtre.
  • Écrire des requêtes qui utilisent des fonctions de classement de fenêtre.
  • Écrire des requêtes qui utilisent des fonctions de décalage de fenêtre

Module 14: Ensembles de pivotement et de regroupement

Ce module décrit les requêtes d’écriture qui font pivoter et qui ne modifient pas les résultats. Écrire des requêtes qui spécifient plusieurs regroupements avec des ensembles de regroupement

Cours:

  • Écrire des requêtes avec PIVOT et UNPIVOT
  • Travailler avec des ensembles de regroupement

Laboratoire: Ensembles de pivotement et de regroupement

  • Écrire des requêtes qui utilisent l’opérateur PIVOT
  • Écrire des requêtes qui utilisent l’opérateur UNPIVOT
  • Écriture de requêtes utilisant les sous-clauses GROUPING SETS CUBE et ROLLUP

À la fin de ce module, les étudiants seront en mesure de:

  • Décrivez comment les données pivotantes peuvent être utilisées dans les requêtes T-SQL.
  • Écrivez des requêtes qui font pivoter les données de lignes en colonnes à l’aide de l’opérateur PIVOT.
  • Écrivez les requêtes qui décompactent les données des colonnes dans les lignes à l’aide de l’opérateur UNPIVOT.
  • Écrivez des requêtes en utilisant la sous-clause GROUPING SETS.
  • Rédigez des requêtes utilisant ROLLUP AND CUBE.
  • Écrivez des requêtes qui utilisent la fonction GROUPING_ID.

Module 15: Exécution de procédures stockées

Ce module explique comment renvoyer des résultats en exécutant des procédures stockées. Passer les paramètres aux procédures. Créez des procédures stockées simples qui encapsulent une instruction SELECT. Construisez et exécutez du SQL dynamique avec EXEC et sp_executesql.

Cours:

  • Interrogation de données avec des procédures stockées
  • Passage des paramètres aux procédures stockées
  • Création de procédures stockées simples
  • Travailler avec SQL dynamique

Laboratoire: Exécution de procédures stockées

  • Utilisation de l’instruction EXECUTE pour appeler des procédures stockées
  • Passage des paramètres aux procédures stockées
  • Exécution des procédures stockées du système

À la fin de ce module, les étudiants seront en mesure de:

  • Décrire les procédures stockées et leur utilisation.
  • Écrivez des instructions T-SQL qui exécutent des procédures stockées pour renvoyer des données.
  • Écrivez des instructions EXECUTE qui transmettent des paramètres d’entrée aux procédures stockées.
  • Écrivez des lots T-SQL qui préparent les paramètres de sortie et exécutent des procédures stockées.
  • Utilisez l’instruction CREATE PROCEDURE pour écrire une procédure stockée.
  • Créez une procédure stockée qui accepte les paramètres d’entrée.
  • Décrivez comment T-SQL peut être construit de manière dynamique.
  • Écrire des requêtes qui utilisent SQL dynamique.

Module 16: Programmation avec T-SQL

Ce module explique comment améliorer votre code T-SQL avec des éléments de programmation.

Cours:

  • Éléments de programmation T-SQL
  • Contrôle du déroulement du programme

Atelier: Programmation avec T-SQL

  • Déclaration de variables et délimitation de lots
  • Utilisation d’éléments de contrôle de flux
  • Utilisation de variables dans une instruction SQL dynamique
  • Utiliser des synonymes

À la fin de ce module, les étudiants seront en mesure de:

  • Décrivez comment Microsoft SQL Server traite les collections d’instructions en tant que lots.
  • Créez et soumettez des lots de code T-SQL à exécuter par SQL Server.
  • Décrivez comment SQL Server stocke les objets temporaires en tant que variables.
  • Écrivez un code qui déclare et assigne des variables.
  • Créer et invoquer des synonymes
  • Décrire les éléments de contrôle de flux dans T-SQL.
  • Écrivez le code T-SQL en utilisant des blocs IF … ELSE.
  • Écrivez le code T-SQL qui utilise WHILE.

Module 17: Mise en œuvre du traitement des erreurs

Ce module présente la gestion des erreurs pour T-SQL.

Cours:

  • Implémentation du traitement des erreurs T-SQL
  • Implémentation de la gestion des exceptions structurées

Laboratoire: Mise en œuvre du traitement des erreurs

  • Redirection des erreurs avec TRY / CATCH
  • Utilisation de THROW pour renvoyer un message d’erreur à un client

À la fin de ce module, les étudiants seront en mesure de:

  • Implémentez la gestion des erreurs T-SQL.
  • Implémentez la gestion structurée des exceptions.

Module 18: Mise en œuvre des transactions

Ce module explique comment implémenter des transactions.

Cours:

  • Transactions et les moteurs de base de données
  • Contrôle des transactions

Laboratoire: Mise en œuvre des transactions

  • Contrôle des transactions avec BEGIN, COMMIT et ROLLBACK
  • Ajout du traitement des erreurs à un bloc CATCH

À la fin de ce module, les étudiants seront en mesure de:

  • Décrire les transactions et les différences entre les lots et les transactions.
  • Décrivez les lots et comment ils sont gérés par SQL Server.
  • Créez et gérez des transactions à l’aide d’instructions en langage de contrôle de transaction (TCL).
  • Utilisez SET XACT_ABORT pour définir le traitement par les serveurs SQL des transactions en dehors des blocs TRY / CATCH.

– Connaissance de base du système d’exploitation Microsoft Windows et de ses fonctionnalités principales.

– Connaissance pratique des bases de données relationnelles.

Programme de Formation

No curriculum found !
Course Reviews
N.C
ratings
  • 5 stars0
  • 4 stars0
  • 3 stars0
  • 2 stars0
  • 1 stars0

No Reviews found for this course.

© Copyright 2018 Reunit.
X