Cette publication ne fait pas partie de la bibliothèque YouScribe
Elle est disponible uniquement à l'achat (la librairie de YouScribe)
Achetez pour : 19,90 € Lire un extrait

Lecture en ligne + Téléchargement

Format(s) : PDF

sans DRM

Entity Framework : le point de vue du DBA

De
301 pages
Ce livre est le fruit des constats de Dominique en entreprise :
- Les développeurs ont des outils de plus en plus puissants à leur disposition
- Mais ils s’éloignent de plus en plus des modèles physiques
- Beaucoup pensent que les ‘machines arriveront toujours à suivre’
- Il faut donc faire sentir à chacun ce qui se passe et quelles sont les implications de leurs stratégies de développement pour arriver à des systèmes d’information vraiment opérationnels !
- Tout ceci fait que des logiciels ‘morts-nés’ arrivent sur le marché : ces logiciels supportent tellement peu la charge que leur durée de vie est très brève … dans certains cas n’atteint pas le stade de la mise en production !
Afin de sensibiliser les développeurs à la problématique de gestion du volume depuis Entity Framework, les thèmes suivants sont abordés :
1) Utilisation d’une base existante dans le modèle
2) Evolutions de la base et impacts sur le modèle
3) Requêtes d’extraction de type Linq to entities
4) Pratique du SQL au sein du framework
5) Utiliser les méthodes
6) Mettre à jour les données singleton, avec des héritages, mise à jour de masse
7) Gérer les transactions et le verrouillage
8) Utiliser les procédures stockées, les fonctions et les vues
9) Créer une base en dérivant un modèle
10) Mettre en œuvre les services WCF et les POCO
Voir plus Voir moins



SQL Server
2008 R2 -
2012
Entity framework : le point de
vue du DBA
Dominique Verrière
Dialogue Formation Informatique
SQL Server 2008 R2 -2012
Edition du 30 juin 2013
Sommaire
Table des matières
I : Introduction et vue d’ensemble ................................................................................ 14
L’utilité du mapping relationnel-objet ............ 15
Tout part de la base ?..................................................................... 18
Génération initiale du modèle EF partir de la base de données ...................................... 19
Notre modèle Entity généré ....................................................................................................................... 23
Accès aux propriétés du modèle................. 23
Accès aux propriétés des entités : .............................................................................................................. 24
Accès aux propriétés des colonnes ............. 24
Accès aux propriétés des associations ........ 25
Altérations ultérieures du schéma.................................................................................................................. 25
Altération de table existante ...................... 28
Ajout de table avec relations 29
Suppression de table .................................................................................................................................. 29
Lien vers les exemples et les solutions :.......... 32
Pratique 1 ...................................................................................................................................................... 32
Le sujet à traiter ......... 32
Les solutions .............................................................................................................................................. 33
II : Requêtes de type Linq to entities ............. 34
Introduction : ................. 35
Requête sur une simple table avec critères .................................................................................................... 37
Passage de paramètre de type Date : ......... 38
Critère de type partie de date : .................................................................................................................. 38
Critère de type booléen ............................. 41
Recherche approchée équivalent de like .................................................................................................... 41
Recherche de valeurs NULL ........................................................ 42
Critères dans une liste (in, not in) ............................................................................... 44
Tris des résultats ............................................................................ 47
Extraire des sous-ensembles du résultat : ...................................................................... 48
Utilisation de la méthode Take ................... 48
Utilisation de la méthode Skip .................................................................................................................... 48
Combinaison de Skip et Take ...................... 49
Types anonymes ............................................................................................................................................ 49

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 5 Sommaire

Projection sur des colonnes d’une table ..................................................................................................... 50
Agrégations.................................................................................................................................................... 51
Comptage des élements d’un ensemble ..... 51
Comptage des valeurs distinctes ................ 52
Utilisation de groupements ........................................................................................................................ 52
Utilisation d’agrégats multiples .................. 54
Tris des résultats du groupement ............................................................................................................... 55
Filtrage sur agrégations .............................................................................................................................. 55
Jointures ........................................................ 58
Jointure à l’ancienne .................................. 58
Jointure par inner join ................................................................................................ 58
Jointure multi-tables .. 59
Jointure de tables non connectées ............................................................................................................. 59
Jointure sur clés composites....................... 60
Jointure groupée ........................................ 62
Jointure externe gauche ............................................................................................. 63
Produit cartésien ........................................... 64
Navigation dans les entités de référence ........................................................................ 65
Remontée vers une entité de référence ......... 66
Descente vers les entités référençantes ......................................... 67
Chargement différé automatique ................................................................................... 69
Chargement différé manuel ........................................................... 70
Chargement initial par include ....................... 71
Conclusion : ............................................................................................................................................... 73
Pratique 2 : .................... 74
Le sujet à traiter ......... 74
Les solutions .............................................................................................................................................. 75
III : Utiliser Entity SQL et T-SQL...................... 79
Introduction ................................................................................................................................................... 80
Entity SQL = Transact SQL ? ............................ 80
Production d’entités entières ......................... 81
Extraction d’une entité complète ............................................................................................................... 81
Sélection de données d’une entité ............. 82

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 6 Sommaire
Utiliser une date en critère de sélection ..................................................................................................... 82
Utilisation de paramètres ........................................................... 83
Projection .................................................................................................................. 83
Mises à jour au moyen de SQL natif ............................................... 85
Insert de masse en mise à jour directe ....................................................................... 85
Utilisation de paramètres ........................................................................................... 86
Update de masse ....... 86
Delete de masse ......................................................................................................................................... 88
Nouveautés du framework Entity 5.0 ............. 89
Disparition de CreateQuery ........................................................................................................................ 89
Disparition de ExecuteStoreCommand ....................................................................................................... 89
Pratique 3 ...................................................... 91
Le sujet à traiter ......... 91
Les solutions .............................................................................................................................................. 92
IV : Linq par les méthodes ............................. 93
Introduction ................................................................................................................................................... 94
Requête d’extraction des donnés d’une entité ........................... 94
Extraction de ligne sur valeur de clé primaire ............................................................................................. 95
Recherche de contenu par Any................................................... 96
Projection .................................................................................................................. 97
Projection avec calculs et alias ................... 98
Trier les données ........................................................................................................................................ 99
SelectMany : extraire des entités associées .............................. 100
Extraire des parties de résultats avec Skip et Take .................................................................................... 101
Boucler dans les résultats avec SkipWhile et TakeWhile ........... 102
Grouper et obtenir des agrégats .................................................. 104
Syntaxe de la méthode GroupBy: ............................................................................. 104
ère1 requête d’aggrégation........................ 104
ème2 requête d’agrégation ................................................................................................ 105
Généralisation à n agrégats ...................... 106
Appliquer des restrictions de groupe : ...................................................................................................... 107
Distinct .................................................... 108
Union ....................................................................................................................... 111
Intersect .................. 112

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 7 Sommaire

Except ...................................................................................................................................................... 113
SelectValue .............. 114
Combinaison de requêtes......................... 115
Jointure.................................................................................................................................................... 116
Combinaisons de méthodes ......................... 118
Tri descendant en combinaison de FirstOrDefault .................... 118
Conclusion ................................................................................................................................................... 122
Pratique 4 .................... 123
Le sujet à traiter ....................................................................................................................................... 123
Les solutions ............ 124
V Modifier les données................................................................ 129
Mettre à jour les données ............................................................ 130
Mise à jour singleton sur une seule colonne ............................. 130
Mise à jour singleton sur n colonnes ........................................................................................................ 131
Que se passe-t-il sur des types de données plus complexes ? ... 131
Mise à jour ensembliste ........................................................................................................................... 133
Utiliser Entity SQL pour les mises à jour de masse .................... 134
Conclusion sur les update......................... 136
Insertions de nouvelles entités ..................................................................................................................... 136
Insertion d’entité sans colonne identity ................................... 137
Utilisation des identity lors des insertions ................................................................ 137
Insertion de plusieurs objets possédant des liens ..................... 141
Insertions de données avec héritage ........................................................................................................ 143
Suppressions ................................................ 146
Suppression d’une entité isolée................................................................................................ 146
Suppression d’entités liées sans cascade .. 147
Suppression d’entités liées avec cascade .................................................................................................. 150
Suppression d’objets avec héritage .......... 151
Conclusion sur les delete .......................................................................................................................... 152
Gestion des transactions .............................. 153
Utilisation des transactions implicites ...................................................................................................... 153
Utilisation d’une transaction explicite ...... 154
Incidence des transactions sur le verrouillage .......................................................................................... 157

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 8 Sommaire
Utiliser les niveaux d’isolation .................................................................................................................. 158
Gestion de la concurrence............................ 162
Gestion de concurrence par défaut .......................................................................................................... 163
Gestion de concurrence optimiste : .......... 164
Capturer les erreurs ..................................... 171
Erreur sur valeurs non null ....................................................................................... 171
Erreur sur clause CHECK ........................................................... 172
Erreur de violation de clé primaire ........................................................................................................... 174
Erreur de violation de clé étangère .......... 174
Erreur de doublons sur index unique ........ 175
Erreur de lock time out ............................................................................................................................ 176
Erreur de deadlock ................................... 177
Erreur due à la concurrence optimiste...................................................................... 177
Collection d’erreurs .................................. 178
Nouveautés du framework 5.0 ..................................................................................... 180
Disparition de la méthode ExecuteStoreCommand................... 180
Disparition de certains constructeurs des entités ..................... 180
Disparition de la méthode AddObject....................................................................................................... 180
Disparition de la méthode DeleteObject ... 180
Conclusion ............................................................................................................................................... 181
Pratique 5 .................... 182
Le sujet à traiter ....................................................................................................................................... 182
Les solutions ............ 183
VI Procédures stockées et fonctions ........................................................................... 186
Introduction ................................................. 187
Utiliser des vues ........................................... 187
Filtrage sur les vues .................................................................................................. 190
Un cas pratique : des vues avec le framework 5.0 .................................................... 191
Utiliser des procédures stockées .................................................................................. 194
Procédures stockées de type traitement batch ......................... 195
Procédure avec paramètres en output ..................................................................................................... 197
Procédure retournant un resultset ........... 198
Capture d’erreurs dans les procédures ..... 200
Apport du framework 5 pour l’utilisation des procédures ......................................................................... 202

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 9 Sommaire

Fonctions de type table ............................................................................................................................ 208
Les apports du framework 5 : ................... 213
Pratique 6 .................................................................................................................................................... 215
Le sujet à traiter ....... 215
Les solutions : .......................................................................................................................................... 216
VII Modèle first, base ensuite...................... 220
Introduction ................................................................................................................................................. 221
Ajout de notre première entité ................ 222
Révision des types de données ................. 225
Ajout d’association de plusieurs à plusieurs ............................................................................................. 227
Utilisation de l’héritage ............................................................ 231
Le modèle complet de notre gestion des courses ..................................................................................... 235
Le DDL généré de notre gestion des courses ............................ 236
Conclusion : ............................................................................................................................................. 239
Pratique 7 .................... 240
Le sujet à traiter ....... 240
Les solutions ............................................................................................................................................ 241
VIII Mise en pratique ................................... 246
Introduction ................................................................................................................. 247
Utilisation de WCF ....................................... 248
Extraire une entité autonome par le service WCF ..................... 253
Extraire un type composite par le service WCF ......................................................................................... 257
Mettre à jour les entités ........................................................... 259
Les apports des classes POCO ...................... 262
Création d’une nouvelle solution .............................................................................................................. 262
Premiers test de notre service WCF .......... 269
Mise à jour de propriétés d’entités........... 271
Mise à jour de type avec héritage ............................................................................................................. 273
Lecture de grappes d’objets ..................... 274
Mise à jour de données connexes singleton ............................................................................................. 276
Lecture d’ensemble d’objets connexes ..................................... 276
Mise à jour multiple d’éléments d’une collection ..................................................................................... 278
Développement d’un client ASP.Net ............................................ 280

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 10 Sommaire
Lecture depuis le service http ................................................................................................................... 281
Mise à jour depuis le service http ............. 283
Suppression de plusieurs occurrences associées....................... 284
Conclusion ............................................................................................................................................... 285
Pratique 8 .................... 287
Le sujet à traiter ....................................................................................................................................... 287
Les solutions ............ 288
Contacter l’auteur : ...... 300
Présentation de cet ouvrage ........................................................................................................................ 301




SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 11 Méthodes Linq to entities
{ var Resultats = bdd.Personne.SelectValue<Int32>("it.IdPersonne");
; foreach (Int32 iIdPersonne in Resultats)
{ Ligne = String.Format("Idpersonne {0} ",iIdPersonne.ToString());
lbResultats.Items.Add(Ligne); }
}

Nous allons récupèrer un tableau d’entiers qui correspond aux clés primaires demandées .


Combinaison de requêtes
Une fois ces principes acquis, on pourra combiner des requêtes avec stockage ou non des résultats
intermédiaires.
Par exemple je veux récupérer les deux personnes qui sont à la fois présentes et parties :
erEn considérant que je suis capable dans un 1 temps de récupèrer leurs clés primaires, je vais pouvoir
utiliser ces clés avec un contains :
lbResultats.Items.Add("Combinaison"); using (BaseDemoEntity bdd = new BaseDemoEntity())
{ var ClesPrimaires = bdd.PersonnePartie
.SelectValue<Int32>("it.IdPersonne"); var Resultats = bdd.Personne
.Where(t1 => ClesPrimaires .Contains(t1.IdPersonne));

foreach (Personne p in Resultats) {
Ligne = String.Format("Idpersonne {0} | Nom {1} | Prenom {2} ", p.IdPersonne.ToString(), p.Nom, p.Prenom);
lbResultats.Items.Add(Ligne); }
}



SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 115 Méthodes Linq to entities
Effectivement, nous retrouvons bien nos deux personnes parties .
Et là, je dois avouer que je suis sidéré par le SQL généré !

Le framework a reconstitué en une seule requête les deux morceaux de ma requête !
Champions les développeurs !
Jointure
Ainsi qu’avec Linq To Entities il est possible de créer des jointures, mais attention la syntaxe est un peu
particulière :

IQueryable<TResult> Join (
TableExterne<TOuter> outer,
CleExterne,
CleInterne,
Résultat
)



Je vais, par exemple, répondre à la question précédente (Noms des personnes qui sont aussi dans la
table PersonnePartie) mais cette fois avec une jointure :
lbResultats.Items.Add("Jointure"); using (BaseDemoEntity bdd = new BaseDemoEntity())
{ var Resultats = bdd.Personne
.Join(bdd.PersonnePartie, t1 => t1.IdPersonne,
t2 => t2.IdPersonne, (t1, t2) => new { Personne = t1, PersonnePartie
= t2 })
.Select(t1 => t1.Personne);

foreach (Personne p in Resultats) {
Ligne = String.Format("Idpersonne {0} | Nom {1} | Prenom {2} ",

SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 116 Méthodes Linq to entities
p.IdPersonne.ToString(), p.Nom, p.Prenom); lbResultats.Items.Add(Ligne);
} }
}

Détaillons tout cela :
 J’applique la jointure à la table Personne
 Je la joins à PersonnePartie
ère
 La clé de la 1 table est IdPersonne
ème Celle de la 2 est IdPersonne
 Les deux tables sont mises dans le résultat
 Une projection est faite sur toutes les colonnes
Voici le résultat de cette jointure :

Et le SQL généré :

On note que le framework a exclu toutes les données de la table PersonnePartie car elles ne sont pas
utilisées…
Mais j’aurai pu simplifier l’écriture dès le départ ainsi :
var Resultats = bdd.Personne.Join(bdd.PersonnePartie,
t1 => t1.IdPersonne,
t2 => t2.IdPersonne,
(t1, t2) => new { Personne = t1 })
.Select(t1 => t1.Personne);



SQL Server 2008R2-2012 : Entity framework, le point de vue du DBA par Dominique Verrière 117 Au sujet de cet ouvrage
Présentation de cet ouvrage



Dominique Verrière est un consultant spécialisé sur les technologies SQL Server depuis la version SQL Server
2000.

Il intervient dans les entreprises pour des missions d'audit, de suivi de performances, d'administration de
bases de données.
Les bases de données dont il s'occupe peuvent contenir plusieurs milliards de lignes et atteindre des Téra
octets; son expérience du terrain est donc significative.
Par ailleurs formateur sur ces domaines depuis un grand nombre d'années, son expérience de la pédagogie
vous permettra d'aborder facilement les sujets les plus complexes.

Ce livre est le fruit des constats de Dominique en entreprise :
 Les développeurs ont des outils de plus en plus puissants à leur disposition
 Mais ils s’éloignent de plus en plus des modèles physiques
 Beaucoup pensent que les ‘machines arriveront toujours à suivre’
 Il faut donc faire sentir à chacun ce qui se passe et quelles sont les implications de leurs stratégies de
développement pour arriver à des systèmes d’information vraiment opérationnels !
 Tout ceci fait que des logiciesl ‘morts-nés’ arrivent sur le marché : ces logiciels supportent tellement
peu la charge que leur durée de vie est très brève … dans certains cas n’atteint pas le stade de la
mise en production !
Afin de sensibiliser les développeurs à la problématique de gestion du volume depuis Entity Framework, les
thèmes suivants sont abordés :
 Utilisation d’une base existante dans le modèle
 Evolutions de la base et impacts sur le modèle
 Requêtes d’extraction de type Linq to entities
 Pratique du SQL au sein du framework
 Utiliser les méthodes
 Mettre à jour les données singleton, avec des héritages, mise à jour de masse
 Gérer les transactions et le verrouillage
 Utiliser les procédures stockées, les fonctions et les vues
 Créer une base en dérivant un modèle
 Mettre en œuvre les services WCF et les POCO

De nombreux exemples pratiques (avec les scripts et les projets solutions) sont fournis.


Edition du 30 juin 2013.

SQL Server 2008R2-2012 : Entity Framework le point de vue du DBA par Dominique Verrière

Un pour Un
Permettre à tous d'accéder à la lecture
Pour chaque accès à la bibliothèque, YouScribe donne un accès à une personne dans le besoin