Les articles des consultants de MCNEXT
Avec le déploiement de Windows Phone 7.5 (Mango), une nouvelle fonctionnalité très attendue est venue enrichir l’environnement de développement sur Windows Phone 7 : la base de données locale.
Depuis son lancement, de nombreux développeurs se sont heurtés à des problèmes de performance en utilisant cette version de SQL Compact Edition spécialement dédiée à Windows Phone.
Cet article vise à rassembler et à organiser un certain nombre d’astuces et de bonnes pratiques glanées sur internet dans le but de tirer le meilleur de cette base en terme de performance.
Initialement disponible et éprouvé sur Windows mobile 6.5 , SQL CE Mobile brillait par son absence sur Windows Phone 7.
Plusieurs raisons pouvaient expliquer une telle situation :
Quelles qu’en soient les raisons, le besoin s’est rapidement fait sentir pour le développement d’applications en tout genre et la communauté de développeurs Windows Phone s’est rapidement mobilisée pour proposer des solutions.
En voici une liste non exhaustives :
WinPhone7Db, Perst, SQLite for Windows Phone, siaqodb, Ninja Database, Rapid Repository et le plus célèbre Sterling.
La mise à disposition de SQL CE for Windows Phone a sonné le glas de bon nombre de ces projets. En effet, l’intérêt de solutions managées semblent limité face à ce port natif de SQL CE 3.5 spécialement conçu pour Windows Phone et officiel qui plus est.
Pour autant et à l’image de Sterling, les développements et la popularisation de certains projets se sont poursuivis car ils se sont démarqués pour des usages bien particuliers.
Sterling avec son orientation NoSQL et le soin tout particulier apporté à l’optimisation des opérations de sérialisation / désérialisation se distingue par exemple par sa simplicité d’utilisation et ses performances en lecture.
Néanmoins sur Windows Phone 7 et parmi les solutions existantes, SQL CE de par son implémentation native parait être le choix le plus adapté lorsqu’il s’agit de travailler sur de grande quantité de données à la fois en lecture et en écriture.
Pour une comparaison entre SQL CE for Windows Phone et Sterling, rendez vous à cette adresse.
L’une des première surprise rencontrée lors de l’utilisation de SQL CE for Windows Phone est que l’exécution directe de Transact-SQL n’est pas supporté.
Le recours à LINQ to SQL sur Windows Phone est donc obligatoire pour communiquer avec sa base de données locale relationnelle. Ce dernier a la responsabilité de traduire les requêtes de LINQ vers Transact-SQL et de matérialiser les résultats retournés par la base.
Pour éviter l’effet boîte noire, il est possible de logger les requêtes générées par LINQ to SQL et soumises à la base.
Pour ce faire, tout se joue au niveau de l’objet DataContext qui comporte une propriété Log. Si cette dernière est affectée à un StreamWriter, toute l’activité du DataContext concerné sera loggée par son intermédiaire.
using (var context = new MyDataContext(MyDataContext.DBConnectionString))
using (context.Log = new StreamWriter(IsolatedStorageFile.GetUserStoreForApplication().CreateFile("logs.txt")))
{
// Ecrivez ici les insert, update, delete dont vous avez besoin...
context.SubmitChanges();
}
Il ne vous reste plus qu’à récupérer le fichier de log de votre émulateur ou téléphone vers votre PC à l’aide d’outils de développement spécifiques tels que IsoStorageSpy ou encore Windows Phone Power Tools.
SQL CE for Windows Phone supporte le chiffrement des données contenues, il vous suffit d’ajouter le paramètre Password dans votre connection string. Mais n’oubliez pas que cette sécurité a un prix en terme de performance : des opérations supplémentaires de chiffrement et déchiffrement viendront respectivement s’ajouter à chaque opération d’écriture et de lecture en base.
Ce n’est certainement ni la première, ni la dernière fois que vous le lisez : Il est important de ne pas bloquer votre thread UI avec des traitements lourds.
Ceci a pour conséquence de bloquer l’affichage de votre application, comportement qui mène à de nombreux points négatifs :
De plus pour les traitements massifs sur la base, il semblerait que l’utilisation d’un thread en arrière plan accélère assez significativement les choses, voir ce lien.
Dans certains cas, il est plus rentable de stocker un bloc entier de données sérialisées (en XML ou binaire) directement en base sous la forme d’un blob dans une colonne de type text, varbinary, binary par exemple.
Cela permet de limiter autant le nombre de requêtes et d’allers et retours avec le base que la complexité et la quantité de données à requêter sont grandes.
Un index est automatiquement crée pour chaque colonne de la base définie en tant que clé primaire. Mais vous pouvez également créer vos propres index sur les propriétés souvent utilisées dans vos requêtes LINQ, y compris celles utilisées pour trier les résultats des requêtes.
[Index(Column=”OrderID ASC, Quantity DESC”)]
Lors de chaque exécution de requêtes LINQ, LINQ to SQL traduit l’arbre d’expression défini vers le code Transact-SQL correspondant. Ce mode de fonctionnement s’avère peu optimal pour les requêtes LINQ qui sont exécutées de nombreuses fois au cours de la durée de vie de l’application.
Pour éviter que cette opération de traduction ne soit exécutée encore et encore, il est possible de compiler votre requête LINQ à l’aide de CompiledQuery.Compile.
Cette méthode produit une requête Transact-SQL paramétrée qu’il vous sera possible de réutiliser avec des paramètres d’entrés différents par l’intermédiaire de la Func retournée.
Cela peut sembler étrange, mais lorsque l’on travaille avec de grandes volumétries, récupérer les données dont vous avez besoin avec des requêtes très simples puis effectuer les jointures par ses propres moyens se révèle bien souvent plus efficace que de laisser faire SQL CE. A condition bien sûr, que la quantité de données ne soit pas excessive! (quota de 90 mo par application sur Windows Phone 7)
Le post suivant y fait d’ailleurs référence dans sa conclusion.
Avant d’effectuer des updates ou des deletes, LINQ to SQL doit s’assurer qu’il n’y pas de conflits dus à des accès concurrentiels.
Afin de vérifier que les entités reflètent bien les valeurs présentes en base en moment du SubmitChanges, ces opérations sont effectuées avec une clause where supplémentaire qui vérifie les valeurs de chacune des colonnes. Cette dernière alourdit donc autant les requêtes que la table concernée contient de colonnes.
Pour éviter ces traitements supplémentaires, il est possible de définir une colonne de type RowVersion.
[Column(IsVersion=true)] private Binary _version;
Lorsqu’elle est présente, LINQ to SQL se base uniquement sur la valeur contenue dans ce champ pour déterminer si une entrée a changé ou non et la clause where supplémentaire, devenue inutile, disparaît.
Pour optimiser un scénario dans lequel une grande quantité de données doit être insérée en base vous pouvez utiliser le paramètre "Max Buffer Size". Par défaut, sa valeur est de 384 ko et 5120 ko au maximum. Ce paramètre indique à la base la plus grande quantité de données qu’elle peut stocker en mémoire avant de l’écrire sur le disque, 1024 KB semble être un bon compromis. Attention toutefois à ce pas trop l’augmenter, au delà d’une certaine valeur, cela n’aura plus d’impacts positifs mais négatifs! Pour plus d’informations voir cet article.
La présence de la colonne RowVersion fait gagner du temps sur les opérations d’updates et de deletes. A l’inverse, dans le cas d’un insert, RowVersion constitue une donnée de plus à insérer en base et à générer par LINQ to SQL. Si vous souhaitez privilégier les inserts sur les updates/deletes et les accélérer sensiblement, supprimez cette colonne. A noter que cette optimisation ne concerne à nouveau que les cas d’insertions massifs de données. Pour plus d’informations voir ce post traduit.
Privilégiez l’utilisation de InsertAllOnSubmit à InsertOnSubmit pour de nombreux inserts consécutifs
Enfin, si vous cherchez à injecter rapidement une grande quantité de données dans votre base, sachez qu’il existe un portage de SqlBulkCopy pour Windows Phone 7.5, vous le trouverez à cette adresse.
Par défaut, vos instances de DataContext sont configurées de manière à ce qu’une copie de toutes les entités issues de la base soit effectuée et conservée. Ces copies originales sont utilisées par la suite lors de l’appel à la méthode SubmitChanges pour déterminer ce qui a changé et générer les requêtes Transact-SQL adéquates (insert, update, delete etc…).
Ce mécanisme peut être désactivé pour les scénarios dans lesquels les données sont consultables et non modifiables et ainsi économiser la mémoire utilisée par ces copies. Pour ce faire, assignez false à la propriété ObjectTrackingEnabled de votre DataContext courant.
L’interface INotifyPropertyChanging permet de modifier quelque peu la manière dont LINQ to SQL assure le suivi des modifications afin de réduire l’empreinte mémoire de votre application.
Sans implémentation de cette interface sur vos objet POCOs liés à LINQ to SQL, ce dernier est contraint de dupliquer toutes les entités lues à partir de la base de données afin d’en conserver une copie originale. Lors de l’appel à la méthode SubmitChanges, il détermine si une entité a changé et qu’est-ce qui a changé en comparant ses valeurs actuelles avec celles de sa copie originale.
En revanche, si l’interface INotifyPropertyChanging est implémentée, LINQ to SQL est directement informé de la modification des entités et seules ces dernières sont dupliquées. Ce qui réduit grandement le nombre de copies effectuées.
Après s’être longtemps fait désirée, Mango apporte enfin une solution de stockage de données native sur Windows Phone avec une version SQL CE spécialement dédiée à Windows Phone.
Malgré ses défauts et certaines alternatives viables, SQL CE for Windows Phone constitue une solution particulièrement adaptée pour les applications amenées à travailler sur de grandes quantités de données à la fois en lecture et en écriture sur Windows Phone 7. D’autant qu’iI existe bon nombres de solutions et d’astuces pour améliorer les temps d’exécutions ainsi que l’empreinte mémoire de l’indissociable couple SQL CE/LINQ to SQL.
L’arrivée de Windows Phone 8 souffle un vent nouveau dans le domaine du stockage de données sur les appareils mobiles Microsoft. Avec la possibilité de développer directement en natif, d’autres solutions de stockage, jouant désormais à armes égales avec SQL CE, pourraient bien faire leur apparition et représenter de très sérieuses alternatives. SQLlite for Windows Phone 8 en est déjà un exemple concret. Si vous souhaitez en savoir plus sur le sujet, je vous invite à consulter cet article ou encore celui-ci.
Les transactions sont des suites d’opérations (Insertion, Suppression, Mise à Jour…) qui font passer la base de données d’un état A (état initial avant les opérations) à un état B (après les opérations).
Dans le cas où une opération échoue, la transaction permet de revenir à l’état antérieur B, c’est-à-dire avant le démarrage de la transaction.
Toutes les modifications seraient dans ce cas annulées.
Dans l’exemple qui va suivre, nous allons voir comment mettre en place les transactions afin d’annuler des opérations opérées sur une base de données en cas d’échec.
Lire la suite
Tour de France Windows 8 et Windows Phone 8
Microsoft organise un Tour de France autour des applications Windows 8 et Windows Phone 8
"Apprendre à développer, sécuriser et optimiser vos "back-end" pour vos applications Windows 8 et Windows Phone 8"
Au programme 4 heures de :
L’objectif est de vous apprendre, en une demi-journée, à développer, sécuriser et optimiser vos "back-end" pour vos applications Windows 8 et Windows Phone 8.
Les thèmes suivants (autour de Windows 8 et Windows Phone 8) seront abordés :
Les intervenants :
Ce Tour de France sera animé par des intervenants MCNEXT :
Ils ont développé de nombreuses applications Windows 8 et Windows Phone 8 présentes dans le Microsoft Store. Ce sont leurs retours d’expériences autour de Windows 8 et Windows Phone 8 qu’ils souhaitent vous apporter.
Le public visé :
Développeurs généralistes
Niveau technique : 300
Pour en savoir plus :
http://www.mcnext.com/evenements/microsoft/Pages/tour-de-france-windows-8-et-windows-phone-8.aspx
Microsoft Dev Camp : Windows 8 et Windows Phone
Rendez-vous le Jeudi 2 mai 2013 à partir de 13h30 !
Qu’est-ce qu’un Dev Camp ?
Le Dev Camp est un événement destiné aux développeurs professionnels comme non professionnels animé par les experts Microsoft et ses partenaires.
Au programme 4 heures de :
L’objectif de ce Dev Camp est de vous montrer comment développer, sécuriser, et optimiser les API et les services qui vous permettront d’exposer vos données pour des applications mobiles.
Les intervenants :
Cet après-midi sera animé par des intervenants MCNEXT :
Ils ont développé de nombreuses applications Windows 8 et Windows Phone 8 présentes dans le Microsoft Store. Ce sont leurs retours d’expériences autour de Windows 8 et Windows Phone 8 qu’ils souhaitent vous apporter.
Lieu :
Campus de Microsoft – Issy les Moulineaux
Pour en savoir plus : http://www.mcnext.com/evenements/microsoft/Pages/microsoft-dev-camp-reussir-la-partie-serveur-de-vos-applications-windows-8-et-windows-phone.aspx
Nous travaillons avec beaucoup de fichiers Excel, mais n’avons pas forcément accès à un ETL de type SSIS. Ne vous inquiétez pas, Microsoft a pensé à cela et travaille actuellement sur une version finale de l’add-in Excel (2010 SP1 et 2013) permettant d’effectuer des tâches d’intégration basiques et courantes. Cet article a pour but de vous introduire le fonctionnement de cette preview add-in gratuit.
Chaque sortie d’une nouvelle version de Visual Studio apporte aux développeurs son lot de nouveautés et d’innovations. La version 2012 de Visual Studio ne déroge pas à la règle. Par ce post, je souhaite vous faire partager mes différentes découvertes sur cette version, et principalement, tout ce qui peut et va améliorer notre productivité au quotidien.
La première constatation que j’ai fait, immédiatement après avoir ouvert Visual Studio 2012, est son apparence.
En effet, dès son ouverture, je me retrouve immergé dans un environnement quasi mono chrome. Il semble qu’il s’agit là d’une volonté de la part de Microsoft de revenir à la base de ce qu’est la conception de logiciel. Dans leur bonne pratique, Microsoft nomme cela Content before Chrome. Le contenu d’une application est l’élément principal de celle-ci. Microsoft a donc pris parti de ne plus ajouter de fioritures superflues à l’interface fourni aux développeurs, afin que ceux-ci puissent se concentrer sur le contenu, plutôt que de privilégier ce qui l’entoure.
On constate également le style épuré de la barre de menu, dont le texte est écrit en majuscule. Ainsi que le faible nombre de bouton raccourci de la barre de tâche.
On retrouve ce style dans tous les logiciels mis à jour en style Modern UI, comme Word 2013, Excel 2013, Etc.
Je parcours la page de démarrage. Elle propose une série de vidéos, type podcast, qui sont autant de tutoriels sur des sujets mise en avant par les équipes Microsoft. Ces vidéos se jouent directement dans Visual Studio 2012. Une coche apparait dans le coin inférieur droit pour indiquer celle que l’on a déjà joué.
L’un des raccourcis clavier, que tous les développeurs connaissent, après le copier/coller (Ctrl+C Ctrl+V), est la fonctionnalité de recherche (Ctrl+F). Visual Studio 2012 ajout le Quick Search aux outils de recherche fourni aux développeurs.
La fenêtre apparait en haut à droite de la page active. Tout d’abord, je la trouve moins intrusive. De plus, maintenant, elle est 100% compatible avec les expressions régulières (le RegEx). Et je garde le meilleur pour la fin, elle affiche le résultat en temps réel, en surlignant le texte d’une façon visible, en Jaune.
Ce mode de recherche est accessible sur chaque fenêtre présentée par Visual Studio 2012. On la retrouve dans l’explorateur de solution, la fenêtre de propriétés, etc.
D’après des recherches effectuées par les équipes de Microsoft, le temps de chargement d’un projet à l’ouverture de Visual Studio est au minimum deux fois plus rapide. Il faut garder à l’esprit que cela dépend grandement de la technologie employée.
Windows 8, permet de scinder l’écran affiché en deux moitié horizontal, par un simple glissé/déposé sur la partie gauche ou droite de l’écran.
Visual Studio 2012 a amélioré la gestion des fenêtres en les rendant totalement autonome. Microsoft, nous fait profiter là de toutes les innovations de Windows 8.
Voici une copie de mon écran. On constate qu’il est scindé en deux, j’ai affiché le fichier XAML d’un contrôle utilisateur à gauche et son fichier contenant le code behind à droite.
Naturellement, cela fonctionne avec toutes les fenêtres de Visual Studio 2012, l’explorateur de fichier, les fenêtres de débogage, etc.
Dans la vie d’un développeur, nous passons beaucoup de temps à chercher des informations spécifiques au travers de notre code. Pour cela, il utilise, généralement la fonction Go to reference (raccourci F12). Dans Visual Studio 2012, cela avait pour effet d’ouvrir des fenêtres, qui finissaient rapidement par polluer notre espace de travail. Pour éviter, cette pollution, on refermait manuellement les fenêtres superflues ouvertes de cette manière.
Visual Studio 2012 propose une vue de prévisualisation. Celle-ci affiche le contenu d’un fichier, en lecture seul. Il n’y a qu’une seule et unique vue de prévisualisation affichée. Dès lors, que l’on modification le contenu de cette fenêtre, ou que l’on clique sur le petit icône en forme de dossier se trouvant dans l’onglet, celle-ci passe en mode normal.
A l’aide du bouton Ctrl, on peut sélectionner plusieurs fenêtres, pour ainsi les déplacer toutes en même temps.
Visual Studio 2012 intègre, nativement, une fonctionnalité qui permet d’épingler une fenêtre. Une fenêtre épinglée reste en première position dans la barre de gestion des fenêtres de l’espace de travail.
Dans les évolutions anecdotiques, sur lesquels je me sens obligé de m’arrêter, il y a une nouvelle fonctionnalité qui permet lorsque l’on fait un clic droit sur l’onglet d’une fenêtre de fermer toutes les fenêtres de l’espace de travail, ainsi qu’une autre pour toutes les fenêtres épinglées. Ces fonctionnalités n’existaient pas sous Visual Studio 2010.
A première vue, l’explorateur de solution n’a pas beaucoup changé. La liste de bouton raccourci en haut de la fenêtre a été augmentée.
J’y retrouve les boutons de la précédente version, telle que Rafraichir, Afficher tous les fichiers, etc. Et puis, je découvre un bouton Tous réduire qui permet de réduire l’arbre de la solution à ces nœuds racines, ainsi qu’un bouton Propriété qui me permet d’ouvrir la fenêtre Propriétés de l’élément sélectionné dans mon arbre de solution.
Après une seconde, je découvre cependant un nouveau niveau logique ajouté à l’arbre. Celui-ci décrit et expose le contenu des fichiers ; Accesseur, Méthodes, Evènement, etc.
Un double clic sur l’un de ses éléments nous permet d’ouvrir le fichier, et positionne le curseur, sur celui-ci.
Sa manipulation a également changé. Un simple clic sur un élément de l’explorateur de solution l’ouvre dans la vue de prévisualisation. Un double clic l’ouvre en mode normal.
On trouve aussi un module de Quick Search, qui ouvre l’arbre sur tous les éléments trouvés (Voir image ci-dessous).
Visual Studio 2012 fourni tous les outils pour permettre de développer des applications sous Windows 8 en Modern UI. Lorsque l’on souhaite lancer une application de Visual Studio 2012, on peut choisir le mode de lancement (voir image ci-dessous).
Dans le cas des applications en Modern UI, on y trouve un simulateur qui ouvre une fenêtre qui ressemble à une tablette (voir image ci-dessous).
A l’aide de cette fenêtre, via les boutons à droite de l’écran, on peut simuler une touche du doigt (on ne peut pas tous être équipé d’écran tactile), faire pivoter la fenêtre (très important à tester), changer la résolution, etc.
Une autre innovation est la fonctionnalité Store, que l’on obtient grâce à un clic droit sur le projet. Il permet d’accédé à toutes les fonctionnalités de déploiement d’une application sur le Windows Store.
Pour les développeurs web, l’auto complétion de Javascript, JQuery et des feuilles CSS est apparue. L’équivalant des commentaires C# (en ///) viens de faire son apparition. Permettant d’associer un commentaire à un paramètre d’une fonction, que l’on retrouve dans la bulle info de l’auto complétion.
Coté HTML, de petite innovation, bien pratique. Par exemple, lorsque l’on modifie une balise, sa balise homologue de fermeture est modifiée aussi, et vice-versa.
Tout comme Modern UI, les sites peuvent être lancés avec un navigateur (installé indépendamment sur la machine) ou à partir du Page inspector (voir image à gauche).
Le Page inspector permet de debugger plus efficacement le site en live.
Enfin, Visual Studio 2012 intègre les nouvelles normes de W3C appelé WAI-ARIA.
Il y aurait encore beaucoup de choses à explorer (l’explorateur de tests unitaires, la barre de Quick Launch, la connexion à TFS…), mais voilà déjà mes premières impressions sur cette nouvelle version 2012 !
Dans le cadre d’une mission, nous intégrons des données de facturation provenant d’un fournisseur externe , afin de les restituer dans nos cubes d’analyse. Ces informations transmises par fichiers XML sont intégrées dans une base de données SQL Server.
La structure du fichier d’échange XML n’est pas sous contrôle, celle-ci est imposée par l’émetteur : l’adaptation du consultant BI s’impose.
Voyons comment intégrer une source XML au travers « SQL Server Integration Services ».
Le XML « Extensible Markup Language » est un langage de balises lisible pour l’homme permettant de structurer de l’information en vue d’échange.
Voyons les composants XML de base constituant un arbre structuré
| Nœud document | Elément racine à tout XML. Il est le point de départ |
| Balise | Une balise est un nom commode pour désigner les constructions entre deux chevrons <…> dans un fichier XML |
| Texte | Un nœud texte n’ayant pas d’enfant. Il est toujours contenu dans une balise. |
| Attribut | Un attribut est un nom et une valeur. Il est toujours porter par une balise. Sa valeur ne sera jamais nulle, mais vide <balise attribut= ‘’/>. L’attribut est unique sur une balise qui peut en avoir plusieurs. <balise attribut1=’valeur1’ attribut2=’valeur2’ …/> |
Étudions dans un premier temps la structure de notre fichier XML.
<?xml version="1.0" encoding="iso-8859-1"?>
<JD_GENERIQUE xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Definition>
<PieceComptable>FARC130014</PieceComptable>
<Redevance>RC</Redevance>
<Activite>Act1</Activite>
<SSActivite>ssAct1</SSActivite>
<ServTransport>Train</ServTransport>
<Date>10/12/2012</Date>
</Definition>
<TableauDetaille Search_Code="044101">
<ENTETE>
<ElementEnTete Nom="NM">044101</ElementEnTete>
<ElementEnTete Nom="TYPCIRC">réelle</ElementEnTete>
<ElementEnTete Nom="HD">00:10:00</ElementEnTete>
<ElementEnTete Nom="DE">Cerbère</ElementEnTete>
<ElementEnTete Nom="FE">Portbou</ElementEnTete>
<ElementEnTete Nom="LT">0,9</ElementEnTete>
<ElementEnTete Nom="MT">3,08</ElementEnTete>
</ENTETE>
<BODY>
<LIGNE>
<ElementDetail Nom="NL">994</ElementDetail>
<ElementDetail Nom="SEGMTARIF">LC</ElementDetail>
<ElementDetail Nom="LNG">0,0</ElementDetail>
<ElementDetail Nom="TCT">FMC</ElementDetail>
<ElementDetail Nom="PU">3,425</ElementDetail>
<ElementDetail Nom="COEFTRAFIC">0,600</ElementDetail>
<ElementDetail Nom="M">0,00</ElementDetail>
</LIGNE>
<LIGNE>
<ElementDetail Nom="NL">995</ElementDetail>
<ElementDetail Nom="SEGMTARIF">LC_FM</ElementDetail>
<ElementDetail Nom="LNG">0,9</ElementDetail>
<ElementDetail Nom="TCT">FMC</ElementDetail>
<ElementDetail Nom="PU">3,425</ElementDetail>
<ElementDetail Nom="COEFTRAFIC">1,000</ElementDetail>
<ElementDetail Nom="M">3,08</ElementDetail>
</LIGNE>
…
| JD_GENERIQUE | Balise racine du document |
| Definition | Balise structurante, définissant le fichier dans sa globalité. |
| PieceComptable RedevanceActivite SSActivite ServTransport Date |
Balises de données contenues dans la balise « Definition » |
| TableauDetaille | Balise structurante, définissant des éléments de facturation |
| Entete | Balise structurante, regroupant des éléments d’entête. |
| ElementEnTete Nom="NM" ElementEnTete Nom="TYPCIRC" ElementEnTete Nom="HD" ElementEnTete Nom="DE" ElementEnTete Nom="FE" ElementEnTete Nom="LT" ElementEnTete Nom="MT" |
Balises de données avec attribut structurant |
| BODY | Balise structurante, définissant le corps |
| LIGNE | Balise structurante, définissant une ligne |
| ElementDetail Nom="NL" ElementDetail Nom="SEGMTARIF" ElementDetail Nom="LNG" ElementDetail Nom="TCT" ElementDetail Nom="PU" ElementDetail Nom="COEFTRAFIC" ElementDetail Nom="M" |
Balises de données avec attribut structurant |
? Une facture est constituée d’une unique entête, de plusieurs tableaux de facturation. Ces derniers sont composés d’une entête de tableau et de plusieurs lignes de détails.
Le traitement d’un fichier XML revient à remettre à plat les données qui ont été hiérarchisées. La difficulté vient de l’aisance à y arriver.
Le traitement d’un nœud comme celui « Definition » est relativement simple. La mise en colonne de l’information est triviale avec les outils SSIS
Le traitement d’un nœud « Entete » ou « Ligne » demandera plus de manipulation pour préparer les données à l’intégration.
Dans un but d’intégration des données, nous remarquerons qu’il y a de nombreux attributs de balise présent et ceux à plusieurs reprise dans les balises « ElementEntete » et « ElementDetail ». Ces derniers ont une valeur fonctionnelle réelle. L’information aurait pu être résumée comme suit pour notre exemple :
Le format du fichier XML nous étant imposé en l’état, aucun changement de la source n’est possible.
Comment traiter ces balises XML avec attributs fonctionnels ? Nous aborderons une façon de faire sans qu’elle soit unique dans la section suivante. Celle-ci traite de l’utilisation des tâches SSIS mise à disposition dans BIDS.
Comme son nom l’indique, la tâche Source XML permet d’utiliser les données stockées dans des fichiers XML dans le flux de données. Si le XML provient d’un fichier, il suffit de spécifier le chemin d’accès ou obtenir le chemin du fichier grâce à une variable au moment de l’exécution. Il est également possible de spécifier le chemin d’accès d’un XSD qui définit la structure de notre XML. Le XSD peut ce générer à partir du fichier XML renseigné.
Création d’un composent « XML Source ». Nous renseignons le document source avec la localisation. La génération d’un fichier XSD est obligatoire pour la structure.
Sur la seconde page du composent « Columns », nous retrouvons les structures de données qui ont été importées.
Pour garantir la hiérarchie du fichier XML d’entrée, le composant génère une multitude de structures imbriquées. Plusieurs sorties sont disponibles et un identifiant unique ID apparait pour garantir l’arborescence.
SSIS rajoute une clé de substitution à chaque élément enfant. Un identifiant ParentID est ajouté au parent, un ChildID à l’enfant et un ChildParentID pour désigner la liaison entre le parent et l’enfant. Les données sont aplaties dans une forme tabulaire en sortie du composant.
En fonction de la complexité de l’arborescence du fichier XML, nous pouvons vite imaginer la difficulté de gérer cette solution.
Il reste à achever le traitement de transformation une fois les sources de sortie du composent identifiées. Rappelez-vous les attributs de balise comme ElementEntete ou ElementDetail ! Comment prendre en compte le nom du champ contenu dans l’attribut et la valeur réelle dans le texte de la balise ? Et bien, on va pivoter le tout.
Cette tâche de transformation de tableau croisé dynamique permet à un ensemble de données normalisées en ligne d’être modifier en données moins normalisées, mais plus compacte. Ceci grâce au croisement dynamique des données du flux.
A partir d’une représentation tabulaire d’un niveau (balise XML). La ligne d’entête est à extraire de la chaine.
XML source extrait
Représentation tabulaire de sortie souhaitée
| ENTETE_ID | NM | TYPCIRC | HD | DE | FE | LT | MT |
| 3 | 044101 | Réelle | 00:10:00 | Cerbèce | Portbou | 0,9 | 3,08 |
En sortie du composant XML Source, la structure générée est la suivante :
Les éléments attribut de balise XML sont récupérés sous le champ « Nom » et la valeur sous « text » (voir image ci-dessus).
En utilisant le composant de tâche Pivot, nous obtenons la représentation tabulaire de sortie souhaitée (voir ci-dessus le tableau). En effet, nous allons faire une transformation de pivot avec la valeur « Texte », en colonne « Nom » et en ligne l’identifiant de l’entête.
| Pivot_Key | Nom |
| Set Key | ENTETE_ID |
| Pivot_Value | Text |
Mise en place de la tâche pivot.
1 – Positionner sur l’onglet des propriétés d’entrées et sortie. Etendre jusqu’au « Input Columns » est renseigné le paramètre « PivotUsage » des champs comme suit :
| PivotUsage | 0 | La valeur n’est pas pivotée, elle passe en sortie du traitement |
| 1 | La valeur fait partie de la clé d’ensemble qui identifie une ou plusieurs rangées dans le cadre d’une série. Toutes les lignes d’entrée avec la clé même ensemble sont combinées en une seule ligne de sortie. | |
| 2 | La colonne est une colonne pivot. Au moins une colonne est créée à partir de chaque valeur de colonne. | |
| 3 | Les valeurs de cette colonne sont mises en colonnes qui sont créées à la suite du pivotement. |
2 – Configuration des champs de sortie. Cette partie est la plus manuelle
a. Etendre « Pivot Default Output » jusqu’au « Output Columns ».
b. Cliquer sur « Add Columns » pour obtenir 8 colonnes
c. Sélectionner la première colonne
i. Renommer la « LIGNE_ID »
ii. Changer la propriété « SourceColumn » pour qu’il corresponde avec la propriété « LineageID » du champ LIGNE_ID présent dans les « Input Columns ». Ici 85 dans notre exemple.
d. Sur le reste des colonnes
i. Renommer les champs avec les libellés contenus dans la colonne « Nom »
ii. Changer pour tous la propriété « SourceColumn » pour qu’il corresponde avec la propriété « LineageID » du champ Text présent dans les « Input Columns ». On renseigne ici l’alimentation de la future colonne de sortie lors du process.
iii.La propriété « PivotKeyValue » qui permet le dispache des données doit-être renseigner. Les valeurs possibles proviennent de la colonne d’entrée « Nom ». Exemple pour la sortie NM, PivotKeyValue = NM
Sortie du composant Pivot
Ce composant de rapprochement des données est utilisé pour reconstruire dans un dataset les valeurs qui seront par la suite stockées.
Nous n’allons pas revenir sur un composant simple. Il s’agit ici d’utiliser les identifiants ID générés automatiquement par la mise à plat du fichier XML.
Dans cet article, Intregration Services peut être utilisé pour sortir des données d’attribut des balises d’un fichier XML. Le composant source XML effectue un travail amont de tabularisation des données qui est simple d’exploiter. Le pivotement des données est clé dans l’exemple pris. N’oubliez pas que le traitement du fichier se réalise en mémoire vis-à-vis des volumétries.
Ce document a pour but de définir un mode opératoire pour la migration de SQL Server 2008 vers SQL Server 2012.
Il vise à décrire les étapes à suivre pour la restauration de la base de données, la migration et le déploiement d’une solution SSIS.
Pour la restauration de la base de données je vous invite à suivre les étapes suivantes :
Etape 1 : Connectez-vous à votre instance SQL Server 2012 via SQL Management Studio.
Etape 2 : Faites clics droits sur Bases de données -> Restaurer la base de données… .
Etape 3 : A partir de l’unité choisissez la source de données que vous souhaitez restaurer en ajoutant le chemin d’accès du fichier .bak (Dans mon exemple je restaure « MCNEXT_Tests.bak »
Etape 4 : Après avoir ajouté le fichier « .bak » sélectionnez la base de destination.
Sélectionner la Base de données ajouté.
Etape 5 : Cliquez sur "ok" pour lancer la restauration.
Etape 6 : Afin de visualiser la base de données cliquez sur Actualisez
Pour la migration d’un package SSIS je vous invite à suivre les étapes suivantes :
Etape 1: Nouveau projet
-> Choisissez ‘Integration Services Project’
Etape 2 : Sélectionnez la solution SSIS à importer
Etape 3 : Assistant de conversion
-> Cliquez sur le bouton Suivant
Etape 4 :
-> Cliquez sur le bouton Terminer
Etape 5 : Assistant de mise à niveau de Package SSIS
-> Cliquez sur le bouton Suivant
Etape 6 :
-> Sélectionnez le package
Etape 7 :
-> Sélectionnez : « Update connection strings to use new provider names » et « Continue upgrade process when a package upgrade fails
Etape 8 : Fin de l’assistant
-> Cliquez sur le bouton Terminer
Etape 9 :
-> Cliquez sur le bouton Fermer
Etape 10 :
Si vous avez créé le projet sous SQL Server 2012, le projet utilise le modèle de déploiement du projet par défaut sinon dans le cas d’une migration il faut le convertir en modèle de déploiement de projet.
Pour cela je vous invite à suivre les étapes suivantes :
Etape 1 : Faites clics droits sur la solution SSIS -> Convertir le projet en modèle de déploiement… . 
Etape 2 : Assistant Conversion de projet Integration Services
-> Cliquez sur le bouton Suivant
Etape 3 : Définir les options sur la page Sélectionner les package
-> Sélectionnez le package
Etape 4 : Définir les options sur la page Spécifier les propriétés du projet
-> Indiquez le nom du projet.
-> Sélectionnez le niveau de protection des packages
-> Tapez une description facultative du projet
Etape 5 : Définir les options sur la page Mettre à jour la tâche d’exécution de package
-> Cliquez sur le bouton Suivant
Etape 6 : Définir les options sur la page Sélectionner les configurations
-> Ajoutez les configurations de package que vous souhaitez remplacer à l’aide de paramètres
-> Sélectionnez les configurations de package que vous souhaitez remplacer par des paramètres.
-> Sélectionnez « Remove configurations from all packages after conversion » afin de Supprimer les configurations de tous les packages après la conversion
Etape 7 : Définir les options sur la page Créer des paramètres
->Sélectionnez le package.
->Indiquez le nom du paramètre.
->Sélectionnez l’étendue du paramètre, package ou projet.
Etape 8 : Définir les options sur la page Configurer les paramètres
->Indiquez le chemin d’accès aux sources de données
Etape 9 :
->Cliquez sur le bouton Suivant
Etape 10 : La page Effectuer la conversion indique l’état de la conversion du projet
->Cliquez sur le bouton Ferme
Le déploiement est une chose qui a pas mal changé dans SQL Server 2012, un nouveau dossier est apparu dans management studio : « Integration Services Catalogs ».
Ce dossier sera l’endroit où les packages seront déployés et l’endroit où les variables d’environnement seront créées.
Avant de pouvoir déployer des projets sur le serveur Integration Services, celui-ci doit contenir le catalogue SSISDB. Le programme d’installation de SQL Server 2012 ne crée pas automatiquement le catalogue vous devez le créer manuellement
Pour cela je vous invite à suivre les étapes suivantes :
Etape 1 : Créer un catalog
->Faites clics droits sur Integration Services Catalogs -> Créer un Catalog… .
->Saisissez un mot de passe
Les objets stockés dans le catalogue SSISDB sont les projets, les packages, les paramètres, les environnements et l’historique opérationnel.
Etape 2 : Déployer
->Faites clics droits sur la solution SSIS -> Déployer… .
Etape 3 : Assistant Déploiement d’Integration Services
->Cliquez sur le bouton Suivant
Etape 4 : Sélectionner une source
->Sélectionnez Fichier de déploiement de projet
->Entrez le chemin d’accès du fichier .ispac
Etape 5 :
->Entrez le nom du serveur.
->Sélectionnez la destination du projet.
Etape 6 :
->Cliquez sur déployer
Etape 7 : Fin de l’assistant
->Cliquez sur Fermer pour quitter l’assistant
La solution SSIS est installée dans le Management Studio
L’autre nouveauté de SSIS dans SQL Server 2012 c’est la gestion des environnements, il vous suffit maintenant de créer un environnement dans SSIS pour chaque environnement physique (Dev, Prod…) et d’y attribuer les valeurs correspondantes.
Pour cela je vous invite à suivre les étapes suivantes :
Etape 8 : Faites clics droits sur le dossier Environnement -> Créer Environnement… .
Etape 9 :
->Tapez un nom pour l’environnement
Etape 10 : Faites clics droits sur Environnement -> Propriétés… .
Etape 11: Dans la page « Variables »
->Choisissez un nom de la variable.
->Sélectionnez le Type de la variable
->Entrez la Valeur de la variable d’environnement.
Etape 12: Dans la page « Permissions »: Vous pouvez accorder ou refusez des autorisations pour les rôles et les utilisateurs.
->Cliquez sur 
pour enregistrer les propriétés de l’environnement.
Etape 13 : Dans l’Explorateur d’objets, faites clics droits sur la solution -> Configurer… .
Etape 14: Dans la page « Références »: procédez comme suit pour ajouter une variable:
->Cliquez sur Ajouter pour ajouter un environnement
->Cliquez sur pour enregistrer la référence dans l’environnement.
Etape 15:
Dans l’onglet « Connection Managers » de la page « Paramètre » : Vous pouvez mapper la variable d’environnement à une propriété du gestionnaire de connexions.
->cliquez sur le bouton Parcourir en regard du champ Valeur.
->Sélectionnez variable d’environnement.
->Choisissez la variable d’environnement que vous avez créée.
->Cliquez deux fois sur pour enregistrer vos modifications.
Etape 16: Faites clics droits sur le package -> Exécute… .
->Sélectionnez l’environnement.
->Cliquez sur pour lancer l’exécution.
Tutorial rédigé par Laila TABII
Les GEDs SharePoint dépassent couramment le million de documents.
Dans ce contexte, il faut créer (au moins) deux indexeurs en équilibre de charge, ce qui nous permettra en plus d’offrir de la tolérance de panne.
1. Préambule
La source d’info :
On retrouve logiquement une grande partie du paramétrage de fast sur http://technet.microsoft.com/fr-fr/library/jj219705.aspx
Les prérequis :
Pas de tests en prod !
- Deux serveurs SharePoint 2013 sur lesquels on n’a pas encore crée de service de recherche (de toute façons, vous ne voulez pas du wizard pour une install en production ;)
- Un répertoire local de stockage sur chaque serveur ou (mieux) plusieurs répertoires sur un espace partagé. Ils doivent exister et êtres vides.
- Classiquement :
Si vous avez créé un service de recherche avec une topologie incorrecte, ou que le script échoue, une chance, dropper un service applicatif prend deux lignes J
$spapp = Get-SPServiceApplication -Name "Search Service Application"
Remove-SPServiceApplication $spapp -RemoveData
A faire avant chaque tentative. Gardez aussi à l’esprit que l’ordonnanceur interne de SharePoint n’est pas en temps réel, il vaut mieux donc attendre 5 mn avant de relancer le script au cas où un job serait encore dans la file du SPTIMER.
2. Les rôles
On doit répartir les rôles query, admin, stats et content sur nos deux nœuds.
Dans mon exemple, je suivrais la matrice suivante :
|
ROLE |
SPIDX1 (Principal) |
SPIDX2 (Backup) |
|
CRAWL |
X |
X |
|
ADMIN |
X |
|
|
CONTENT |
X |
X |
|
STATS |
X |
|
|
QUERY |
X |
X |
3. Les partitions
- Le minimum pour l’équilibrage est deux partitions (0/1)
- Le minimum pour la tolérance de panne est de découper en un maitre et un replica pour chaque partition (0/1 répliqué en 1/0)
On aura donc quatre composants Index.
4. Le script
Partant de cette configuration, on peut commencer à écrire le script :
J’ai utilisé la nomenclature du technet.
# RAZ!
# Supprime le service applicatif et les BDD existantes
$spapp = Get-SPServiceApplication -Name "Search Service Application"
Remove-SPServiceApplication $spapp -RemoveData
#==============================================================
#Configuration Search Service Application (SSA)
#==============================================================
$SearchApplicationPoolName = "SearchAdminApplicationPool"
$SearchApplicationPoolAccountName = "SP2013\SP_SEARCH"
$SearchServiceApplicationName = "Search Service Application"
$SearchServiceApplicationProxyName = "Search Service Application Proxy"
$DatabaseInstance = "SQL2012\SPSQL2013"
$DatabaseName = "Sharepoint2013_SearchService"
#Nom des serveurs d’index
$App1 = “SPIDX1”
$App2 = "SPIDX2"
#Reps Exemples. Attention à mettre deux reps differents en Stockage partagé!
$IndexLocationServer1 = "D:\IDX_HostA"
$IndexLocationServer2 = "D:\IDX_HostB"
# Création des reps (avec le bug local)
New-Item -Path "\\SPIDX1\d$\IDX_HOSTA" -type directory -force
New-Item -Path "\\SPIDX1\d$\IDX_HOSTB" -type directory -force
New-Item -Path "\\SPIDX2\d$\IDX_HOSTB" -type directory -force
#==============================================================
# Création du Pool s’il n’existe pas
#==============================================================
Write-Host -ForegroundColor DarkGray "Test – Pool SSA"
$SPServiceApplicationPool = Get-SPServiceApplicationPool -Identity $SearchApplicationPoolName -ErrorAction SilentlyContinue
if (!$SPServiceApplicationPool)
{
Write-Host -ForegroundColor Yellow "Création – Pool SSA"
$SPServiceApplicationPool = New-SPServiceApplicationPool -Name $SearchApplicationPoolName -Account $SearchApplicationPoolAccountName -Verbose
}
#==============================================================
#Search Service Application
#==============================================================
Write-Host -ForegroundColor DarkGray "Test – SSA"
$SearchServiceApplication = Get-SPEnterpriseSearchServiceApplication -Identity $SearchServiceApplicationName -ErrorAction SilentlyContinue
if (!$SearchServiceApplication)
{
Write-Host -ForegroundColor Yellow "Création – SSA"
$SearchServiceApplication = New-SPEnterpriseSearchServiceApplication -Name $SearchServiceApplicationName -ApplicationPool $SPServiceApplicationPool.Name -DatabaseServer $DatabaseInstance -DatabaseName $DatabaseName
}
Write-Host -ForegroundColor DarkGray "Test – SSA Proxy"
$SearchServiceApplicationProxy = Get-SPEnterpriseSearchServiceApplicationProxy -Identity $SearchServiceApplicationProxyName -ErrorAction SilentlyContinue
if (!$SearchServiceApplicationProxy)
{
Write-Host -ForegroundColor Yellow "Création – SSA Proxy"
New-SPEnterpriseSearchServiceApplicationProxy -Name $SearchServiceApplicationProxyName -SearchApplication $SearchServiceApplicationName
}
#==============================================================
# Démarrer le service – IDX1
#==============================================================
$HostA = Get-SPEnterpriseSearchServiceInstance -Identity $App1
Write-Host -ForegroundColor DarkGray "Test – SSI 1"
if($HostA.Status -ne "Online")
{
Write-Host -ForegroundColor Yellow "Démarrage – SSI 1"
Start-SPEnterpriseSearchServiceInstance -Identity $HostA
While ($HostA.Status -eq "Online")
{
Start-Sleep -s 5
}
Write-Host -ForegroundColor Yellow "SSI 1 Démarré"
}
#==============================================================
# Démarrer le service – IDX2
#==============================================================
$HostB = Get-SPEnterpriseSearchServiceInstance -Identity $App2
Write-Host -ForegroundColor DarkGray " Test – SSI 2"
if($HostB.Status -ne "Online")
{
Write-Host -ForegroundColor Yellow " Démarrage– SSI 2"
Start-SPEnterpriseSearchServiceInstance -Identity $HostB
While ($HostB.Status -eq "Online")
{
Start-Sleep -s 5
}
Write-Host -ForegroundColor Yellow "SSI 2 Démarré"
}
#==============================================================
# Créer une nouvelle topologie vide pour pouvoir la modifier, et la remplir.
#==============================================================
$InitialSearchTopology = $SearchServiceApplication |
Get-SPEnterpriseSearchTopology -Active
$NewSearchTopology = $SearchServiceApplication | New-SPEnterpriseSearchTopology
#==============================================================
# Composants IDX1 : Stats, Index, Crawl, Admin, Query
#==============================================================
New-SPEnterpriseSearchAnalyticsProcessingComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA
New-SPEnterpriseSearchContentProcessingComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA
New-SPEnterpriseSearchCrawlComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA
New-SPEnterpriseSearchAdminComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA
New-SPEnterpriseSearchQueryProcessingComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA
#==============================================================
# Composants IDX2: Index, Crawl, Query (noeud de backup)
#==============================================================
New-SPEnterpriseSearchContentProcessingComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostB
New-SPEnterpriseSearchCrawlComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostB
New-SPEnterpriseSearchQueryProcessingComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostB
#==============================================================
# Création de deux indexs, deux partitions = 4 replicas
# spécifier les répertoires permet d’éviter de le stocker dans "Office Servers…"
# A = 0/1 B= 1/0
#==============================================================
New-SPEnterpriseSearchIndexComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA -IndexPartition 0 -RootDirectory $IndexLocationServer1
New-SPEnterpriseSearchIndexComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostB -IndexPartition 1 -RootDirectory $IndexLocationServer2
New-SPEnterpriseSearchIndexComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostA -IndexPartition 1 -RootDirectory $IndexLocationServer1
New-SPEnterpriseSearchIndexComponent -SearchTopology $NewSearchTopology -SearchServiceInstance $HostB -IndexPartition 0 -RootDirectory $IndexLocationServer2
#==============================================================
# Enregistrement de la topologie
#==============================================================
Write-Host -ForegroundColor Yellow "Enregistrement tolologie"
Set-SPEnterpriseSearchTopology -Identity $NewSearchTopology
#==============================================================
# Suppression de l’ancienne
#==============================================================
Write-Host -ForegroundColor DarkGray "Suppression tolologie.old"
Remove-SPEnterpriseSearchTopology -Identity $InitialSearchTopology -Confirm:$false
Write-Host -ForegroundColor Yellow "Supprimée"
#==============================================================
#Check Search Topology
#==============================================================
Get-SPEnterpriseSearchStatus -SearchApplication $SearchServiceApplication -Text
Write-Host -ForegroundColor Yellow "Topologie configurée!"
5. Résultat attendu :
On peut aussi tester en ligne de commande par, par exemple,
Get-SPEnterpriseSearchStatus –SearchApplication « Serch Service Application"
Emmanuel ISSALY
Architecte Infrastructure Sharepoint
MCNEXT
Suite à l’article sur l’indexation d’un DataWarehouse, voici quelques scripts qui vous aideront dans l’administration des index (merci à Frédéric BO pour la majorité des scripts listés ci-dessous)
