Hands On Labs chez Winwise !

Bonjour à tous !

Le mois prochain, Winwise, en coopération avec le GUSS (Groupe d'Utilisateurs de SQL server), vous propose de découvrir gratuitement SQL Server au travers de plusieurs Hands-On-Labs.
Les différents ateliers seront présentés par les formateurs de Winwise, dont votre serviteur.

Je ne peux donc que vous encourager à vous inscrire pour cet événement, et ce très rapidement car les places sont limitées !
Vous trouverez toutes les informations nécessaires ici.

Alors à vos claviers !

Haute disponibilité avec SQL Server - Quelle solution pour quel résultat ?

Bonjour à tous !

SQL Server est depuis longtemps rompu à la nécessaire disponibilité des données. Mais quelles sont les différentes solutions proposées, et que peut-on en attendre ?

Je vous propose aujourd'hui un résumé de chaque solution proposée par Microsoft avec SQL Server 2005, et ce que vous pouvez raisonnablement espérer de chacune d'entre elles.

LOG SHIPPING ET MIRRORING - DEUX SOLUTIONS, UNE FINALITE

Beaucoup ont entendu parler de Log Shipping, nombreux sont ceux qui ont entendu parler de mirroring... Mais pour quel résultat, quel impact sur l'existant, quelle maintenance ?
Le Log Shipping est reconnu depuis longtemps comme une solution peu onéreuse, simple à mettre en oeuvre, mais assez délicate à exploiter, en particulier lors d'un basculement de serveur. En effet, le basculement est manuel, la perte des dernières données probable, car le temps d'indisponibilité fluctue en fonction de la réactivité du DBA.
Le Mirroring peut être vu comme une solution de Log Shipping évoluée. Si le mode SAFETY OFF est sélectionné, le Mirroring se comporte en effet comme le Log Shipping, recopiant le journal de transaction au fil de l'eau. Le temps de latence reste globalement plus faible que dans le cas du Log Shipping, et la mise en oeuvre est totalement automatisée.
En revanche, si l'on sélectionne le mode SAFETY FULL, le Mirroring permet de garantir à l'utilisateur une parfaite synchronisation des bases de données, ce que ne permet pas le Log Shipping.
De plus, l'utilisation d'un WITNESS permet d'automatiser le processus de basculement des serveurs en cas d'erreur.
Qu'il s'agisse de Log Shipping ou de Mirroring, l'initialisation des bases de données s'effectue par Backup/Restore.

Devant ces similitudes, je privilégie donc largement le Mirroring sous SQL Server 2005, qui permet un temps de latence bien plus faible que son copain le Log Shipping.
De plus l'utilisation d'un WITNESS assure un basculement automatique des plus appréciables, et qui plus est l'un des plus rapides du marché avec un temps d'absence de service inférieur à 5 secondes.

REPLICATION ET DISTRIBUTION DES DONNEES

L'utilisation de la distribution des données comme moyen de haute disponibilité est une méthode couramment utilisée.
Il existe de nombreux moyens de distribuer ses données. Le plus simpliste reste la copie par batch des données à intervalle régulier. Cette méthode très simple à mettre en oeuvre s'apparente dans les applications à du Log Shipping, même si son procédé est radicalement différent. De plus, il est possible d'utiliser la base de données ainsi obtenue en lecture par exemple.
Pour les bases de faible volumétrie et supportant le risque de la perte des données les plus récentes, la réplication snapshot correspond aussi à cette problématique. En revanche, contrairement au batch de recopie, la réplication snapshot supporte difficilement les très grosses volumétries.
Enfin, pour une distribution assurant une plus grande fraîcheur de données, la réplication transactionnelle offre également un compromis intéressant. Là encore, les données sont accessibles en lecture. En revanche, la publication transactionnelle doit être désactivée pour effectuer quelque changement que ce soit dans la structure des données. De plus, la réplication transactionnelle s'avère souvent très fragile dès qu'une opération de maintenance sur le journal de transactions est nécessaire.

La distribution des données, qu'il s'agisse d'un batch ou d'une réplication, aussi faible son temps de latence soit-il, n'est pas à proprement parler une véritable solution de haute disponibilité. En revanche, il peut s'agir d'un compromis efficace pour pallier à une éventuelle défaillance du système tout en conservant l'utilisation de toutes les machines achetées.

CLUSTERING

Le clustering reste la méthode reine de la haute disponibilité, permettant entre autres de ne spécifier qu'une seule adresse réseau pour plusieurs ordinateurs physiques, assurant ainsi un basculement transparent pour les applications clientes.
Pour être mis en oeuvre, le clustering demande des connaissances avancées tant sur la partie SQL Server que sur le système d'exploitation.
Le point noir du clustering proposé par Microsoft reste l'inactivité des serveurs de secours, induisant un coût d'immobilisation supplémentaire. De plus, le clustering n'apporte aucune solution en cas de destruction physique des supports de stockage - incendie par exemple - étant donné que ces ressources physiques sont partagées entre les différents noeuds (je n'évoquerai pas ici les possibilités de géo-cluster pour des raisons de simplification).
Concernant les surcoûts d'immobilisation, il faut tout de même noter que dans le cadre du clustering, tout comme dans le cadre du mirroring, un serveur de secours actif moins de 30 jours par an ne requiert aucune licence.
Le délai de basculement de serveur dans le cas du clustering avoisine les 30 secondes, à mettre en parallèle avec les 5 secondes du mirroring.

Contrairement à son grand concurrent ORACLE, SQL Server ne dispose pas d'une réelle solution de clustering Actif-Actif. Microsoft préfère en effet privilégier l'accroissement des performances monoserveurs. Pour ceux dont l'architecture nécessiterait un scale out, il est possible d'implémenter une solution alternative consistant à créer deux clusters Actif-Passif croisés, simulant de fait le clustering Actif-Actif.

REPLICATION PEER-TO-PEER ET MIRRORING "ACTIF-PASSIF"

Microsoft offre également d'autres méthodes permettant d'utiliser les différentes machines tout en limitant les pertes de données potentielles en cas de crash système.
La plus ancienne des deux méthodes que je vous présenterai ici est la réplication Peer-To-Peer. Il ne s'agit ni plus ni moins que d'une réplication transactionnelle bi-directionnelle.
Ce type de réplication est extrêmement utile dans le cadre de sites de sauvegarde délocalisés. De plus, tous les serveurs sont actifs. Si l'on multiplie les noeuds de réplication, cette méthode s'avère très efficace et permet même d'envisager un partage de charge (Load Balancing). En revanche, contrairement au clustering, chaque machine est identifiée individuellement, et par conséquent le partage de charge doit être géré à un niveau plus bas, par exemple à l'aide d'un switch actif.
Une autre technique, s'appuyant sur le mirroring, permet d'avoir accès en lecture aux bases de données. Cette méthode nécessite un partage de ressource à l'aide, par exemple, d'une baie SAN, et un seul serveur accède à la base en écriture. Cette solution peut être très intéressante dans le cas de DataWareHouse nécessitant une grande capacité de calcul lors des lectures. Un des serveurs mirroirs prend le relai en cas de panne du serveur maître.

La réplication Peer-To-Peer est une solution largement répandue, mais souvent utilisée pour ses capacités de rapprochement des données des utilisateurs plus que pour la haute disponibilité ainsi procurée.

EN CONCLUSION

Je concluerai ce post en faisant le constat suivant : le besoin métier pilote évidemment le choix technologique, tant par les aspects financiers que par les aspects de criticité des données. Il est donc primordial de bien prendre en compte tous les éléments avant de définir une architecture de serveurs de bases de données, cela conditionnant également le développement des applications gravitant autour de celle-ci.

A très bientôt !

Mise en oeuvre d'un test de validité avec SQL Server Integration Services

Bonsoir à tous !

Si SSIS présente de grands avantages en matière de débugging de part sa conception, il n'en demeure pas moins un outil largement perfectible sur un certain nombre de points.

Le premier d'entre eux est sans doute la faiblesse des bibliothèques de fonctions accessibles dans les tâches de conversions de données. En effet, les tests classiques permettant d'identifier la bonne typologie de la donnée importée dans un Data Flow (ISDATE, ISNUMERIC, ...) ne peuvent pas être effectués autrement qu'à l'aide d'une tâche Script Component... Une tâche souvent fastidieuse et longue à développer, en particulier si le nombre de champs à tester est particulièrement important.
Si devant cette lacune importante la solution de redévelopper un composant spécifique pour SSIS vient immédiatement à l'esprit, la réalité du déploiement sur les postes clients nous rattrape inexorablement. En effet, il est nécessaire de déployer le dit composant sur tous les serveurs impactés ce qui peut s'avérer rapidement délicat...

Je viens donc ici vous proposer une solution alternative, bien que peu satisfaisante pour les perfectionnistes dont je fais partie : l'utilisation de tables temporaires !
En effet, si SSIS ne possède pas les fonctions adéquates, le Transact-SQL peut venir à notre secours !
Il convient donc d'intégrer la source de données dans une table temporaire indépendante du format des données - par exemple des champs VARCHAR - puis d'effectuer les transformations et les vérifications d'intégrité dans le cadre d'une procédure stockée...

Si cette solution demeure peu reluisante, elle reste réellement la seule solution viable tant que SQL Server Integration Services n'offrira pas une bibliothèque de composants et de fonctions satifaisante...

A suivre...

Déplacement des bases de données système SQL Server 2005...

Bonjour à tous !!!

Voici un post qui ne devrait pas laisser indifférentes les personnes qui ont procédé au déplacement laborieux de toutes les bases d'une instance SQL, en particulier les bases système !

En effet, si le déplacement de ces bases est largement documenté dans la MSDN, il n'en demeure pas moins extrêmement long et fastidieux d'entreprendre une telle opération...
On note cependant l'effort important que Microsoft a consenti pour simplifier ce déplacement entre la version SQL Server 2000 et SQL Server 2005.

Pour mémoire, vous trouverez ici la documentation concernant le déplacement des fichiers des bases de données système de SQL Server 2000 et de SQL Server 7.
Sous SQL Server 2005, seul le déplacement des bases de données Master et mssqlsystemresource, nouvelle base de données qui n'existait pas sous SQL Server 2000, nécessite un traitement particulier.

Je vous propose donc ici un script customisable qui devrait ravir les grands et les petits qui souhaitent déplacer leurs bases de données système SQL Server 2005 en un clic !

Pour exploiter le code suivant, sauvegardez le dans un fichier Visual Basic Script (par exemple c:\movedb.vbs) et lancez le !

Function newliner(s)
newliner = Replace(s,"\n",VBCrLf)
End Function

Sub commande(s)
shcmd.Run "cmd /C " & s,1,true
End Sub

Dim base(4)
base(0) = array("ma","","","","master.mdf","mastlog.ldf")
base(1) = array("rs","mssqlsystemresource","data","log","mssqlsystemresource.mdf","mssqlsystemresource.ldf")
base(2) = array("mo","model","modeldev","modellog","model.mdf","modellog.ldf")
base(3) = array("db","msdb","MSDBData","MSDBLog","MSDBData.mdf","MSDBLog.ldf")
base(4) = array("tp","tempdb","tempdev","templog","tempdb.mdf","templog.ldf")

Function baseray(s)
baseray = array()
For Each row in base
If row(0) = s Then
baseray = row
End If
Next
End Function

' Déplace une base de données autre que "master" et "resource"
Sub movenormal(row, s)
database = row(1)
If s = "d" Then
nom = row(2)
fichier = row(4)
Elseif s = "j" Then
nom = row(3)
fichier = row(5)
End If
commande("sqlcmd -S " & instance & " -Q ""ALTER DATABASE " & database & " MODIFY FILE (name=" & nom & ", FILENAME='" & dest & "\" & fichier & "')""")
commande("net stop " & serviceinstance & " /yes")
commande("move """ & src & "\" & fichier & """ """ & dest & """ ")
commande("net start " & serviceinstance)
End Sub

' Déplace "master" et "resource"
Sub movemaster()
row = base(0)
fichierd = row(4)
fichierj = row(5)
commande("net stop " & serviceinstance & " /yes")

'SEARCH and replace parameters
cle = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\Instance Names\SQL\" & keyinstance
cleinstance = shcmd.RegRead(cle)
cle = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\" & cleinstance & "\MSSQLServer\Parameters"
If s = "d" Then
shcmd.RegWrite cle & "\SQLArg0", "-d" & dest & "\" + fichierd, "REG_SZ"
commande("move """ & src & "\" & fichierd & """ """ & dest & """ ")
Elseif s = "j" Then
shcmd.RegWrite cle & "\SQLArg2", "-l" & dest & "\" + fichierj, "REG_SZ"
commande("move """ & src & "\" + fichierj & """ """ & dest & """ ")
End If
commande("net start " + serviceinstance + " /f /T3608")
row = base(1)
database = row(1)
nomd = row(2)
nomj = row(3)
fichierd = row(4)
fichierj = row(5)
If s = "d" Then
commande("sqlcmd -S " & instance & " -Q ""ALTER DATABASE " & database & " MODIFY FILE (name=" & nomd & ", FILENAME='" & dest & "\" & fichierd & "')""")
commande("move """ & src & "\" & fichierd & """ """ & dest & """ ")
Elseif s = "j" Then
commande("sqlcmd -S " & instance & " -Q ""ALTER DATABASE " & database & " MODIFY FILE (name=" & nomj & ", FILENAME='" & dest & "\" & fichierj & "')""")
commande("move """ & src & "\" & fichierj & """ """ & dest & """ ")
End If
commande("sqlcmd -S " & instance & " -Q ""ALTER DATABASE " & database & " SET READ_ONLY""")
commande("net stop " & serviceinstance & " /yes")
commande("net start " & serviceinstance)
End Sub

set shcmd = WScript.CreateObject("WScript.Shell")

' Variables à redéfinir par InputBox ou manuellement:
' nom du serveur SQL et de l'instance dont on déplace les basese
serveur = InputBox("Nom du serveur")
If serveur = "" Then WScript.Quit
instance = InputBox("Nom de l'instance (Pour l'instance par défaut, laisser le champ vide)")
If Replace(instance, " ", "") = "" Then
instance = serveur
serviceinstance = "MSSQLSERVER"
keyinstance = "MSSQLSERVER"
Else
instance = serveur & "\" & instance
serviceinstance = "MSSQL$" & instance
keyinstance = instance
End If

src = InputBox("Chemin source")
dest = InputBox("Chemin destination")

line = "Base(s) à déplacer:\nmr: master + resource\ndb: msdbdata\nmo: model\ntp: tempdb\n(ex: 'mr, tp')"
db = InputBox(newliner(line))

line = "Déplacer (d)onnées, (j)ournaux\n ou les deux (d,j)"
dj = InputBox(newliner(line))

'line = "Paramêtres:\n- source: " + src + "\n- destination: " + dest + "\n- bases: " + db + "\n- objets: " + dj
'msgbox(newliner(line))

dbpar = Split(Replace(db," ",""),",")
djpar = Split(Replace(dj," ",""),",")

For Each db In dbpar
If db <> "mr" Then
r = baseray(db)
If ubound(r) > -1 Then
For Each dj in djpar
movenormal r, dj
Next
End If
Else
movemaster
End If
Next


Bonne journée !

Gestion des requêtes sur les vues partitionnées...

Bonsoir à tous !

Suite à de nombreux problèmes rencontrés avec les vues partitionnées, je souhaite clarifier certaines règles d'usage pour éviter tout problème avec ces éléments capricieux.

Tout d'abord, je voudrai parler du cas des champs date utilisés comme clé de partition. L'optimiseur de SQL Server n'est pas capable d'interpréter correctement les clauses CHECK sur ce type de données.
Le plus simple est alors de créer un champ acceptant l'optimisation des vues partitionnées. Par exemple, le plus simple avec une clé de partition sur l'année est de créer un champ de type INT contenant cette information.

Ainsi, la clé de partition ne sera plus le champ date qui nous posait problème, mais bien le champ INT qui lui sera supporté sans aucun problème.

Je souhaiterai ensuite évoquer les problèmes liés au mode de requêtage. En effet, l'optimiseur de requête de SQL Server effectuant le processus de Paramétrisation avant le processus de Planification de la requête, SQL Server ne procède pas aux optimisations nécessaires lors de la requête suivante :
DECLARE @TEST INT
SET @TEST = 50
SELECT Id, PartitionCol FROM VALL WHERE PartitionCol = @TEST

Nous pouvons alors privilégier le SQL Dynamique dans ce cas bien particulier, seule solution pour obtenir le résultat escompté.

Enfin, je voulai attirer ici l'attention sur l'importance des statistiques dans le cadre de l'utilisation des vues partitionnées. En effet, de mauvaises statistiques induisent le stockage d'un mauvais plan d'exécution. Les performances s'en ressentent alors de façon très importante, en particulier dans le cadre de l'utilisation de procédures stockées, où en cas de paramétrisation des requêtes ad hoc.

Bonne soirée !

Optimisation des requêtes à l'aide des vues partitionnées

Bonjour à tous !

Les vues partitionnées, tout comme les tables partagées dans SQL Server 2005, sont un moyen simple de répartir ses données sur plusieurs filegroups afin d'alléger les coûts de maintenance. Il est même possible à l'aide des vues partitionnées distribuées de répartir la charge, tout simplement en stockant les différentes tables sur différents serveurs.
Les vues partitionnées regroupent donc les données de plusieurs tables dont la structure est identique. Ainsi, toutes les opérations d'insertion, de modification et de suppression peuvent être effectuées sur une vue partitionnée, moyennant une condition sine qua non : la clé de répartion doit faire partie de la clé primaire de chacune des tables aggrégées.

Si les vues partitionnées sont très couramment utilisées pour aggréger les données dans le cadre d'infocentres multisites, les vues partitionnées n'en demeurent pas moins la seule façon de faire du partitionnement horizontal sous SQL Server 2000.
Dès lors, ces vues s'avèrent incontournables sous SQL Server 2000 pour architecturer une solution à forte volumétrie ou disposant d'une fenêtre de données glissante - dans ce cas particulier, la clé de répartition est couramment la date.

Afin de mieux comprendre comment optimiser une vue partitionnée, commençons par un exemple. Créons deux tables possédant la même structure.
CREATE TABLE TB1 (Id INT NOT NULL CONSTRAINT PK_TB1 PRIMARY KEY, PartitionCol INT NOT NULL)
CREATE TABLE TB2 (Id INT NOT NULL CONSTRAINT PK_TB2 PRIMARY KEY, PartitionCol INT NOT NULL)

La vue suivante est alors la vue "partitionnée" qui permet de concaténer les données de ces deux tables :
CREATE VIEW VALL AS SELECT Id, PartitionCol FROM TB1 UNION SELECT Id, PartitionCol FROM TB2

Cependant, cette vue est loin d'optimiser les performances, effectuant même une tâche de reconnaissance afin d'éviter les doublons.
Admettons maintenant que nos données soient réparties de façon bien distincte selon la clé de répartition. Nous pouvons alors de façon sûre écrire :
ALTER VIEW VALL AS SELECT Id, PartitionCol FROM TB1 UNION ALL SELECT Id, PartitionCol FROM TB2

Cette vue est maintenant nettement plus performante, mais reste toujours sans grand intérêt.
Appliquons maintenant des contraintes de type CHECK afin d'assurer au système la bonne séparation des données, par exemple en séparant les éléments négatifs des éléments positifs :
ALTER TABLE TB1 ADD CONSTRAINT CK_TB1_PartitionCol CHECK (PartitionCol < 0)
ALTER TABLE TB2 ADD CONSTRAINT CK_TB2_PartitionCol CHECK (PartitionCol >= 0)

En exploitant notre vue à l'aide de la commande suivante, on obtient enfin le résultat attendu :
SELECT Id, PartitionCol FROM VALL WHERE PartitionCol = 50

En effet, on peut voir dans le plan d'exécution de notre requête que seule la table TB2 est effectivement requêtée.

Nous pouvons maintenant procéder à la dernière étape de l'optimisation de notre vue partitionnée. Pour cela il nous faut ajouter notre clé de répartition dans la clé primaire. Ainsi, nous pourrons utiliser notre vue partitionnée pour insérer et modifier nos données.
ALTER TABLE TB1 DROP CONSTRAINT PK_TB1
ALTER TABLE TB1 ADD CONSTRAINT PK_TB1 PRIMARY KEY (Id, PartitionCol)
ALTER TABLE TB2 DROP CONSTRAINT PK_TB2
ALTER TABLE TB2 ADD CONSTRAINT PK_TB2 PRIMARY KEY (Id, PartitionCol)

La commande suivante est alors possible !!!
INSERT INTO VALL (Id, PartitionCol) VALUES (10, 1000)

Je conviens aisément que ces vues partitionnées présentent de nombreuses difficultés d'implémentation, et qu'en matière de "fenêtre glissante", rien ne vaut les tables partitionnées de SQL Server 2005. En revanche, qu'il s'agisse d'une architecture sous SQL Server 2000 ou une architecture distribuée sur plusieurs serveurs, les vues partitionnées s'avèrent être une arme redoutable dans l'arsenal du développeur Base de Données.

A bientôt, et tous à vos benchs !

Haute disponibilité et licences SQL Server 2005

Bonsoir !

En attendant que je trouve une solution pour publier un post qui me tient à coeur, je viens vous parler d'un sujet qui intéresse un jour ou l'autre tout le monde : les sous !

En effet, la mise en oeuvre d'une solution de haute disponibilité est souvent vue par beaucoup de clients comme un poste financier des plus onéreux. Je viens ici démonter ces préjugés... La politique de licences de SQL Server 2005 permet aux sociétés disposant de moyens financiers limités d'obtenir une solution robuste à faible coût.

Le premier des préjugés que je voudrais casser ici, sans doute lié à la réalité de la version précédente de SQL Server, c'est que SQL Server 2005 ne nécessite pas l'acquisition d'une édition Entreprise pour permettre de mettre en oeuvre une solution de haute disponibilité. En effet, l'édition Standard supporte les solutions de mirroring, de clustering et de log shipping... Et bien entendu, la distribution des données !

Le deuxième est un aspect de licence qui revient souvent dans mes entretiens avec mes clients : les solutions de haute disponibilités telles que le mirroring et le clustering étant des solutions dites "Actif-Passif" - comprenez que le serveur de backup est en position d'attente et ne peut servir l'utilisateur - Microsoft considère que vous n'avez pas à investir dans une licence pour votre serveur de backup si celui-ci ne remplace pas le serveur principal plus de 30 jours par an !

Bien entendu, des limites existent, puisque, par exemple, le mirroring proposé dans l'édition Standard ne supporte que 2 noeuds d'au plus 2 processeurs chacun... Mais quand on rappelle que le serveur témoin peut être matérialisé par un simple SQL Server 2005 Express, il apparaît évident que SQL Server 2005 propose une solution de haute disponibilité tout à fait accessible.

A très bientôt !

Maintenance des index SQL Server - Défragmentation et réindexation

Bonjour à tous !

Je rencontre de plus en plus fréquemment le problème de la fragmentation des index.
En effet, lorsqu'un fort volume de données est inséré dans une table sans que cela ne soit prévu lors de la conception de la base de données, les index croissent de manière désordonnée...

Pour détecter une telle fragmentation, SQL Server 2000 offre la commande suivante :
DBCC SHOWCONTIG
Si cette commande est toujours disponible sous SQL Server 2005 - et sera amenée à disparaitre dans les versions futures -, ce dernier fournit d'autres outils plus ergonomiques et plus précis pour les administrateurs. Parmi ces outils, on notera notamment la fonction dynamique suivante :
sys.dm_db_index_physical_stats

Il existe plusieurs façons de corriger le problème de la fragmentation. Mais avant de voir ces différentes techniques, attachons-nous tout d'abord à la façon dont l'on peut éviter que cette fragmentation ne se produise...

En réalité, tout dépend du mode d'alimentation de la base de données. En effet, un batch de chargement sera traité différemment d'une insertion unitaire.
De la même manière, le milieu fonctionnel impose des contraites ne permettant pas toujours l'emploi de certaines techniques.

Voyons tout d'abord le cas du batch de chargement : lors de l'exécution d'un batch, nous insérons généralement de grandes quantité de données. Ces batches s'exécutent habituellement de nuit, période de faible activité pour la base de données.
Dans ce cas, nous privilégierons la suppression de tous les index avant le chargement, et la recréation de ces index à la fin. Ceci présente un double avantage :
- D'une part les index regénérés ne sont pas fragmentés, puisque tout frais
- D'autre part le chargement des données est beaucoup plus rapide

Je rappellerai ici que la clé primaire incluant un index unique doit également être supprimée dans ce cas - parce que non, ça n'arrive jamais qu'il y ait des personnes qui suppriment tous les index sauf celui de la clé primaire ;-).
Bien entendu, cette suppression des index implique une absence d'activité sur la base de données sur une plage horaire donnée.

Dans le cas des insertions unitaires, le volume de ces insertions est généralement prévisible et plus faible. Dans ces conditions, le mieux est de dimensionner le FILLFACTOR de l'index à une valeur assurant un espace suffisant pour son développement.
Attention à ne pas tomber dans l'excès tout de même : un FILLFACTOR inférieur à 50 dégrade très fortement les performances et s'avère donc plus pénalisant que la fragmentation des index.

Attachons-nous maintenant à une table dont les index sont largement fragmentés.

Une solution simple reste la suppression des index pour les recréer. Cette solution présente l'avantage de toujours donner satisfaction et d'éviter l'explosion des groupes de fichiers.
Cette solution peut être effectuée dans un script traditionnel (DROP/CREATE) ou à l'aide de la commande DBCC DBREINDEX.
L'inconvénient majeur de cette méthode reste la période d'inactivité de la base de données nécessaire pour la reconstruction des index, car ces opérations sont des opérations OFFLINE.
La commande DBCC DBREINDEX, toujours présente dans SQL Server 2005, possède un équivalent avec la commande ALTER INDEX avec l'option REBUILD.

L'autre solution est la défragmentation (DBCC INDEXDEFRAG). Cette solution est une solution ONLINE. C'est la principale raison d'être de l'utilisation de cette commande. Cependant, il faut prendre garde à n'effectuer cette opération qu'après le chargement et non pas en parallèle au risque d'être totalement inefficace.
Le principal inconvénient de cette solution est la place nécessaire sur les groupes de fichiers. En effet, la défragmentation déplace des blocs de données vers des emplacements libres, et par conséquent pose rapidement des problèmes de taille des groupes de fichiers si la fragmentation est très importante. De plus la défragmentation est une opération entièrement loggée générant de fait de très gros volumes dans les journaux de transactions.
Là encore, SQL Server 2005 autorise toujours la commande DBCC INDEXDEFRAG, destinée à disparaître au profit du ALTER INDEX avec l'option REORGANIZE.

En conclusion, voici un récapitulatif des points importants :
- La première des choses est de s'assurer dans le cadre du développement de la base de données que notre base de données ne se fragmentera pas ou peu. Pour cela, il ne faut pas hésiter à supprimer les index et à les recréer au cours des processus d'alimentation. La fragmentation des index n'est pas une fatalité.
- Par la suite, un examen régulier de l'état de la base de données permet de surveiller l'évolution des index et le cas échéant d'entreprendre des actions.
- Sous SQL Server 2000, on privilégiera la commande atomique DBCC DBREINDEX si l'opération peut être menée OFFLINE. On restreindra donc l'usage de la commande DBCC INDEXDEFRAG aux cas nécessitant que les données restent ONLINE.
- Sous SQL Server 2005, on utilisera la commande ALTER INDEX avec les options REBUILD et REORGANIZE qui vont bien, cette commande étant la seule destinée à être maintenue dans les prochaines versions de SQL Server.

SQL Server 2005 plus strict que la norme XSD du W3C

Bonjour à tous !

Suite à une question pertinente d'un client, j'ai cherché à comprendre pour quelle raison un schéma XSD me semblant parfaitement valable me générait une erreur à l'insertion des données...

Une fois le problème isolé, j'ai pu effectuer le test suivant :

DROP TABLE TestXML
GO
DROP XML SCHEMA COLLECTION TestDateRestriction
GO
DROP XML SCHEMA COLLECTION TestDateRestrictionTimeZone
GO
CREATE XML SCHEMA COLLECTION TestDateRestriction
AS
'<?xml version="1.0" encoding="utf-8"?>
<xsd:schema targetNamespace="http://tempuri.org/TestDateRestriction.xsd" attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns="http://tempuri.org/TestDateRestriction.xsd" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="root">
<xsd:simpleType>
<xsd:restriction base="xsd:dateTime">
<xsd:pattern value=".+T[^Z+-\.]+" />
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
</xsd:schema>'
GO
CREATE XML SCHEMA COLLECTION TestDateRestrictionTimeZone
AS
'<?xml version="1.0" encoding="utf-8"?>
<xsd:schema targetNamespace="http://tempuri.org/TestDateRestriction.xsd" attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns="http://tempuri.org/TestDateRestriction.xsd" xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;
<xsd:element name="root">
<xsd:simpleType>
<xsd:restriction base="xsd:dateTime">
<xsd:pattern value=".+T[^+-\.]+Z" />
</xsd:restriction>
</xsd:simpleType>
</xsd:element></xsd:schema>'
GO
CREATE TABLE TestXML
(
IdTB INT IDENTITY(1, 1) NOT NULL
CONSTRAINT PK_TestXML PRIMARY KEY CLUSTERED,
XMLTB XML (DOCUMENT TestDateRestriction) NULL,
XMLTBTimeZone XML (DOCUMENT TestDateRestrictionTimeZone) NULL
)
GO
INSERT INTO TestXML (XMLTB) VALUES (N'<r:root xmlns:r="http://tempuri.org/TestDateRestriction.xsd">2005-03-22T08:35:00</r:root>')
GO
INSERT INTO TestXML (XMLTBTimeZone) VALUES (N'<r:root xmlns:r="http://tempuri.org/TestDateRestriction.xsd">2005-03-22T08:35:00Z</r:root>')
GO

Le résultat est le suivant : SQL Server 2005 n'autorise pas les dates sans spécification du flag Time Zone.

Or, dans le cadre des types DateTime, la norme XSD n'impose nullement la présence de l'indication TimeZone spécifiée dans la norme ISO 8601 comme le spécifie le W3C dans les spécifications suivantes : http://www.w3.org/TR/2005/WD-xpath-datamodel-20050211/#storing-timezones...
En revanche, l'exemple précédent prouve définitivement le choix de SQL Server de se conformer à la norme ISO. Cette information est d'ailleurs confirmée par cet article de la MSDN : http://msdn2.microsoft.com/en-us/library/ms345115.aspx#sql25xmlbp_topic3 (section "Using xs:datetime, xs:date and xs:time").

La seule question qui me reste à élucider est la raison de ce choix exigeant qui pose un problème de compatibilité : le XSD dont je dispose est imposé et partagé par de nombreux utilisateurs et ne peut donc pas être modifié...

Bonne lecture !

Les colonnes calculées persistantes... Une bonne idée ?

Bonsoir !

Les colonnes calculées sont supportées par SQL Server depuis la version 7... En revanche, SQL Server 2005 permet désormais de rendre ces colonnes persistantes.

En effet, jusque là, les colonnes calculées étaient des colonnes virtuelles, c'est à dire que ces colonnes n'étaient pas écrites sur le disque. Le fait de pouvoir rendre une colonne calculée persistante, c'est le fait de rendre cette colonne physique, et donc de stocker les données inhérentes à cette colonne sur le disque de données.

SQL Server 2000 avait déjà apporté la possibilité de créer des index sur les colonnes calculées, permettant ainsi d'améliorer grandement les performances de certaines applications, en particulier dans le domaine de la consolidation de données. L'exemple type qui reste gravé dans la mémoire collective est la consolidation du chiffre d'affaire mois par mois.
En effet, examinons la table suivante :

CREATE TABLE dbo.Vente
(
VenteID INT IDENTITY (1, 1) NOT NULL
CONSTRAINT PK_Vente PRIMARY KEY CLUSTERED,
DateVente SMALLDATETIME NOT NULL,
MontantVente MONEY NOT NULL
)

Une requête pour consolider ces résultats sur le mois de janvier serait :

SELECT
SUM(MontantVente)
FROM
dbo.Vente
WHERE
DATEPART(MONTH, DateVente) = 1

Cependant, si la volumétrie est importante, cette requête peut rapidement s'avérer très coûteuse. Si la solution d'indexer la colonne DateVente n'apporte rien dans notre cas, il peut être très utile d'employer une colonne calculée :

ALTER TABLE dbo.Vente
ADD MoisVente AS DATEPART(MONTH, DateVente)

Cette colonne n'utilisant qu'une fonction déterministe, il est possible d'y ajouter un index. A cet effet, un certain nombre d'options doivent être correctement positionnées :

SET ANSI_NULL ON
SET ANSI_PADDING ON
SET ANSI_WARNINGS ON
SET ARITHABORT ON
SET CONCAT_NULL_YIELDS_NULL ON
SET QUOTED_IDENTIFIER ON
SET NUMERIC_ROUNDABORT OFF

Puis, il est possible de créer l'index :

CREATE NONCLUSTERED INDEX IX_MoisVente ON dbo.Vente
(
MoisVente
)

Avant d'effectuer notre requête optimisée :

SELECT
SUM(MontantVente)
FROM
dbo.Vente
WHERE
MoisVente = 1

Le résultat est assez probant, et peut s'avérer extrêmement intéressant.
La question qui se pose donc est ce que peut bien apporter la persistance d'une telle colonne calculée. En effet, l'argument régulièrement évoqué de l'indexation de la colonne semble bien tomber à l'eau... Quant aux conditions d'utilisation des index sur les colonnes calculées, elles s'avèrent identiques que la valeur soit persistée ou non, à l'exception du déterminisme de la fonction employée...

Pourquoi donc encombrer les disques de données visiblement inutiles ?
La première piste serait donc l'utilisation de fonctions non déterministes, ou dont il serait difficile de savoir si elles le sont, en particulier en ce qui concerne les fonctions CLR.

Mais il faut également se tourner vers des cas plus gourmands en calculs : la persistance prend tout son intérêt lors de calculs complexes nécessitant des ressources CPU importantes, en particulier lorsque la volumétrie de modifications est faible.
Dans ces cas là, le calcul à la volée de notre colonne entraine nécessairement un ralentissement du système, et justifie la persistance de ce calcul.

Soit, voici donc les applications de ces colonnes calculées persistantes...

Un logiciel pour les audits de Bases de données...

Bonjour !

Voici un coup de coeur pour un programme que mon pôle va acquérir dans les jours à venir...
Les logiciels de l'éditeur APEX sont purement et simplement incontournables !!!

En ce qui me concerne, je ne sais pas combien de scripts différents j'ai pu développer ces derniers temps pour un résultat texte médiocre... Certes, cette technique reste appropriée et permet de générer des informations utiles et pratiques à analyser...
Mais que dire alors du résultat obtenu avec APEX SQL... Une pure merveille !!!

Bref, visitez le site http://www.apexsql.com/products.asp, testez, et adoptez !

Informations sur la taille des fichiers d'une base de données

Bonjour à tous !

Je viens aujourd'hui traiter d'un sujet que bon nombre de DBA ont à affronter, et ne disposent que rarement des informations le concernant : je veux parler de l'espace restant sur les différents fichiers avant le désastreux et non moins célèbre "Auto-Growth" !

Voici donc quelques commandes très utiles que vous pourrez essayer sans risques...

1 - sp_helpdb :
La première procédure stockée à utiliser dès que l'on recherche des informations sur la taille des différentes bases de données.
Si l'on spécifie en argument le nom d'une base de données, on obtient les informations découpées par fichier... Bref, un sur ensemble de la procédure sp_helpfile !

2 - sp_helpfile :
Là encore, une des procédures stockées très utilisées. Si cette procédure ne permet pas d'obtenir des informations sur le taux d'utilisation des fichiers, elle permet de connaître d'un seul coup d'oeil la structure fichier de la base de données et la taille de chacun.

3 - sp_spaceused :
Une jolie procédure stockée qui permet de connaître les informations de taille de la base de données courante...
A noter qu'il est possible de préciser le nom d'un objet de la base de données pour obtenir des informations sur la taille occupée.
Cette procédure stockée peut s'avérer très utile lors d'un audit afin de repérer les objets volumineux et, le cas échéant, coûteux en ressource disque.

4 - DBCC SHOWFILESTATS :
Une commande non documentée de SQL Server... Et pourtant tellement importante !
En effet, il s'agit de la seule commande permettant d'obtenir le taux d'utilisation des fichiers de données d'une base... Sans recourrir aux tables système bien entendu ;)
Une information cependant : les informations délivrées par cette commande ont pour unité un "extent"... Dans la plupart des cas un extent est de 64 Ko... Alors à vos calculettes !

5 - DBCC SQLPERF(LOGSPACE) :
Si DBCC SHOWFILESTATS permet d'afficher le taux de remplissage des fichiers de données d'une base, DBCC SQLPERF(LOGSPACE) fournit cette information pour les journaux de transactions de toutes les bases de données... Et en Mo s'il vous plaît !
Bref, encore une commande très utile pour savoir si le journal de transactions va bientôt exploser ;)

Voilà donc pour quelques commandes à utiliser sans modération, qu'il s'agisse de SQL Server 2000 ou 2005 ! Et oui, la firme de Redmond a pour une fois choisi de rester compatible... Pour notre plus grand bonheur :D

Bug SQL Server 2005 - Version française...

Vous avez dit un bug ?
Oui, tout à fait... J'étais tranquillement en train de faire une jolie démo de la réplication de capture instantanée, Snapshot pour les intimes.
Au détour d'une explication, je vais dans les jobs de l'agent SQL consulter l'historique des messages, histoire de montrer comment constater que la réplication tournait bien... Pour faire le beau en somme...
Et comme toute démo qui se respecte, un vilain petit lutin est intervenu...
Une erreur non critique intervient systématiquement sur la première étape : "Message de démarrage de l'agent de capture instantanée."

Je me suis alors empressé de vérifier l'équivalent sur la version anglaise, et là, Ô surprise, pas d'erreur... Serait-ce la petite apostrophe qui poserait tant de problèmes ?
Dans tous les cas, cette erreur n'est pas corrigée par le service pack 1... Et comme la version CTP du service pack 2 n'existe pas en français, impossible de savoir si ce bug persistera après le SP2...

J'en conclus donc qu'il est important d'utiliser uniquement des versions anglaises en production...
A bon entendeur,