Développement logiciel, Langages C / C++ / VB... - Orsys

Développement logiciel, Langages C / C++ / VB...
De nombreuses applications ont été développées en C, C++, Visual Basic, SQL ou même
Cobol et continuent à évoluer. A cela vient s'ajouter l'utilisation de nombreux autres langages
plus spécialisés tels que Python ou Ruby. Conçus sur la base d'expériences concrètes, les
cours Orsys vous permettront de comprendre le contexte d'utilisation de ces langages et d'en
acquérir une parfaite maîtrise en vue de développer de nouvelles applications, de les intégrer
au système d'information et d'en assurer la maintenance.
Stages Pratiques
Introduction à la programmation avec Visual Basic.... ( p3 )
Introduction à la programmation avec Java.... ( p5 )
Introduction à la programmation avec C#.... ( p7 )
Développer en Visual Basic.... ( p9 )
Visual Basic, perfectionnement.... ( p11 )
Programmation en C.... ( p12 )
Programmation objet en C++.... ( p14 )
Programmation C++, perfectionnement.... ( p16 )
C++, mise à niveau pour les développeurs C# et Java.... ( p18 )
C++, développement d'applications graphiques en QT.... ( p19 )
Programmer vos applications en Multicore.... ( p21 )
C++, programmer avec CUDA, OpenMP et les PPL Visual Studio.... ( p23 )
Linux industriel, temps réel et embarqué.... ( p25 )
Développeur système sous Linux/Unix.... ( p27 )
Objective C, programmation.... ( p28 )
Python, programmation objet.... ( p29 )
Développer avec les frameworks Python.... ( p31 )
Django, développement Web avec Python.... ( p32 )
Langage Perl.... ( p34 )
Langage Perl, programmation avancée.... ( p36 )
Windev, développement d'applications.... ( p37 )
Webdev, développement Web.... ( p38 )
Webdev, développement Web, perfectionnement.... ( p40 )
PowerBuilder, les fondamentaux.... ( p41 )
PowerBuilder, perfectionnement.... ( p43 )
PowerBuilder, développer des applications .NET.... ( p45 )
Groovy, programmation.... ( p47 )
Groovy et Grails, développement Web.... ( p49 )
Ruby On Rails 3, développement Web.... ( p50 )
Amazon Web Services, architecture et mise en œuvre.... ( p51 )
Scala, programmation.... ( p53 )
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 1 / 86

Programmation Cobol.... ( p54 )
Corba, architecture, mise en œuvre.... ( p55 )
Mettre en œuvre le contrôle de versions avec le système GIT.... ( p57 )
SQL Server, Programmation SQL.... ( p59 )
SQL Server, programmation SQL avancée.... ( p61 )
SQL Server 2012/2008, développement .... ( p62 )
SQL Server 2012, mise en œuvre.... ( p63 )
Transact-SQL, optimisation pour SQL Server 2012/2008.... ( p65 )
SQL Server 2008, mise en œuvre.... ( p66 )
SQL server 2008, mise en œuvre avancée.... ( p68 )
SQL Server 2005, mise en œuvre.... ( p69 )
SQL Server, optimisation.... ( p71 )
Oracle SQL.... ( p73 )
Oracle SQL, perfectionnement.... ( p74 )
Oracle SQL pour le décisionnel.... ( p76 )
Développer en PL/SQL.... ( p77 )
Développer en PL/SQL, perfectionnement.... ( p78 )
Oracle, optimisation d'applications.... ( p80 )
SQL pour MySQL et PostgreSQL.... ( p81 )
MySQL, prise en main.... ( p83 )
PostgreSQL, prise en main.... ( p85 )
MariaDB, prise en main.... ( p86 )
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 2 / 86

Stage pratique de 3 jour(s)
Réf : INP
Participants
Toute personne devant
apprendre à programmer.
Pré-requis
Aucune connaissance
particulière.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
3 fév. 2014, 3 mar. 2014
7 avr. 2014, 5 mai 2014
2 juin 2014, 7 juil. 2014
18 aoû. 2014, 1 sep. 2014
6 oct. 2014, 3 nov. 2014
1 déc. 2014
Introduction à la programmation avec Visual Basic
OBJECTIFS
Ce stage vous permettra de comprendre les fondements de la programmation et de l'algorithmique. Vous
acquérez des bases en programmation qui vous permettront d'aborder n'importe quel langage dans les
meilleures conditions. Tous les aspects essentiels seront vus : les modèles de programmation, les éléments
de lexique et de syntaxe, les outils, l'organisation du code, l'accès aux bases de données et les tests.
1) Les fondements de la programmation
2) Genèse d'un premier programme
3) Règles de programmation
4) Les variables
5) Opérateurs et expressions
Travaux pratiques
6) Les structures de contrôle
7) Les procédures et les fonctions
8) Introduction à la programmation objet
9) L'accès aux bases de données
10) Maintenance, débogage et test des
programmes
Ce stage contient plus de 60 % de travaux pratiques effectués selon vos besoins en Visual Basic (Cours
INP), en Java (cours INJ ) ou en C# (cours OGR).
1) Les fondements de la programmation
- Qu'est-ce qu'un programme ? Qu'est-ce qu'un langage ? Les différents paradigmes. Quel langage pour
quelle application ?
- Les compilateurs. Les exécutables.
- Les responsabilités d'un programmeur.
- Qu'est-ce qu'un algorithme ?
- Les besoins auxquels répond un algorithme.
- Le concept de pseudo-langage.
Travaux pratiques
Présentation de différents langages (Java, C#, Visual Basic, C, C++). Ecriture d'un premier algorithme en
pseudo-langage.
2) Genèse d'un premier programme
- Ecriture d'un programme simple : syntaxe et instructions.
- Compilation et exécution du programme.
- Qu'est-ce qu'une librairie ? Son rôle, son usage.
Travaux pratiques
Découverte de l'environnement de développement et d'exécution. Ecriture, compilation et exécution d'un
premier programme.
3) Règles de programmation
- Convention de nommage.
- Convention syntaxique.
- Utilisation des commentaires. Pourquoi commenter les développements ?
- Améliorer la lisibilité des programmes : indentation du code, découpage du code...
4) Les variables
- Qu'est-ce qu'une variable ?
- Pourquoi typer une variable ?
- Les types primitifs : entiers, chaînes de caractères, nombres réels, autres.
- Déclaration, définition et initialisation d'une variable.
- Les constantes.
- Saisie, affichage, affectation, conversion de type.
- Organiser ses données sous forme de tableaux.
- Les types évolués : enregistrement, matrice, arbre.
Travaux pratiques
Ecriture de plusieurs programmes simples manipulant les variables.
5) Opérateurs et expressions
- Les différents opérateurs (multiplicatif, additif, comparaison, égalité, logique, affectation).
- Combinaison d'opérateurs.
- Expression booléenne.
Travaux pratiques
Manipulation des opérateurs et des expressions booléennes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 3 / 86

6) Les structures de contrôle
- Les sélections alternatives (si, si-alors-sinon, sélection cas).
- Les blocs d'insctructions (notion de début... fin).
- Les boucles itératives (tant que-répéter, répéter-jusqu'à, pour-de-à).
- Imbrication des instructions.
- Les commentaires.
Travaux pratiques
Utilisation des structures de contrôle pour implémenter un algorithme.
7) Les procédures et les fonctions
- Définitions : procédure, fonction.
- Pourquoi sont-elles incontournables en programmation (réutilisabilité, lisibilité...) ?
- Le passage de paramètres.
- Le code retour d'une fonction.
- Sensibilisation aux limites du passage de la valeur d'une variable.
- Notion de passage par adresse.
- Appel de fonctions.
Travaux pratiques
Debugging de programmes exemples.
8) Introduction à la programmation objet
- Les concepts associés à la programmation objet : classe, attribut, méthode, argument.
- La modélisation objet à partir des exigences fonctionnelles.
- Introduction aux bonnes pratiques d'organisation de conception et d'organisation d'un programme.
Travaux pratiques
Illustration des concepts objets.
9) L'accès aux bases de données
- Organisation et stockage des données.
- Les traitements de base (connexion, requêtes, récupération des données).
- Application cliente et serveur de données.
- Affichage et manipulation des données dans l'application cliente.
Travaux pratiques
Création d'un formulaire de recherche d'informations dans une base de données.
10) Maintenance, débogage et test des programmes
- Savoir lire et interpréter les différents messages d'erreurs.
- Utiliser un débogueur : exécuter un programme pas à pas, points d'arrêts, inspecter les variables pendant
l'exécution.
- Prévoir les tests unitaires.
Travaux pratiques
Utilisation d'un débogueur pour contrôler l'exécution des programmes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 4 / 86

Stage pratique de 3 jour(s)
Réf : INJ
Participants
Toute personne devant
apprendre à programmer.
Pré-requis
Aucune connaissance
particulière.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
7 avr. 2014, 30 juin 2014
13 oct. 2014, 15 déc. 2014
Introduction à la programmation avec Java
OBJECTIFS
Ce stage vous permettra de comprendre les fondements de la programmation et de l'algorithmique. Vous
acquérez des bases en programmation qui vous permettront d'aborder n'importe quel langage dans les
meilleures conditions. Tous les aspects essentiels seront vus : les modèles de programmation, les éléments
de lexique et de syntaxe, les outils, l'organisation du code, l'accès aux bases de données et les tests.
1) Les fondements de la programmation
2) Genèse d'un premier programme
3) Règles de programmation
4) Les variables
5) Opérateurs et expressions
Travaux pratiques
6) Les structures de contrôle
7) Les procédures et les fonctions
8) Introduction à la programmation objet
9) L'accès aux bases de données
10) Maintenance, débogage et test des
programmes
Ce stage contient plus de 60 % de travaux pratiques effectués selon vos besoins en Visual Basic (cours INP),
en Java (cours INJ) ou en C# (cours OGR).
1) Les fondements de la programmation
- Qu'est-ce qu'un programme ? Qu'est-ce qu'un langage ? Les différents paradigmes. Quel langage pour
quelle application ?
- Les compilateurs. Les exécutables.
- Les responsabilités d'un programmeur.
- Qu'est-ce qu'un algorithme ?
- Les besoins auxquels répond un algorithme.
- Le concept de pseudo-langage.
Travaux pratiques
Présentation de différents langages (Java, C#, Visual Basic, C, C++). Ecriture d'un premier algorithme en
pseudo-langage.
2) Genèse d'un premier programme
- Ecriture d'un programme simple : syntaxe et instructions.
- Compilation et exécution du programme.
- Qu'est-ce qu'une librairie ? Son rôle, son usage.
Travaux pratiques
Découverte de l'environnement de développement et d'exécution. Ecriture, compilation et exécution d'un
premier programme.
3) Règles de programmation
- Convention de nommage.
- Convention syntaxique.
- Utilisation des commentaires. Pourquoi commenter les développements ?
- Améliorer la lisibilité des programmes : indentation du code, découpage du code...
4) Les variables
- Qu'est-ce qu'une variable ?
- Pourquoi typer une variable ?
- Les types primitifs : entiers, chaînes de caractères, nombres réels, autres.
- Déclaration, définition et initialisation d'une variable.
- Les constantes.
- Saisie, affichage, affectation, conversion de type.
- Organiser ses données sous forme de tableaux.
- Les types évolués : enregistrement, matrice, arbre.
Travaux pratiques
Ecriture de plusieurs programmes simples manipulant les variables.
5) Opérateurs et expressions
- Les différents opérateurs (multiplicatif, additif, comparaison, égalité, logique, affectation).
- Combinaison d'opérateurs.
- Expression booléenne.
Travaux pratiques
Manipulation des opérateurs et des expressions booléennes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 5 / 86

6) Les structures de contrôle
- Les sélections alternatives (si, si-alors-sinon, sélection cas).
- Les blocs d'instructions (notion de Début... Fin).
- Les boucles itératives (tant que-répéter, répéter-jusqu'à, pour-de- à).
- Imbrication des instructions.
- Les commentaires.
Travaux pratiques
Utilisation des structures de contrôle pour implémenter un algorithme.
7) Les procédures et les fonctions
- Définitions : procédure, fonction.
- Pourquoi sont-elles incontournables en programmation (réutilisabilité, lisibilité...) ?
- Le passage de paramètres.
- Le code retour d'une fonction.
- Sensibilisation aux limites du passage de la valeur d'une variable.
- Notion de passage par adresse.
- Appel de fonctions.
8) Introduction à la programmation objet
- Les concepts associés à la programmation objet : classe, attribut, méthode, argument.
- La modélisation objet à partir des exigences fonctionnelles.
- introduction aux bonnes pratiques d'organisation de conception et d'organisation d'un programme.
Travaux pratiques
Illustration des concepts objets.
9) L'accès aux bases de données
- Organisation et stockage des données.
- Les traitements de base (connexion, requêtes, récupération des données).
- Application cliente et serveur de données.
- Affichage et manipulation des données dans l'application cliente.
Travaux pratiques
Création d'un formulaire de recherche d'informations dans une base de données.
10) Maintenance, débogage et test des programmes
- Savoir lire et interpréter les différents messages d'erreurs.
- Utiliser un débogueur : exécuter un programme pas à pas, points d'arrêts, inspecter les variables pendant
l'exécution.
- Prévoir les tests unitaires.
Travaux pratiques
Utilisation d'un débogueur pour contrôler l'exécution des programmes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 6 / 86

Stage pratique de 3 jour(s)
Réf : OGR
Participants
Toute personne devant
apprendre à programmer.
Pré-requis
Aucune connaissance
particulière.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
19 mai 2014, 8 sep. 2014
12 nov. 2014
Introduction à la programmation avec C#
OBJECTIFS
Ce stage vous permettra de comprendre les fondements de la programmation et de l'algorithmique. Vous
acquérez des bases en programmation qui vous permettront d'aborder n'importe quel langage dans les
meilleures conditions. Tous les aspects essentiels seront vus : les modèles de programmation, les éléments
de lexique et de syntaxe, les outils, l'organisation du code, l'accès aux bases de données et les tests.
1) Un programme
2) Nécessité d'un algorithme
3) Genèse d'un premier programme
4) Règles de programmation
5) Les variables
6) Opérateurs et expressions
Travaux pratiques
7) Les structures de contrôle
8) Les procédures et les fonctions
9) Introduction à la programmation objet
10) L'accès aux bases de données
11) Maintenance, débogage et test des
programmes
Ce stage contient plus de 60 % de travaux pratiques effectués selon vos besoins en Visual Basic (cours INP),
en Java (cours INJ) ou en C# (cours OGR).
1) Un programme
- Qu'est-ce qu'un programme ?
- Qu'est-ce qu'un langage ? Les différents paradigmes.
- Quel langage pour quelle application ?
- Les compilateurs. Les exécutables.
- Les responsabilités d'un programmeur.
Travaux pratiques
Présentation de différents langages (Java, C#, Visual Basic, C, C++).
2) Nécessité d'un algorithme
- Qu'est-ce qu'un algorithme ?
- Les besoins auxquels répond un algorithme.
- Le concept de pseudo-langage.
Travaux pratiques
Ecriture d'un premier algorithme en pseudo-langage.
3) Genèse d'un premier programme
- Ecriture d'un programme simple : syntaxe et instructions.
- Compilation et exécution du programme.
- Qu'est-ce qu'une librairie ? Son rôle, son usage.
Travaux pratiques
Découverte de l'environnement de développement et d'exécution. Ecriture, compilation et exécution d'un
premier programme.
4) Règles de programmation
- Convention de nommage.
- Convention syntaxique.
- Utilisation des commentaires. Pourquoi commenter les développements ?
- Améliorer la lisibilité des programmes : indentation du code, découpage du code...
5) Les variables
- Qu'est-ce qu'une variable ?
- Pourquoi typer une variable ?
- Les types primitifs : entiers, chaînes de caractères, nombres réels, autres.
- Déclaration, définition et initialisation d'une variable.
- Les constantes.
- Saisie, affichage, affectation, conversion de type.
- Organiser ses données sous forme de tableaux.
- Les types évolués : enregistrement, matrice, arbre.
Travaux pratiques
Ecriture de plusieurs programmes simples manipulant les variables.
6) Opérateurs et expressions
- Les différents opérateurs (multiplicatif, additif, comparaison, égalité, logique, affectation).
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 7 / 86

- Combinaison d'opérateurs.
- Expression booléenne.
Travaux pratiques
Manipulation des opérateurs et des expressions booléennes.
7) Les structures de contrôle
- Les sélections alternatives (si, si-alors-sinon, sélection cas).
- Les blocs d'instructions (notion de Début... Fin).
- Les boucles itératives (tant que-répéter, répéter-jusqu'à, pour-de- à).
- Imbrication des instructions.
- Les commentaires.
Travaux pratiques
Utilisation des structures de contrôle pour implémenter un algorithme.
8) Les procédures et les fonctions
- Définitions : procédure, fonction.
- Pourquoi sont-elles incontournables en programmation (réutilisabilité, lisibilité...) ?
- Le passage de paramètres.
- Le code retour d'une fonction.
- Sensibilisation aux limites du passage de la valeur d'une variable.
- Notion de passage par adresse.
- Appel de fonctions.
9) Introduction à la programmation objet
- Les concepts associés à la programmation objet : classe, attribut, méthode, argument.
- La modélisation objet à partir des exigences fonctionnelles : introduction aux bonnes pratiques
d'organisation de conception et d'organisation d'un programme.
Travaux pratiques
Illustration des concepts objets.
10) L'accès aux bases de données
- Organisation et stockage des données.
- Les traitements de base (connexion, requêtes, récupération des données).
- Application cliente et serveur de données.
- Affichage et manipulation des données dans l'application cliente.
Travaux pratiques
Création d'un formulaire de recherche d'informations dans une base de données.
11) Maintenance, débogage et test des programmes
- Savoir lire et interpréter les différents messages d'erreurs.
- Utiliser un débogueur : exécution d'un programme pas à pas, points d'arrêts, inspecter les variables pendant
l'exécution.
- Prévoir les tests unitaires.
Travaux pratiques
Utilisation d'un débogueur pour contrôler l'exécution des programmes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 8 / 86

Stage pratique de 5 jour(s)
Réf : VB6
Participants
Concepteurs et développeurs
d'applications en Visual Basic.
Les participants souhaitant
aborder le VBA pour le
développement d'applications
liées au Pack Office doivent
se diriger vers un autre stage.
Pré-requis
Connaissances de base
en programmation.
Expérience souhaitable en
développement logiciel.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
24 fév. 2014, 24 mar. 2014
14 avr. 2014, 19 mai 2014
16 juin 2014, 28 juil. 2014
25 aoû. 2014, 22 sep. 2014
20 oct. 2014, 24 nov. 2014
15 déc. 2014
Aix
31 mar. 2014, 23 juin 2014
13 oct. 2014, 8 déc. 2014
Bordeaux
29 sep. 2014, 17 nov. 2014
Lille
29 sep. 2014, 17 nov. 2014
Lyon
31 mar. 2014, 23 juin 2014
13 oct. 2014, 8 déc. 2014
Nantes
10 mar. 2014, 23 juin 2014
6 oct. 2014, 1 déc. 2014
Rennes
10 mar. 2014, 23 juin 2014
6 oct. 2014, 1 déc. 2014
Sophia-antipolis
31 mar. 2014, 23 juin 2014
13 oct. 2014, 8 déc. 2014
Strasbourg
29 sep. 2014, 17 nov. 2014
Toulouse
29 sep. 2014, 17 nov. 2014
Développer en Visual Basic
OBJECTIFS
Ce stage vous permettra de maîtriser pleinement les fonctionnalités et les capacités de Visual Basic. Tous
les aspects essentiels du langage seront abordés, y compris la programmation objet, l'interaction avec les
bases de données et les Active X Data Objects. A l'issue de ce cours, vous serez à même de réaliser des
applications professionnelles.
1) Positionnement de Visual Basic (vb, vba,
vbscript)
2) Améliorer la conception des applications avec
la programmation objet
3) La plateforme de développement Visual Basic
4) Visual Basic, le langage
5) Fenêtres, menus et boîtes de dialogue
1) Positionnement de Visual Basic (vb, vba, vbscript)
- La construction d'interfaces utilisateur.
- L'accès aux bases de données.
- Utilisation et création de composants.
- Le développement Internet/Intranet.
6) Les composants graphiques (contrôles)
7) La gestion des erreurs
8) L'accès aux données
9) Touche finale
2) Améliorer la conception des applications avec la programmation objet
- Classes et objets.
- Les objets graphiques : formes, contrôles.
- Propriétés, méthodes, événements.
- La programmation événementielle.
3) La plateforme de développement Visual Basic
- Les principes récurrents.
- Fenêtres, barre de menus, barre d'outils.
- Aide en ligne et compléments.
- L'éditeur de code.
- Etapes de création d'une application.
- Les différents types de fichiers.
Travaux pratiques
Prise en main de l'interface, enregistrement et compilation.
4) Visual Basic, le langage
- Les variables.
- Types de données et conversions.
- Portée et durée de vie des variables.
- Tableaux et types de données utilisateurs.
- Les constantes.
- Les variables objets.
- Les conventions de dénomination.
- Procédures événementielles et générales.
- Subroutines et fonctions.
- Portée des procédures : les modules standard.
- Le passage d'arguments.
- Les fonctions de Visual Basic.
- Les opérateurs. Les structures de contrôle.
Travaux pratiques
Création de procédures, passage d'arguments. Création d'une fonction de vérification des dates.
5) Fenêtres, menus et boîtes de dialogue
- Principe des MDI (Multiple Document Interface), formes et contrôles. Formes modales. Formes prédéfinies.
- Chargement et affichage.
- Principaux événements, méthodes et propriétés.
- Menus, popup menus.
- Les fonctions msgbox et inputbox.
Travaux pratiques
Création de formes et d'un menu de présentation. Gestion des événements de chargement et déchargement
des formes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 9 / 86

6) Les composants graphiques (contrôles)
- Contrôles standard, contrôles Active X.
- Saisie et affichage : label, text box, masked edit.
- Les boutons : command, check box, option.
- Les listes : list box, combo box.
- Présentation : Tool Bar, Status Bar, Image List, Scroll Bar, Progress Bar.
- Les boîtes de dialogue standard : common dialog.
- La minuterie : timer.
- Le Drag and Drop. Objet source et objet cible. Evénements souris. Propriétés de la source. Evénements sur
la cible.
Travaux pratiques
Gestion d'un formulaire de saisie, contrôles de validité. Manipulation des listes. Lancement de procédures.
Déplacement d'un contrôle sur une forme. Déplacement d'un élément d'une liste dans une autre liste.
7) La gestion des erreurs
- Traitement des erreurs logiques : le débogage
- Les points d'arrêt. Les expressions espionnes.
- Les fenêtres de débogage.
- Mode pas à pas et procédures.
- Traitement des erreurs d'exécution.
- L'interception et les gestionnaires d'erreurs.
- L'objet Err.
Travaux pratiques
Interception d'une erreur d'exécution. Prise en main du debugger.
8) L'accès aux données
- Manipulation des fichiers. Accès séquentiel, direct, binaire. Ouverture, fermeture. Instructions de lecture/
écriture.
- Architecture et objets des bases relationnelles.
- Le langage SQL. Le Data Environment.
- L'architecture client serveur.
- Les fournisseurs d'accès : ODBC et OLE-DB.
- Les objets d'accès aux données : ADO (Active X data access).
- Les outils d'accès aux données. Data Environment. Data Control. Data Report. Data Form Designer.
- Les contrôles dépendant des données. Data Grid, Hierarchical Flex Grid. Data List, Data Combo.
Travaux pratiques
Création et manipulation d'un fichier en accès séquentiel (enregistrements de taille variable). Utilisation des
contrôles d'accès aux données.
9) Touche finale
- Les fichiers de ressources.
- Enregistrement des paramètres d'une application.
- Générer un exécutable et le distribuer.
- Optimisation du programme.
Travaux pratiques
Création et utilisation d'un fichier de ressources. Utilisation de la base de registre pour conserver des
paramètres dynamiques. Déploiement d'une application.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 10 / 86

Stage pratique de 4 jour(s)
Réf : VBE
Participants
Développeurs Visual Basic 6.
Pré-requis
Bonnes connaissances
en Visual Basic 6 et en
bases de données. Ou
connaissances équivalentes
à celles apportées par
le stage "Développer en
Visual Basic" (réf. VB6).
Expérience souhaitable en
développement VB6.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
20 mai 2014, 8 juil. 2014
9 sep. 2014, 4 nov. 2014
Visual Basic, perfectionnement
OBJECTIFS
Ce stage de perfectionnement insiste sur les accès aux bases de données (ADO), la création de composants
COM et la création d'applications Web dynamiques.
1) L'accès aux bases de données
2) La création des composants Com
3) Exemple : les contrôles Active X
1) L'accès aux bases de données
4) Client-serveur et multitiers : Com+
5) Visual Basic et le développement Internet
6) Se préparer à Visual Basic .NET
- Les fournisseurs d'accès : ODBC et OLE-DB.
- Les objets d'accès aux données : ADO.
- Data Environnement, Data Control. Data Grid...
- Les objets ADO
- Modèle objet. Connexion à une source de données. Commandes. Récupération de données : le Recordset.
- Mise à jour, recherche, tri.
- Intégrité des données : transactions, verrous.
- Exécution des procédures stockées.
Travaux pratiques
Utilisation des outils d'accès aux données. Création d'un formulaire de saisie. Récupération de données via
une procédure stockée. Gestion d'une transaction d'écriture.
2) La création des composants Com
- Réutilisabilité, simplification, optimisation.
- Les interfaces standard, choix du type de composant.
- Création d'une application cliente.
- Variables objet, instanciation et manipulation d'objets. Les modules de classe.
- Définitions des propriétés, méthodes, événements.
- Le déclenchement des erreurs.
- COM et ADO : les composants liés aux données.
- Les collections. La création d'interfaces.
- Compilation et enregistrement des composants.
Travaux pratiques
Création et test de composants : un COM Dll de services bancaires, un de connexion à une base de données
avec ADO.
3) Exemple : les contrôles Active X
- Création. Propriétés, méthodes, événements.
- Création d'un contrôle dépendant des données.
- Création d'un contrôle fournisseur de données.
Travaux pratiques
Création d'un contrôle Active X de saisie des dates. Création d'un contrôle Active X fournisseur de données
avec ADO.
4) Client-serveur et multitiers : Com+
- Approche. Encapsulation des objets ADO. COM+ et MTS. Transaction multi-objets : le " double commit ".
- Optimisation des ressources. COM+ et la sécurité.
Travaux pratiques
Gestion d'une transaction en " double commit ".
5) Visual Basic et le développement Internet
- Développements côté serveur et côté client.
- Le contrôle WebBrowser. Documents Active X. Visual Basic et Vbscript. DHTML. COM et ASP, COM et
ADO.
Travaux pratiques
Création d'un navigateur sur une forme Visual Basic. Création d'un projet Document Active X s'exécutant
dans IE.
6) Se préparer à Visual Basic .NET
- La plateforme .NET, architecture. Le VB .NET.
- Visual Studio.NET, ADO.NET.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 11 / 86

Stage pratique de 5 jour(s)
Réf : LGC
Participants
Les ingénieurs et les
informaticiens qui souhaitent
acquérir une formation
complète et opérationnelle sur
le langage C.
Pré-requis
Connaissances de bases en
programmation.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
10 fév. 2014, 10 mar. 2014
7 avr. 2014, 12 mai 2014
2 juin 2014, 7 juil. 2014
18 aoû. 2014, 15 sep. 2014
13 oct. 2014, 3 nov. 2014
8 déc. 2014
Aix
24 fév. 2014, 7 avr. 2014
30 juin 2014, 1 sep. 2014
24 nov. 2014
Bordeaux
17 mar. 2014, 16 juin 2014
8 sep. 2014, 15 déc. 2014
Bruxelles
17 mar. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Geneve
17 mar. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Lille
17 mar. 2014, 16 juin 2014
8 sep. 2014, 15 déc. 2014
Luxembourg
17 mar. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Lyon
24 fév. 2014, 7 avr. 2014
30 juin 2014, 1 sep. 2014
24 nov. 2014
Nantes
17 mar. 2014, 23 juin 2014
1 sep. 2014, 15 déc. 2014
Rennes
17 mar. 2014, 23 juin 2014
1 sep. 2014, 15 déc. 2014
Sophia-antipolis
24 fév. 2014, 7 avr. 2014
30 juin 2014, 1 sep. 2014
24 nov. 2014
Strasbourg
17 mar. 2014, 16 juin 2014
8 sep. 2014, 15 déc. 2014
Toulouse
17 mar. 2014, 16 juin 2014
8 sep. 2014, 15 déc. 2014
Programmation en C
OBJECTIFS
Ce stage intensif vous permettra d'acquérir une connaissance réellement opérationnelle du langage. Il vous
expliquera le fonctionnement des différents mécanismes et vous montrera leur mise en œuvre grâce à de
nombreux exercices pratiques. A l'issue de ce stage, vous serez en mesure d'écrire des programmes C
robustes et portables.
1) Premiers pas en C
2) Opérateurs et expressions
3) Structures de contrôles
4) Tableaux, pointeurs et chaînes de caractères
5) Les structures
Travaux pratiques
6) Les fonctions
7) Compilation séparée, classe d'allocation
8) Le préprocesseur
9) Les bibliothèques standards
Des machines sous système Unix ou Windows (PC) seront mises à la disposition des participants de manière
à mettre en pratique les notions présentées.
1) Premiers pas en C
- Présentation du langage C, ses atouts.
- Le C++ par rapport au C.
- Les fichiers sources (.c, .h).
- Structure générale d'un programme.
- La syntaxe de base du langage.
- Les types de données et constantes de base.
- Variables globales et locales.
- Stockage et passage de paramètres.
- Entrées/sorties formatées.
- Les commentaires.
- Utilisation élémentaire de la chaîne de production.
- Les environnements d'édition, de compilation et d'exécution.
- Exécution d'un premier programme.
2) Opérateurs et expressions
- Opérateurs arithmétiques.
- Mécanismes d'évaluation des expressions.
- Post et pré-incrémentation de décrémentation.
- Précédence et associativité des opérateurs.
- Opérateurs d'affectation.
- Mécanismes de fonctionnement des expressions logiques.
- Expressions logiques dans les instructions while, if...
- Opérateurs de comparaison : , ==, !=...
- Opérateurs logiques : ET, OU, négation.
- Les types numériques composés. Règle de conversion dans les expressions mixtes. Conversions implicites/
explicites.
- Initialisation des variables.
- Arithmétique sur les adresses.
- Formats d'entrée/sortie associés aux types numériques.
- Opérateurs bit à bit : ET, OU, OU exclusif, complément à 1, négation. Opérateurs de décalage : >>,

- Equivalences pointeurs/tableaux.
- Calculs sur les pointeurs.
- Chaînes de caractères.
- Exemples de manipulation de chaînes de caractères.
Travaux pratiques
Manipulation de tableaux, pointeurs et des chaînes de caractères.
5) Les structures
- Intérêts des structures.
- Déclarer, initialiser et accéder aux champs d'une structure.
- Utiliser des structures imbriquées.
- Créer de nouveaux types en utilisant Typedef.
- Les champs de bits.
- Les unions.
- Les énumérations.
- Définir des pointeurs sur structures.
Travaux pratiques
Implémentation de nouvelles structures de données .
6) Les fonctions
- Définition d'une fonction.
- Appel d'une fonction.
- Passage de paramètres : par valeur ou par référence.
- Code retour d'une fonction. Les types de retour.
- La fonction " main ".
Travaux pratiques
Découper son code à l'aide de fonctions. Gérer les appels de fonctions.
7) Compilation séparée, classe d'allocation
- Mécanisme de fonctionnement de la chaîne de production.
- Utilisation de bibliothèque de sources.
- Notion de Makefile.
- Configuration mémoire d'un Programme C (pile, tas...).
- Classes d'allocation des variables (auto, register, static, extern).
- Différents cas de figure de la compilation séparée.
- Notion d'objet externe.
- Cas des données globales et statiques.
- Cas des données locales.
- Règle de visibilité.
- Compléments sur les fonctions et les initialisations.
8) Le préprocesseur
- Utilisation des macros prédéfinies (constantes symboliques). Définir ses propres macros avec #define.
- Définir des macros comme des fonctions. Utilisation des marqueurs # et ##.
- Annuler la définition de constante avec #undef.
- La compilation conditionnelle : #if, #ifdef, #ifndef, #elif, #endif.
- Inclure des ressources avec #include.
Travaux pratiques
Utilisation des directives du préprocesseur. Mise en place de la compilation conditionnelle.
9) Les bibliothèques standards
- Les fonctions de calcul mathématique (sqrt, sin...).
- Les fonctions d'entrées/sorties (fprintf, fscanf...).
- Les fonctions d'accès aux fichiers (fread, fwrite..).
- Les fonctions de manipulation de chaînes de caractères (strlen, strcat...)
- Les fonctions de gestion de la mémoire (malloc, free...).
- Mise en place de structures chaînées (listes chaînées, arbres n-aire...).
Travaux pratiques
Utilisation des principales fonctions des bibliothèques standards.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 13 / 86

Stage pratique de 5 jour(s)
Réf : C++
Participants
Ce cours s'adresse aux
ingénieurs qui souhaitent
acquérir une formation à
l'approche objet et aux
spécificités du langage C+
+. A l'issue de ce cours, ils
sauront utiliser ce langage
comme un véritable outil de
programmation objet.
Pré-requis
Bonnes connaissances du
langage C.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
3 fév. 2014, 3 mar. 2014
7 avr. 2014, 12 mai 2014
2 juin 2014, 7 juil. 2014
18 aoû. 2014, 15 sep. 2014
13 oct. 2014, 3 nov. 2014
8 déc. 2014
Aix
7 avr. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Bordeaux
14 avr. 2014, 16 juin 2014
8 sep. 2014, 1 déc. 2014
Bruxelles
14 avr. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Geneve
14 avr. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Lille
14 avr. 2014, 16 juin 2014
8 sep. 2014, 1 déc. 2014
Luxembourg
14 avr. 2014, 16 juin 2014
22 sep. 2014, 15 déc. 2014
Lyon
7 avr. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Nantes
24 fév. 2014, 19 mai 2014
28 juil. 2014, 1 sep. 2014
15 déc. 2014
Rennes
24 fév. 2014, 19 mai 2014
28 juil. 2014, 1 sep. 2014
15 déc. 2014
Sophia-antipolis
7 avr. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Strasbourg
14 avr. 2014, 16 juin 2014
8 sep. 2014, 1 déc. 2014
Toulouse
17 fév. 2014, 14 avr. 2014
16 juin 2014, 8 sep. 2014
1 déc. 2014
Programmation objet en C++
OBJECTIFS
Ce stage intensif a deux objectifs : initier les participants aux méthodes et réflexes de la programmation
par objets ; leur apporter une maîtrise opérationnelle complète du langage C++. Il est le fruit d'une longue
expérience en matière de développement en C++ et est construit selon une pédagogie rigoureuse reposant
sur des travaux pratiques nombreux et progressifs.
1) La syntaxe du C++ (différences entre C et C++)
2) Approche orientée objet
3) La programmation objet avec C++
4) Les exceptions
Travaux pratiques
5) La surcharge des opérateurs
6) Les modèles
7) Les I/O et aperçu sur la STL
8) Conclusion
Des stations de travail disposant des langages Visual C++ (sous Windows) et gcc (sous Unix) seront à
la disposition des participants pendant toute la durée du cours. Les exercices pratiques ont été conçus
pour illustrer tous les éléments du langage et pour systématiquement mettre en oeuvre les concepts de la
conception orientée objet : tous les exercices comportent une phase d'analyse/conception suivie d'une phase
de programmation.
1) La syntaxe du C++ (différences entre C et C++)
- Données : définition, initialisation, types de données.
- Expressions : notion de référence, mécanismes de cast.
- Opérateurs ( : :, new, delete).
- Fonctions (passage de paramètres et valeur de retour par référence, valeurs par défaut, inlining, surcharge).
- Utilisation du code C dans un programme C++.
- Les références (arguments et valeurs de retour).
- Les types constants.
- Les espaces de nommage.
Travaux pratiques
Prise en main de l'environnement de développement et programmation d'un programme simple.
2) Approche orientée objet
- Les principes généraux des techniques objet.
- C++ et la programmation objet.
- Une introduction aux méthodologies orientées " objets ".
- Une introduction aux modèles et à la notation UML (modèle statique, dynamique, modèle de coopération,
scénario).
Travaux pratiques
L'application des concepts à une étude de cas qui sera l'un des fils directeurs des exercices suivants.
3) La programmation objet avec C++
Les classes et les objets
- Les aspects syntaxiques : les champs, les méthodes, les constructeurs.
- Le contrôle d'accès.
- L'auto-référence.
- Les champs et méthodes statiques.
- Les fonctions.
- Les méthodes et les classes friend.
- La création dynamique des tableaux d'objets.
- Les aspects méthodologiques : la conception des classes.
- Les constructeurs de copie.
Dérivation et héritage
- Principe de la dérivation.
- Les aspects syntaxiques : la définition des classes dérivées, les constructeurs.
- Le contrôle d'accès.
- La mise en oeuvre du polymorphisme : les fonctions virtuelles.
- La réutilisation de code : les classes abstraites.
- La dérivation multiple.
- Les aspects sémantiques et méthodologiques : la factorisation du code.
Travaux pratiques
La programmation de l'étude de cas. La conception et la construction d'une hiérarchie de classes et
d'interfaces. La mise en place du polymorphisme dans l'étude de cas.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 14 / 86

4) Les exceptions
- Les aspects syntaxiques : les blocs de try, la génération des exceptions.
- Les aspects méthodologiques : la construction d'une hiérarchie d'exception, l'utilisation des exceptions.
Travaux pratiques
L'introduction des exceptions dans l'étude de cas.
5) La surcharge des opérateurs
- Principe de la surcharge.
- Surcharge des opérateurs binaires.
- Surcharge particulière : l'opérateur indice, fonction, conversion.
- Surcharge des opérateurs de gestion mémoire.
- Surcharge des opérateurs ''.
Travaux pratiques
La surcharge de quelques opérateurs simples.
6) Les modèles
- Modèle de classe. Principes et mécanismes généraux. Surcharge des modèles et redéfinition de méthodes.
- Modèle de fonction. Principes et mécanismes généraux. Surcharge des modèles.
- Modèles et surcharge des opérateurs.
- Les modèles et les mécanismes de dérivation.
Travaux pratiques
TP sur les modèles.
7) Les I/O et aperçu sur la STL
- Les I/O.
- Le principe des streams et la hiérarchie des classes d'entrée/sortie.
- Description de quelques classes d'entrées/sorties.
- Aperçu sur la STL.
- Objectifs et principes.
- Descriptions de quelques modèles et classes.
- Les conteneurs, les itérateurs.
8) Conclusion
- Cycle de vie du logiciel : test, intégration, méthode de mise en production.
- Interaction avec les autres environnements.
- Analyse critique du C++.
- Evolution du C++.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 15 / 86

Stage pratique de 4 jour(s)
Réf : POP
Participants
Concepteurs et développeurs
d'applications en C++,
chefs de projets, architectes
logiciels.
Pré-requis
Bonnes connaissances en
développement C++, ou
connaissances équivalentes à
celles apportées par le stage
" Programmation Objet en C
++ " (réf. C++). Expérience
requise.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
25 fév. 2014, 1 avr. 2014
24 juin 2014, 9 sep. 2014
21 oct. 2014, 18 nov. 2014
16 déc. 2014
Programmation C++, perfectionnement
OBJECTIFS
En constante évolution, le langage C++ offre des mécanismes tels que la généricité ou la métaprogrammation
qui permettent une conception robuste et très riche. Les récentes normes Technical
Report TR1 et TR2 déjà intégrées dans C++ reprennent l'essentiel des bibliothèques du projet BOOST qui
améliorent notablement la Standard Template Library (STL). Cette formation vous permettra d'approfondir la
conception en C++ par l'apprentissage de très nombreux mécanismes et l'utilisation effective de la STL.
1) Rappels
2) Gestion des opérateurs
3) Conversion et RTTI
4) La généricité
Travaux pratiques
5) La STL (Standard Template Library)
6) BOOST
7) Utilisation avancée de l'héritage
Le cours se déroulera sur des stations de travail sous Windows/Visual C++. De nombreux exercices
permettront de mettre en oeuvre les thèmes abordés plus spécifiquement sous l'angle de la conception.
1) Rappels
- Classes d'allocation mémoire.
- Construction, initialisation, embarquement d'objets.
- Les fuites mémoires.
- Constance, le mot-clé mutable, Lazy Computation.
- Amitié (friendship) C++ et contrôle d'accès.
- Destruction virtuelle.
- Stratégie de gestion des exceptions.
- Organisation logiques de l'application : les espaces de nommage (namespace).
2) Gestion des opérateurs
- Opérateurs binaires et unaires.
- L'opérateur d'indirection, cas d'usage.
- L'opérateur de référencement.
- Les opérateurs d'incrémentation/décrémentation pré-fixés et post-fixés.
- Les autres opérateurs : comparaison, affectation...
- La surcharge de l'opérateur [], des opérateurs d'insertion (

- Les conteneurs séquentiels et associatifs : définition, rôle et critères de choix.
- Les allocateurs et la gestion de la mémoire des conteneurs.
- Les méthodes d'insertion, de suppression, d'itération et d'accès aux principaux conteneurs : Vector, List,
Set, Stack...
- Le concept d'itérateur. Parcours d'un conteneur.
- Les différents groupes d'algorithmes STL : non mutants, mutants, de tri et de fusion, numériques.
- Manipulation de conteneurs (manipulation, recherche de valeurs...).
- Paramétrer les algorithmes génériques par des objets " fonction ".
- Les " adapteurs " et la modification du comportement d'un composant.
- La STL et les traitements sur les flux (fichiers, mémoire...).
- Principe du RAII : les pointeurs automatiques et la classe auto_ptr.
- Les exceptions standard de la STL.
Travaux pratiques
Implémentation des relations avec les collections de la STL. Utilisation d'algorithmes standard quelconques.
6) BOOST
- Présentation de Boost et de l'extension TR1 (Technical Report 1).
- Les nouveaux conteneurs.
- Les pointeurs intelligents (smart pointers) : shared_ptr, weak_ptr, unique_ptr.
- La Pointer Container Library (destruction des données pointées d'un conteneur).
- Foncteurs, binders et lambda-expressions.
- Programmation événementielle (connexions et signaux). Introduction à la gestion des threads.
- Gestion des processus, mécanismes de communication interprocessus et mémoire partagée.
- Les structures de données (Tuple, Any, Variant).
Travaux pratiques
Mise en oeuvre de la robustesse avec les smart pointers de BOOST.
7) Utilisation avancée de l'héritage
- Héritage versus embarquement. Héritage privé. Héritage protégé.
- Exportation de membres cachés avec la Clause Using.
- Héritage multiple et gestion des collisions de membres.
- Héritage en diamant. Héritage virtuel et dynamic_cast.
- Principes fondamentaux de conception : substitution de Liskov, principe d'ouverture/fermeture, inversion
des dépendances
- Règles d'implémentation des interfaces en C++.
Travaux pratiques
Combinaison de l'héritage multiple, privé et de l'exportation pour concevoir des classes robustes et
hautement évolutives.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 17 / 86

Stage pratique de 2 jour(s)
Réf : TDE
Participants
Ce cours s'adresse aux
développeurs Java et C#
souhaitant acquérir des
connaissances spécifiques au
développement C++.
Pré-requis
Maîtrise de C# ou de Java
ainsi que des concepts de
programmation orientée objet.
Eligible DIF
C++, mise à niveau pour les développeurs C# et Java
OBJECTIFS
Windows 8 a relancé l'intérêt du langage C++ auprès de développeurs pratiquant le C# et Java. Sur la base
de vos connaissances objets, ce cours vous assurera une transition douce vers le C++ 11. Vous apprendrez
comment C++ et sa librairie standard permettent d'écrire du code efficace et robuste pour vos applications.
1) Rappel des concepts de base du
développement C++
2) Présentation des concepts C++ avancés
3) Librairie standard : la BCL de C++
4) Syntaxe C++ avancée
5) C++ et l'interopérabilité
1) Rappel des concepts de base du développement C++
- Les différents fichiers sources (.h, .cpp...).
- Linkage et compilation de code écrit en C++.
- Ecriture de classes et structures : la syntaxe de base.
- Réutilisation de composants déjà compilés : .lib, .dll, .h etc.
Travaux pratiques
Création d'une solution multi-projets en C++, avec linkage statique et dynamique.
2) Présentation des concepts C++ avancés
- Instanciation "statique" versus instanciation "dynamique" d'objets.
- Les différents types de constructeurs (par défaut, par copie...).
- Gestion de la mémoire sans garbage collector (manuellement ou en utilisant les smart pointers de la librairie
standard).
- Héritage multiple : cas pratiques et pièges à éviter.
- Les Templates.
- Orientation objet et comparaison avec C#.
Travaux pratiques
Atelier de manipulation des smart pointers de la librairie standard.
3) Librairie standard : la BCL de C++
- Représentations mémoires possibles d'une chaîne de caractère et manipulation avec std::string et
std::wstring.
- Introduction à la stl (standard template library).
- Containers et itérateurs, les collections C++.
Travaux pratiques
Atelier de manipulation de chaînes de caractères et de collections en C++.
4) Syntaxe C++ avancée
- Inférence de types et mot-clef automatique.
- Orientation fonctionnelle du langage : Lambdas, Functors... et utilisation avec la stl.
- Asynchronisme et parallélisation avec C++ 11.
- Utilisation d'objets COM Microsoft, avec et sans smart pointers.
Travaux pratiques
Exercice d'introduction à la parallel platform library, et manipulation d'expressions Lambda. Cas pratique de
consommation d'objets COM, illustration avec Direct 2D.
5) C++ et l'interopérabilité
- Publication d'objets COM Windows réutilisables.
- Interopérabilité avec .Net sur le Desktop : C++ CLI.
- Interopérabilité avec .Net et JavaScript dans les applications Metro : C++ / CX.
Travaux pratiques
Création d'une application métro hybride C# / Xaml + C++ / Direct 2D.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 18 / 86

Stage pratique de 5 jour(s)
Réf : CQT
Participants
Ce cours est destiné aux
développeurs et chefs de
projets amenés à mettre
en place des applications
graphiques utilisant le
Framework QT.
Pré-requis
Bonnes connaissances du
langage C++. Connaissances
de base en XML. Expérience
requise en développement C
++.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
17 mar. 2014, 12 mai 2014
8 sep. 2014, 24 nov. 2014
C++, développement d'applications graphiques en QT
OBJECTIFS
QT est un Framework orienté Objet qui offre des composants d'interface graphique (widgets), d'accès aux
données, de connexions réseaux, etc. Cette formation vous apprendra à identifier les éléments importants
d'un projet QT et les différents composants graphiques proposés, et à les utiliser avec le XML.
1) Présentation du langage QT
2) Les différents types de projets
3) Les éléments importants d'un projet
4) Les différents composants graphiques
1) Présentation du langage QT
- Historique du langage.
- Les différentes possibilités d'utilisation.
- Les autres librairies graphiques existantes.
2) Les différents types de projets
- Présentation des différents types de projet avec QT.
- Présentation de QT Creator.
- La structure de base d'une application à base d'IHM.
Exercice
Création d'une première application QT.
3) Les éléments importants d'un projet
5) La gestion des événements
6) Le système de Plug-in de QT
7) Aller plus loin avec QT
- Fichiers pro, de conception graphique (ui).
- Les fichiers de gestion d'internationalisation (ts et qm).
- Les types de bases du langage (qint, qfloat...).
- La compilation avec qmake.
- La classe QObject.
- Présentation du modèle MVC.
- Le modèle MVC dans QT.
Exercice
Etude d'un fichier projet pour la mise en place de l'application.
4) Les différents composants graphiques
- Les composants de base de l'IHM (QMainWindow, QFrame, QLabel...).
- La gestion du positionnement des composants.
- Les boîtes de dialogue (QDialog).
- Les menus (QMenu).
- Modèles prédéfinis et personnalisés.
- Les outils de conception visuelle de QT (QT Designer...).
Exercice
Mise en place de la structure de l'application.
5) La gestion des événements
- Notions de signal et slot.
- Déclaration de signaux et de slots.
- Installer des filtres d'événement.
- Accéder à l'application pendant un traitement lourd (timer et hasPendingEvents).
Exercice
Ajout de la gestion des événements à l'application
6) Le système de Plug-in de QT
- Comprendre ce que sont les Plug-ins avec QT.
- Les différentes classes de plugin (QStylePlugin...).
- Les éléments nécessaires à la mise en place d'un Plug-in pour QT.
- Mise au point d'application gérant des Plug-ins.
Exercice
Mise au point d'un plugin simple.
7) Aller plus loin avec QT
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 19 / 86

- Utilisation de XML avec QT. Rappel sur XML, les parsers DOM et SAX. Parsing de documents XML en
utilisant QT.
- L'internationalisation. Rappel sur Unicode. L'objet QTranslator. L'application QT Linguist.
- Applications multiplateformes. QT Mobility.
Exercice
Utilisation d'un fichier XML pour stocker les données de l'application. Internationalisation de l'application.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 20 / 86

Stage pratique de 3 jour(s)
Réf : MUC
Participants
Développeurs, architectes
logiciels, chefs de projet.
Pré-requis
Programmer vos applications en Multicore
OBJECTIFS
Vous découvrirez les architectures Multicore et leur programmation, les techniques de mise en œuvre d'une
approche multithread ou multiprocessus et les langages dédiés à la programmation parallèle. Vous étudierez
également les contraintes en matière de synchronisation d'accès aux données et les précautions à prendre.
Bonnes connaissances d'un
des 3 langages Objet utilisés
dans le cours (Java, C#,
C++). Connaissances de
base des concepts liés aux
applications Multicore.
1) Introduction
2) Modélisation des applications
3) Threads
Travaux pratiques
4) Processus
5) La programmation parallèle
6) Synthèse et conclusion
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
31 mar. 2014, 7 avr. 2014
30 juin 2014, 6 oct. 2014
3 nov. 2014, 15 déc. 2014
Les exercices et les exemples s'appuieront sur Java, C++ et C# via les IDE Visual Studio et NetBeans.
BOUML sera utilisé pour la modélisation UML.
1) Introduction
- Enjeux de la programmation Multicore.
- Tableau des technologies utilisables : processus, thread et parallélisme.
- Description du fonctionnement d'un processeur.
- Architecture en "Hyperthreading".
- Architectures des processeurs INTEL et AMD.
- Architectures NVidia et API.
2) Modélisation des applications
- Importance des aspects modélisation.
- Parallélisation des traitements.
- Utilisation des mécanismes asynchrones.
- Développer une nouvelle application : précautions et modélisation. Eviter les "singletons".
- Modifier une application existante en Multicore.
- Choix d'architecture : un compromis synchronisation et performance. Choix multiprocessus/multithreads.
3) Threads
- Threads dans les systèmes et les langages (Java, .NET...).
- Apport des threads dans une application industrielle.
- Ordonnancement des threads. Le "round robin".
- Gestion des stacks et "call stack" dans les threads.
- Débogueurs multithreads : Visual Studio, NetBeans...
- Gestion des objets de synchronisation : sections critiques, Mutex et Sémaphores.
- Développer "Thread safe".
- API de threads avec Windows, Java et .NET. API POSIX.
Travaux pratiques
Threads et synchronisation en DOT Net, Java et C++.
4) Processus
- Espaces d'adressage des processus, organisation.
- Critères de choix d'une approche multiprocessus.
- Techniques de communication interprocessus (IPC).
- Outils de debugging multiprocessus.
- Avantage et inconvénients des techniques multiprocessus.
- Les "Domain" DOT Net.
Travaux pratiques
Gestion de traitements asynchrones avec l'API Windows.
5) La programmation parallèle
- Apport et objectifs de la programmation parallèle.
- "Parallel FX" la bibliothèque DOT Net.
- Architecture PFX et philosophie.
- Composants TPL et PLINQ.
- La librairie "OpenMp" C++.
- Utiliser les GPU des cartes graphiques pour le calcul.
- Kits de NVidia (CUDA) et ATI.
Travaux pratiques
Paralléliser des algorithmes avec PFX en C# et avec "OpenMP" en C++.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 21 / 86

6) Synthèse et conclusion
- Conclusion des techniques étudiées.
- Avenir du C++ avec le multicore.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 22 / 86

Stage pratique de 4 jour(s)
Réf : CUD
Participants
Concepteur et développeur
d'applications en C++, chef de
projets, architecte logiciel.
Pré-requis
Bonne connaissance du
langage C++, expérience
requise. Connaissances de
base des threads de l'API
Windows.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
11 mar. 2014, 10 juin 2014
9 sep. 2014, 9 déc. 2014
C++, programmer avec CUDA, OpenMP et les PPL Visual
Studio
OBJECTIFS
Cette formation vous propose de découvrir, d'évaluer et de manipuler différentes librairies pour la
programmation parallèle en C++. Vous acquerrez toutes les connaissances nécessaires à la mise en
oeuvre de traitements parallèles. Vous maîtriserez également les Design Patterns spécifiques à ce type de
développement.
1) Introduction
2) Les threads dans le C++ 11 et la librairie Boost
3) Les Patterns du parallélisme
Travaux pratiques
4) Le GPU Computing avec CUDA et le C++ AMP
5) Le standard OpenMP et la Parallel Patterns
Library
6) Conclusion
Développement d'une application de test. Evaluation des différentes solutions proposées et patterns de
développement pour le traitement parallèle.
1) Introduction
- Présentation des librairies étudiées.
- Rappel de la gestion des threads sous Windows.
- Les nouveautés de Visual Studio 2010 et 2012.
- L'instrumentation du code.
- Les problèmes liés à l'utilisation des threads.
Travaux pratiques
Elaboration d'une application de test des différentes Solutions étudiées. Instrumentation du code de
l'application de test afin de constater les variations dans les exécutions.
2) Les threads dans le C++ 11 et la librairie Boost
- Rappel sur les expressions Lambda et les smart pointers.
- La gestion des Threads. La Synchronisation.
- Comparaison entre l'implémentation du C++ 11, la librairie Boost.Thread et l'API de Windows.
- Le Parallel Aggregation Pattern.
Travaux pratiques
Mise en œuvre des threads dans l'application de test.
3) Les Patterns du parallélisme
- Adapter les Patterns orientés Objets.
- Le Parallel Loop Pattern.
- Le Parallel Task Pattern.
- Le Parallel Aggregation Pattern.
- Le Futures Pattern.
- Le Pipelines Pattern.
Travaux pratiques
Réflexions sur la mise en œuvre des différents Patterns avec les librairies de parallélisme sur l'application de
test.
4) Le GPU Computing avec CUDA et le C++ AMP
- Présentation des librairies DirectCompute, OpenCL et NPP dans l'architecture de CUDA.
- Installation du driver spécifique de NVIDIA,
- Installation du SDK de CUDA.
- Installation de NSight.
- Présentation de CUDA C/C++.
- Présentation du C++ AMP.
Travaux pratiques
Mise en œuvre des fonctions d'une librairie de CUDA, évaluation et profilage des exécutions de l'application
de test. Comparaison avec la syntaxe du C++ AMP et évaluation.
5) Le standard OpenMP et la Parallel Patterns Library
- Les constructions d'OpenMP et l'utilisation des pragmas, comparaison avec les threads du C++ 11.
- OpenMP.
- La Parallel Patterns Library.
- Le Concurrency Runtime et les nouvelles fonctionnalités de C++.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 23 / 86

- Comparaison avec OpenMP.
- Les fonctions de travail.
Travaux pratiques
Mise en œuvre des différents Patterns avec OpenMP et la PPL sur l'application de test.
6) Conclusion
- Les bonnes pratiques, l'architecture.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 24 / 86

Stage pratique de 4 jour(s)
Réf : LXT
Participants
Développeurs Linux/Unix.
Pré-requis
Bonnes connaissances d'un
système Linux/Unix et de la
programmation en C.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
18 fév. 2014, 18 mar. 2014
22 avr. 2014, 20 mai 2014
17 juin 2014, 15 juil. 2014
26 aoû. 2014, 23 sep. 2014
21 oct. 2014, 25 nov. 2014
15 déc. 2014
Aix
11 mar. 2014, 3 juin 2014
14 oct. 2014, 2 déc. 2014
Bordeaux
1 avr. 2014, 24 juin 2014
30 sep. 2014, 18 nov. 2014
Bruxelles
1 avr. 2014, 24 juin 2014
30 sep. 2014, 9 déc. 2014
Geneve
1 avr. 2014, 24 juin 2014
30 sep. 2014, 9 déc. 2014
Lille
1 avr. 2014, 24 juin 2014
30 sep. 2014, 18 nov. 2014
Luxembourg
1 avr. 2014, 24 juin 2014
30 sep. 2014, 9 déc. 2014
Lyon
11 mar. 2014, 3 juin 2014
14 oct. 2014, 2 déc. 2014
Nantes
25 mar. 2014, 17 juin 2014
1 juil. 2014, 7 oct. 2014
9 déc. 2014
Rennes
25 mar. 2014, 17 juin 2014
1 juil. 2014, 7 oct. 2014
9 déc. 2014
Sophia-antipolis
11 mar. 2014, 3 juin 2014
14 oct. 2014, 2 déc. 2014
Strasbourg
1 avr. 2014, 24 juin 2014
30 sep. 2014, 18 nov. 2014
Toulouse
1 avr. 2014, 24 juin 2014
30 sep. 2014, 18 nov. 2014
Linux industriel, temps réel et embarqué
OBJECTIFS
Découvrir les outils de développement industriel disponibles librement sous Linux. Maîtriser les mécanismes
d'ordonnancement, connaître leurs possibilités. Accéder au développement temps réel strict avec l'extension
LinuxRT ou Xenomai. Déployer Linux sur des systèmes embarqués en équilibrant les performances et
l'occupation mémoire.
1) Architecture
2) Développement industriel sous Linux
3) Ordonnancement temps partagé et réel souple
Travaux pratiques
4) Temps réel strict - Extension Xenomai
5) Environnements restreints, systèmes
embarqués
6) Personnalisation du boot du système
Les nombreux exercices et études de cas progressifs sont réalisés sur un réseau de serveurs Linux. Tous les
programmes réalisés en TP existent sous forme de squelettes que les participants complètent eux-mêmes.
1) Architecture
- Système informatique ordinaire et Système embarqué.
- Contraintes d'un système embarqué.
- Architecture générale d'un système embarqué.
- Démarrage du système, étape de boot.
- Architecture du noyau Linux. Emplacement des sources.
- Démarrage du système, phases de boot (code dépendant, commun).
Travaux pratiques
Détection d'erreur à la compilation, à l'édition des liens, utilisation d'Eclipse/CDT, utilisation d'une chaîne
de compilation croisée. Débogage. Détection des fuites mémoire et des débordements de buffers. Test de
couverture sur l'exécution d'une application.
2) Développement industriel sous Linux
- Environnement Linux.
- Mode de fonctionnement : utilisateur, superviseur.
- Licences et implications pour le développement industriel.
- Outils de développement libres (compilateur, debugger, outils d'analyse, de trace et de tests).
- Les différents IDE (Integrated Development Environment) : Eclipse, ...
- Méthodes de compilation avancées.
- La chaîne de compilation croisée.
- La gestion de mémoire.
- La détection des fuites mémoire.
- Le débordement de buffers.
3) Ordonnancement temps partagé et réel souple
- Précision des mesures horaires et des attentes.
- Ordonnancement temps partagé. Les règles de la préemptibilité.
- Le fonctionnement général de l'ordonnanceur, priorités et partage du CPU.
- Quand le noyau devient-il préemptible ?
- Gestion du temps et la précision des timers.
- Temps réel souple Posix.1b : principes.
- Configuration de l'ordonnancement des processus et des threads.
- Problèmes algorithmiques liés au temps réel.
- L'ordonnanceur Linux : noyaux 3.x
Travaux pratiques
Création et gestion de processus. Priorités et partage du CPU. Examen du fonctionnement de
l'ordonnanceur. Basculement de processus en temps réel. Vérification de la précision des timers et des
sommeils.
4) Temps réel strict - Extension Xenomai
- Principe du temps réel strict.
- Vue d'ensemble de l'extension Xenomai.
- Concepts de temps réel strict : principe des micro-noyaux Adeos, Xenomai, LinuxRT.
- Installation et API de Xenomai.
- Utilisation de l'extension LinuxRT.
- Ordonnancement temps réel strict en mode utilisateur.
- Interruptions (activation, désactivation, ...).
- Protection contre les interruptions.
- Gestion des communications.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 25 / 86

- Présentation de l'API de Xenomai, installation de Xenomai.
- La gestion des tâches temps réel strict.
Travaux pratiques
Installation de Xenomai. Création de tâches temps réel strict. Gestion des communications. Ecriture d'un
gestionnaire d'interruption, de processus ordonnancé en temps réel strict. Installation et utilisation de
Xenomai.
5) Environnements restreints, systèmes embarqués
- Problématique des systèmes embarqués.
- Système LinuxRT, Xenomai : API, développement.
- Linux embarqué : choix d'une version du noyau.
- Bibliothèques système (Newlib, DietLibc).
- Applications et utilitaires à embarquer.
- Interface utilisateur.
- Interfaces graphiques optimisées (directfb, etc).
- Présentation et configuration d'un chargeur de démarrage.
- Générer un noyau réduit. Généralité sur le système de fichiers
- Installation de la chaîne de compilation.
Travaux pratiques
Installation, compilation d'une application personnalisée LinuxRT, Xenomai et d'un noyau de taille réduite.
Création d'un système de fichiers. Incorporation d'applications minimales. Ecriture d'application utilisant une
interface par Leds ou afficheur LCD. Installation d'un serveur HTTP embarqué.
6) Personnalisation du boot du système
- Les différentes phases de boot (mise sous tension, Bios, chargeur (Grub, UBoot...) du noyau.
- Le rôle du processus Init. Le niveau d'exécution.
- Le contenu du processus init.
- Le remplacement du processus Init par une version personnalisée.
- Initialisation depuis l'espace utilisateur.
Travaux pratiques
Création et personnalisation d'un disque initrd. Remplacement du processus Init par une version
personnalisée et remplacement par un script shell.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 26 / 86

Stage pratique de 4 jour(s)
Réf : LIS
Participants
Développeurs Linux/Unix.
Pré-requis
Bonne connaissance d'un
système Linux/ Unix et de la
programmation en C.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
11 fév. 2014, 1 avr. 2014
17 juin 2014, 30 sep. 2014
9 déc. 2014
Bruxelles
18 mar. 2014, 19 mai 2014
23 sep. 2014, 18 nov. 2014
Geneve
18 mar. 2014, 19 mai 2014
23 sep. 2014, 18 nov. 2014
Luxembourg
18 mar. 2014, 19 mai 2014
23 sep. 2014, 18 nov. 2014
Développeur système sous Linux/Unix
OBJECTIFS
Cette formation vous permettra de maîtriser toutes les facettes de la programmation applicative : gestion des
processus et threads, gestion fine du système de fichiers et de la mémoire, et bien entendu l'ensemble des
outils de communication interprocessus.
1) Outils et méthodes de développement
2) Les processus
3) Les threads Posix
4) Communications entre processus
Travaux pratiques
5) Gestion de la mémoire
6) Signaux
7) Communiquer sur le réseau
8) Entrées-sorties classiques et avancées
Les exercices et études de cas progressifs sont réalisés sur un réseau de serveurs Linux. Tous les TP
existent sous forme de squelettes à complèter.
1) Outils et méthodes de développement
- Environnement Linux : influences, logiciels libres, licence GPL, distributions.
- Outils de développement : Editeurs et environnements intégrés, compilateurs et constructeurs, profileurs et
débogueurs.
Travaux pratiques
Prise en main des outils de développement (gcc, make...).
2) Les processus
- Concept de processus, identifications.
- Création, terminaison d'un processus et exécution.
- Problèmes de sécurité.
3) Les threads Posix
- Principe des threads Posix.1c.
- Exécution et terminaison des threads.
- Synchronisation des threads : Utilisation des mutex et des variables conditions.
4) Communications entre processus
- Files de messages : Principe. Files de message System V et Posix.
- Mémoire partagée : Principe. Segments de mémoire System V et Posix.
- Synchronisation des accès : Sémaphores Posix et nommés.
- Tubes de communication : Création d'un tube, redirection des entrées-sorties, tubes nommés.
5) Gestion de la mémoire
- Principes de la mémoire virtuelle : Espace d'adressage et mémoire physique. Segmentation et pagination.
Fautes de page.
- Allocation de la mémoire : Fonctions classiques, exploration de l'espace d'adressage, réussite et échec
d'allocation.
- Utilisation de la mémoire : projection, configuration, détection des fuites et débordements mémoire.
6) Signaux
- Gestion des signaux : émission et réception de signaux, blocages et attentes.
- Signaux temps réel : principes. Emission et réception.
7) Communiquer sur le réseau
- Appels système fondamentaux : résolution de noms, de services, création de sockets.
- Communication TCP/IP et UDP/IP : serveurs multiprocessus et multithreads, clients TCP.
- Transmission unicast, multicast et broadcast.
8) Entrées-sorties classiques et avancées
- Descripteurs et flux : concepts, utilisation, paramétrage.
- Entrées-sorties avancées : entrées-sorties non bloquantes et multiplexées, asynchronisme.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 27 / 86

Stage pratique de 4 jour(s)
Réf : OBC
Participants
Développeurs désirant
programmer dans un
environnement Apple sous
MacOSX et voulant se
diriger vers les filières de
développement iPhone/iPad.
Pré-requis
Bonnes connaissances en
développement logiciel.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
11&18 mar. 2014, 10 juin
2014
9 sep. 2014, 9 déc. 2014
Objective C, programmation
OBJECTIFS
A l'issue, vous serez à même de programmer en Objective-C dans l'environnement Cocoa MacOSX et aurez
toutes les bases nécessaires pour vous orienter vers les plateformes mobiles iPhone/iPad. Au travers de
nombreux exercices, vous apprendrez à manipuler SDK et les outils proposés par Apple.
1) Eléments de base
2) Eléments avancés
1) Eléments de base
- Programmation en Objective-C.
- Classes, Objets et Méthodes.
- Types de données et expressions.
- Booléens, complexes et imaginaires.
- Structures de contrôle : if, while, do, break.
3) Eléments additionnels
4) Le Foundation Framework sous MacOSX
(Environnement Cocoa)
Exercice
Exercices sur les classes, objets et méthodes, les différents types de données, les structures de contrôle.
2) Eléments avancés
- Les classes en détail.
- Mécanismes d'héritage.
- Polymorphisme, éléments dynamiques.
- Variables et types de données.
- Catégories et protocoles.
Travaux pratiques
Mécanismes d'héritage. Manipulation des catégories et des protocoles.
3) Eléments additionnels
- Le préprocesseur.
- Eléments empruntés au langage C.
Travaux pratiques
Mécanismes de compilation et de préprocesseur.
4) Le Foundation Framework sous MacOSX (Environnement Cocoa)
- Introduction.
- Présentation du SDK et de l'environnement Cocoa Apple.
- Utilisation de XCode pour programmer en environnement MacOSX.
- Nombres, chaînes et énumérations.
- Travailler avec les fichiers.
- Gestion de la mémoire.
- Copier les objets.
- Archivage.
Travaux pratiques
Programmes en environnement SDK. Manipulation des éléments du Framework Foundation. Manipulation de
la mémoire. Mécanismes d'archivage.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 28 / 86

Stage pratique de 5 jour(s)
Réf : PYT
Participants
Ce cours s'adresse aux
ingénieurs qui souhaitent
acquérir une formation à
l'approche Objet et aux
spécificités du langage
Python.
Pré-requis
Connaissances de base en
programmation.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
3 fév. 2014, 31 mar. 2014
12 mai 2014, 30 juin 2014
20 oct. 2014, 15 déc. 2014
Sophia-antipolis
3 fév. 2014
Python, programmation objet
OBJECTIFS
Ce stage intensif a pour objectifs d'initier les participants aux méthodes et aux réflexes de la Programmation
Orientée Objet et de leur apporter la maîtrise opérationnelle du langage Python.
1) Syntaxe du langage Python
2) Approche Orientée Objet
3) Programmation Objet en Python
4) Utilisation StdLib
1) Syntaxe du langage Python
5) Outils QA
6) Création IHM TkInter
7) Interfaçage Python/C
8) Conclusion
- Les identifiants et les références. Les conventions de codage et les règles de nommage.
- Les blocs, les commentaires.
- Les types de données disponibles.
- Les variables, l'affichage formaté, la portée locale et globale.
- La manipulation des types numériques, la manipulation de chaînes de caractères.
- La manipulation des tableaux dynamiques (liste), des tableaux statiques (tuple) et des dictionnaires.
- L'utilisation des fichiers.
- La structure conditionnelle if/elif/else.
- Les opérateurs logiques et les opérateurs de comparaison.
- Les boucles d'itérations while et for. Interruption d'itérations break/continue.
- La fonction range.
- L'écriture et la documentation de fonctions.
- Les Lambda expression.
- Les générateurs.
- La structuration du code en modules.
Travaux pratiques
Installation et prise en main de l'interpréteur Python.
2) Approche Orientée Objet
- Les principes du paradigme Objet.
- La définition d'un objet (état, comportement, identité).
- La notion de classe, d'attributs et de méthodes.
- L'encapsulation des données.
- La communication entre les objets.
- L'héritage, transmission des caractéristiques d'une classe.
- La notion de polymorphisme.
- Association entre classes.
- Les interfaces.
- Présentation d'UML.
- Les diagrammes de classes, de séquences, d'activités...
- Notion de modèle de conception (Design Pattern).
Travaux pratiques
Modélisation en UML d'un cas d'étude simple.
3) Programmation Objet en Python
- Les particularités du modèle objet de Python.
- L'écriture de classes et leur instanciation.
- Les constructeurs et les destructeurs.
- La protection d'accès des attributs et des méthodes.
- La nécessité du paramètre Self.
- L'héritage simple, l'héritage multiple, le polymorphisme.
- Les notions de visibilités.
- Les méthodes spéciales.
- L'introspection.
- L'implémentation des interfaces.
- Les bonnes pratiques et les modèles de conception courants.
- L'utilisation du mécanisme d'exception pour la gestion des erreurs.
Travaux pratiques
Pratique des différents concepts objets au travers de l'implantation de l'étude de cas.
4) Utilisation StdLib
- Les arguments passés sur la ligne de commande.
- L'utilisation du moteur d'expressions régulières Python avec le module "re", les caractères spéciaux, les
cardinalités.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 29 / 86

- La manipulation du système de fichiers.
- Présentation de quelques modules importants de la bibliothèque standard : module "sys", "os", "os.path".
- Empaquetage et installation d'une bibliothèque Python.
- Les accès aux bases de données relationnelles, le fonctionnement de la DB API.
Travaux pratiques
Mise en oeuvre de modules Python : expressions régulières, accès à une base de données,
5) Outils QA
- Les outils d'analyse statique de code (pylint, pychecker).
- L'analyse des comptes rendus d'analyse (types de messages, avertissements, erreurs).
- Extraction automatique de documentation.
- Le débogueur de Python (exécution pas à pas et analyse post-mortem).
- Le développement piloté par les tests.
- Les modules de tests unitaires Python (Unittest...).
- L'automatisation des tests, l'agrégation de tests.
- Les tests de couverture de code, profiling.
Travaux pratiques
Utilisation des outils pylint et pychecker pour la vérification d'un code Python. Mise en oeuvre de tests
unitaires.
6) Création IHM TkInter
- Les principes de programmation des interfaces graphiques.
- Présentation de la bibliothèque TkInter.
- Les principaux conteneurs.
- Présentation des widgets disponibles (Button, Radiobutton, Entry, Label, Listbox, Canvas, Menu, Scrollbar,
Text...).
- Le gestionnaire de fenêtres.
- Le placement des composants, les différents layouts.
- La gestion des événements, l'objet event.
- Les applications multifenêtres.
Travaux pratiques
Conception d'une interface graphique avec la bibliothèque Tkinter.
7) Interfaçage Python/C
- Présentation du module Ctypes.
- Le chargement d'une librairie C.
- Appel d'une fonction.
- La réécriture d'une fonction Python en C avec l'API Python/C.
- La création de modules C pour Python avec Pyrex.
- L'Interpréteur Python dans C.
- L'utilisation du profileur de code.
Travaux pratiques
Appel de fonctions écrites en C depuis Python. Création de modules C pour Python avec Pyrex.
8) Conclusion
- Analyse critique de Python.
- L'évolution du langage.
- Eléments de Webographie et de bibliographie.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 30 / 86

Stage pratique de 4 jour(s)
Réf : FPY
Participants
Développeurs Python.
Pré-requis
Bonnes connaissances
en programmation ou
connaissances équivalentes
à celles apportées
par le stage " Python,
programmation Objet " (réf.
PYT). Expérience souhaitable
en développement Python.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
4 mar. 2014, 10 juin 2014
7 oct. 2014, 9 déc. 2014
Développer avec les frameworks Python
OBJECTIFS
Cette formation vous permettra d'améliorer vos développements d'applications Web en Python au moyen
des Frameworks les plus utilisés. Vous découvrirez leur rôle, apprendrez dans quel contexte les utiliser, les
bonnes pratiques de développement associées et acquerrez l'autonomie nécessaire à leur mise en oeuvre.
1) Introduction
2) Le Framework Turbogears
3) Le Framework Django
Travaux pratiques
4) Le Framework CubicWeb
5) Conclusion
Chaque Framework sera installé durant le cours. Pour chacun d'eux, une application sera réalisée pour
mettre en application les différents concepts.
1) Introduction
- Historique et évolution des solutions Web en Python.
- Présentation du standard WSGI, du middleware.
- Interfaçage avec les bases de données relationnelles.
- Aperçu des Frameworks leaders, et de leur rôle.
Travaux pratiques
Démonstrations des différents Frameworks. Création d'une mini-application avec accès à une base de
données.
2) Le Framework Turbogears
- Un Framework MVC pour le développement Web.
- Mise en place de l'environnement (dépendances, installation, architecture).
- Présentation de SQLAlchemy.
- Gestion des URL, moteur de template (Genshi, Mako).
- Authentification avec repoze, gestion des autorisations.
- Mode de déploiement.
Travaux pratiques
Installation du framework. Développement d'une mini-application Web MVC avec Turbogears.
3) Le Framework Django
- Un Framework MVC pour le développement Web.
- Mise en place de l'environnement (dépendances, installation, manage.py).
- Modèle de données Django, présentation de l'ORM.
- Interface d'administration. Gestion des URL, moteur de template. Middlewares courants.
- Authentification et autorisation. Mode de déploiement.
Travaux pratiques
Mise en place de Django. Ecriture d'une application à l'aide d'un Template. Mise en oeuvre des principales
fonctionnalités.
4) Le Framework CubicWeb
- Un framework pour le développement d'applications Web sémantique.
- Mise en place de l'environnement (dépendances, installation, cubicweb-ctl).
- Modèle de données Yams.
- Présentation du langage d'interrogation RQL.
- Fédération des sources de données.
- Authentification et autorisation.
- Vers le Web sémantique, comparaison SPARQL et RQL.
- Mode de déploiement.
Travaux pratiques
Installation de CubicWeb. Intégration de données sémantiques dans une application Web. Ecriture de
requêtes RQL.
5) Conclusion
- Choisir la technologie adaptée. Du script CGI au Web sémantique.
- Programmation asynchrone : Ajax, Comet, le problème C10K. Architecture REST et Python.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 31 / 86

Stage pratique de 4 jour(s)
Réf : DJA
Participants
La formation est destinée
aux développeurs souhaitant
acquérir une connaissance
approfondie des bases du
Framework Django.
Pré-requis
Connaissances des bases
du langage Python et
technologies Web (HTML,
JavaScript...)
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
25 fév. 2014, 18 mar. 2014
22 avr. 2014, 20 mai 2014
24 juin 2014, 15 juil. 2014
30 sep. 2014, 27 oct. 2014
25 nov. 2014, 15 déc. 2014
Django, développement Web avec Python
OBJECTIFS
Django est un Framework Web MVC (Modèle-Vue-Contrôleur) basé sur le langage Python. Ce stage vous
apprendra à mettre en oeuvre ce Framework et à utiliser avec efficacité ses différents modules dans le cadre
de développement d'applications Web.
1) Introduction
2) L'accès aux données avec Django
3) Gestion des vues
1) Introduction
- Rappel des principes de la POO.
- Le Design Pattern MVC.
- Présentation de Framework Django.
- Origine et historique. Objectifs et avantages.
- Les composants de Framework Django.
4) Les templates
5) Gestion des formulaires
6) Fonctions avancées
Exercice
Préparation de l'environnement. Installation de Python, Django, Serveur Apache, MySQL et Eclipse. Création
d'un nouveau projet.
2) L'accès aux données avec Django
- Le modèle ORM Django.
- Les modèles Django : Model, Field, Table, Column, Primary Key...
- Mapping des associations : OneToMany, ManyToOne, ManyToMany, OneToOne.
- Stratégies de mapping de l'héritage : Meta Class, OneToOneField, ManyToManyField...
- Accès aux données avec les QuerySets.
Exercice
Développer une couche d'accès aux données. Interfacer Django avec MySQL.
3) Gestion des vues
- Vues simples ou fonctions vues.
- Les classes HttpResponse, HttpRequest et QueryDict.
- Configuration des Urls : UrlConf.
- Vues génériques.
- Exemples de vues génériques : Redirects, Create, Update, Delete...
Exercice
Développer des vues dynamiques HTML avec Django.
4) Les templates
- Le rôle des templates.
- Création et chargement des templates.
- Gestion des contextes.
- Utilisation des tags et filtres personnalisés.
- Réutilisation des templates : héritage entre templates.
Exercice
Développer un Template pour faciliter la génération de la présentation.
5) Gestion des formulaires
- Les avantages des formulaires Django.
- Création des formulaires.
- Les différents types de champs.
- Validation des données d'un formulaire.
- Gestion et personnalisation des messages d'erreurs.
- Génération des formulaires à partir des modèles.
Exercice
Développer les formulaires associés aux opérations CRUD de l'atelier précédent.
6) Fonctions avancées
- L'internationalisation.
- L'authentification et la gestion des sessions.
- Optimisation et caches.
- Intégration d'AJAX.
- L'interface d'administration.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 32 / 86

- Les tests unitaires.
Exercice
Intégrer AJAX à travers le Framework JQuery.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 33 / 86

Stage pratique de 3 jour(s)
Réf : PRL
Participants
Destiné aux informaticiens
concernés par des
procédures d'exploitation en
environnements Unix, Linux
ou Windows.
Pré-requis
Connaissances de base
de la programmation et
d'un système d'exploitation
(Windows ou Linux/Unix).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
24 fév. 2014, 31 mar. 2014
28 avr. 2014, 26 mai 2014
30 juin 2014, 15 juil. 2014
18 aoû. 2014, 29 sep. 2014
27 oct. 2014, 24 nov. 2014
15 déc. 2014
Aix
24 mar. 2014, 23 juin 2014
15 sep. 2014, 8 déc. 2014
Bordeaux
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Bruxelles
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Geneve
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Lille
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Luxembourg
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Lyon
24 mar. 2014, 23 juin 2014
15 sep. 2014, 8 déc. 2014
Nantes
17 mar. 2014, 30 juin 2014
29 sep. 2014, 1 déc. 2014
Rennes
17 mar. 2014, 30 juin 2014
29 sep. 2014, 1 déc. 2014
Sophia-antipolis
24 mar. 2014, 23 juin 2014
15 sep. 2014, 8 déc. 2014
Strasbourg
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Toulouse
10 mar. 2014, 30 juin 2014
1 sep. 2014, 24 nov. 2014
Langage Perl
scripts système Unix/Linux/Windows
OBJECTIFS
Ce stage vous apprendra à programmer ou maintenir des procédures d'exploitation écrites en Perl. Il
permettra de maîtriser le langage lui-même mais aussi de découvrir la " philosophie Perl " avec notamment le
recours à un grand nombre de modules permettant d'élargir quasiment à l'infini ses possibilités.
1) Présentation
2) L'essentiel du langage
3) Expressions régulières
4) Fonctions, procédures, modules
1) Présentation
- Historique du langage.
- Perl pour quel usage ?
- Caractéristiques du langage Perl.
- Les différentes distributions et versions.
- La documentation officielle.
- Installation et première exécution d'un programme Perl.
- Fichiers sources, extension et interprétation.
- Les outils pour utiliser Perl.
Travaux pratiques
Installation de l'interpréteur Perl.
2) L'essentiel du langage
- Structure d'un programme Perl, en-tête de script.
- Conventions de codage et règles de nommage.
- Ajout de commentaires.
- Les chaînes de caractères, interprétation de codes.
- Les variables, nommage et typage. Portée des variables.
- Les scalaires.
- Les opérateurs : calcul, incrément, affectation, comparaison...
- Les tableaux, initialisation, affichage du contenu.
- Les tableaux associatifs (hash table), les fonctions keys et values.
- Les références mémoires.
- Les variables systèmes.
- La notion de blocs.
- Les structures de contrôle conditionnelles : if, if... else, if... elsif... else.
- Les structures de contrôle itératives : while, for, until, foreach.
- Les flux entrées/sorties standard (stdin, stdout, stderr).
Travaux pratiques
Manipulation du langage à travers l'écriture de différents programmes.
3) Expressions régulières
5) Gestion des fichiers et des répertoires
6) Interactions avec le système d'exploitation
7) Aspects avancés, bases de données,
implémentation objet
8) Scripts Perl dans un contexte Web, module
CGI
- Les cas d'utilisations des expressions.
- Panorama des différents motifs : les méta-caractères, les quantificateurs, les caractères spéciaux.
- Le Pattern Matching.
- Le Pattern Substitute.
- Options de la ligne de commande pour l'interpréteur.
- Programme tiers : sed, awk...
- Perl utilisé comme filtre supplémentaire.
Travaux pratiques
Mise en oeuvre d'expressions régulières.
4) Fonctions, procédures, modules
- Définition des fonctions. Différence entre fonctions et procédures.
- La déclaration d'une fonction, le mécanisme d'appel, le passage d'arguments et la récupération des
résultats.
- Visibilité des variables, l'opérateur my.
- Utilisation des références.
- Les fonctions intégrées dans Perl : chomp, chop, length...
- Notion de "package" et de module.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 34 / 86

- Modules de la distribution standard.
- Modules du CPAN, recensement, documentation, sites de ressources.
- Installation de modules.
- Utilisation d'un module " classique " et d'un module " Orienté Objet ". Les fonctions require et use.
- Fabrication d'un module.
- Documenter les modules créés.
Travaux pratiques
Ecriture de fonctions. Intégration d'un module dans un développement. Création d'un module.
5) Gestion des fichiers et des répertoires
- Notion de filehandle.
- Gestion des fichiers : ouverture, lecture, écriture, fermeture...
- Informations sur les fichiers (propriétaire, taille, droits...), la fonction stat.
- L'opérateur diamant.
- Gestion des répertoires : changement, parcours, création, suppression...
- Gestion des erreurs sur manipulation des fichiers et des répertoires.
Travaux pratiques
Lecture/ écriture dans un fichier. Manipulation des répertoires.
6) Interactions avec le système d'exploitation
- Accès aux informations du système d'exploitation.
- Les commandes agissant sur le système : mkdir, rmdir, chown, chroot, chmod, ...
- Gestion des processus.
- Création de processus fils : system, exec.
- Les quotes inverses.
- Interactions avec le système Windows (modules Win32 et Win32API).
Travaux pratiques
Création de processus fils.
7) Aspects avancés, bases de données, implémentation objet
- Tris personnalisés.
- Traitements complémentaires sur les chaînes de caractères.
- Structures de données élaborées à l'aide des références anonymes.
- Accès aux bases de données à l'aide du module DBI.
- Etablissement et configuration d'une connexion, requêtage et récupération des résultats.
- Création de la structure d'une classe et instanciation : paquetage, sous-programme et référence.
- Constructeur et destructeur d'objets.
- Invocation des méthodes d'une classe.
- Le ramasse-miettes.
Travaux pratiques
Exploitation des données d'une base de données relationnelle.
8) Scripts Perl dans un contexte Web, module CGI
- Protocole HTTP, serveur Web, schéma fonctionnel CGI.
- Le module CGI.
- Variables d'environnement, méthodes GET et POST.
- Génération des éléments HTML du formulaire avec Perl.
- Traitement des formulaires, exploitation des résultats.
Travaux pratiques
Ecriture d'un script CGI en Perl.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 35 / 86

Stage pratique de 2 jour(s)
Réf : LAP
Participants
Informaticiens concernés par
des procédures d'exploitation
en environnements Unix,
Linux ou Windows.
Pré-requis
Langage Perl, programmation avancée
OBJECTIFS
Ce stage vous présentera les dernières technologies préconisées par la communauté Perl. Vous verrez
comment maintenir efficacement vos programmes écrits " à l'ancienne ", ainsi qu'à en améliorer la
performance. A l'issue du cours, vous maîtriserez les principales primitives du noyau, la création d'interfaces
graphiques et de masques de saisie pour vos procédures d'exploitation. Vous découvrirez également
l'approche plus moderne et plus puissante de la programmation Objet en Perl.
Bonnes connaissances
du langage Perl. Ou
connaissances équivalentes à
celles apportées par le stage
PRL " Langage Perl ".
1) Programmation système
2) Perl et l'objet
3) Interface graphique : de Perl/Tk à GTK
4) Écrire du nouveau code en utilisant GTK
5) Evolutions
Prix 2014 : 1350€ HT
Eligible DIF
Dates des sessions
Paris
6 mai 2014, 4 sep. 2014
13 nov. 2014
1) Programmation système
- Rappel des principes de base des processus : fork et exec.
- Rappel des principes de la gestion des signaux.
- Envoyer un signal à des processus : la fonction kill
- Gérer les signaux : le pragma sigtrap, installer un gestionnaire de signal.
- Programmation des sockets et services de IO::Socket à Net::Server.
- Présentation de la programmation des threads.
Travaux pratiques
Ecriture de programmes Perl pour manipuler les fonctions systèmes.
2) Perl et l'objet
- Quelques définitions : programmation orientée objet, classe, instance, constructeur, destructeur, héritage ...
- La mise en oeuvre de l'objet en Perl : le paquetage pour la classe, le hachage pour les attributs, les
fonctions pour les méthodes.
- La création d'instance : la bénédiction (bless) de la référence de l'objet.
- Programmer un constructeur.
- Agir quand l'objet est détruit, la méthode DESTROY.
- L'héritage : le tableau @ISA et la classe UNIVERSAL.
- La surcharge de méthode, l'utilisation de SUPER.
- Abstraction : l'avenir de l'objet dans Perl, de Class::Std et Class::Accessor à Moose.
Travaux pratiques
Programmation de classes. Mise en oeuvre des concepts objets (héritage, surcharge...).
3) Interface graphique : de Perl/Tk à GTK
- Comprendre et maintenir du code écrit en Perl/Tk.
- Présentation et installation de Perl/Tk.
- Gestionnaire de géométrie : Pack, Grid, Place.
- Les Widgets par famille.
- Les boutons : Button, Checkbutton, Radiobutton.
- Libellé et zone de saisie : Label, Entry.
- Ascenseur, liste, menu et saisie de texte : Scrollbar, Listbox, Menubutton, Optionmenu, Text.
- Les conteneurs : Canvas, Frame, Toplevel.
- La gestion des événements.
Travaux pratiques
Création d'une application avec interface graphique en Perl/Tk et gestion événementielle.
4) Écrire du nouveau code en utilisant GTK
- Lien entre Pert et GTK : installer GTK et ses bibliothèques.
- Widget : hiérarchie, création, accélérateurs clavier, conteneurs de bases, ...
- Widget : signaux et événements.
- Les différents types de boutons : Toggle (interrupteurs), radio, ...
Travaux pratiques
Manipulation de différents composants : boutons, boite de boutons, Widget cadre, ...
5) Evolutions
- Fonctionnalités apportées par Perl 5.10, 5.12, 5.14.
- Perl 6 : un nouveau langage.
- Nouveautés : les sigils, typage statique et dynamique, paramètres formels des fonctions.
- Un véritable langage objet.
- De nouveaux concepts : les jonctions et l'évaluation paresseuse.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 36 / 86

Stage pratique de 5 jour(s)
Réf : DEV
Participants
Développeurs. Nouveaux
utilisateurs de Windev.
Pré-requis
Windev, développement d'applications
OBJECTIFS
Cette formation vous apportera la maîtrise de l'environnement Windev. Vous verrez en détail ses différents
éditeurs et comment l'utiliser efficacement pour programmer vos applications, les connecter à des bases de
données, concevoir leurs IHM au standard Windows, les tester, les packager et les déployer.
Connaissances de base
en programmation et d'un
environnement graphique.
Expérience souhaitable en
développement logiciel.
1) Présentation de l'environnement Windev
2) La base de données
3) L'interface homme/machine
4) Les états
5) Les dossiers
6) La programmation
7) L'installation
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
12 mai 2014, 6 oct. 2014
8 déc. 2014
1) Présentation de l'environnement Windev
- L'environnement Windows. L'éditeur de fenêtres.
- L'éditeur de sources : rechercher, remplacer, couper, copier, coller, imprimer. Personnalisation de l'éditeur.
- L'outil de description des fichiers. L'éditeur d'états.
- La compilation, la mise en bibliothèque.
- L'exécutable : programme, bibliothèque, DLL.
- Les utilitaires : WDMAP, WDBACKUP, WDRESTOR, WDOUTIL..., le RAD.
2) La base de données
- Le format HyperFileSQL.
- L'outil de description des fichiers.
- Génération de l'analyse, modifications automatiques, liaisons entre les fichiers.
3) L'interface homme/machine
- Les projets, les menus, les fenêtres.
- L'ergonomie, le menu système, la barre de titre, l'éditeur de styles (feuille de style), les groupes de champs.
- Etude des différents types d'objets. Les tables.
- L'intégration automatique des rubriques d'un fichier dans un écran, la création d'une fenêtre VISION+.
4) Les états
- La description de l'éditeur.
- Les différents modes création : état lié à un fichier, étiquettes, état libre, les tris, les filtres, les ruptures.
- Les différents types de blocs (début de document, haut de page, corps, bas de page, etc.).
- Les différents types d'objets (champ, libellé...).
5) Les dossiers
- Les fichiers de données et leur structure.
- Le dictionnaire des rubriques.
- Les sources des fenêtres : dessin de la fenêtre, détail des objets, source associé à l'objet.
6) La programmation
- Le projet, les procédures, les fonctions.
- Le W-Langage : fonctionnement de l'éditeur de sources, opérateurs et fonctions.
- Tables mémoire et tables fichier. Timer et multitâche.
- Gestion des liaisons série.
- Le grapheur.
- OLE Automation vers Excel, Le dialogue DDE vers Excel.
- Aspect monoposte, multi-instance ou réseau.
- Gestion des triggers.
7) L'installation
- La création d'un programme exécutable.
- La mise en bibliothèque des objets.
- L'installation sur un autre poste.
- Les DLL.
- Maintenance de l'application réalisée.
- L'outil d'installation.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 37 / 86

Stage pratique de 3 jour(s)
Réf : WEB
Participants
Cette formation pratique
s'adresse aux futurs
développeurs WebDev
souhaitant réaliser des sites
dynamiques Internet ou
Intranet.
Pré-requis
Connaissances de
base du HTML et de la
programmation.
Eligible DIF
Webdev, développement Web
OBJECTIFS
Ce stage vous montrera comment réaliser un site web dynamique à l'aide de WebDev. Vous verrez comment
utiliser les fonctions courantes de l'environnement logiciel, créer vos IHMs, utiliser des bases de données et
déployer vos applications sur un serveur Web.
1) Concepts de base
2) Accès aux données
3) Le code
4) Gestion de l'IHM
Travaux pratiques
5) Pages pour l'impression
6) Créer le dossier du site
7) Déploiement de l'application
Prise en main de l'environnement, la bonne méthode de création d'un nouveau projet WebDev.
1) Concepts de base
- Qu'est-ce qu'un site Web dynamique.
- L'environnement de développement.
- L'éditeur graphique.
- L'éditeur de code.
- Etapes de création d'un nouveau projet.
2) Accès aux données
- Créer une base de données HYPERFILE.
- Se connecter à une base de données SQL Server, MySQL ou Oracle.
- Création de l'application à l'aide du RAD.
- Ajouter, supprimer, modifier des données automatiquement.
Travaux pratiques
Réalisation d'une base de données catalogue.de produits
3) Le code
- Le WDLANGAGE (Variables, procédure, fonctions, boucles...)
- Code coté client.
- Code côté serveur.
- Accéder aux données par le code.
Travaux pratiques
Création de pages personnalisés.
4) Gestion de l'IHM
- Apparence des pages.
- Création et utilisation de modèles.
- Les différents objets des pages.
- Réalisation de menus.
Travaux pratiques
Réalisation d'un IHM via le RAD, et ajout de pages spécifiques.
5) Pages pour l'impression
- L'éditeur d'état.
- Les différents états (Lié aux données, libres ...).
- Composition d'un état WEBDEV (entêtes, corps, pieds...).
- Les objets à disposition (différents types de champs).
- Les options d'impression.
- Génération d'impression HTML et PDF.
Travaux pratiques
Génération d'état pour l'impression, au format HTML et PDF.
6) Créer le dossier du site
- Importance de ce dossier.
- Génération du dossier (pages, états, code sources).
Travaux pratiques
Bien organiser ses dossiers de projet, créer la documentation de l'application.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 38 / 86

7) Déploiement de l'application
- Génération de l'application.
- Génération de la procédure d'installation.
- Déploiement.
Travaux pratiques
Créer le programme d'installation et installation d'un programme
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 39 / 86

Stage pratique de 2 jour(s)
Réf : WED
Participants
Développeurs WebDev.
Pré-requis
Avoir déjà développé des
sites avec WebDev. Ou
connaissances équivalentes à
celles apportées par le stage
" WebDev, développement
Web " (réf. WEB).
Eligible DIF
Webdev, développement Web, perfectionnement
OBJECTIFS
Ce stage de perfectionnement vous aidera à développer des applications complexes avec WebDev. Il
insiste sur les fonctions avancées de l'environnement ainsi que sur l'interaction avec d'autres langages et
technologies comme JavaScript, Ajax et PHP.
1) CSS et le référencement
2) Utilisation de scripts externes
3) Composants avancés de WebDev
1) CSS et le référencement
- Utiliser des feuilles de style externe.
- Notion et utilisation d'un kit graphique.
- Bien référencer un site WebDev.
4) Upload / Download
5) Import / Export
6) Etats avancés
Travaux pratiques
Créer et utiliser une feuille CSS externe, bonne pratique du référencement.
2) Utilisation de scripts externes
- Utilisation des procédures événementielle de JavaScript.
- Code JAVASRIPT-WD-LANGAGE.
- Passer des paramètres entre les pages.
- Utiliser Ajax intégré.
- Ajax (XMLHttpRequest().
- Appel de pages PHP.
Travaux pratiques
Rendre un site plus dynamique et plus rapide avec Ajax, appel et passage de paramètres à un script externe.
3) Composants avancés de WebDev
- Traitement des erreurs.
- Maitriser le champ HTML
- Timer et Trigger.
- Envoyer des mails pour le suivi de l'activité du site.
- La réglette personnalisée.
Travaux pratiques
Actualiser automatiquement une page à intervalle régulier.
4) Upload / Download
- Upload d'images et de fichier PDF.
- Télécharger des fichiers depuis le serveur.
Travaux pratiques
Upload de fichier image pour la réalisation d'un site e-commerce.
5) Import / Export
- Lire et écrire dans un fichier texte type CSV.
- Utiliser un fichier Excel avec sa base de données.
Travaux pratiques
Utiliser un fichier texte en tant que compteur.
6) Etats avancés
- Retour sur les blocs d'états (entête, corps, pieds).
- Etats imbriqués.
- Tris, ruptures , filtres.
- Gestion des graphiques.
Travaux pratiques
Réalisation d'états complexes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 40 / 86

Stage pratique de 5 jour(s)
Réf : PBF
Participants
Pour les développeurs
désirant acquérir les
techniques et les réflexes
pour développer des
applications client/serveur
avec PowerBuilder.
Pré-requis
Connaissances de base en
programmation et en langage
SQL. Expérience requise en
développement logiciel.
Prix 2014 : 2440€ HT
Eligible DIF
Dates des sessions
Paris
10 mar. 2014, 2 juin 2014
8 sep. 2014, 1 déc. 2014
PowerBuilder, les fondamentaux
OBJECTIFS
Cette formation vous permettra de prendre en main l'environnement PowerBuilder et de l'utiliser efficacement
pour développer et déployer des applications Client/Serveur. Vous manipulerez et personnaliserez son
interface de développement, et apprendrez les bonnes pratiques pour créer des applications performantes.
1) Introduction à PowerBuilder
2) Création de fenêtres
3) Ecriture de scripts
4) Utilisation du PowerScript
1) Introduction à PowerBuilder
- Principe et architecture.
- La personnalisation de l'interface.
- Les éléments fondamentaux de la programmation.
- Les bases pour créer une application.
- La Painter Application.
- Les bibliothèques. Les événements.
Travaux pratiques
Prise en main de l'interface de PowerBuilder.
2) Création de fenêtres
5) Création et utilisation de menus
6) Utilisation des objets DataWindow et des
objets utilisateurs
7) La gestion de projets
- Comment créer une fenêtre ?
- Décryptage de la notion de contrôles.
- Passage en revue des types de contrôles possibles.
- Mise en place de contrôles au sein d'une application.
- Le Painter pour les fenêtres.
- Le principe d'héritage. Mise en pratique.
Travaux pratiques
Création de fenêtres et de contrôles. Mise en place du principe d'héritage.
3) Ecriture de scripts
- Définition des scripts. Comment les utiliser ?
- Comment travailler avec les attributs.
- Les différents types de fonction.
- La portée et la visibilité des variables.
- La gestion des erreurs.
Travaux pratiques
Création de scripts simples.
4) Utilisation du PowerScript
- Présentation de PowerScript.
- Le Painter PowerScript.
- Les fonctions et les commandes.
- Le nommage de contrôles, d'objets et de variables.
- Les requêtes SQL intégrées. La syntaxe.
Travaux pratiques
Exemples d'utilisation de PowerScript.
5) Création et utilisation de menus
- Qu'est-ce que le Painter Menu ?
- Savoir construire une hiérarchie de menus.
- Comment associer un script à un menu ?
Travaux pratiques
Création de menus simples. Mise en place d'une hiérarchie de menus. Exemples d'association d'un menu à
une fenêtre.
6) Utilisation des objets DataWindow et des objets utilisateurs
- Présentation du concept de DataWindow. Les types de DataWindow. Le Painter DataWindow.
- Les filtres et les tris. Comment communiquer avec une base de données ? Les fonctions et les événements.
- Les différents types d'objets utilisateurs. Le Painter User Object. Comment créer un objet utilisateur ?
Travaux pratiques
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 41 / 86

Mise en place d'un DataWindow. Exemples d'utilisation de DataWindow. Exemples de création et d'utilisation
d'un objet utilisateur.
7) La gestion de projets
- Comment distribuer une application ?
- Le Painter projet.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 42 / 86

Stage pratique de 4 jour(s)
Réf : PBP
Participants
Pour les développeurs qui
souhaitent approfondir
leur connaissance sur
PowerBuilder.
Pré-requis
Connaissances de base
de PowerBuilder ou
celles équivalant au stage
ORSYS " PowerBuilder, les
fondamentaux ". Expérience
requise en développement
logiciel.
Eligible DIF
PowerBuilder, perfectionnement
OBJECTIFS
Cette formation vous permettra d'approfondir vos connaissances et compétences sur l'utilisation de
l'environnement PowerBuilder. Vous apprendrez à utiliser des techniques avancées pour développer et
déployer vos applications client-serveur, mettant notamment en oeuvre PowerScript, les DataWindows ou
encore les DataStores.
1) Utiliser des techniques PowerScript
2) Gérer les exceptions
3) Utiliser efficacement les DataWindows
1) Utiliser des techniques PowerScript
- Manipuler les tableaux. Travailler avec le Control Array.
- Les fonctions avec les String, Date, et Numeric.
- Les messages entre les objets.
- Utilisation avancée des techniques d'héritage.
- Accès aux variables.
- Appel de fonctions récursives.
Travaux pratiques
Mise en oeuvre de PowerScript.
2) Gérer les exceptions
- Le processus de manipulation des exceptions.
- Lancer des exceptions. Capter et traiter des exceptions.
- Définir ses propres fonctions pour lancer des exceptions.
4) Créer et utiliser des DataStores
5) Mettre en oeuvre des contrôles et techniques
avancés d'IHM
6) Gérer la communication entre les composants
Travaux pratiques
Gérer les exceptions levées par vos applications. Créer ses propres exceptions. Les lever dans ses propres
fonctions.
3) Utiliser efficacement les DataWindows
- Les styles de présentation des DataWindows.
- TreeView DataWindows. CrossTabs.
- Communication avec les bases de données. Les objets transactions.
- Mettre en oeuvre les caractéristiques avancées des DataWindows : graphes, DataWindows imbriqués,
BLOB et DataWindow...
- Utiliser les éléments Find, Print Review, Zoom, Importing Data, Query Mode, Store Procedure Updates...
- Créer des rapports.
- Manipuler les attributs des objets contenus dans un DataWindow. Les types DataWindowChild.
- Les DataWindows dynamiques. Les DataWindows multitables. Les DataWindow Property Conditional
Expressions.
Travaux pratiques
Manipulation des contrôles. Connexion à une base. Manipulations variées des DataWindows pour enrichir
une application.
4) Créer et utiliser des DataStores
- Créer un DataStore.
- Utiliser dans une application un DataStore.
- Partager des données entre DataStores et DataWindows.
- Utiliser une API de synchronisation DataWindow.
Travaux pratiques
Mise en oeuvre des DataStores au sein d'une application. Implémentation du partage de données.
5) Mettre en oeuvre des contrôles et techniques avancés d'IHM
- Utiliser des contrôles de type TreeView.
- Utiliser des contrôles de type ListView.
- Utiliser des contrôles de type Tab.
- Utiliser des contrôles de type OLE.
- Mettre en oeuvre le Drag & Drop dans une application.
- Construire un menu contextuel.
- Créer de manière dynamique une IHM.
Travaux pratiques
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 43 / 86

Test des différents contrôles. Enrichissement d'une application existante avec différents composants évolués
d'IHM.
6) Gérer la communication entre les composants
- Construction et gestion d'un objet pipeline.
- Les fonctions externes.
- Envoi des messages Windows et l'objet message.
Travaux pratiques
Mise en oeuvre des techniques de communication.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 44 / 86

Stage pratique de 5 jour(s)
Réf : PBA
Participants
Pour les développeurs qui
souhaitent développer des
applications .NET avec
PowerBuilder.
Pré-requis
Bonne connaissance de
PowerBuilder. Expérience
requise en développement
logiciel.
Eligible DIF
PowerBuilder, développer des applications .NET
OBJECTIFS
Cette formation s'adresse à tous les développeurs PowerBuilder qui souhaitent apprendre à créer et déployer
des applications .NET en C#. Ils verront comment tirer le meilleur parti de la richesse du Framework .NET
de Microsoft, et comment maximiser leur productivité par leurs connaissances et habitudes de travail en
environnement PowerBuilder.
1) Présentation de la plateforme .NET
2) PowerBuilder 12.0 et ses outils de
développement
3) La syntaxe de base de C#
1) Présentation de la plateforme .NET
- Principe et architecture de la plateforme .NET.
- Architecture du Framework .NET.
- Aperçu des différents types d'applications dans un environnement multicible.
- Outils et environnement de développement.
- Présentation du langage de CIL.
4) Programmation Orientée Objet
5) Création d'applications WPF
6) Fonctionnalités et techniques avancées
Travaux pratiques
Exemple d'un programme C# simple. Exécution en mode géré. Test d'un premier programme.
2) PowerBuilder 12.0 et ses outils de développement
- L'IDE classique et le nouvel IDE .NET.
- Les différences majeures entre les deux IDE.
- La nouvelle terminologie associée au .NET.
- PowerBuilder pour le .NET. L'environnement. Son organisation et ses fonctionnalités.
- Le Visual Studio Isolated Shell.
- Les caractéristiques spécifiques.
- Utilisation des classes .NET et de leurs méthodes à l'intérieur de l'IDE PowerBuilder.
Travaux pratiques
Prise en main de PowerBuilder pour le développement .NET.
3) La syntaxe de base de C#
- Les variables et les expressions : déclaration, constantes, opérateurs, les types.
- Les types de données : Common Type System, rôle de la classe de base System.Object et transtypage.
- Les types valeur et types référence.
- Les instructions de contrôle de flux : boucles et tests.
- Manipulation des tableaux, instructions de contrôle de flux, ...
Travaux pratiques
Ecriture de programmes en C# mettant en oeuvre des algorithmes classiques.
4) Programmation Orientée Objet
- Classes et objets. Modélisation du monde réel par objet.
- Notions de champ, méthode et propriété.
- Héritage. Polymorphisme. Interfaces.
- Définition des classes en C#. Utilisation des objets.
- Définition du contenu de la classe : méthodes et propriétés.
- Le mécanisme de surcharge (constructeurs, méthodes et opérateurs).
- Dérivation et héritage des classes en C#. Classes génériques.
- Objets et classes de base du Framework .NET.
Travaux pratiques
Implémentation sous PowerBuilder dans une application des concepts objets en .NET. Création du squelette
de l'application fil rouge.
5) Création d'applications WPF
- Windows Presentation Foundation.
- Architecture des applications WPF et fondamentaux du langage XAML.
- Principaux contrôles conteneurs et environnement graphique.
- Ressources. Styles. Transformations. Animations. Modèle de contrôle et contrôles du toolkit WPF.
- Infrastructure de liaison de données.
- Créer une IHM avec PowerBuilder et WPF.
- Squelette d'application avec PowerBuilder.
Travaux pratiques
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 45 / 86

Création de l'IHM de l'application à partir de PowerBuilder. Test de contrôles et de la dynamique d'interaction.
6) Fonctionnalités et techniques avancées
- Utilisation des nouvelles fonctionnalités WPF DataWindow.
- Utilisation de contrôles personnalisés et des nouveaux types Graph.
- Gestion et accès aux données. Les DataStore et ses usages.
- Utilisation de WCF (Windows Communications Foundation) et du nouveau Proxy WCF pour appeler un
service WCF.
Travaux pratiques
Mise en oeuvre des fonctions avancées. Appel de services WCF.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 46 / 86

Stage pratique de 3 jour(s)
Réf : GRO
Participants
Développeur, chef de projets,
architecte applicatif.
Pré-requis
Bonne expérience en
programmation Java.
Eligible DIF
Groovy, programmation
OBJECTIFS
Groovy est un langage orienté objet qui se propose d'améliorer la productivité des développeurs en
simplifiant l'écriture du code et l'usage des modules. Ce stage très pratique vous apprendra les bases de ce
langage et vous montrera comment produire rapidement des applications de qualité. Vous verrez comment
mettre en oeuvre des tests unitaires, l'accès aux données, la manipulation de XML et certains modules
avancés proposés avec Groovy.
1) Introduction
2) Les bases du langage
3) Les tests avec Groovy
4) L'accès aux bases de données
5) Manipulation des documents XML
6) Programmation avancée
1) Introduction
- Les langages dynamiques.
- Présentation du langage Groovy.
- Avantages du langage Groovy.
- Historique du langage Groovy.
- Différence entre Java, Ruby et Groovy.
Travaux pratiques
Mise en place de l'environnement (JDK, Groovy, Eclipse...).
2) Les bases du langage
- Structure des programmes Groovy.
- Compilation et exécution des programmes.
- Les types de base du langage.
- Déclaration des classes, Asset et AST.
- Enumération et collections : Enum, Ranges, Lists, Maps.
- Groovy Closure.
- Les structures de contrôle : Les conditions, Groovy Truth, les itérations.
- Les expressions régulières.
Travaux pratiques
Développer une application orientée objet.
3) Les tests avec Groovy
- Les tests unitaires avec Groovy.
- Utilisations des Mocks.
- Couverture du code.
Travaux pratiques
Définir des tests avec Groovy.
4) L'accès aux bases de données
- L'API SQL de Groovy.
- Requêtes simples et requêtes paramétrées.
- Manipulation des DataSets, indexation négative.
- Utilisation des procédures avec Groovy.
- Groovy et les solutions ORM (GORM).
Travaux pratiques
Implémenter une couche d'accès aux données avec Groovy.
5) Manipulation des documents XML
- Lecture des documents XML (XmlParser, XmlSlurper, DOMCategory).
- Manipulation des documents XML (DOM, JDOM, DOM4J...).
- Validation des documents XML (DTD, XMLSchema, RELAX NG...).
- Les transformations avec XPath, XSL et XSLT.
Travaux pratiques
Manipuler les documents XML avec Groovy.
6) Programmation avancée
- Intégration de Groovy dans Java.
- Groovy Builders (NodeBuilder, MarkupBuilder...).
- Templates.
- Groovlets.
- Les modules GroovyWS, Grails...
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 47 / 86

Travaux pratiques
Développer un Web service avec le module GroovyWS.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 48 / 86

Stage pratique de 3 jour(s)
Réf : GRG
Participants
Développeur Web, architecte
applicatifs.
Pré-requis
Bonne connaissance du
langage Groovy et des
concepts des technologies
Java Web (Servlet, JSP et
tags).
Eligible DIF
Groovy et Grails, développement Web
OBJECTIFS
Le Framework Grails a été conçu pour faciliter la mise en oeuvre d'applications Web au moyen du langage
Groovy, de Spring et Hibernate, deux frameworks parmi les plus utilisés du marché. Cette formation
vous détaillera son utilisation et les bonnes pratiques à mettre en oeuvre pour assurer la robustesse et
l'extensibilité de vos applications.
1) Introduction
2) Grails : premier pas
3) Modèle métier
1) Introduction
- La plateforme JavaEE.
- Les technologies Web : Servlet, JSP et taglib.
- Design Pattern MVC.
- Le framework Rails.
- Fondements du framework Grails.
- Grails : fonctionnalités et positionnement.
- Les bases du langage Groovy.
Travaux pratiques
Mise en place de l'environnement (JDK, Groovy, Grails, Eclipse...).
2) Grails : premier pas
- Structure d'un projet.
- Modèle métier, les contrôleurs et les vues.
- Eléments de configuration.
- Les utilitaires Grails en ligne de commande.
- Intégration avec l'IDE Eclipse.
Travaux pratiques
Développer une application simple Grails.
3) Modèle métier
4) Application des concepts Grails
5) Compléments
- Mécanisme de mapping Objet-Relation avec GORM (Entités, associations, héritage,...).
- Validation des données.
- Implémentation des opérations CRUD.
- Requêtes dynamiques.
Travaux pratiques
Implémenter une couche d'accès aux données avec GORM.
4) Application des concepts Grails
- Scaffholding statique versus Scaffholding dynamique : génération automatique des artefacts (Contrôleurs,
Vues,...).
- Validation des données de saisie.
- Conversion des données.
- Gestion des actions (action par défaut,...).
- Rendu dynamique :Groovy Scriptlets et GSP. Boîte à outils Grails de tags. Définition des tags
personnalisés. Layout et template. Pagination.
- Internationalisation.
Travaux pratiques
Mettre en oeuvre une application utilisant les concepts Grails : Controller, Actions, Views, tags Grails,
validation...
5) Compléments
- Les concepts d'AJAX.
- Gestion des événements.
- Intégration avec Ajax : les tags.
- Mise en oeuvre des services et tâches.
- Injection des dépendances.
- Intégration des frameworks : Hibernate et Spring.
Travaux pratiques
Améliorer l'application développée en intégrant AJAX et Spring.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 49 / 86

Stage pratique de 4 jour(s)
Réf : RUB
Participants
Programmeurs, développeurs
Web et Webmasters désirant
concevoir des sites Internet
professionnels orientés Web
Services.
Pré-requis
Connaissances de base
d'HTML, de JavaScript, d'un
langage de développement
côté serveur et en
administration d'un serveur
Web.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
13 mai 2014, 30 sep. 2014
2 déc. 2014
Ruby On Rails 3, développement Web
OBJECTIFS
Ce stage vous apprendra à maîtriser le Framework Ruby On Rails 3 pour développer vos applications
Web. Vous verrez comment tirer parti de la simplicité et de la rapidité d'utilisation de Rails 3 pour créer des
applications riches et évolutives en utilisant le modèle MVC, et pour les connecter à des Services Web.
1) Introduction
2) Préparer son environnement de travail
3) Programmer en Ruby
1) Introduction
- Rappel Internet, HTML et CSS, XML, JSON, YAML.
- Design Pattern MVC : modèles, vues et contrôleurs.
- Les hébergeurs Rails.
2) Préparer son environnement de travail
4) Découverte de Rails
5) Notions avancées de Rails
6) Tests et versioning
- Installer l'environnement de travail (serveur HTTP, BDD et interpréteur Ruby avec RailsInstaller).
- Préparer le dossier de travail.
- Les outils en ligne de commande.
- Installer les outils de développement.
Travaux pratiques
Installation de l'environnement.
3) Programmer en Ruby
- Rappel objet (modules, classes, instances, UML...).
- Les conventions de nommage de Rails.
- La syntaxe Ruby (module, classe, portée, méthodes...).
- Les aides Ruby (RI, Rubycore, inspect).
Travaux pratiques
Réalisation d'un premier programme en Ruby.
4) Découverte de Rails
- Architecture Rails (ActiveRecord, ActiveModel, ORM, ActionVue, ActionController, routage des requêtes...).
- Préparer une maquette HTML/CSS dans le respect des normes (XHTML/WCAG 2).
- Créer un contrôleur de pages statiques.
- Établir des modèles de pages (application / contrôleur).
- Mise en place de scripts de vues ERB, RHTML, HAML, Liquid, SASS, SCSS, RJS, CoffeeScript, RXML.
- Utiliser des assistants de pagination.
- Placer des ressources partagées.
- Paramétrage de la BDD (database.yml), création et "migration" d'une base de données MySQL.
Travaux pratiques
Réaliser une application avec Rails. Établir des modèles de page. Accès à la base MySQL.
5) Notions avancées de Rails
- Le CRUD, RESTFul Web Services, ActiveRecord et le routage orienté ressources, routage avancé des
requêtes.
- Les migrations d'ActiveRecord. Les transactions.
- Les formulaires Rails (form_for, button_to, validation des données...). Les filtres.
- Internationaliser avec le "i18n". Intégrer l'UNICODE côté client et côté serveur.
- Gérer les sessions, les Cookies et le cache.
- Protéger et sécuriser ses pages côté client et serveur.
- Déboguer avec les journaux, la console iRb, les points d'arrêt.
- Dynamiser son site avec Ajax, JQuery et CoffeeScript.
Travaux pratiques
Ecriture de formulaires. Intégration de JQuery et CoffeeScript dans les développements.
6) Tests et versioning
- Le TDD (Test Driven Development). Rails Tests et RSpec. Gérer les versions avec GIT.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 50 / 86

Stage pratique de 3 jour(s)
Réf : AMZ
Participants
Architectes, développeurs,
administrateurs systèmes.
Pré-requis
Connaissances de base du
Cloud Computing, du langage
Java et d'un langage shell
Unix/Linux.
Prix 2014 : 1830€ HT
Eligible DIF
Dates des sessions
Paris
10 mar. 2014, 30 juin 2014
29 sep. 2014, 8 déc. 2014
Amazon Web Services, architecture et mise en œuvre
OBJECTIFS
Cette formation vous propose de plonger au coeur de l'offre Amazon Web Services. Vous découvrirez
les possibilités de cette plateforme, ses services, ses API et interfaces. Vous verrez comment l'utiliser de
manière industrielle, apprendrez à créer des services et à les utiliser au sein de vos applications.
1) Introduction
2) Les outils de base d'Amazon Web Services
3) Les coûts d'utilisation d'Amazon Web
Services
4) Les outils en ligne de commande
Méthodes pédagogiques
5) Mise en oeuvre des composants AWS
6) Industrialisation et pratiques DevOps
7) Création d'images Cloud AMI
Tout au long de la formation, un parallèle sera fait avec les offres et SDK des Cloud publics "Microsoft Azure"
et "OVH Public Cloud" ainsi qu'avec VMWare vCloud.
Exercice
Des exercices vous permettront de mettre en pratique la majeure partie des concepts présentés, en utilisant
les outils AWS et des outils tiers.
1) Introduction
- Définitions. Clouds publics, privés, privés externalisés.
- Différences entre IaaS, PaaS et VDC (Virtual Data Center).
- Rôle des API et SDK. Des API pour les offres PaaS ?
- Notions de CloudApp et de CloudPlatform. Introduction de l'offre AWS d'Amazon.
2) Les outils de base d'Amazon Web Services
- Présentation du SDK et des API (SOAP, REST).
- La console Amazon.
- Les outils de base pour EC2, S3 et SQS.
- Le modèle de sécurité AWS (SecurityGroups, ...).
- IAM. Exemple de politiques de sécurité.
Exercice
Mise en oeuvre de AWS grâce à la console Web. Définition de profils et utilisateurs Amazon IAM.
3) Les coûts d'utilisation d'Amazon Web Services
- Modèle des comptes Amazon. Notion de Consolidated Account.
- Modèle de coût. Quota d'utilisation gratuite.
- Facteurs influents sur les coûts. Outils pour le suivi et l'analyse des coûts.
Démonstration
Analyse de coûts. Mise en place d'une solution de suivi des coûts.
4) Les outils en ligne de commande
- Les outils CLI dédiés aux composants EC2, ELB et RDS et de l'outil S3CMD.
- Mise en oeuvre de ces outils sous Linux.
Exercice
Création de scripts permettant de mettre en place l'infrastructure virtuelle d'une application.
5) Mise en oeuvre des composants AWS
- Les possibilités des services EC2, S3, SQS, RDS et de leur modèle de programmation.
- Comment les applications Java peuvent-elles utiliser ces ressources ?
- Composants Amazon AWS avancés.
- Les services Virtual Private Cloud, Beanstalk et de leur modèle de programmation.
Exercice
Création de ressources virtuelles avec les services EC2, S3, SQS, RDS. Déploiement d'une application Java.
6) Industrialisation et pratiques DevOps
- Besoin de traçabilité, de répétabilité. Infrastructure as Code (IaC).
- Bonnes pratiques et outils disponibles.
- Définition et utilité des architectures Cloud avec des instances basées sur les rôles.
- Mécanisme Cloud-Init et notion de UserData.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 51 / 86

Exercice
Création de scripts et exécution "tracée et contrôlée".
7) Création d'images Cloud AMI
- Les images virtuelles. Créer des AMI avec Amazon.
- Intégration avec la Software Factory. Usine à création d'images en mode SaaS - CloudImageFactory.
Exercice
Création d'images AMI AWS.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 52 / 86

Stage pratique de 3 jour(s)
Réf : SCA
Participants
Développeurs, architectes.
Pré-requis
Bonnes connaissances en
Programmation Orientée
Objet (Java, C#, C++).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
10 mar. 2014, 10 juin 2014
28 juil. 2014, 20 oct. 2014
8 déc. 2014
Scala, programmation
OBJECTIFS
Ce cours montre les bases de la programmation en Scala. Après avoir étudié le support de Scala par la
JVM vous rentrerez dans le détail des concepts liés à la programmation objet et fonctionnelle. Enfin, vous
étudierez les librairies spécifiques à Scala ainsi que sa coexistence avec les librairies de l'écosystème Java.
1) Présentation de Scala
2) Mise en place
3) Les principes de base du langage
4) La programmation fonctionnelle
1) Présentation de Scala
- Historique du langage.
- Les paradigmes objet et fonctionnel.
- Les langages pour la JVM.
- Quelle différence avec les langages Java, C# et C++ ?
- Les avantages.
- Les types d'applications utilisant Scala (Twitter...).
2) Mise en place
5) Mise en oeuvre des notions-concepts
avancées
6) Utilisation des APIs et librairies
7) Conclusion
- Le Shell Scala.
- Couplage avec les environnements de développement.
- Le compilateur et l'interpréteur Scala.
- Utilisation de Maven.
- Le déploiement sur un serveur.
Travaux pratiques
Mise en place de l'environnement.
3) Les principes de base du langage
- La syntaxe, la notation infixe. Le typage statique, les types de base.
- Les structures de contrôle. Les packages et les imports.
- Les classes (Class et Object), les interfaces. Les conversions implicites, les mécanismes d'inférence.
- La hiérarchie d'héritage. Les exceptions.
Exercice
Ecriture et test d'un programme mettant en oeuvre les bases du langage.
4) La programmation fonctionnelle
- Le paradigme de programmation fonctionnelle.
- Des données non-mutables : variables, structures de données, objets... Les listes.
- Tuples et tables associatives (set). Les fonctions (passage en argument, affectation dans des variables...).
- Les méthodes d'ordre supérieur, les fonctions pures.
Travaux pratiques
Ecriture et test d'un programme mettant en oeuvre la programmation fonctionnelle.
5) Mise en oeuvre des notions-concepts avancées
- Les types génériques. Les annotations.
- Les traits, les mixins.
- Le Pattern Matching (structure de contrôle case, les exceptions, la gestion des événements).
- La récursivité. Les extracteurs.
Exercice
Ecriture et test d'un programme mettant en oeuvre les notions avancées du langage.
6) Utilisation des APIs et librairies
- Les collections, les conversions possibles avec les collections Java.
- Manipulation du XML.
- Utilisation de librairies de l'écosystème java.
Exercice
Cohabitation d'objets Java et Scala au sein d'un même programme. Démonstration d'un déploiement d'une
application Java EE contenant des EJB Scala et Java.
7) Conclusion
- Comparaison des performances. Scala vs Java 8 : enjeux et perspectives.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 53 / 86

Stage pratique de 3 jour(s)
Réf : BOL
Participants
Cette formation s'adresse
aux informaticiens qui
souhaitent acquérir une
formation opérationnelle pour
développer ou maintenir des
applications en Cobol.
Pré-requis
Connaissances de base en
programmation. Expérience
souhaitable d'un langage de
développement.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
10 mar. 2014, 30 juin 2014
28 juil. 2014, 6 oct. 2014
15 déc. 2014
Programmation Cobol
OBJECTIFS
Cette formation a pour objectif de communiquer aux stagiaires une réelle compétence dans la programmation
Cobol. L'ensemble des concepts fondamentaux est développé. A l'issue de ce stage les participants savent
lire, écrire, mettre au point, des applications Cobol.
1) Premiers pas en Cobol
2) Les données
3) Instructions et expressions
4) Les tableaux
Travaux pratiques
5) Les fonctions
6) Programmes et sous-programmes
7) Les fichiers
8) Les impressions
De nombreux travaux pratiques illustrent systématiquement les concepts présentés. Ces travaux
représentent 60 % du cours.
1) Premiers pas en Cobol
- Le langage Cobol : ses origines et ses évolutions. Ses principes généraux.
- Les nouvelles versions de Cobol, Cobol et l'approche objet.
- Les différentes parties d'un programme (division).
- Les différentes zones (numéros d'ordre, indicateur, A, B).
- Les principaux symboles du langage (mots et littéraux).
- Les compilateurs : leurs utilités.
- Les outils de debug.
2) Les données
- Les différents Formats, les chaînes de caractères (ou Pictures), les niveaux.
- Les constantes figuratives. La redéfinition d'une donnée.
- Manipulation des données. Inspect, les paramètres utilisés dans les commandes. String et Unstring.
3) Instructions et expressions
- La description des traitements. La procédure division. Structure de base d'une instruction.
- Accept, Display, Move, les différentes zones (alphabétiques, alphanumériques, numériques).
- Les paramètres utilisés dans les commandes.
- Instructions arithmétiques : Compute, expressions arithmétiques, règles d'évaluation, Add, Subtract,
Multiply, Divide.
- Expressions conditionnelles et de branchement : Evaluate et Continue. Goto, Perform, Exit Alter. Les mots
réservés.
- Pour une bonne utilisation de ces instructions.
4) Les tableaux
- Présentation, Set, Search.
- Une utilisation différente des tableaux.
- Implémentation.
5) Les fonctions
- Différents modes d'appel : exemple de fonction.
- Fonctions financières, statistiques, de date, mathématiques.
- Autres fonctions intéressantes.
6) Programmes et sous-programmes
- Les conditions d'utilisation des sous-programmes.
- Call, Exit Program, Cancel, Stop, End Program.
7) Les fichiers
- La description des fichiers. La data division, organisation et structure, la Linkage Section.
- Les commandes de gestion des fichiers : Open, Close, Read, Start, Write, Rewrite, Delete.
8) Les impressions
- Présentation. Les différents types d'édition. Les différents formats de la commande d'édition : Write.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 54 / 86

Stage pratique de 4 jour(s)
Réf : COR
Participants
Concepteurs et développeurs
amenés à mettre en œuvre
des applications distribuées
basées sur Corba.
Pré-requis
Bonnes connaissances des
techniques de conception
objet. Très bonnes
connaissances d'un langage
objet (Java et/ou C++).
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
4 mar. 2014, 10 juin 2014
1 juil. 2014, 21 oct. 2014
9 déc. 2014
Corba, architecture, mise en œuvre
OBJECTIFS
Ce stage vous présentera la norme Corba 2.0 et les technologies associées. Il vous apportera tous les
éléments pour développer avec rigueur et efficacité des applications distribuées avec Corba dans un
environnement comprenant des langages et des systèmes d'exploitation différents.
1) Introduction
2) Caractéristiques des AD, position de Corba
3) L'architecture Corba
4) Le design et Corba
5) Implémenter Corba
1) Introduction
- Pourquoi des AD ? Fonctionnement en multi-tiers.
- Exemples de projets. Historique des AD et de Corba.
- Les apports de Corba 3, CCM.
2) Caractéristiques des AD, position de Corba
6) Client et serveur Corba
7) La gestion des exceptions Corba
8) Le service de nom
9) Le service de gestion des événements
10) CCM
- Vue d'ensemble. Approche client/serveur.
- Les services standard d'une AD : annuaire, gestion de la sécurité, transactions, bases de données.
- Fonctionnement des serveurs d'applications.
- Cycle de fonctionnement d'une AD. Gestion des instances d'objets, des threads et des clients.
- Montée en charge : Load Balancing. Round Robin...
- Comparatif de Corba/autres AD. WS, EJB, DCOM, .Net ...
3) L'architecture Corba
- Corba : un bus logiciel, une publication d'instances. un OA côté serveur, un protocole intéropérable GIP.
- L'IR. Le référentiel des implémentations.
- Le protocole GIOP. Les services Corba.
- Service de noms (annuaire) et autres services.
- Gestion des événements.
- Architecture complète Corba.
4) Le design et Corba
- Retour d'expériences. Approche modèle MVC.
- Utilisation de patterns de conception.
5) Implémenter Corba
- Processus de développement Corba.
- Gestion de l'IDL, génération des codes.
- Création des " Stub " et " Skeleton ".
- Approche DII/DSI, invocation dynamique.
- Le langage IDL : possibilités et points-clés.
6) Client et serveur Corba
- Process de développement.
- API standard. Code Java et C++
- Héritage d'interface IDL, approche TIE.
Travaux pratiques
Création d'un serveur Java.
7) La gestion des exceptions Corba
- Exceptions systèmes Corba, utilisateurs Corba.
- Fonctionnement sur le bus.
Travaux pratiques
Gestion d'exceptions Corba en Java.
8) Le service de nom
- Fonctionnement. Contraintes/Possibilités. API de programmation. Exemples de codes.
9) Le service de gestion des événements
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 55 / 86

- Fonctionnement. Gestion par " callback ". Proxy, admi-nistration. API de programmation. Exemples de
codes.
10) CCM
- Un modèle composants pour Corba.
- CIDL. Composants et interconnexions.
- Packaging. Déploiement. Administration.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 56 / 86

Stage pratique de 2 jour(s)
Réf : GIT
Participants
Développeurs, architectes,
chefs de projet.
Pré-requis
Aucun.
Prix 2014 : 1490€ HT
Eligible DIF
Dates des sessions
Paris
27 mar. 2014, 26 juin 2014
9 oct. 2014, 11 déc. 2014
Aix
3 mar. 2014
Mettre en œuvre le contrôle de versions avec le système
GIT
OBJECTIFS
Vous apprendrez dans ce stage à installer, configurer et utiliser GIT au quotidien pour gérer votre code
source. Vous mettrez en place différents dépôts, apprendrez à gérer les branches de vos projets et résoudrez
les conflits survenant lors d'opérations de fusion. Vous manipulerez également les outils annexes à GIT.
1) Présentation de GIT
2) Installation et configuration
3) Utilisation de GIT, les fondamentaux
4) Gestion locale des fichiers
1) Présentation de GIT
5) Gestion des branches
6) Partage du travail et collaboration
7) Mise en oeuvre des Outils GIT
- Intérêt de la gestion de code.
- Concepts de base du contrôle de version.
- Les différentes typologies : gestion centralisée ou distribuée.
- Les différentes solutions de gestion de versions : (GIT, CVS, SVN, Mercurial, Bazaar, ...).
- Apports la décentralisation.
- Principe de fonctionnement de GIT.
2) Installation et configuration
- Installation sous différents systèmes : UNIX/Windows.
- Le système d'émulation sous Windows msysgit.
- Configuration du fichier .gitconfig (nom, adresse mail, ...).
- La console.
- Déclaration d'un outil d'analyse de différentiel de versions.
Travaux pratiques
Installation et configuration de GIT sous Windows.
3) Utilisation de GIT, les fondamentaux
- Le modèle objet GIT : blob, tree, commit et tag.
- Le répertoire GIT et le répertoire de travail.
- L'index ou staging area.
- Création et initialisation un dépôt.
- Clonage d'un dépôt existant.
- Les concepts de branche, tag et de dépôt.
- Outil de visualisation Gitk.
Travaux pratiques
Création et initialisation d'un dépôt. Utilisation de l'outil de visualisation Gitk.
4) Gestion locale des fichiers
- Consultation de l'état de l'arbre de travail.
- Ajout, ignorance, modification, suppression et recherche de fichiers.
- Enregistrement des modifications (commit).
- Annulation des modifications.
- Visualisation des modifications.
- Parcours de l'historique des révisions.
- Les logs (statistique, formatage, ...).
Travaux pratiques
Manipulation des principales commandes GIT de gestion de modifications de fichiers.
5) Gestion des branches
- La branche « master ».
- Création de branches et de sous-branches.
- Changement de branche.
- Fusion d'une branche (merge/rebase), gestion des conflits.
- Comparaison de deux branches.
Travaux pratiques
Manipulation des principales commandes GIT de gestion des branches (création, fusion, comparaison)
6) Partage du travail et collaboration
- Mise en place d'un dépôt distant public ou privé.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 57 / 86

- Publier ses modifications (opération de push).
- Récupération des modifications de l'équipe (opération de pull).
- Les branches de suivi.
- Gestion des échecs.
Travaux pratiques
Mise en place d'un dépôt distant et simulation d'un travail collaboratif.
7) Mise en oeuvre des Outils GIT
- Git-gui et TortoiseGIT, la navigation graphique dans GIT.
- GITWeb, la navigation graphique au sein des dépôts.
- GITHub, le service d'hébergement de dépôts.
- Gerrit, le système de revue de code.
Travaux pratiques
Manipulation de quelques outils.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 58 / 86

Stage pratique de 3 jour(s)
Réf : PSQ
Participants
Concepteur de requêtes
SQL, en charge d'analyse/
reporting, gestionnaire de
bases de données, futur
développeur d'applications de
gestion de base de données,
administrateur ou chargé de
maintenance.
Pré-requis
Connaissances de base en
programmation.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
24 fév. 2014, 31 mar. 2014
28 avr. 2014, 26 mai 2014
30 juin 2014, 15 juil. 2014
15 sep. 2014, 13 oct. 2014
12 nov. 2014, 15 déc. 2014
SQL Server, Programmation SQL
OBJECTIFS
Cette formation vous permettra d'appréhender les fondements du langage SQL. Vous verrez la structure
du langage, les principes généraux des bases de données relationnelles (algèbre relationnelle, théorie des
ensembles), et vous aurez aussi une introduction pratique au développement SQL pour SGBDR.
1) Algèbre relationnelle et norme SQL
2) Extractions de données
3) Regroupements
Travaux pratiques
4) Extractions avancées
5) Mise à jour des données
6) SQL procédural
Les exemples et les travaux pratiques sont réalisés sur MS SQL Server, l'un des SGBDR les plus proches de
la norme SQL.
1) Algèbre relationnelle et norme SQL
- Les principes et notions essentielles du modèle relationnel.
- Comprendre l'algèbre relationnelle.
- Les douze règles de Codd.
- La norme SQL : historique de la normalisation du langage, différentes parties de SQL (DDL, DML, etc.).
- SQL et les SGBDR.
Démonstration
Scripts de création de base de données. Les objets d'une base de données. Découverte de la base étudiée.
2) Extractions de données
- Introduction : la notion de table.
- L'ordre SELECT et la clause TOP.
- Expression des valeurs, prédicats et logique ternaire (NULL), opérateurs, expressions et fonctions SQL.
- Extractions simples monotabulaires.
- Utiliser des jointures internes, externes, simples et avancées.
Travaux pratiques
Extraction à l'aide de la clause WHERE. Utilisation d'opérateurs IN, LIKE, CASE ... des opérateurs
numériques, dates, des fonctions de chaine. Utilisation des jointures. Tri des données.
3) Regroupements
- Fonctions d'agrégation (AVG, SUM, COUNT..)
- Création de sous-ensembles (clause GROUP BY).
- Filtrage des agrégats avec la clause HAVING.
- Fonctions analytiques et de rangement (OVER, RANK, DENSE_RANK..).
Travaux pratiques
Restituer et classer des données groupées à l'aide des fonctions présentées.
4) Extractions avancées
- Opérations ensemblistes.
- Sous-requêtes et comparateurs.
- Corrélation des sous-requêtes. Quantificateurs EXISTS, UNIQUE et DISTINCT.
- Expressions de tables.
- Requêtes récursives à l'aide de la CTE.
- Expressions diverses pour la division relationnelle.
Travaux pratiques
Ecriture de sous-requêtes. Création d'une sous-requête correlée. Utilisation d'expression de table commune.
5) Mise à jour des données
- Les ordres INSERT, UPDATE, DELETE, TRUNCATE.
- Insertion multiligne, modification de colonnes, suppression de lignes à l'aide d'une sous-requête.
- Combinaison d'INSERT ou d'UPDATE.
- Combinaison de CREATE TABLE et d'INSERT.
- Mise à jour des données à travers les vues.
Travaux pratiques
Opérations d'insertion et mises à jour de tables de la base de données.
6) SQL procédural
- Les dialectes SQL des principaux éditeurs.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 59 / 86

- Les UDF ou fonction utilisateur.
- La gestion d’une transaction et le mécanisme de verrouillage.
- Introduction aux procédures stockées.
- Notions basiques sur les déclencheurs.
Travaux pratiques
Création d'une transaction simple, d'une procédure stockée.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 60 / 86

Stage pratique de 2 jour(s)
Réf : PAV
Participants
Développeurs,
administrateurs, utilisateurs
avancés, ayant à mettre
en oeuvre des requêtes
complexes avec SQL Server.
Pré-requis
Bonnes connaissances des
bases du langage SQL ou
connaissances équivalentes à
celles apportées par le stage
" SQL Server, programmation
SQL " (PSQ).
Prix 2014 : 1350€ HT
Eligible DIF
Dates des sessions
Paris
20 mar. 2014, 26 juin 2014
24 juil. 2014, 9 oct. 2014
11 déc. 2014
SQL Server, programmation SQL avancée
OBJECTIFS
Grâce à ce cours, vous découvrirez les expressions et opérateurs SQL avancés, et verrez comment les
utiliser avec efficacité pour résoudre des problématiques d'extraction de données complexes. Vous saurez
traiter des besoins de regroupement, d'analyse, d'échantillonnage et de restitution de données hiérarchisées.
1) Rappel sur les requêtes multitables
2) Opérateurs particuliers
Méthodes pédagogiques
3) Les expressions de tables
4) L'écriture des données
Les stagiaires pourront récupérer les nombreux exemples et TP ainsi que la base servant de fil rouge. Des
références web et bibliographiques sont proposées pour en savoir plus sur chacun des sujets.
Travaux pratiques
Ce stage fait alterner la présentation des concepts et de la syntaxe, et de multiples exercices d'application.
1) Rappel sur les requêtes multitables
- Opérateurs ensemblistes UNION, INTERSECT et EXCEPT.
- Rappel sur les jointures internes et externes.
- Maîtriser les sous-requêtes dans les différentes parties des instructions SQL.
- Corrélations des requêtes imbriquées.
- Opérations d'intra-jointure avec APPLY (CROSS, OUTER) pour les fonctions et les fragments XML.
Travaux pratiques
Résolutions de cas de requêtes mettant en action plusieurs tables.
2) Opérateurs particuliers
- Utilité du produit cartésien (CROSS JOIN).
- La division relationnelle.
- Groupage décisionnel avec CUBE, ROLLUP et GROUPING SET.
- Fonctions analytiques et de fenêtrage : ordonnancement et agrégat avec les clauses OVER et WINDOW.
- Tableaux croisés avec PIVOT et UNPIVOT.
- Échantillon de données avec TABLESAMPLE.
Travaux pratiques
Résolution de cas de division relationnelle. Utilisation des fonctions de groupages décisionnels. Mise en
oeuvre des fonctions analytiques
3) Les expressions de tables
- L'expression de table commune, Common Table Expression (CTE), ou vue non persistante.
- L'utilisation du mot-clé WITH pour spécifier une CTE.
- Les différentes techniques de requêtage dans les arborescences (adjacence, chemin, intervallaire,
récursion).
- Résolution de problèmes de graphes avec les requêtes récursives.
- Utilisation de tables de nombres et de dates (tally tables) pour résoudre des requêtes complexes.
Travaux pratiques
Exprimer des requêtes sous la forme de la CTE récursive.
4) L'écriture des données
- Mise à jour et suppression des données avec sous-requêtes.
- Utilisation de la syntaxe étendue de mise à jour et suppression avec jointures.
- Opérations d'insertion, de mise à jour ou de suppression à partir de résultats d'une jointure, l'opérateur
MERGE.
- Récupération des données ajoutées, modifiées ou supprimées, avec la clause OUTPUT.
Travaux pratiques
Ecriture de commandes de mises à jour complexes avec l'instruction MERGE et les sous requêtes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 61 / 86

Stage pratique de 4 jour(s)
Réf : SED
Participants
Développeurs, chef de
projets.
Pré-requis
SQL Server 2012/2008, développement
OBJECTIFS
Ce stage vous procurera toutes les connaissances nécessaires pour développer des applications sous SQL
Server. Il vous apprendra notamment à manipuler les objets d'une base de données, à optimiser les temps
de restitution des données, et à réaliser les opérations de maintenance courantes du développeur.
Connaissances de base en
programmation. Notions sur
les bases de données et le
langage SQL.
1) La construction des bases de données
2) Requêtes d'extraction de données
3) Mise à jour des données
4) Coder en Transact SQL
5) Optimisation de l'exécution des requêtes
6) Maintenance courante pour le développeur
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
4 fév. 2014, 13 mai 2014
29 juil. 2014, 30 sep. 2014
2 déc. 2014
1) La construction des bases de données
- Le stockage physique avec les fichiers et les groupes de fichiers.
- Les schémas SQL ou le stockage logique.
- Bon usage des différents types de données.
- Créer des tables. Mise en place des contraintes.
- Obtenir un rétro script DDL.
Travaux pratiques
Créer les tables d'une base de données et définir les contraintes associées.
2) Requêtes d'extraction de données
- Les opérateurs ensemblistes.
- Les jointures internes et externes. Typologies.
- Les sous-requêtes.
- Utiliser les " Common Table Expression " (CTA) et les requêtes récursives.
- Fonctions fenêtrées et clause OVER (ordonnancement, agrégat et fenêtrage RANGE/ROWS).
- Les opérateurs particuliers (APPLY, PIVOT...).
- La création des vues.
Travaux pratiques
Manipuler des requêtes d'extraction avec différents types de jointures. Présenter les données avec les
fonctions d'agrégat. Créer des vues.
3) Mise à jour des données
- Les mises à jour simples (INSERT, UPDATE et DELETE).
- L'ordre SQL MERGE.
- Mise à jour avec des sous requêtes.
- BULK INSERT et BCP pour le chargement de fichier et l'export de données.
Travaux pratiques
Réaliser des opérations de mise à jour de la base. Importer et exporter des données.
4) Coder en Transact SQL
- Eléments du langage Transact SQL. Notion de Batch.
- Créer des fonctions scalaires et des fonctions tables.
- Présentation des transactions.
- Programmation des déclencheurs.
- Développer des procédures stockées.
Travaux pratiques
Créer des fonctions et des vues paramétrables. Créer des procédures stockées gérant des transactions.
Automatiser des traitements à l'aide de déclencheurs.
5) Optimisation de l'exécution des requêtes
- Visualisation des plans de requêtes.
- Métrique (IO TIME) et comparaison d'exécution.
- Présentation des index. Que faut-il indexer ?
Travaux pratiques
Comparer les temps d'exécution pour des scénarios d'indexation. Utiliser des plans de requêtes.
6) Maintenance courante pour le développeur
- Sauvegarde des données. Scénarios de restauration.
- Maintenir les index et les statistiques.
- Vérifier l'intégrité physique d'une base et la réparer.
Travaux pratiques
Effectuer des sauvegardes et des restaurations. Élaborer un plan de maintenance des index.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 62 / 86

Stage pratique de 5 jour(s)
Réf : QSM
Participants
Cette formation est destinée
à des ingénieurs systèmes et
des développeurs qui doivent
utiliser ou mettre en oeuvre
SQL Server 2012.
Pré-requis
Bonnes connaissances
du langage SQL ou
connaissances équivalentes à
celles apportées par le stage
" SQL Server, programmation
SQL " (réf. PSQ).
Prix 2014 : 2770€ HT
Eligible DIF
Dates des sessions
Paris
10 fév. 2014, 14 avr. 2014
30 juin 2014, 15 sep. 2014
24 nov. 2014
SQL Server 2012, mise en œuvre
OBJECTIFS
Ce stage vous apportera toutes les connaissances nécessaires à la pleine utilisation de SQL Server 2012.
Vous apprendrez à écrire des ordres SQL et utiliser les extensions du langage, à modifier les structures et
mettre en place les contraintes d'intégrité, à charger les données et exploiter au mieux les transactions.
1) Présentation de SQL Server 2012
2) Bases de données et schémas SQL
3) Tables, vues et contraintes
4) Chargement de données et exports
1) Présentation de SQL Server 2012
- Architecture de SQL Server 2012.
- Outils de développement et d'administration.
Travaux pratiques
Prise en main du gestionnaire de configuration et de Management Studio.
2) Bases de données et schémas SQL
- Les identifiants : nommage des objets SQL Server.
- Création de la base de données. Schémas SQL.
- Cycle de vie des objets d'une base.
3) Tables, vues et contraintes
5) Indexation et plans de requêtes
6) SQL avancé avec Transact SQL, code
procédural
7) Transactions et gestion des exceptions
8) Introduction aux techniques avancées
- Langage DDL : création d'objets, contraintes.
- Types de données natifs et types utilisateurs.
- Création des tables et des vues.
- Les contraintes de domaine et de colonne.
- Clé primaire et clés alternatives. Gestion de l'intégrité référentielle.
Travaux pratiques
Création de types utilisateurs. Création de tables et de vues. Ajout de contraintes. Mise en place de clés
primaires et de contraintes d'unicité.
4) Chargement de données et exports
- La commande BULK INSERT.
- Import/export en ligne de commande avec BCP.
- Fonctions OPEN pour interroger les données externes.
- Présentation d'Integration Services.
Travaux pratiques
Chargement des données à l'aide de BULK INSERT et BCP. Utilisation d'OPENROWSET.
5) Indexation et plans de requêtes
- Structure des index : arbre équilibré, index clustered...
- Création d'index : approche de création...
- Analyse des performances.
- Utilisation du Database Tuning Advisor.
Travaux pratiques
Mise en place d'index sur la base de données et constat sur les performances.
6) SQL avancé avec Transact SQL, code procédural
- Groupages OLAP et clauses OUTPUT, SELECT INTO...
- Ordre SQL MERGE. Chiffrement des données.
- Fonctions, procédures stockées, curseurs, déclencheurs.
Travaux pratiques
Création de requêtes avancées de Transact-SQL. Réalisation d'une fonction table multi-instructions.
Procédure stockée pour l'insertion combinée.
7) Transactions et gestion des exceptions
- Les transactions. Niveaux d'isolation. Gestion des exceptions. Transactions imbriquées.
Travaux pratiques
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 63 / 86

Intégration de la gestion des exceptions et des transactions dans les déclencheurs et les procédures
stockées.
8) Introduction aux techniques avancées
- Présentation du Système d'Information Géographique-SIG. Utilisation de XML au sein de SQL Server 2012.
Travaux pratiques
Utilisation du SIG. Interrogation XML.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 64 / 86

Stage pratique de 2 jour(s)
Réf : TAS
Participants
Chefs de projet, concepteurs
et développeurs Transact-
SQL.
Pré-requis
Bonnes connaissances des
bases du langage SQL ou
connaissances équivalentes à
celles apportées par le stage
" SQL Server, programmation
SQL " (PSQ).
Prix 2014 : 1350€ HT
Eligible DIF
Dates des sessions
Paris
20 mar. 2014, 26 juin 2014
21 aoû. 2014, 2 oct. 2014
11 déc. 2014
Transact-SQL, optimisation pour SQL Server 2012/2008
OBJECTIFS
Cette formation présente les règles de bonne écriture et d'optimisation du Transact-SQL, pour améliorer les
performances des requêtes et éviter les écueils fréquemment rencontrés lors de la programmation en T-SQL.
1) Le modèle relationnel et le langage SQL
2) Réussir l'indexation
3) Écrire des requêtes performantes
Travaux pratiques
4) Remplacer tables temporaires et curseurs
5) Bonnes pratiques pour les modules de code
Formation interactive, alternant étroitement théorie et pratique. L'apprentissage se fait par l'expérimentation.
1) Le modèle relationnel et le langage SQL
- Les spécificités des bases de données relationnelles et du langage SQL.
- La normalisation du modèle de données.
- Les notions d'écriture ensembliste et déclarative. Les spécificités du dialecte Transact-SQL.
- Le fonctionnement de l'optimiseur SQL.
Travaux pratiques
Expérimentation de requêtes sur des modèles plus ou moins normalisés.
2) Réussir l'indexation
- Les bases de l'indexation. La structure en B-Tree et les différents types d'index.
- Comment choisir ses index en fonction des requêtes ?
- La notion de couverture de requête par un index.
- Le concept de SARG (Search Argument) pour favoriser l'utilisation de l'index.
- Utilisation du profiler et du Database Tuning Advisor.
Travaux pratiques
Indexation de tables pour améliorer les performances de requêtes.
3) Écrire des requêtes performantes
- Les règles de bonne écriture des requêtes SQL.
- Lire et utiliser les statistiques d'exécution et le plan d'exécution. Optimiser ses jointures et ses
regroupements.
- Optimiser le code de mise à jour des données.
- Erreurs les plus communes : SQL dynamique, fonctions utilisateurs, comparaisons insensibles à la casse.
Travaux pratiques
Réécriture de requêtes peu performantes.
4) Remplacer tables temporaires et curseurs
- Maîtriser les sous-requêtes et les opérateurs relationnels.
- Utiliser l'instruction MERGE pour les mises à jour de données complexes.
- Créer des tables de nombres et de dates pour résoudre les problèmes de façon relationnelle.
- Utiliser les fonctions de fenêtrage et les fonctions statistiques.
- Utiliser le CROSS JOIN pour résoudre les problèmes complexes.
- Écrire du code récursif en utilisant des expressions de table.
Travaux pratiques
Résolution de problématiques complexes par des requêtes ensemblistes.
5) Bonnes pratiques pour les modules de code
- Règles pour l'écriture de procédures stockées.
- Maîtriser la compilation et recompilation.
- Minimiser l'impact des déclencheurs. Comprendre les transactions et les problèmes de verrouillage.
- Utiliser les niveaux d'isolation de la transaction.
Travaux pratiques
Ecriture d'une procédure stockée optimisée.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 65 / 86

Stage pratique de 5 jour(s)
Réf : SEM
Participants
Cette formation est destinée
à des ingénieurs système et
des développeurs doivent
utiliser ou mettre en œuvre
SQL Server 2008.
Pré-requis
Bonnes connaissances
du langage SQL ou
connaissances équivalentes à
celles apportées par le stage
" Programmation SQL " (réf.
PSQ).
Prix 2014 : 2770€ HT
Eligible DIF
Dates des sessions
Paris
31 mar. 2014, 30 juin 2014
25 aoû. 2014, 6 oct. 2014
1 déc. 2014
Aix
24 mar. 2014, 23 juin 2014
22 sep. 2014, 8 déc. 2014
Bordeaux
3 mar. 2014, 2 juin 2014
29 sep. 2014, 15 déc. 2014
Bruxelles
3 mar. 2014, 2 juin 2014
15 sep. 2014, 1 déc. 2014
Geneve
3 mar. 2014, 2 juin 2014
15 sep. 2014, 1 déc. 2014
Lille
3 mar. 2014, 2 juin 2014
29 sep. 2014, 15 déc. 2014
Luxembourg
3 mar. 2014, 2 juin 2014
15 sep. 2014, 1 déc. 2014
Lyon
24 mar. 2014, 23 juin 2014
22 sep. 2014, 8 déc. 2014
Nantes
31 mar. 2014, 30 juin 2014
15 sep. 2014, 1 déc. 2014
Rennes
31 mar. 2014, 30 juin 2014
15 sep. 2014, 1 déc. 2014
Sophia-antipolis
24 mar. 2014, 23 juin 2014
22 sep. 2014, 8 déc. 2014
Strasbourg
3 mar. 2014, 2 juin 2014
29 sep. 2014, 15 déc. 2014
Toulouse
3 mar. 2014, 2 juin 2014
29 sep. 2014, 15 déc. 2014
SQL Server 2008, mise en œuvre
OBJECTIFS
Cette formation vous apportera toutes les connaissances nécessaires à la pleine utilisation de SQL Server
2008. Elle vous permettra de comprendre le rôle des divers composants de SQL Server 2008, d'utiliser les
outils de requête, et d'écrire des ordres SQL de manipulation des données incluant les extensions au langage
SQL propres à SQL Server. Elle vous montrera comment modifier la structure des tables, mettre en place les
contraintes d'intégrité et comment exploiter au mieux le concept de transaction.
1) Présentation de SQL Server 2008
2) Bases de données et schémas SQL
3) Tables et vues
4) Les contraintes
5) Chargement de données et exports
1) Présentation de SQL Server 2008
- Présentation de SQL Server 2008. Versions.
- Architecture de SQL Server 2008.
- Outils de développement et d'administration.
- Les bases systèmes.
6) SQL avancé avec Transact SQL
7) Indexation et plans de requêtes
8) Codage procédural
9) Transactions et gestion des exceptions
10) Introduction aux techniques avancées
Travaux pratiques
Prise en main des outils graphiques de SQL Server : gestionnaire de configuration et Management Studio.
2) Bases de données et schémas SQL
- Les identifiants : nommage des objets SQL Server.
- Stockage physique : fichiers de données et journal de transactions.
- Création de la base de données : gestion des espaces de stockage paramètres de création.
- Schémas SQL : concept et utilisation.
- Cycle de vies des objets d'une base.
- Brèves notions sur la gestion des privilèges.
- Vues et procédures de métadonnées.
Travaux pratiques
Création physique d'une base de données. Mise en place de différents schémas SQL. Modification des
paramètres de la base de données
3) Tables et vues
Langage DDL : création d'objets, contraintes
- Types de données SQL Server et types utilisateurs.
- Création des tables : définition des colonnes.
- Gestion des auto-incréments.
- Création et utilisation des vues.
- Conditions de mise à jour à travers les vues.
Travaux pratiques
Création de types utilisateurs. Création de tables et de vues. Manipulation des auto-incréments. Mise à jour à
travers les vues.
4) Les contraintes
- Les contraintes de domaine (CHECK).
- Contraintes de colonne NOT NULL et DEFAULT.
- Clef primaire et clefs alternatives.
- Gestion de l'intégrité référentielle.
- Utilisation de déclencheurs Ttriggers) pour la réalisation des assertions.
Travaux pratiques
Ajout de contraintes de domaines aux types utilisateurs et aux colonnes. Mise en place de clefs primaires et
de contraintes d'unicité. Mise en place de clefs étrangères. Réalisation de contraintes complexes CHECK à
l'aide de fonctions et de déclencheurs.
5) Chargement de données et exports
- Chargement de fichier avec la commande BULK INSERT
- Import/export en ligne de commande avec bcp.
- Fonctions OPEN pour interroger les données externes.
- Gestion des flux interserveurs.
- Integration Services.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 66 / 86

Travaux pratiques
Chargement des données à l'aide de BULK INSERT et bcp. Utilisation d'OPENROWSET pour faire des
requêtes externes.
6) SQL avancé avec Transact SQL
- Manipulation de données booléennes.
- Groupages OLAP (CUBE, ROLLUP, GROUPING SETS...)
- Fonction de fenêtrage et clause OVER.
- Tableaux croisés avec PIVOT et UNPIVOT.
- Clauses TOP et SAMPLE.
- Clause OUTPUT, SELECT INTO, TRUNCATE TABLE.
- Ordre SQL MERGE.
- Gestion d'objets larges à l'aide du type filestream.
- Cryptage des données
Travaux pratiques
Exercices de requêtes mettant en œuvre les fonctions avancées de Transact-SQL.
7) Indexation et plans de requêtes
- Présentation : rôle des index, utilisation.
- Structure des index : arbre équilibré, index ordonné et non ordonné, statistiques de distribution.
- Création d'index : approche de création, choix des index.
- Utilisation du Database Tuning Advisor.
- Indexation de vues : indications et contraintes.
- Index pour recherche en texte intégral.
- Analyse des performances.
Travaux pratiques
Mise en place d'index sur la base de données et constat sur les performances.
8) Codage procédural
- Syntaxe procédurale du Transact SQL (variables, affectation, types de données et structures).
- Création de fonctions scalaires (UDF).
- Fonction tables (requête paramétrées).
- Principe des procédures stockées.
- Création et utilisation de tables temporaires et de variables table.
- Manipulation de curseurs.
- Déclencheurs : types de triggers.
- Débogage du code Transact-SQL.
Travaux pratiques
Réalisation de fonctions scalaires et de déclencheurs pour gérer la qualité des données. Réalisation d'une
fonction table multi instruction. Programmation d'une procédure stockée pour l'insertion combinée.
9) Transactions et gestion des exceptions
- Principe des transactions : mode implicite et explicite.
- Définition des frontières des transactions.
- Anomalies transactionnelles, gestion des niveaux d'isolation et mise en place des verrous.
- Gestion des exceptions.
- Problématique des transactions imbriquées.
- Transactions distribuées et commit à deux phases.
Travaux pratiques
Intégration de la gestion des exceptions et des transactions dans les déclencheurs et les procédures
stockées.
10) Introduction aux techniques avancées
- Présentation du SIG de SQL Server (système d'information géographique).
- Utilisation de XML au sein de SQL (requêtes avec XQuery/XPath et clause FOR XML).
- Introduction à l'indexation textuelle (Full Text Search).
- Intégration de .NET dans SQL Server.
Travaux pratiques
Utilisation du SIG, interrogation XML et recherches "plain text".
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 67 / 86

Stage pratique de 3 jour(s)
Réf : SQD
Participants
Ingénieur, architecte base
de données, chef de projet
et développeur désireux
de mettre en œuvre SQL
Server 2005 ou 2008 dans
des applications critiques et
ayant déjà pratiqués MS SQL
Server.
Pré-requis
Très bonnes connaissances
de MS SQL Server
2005/2008, ou connaissances
équivalentes à celles
apportées par les stages
"Programmation SQL" (réf.
PSQ) et "SQL Server, mise en
œuvre" (réf. SQM ou SEM).
Eligible DIF
SQL server 2008, mise en œuvre avancée
OBJECTIFS
Cette formation vous apportera les connaissances nécessaires pour la mise en œuvre de bases SQL Server
dans lesquelles la volumétrie des données et la montée en charge sont des enjeux majeurs. Elle vous
permettra de comprendre les techniques essentielles pour gagner en performance ainsi qu'en temps de
développement.
1) Types de données, tables et contraintes
2) Qualité des données, dénormalisation,
fonctions avancées
3) Contraintes complexes
1) Types de données, tables et contraintes
- Création des domaines SQL.
- Gestion des contraintes de domaines.
- Création des tables et intégration des contraintes.
- Rappels sur la gestion des privilèges.
4) Les vues SQL
5) Introduction au mapping relationnel objet
(ORM) côté serveur
6) Bases de données réparties
Travaux pratiques
Création de domaines SQL et utilisation de ces domaines dans la création des tables.
2) Qualité des données, dénormalisation, fonctions avancées
- Fonctions de gestion de la qualité des données.
- Intégration de ces fonctions dans des déclencheurs.
- Dénormalisation de tables via les colonnes calculées, les déclencheurs et les vues indexées.
- Nouvelles fonctions d'agrégat via SQL CLR.
Travaux pratiques
Intégration de la gestion de la qualité des données. Dénormalisation et étude des gains obtenus.
3) Contraintes complexes
- Mise en place de contraintes complexes (CHECK).
- Intégrité référentielle : greffage de la référence, gestion de la mise à jour, problématiques de valuation
partielle.
- Utilisation des procédures stockées pour la simulation de contraintes circulaires ou déférables.
Travaux pratiques
Réalisation de contraintes de validation incluant le calcul d'un agrégat externe. Mise en place d'une contrainte
circulaire.
4) Les vues SQL
- Intérêt des vues.
- Notion de schéma externe.
- Création des vues et limitation des accès aux données.
- Mise à jour des données à travers les vues.
- Utilisation de vues partitionnées pour la montée en charge.
Travaux pratiques
Création de vues. Etude de leurs mises à jour.
5) Introduction au mapping relationnel objet (ORM) côté serveur
- Création de vue de mapping RO pour intégration dans les objets client.
- Mise en place de procédure de correspondance pour la manipulation des objets.
- Utilisation des déclencheurs INSTEAD OF pour simuler la mise à jour de vues complexes.
Travaux pratiques
Mise en place du mapping complet sur un objet relationnel.
6) Bases de données réparties
- Introduction aux architectures de données distribuées avec SODA.
- Les points de terminaison http et les services web SQL Server.
- Utilisation de Service Broker pour des bases de données collaboratives.
Travaux pratiques
Démonstration de Service Broker.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 68 / 86

Stage pratique de 5 jour(s)
Réf : SQN
Participants
Cette formation est destinée
à des ingénieurs système et
des développeurs qui doivent
utiliser ou mettre en œuvre
SQL Server 2005.
Pré-requis
Bonnes connaissances
du langage SQL ou
connaissances équivalentes à
celles apportées par le stage
"Programmation SQL" (réf.
PSQ).
Prix 2014 : 2770€ HT
Eligible DIF
Dates des sessions
Paris
19 mai 2014, 8 sep. 2014
17 nov. 2014
Bruxelles
12 mai 2014, 22 sep. 2014
24 nov. 2014
Geneve
12 mai 2014, 22 sep. 2014
24 nov. 2014
Luxembourg
12 mai 2014, 22 sep. 2014
24 nov. 2014
SQL Server 2005, mise en œuvre
OBJECTIFS
Cette formation vous apportera toutes les connaissances nécessaires à l'utilisation de SQL Server 2005.
Vous y mettrez en pratique l'écriture des requêtes SQL de sélection et mise à jour des données. Vous
apprendrez à modifier la structure des tables et à définir des contraintes d'intégrité référentielle.
1) Création et gestion d'une base de données
2) Spécificités du dialecte Transact-SQL
3) Objets de code
4) Index, traces et plans d'exécution
1) Création et gestion d'une base de données
- Moteurs, composants, objets.
- Outils de développement et d'administration.
- Fichiers de données et journal de transactions.
- Schémas : concept et création (tables, colonnes).
- DDL : création, modification, destruction.
- Vues et procédures de métadonnées.
- Implémentation des contraintes.
- Chargement de données : BULK INSERT, BCP...
5) Langage Transact-SQL
6) Intégration de XML
7) Intégration de .NET
Travaux pratiques
Utilisation de SQL Server Management Studio. Mise en œuvre d'un modèle pour la création de la base,
importation et intégration de données.
2) Spécificités du dialecte Transact-SQL
- Instructions PIVOT et UNPIVOT : tableaux croisés.
- Clauses OUTPUT, SELECT INTO, TRUNCATE TABLE.
- Clauses TOP et SAMPLE. Les objets larges.
Travaux pratiques
Requêtes avec Transact-SQL.
3) Objets de code
- Vues : création et utilisation des vues.
- Procédures : création, valeur de retour.
- Fonctions utilisateurs (UDF) : scalaires...
- Déclencheurs : AFTER et INSTEAD OF.
Travaux pratiques
Création et utilisation d'objets.
4) Index, traces et plans d'exécution
- Structure des index : ordonné...
- Création d'index : approche, choix, pertinence. Utilisation du Database Tuning Advisor.
- Indexation de vues : indications et contraintes.
- Index pour recherche en texte intégral.
- Comprendre le plan de requête, utiliser le profiler.
Travaux pratiques
Création d'index, constat des performances.
5) Langage Transact-SQL
- Identifiants, variables, types de données et structures.
- Création et utilisation de tables temporaires.
- Utilisation des curseurs.
- Les transactions : délimitation, niveau d'isolation.
- Débogage du code Transact-SQL.
- Gestion des erreurs et manipulation des exceptions.
Travaux pratiques
Gestion des transactions et des erreurs.
6) Intégration de XML
- Rappels : types de données, typage.
- Requêtes par Xquery, modification par XML DML.
- Extraction en XML avec l'instruction FOR XML.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 69 / 86

- Indexation des colonnes XML.
Travaux pratiques
Interrogation d'une base de données, utilisation des typages, extraction directe en XML.
7) Intégration de .NET
- Types d'objets, relation avec SQL Server.
- Les ASSEMBLY. Sécurité du code managé.
- Utilisation de SQL Server 2005 depuis ADO.NET 2.0.
Travaux pratiques
Développement de procédures stockées en .NET dans SQL Server 2005.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 70 / 86

Stage pratique de 4 jour(s)
Réf : SQS
Participants
DBA SQL Server, chefs de
projets ayant à piloter des
développements impliquant
de fortes volumétries
(données, accès...) et
développeurs face à des
problématiques de temps de
réponse.
Pré-requis
Bonnes connaissances de
la modélisation de données,
des concepts des SGBDR,
de MS SQL Server et des
langages SQL et Transact
SQL. Connaissances de base
sur les OS Windows.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
20 mai 2014, 2 sep. 2014
25 nov. 2014
Bruxelles
4 mar. 2014, 3 juin 2014
23 sep. 2014, 2 déc. 2014
Geneve
4 mar. 2014, 3 juin 2014
23 sep. 2014, 2 déc. 2014
Luxembourg
4 mar. 2014, 3 juin 2014
23 sep. 2014, 2 déc. 2014
SQL Server, optimisation
OBJECTIFS
Cette formation constitue une introduction rationnelle et efficace à l'optimisation des bases des données
relationnelles MS SQL Server en vue d'obtenir de hautes performances pour des applications complexes ou
à forte volumétrie. Elle couvre différentes versions de SQL Server.
1) Le modèle et les données
2) Optimisation du matériel
3) Paramétrage de SQL Server
4) Ecriture et lecture des données
1) Le modèle et les données
5) Optimiser les requêtes SQL
6) Coder pour la performance
7) Gérer de grandes bases de données
- Influence du type de données. Standard de schématisation. Composition des clefs.
- Modélisation en fonction de la volumétrie.
- Utilisation des contraintes et des déclencheurs.
- Qualité des données. Gestion de la redondance.
Travaux pratiques
Comparaison de deux modèles aux données identiques.
2) Optimisation du matériel
- Processeurs et gestion du parallélisme.
- Mémoire vive. Fenêtre de données et RAM optimale.
- Comparaisons des versions 32 et 64 bits de Windows.
- Paramètres des disques durs. RAID et SAN.
- Infrastructure réseau : bonnes pratiques.
Travaux pratiques
Mesure des I/O du serveur physique à l'aide de Perfmon.
3) Paramétrage de SQL Server
- Remarques sur l'installation. Paramètres : OS, SQL Server, session. Audit du serveur avec Perfmon.
- Gestion des ressources par Quota.
Travaux pratiques
Mesure des caractéristiques du serveur logique à l'aide de requêtes SQL et du moniteur de performances.
4) Ecriture et lecture des données
- Le moteur de stockage. Le cache des données.
- Checkpoint et LazyWriter.
- Organisation des tables et index. Volumétrie.
- Transaction. Logs. Niveaux d'isolation.
- Organisation logique des fichiers.
Travaux pratiques
Création d'une base multifichiers et migration des données.
5) Optimiser les requêtes SQL
- Rôle de l'optimiseur. Code procédural. Requêtes complexes. Influence de l'écriture des requêtes.
- Plan de requête et statistiques d'exécution.
- Défragmentation des index.
- Monitorer l'exécution des requêtes.
- Utilisation des DMV pour affiner l'optimisation.
Travaux pratiques
Comparaison des différentes écritures d'une même requête à l'aide de l'audit via Profiler.
6) Coder pour la performance
- Choisir entre Transact SQL et SQLCLR (C#, .Net).
- Bonnes pratiques pour les procédures stockées.
- Transactions : effets de bord et exceptions.
- Déclencheurs et performances.
- Monitorat. Tuning. Mesure.
Travaux pratiques
Réalisation d'une procédure de calcul d'auto-incrément (compteur) et d'une fonction utilisateur.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 71 / 86

7) Gérer de grandes bases de données
- VLDB (Very Large DataBase).
- La compression des données, des Backups.
- Le partitionnement.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 72 / 86

Stage pratique de 3 jour(s)
Réf : OSL
Participants
Toute personne ayant
un profil d'informaticien
désirant se servir de SQL en
environnement Oracle.
Pré-requis
Connaissances de base en
informatique.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
10 fév. 2014, 10 mar. 2014
7 avr. 2014, 5 mai 2014
10 juin 2014, 18 aoû. 2014
15 sep. 2014, 13 oct. 2014
17 nov. 2014, 8 déc. 2014
Aix
17 mar. 2014, 30 juin 2014
6 oct. 2014, 15 déc. 2014
Bordeaux
24 mar. 2014, 23 juin 2014
15 sep. 2014, 15 déc. 2014
Bruxelles
24 mar. 2014, 22 sep. 2014
15 déc. 2014
Geneve
24 mar. 2014, 22 sep. 2014
15 déc. 2014
Lille
24 mar. 2014, 23 juin 2014
15 sep. 2014, 15 déc. 2014
Luxembourg
24 mar. 2014, 22 sep. 2014
15 déc. 2014
Lyon
17 mar. 2014, 30 juin 2014
6 oct. 2014, 15 déc. 2014
Nantes
17 mar. 2014, 30 juin 2014
22 sep. 2014, 1 déc. 2014
Rennes
17 mar. 2014, 30 juin 2014
22 sep. 2014, 1 déc. 2014
Sophia-antipolis
17 mar. 2014, 30 juin 2014
6 oct. 2014, 15 déc. 2014
Strasbourg
24 mar. 2014, 23 juin 2014
15 sep. 2014, 15 déc. 2014
Toulouse
24 mar. 2014, 23 juin 2014
15 sep. 2014, 15 déc. 2014
Oracle SQL
OBJECTIFS
Une formation pratique aux aspects essentiels, logique et syntaxe, du langage SQL. Ce cours vous apportera
une méthode sûre d'écriture de requêtes SQL complexes.
1) Introduction
2) Outils
3) Introduction SQL
1) Introduction
- Le modèle relationnel.
- Notions de base : relation (table), attributs (colonnes), contraintes d'intégrité.
- Contraintes d'intégrité.
2) Outils
- SQL*Plus.
- SQL Developer.
3) Introduction SQL
- Types de données Oracle.
- Création des tables.
- Introduction aux instructions de mise à jour.
- Utilisation des séquences.
- Introduction à l'interrogation (SELECT).
4) Interrogation des données
4) Interrogation des données
5) Objets d'une base de données Oracle
6) Instructions SQL complexes
- Tri et suppression des doublons. Utilisation des alias et des préfixes.
- Traitement de la valeur NULL. Utilisation des fonctions SQL.
- Utilisation des pseudo-colonnes : ROWID et ROWNUM. Utilisation des agrégats : COUNT, SUM, AVG...
- Opérations ensemblistes : union, intersection, différence.
- Requêtes imbriquées : opérateurs IN, EXISTS.
- Utilisation des jointures.
- Jointures externes.
- Groupement : GROUP BY et HAVING.
5) Objets d'une base de données Oracle
- Création et suppression des tables.
- Gestion des contraintes d'intégrité : clé primaire, unicité, non-nullité, CHECK, contraintes référentielles.
- Utilisation des vues.
- Utilisation des synonymes.
- Dictionnaire de données.
6) Instructions SQL complexes
- Paramétrage des scripts SQL*Plus.
- Division et interrogations complexes.
- Instructions de mise à jour avec des requêtes imbriquées.
- Les requêtes hiérarchiques.
- Utilisation des expressions régulières.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 73 / 86

Stage pratique de 2 jour(s)
Réf : OSP
Participants
Toute personne impliquée
indirectement dans l'exécution
de requêtes SQL avancées
(développeur, DBA, maîtrise
d'ouvrage).
Pré-requis
Bonnes connaissances
des bases du SQL ou
connaissances équivalentes à
celles apportées par le stage
"Oracle SQL" (réf. OSL).
Expérience requise.
Prix 2014 : 1350€ HT
Eligible DIF
Dates des sessions
Paris
27 mai 2014, 25 sep. 2014
20 nov. 2014
Oracle SQL, perfectionnement
OBJECTIFS
Cette formation très pratique se propose de développer les aspects avancés du langage SQL comme
les opérateurs ensemblistes, la gestion des LOB, des Bfiles et du XML, les fonctions d'agrégation et de
statistiques.
1) Les fonctions complémentaires
2) Les opérateurs ensemblistes
3) La gestion des LOB et des Bfiles
4) Agrégation, jointures et sub-select
1) Les fonctions complémentaires
- Fonctions de transformation.
- Fonctions analytiques : Rank, Dense_Rank.
- Fonction hiérarchique. Autres fonctions : Rowid, etc.
5) La gestion des intégrités
6) La gestion du XML
7) Le partitionnement des données
8) La gestion des tables distantes
Travaux pratiques
Mise en forme de données disparates (dates, numériques), liste d'une hiérarchie à plusieurs niveaux.
2) Les opérateurs ensemblistes
- Union et Union ALL.
- Différence Minus.
- Exists, Some, Any, All.
Travaux pratiques
Recherche des différences entre plusieurs tables.
3) La gestion des LOB et des Bfiles
- Utilisations possibles. Définition des tables.
- Insertion et mises à jour des LOB.
- Gestion d'un Bfile.
Travaux pratiques
Ajout d'une photo dans une table, ajout d'un CV dans une table.
4) Agrégation, jointures et sub-select
- Les fonctions d'agrégation et statistiques : Group By Rollup. Group by Cube. Group by Sets.
- Rappel des jointures " classiques ". Auto-jointure. FULL, RIGHT, LEFT.
- Sub-select corrélés/non-corrélés avec des Insert, Update, Delete.
Travaux pratiques
Statistiques et regroupements sur plusieurs critères. Création d'une table à partir d'autres tables.
5) La gestion des intégrités
- Rappel des définitions : unicité, référentielle, cohérence.
- Mise en oeuvre : Primary Key, Foreign Key, Increment, Check.
- Principes d'utilisation. Bonnes pratiques et limites.
Travaux pratiques
Création de tables en intégrité référentielle. Ajout/suppression des contraintes d'intégrité et des contrôles par
Check.
6) La gestion du XML
- Stockage de XML. Utilisation de fonctions avancées XML.
Travaux pratiques
Gestion d'un document XML.
7) Le partitionnement des données
- Les différents types de partitionnements possibles.
- Mise en oeuvre du partitionnement des données.
Travaux pratiques
Création de tables partitionnées, rechargement des données.
8) La gestion des tables distantes
- Rappel des principes : schémas, ODBC, DRDA.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 74 / 86

- Accès à une table distante. Jointures avec des tables distantes.
Travaux pratiques
Lecture des tables d'autres BD.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 75 / 86

Stage pratique de 3 jour(s)
Réf : ROD
Participants
Ce stage s'adresse aux
développeurs d'applications
décisionnelles sous Oracle
désireux d'utiliser tout le
potentiel SQL d'Oracle.
Pré-requis
Bonnes connaissances du
langage SQL.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
26 mai 2014, 15 sep. 2014
12 nov. 2014
Oracle SQL pour le décisionnel
OBJECTIFS
Un cours intensif pour acquérir toutes les compétences nécessaires à l'utilisation des fonctionnalités
décisionnelles du SQL d'Oracle.
1) Introduction
2) Groupements des données
3) Agrégation et analyse des données
1) Introduction
4) La clause MODEL
5) Mise à jour des données
6) Objets
- Informatique décisionnelle. Etat de la norme SQL. Norme SQL3 et décisionnel.
- Rappels des concepts liés à un Datawarehouse. Notions de CUBE. Concept OLAP. Analyse
multidimensionnelle.
- Modélisation en étoile et constellation. Notions de dimension. Notion de table de fait.
Etude de cas
Présentation : le modèle, les problématiques.
2) Groupements des données
- Fonctions horizontales. Fonctions verticales. Fonctions d'agrégat.
- Le groupe. Rappels : fonctionnement du GROUP BY, fonctionnement du HAVING.
- Fonctions GROUPING. Syntaxe. Exemples. Gestion des valeurs NULL.
- Le groupe à deux niveaux.
Travaux pratiques
Manipulation de la syntaxe et des fonctionnalités de groupements.
3) Agrégation et analyse des données
- Extensions ROLLUP et CUBE. Expression de GROUPING SET.
- Fonctions de groupes. Fonctions analytiques. La clause de partitionnement.
- La clause d'ordre. La clause de fenêtrage. Fonctions de classement.
- Ordonner les tris. Fonction de classement . Fonctions de fenêtres.
Travaux pratiques
Manipulation de la syntaxe et des fonctionnalités d'agrégation.
4) La clause MODEL
- La mise en oeuvre. La fonction CV.
- La fonction ITERATION_NUMBER. La fonction PRESENTNNV.
- La fonction PRESENTV. La fonction PREVIOUS.
Travaux pratiques
Manipulation de la syntaxe de la clause MODEL.
5) Mise à jour des données
- Insertion multitables. Insertion sans condition.
- INSERT_ALL, INSERT_FIRST. Mises à jour conditionnées.
Travaux pratiques
Alimentation du modèle en étoile.
6) Objets
- Les ETL (Extraction, Transformation, Chargement).
- Interrogation de tables externes. Vues du dictionnaire de données.
- Vues Matérialisées (VM). Intérêt. Syntaxe de création. Options.
- Vues Matérialisées et l'optimisation. Réécriture de requêtes. Dimensions et hiérarchies.
Travaux pratiques
Utilisation des tables externes pour le déplacement des données. Création des vues matérialisées pour
optimiser les requêtes.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 76 / 86

Stage pratique de 3 jour(s)
Réf : ORD
Participants
Concepteurs, développeurs
et toutes les personnes
impliquées dans des
développements utilisant la
base de données Oracle.
Pré-requis
Bonnes connaissances de
SQL.
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
3 fév. 2014, 3 mar. 2014
7 avr. 2014, 5 mai 2014
2 juin 2014, 28 juil. 2014
25 aoû. 2014, 15 sep. 2014
13 oct. 2014, 17 nov. 2014
8 déc. 2014
Aix
3 mar. 2014, 26 mai 2014
21 juil. 2014, 22 sep. 2014
1 déc. 2014
Bordeaux
12 mai 2014, 28 juil. 2014
15 sep. 2014, 12 nov. 2014
Bruxelles
12 mai 2014, 15 juil. 2014
1 sep. 2014, 24 nov. 2014
Geneve
12 mai 2014, 15 juil. 2014
1 sep. 2014, 24 nov. 2014
Lille
12 mai 2014, 28 juil. 2014
15 sep. 2014, 12 nov. 2014
Luxembourg
12 mai 2014, 15 juil. 2014
1 sep. 2014, 24 nov. 2014
Lyon
3 mar. 2014, 26 mai 2014
21 juil. 2014, 22 sep. 2014
1 déc. 2014
Nantes
17 fév. 2014, 19 mai 2014
15 juil. 2014, 1 sep. 2014
24 nov. 2014
Rennes
19 mai 2014, 15 juil. 2014
1 sep. 2014, 24 nov. 2014
Sophia-antipolis
3 mar. 2014, 26 mai 2014
21 juil. 2014, 22 sep. 2014
1 déc. 2014
Strasbourg
12 mai 2014, 28 juil. 2014
15 sep. 2014, 12 nov. 2014
Toulouse
12 mai 2014, 28 juil. 2014
15 sep. 2014, 12 nov. 2014
Développer en PL/SQL
OBJECTIFS
Le cours PL/SQL a comme objectif la maîtrise du langage PL/SQL et l'utilisation des traitements stockés et
des triggers dans les applications. Les concepts abordés sont systématiquement mis en pratique.
1) Introduction et rappels
2) Eléments du langage
3) Accès à la base
4) Traitements stockés
1) Introduction et rappels
- Traitement transactionnel dans Oracle.
- Objets et dictionnaire d'une base Oracle.
- SQL et PL/SQL. Vue globale de PL/SQL.
- Outils utilisés. Documentation Oracle.
2) Eléments du langage
5) Gestion des erreurs
6) Triggers
7) Compléments
- Environnements hôtes. Introduction syntaxique. Déclarations de variables et de constantes PL/SQL.
- Types de données et conversion. Fonctions prédéfinies.
- Instructions de contrôle : IF- ELSE, la boucle LOOP, la boucle FOR.
- Types composites : records, tables indexées.
- Types objets. Définition des sous-programmes.
- Paramétrage des sous-programmes.
Exercice
Déclaration de variables. Manipulation de la date. Attributs de typage. Utilisation des collections et de leurs
méthodes.
3) Accès à la base
- La base et notion de curseur.
- Accès via curseur implicite : update, delete, insert, select. Utiliser les clauses RETURNING et BULK
COLLECT.
- Collections et FORALL.
- Boucles FOR à curseur. Curseurs en mise à jour.
- Curseurs explicites. Variables curseur.
Exercice
Utilisation de curseur explicite et de BULK COLLECT.
4) Traitements stockés
- Gestion de sous-programmes stockés, de bibliothèques stockées et de paquetages.
- Gestion des traitements stockés : droits d'accès, vues du dictionnaire et dépendance.
- Utilisation des packages.
Exercice
Création de procédures, de fonctions stockées et de paquetages.
5) Gestion des erreurs
- Traitement d'une exception.
- Utilisation de RAISE_APPLICATION_ERROR.
- Déclenchement d'une exception via RAISE.
- Propagation et gestion transactionnelle.
Exercice
Utilisation de Raise et de RAISE_APPLICATION_ERROR.
6) Triggers
- Définition et types de triggers Evénement/Action. Triggers Ordre.
- Lignes (utilisation de : NEW et : OLD), E/C/A (Evénement/Condition/Action).
- " INSTEAD OF " sur les vues, sur événements système.
- Utilisation des transactions autonomes.
Exercice
Création de triggers ordre et triggers ligne.
7) Compléments
- SQL dynamique. Utilisation de dbms_application_info et de WRAP pour cacher le code source.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 77 / 86

Stage pratique de 3 jour(s)
Réf : DSP
Participants
Développeurs Oracle.
Pré-requis
Bonnes connaissances de la
programmation PL/SQL ou
connaissances équivalentes à
celles apportées par le stage "
Développer en PL/SQL " (réf.
ORD).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
10 fév. 2014, 26 mai 2014
29 sep. 2014, 12 nov. 2014
1 déc. 2014
Développer en PL/SQL, perfectionnement
OBJECTIFS
Ce stage vous apprendra à écrire des programmes PL/SQL et à tirer le meilleur parti des fonctions
avancées : packages, curseurs, méthodes d'interface avancées et ensembles. Il aborde le développement, le
code SQL dynamique et les notions conceptuelles nécessaires à un codage efficace.
1) Rappels sur le PL/SQL
2) Les ensembles
3) Les procédures et les fonctions stockées
4) Les performances et la mise en mémoire
cache
1) Rappels sur le PL/SQL
- Décrire les types de données prédéfinis.
- Créer des sous-types basés sur des types existants.
- Répertorier les règles de conception d'un curseur.
2) Les ensembles
5) Les packages
6) Les déclencheurs
7) Le SQL dynamique
- Présentation des ensembles.
- Tableaux associatifs et tables imbriquées.
- Programmes PL/SQL qui utilisent des ensembles.
- Le stockage des ensembles dans les tables.
- Les ordres SQL dans PL/SQL.
- L'utilisation de la clause RETURNING, BULK COLLECT.
Travaux pratiques
Utiliser les traitements de masse pour améliorer les performances.
3) Les procédures et les fonctions stockées
- Créer une conception modulaire.
- Créer, appeler et supprimer des procédures stockées.
- Implémenter les paramètres de procédure.
- Implémenter le hint de compilation NOCOPY.
- Créer, appeler et supprimer des fonctions stockées.
- Identifier les restrictions liées aux appels de fonctions.
Travaux pratiques
Visualiser les informations des procédures à l'aide des vues du dictionnaire de données et de SQL
Developer.
4) Les performances et la mise en mémoire cache
- Décrire la mise en mémoire en cache des résultats.
- Utiliser le cache des résultats d'interrogation SQL.
- Cache des résultats de fonction PL/SQL.
Travaux pratiques
Vérifier les principaux aspects du cache des résultats de fonction PL/SQL.
5) Les packages
- Identifier les composants d'un package.
- Utiliser le package STANDARD et les fonctions de package.
- Contrôler les effets de bord des sous-programmes PL/SQL.
Travaux pratiques
Créer la spécification et le corps d'un package. Afficher le code source PL/SQL à l'aide du dictionnaire de
données. Appeler des tables PL/SQL d'enregistrements dans des packages.
6) Les déclencheurs
- Comment implémenter les déclencheurs ?
- Présentation des déclencheurs combinés.
- Déclencheur combiné pour les tables et les vues.
- Créer des déclencheurs sur les instructions LDD.
Travaux pratiques
Créer des déclencheurs LMD, INSTEAD OF. Implémenter un déclencheur combiné pour résoudre l'erreur de
table en mutation.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 78 / 86

7) Le SQL dynamique
- Flux d'exécution du code SQL.
- Présentation du code SQL dynamique.
- Déclarer des variables de curseur.
Travaux pratiques
Exécuter dynamiquement un bloc PL/SQL.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 79 / 86

Stage pratique de 4 jour(s)
Réf : OPT
Participants
Ce cours s'adresse
aux développeurs et
administrateurs d'applications.
Pré-requis
Bonnes connaissances des
langages SQL et PL/SQL.
Prix 2014 : 2270€ HT
Eligible DIF
Dates des sessions
Paris
18 mar. 2014, 15 avr. 2014
20 mai 2014, 24 juin 2014
8 juil. 2014, 19 aoû. 2014
16 sep. 2014, 14 oct. 2014
18 nov. 2014, 15 déc. 2014
Aix
25 mar. 2014, 13 mai 2014
15 juil. 2014, 23 sep. 2014
25 nov. 2014
Bordeaux
4 mar. 2014, 10 juin 2014
9 sep. 2014, 4 nov. 2014
Bruxelles
4 mar. 2014, 10 juin 2014
23 sep. 2014, 18 nov. 2014
Geneve
4 mar. 2014, 10 juin 2014
23 sep. 2014, 18 nov. 2014
Lille
4 mar. 2014, 10 juin 2014
9 sep. 2014, 4 nov. 2014
Luxembourg
4 mar. 2014, 10 juin 2014
23 sep. 2014, 18 nov. 2014
Lyon
25 mar. 2014, 13 mai 2014
15 juil. 2014, 23 sep. 2014
25 nov. 2014
Nantes
1 avr. 2014, 3 juin 2014
9 sep. 2014, 4 nov. 2014
Rennes
1 avr. 2014, 3 juin 2014
9 sep. 2014, 4 nov. 2014
Sophia-antipolis
25 mar. 2014, 13 mai 2014
15 juil. 2014, 23 sep. 2014
25 nov. 2014
Strasbourg
4 mar. 2014, 10 juin 2014
9 sep. 2014, 4 nov. 2014
Toulouse
4 mar. 2014, 10 juin 2014
9 sep. 2014, 4 nov. 2014
Oracle, optimisation d'applications
OBJECTIFS
Grâce à ce cours pratique, vous serez en mesure de réduire d'une manière décisive les temps de réponse
de vos applications. Vous comprendrez le fonctionnement de l'optimiseur intégré et des outils d'analyse et de
gestion d'Oracle. Vous serez en mesure d'écrire des requêtes SQL performantes.
1) Introduction
2) Traitement des requêtes SQL
3) Diagnostic et mesure de performance
4) Optimisation du schéma relationnel
1) Introduction
- Démarche, étapes et acteurs de l'optimisation.
- Problèmes de performances.
- Particularités des types d'applications. Problématiques.
2) Traitement des requêtes SQL
5) L'optimiseur
6) Optimisation des requêtes
7) Exécution en parallèle des requêtes
- Mécanismes internes. Partage des curseurs. Variables de lien dans SQL*Plus et Enterprise Manager.
- Partage des curseurs. Fonctionnalité Adaptive Cursor Sharing. Cache de résultat.
Travaux pratiques
Utilisation des bind variables pour partager des curseurs.
3) Diagnostic et mesure de performance
- Outils d'optimisation. Traces de diagnostic. Services avec les applications client.
- Trace pour votre session. Fichiers de trace SQL. Les fichiers de trace SQL.
Travaux pratiques
Utilisation de Tkprof.
4) Optimisation du schéma relationnel
- Structures principales et chemins d'accès. Balayage complet de table.
- Accélérer les requêtes. Index B*Tree et Bitmap. Tables indexes. Indexes composites et indexes invisibles.
- Règles de gestion des index. Tables globales temporaires.
- Partitionnement des données. Vues matérialisées. Colonnes virtuelles.
Travaux pratiques
Optimisation de requêtes.
5) L'optimiseur
- Recherches de données. Optimisation statistique ou syntaxique. Statistiques destinées à l'optimiseur.
- Collecte dynamique des statistiques. Conversions de types de données. Evaluation des expressions.
- Opérateurs de comparaison. Sous-interrogations. Méthodes de jointure et d'accès aux données.
- Optimisation manuelle des requêtes par hints.
Travaux pratiques
Comparaison des optimiseurs statistique et syntaxique.
6) Optimisation des requêtes
- La conception et l'applicatif. Prédicats composés. Arborescences. Fonctions de groupes.
- Boucles inutiles. Vues et requêtes imbriquées. Updates synchronisés. Les tableaux dans PL/SQL.
- Curseurs implicites/explicites et la récupération des lignes par lot. FORALL.
Travaux pratiques
Optimisation de traitements batch.
7) Exécution en parallèle des requêtes
- Un serveur à plusieurs CPU. Requêtes en parallèle. Réglage automatique des instructions SQL.
- Réglage d'une application. Fonction de conseil STA. Statistiques obsolètes sur les objets.
- Profilage des instructions SQL. Flux de réglage d'un plan et création de profil SQL.
- Database Control et fonction de conseil STA. Recommandations d'implémentation.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 80 / 86

Stage pratique de 2 jour(s)
Réf : MYP
Participants
Pour toute personne désirant
se servir de SQL dans les
environnements MySQL ou
PostgreSQL.
Pré-requis
Aucune connaissance
particulière.
Prix 2014 : 1350€ HT
Eligible DIF
Dates des sessions
Paris
20 mar. 2014, 19 juin 2014
9 oct. 2014, 4 déc. 2014
Aix
20 mar. 2014, 27 mai 2014
2 oct. 2014, 18 déc. 2014
Bordeaux
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Bruxelles
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Geneve
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Lille
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Luxembourg
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Lyon
20 mar. 2014, 27 mai 2014
2 oct. 2014, 18 déc. 2014
Nantes
6 mar. 2014, 12 juin 2014
16 oct. 2014, 11 déc. 2014
Rennes
6 mar. 2014, 12 juin 2014
16 oct. 2014, 11 déc. 2014
Sophia-antipolis
20 mar. 2014, 27 mai 2014
2 oct. 2014, 18 déc. 2014
Strasbourg
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
Toulouse
3 avr. 2014, 26 juin 2014
16 oct. 2014, 18 déc. 2014
SQL pour MySQL et PostgreSQL
OBJECTIFS
Cette formation très pratique focalise sur les aspects essentiels du langage d'interrogation SQL, tant du point
de vue logique que syntaxique. Elle vous apportera également une méthode sûre pour écrire des requêtes,
simples et complexes, en environnement MySQL et PostgreSQL.
1) Introduction
2) Modèle relationnel
3) Les outils client
4) Les objets
Travaux pratiques
5) Requêtes simples
6) Tris et agrégats
7) Jointures
8) Requêtes complexes
L'apprentissage du SQL en environnement MySQL ou PostgreSQL, au choix du participant.
1) Introduction
- Serveur MySQL/PostgreSQL.
- Versions et évolution.
- Ressources et documentation.
2) Modèle relationnel
- Les principes du modèle relationnel.
- L'algèbre relationnelle : opérations relationnelles sur les ensembles de données.
- Introduction à SQL.
3) Les outils client
- L'outil client MySQL.
- Présentation de l'outil " PSQL " de PostgreSQL.
4) Les objets
- Types de données dans MySQL/PostgreSQL.
- Création de tables.
- Utilisation de colonnes auto-incrémentées.
- Utilisation des vues.
Travaux pratiques
Utilisation des outils " mysql " et " psql ", Création de tables et mise à jour de données. Utilisation des vues.
5) Requêtes simples
- L'interrogation (SELECT).
- La mise à jour.
- Opérateurs et critères.
- Les transactions.
Travaux pratiques
Ecriture de requêtes SQL simples.
6) Tris et agrégats
- Tri et doublons: Clause ORDER BY, clause LIMIT, clause OFFSET, suppression des doublons.
- Utilisation de NULL : Opérateur IS NULL.
- Utilisation des fonctions.
- Utilisation des agrégats.
Travaux pratiques
Manipulation des fonctions de tris et d'agrégats.
7) Jointures
- Produit cartésien.
- Jointure interne.
- Jointure externe.
8) Requêtes complexes
- Les requêtes imbriquées : Opérateur IN, opérateur EXISTS, requêtes imbriquées plus générales.
- Opérateurs ensemblistes (union, intersection, différence).
- Groupement de données (clause GROUP BY, HAVING).
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 81 / 86

Travaux pratiques
Ecriture de requêtes SQL simples. Utilisation de fonctions, utilisation d'agrégats, jointures et requêtes
imbriquées, utilisation de GROUP BY et HAVING.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 82 / 86

Stage pratique de 3 jour(s)
Réf : MSQ
Participants
Ce stage s'adresse à tous
les informaticiens ayant à
développer pour MySQL.
Pré-requis
Connaissances de base
d'un système d'exploitation
(Windows, Linux/Unix).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
17 fév. 2014, 17 mar. 2014
28 avr. 2014, 26 mai 2014
23 juin 2014, 28 juil. 2014
15 sep. 2014, 27 oct. 2014
24 nov. 2014, 15 déc. 2014
Aix
22 avr. 2014, 30 juin 2014
27 oct. 2014, 8 déc. 2014
Bordeaux
22 avr. 2014, 10 juin 2014
13 oct. 2014, 8 déc. 2014
Bruxelles
22 avr. 2014, 10 juin 2014
27 oct. 2014, 8 déc. 2014
Geneve
22 avr. 2014, 10 juin 2014
27 oct. 2014, 8 déc. 2014
Lille
22 avr. 2014, 10 juin 2014
13 oct. 2014, 8 déc. 2014
Luxembourg
22 avr. 2014, 10 juin 2014
27 oct. 2014, 8 déc. 2014
Lyon
22 avr. 2014, 30 juin 2014
27 oct. 2014, 8 déc. 2014
Nantes
24 mar. 2014, 16 juin 2014
6 oct. 2014, 1 déc. 2014
Rennes
24 mar. 2014, 16 juin 2014
6 oct. 2014, 1 déc. 2014
Sophia-antipolis
22 avr. 2014, 30 juin 2014
27 oct. 2014, 8 déc. 2014
Strasbourg
22 avr. 2014, 10 juin 2014
13 oct. 2014, 8 déc. 2014
Toulouse
22 avr. 2014, 10 juin 2014
13 oct. 2014, 8 déc. 2014
MySQL, prise en main
OBJECTIFS
Ce cours vous permettra d'acquérir toutes les compétences nécessaires à l'utilisation efficace et fiable de la
base de données MySQL : la pratique du langage SQL, les objets de la base de données... Ce stage propose
également une introduction à l'administration.
1) Introduction et prise en main
2) Modèle relationnel, conception et création
d'une base
3) Pratique du SQL avec MySQL
4) Tables transactionnelles InnoDB
Travaux pratiques
5) SQL procédural
6) Connexions, droits d'accès, sécurité
7) Introduction à l'administration
Tout au long du stage, de nombreux travaux pratiques permettent de valider les connaissances théoriques.
1) Introduction et prise en main
- Versions, panorama des fonctionnalités et des outils.
- Ressources et documentation.
- Procédure d'installation.
- Paramétrages de post-installation et premiers tests.
- L'outil client ligne de commandes mysql.
- L'outil graphique MySQL Query Browser.
2) Modèle relationnel, conception et création d'une base
- Eléments de conception d'un schéma de base de données.
- Contraintes d'intégrité.
- Types de données MySQL (numériques, chaînes, dates, types spécifiques...).
- Fonctions intégrées de MySQL.
- Types de tables (MyISAM, MEMORY, MERGE, InnoDB...).
- Création de bases et de tables.
- La base INFORMATION_SCHEMA.
- Jeux de caractères, internationalisation.
Travaux pratiques
Conception et création d'une base en tables MylSAM.
3) Pratique du SQL avec MySQL
- Sélections simples, comparaisons, tris.
- Sélections multitables, différents types de jointures.
- Requêtes imbriquées, préparées.
- Modifications et gestion des vues.
Travaux pratiques
Sélections simples. Sélections multiples, jointures internes et externes, requêtes imbriquées. Modifications et
suppressions de données.
4) Tables transactionnelles InnoDB
- Notion de transaction, niveaux d'isolation.
- Structure physique des tables.
- Programmation des transactions (START TRANSACTION, COMMIT, ROLLBACK).
Travaux pratiques
Mise en oeuvre de transactions.
5) SQL procédural
- Procédures stockées et fonctions.
- Définition des procédures. Déclencheurs (Triggers).
- Gestion des erreurs.
Travaux pratiques
Ecriture de procédures stockées. Récupération de résultats à l'aide de curseurs. Création et utilisation de
triggers.
6) Connexions, droits d'accès, sécurité
- Niveaux de privilèges et vérification des droits.
- Gestion des utilisateurs et de leurs privilèges.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 83 / 86

- Sécurisation des procédures stockées et des vues.
Travaux pratiques
Gestion des privilèges et des mots de passe.
7) Introduction à l'administration
- Exportation de données.
- Sauvegardes, la commande mysqldump.
- Survol de l'installation de MySQL.
Travaux pratiques
Exportation de données.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 84 / 86

Stage pratique de 3 jour(s)
Réf : POS
Participants
Développeurs, exploitants
et toute autre personne
désireux d'utiliser au mieux
PostgreSQL ou de migrer vers
PostgreSQL.
Pré-requis
Connaissances de base
d'un système d'exploitation
(Windows, Linux/Unix).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
24 fév. 2014, 31 mar. 2014
28 avr. 2014, 26 mai 2014
30 juin 2014, 8 sep. 2014
6 oct. 2014, 12 nov. 2014
8 déc. 2014
Aix
28 avr. 2014, 10 juin 2014
13 oct. 2014, 15 déc. 2014
Bordeaux
19 mai 2014, 15 juil. 2014
29 sep. 2014, 24 nov. 2014
Bruxelles
19 mai 2014, 29 sep. 2014
24 nov. 2014
Geneve
19 mai 2014, 29 sep. 2014
24 nov. 2014
Lille
19 mai 2014, 15 juil. 2014
29 sep. 2014, 24 nov. 2014
Luxembourg
19 mai 2014, 29 sep. 2014
24 nov. 2014
Lyon
28 avr. 2014, 10 juin 2014
13 oct. 2014, 15 déc. 2014
Nantes
24 fév. 2014, 28 avr. 2014
23 juin 2014, 29 sep. 2014
24 nov. 2014
Rennes
24 fév. 2014, 28 avr. 2014
23 juin 2014, 29 sep. 2014
24 nov. 2014
Sophia-antipolis
28 avr. 2014, 10 juin 2014
13 oct. 2014, 15 déc. 2014
Strasbourg
19 mai 2014, 15 juil. 2014
29 sep. 2014, 24 nov. 2014
Toulouse
19 mai 2014, 15 juil. 2014
29 sep. 2014, 24 nov. 2014
PostgreSQL, prise en main
OBJECTIFS
Le SGBD PostgreSQL dispose de la majorité des fonctionnalités que l'on peut trouver dans des produits
commerciaux comme Oracle ou DB2. Cette formation vous apprendra à l'utiliser de manière efficace,
notamment à créer et à exploiter une base de données, ou encore à programmer avec le langage PL/pgSQL.
1) Introduction
2) SQL avec PostgreSQL
3) Le langage PL/pgSQL
4) Maintenance des données
1) Introduction
- Présentation de PostgreSQL, versions.
- Le modèle relationnel, le schéma.
- Tables, contraintes. Interfaces utilisateurs.
2) SQL avec PostgreSQL
5) Gestion des utilisateurs et des groupes
6) Configuration de PostgreSQL
7) Compléments
- La norme SQL. Positionnement de PostgreSQL. Mise en place du schéma d'une base.
- Type de données PostgreSQL. Tables. Séquences. Vues. Contraintes d'intégrité sur les tables.
- Ajout, modification et suppression des données.
- Interrogation du schéma d'une base. Sélection, restriction, tri, jointure.
- Extractions complexes. Utilisation d'opérateurs. Spécificités SQL de PostgreSQL.
- Fonctionnalités avancées PostgreSQL. Transactions. Vues. Tableaux. Héritage de tables.
Travaux pratiques
Création d'un schéma. Script SQL DDL. Création de vues. Scénarios de transactions.
3) Le langage PL/pgSQL
- Les instructions, types du langage. Blocs de code.
- Structures de contrôle. Erreurs et des exceptions.
- Les curseurs. Déclaration, déplacement et fermeture.
- Les procédures et les fonctions.
- Ajout de sous-programmes à une base de données.
- Les déclencheurs, triggers. Structure.
Travaux pratiques
Fonctions stockées.
4) Maintenance des données
- Importation/exportation de données.
- Avec COPY TO et COPY FROM. Avec Psql.
- Sauvegarde et restauration des données.
- Outils pg_dump. Optimisation de requêtes.
- Les INDEX. L'optimiseur. EXPLAIN et VACUUM.
Travaux pratiques
Importation/exportation de données. Création d'index et analyse de plan d'exécution de requêtes.
5) Gestion des utilisateurs et des groupes
- Création. Authentification.
- Octroi de privilèges.
Travaux pratiques
Création d'utilisateurs, allocation de droits. Tests d'authentification.
6) Configuration de PostgreSQL
- Installation et démarrage d'une base.
- Le Postmaster. Le fichier Postgresql.conf.
- Tables système.
Travaux pratiques
Installation d'une base et configuration.
7) Compléments
- Les interfaces de programmation.
- Connexion de PostgreSQL avec PHP, JDBC, ODBC.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 85 / 86

Stage pratique de 3 jour(s)
Réf : RIB
Participants
Ce stage s'adresse à tous les
informaticiens ayant à utiliser
MariaDB.
Pré-requis
Connaissances de base
d'un système d'exploitation
(Windows/Linux).
Prix 2014 : 1750€ HT
Eligible DIF
Dates des sessions
Paris
24 mar. 2014, 2 juin 2014
15 sep. 2014, 12 nov. 2014
MariaDB, prise en main
OBJECTIFS
Un cours intensif qui vous permettra d'acquérir toutes les compétences nécessaires à l'utilisation efficace et
fiable de la base de données Maria DB : la pratique du langage SQL, les objets de la base de données, la
sécurité... Ce stage propose également une introduction à l'administration.
1) Présentation du serveur de données MariaDB
2) Le langage SQL
3) Requêtes avancées
1) Présentation du serveur de données MariaDB
4) Optimisation des requêtes
5) Introduction à la programmation
- Le serveur MariaDB, historique, les versions et les autres projets issus de MySQL.
- Les bases de données sous MariaDB (création, suppression, options).
- Les outils MariaDB.
- Les tables (type, contraintes, indexes, colonnes virtuelles, contraintes, etc.).
- Introduction au moteur de stockage MariaDB (MyISAM/Aria,XtraDB/InnoDB, etc.).
Travaux pratiques
Création de bases de données, création de différents types de tables, modifications.
2) Le langage SQL
- Le modèle relationnel.
- Intégrité référentielle (show, information_schema, performance_schema).
- Le langage LMD : SELECT, GROUP BY, HAVING, ORDER BY, LIMIT, UNION...
- Fonctions et expressions SQL (CASE, IF, LIKE, fonctions numériques, fonctions sur les dates, gestion des
valeurs NULL).
- Introduction aux transactions (norme ACID et MariaDB).
Travaux pratiques
Implémentation d'un modèle de données, analyse des contraintes et réalisation de requêtes
3) Requêtes avancées
- Requêtes multitables (INNER, JOIN, CROSS JOIN, LEFT/RIGHT OUTER JOIN).
- Les sous-requêtes (scalaires, listes, tables dérivées)
- Les transactions (fonctionnement, cohérence des données).
- Niveaux d'isolation (READ COMMITED, REPEATABLE READ, READ UNCOMMITED, SERIALIZABLE).
- Verrouillage des tables (type de verrous, visualisation, les verrous mortels).
- Comparaison jointures/sous-requêtes : les avancées de MariaDB.
Travaux pratiques
Réalisation des requêtes avec jointures, de sous-requêtes, requêtes préparées, transactions et analyses des
verrouillages des tables.
4) Optimisation des requêtes
- Plan d'exécution (EXPLAIN, SHOW EXPLAIN, STATISTIQUES).
- Exécution de requêtes et cache de requêtes.
- Indexation et bonnes pratiques.
- Sécurisation des procédures stockées et des vues.
Travaux pratiques
Analyse des plans d'exécution, indexation des requêtes.
5) Introduction à la programmation
- Les procédures stockées et les fonctions.
- Les curseurs.
- La gestion des erreurs.
- Les triggers : type, utilité.
ORSYS, La Grande Arche, Paroi Nord, 92044 Paris La Défense cedex. Tél : +33 (0)1 49 07 73 73. Fax : +33(0)1 49 07 73 78 page 86 / 86