SQL Server
Workflow d’optimisation des performances SQL Server : de la requête lente à la cause racine
Un workflow pratique d’optimisation SQL Server pour passer d’un ralentissement vague à une cause racine grâce aux waits, Query Store, plans d’exécution, blocages, I/O, CPU, mémoire et contexte de charge.
Dans cet article
L’optimisation des performances ne consiste pas à trouver une DMV magique, un index manquant ou un plan d’exécution.
Le plus difficile est de passer d’un symptôme vague :
SQL Server est lent.
à une cause racine défendable :
Cette procédure stockée a régressé après un changement de plan : elle parcourt désormais 80 millions de lignes au lieu d’en chercher 40 000, génère des lectures physiques, garde ses verrous plus longtemps et contribue le plus au ralentissement de la charge.
Cela demande un workflow.
Un processus d’optimisation SQL Server utile doit répondre à cinq questions :
1. Qu'est-ce qui a changé ?
2. Où passe le temps ?
3. Quelle charge de travail est responsable ?
4. Pourquoi cette charge est-elle coûteuse ?
5. La correction a-t-elle réellement amélioré le système ?
Cet article présente un workflow pratique que vous pouvez réutiliser lors d’incidents de production, de validations de version et du travail de performance au quotidien.
Partir du symptôme, pas de la correction
L’une des erreurs d’optimisation les plus fréquentes consiste à commencer par une solution.
Exemples :
"Ajouter un index."
"Mettre à jour les statistiques."
"Recompiler la procédure."
"Augmenter MAXDOP."
"Vider le cache des plans."
N’importe laquelle de ces actions peut aider.
Aucune ne devrait être la première question.
Commencez par définir précisément le symptôme.
Au lieu de :
Les rapports sont lents.
relevez :
Quel rapport ?
Quelle procédure ou quelle requête ?
Quand est-ce devenu lent ?
Toutes les requêtes sont-elles touchées ?
Le problème est-il constant ou intermittent ?
Quelle est la durée attendue ?
Quelle est la durée réelle ?
Le CPU, les lectures, les waits, les blocages ou la mémoire ont-ils changé ?
Un déploiement ou le volume de données a-t-il changé ?
Une bonne investigation commence par un constat mesurable.
Par exemple :
Avant :
Durée P95 = 2,1 s
Après la mise en production :
Durée P95 = 14,7 s
Vous avez maintenant quelque chose à analyser, et quelque chose à valider après la correction.
Le workflow
Un workflow pratique d’optimisation SQL Server ressemble à ceci :
- Symptôme
- Délimiter le problème
- Examiner la charge actuelle
- Examiner les waits / blocages
- Trouver les requêtes coûteuses
- Consulter l’historique Query Store
- Lire le plan d’exécution
- Comparer estimations et réalité
- Vérifier index / statistiques / forme des données
- Changer une seule chose
- Mesurer à nouveau
L’ordre est important, car il vous évite d’optimiser la mauvaise chose.
Étape 1 : déterminer si le problème est local ou systémique
Décidez d’abord si vous analysez :
une requête
une application
une base de données
un serveur
ou toute la plateforme
Si une seule procédure stockée est lente alors que tout le reste est normal, commencez par cette requête.
Si de nombreuses requêtes sans rapport entre elles ralentissent au même moment, cherchez une contrainte commune :
- saturation du CPU ;
- latence du stockage ;
- pression mémoire ;
- blocages ;
- pression sur tempdb ;
- pression sur les threads de travail (workers) ;
- instabilité du cache des plans ;
- changement lié à un déploiement ;
- événement d’infrastructure.
Cette distinction évite des efforts inutiles.
Un mauvais plan pour une procédure n’expliquera pas pourquoi dix bases de données sans rapport sont devenues lentes exactement au même moment.
Étape 2 : examiner ce qui se passe en ce moment
Quand le problème est en cours, capturez la charge actuelle avant de modifier quoi que ce soit.
Un point de départ simple :
SELECT
r.session_id,
r.status,
r.command,
r.cpu_time,
r.total_elapsed_time,
r.reads,
r.writes,
r.logical_reads,
r.wait_type,
r.wait_time,
r.wait_resource,
r.blocking_session_id,
DB_NAME(r.database_id) AS database_name,
s.login_name,
s.host_name,
s.program_name,
SUBSTRING(
t.text,
(r.statement_start_offset / 2) + 1,
(
(
CASE r.statement_end_offset
WHEN -1 THEN DATALENGTH(t.text)
ELSE r.statement_end_offset
END
- r.statement_start_offset
) / 2
) + 1
) AS statement_text
FROM sys.dm_exec_requests AS r
JOIN sys.dm_exec_sessions AS s
ON r.session_id = s.session_id
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS t
WHERE r.session_id <> @@SPID
ORDER BY r.total_elapsed_time DESC;Cela permet de savoir :
- ce qui s’exécute ;
- depuis combien de temps ;
- combien de CPU a été consommé ;
- combien de lectures ont été effectuées ;
- ce qui est attendu ;
- si la requête est bloquée ;
- quelle application et quel hôte l’ont soumise.
Ce sont des preuves sur l’état actuel.
Il ne faut pas les confondre avec des preuves historiques.
Étape 3 : lire les waits comme des symptômes
Les waits vous disent ce que SQL Server attend.
Ils ne vous donnent pas automatiquement la cause racine.
Exemples :
PAGEIOLATCH_*
→ attente de pages de données depuis le stockage
LCK_M_*
→ attente de verrous
CXPACKET / CXCONSUMER
→ coordination de l'exécution parallèle
RESOURCE_SEMAPHORE
→ attente de mémoire d'exécution de requête
WRITELOG
→ attente de l'écriture du journal
SOS_SCHEDULER_YIELD
→ le worker a cédé le scheduler CPU
ASYNC_NETWORK_IO
→ SQL Server attend que le client consomme les lignes
La bonne question n’est pas :
Comment éliminer ce wait ?
La meilleure question est :
Pourquoi cette charge de travail produit-elle autant de ce wait ?
Par exemple, PAGEIOLATCH_SH peut venir de la latence du stockage.
Ou d’une requête qui se met soudain à parcourir des millions de pages à cause d’un mauvais plan.
Corriger le stockage ne corrigera pas le plan.
Étape 4 : vérifier les blocages avant d’optimiser le coût des requêtes
Une requête peut être lente parce qu’elle est coûteuse.
Elle peut aussi être lente parce qu’elle attend derrière une autre transaction.
Ce sont deux problèmes différents.
Regardez :
SELECT
r.session_id,
r.blocking_session_id,
r.status,
r.wait_type,
r.wait_time,
r.wait_resource,
r.total_elapsed_time,
DB_NAME(r.database_id) AS database_name
FROM sys.dm_exec_requests AS r
WHERE r.blocking_session_id <> 0
ORDER BY r.wait_time DESC;Puis examinez le bloqueur principal (head blocker).
Questions à se poser :
- Y a-t-il une transaction ouverte ?
- Le bloqueur est-il en cours d’exécution ?
- L’application garde-t-elle une transaction ouverte alors qu’elle est inactive ?
- Un changement d’index ou de plan a-t-il fait que le bloqueur garde ses verrous plus longtemps ?
- Le niveau d’isolation est-il approprié ?
- La charge bloquée lit-elle plus de lignes qu’avant ?
Les blocages sont souvent un effet secondaire d’une régression de requête.
Une procédure qui se terminait en 200 ms et qui dure désormais 20 secondes garde ses verrous beaucoup plus longtemps.
Étape 5 : trouver la charge coûteuse avec la bonne métrique
« La requête la plus coûteuse » n’a pas le même sens selon le problème.
Vous pouvez vous intéresser :
au CPU
aux lectures logiques
aux lectures physiques
à la durée
aux écritures
au nombre d'exécutions
à l'allocation mémoire
à l'utilisation de tempdb
Une requête qui s’exécute une fois par jour pendant 60 secondes peut compter moins qu’une requête qui s’exécute 100 000 fois par heure en 20 ms.
Utilisez la métrique qui correspond au symptôme.
Pour les statistiques agrégées en cache :
SELECT TOP (20)
qs.execution_count,
qs.total_worker_time,
qs.total_elapsed_time,
qs.total_logical_reads,
qs.total_logical_writes,
qs.total_worker_time / NULLIF(qs.execution_count, 0) AS avg_cpu,
qs.total_elapsed_time / NULLIF(qs.execution_count, 0) AS avg_elapsed,
qs.total_logical_reads / NULLIF(qs.execution_count, 0) AS avg_logical_reads,
DB_NAME(st.dbid) AS database_name,
st.text
FROM sys.dm_exec_query_stats AS qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS st
ORDER BY qs.total_worker_time DESC;Rappelez-vous que les DMV du cache des plans sont réinitialisées lorsque les plans sortent du cache ou que l’instance redémarre.
Elles sont utiles, mais ce n’est pas un historique de performance durable.
Étape 6 : utiliser Query Store pour l’historique et les régressions
Query Store est l’un des outils les plus utiles pour répondre à cette question :
Cette requête a-t-elle toujours été lente ?
Il peut conserver :
- le texte des requêtes ;
- les plans ;
- les statistiques d’exécution ;
- les statistiques de waits lorsqu’elles sont activées et prises en charge ;
- l’historique des plans.
Il devient ainsi beaucoup plus simple de comparer l’avant et l’après.
Une régression peut ressembler à ceci :
Plan 12
durée moyenne : 400 ms
lectures moyennes : 40 000
Plan 18
durée moyenne : 8,4 s
lectures moyennes : 3 200 000
Vous avez maintenant une preuve solide que le problème est lié au plan.
Query Store est particulièrement utile après :
- un changement de niveau de compatibilité ;
- des modifications d’index ;
- des changements de statistiques ;
- un déploiement ;
- un changement dans la distribution des paramètres ;
- une mise à niveau de SQL Server ;
- une migration de base de données.
La comparaison importante ne porte pas seulement sur la durée moyenne.
Regardez :
- la moyenne ;
- le P95/P99 s’il est disponible dans votre couche de supervision ;
- le CPU ;
- les lectures logiques ;
- les écritures ;
- le nombre d’exécutions ;
- l’ID du plan ;
- l’intervalle de temps.
Les moyennes peuvent masquer des régressions intermittentes.
Étape 7 : lire le plan d’exécution comme une histoire
Un plan d’exécution n’est pas qu’une collection d’icônes.
Lisez-le ainsi :
Comment SQL Server prévoit-il d'obtenir les lignes ?
Combien de lignes attend-il ?
Combien de lignes arrivent réellement ?
Où les données se multiplient-elles ?
Où sont-elles filtrées ?
Où sont-elles triées ?
Où y a-t-il des débordements (spills) ?
Où y a-t-il des seeks ou des scans ?
Commencez par les écarts les plus importants.
Par exemple :
Lignes estimées : 1
Lignes réelles : 4 800 000
C’est plus intéressant qu’une icône d’avertissement jaune isolée.
Des erreurs d’estimation importantes peuvent influencer :
- le type de jointure ;
- l’ordre des jointures ;
- l’allocation mémoire ;
- le parallélisme ;
- le choix entre seek et scan.
Étape 8 : comparer lignes estimées et lignes réelles
L’estimation de cardinalité est au cœur de la qualité d’un plan.
Quand les estimations sont fausses, demandez-vous pourquoi.
Les causes courantes sont :
- des statistiques obsolètes ;
- des données asymétriques ;
- des prédicats corrélés ;
- la sensibilité aux paramètres ;
- les variables de table ;
- les expressions scalaires ;
- les conversions implicites ;
- des relations complexes entre plusieurs colonnes.
Ne mettez pas automatiquement à jour toutes les statistiques.
Déterminez d’abord si la mauvaise estimation contribue réellement au mauvais plan.
Étape 9 : rechercher la sensibilité aux paramètres
Une procédure stockée peut être rapide pour un paramètre et catastrophique pour un autre.
Exemple :
@MerchantId = 12
→ 50 lignes
@MerchantId = 999
→ 40 millions de lignes
Un plan idéal pour le premier peut être catastrophique pour le second.
Les signes à surveiller :
- une forte variance du temps d’exécution ;
- plusieurs distributions de données très différentes ;
- des changements de plan corrélés aux performances ;
- un profil de paramètre systématiquement lent.
Les réponses possibles dépendent de la situation :
- réécrire la requête ;
- de meilleurs index ou statistiques ;
- l’optimisation Parameter Sensitive Plan lorsqu’elle s’applique ;
OPTION (RECOMPILE)pour des cas ciblés ;- du SQL dynamique ;
- le forçage de plan comme technique de stabilisation temporaire.
Ne qualifiez pas chaque régression de « parameter sniffing ».
Prouvez la relation.
Étape 10 : vérifier les index après avoir compris le plan
Les recommandations d’index manquants peuvent être utiles.
Ce sont des suggestions, pas des conceptions.
Avant d’ajouter un index, demandez-vous :
Quel prédicat a besoin d'être soutenu ?
Quelle jointure a besoin d'être soutenue ?
Un index existant peut-il être étendu ?
Quelle est la sélectivité des clés de tête ?
Quel surcoût en écriture cela va-t-il ajouter ?
Cela va-t-il créer un énième index quasi dupliqué ?
Supposons que la requête soit :
SELECT
sale_id,
amount,
sale_timestamp
FROM dbo.Sales
WHERE merchant_id = @merchant_id
AND sale_timestamp >= @start_date
AND sale_timestamp < @end_date;Un index possible serait :
CREATE INDEX IX_Sales_Merchant_Timestamp
ON dbo.Sales (merchant_id, sale_timestamp)
INCLUDE (sale_id, amount);Cette conception découle du modèle d’accès.
Elle ne doit pas venir d’une copie aveugle de la suggestion verte d’index manquant.
Étape 11 : vérifier les statistiques et la distribution des données
SQL Server choisit ses plans à partir d’estimations.
Les statistiques font partie de ce modèle.
Questions utiles :
- Quand les statistiques ont-elles été mises à jour pour la dernière fois ?
- La table a-t-elle beaucoup grossi ?
- La distribution a-t-elle changé ?
- Le prédicat est-il fortement asymétrique ?
- Une clé croissante crée-t-elle des problèmes d’estimation ?
- Les seuils de mise à jour automatique sont-ils adaptés à la charge ?
Vous pouvez examiner les métadonnées des statistiques avec :
SELECT
OBJECT_SCHEMA_NAME(s.object_id) AS schema_name,
OBJECT_NAME(s.object_id) AS table_name,
s.name AS stats_name,
STATS_DATE(s.object_id, s.stats_id) AS stats_date
FROM sys.stats AS s
WHERE s.object_id = OBJECT_ID('dbo.Sales')
ORDER BY stats_date;Une date de statistiques plus récente ne garantit pas une bonne estimation.
La distribution compte toujours.
Étape 12 : examiner les I/O avant d’accuser le stockage
Beaucoup de lectures et un stockage lent ne sont pas la même chose.
Supposons :
Requête A
lectures logiques : 200 000 000
latence du stockage : normale
Le vrai problème peut être la quantité de données que SQL Server demande au stockage de lire.
Supposons maintenant :
Requête B
lectures logiques : 20 000
lectures physiques : modestes
latence de lecture : 80 ms
Cela désigne plus nettement le stockage.
Séparez :
la quantité d'I/O que la requête demande
de :
la vitesse à laquelle le stockage traite ces I/O
Les deux comptent.
Étape 13 : analyser le CPU dans le contexte de la charge
Un CPU élevé est un symptôme.
Trouvez les requêtes qui le consomment.
Les causes courantes sont :
- de grands scans ;
- des jointures inefficaces ;
- du travail scalaire répété ;
- des conversions implicites ;
- de mauvaises estimations ;
- un excès de compilations ;
- de petites requêtes à très haute fréquence ;
- des plans parallèles ;
- le traitement de JSON/XML ;
- le tri ou le hachage de grands ensembles.
Ne commencez pas par modifier les paramètres de parallélisme du serveur parce que le CPU est élevé.
Identifiez d’abord la charge qui génère ce CPU.
Étape 14 : examiner les allocations mémoire et les spills
Certaines requêtes sont lentes parce qu’elles ont besoin de mémoire pour :
- un tri ;
- une jointure par hachage ;
- une agrégation par hachage.
Si l’allocation est trop petite, le travail peut déborder (spill) dans tempdb.
Si elle est trop grande, les requêtes concurrentes peuvent devoir attendre de la mémoire.
Cherchez :
Avertissements de tri
Avertissements de hachage
Spills
Waits RESOURCE_SEMAPHORE
Grandes allocations mémoire
Là encore, les estimations comptent.
Une requête qui attend 1 000 lignes mais en reçoit 50 millions peut obtenir une allocation mémoire totalement inadaptée.
Étape 15 : surveiller tempdb
La pression sur tempdb peut se manifester par :
- des spills ;
- des tables temporaires ;
- le version store ;
- des tris ;
- des hachages ;
- des tables de travail internes ;
- de nombreuses allocations concurrentes.
Mais « tempdb est chargé » n’est pas encore une cause racine.
Demandez-vous :
Quelle charge de travail génère l’activité dans tempdb ?
Puis optimisez la charge ou la configuration de tempdb en vous appuyant sur des preuves.
Étape 16 : comparer les versions avec la même charge
L’optimisation devient beaucoup plus fiable lorsque vous comparez des périodes maîtrisées.
Par exemple :
Niveau de compatibilité 130
vs
Niveau de compatibilité 150
ou :
version A
vs
version B
Relevez :
- la durée ;
- le CPU ;
- les lectures logiques ;
- les écritures ;
- le nombre d’exécutions ;
- le plan ;
- le profil de waits.
Un tableau de comparaison utile :
| Métrique | Avant | Après | Variation |
|---|---|---|---|
| Durée moyenne | 1,8 s | 2,3 s | +27,8 % |
| Durée P95 | 3,2 s | 18,1 s | +465,6 % |
| CPU | 910 ms | 895 ms | -1,6 % |
| Lectures logiques | 240k | 220k | -8,3 % |
| Écritures | 1 200 | 1 400 | +16,7 % |
Le P95 raconte une histoire très différente de la moyenne.
Étape 17 : changer une seule chose importante à la fois
Si vous :
ajoutez trois index
mettez à jour toutes les statistiques
forcez un plan
changez MAXDOP
réécrivez la requête
augmentez la mémoire
et que les performances s’améliorent, vous ne savez pas pourquoi.
En production, une urgence impose parfois plusieurs actions.
Pour l’optimisation courante, préférez des changements maîtrisés :
hypothèse
→ un seul changement
→ mesure
→ conserver ou annuler
Cela rend l’ingénierie de la performance reproductible.
Étape 18 : valider la correction à plusieurs niveaux
Une requête peut s’améliorer pendant que le système se dégrade.
Par exemple :
La durée de la requête s'améliore de 40 %
mais
le nouvel index augmente le coût des écritures de 30 %
et
le stockage augmente de 200 Go
Validez :
Au niveau de la requête
- la durée ;
- le CPU ;
- les lectures ;
- les écritures ;
- le plan ;
- les spills.
Au niveau de la charge
- le débit ;
- la latence P95/P99 ;
- les blocages ;
- les waits ;
- la concurrence.
Au niveau du système
- le CPU ;
- la mémoire ;
- la latence du stockage ;
- le débit du journal ;
- tempdb.
Une bonne correction améliore le problème visé sans en créer un plus grand ailleurs.
Étape 19 : conserver les preuves
Les incidents de performance sont beaucoup plus faciles à résoudre lorsque vous conservez un historique.
Les preuves utiles comprennent :
horodatage
base de données
query_id
plan_id
durée
CPU
logical_reads
écritures
waits
blocages
version/release
niveau de compatibilité
C’est pourquoi Query Store et un système de supervision externe se complètent.
Query Store fournit un historique durable des requêtes et des plans à l’intérieur de SQL Server.
La supervision apporte le contexte de la charge et de l’infrastructure dans le temps.
Étape 20 : construire une liste de contrôle d’optimisation reproductible
Quand un incident commence, posez les mêmes questions à chaque fois.
Périmètre
- Une requête ou tout le serveur ?
- Une base de données ou plusieurs ?
- Constant ou intermittent ?
- Quand cela a-t-il commencé ?
Charge actuelle
- Qu’est-ce qui s’exécute ?
- Qu’est-ce qui attend ?
- Qu’est-ce qui est bloqué ?
- Qu’est-ce qui consomme du CPU ou des lectures ?
Historique
- La durée a-t-elle régressé ?
- Le plan a-t-il changé ?
- Le nombre d’exécutions a-t-il changé ?
- Le volume de données a-t-il changé ?
Plan
- Estimations ou réalité ?
- Scan ou seek ?
- Stratégie de jointure ?
- Tri/hachage ?
- Spill ?
- Parallélisme ?
- Conversion implicite ?
Structures de données
- Index ?
- Statistiques ?
- Asymétrie ?
- Partitionnement ?
- Croissance du nombre de lignes ?
Validation
- La métrique s’est-elle améliorée ?
- Le P95 s’est-il amélioré ?
- Le CPU et les lectures se sont-ils améliorés ?
- Les blocages ont-ils changé ?
- Une autre charge a-t-elle régressé ?
Erreurs d’optimisation fréquentes
Vider d’abord le cache des plans
Cela détruit des preuves utiles et affecte des charges sans rapport.
Ajouter tous les index manquants
Cela crée des index qui se chevauchent, un surcoût en écriture, un coût de stockage et un coût de maintenance.
Traiter chaque wait comme la cause racine
Les waits sont des indices, pas des diagnostics automatiques.
Ne regarder que les moyennes
Les régressions intermittentes apparaissent souvent d’abord dans le P95/P99.
Ignorer le nombre d’exécutions
Une petite requête exécutée des millions de fois peut dominer une charge.
Optimiser une requête sans valider la sémantique métier
Un résultat faux obtenu plus vite reste faux.
Modifier les paramètres du serveur avant de comprendre la charge
Les changements au niveau de l’instance peuvent affecter toutes les bases de données.
Un déroulé pratique d’incident
Quand quelqu’un dit :
La production est lente.
je suivrais cette séquence :
1. Confirmer le ralentissement avec une métrique mesurable.
2. Vérifier si le problème est local ou systémique.
3. Capturer les requêtes actives, les waits et les blocages.
4. Identifier les requêtes qui pèsent sur le CPU, les lectures ou la durée.
5. Utiliser Query Store pour comparer le comportement actuel et historique.
6. Comparer les plans.
7. Rechercher les problèmes d'estimation et la sensibilité aux paramètres.
8. Évaluer les index et les statistiques.
9. Vérifier les I/O, les allocations mémoire, tempdb et la pression système.
10. Formuler une hypothèse.
11. Faire le plus petit changement utile.
12. Mesurer à nouveau les mêmes métriques.
C’est l’optimisation des performances vue comme un processus d’ingénierie plutôt que comme une suite d’essais et d’erreurs.
Conclusion
L’optimisation des performances SQL Server ne consiste pas d’abord à connaître davantage de requêtes sur les DMV.
Elle consiste à utiliser les preuves dans le bon ordre.
Partez du symptôme.
Mesurez la charge actuelle.
Séparez les blocages du coût des requêtes.
Utilisez les waits pour comprendre où passe le temps.
Utilisez Query Store pour comprendre l’historique.
Utilisez le plan d’exécution pour expliquer le comportement.
N’utilisez les index et les statistiques qu’après avoir compris le modèle d’accès.
Puis validez le résultat avec les mêmes métriques que celles qui ont prouvé l’existence du problème.
Un bon workflow d’optimisation transforme :
SQL Server est lent.
en :
Nous savons quelle charge a régressé, pourquoi elle a régressé, ce qui a changé, ce qui l’a corrigée et à quel point la situation est meilleure maintenant.
C’est le niveau de preuve que le travail de performance en production devrait viser.
Suivre le parcours principal
Passez des requêtes en cours à un ID de session/SPID, puis à la chaîne de blocage lorsque des sessions s’attendent. Utilisez les régressions Query Store pour l’historique et la supervision en temps réel pour observer l’état courant de façon répétée. Gardez la checklist SQL Server comme compagnon opérationnel.
Les fiches Flux de diagnostic, Utilisation des index et Index manquants soutiennent les étapes correspondantes sans remplacer l’investigation.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireTrouver les requêtes gourmandes en CPUIdentifiez les requêtes SQL Server qui consomment le plus de CPU en ce moment et dans l’historique, distinguez le CPU total du CPU par exécution et choisissez la bonne étape d’optimisation suivante.Ouvrir l’aide-mémoire
- RessourceContenu en anglaisSQL Server Performance Tuning ChecklistA one-page troubleshooting reference for slow SQL Server workloads: ten steps from incident scope to measured change, with three diagnostic queries.Voir la ressource
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.