{"id":1035,"date":"2016-01-12T08:55:28","date_gmt":"2016-01-12T16:55:28","guid":{"rendered":"http:\/\/3.209.169.194\/blogs\/glenn\/?p=1035"},"modified":"2017-04-13T12:28:47","modified_gmt":"2017-04-13T19:28:47","slug":"sql-server-diagnostic-information-queries-detailed-day-12","status":"publish","type":"post","link":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/","title":{"rendered":"SQL Server Diagnostic Information Queries Detailed, Day 12"},"content":{"rendered":"

For Day 12 of this series, we start out with Query #27<\/strong>, which is Database Properties. This query retrieves information from the sys.databases<\/a> catalog view, and from the sys.dm_os_performance_counters<\/a> dynamic management view. Query #27 is shown in Figure 1. <\/p>\n

\n
\n
   1:<\/span> -- Recovery model, log reuse wait description, log file size, log usage size  (Query 27) (Database Properties)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> -- and compatibility level for all databases on instance<\/span><\/pre>\n
<\/p>\n
   3:<\/span> SELECT<\/span> db.[name] AS<\/span> [Database<\/span> Name], db.recovery_model_desc AS<\/span> [Recovery Model], db.state_desc, db.containment_desc,<\/pre>\n
<\/p>\n
   4:<\/span> db.log_reuse_wait_desc AS<\/span> [Log Reuse Wait Description], <\/pre>\n
<\/p>\n
   5:<\/span> CONVERT<\/span>(DECIMAL<\/span>(18,2), ls.cntr_value\/1024.0) AS<\/span> [Log Size<\/span> (MB)], CONVERT<\/span>(DECIMAL<\/span>(18,2), lu.cntr_value\/1024.0) AS<\/span> [Log Used (MB)],<\/pre>\n
<\/p>\n
   6:<\/span> CAST<\/span>(CAST<\/span>(lu.cntr_value AS<\/span> FLOAT<\/span>) \/ CAST<\/span>(ls.cntr_value AS<\/span> FLOAT<\/span>)AS<\/span> DECIMAL<\/span>(18,2)) * 100 AS<\/span> [Log Used %], <\/pre>\n
<\/p>\n
   7:<\/span> db.[compatibility_level] AS<\/span> [DB Compatibility Level<\/span>], db.page_verify_option_desc AS<\/span> [Page Verify Option<\/span>], <\/pre>\n
<\/p>\n
   8:<\/span> db.is_auto_create_stats_on, db.is_auto_update_stats_on, db.is_auto_update_stats_async_on, db.is_parameterization_forced, <\/pre>\n
<\/p>\n
   9:<\/span> db.snapshot_isolation_state_desc, db.is_read_committed_snapshot_on, db.is_auto_close_on, db.is_auto_shrink_on, <\/pre>\n
<\/p>\n
  10:<\/span> db.target_recovery_time_in_seconds, db.is_cdc_enabled, db.is_published, db.is_distributor, db.is_encrypted,<\/pre>\n
<\/p>\n
  11:<\/span> db.group_database_id, db.replica_id,db.is_memory_optimized_elevate_to_snapshot_on, <\/pre>\n
<\/p>\n
  12:<\/span> db.delayed_durability_desc, db.is_auto_create_stats_incremental_on,<\/pre>\n
<\/p>\n
  13:<\/span> db.is_query_store_on, db.is_sync_with_backup, <\/pre>\n
<\/p>\n
  14:<\/span> db.is_supplemental_logging_enabled, db.is_remote_data_archive_enabled      <\/pre>\n
<\/p>\n
  15:<\/span> FROM<\/span> sys.databases AS<\/span> db WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
  16:<\/span> INNER<\/span> JOIN<\/span> sys.dm_os_performance_counters AS<\/span> lu WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
  17:<\/span> ON<\/span> db.name = lu.instance_name<\/pre>\n
<\/p>\n
  18:<\/span> INNER<\/span> JOIN<\/span> sys.dm_os_performance_counters AS<\/span> ls WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
  19:<\/span> ON<\/span> db.name = ls.instance_name<\/pre>\n
<\/p>\n
  20:<\/span> WHERE<\/span> lu.counter_name LIKE<\/span> N'Log File(s) Used Size (KB)%'<\/span> <\/pre>\n
<\/p>\n
  21:<\/span> AND<\/span> ls.counter_name LIKE<\/span> N'Log File(s) Size (KB)%'<\/span><\/pre>\n
<\/p>\n
  22:<\/span> AND<\/span> ls.cntr_value > 0 OPTION<\/span> (RECOMPILE);<\/pre>\n
<\/p>\n
  23:<\/span>  <\/pre>\n
<\/p>\n
  24:<\/span> -- Things to look at:<\/span><\/pre>\n
<\/p>\n
  25:<\/span> -- How many databases are on the instance?<\/span><\/pre>\n
<\/p>\n
  26:<\/span> -- What recovery models are they using?<\/span><\/pre>\n
<\/p>\n
  27:<\/span> -- What is the log reuse wait description?<\/span><\/pre>\n
<\/p>\n
  28:<\/span> -- How full are the transaction logs?<\/span><\/pre>\n
<\/p>\n
  29:<\/span> -- What compatibility level are the databases on? <\/span><\/pre>\n
<\/p>\n
  30:<\/span> -- What is the Page Verify Option? (should be CHECKSUM)<\/span><\/pre>\n
<\/p>\n
  31:<\/span> -- Is Auto Update Statistics Asynchronously enabled?<\/span><\/pre>\n
<\/p>\n
  32:<\/span> -- Make sure auto_shrink and<\/span> auto_close are<\/span> not<\/span> enabled!<\/pre>\n
<\/div>\n<\/div>\n
Figure 1: Query #27 Volume Info<\/strong><\/p>\n
This query gives you a lot of very useful information about all of your databases. I pay special attention to Log Reuse Wait Description and Log Used %, to spot problems that are preventing the space in the transaction log from being reused, which will eventually cause the log file to fill up and grow. I also look at the compatibility level (which is much more important in SQL Server 2014, with the new cardinality estimator) and the page verify option, which should always be CHECKSUM.<\/p>\n
It is important to check the statistics-related properties, and to also make sure that auto shrink and auto close are not enabled. I don\u2019t think I have ever seen an instance of SQL Server where I did not notice some database properties for multiple databases that were simply incorrect. This query is great for quickly spotting possible issues that need to be corrected.<\/p>\n
 <\/p>\n
Query #28<\/strong> is Missing Indexes All Databases. This query retrieves information from the sys.dm_db_missing_index_group_stats<\/a> dynamic management view, the sys.dm_db_missing_index_groups<\/a> dynamic management view, and the sys.dm_db_missing_index_details<\/a> dynamic management view about \u201cmissing\u201d indexes that the SQL Server Query Optimizer thinks that it would like to have. Query #28 is shown in Figure 2.<\/p>\n
\n
\n
   1:<\/span> -- Missing Indexes for all databases by Index Advantage  (Query 28) (Missing Indexes All Databases)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> SELECT<\/span> CONVERT<\/span>(decimal<\/span>(18,2), user_seeks * avg_total_user_cost * (avg_user_impact * 0.01)) AS<\/span> [index_advantage], <\/pre>\n
<\/p>\n
   3:<\/span> migs.last_user_seek, mid.[statement<\/span>] AS<\/span> [Database<\/span>.Schema<\/span>.Table<\/span>],<\/pre>\n
<\/p>\n
   4:<\/span> mid.equality_columns, mid.inequality_columns, mid.included_columns,<\/pre>\n
<\/p>\n
   5:<\/span> migs.unique_compiles, migs.user_seeks, migs.avg_total_user_cost, migs.avg_user_impact<\/pre>\n
<\/p>\n
   6:<\/span> FROM<\/span> sys.dm_db_missing_index_group_stats AS<\/span> migs WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
   7:<\/span> INNER<\/span> JOIN<\/span> sys.dm_db_missing_index_groups AS<\/span> mig WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
   8:<\/span> ON<\/span> migs.group_handle = mig.index_group_handle<\/pre>\n
<\/p>\n
   9:<\/span> INNER<\/span> JOIN<\/span> sys.dm_db_missing_index_details AS<\/span> mid WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
  10:<\/span> ON<\/span> mig.index_handle = mid.index_handle<\/pre>\n
<\/p>\n
  11:<\/span> ORDER<\/span> BY<\/span> index_advantage DESC<\/span> OPTION<\/span> (RECOMPILE);<\/pre>\n
<\/p>\n
  12:<\/span>  <\/pre>\n
<\/p>\n
  13:<\/span> -- Getting missing index information for all of the databases on the instance is very useful<\/span><\/pre>\n
<\/p>\n
  14:<\/span> -- Look at last user seek time, number of user seeks to help determine source and importance<\/span><\/pre>\n
<\/p>\n
  15:<\/span> -- Also look at avg_user_impact and avg_total_user_cost to help determine importance<\/span><\/pre>\n
<\/p>\n
  16:<\/span> -- SQL Server is overly eager to add included columns, so beware<\/span><\/pre>\n
<\/p>\n
  17:<\/span> -- Do not<\/span> just blindly add<\/span> indexes that show up from<\/span> this query!!!<\/pre>\n
<\/div>\n<\/div>\n
Figure 2: Query #28 Missing Indexes All Databases<\/strong><\/p>\n
This query is very useful, but also very easy to misinterpret and misuse. I have seen many novice DBAs and developers use the results of this query to pretty badly over-index their databases, which affects their database size and hurts insert, update, and delete performance. I like to focus on the last_user_seek column, and see how long ago that was. Was it a few seconds or minutes ago, or was it days or weeks ago?<\/p>\n
I then start looking at the user_seeks, avg_total_user_cost, and avg_user_impact columns to get a sense for how often SQL Server thinks it wants this proposed index, how expensive it is not to have the index, and how much the query optimizer thinks the cost of the query would be reduced if it did have this index that it is requesting.<\/p>\n
Next, I\u2019ll look at any other proposed indexes on the same table to see if I can come up with a wider, consolidated index that covers multiple requested indexes. Finally, I\u2019ll look at the existing indexes on that table, and look at the index usage metrics for that table to have a better idea of whether a new index would be a good idea, based on the volatility of that table.<\/p>\n
 <\/p>\n
Query #29<\/strong> is VLF Counts. This query calls the DBCC LogInfo command for each on of your system and user databases to get your current virtual log file (VLF) counts for your transaction logs. Query #29 is shown in Figure 3<\/p>\n
\n
\n
   1:<\/span> -- Get VLF Counts for all databases on the instance (Query 29) (VLF Counts)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> -- (adapted from Michelle Ufford) <\/span><\/pre>\n
<\/p>\n
   3:<\/span> CREATE<\/span> TABLE<\/span> #VLFInfo (RecoveryUnitID int<\/span>, FileID  int<\/span>,<\/pre>\n
<\/p>\n
   4:<\/span>                        FileSize bigint, StartOffset bigint,<\/pre>\n
<\/p>\n
   5:<\/span>                        FSeqNo      bigint, [Status]    bigint,<\/pre>\n
<\/p>\n
   6:<\/span>                        Parity      bigint, CreateLSN   numeric<\/span>(38));<\/pre>\n
<\/p>\n
   7:<\/span>      <\/pre>\n
<\/p>\n
   8:<\/span> CREATE<\/span> TABLE<\/span> #VLFCountResults(DatabaseName sysname, VLFCount int<\/span>);<\/pre>\n
<\/p>\n
   9:<\/span>      <\/pre>\n
<\/p>\n
  10:<\/span> EXEC<\/span> sp_MSforeachdb N'Use [?]; <\/pre>\n
<\/p>\n
  11:<\/span>  <\/pre>\n
<\/p>\n
  12:<\/span>                 INSERT INTO #VLFInfo <\/pre>\n
<\/p>\n
  13:<\/span>                 EXEC sp_executesql N'<\/span>'DBCC LOGINFO([?])'<\/span>'; <\/pre>\n
<\/p>\n
  14:<\/span>      <\/pre>\n
<\/p>\n
  15:<\/span>                 INSERT INTO #VLFCountResults <\/pre>\n
<\/p>\n
  16:<\/span>                 SELECT DB_NAME(), COUNT(*) <\/pre>\n
<\/p>\n
  17:<\/span>                 FROM #VLFInfo; <\/pre>\n
<\/p>\n
  18:<\/span>  <\/pre>\n
<\/p>\n
  19:<\/span>                 TRUNCATE TABLE #VLFInfo;'<\/span><\/pre>\n
<\/p>\n
  20:<\/span>      <\/pre>\n
<\/p>\n
  21:<\/span> SELECT<\/span> DatabaseName, VLFCount  <\/pre>\n
<\/p>\n
  22:<\/span> FROM<\/span> #VLFCountResults<\/pre>\n
<\/p>\n
  23:<\/span> ORDER<\/span> BY<\/span> VLFCount DESC<\/span>;<\/pre>\n
<\/p>\n
  24:<\/span>      <\/pre>\n
<\/p>\n
  25:<\/span> DROP<\/span> TABLE<\/span> #VLFInfo;<\/pre>\n
<\/p>\n
  26:<\/span> DROP<\/span> TABLE<\/span> #VLFCountResults;<\/pre>\n
<\/p>\n
  27:<\/span>  <\/pre>\n
<\/p>\n
  28:<\/span> -- High VLF counts can affect write performance <\/span><\/pre>\n
<\/p>\n
  29:<\/span> -- and they can make full database restores and crash recovery take much longer<\/span><\/pre>\n
<\/p>\n
  30:<\/span> -- Try to keep your VLF counts under 200 in most cases (depending on log file size)<\/span><\/pre>\n
<\/p>\n
  31:<\/span>  <\/pre>\n
<\/p>\n
  32:<\/span> -- Important change to VLF creation algorithm in SQL Server 2014<\/span><\/pre>\n
<\/p>\n
  33:<\/span> -- https:\/\/www.sqlskills.com\/blogs\/paul\/important-change-vlf-creation-algorithm-sql<\/span>-server-2014\/<\/a><\/pre>\n
<\/div>\n<\/div>\n
Figure 3: Query #29 VLF Counts<\/strong><\/p>\n
Every time a SQL Server log file grows, a certain number of VLFs are added to the log file. By the way, the formula for this was changed in SQL Server 2014, as discussed by Paul Randal here<\/a>.<\/p>\n
The reason why you care about this is because having a higher number of VLFs affects how long the recovery portion of a database restore takes. If you have ever watched the progress update in SSMS while you were doing a restore of a large database, and noticed that it finally got to 100%, but then kept grinding away for quite a while after that, you have seen this effect in action. It is very frustrating!<\/p>\n
It also affects how long \u201ccrash recovery\u201d takes, which occurs for every database on the instance whenever the SQL Server Service starts. This comes into play whether it is just a standalone instance starting or when you failover to another node with a traditional SQL Server failover cluster instance (FCI). If you have ever been frustrated about how long a FCI failover takes, keeping your VLF counts under control is one thing you can do to help speed up the process.<\/p>\n
If you have a high VLF count in a database, it is usually pretty easy to correct. If you are in the FULL recovery model, you will want to run a transaction log backup. Then, you shrink the transaction log file. Often, you will have to repeat this sequence more than once. Sometimes you will even need to generate some log activity (by doing something like reorganizing an index or two) to get the active portion of the log to a place where a shrink works.<\/p>\n
Once you have done all of this, your transaction log file is likely to be extremely small, perhaps just a few MB in size. You will want to immediately manually grow it in relatively large increments (such as 1000MB, 2000MB, or 4000MB) until you have it at the desired size. You will also want to make sure the auto growth increment is set to a fixed size in MB (such as 1000MB, 2000MB, or 4000MB) so that any future auto growths don\u2019t add an excessive number of VLFs.<\/p>\n","protected":false},"excerpt":{"rendered":"
For Day 12 of this series, we start out with Query #27, which is Database Properties. This query retrieves information from the sys.databases catalog view, and from the sys.dm_os_performance_counters dynamic management view. Query #27 is shown in Figure 1. 1: — Recovery model, log reuse wait description, log file size, log usage size (Query 27) […]<\/p>\n","protected":false},"author":7,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[273],"tags":[270],"class_list":["post-1035","post","type-post","status-publish","format-standard","hentry","category-dmv-diagnostic-queries-detailed","tag-sql-server-diagnostic-information-queries-detailed"],"yoast_head":"\nSQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry\" \/>\n<meta property=\"og:description\" content=\"For Day 12 of this series, we start out with Query #27, which is Database Properties. This query retrieves information from the sys.databases catalog view, and from the sys.dm_os_performance_counters dynamic management view. Query #27 is shown in Figure 1. 1: -- Recovery model, log reuse wait description, log file size, log usage size (Query 27) […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/\" \/>\n<meta property=\"og:site_name\" content=\"Glenn Berry\" \/>\n<meta property=\"article:published_time\" content=\"2016-01-12T16:55:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2017-04-13T19:28:47+00:00\" \/>\n<meta name=\"author\" content=\"Glenn Berry\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Glenn Berry\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/\",\"name\":\"SQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website\"},\"datePublished\":\"2016-01-12T16:55:28+00:00\",\"dateModified\":\"2017-04-13T19:28:47+00:00\",\"author\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/57a8972435106bac7970692fcf5edfa7\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SQL Server Diagnostic Information Queries Detailed, Day 12\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/\",\"name\":\"Glenn Berry\",\"description\":\"Semi-random musings about SQL Server performance\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/57a8972435106bac7970692fcf5edfa7\",\"name\":\"Glenn Berry\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/64bdac8830f25f2f8cc780f8a1286c66ff1182218009271e7a953639596f7e25?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/64bdac8830f25f2f8cc780f8a1286c66ff1182218009271e7a953639596f7e25?s=96&d=mm&r=g\",\"caption\":\"Glenn Berry\"},\"sameAs\":[\"https:\/\/www.sqlskills.com\/blogs\/glenn\/\"],\"url\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/author\/glenn\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"SQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/","og_locale":"en_US","og_type":"article","og_title":"SQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry","og_description":"For Day 12 of this series, we start out with Query #27, which is Database Properties. This query retrieves information from the sys.databases catalog view, and from the sys.dm_os_performance_counters dynamic management view. Query #27 is shown in Figure 1. 1: -- Recovery model, log reuse wait description, log file size, log usage size (Query 27) […]","og_url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/","og_site_name":"Glenn Berry","article_published_time":"2016-01-12T16:55:28+00:00","article_modified_time":"2017-04-13T19:28:47+00:00","author":"Glenn Berry","twitter_misc":{"Written by":"Glenn Berry","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/","url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/","name":"SQL Server Diagnostic Information Queries Detailed, Day 12 - Glenn Berry","isPartOf":{"@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website"},"datePublished":"2016-01-12T16:55:28+00:00","dateModified":"2017-04-13T19:28:47+00:00","author":{"@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/57a8972435106bac7970692fcf5edfa7"},"breadcrumb":{"@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-12\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.sqlskills.com\/blogs\/glenn\/"},{"@type":"ListItem","position":2,"name":"SQL Server Diagnostic Information Queries Detailed, Day 12"}]},{"@type":"WebSite","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website","url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/","name":"Glenn Berry","description":"Semi-random musings about SQL Server performance","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.sqlskills.com\/blogs\/glenn\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/57a8972435106bac7970692fcf5edfa7","name":"Glenn Berry","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/64bdac8830f25f2f8cc780f8a1286c66ff1182218009271e7a953639596f7e25?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/64bdac8830f25f2f8cc780f8a1286c66ff1182218009271e7a953639596f7e25?s=96&d=mm&r=g","caption":"Glenn Berry"},"sameAs":["https:\/\/www.sqlskills.com\/blogs\/glenn\/"],"url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/author\/glenn\/"}]}},"_links":{"self":[{"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/posts\/1035","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/comments?post=1035"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/posts\/1035\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/media?parent=1035"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/categories?post=1035"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/tags?post=1035"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}