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

For Day 18 of this series, we start out with Query #41<\/strong>, which is Memory Clerk Usage. This query retrieves information from the sys.dm_os_memory_clerks<\/a> dynamic management view about total memory usage by your active memory clerks. Query #41 is shown in Figure 1.<\/p>\n

\n
\n
   1:<\/span> -- Memory Clerk Usage for instance  (Query 41) (Memory Clerk Usage)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> -- Look for high value for CACHESTORE_SQLCP (Ad-hoc query plans)<\/span><\/pre>\n
<\/p>\n
   3:<\/span> SELECT<\/span> TOP<\/span>(10) mc.[type] AS<\/span> [Memory Clerk Type], <\/pre>\n
<\/p>\n
   4:<\/span>        CAST<\/span>((SUM<\/span>(mc.pages_kb)\/1024.0) AS<\/span> DECIMAL<\/span> (15,2)) AS<\/span> [Memory Usage<\/span> (MB)] <\/pre>\n
<\/p>\n
   5:<\/span> FROM<\/span> sys.dm_os_memory_clerks AS<\/span> mc WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
   6:<\/span> GROUP<\/span> BY<\/span> mc.[type]  <\/pre>\n
<\/p>\n
   7:<\/span> ORDER<\/span> BY<\/span> SUM<\/span>(mc.pages_kb) DESC<\/span> OPTION<\/span> (RECOMPILE);<\/pre>\n
<\/p>\n
   8:<\/span>  <\/pre>\n
<\/p>\n
   9:<\/span> -- MEMORYCLERK_SQLBUFFERPOOL was new for SQL Server 2012. It should be your highest consumer of memory<\/span><\/pre>\n
<\/p>\n
  10:<\/span>  <\/pre>\n
<\/p>\n
  11:<\/span> -- CACHESTORE_SQLCP  SQL Plans         <\/span><\/pre>\n
<\/p>\n
  12:<\/span> -- These are cached SQL statements or batches that aren't in stored procedures, functions and triggers<\/span><\/pre>\n
<\/p>\n
  13:<\/span> -- Watch out for high values for CACHESTORE_SQLCP<\/span><\/pre>\n
<\/p>\n
  14:<\/span>  <\/pre>\n
<\/p>\n
  15:<\/span> -- CACHESTORE_OBJCP  Object Plans      <\/span><\/pre>\n
<\/p>\n
  16:<\/span> -- These are<\/span> compiled plans for<\/span> stored procedures, functions and<\/span> triggers<\/pre>\n
<\/div>\n<\/div>\n
Figure 1: Query #41 PLE by NUMA Node<\/strong><\/p>\n
This query shows you which memory clerks are using the most memory on your instance. With SQL Server 2012 or newer, your top memory clerk by memory usage should be MEMORYCLERK_SQLBUFFERPOOL, meaning memory usage by the SQL Server Buffer Pool. It is very common to see a high value for the CACHESTORE_SQLCP memory clerk, indicating that you have multiple GB of cached ad hoc or prepared query plans in the plan cache. If you see that, then you should look at the next query more closely, for several things you can do to help mitigate this issue.<\/p>\n
 <\/p>\n
Query #42<\/strong> is Ad hoc Queries. This query retrieves information from the sys.dm_exec_cached_plans<\/a> dynamic management view and the sys.dm_exec_sql_text<\/a> dynamic management function about the single-use ad hoc and prepared query plans. Query #42 is shown in Figure 2.<\/p>\n
\n
\n
   1:<\/span> -- Find single-use, ad-hoc and prepared queries that are bloating the plan cache  (Query 42) (Ad hoc Queries)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> SELECT<\/span> TOP<\/span>(50) [text][\/text] AS<\/span> [QueryText], cp.cacheobjtype, cp.objtype, cp.size_in_bytes\/1024 AS<\/span> [Plan<\/span> Size<\/span> in<\/span> KB]<\/pre>\n
<\/p>\n
   3:<\/span> FROM<\/span> sys.dm_exec_cached_plans AS<\/span> cp WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
   4:<\/span> CROSS<\/span> APPLY sys.dm_exec_sql_text(plan_handle) <\/pre>\n
<\/p>\n
   5:<\/span> WHERE<\/span> cp.cacheobjtype = N'Compiled Plan'<\/span> <\/pre>\n
<\/p>\n
   6:<\/span> AND<\/span> cp.objtype IN<\/span> (N'Adhoc'<\/span>, N'Prepared'<\/span>) <\/pre>\n
<\/p>\n
   7:<\/span> AND<\/span> cp.usecounts = 1<\/pre>\n
<\/p>\n
   8:<\/span> ORDER<\/span> BY<\/span> cp.size_in_bytes DESC<\/span> OPTION<\/span> (RECOMPILE);<\/pre>\n
<\/p>\n
   9:<\/span>  <\/pre>\n
<\/p>\n
  10:<\/span> -- Gives you the text, type and size of single-use ad-hoc and prepared queries that waste space in the plan cache<\/span><\/pre>\n
<\/p>\n
  11:<\/span> -- Enabling 'optimize for ad hoc workloads' for the instance can help (SQL Server 2008 and above only)<\/span><\/pre>\n
<\/p>\n
  12:<\/span> -- Running DBCC FREESYSTEMCACHE ('SQL Plans') periodically may be required to better control this<\/span><\/pre>\n
<\/p>\n
  13:<\/span> -- Enabling forced parameterization for the database can help, but test first!<\/span><\/pre>\n
<\/p>\n
  14:<\/span>  <\/pre>\n
<\/p>\n
  15:<\/span> -- Plan cache, adhoc workloads and clearing the single-use plan cache bloat<\/span><\/pre>\n
<\/p>\n
  16:<\/span> -- https:\/\/www.sqlskills.com\/blogs\/kimberly\/plan<\/span>-cache-adhoc-workloads-and<\/span>-clearing-the-single-use<\/span>-plan<\/span>-cache-bloat\/<\/pre>\n
<\/div>\n<\/div>\n
Figure 2: Query #42 Ad hoc Queries<\/strong><\/p>\n
This query will show you which single-use ad hoc or prepared query plans are using the most space in the plan cache. Once you know who the culprits are, you can start investigating them more closely. Perhaps these queries can be converted to stored procedures or parameterized SQL. At the very least, I think you should enable \u201coptimize for ad hoc workloads\u201d at the instance level pretty much as a default setting. On top of this, it is usually a good idea to periodically flush that particular cache, using the DBCC FREESYSTEMCACHE (‘SQL Plans’); command.<\/p>\n
 <\/p>\n
Query #43<\/strong> is Top Logical Reads Queries. This query retrieves information from the sys.dm_exec_query_stats<\/a> dynamic management view, the sys.dm_exec_sql_text<\/a> dynamic management function and the sys.dm_exec_query_plan<\/a> dynamic management function about the cached query plans that have the highest total logical reads. Query #43 is shown in Figure 3.<\/p>\n
\n
\n
   1:<\/span> -- Get top total logical reads queries for entire instance (Query 43) (Top Logical Reads Queries)<\/span><\/pre>\n
<\/p>\n
   2:<\/span> SELECT<\/span> TOP<\/span>(50) DB_NAME(t.[dbid]) AS<\/span> [Database<\/span> Name], LEFT<\/span>(t.[text][\/text], 50) AS<\/span> [Short Query Text],<\/pre>\n
<\/p>\n
   3:<\/span> qs.total_logical_reads AS<\/span> [Total Logical Reads<\/span>],<\/pre>\n
<\/p>\n
   4:<\/span> qs.min_logical_reads AS<\/span> [Min<\/span> Logical Reads<\/span>],<\/pre>\n
<\/p>\n
   5:<\/span> qs.total_logical_reads\/qs.execution_count AS<\/span> [Avg<\/span> Logical Reads<\/span>],<\/pre>\n
<\/p>\n
   6:<\/span> qs.max_logical_reads AS<\/span> [Max<\/span> Logical Reads<\/span>],   <\/pre>\n
<\/p>\n
   7:<\/span> qs.min_worker_time AS<\/span> [Min<\/span> Worker Time<\/span>],<\/pre>\n
<\/p>\n
   8:<\/span> qs.total_worker_time\/qs.execution_count AS<\/span> [Avg<\/span> Worker Time<\/span>], <\/pre>\n
<\/p>\n
   9:<\/span> qs.max_worker_time AS<\/span> [Max<\/span> Worker Time<\/span>], <\/pre>\n
<\/p>\n
  10:<\/span> qs.min_elapsed_time AS<\/span> [Min<\/span> Elapsed Time<\/span>], <\/pre>\n
<\/p>\n
  11:<\/span> qs.total_elapsed_time\/qs.execution_count AS<\/span> [Avg<\/span> Elapsed Time<\/span>], <\/pre>\n
<\/p>\n
  12:<\/span> qs.max_elapsed_time AS<\/span> [Max<\/span> Elapsed Time<\/span>],<\/pre>\n
<\/p>\n
  13:<\/span> qs.execution_count AS<\/span> [Execution Count<\/span>], qs.creation_time AS<\/span> [Creation Time<\/span>]<\/pre>\n
<\/p>\n
  14:<\/span> --,t.[text][\/text] AS<\/span> [Complete Query Text], qp.query_plan AS<\/span> [Query Plan<\/span>] -- uncomment out these columns if not copying results to Excel<\/span><\/pre>\n
<\/p>\n
  15:<\/span> FROM<\/span> sys.dm_exec_query_stats AS<\/span> qs WITH<\/span> (NOLOCK)<\/pre>\n
<\/p>\n
  16:<\/span> CROSS<\/span> APPLY sys.dm_exec_sql_text(plan_handle) AS<\/span> t <\/pre>\n
<\/p>\n
  17:<\/span> CROSS<\/span> APPLY sys.dm_exec_query_plan(plan_handle) AS<\/span> qp <\/pre>\n
<\/p>\n
  18:<\/span> ORDER<\/span> BY<\/span> qs.total_logical_reads DESC<\/span> OPTION<\/span> (RECOMPILE);<\/pre>\n
<\/p>\n
  19:<\/span>  <\/pre>\n
<\/p>\n
  20:<\/span>  <\/pre>\n
<\/p>\n
  21:<\/span> -- Helps you find the most expensive queries from a memory perspective across the entire instance<\/span><\/pre>\n
<\/p>\n
  22:<\/span> -- Can also help track down parameter<\/span> sniffing issues<\/pre>\n
<\/div>\n<\/div>\n
Figure 3: Query #40 Top Logical Reads Queries<\/strong><\/p>\n
Having logical reads means that you are finding the data you need to satisfy a query in the SQL Server Buffer Pool rather than having to go out to the storage subsystem, which is a good thing. Queries that have high numbers of logical reads are creating extra internal memory pressure on your system. They also indirectly create read I\/O pressure, since the data that is in the buffer pool has to be initially read from the storage subsystem. If you are seeing signs of memory pressure, then knowing which cached queries (across the entire instance) that have the highest number of total logical reads can help you understand which queries are causing the most memory pressure.<\/p>\n
Once you understand this, then you can start looking at individual queries in more detail. Perhaps there is a missing index that is causing a clustered index scan that is causing high numbers of logical reads in a query. Perhaps there is an implicit conversion in a JOIN or in a WHERE clause that is causing SQL Server to ignore a useful index. Maybe someone is pulling back more columns than they need for a query. There are lots of possibilities here.<\/p>\n
These three Pluralsight Courses go into even more detail about how to run these queries and interpret the results: <\/p>\n
\n
SQL Server 2014 DMV Diagnostic Queries \u2013 Part 1<\/a><\/p>\n<\/blockquote>\n
\n
SQL Server 2014 DMV Diagnostic Queries \u2013 Part 2<\/a><\/p>\n<\/blockquote>\n
\n
SQL Server 2014 DMV Diagnostic Queries \u2013 Part 3<\/a><\/p>\n<\/blockquote>\n","protected":false},"excerpt":{"rendered":"
For Day 18 of this series, we start out with Query #41, which is Memory Clerk Usage. This query retrieves information from the sys.dm_os_memory_clerks dynamic management view about total memory usage by your active memory clerks. Query #41 is shown in Figure 1. 1: — Memory Clerk Usage for instance (Query 41) (Memory Clerk Usage) […]<\/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-1041","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 18 - 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-18\/\" \/>\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 18 - Glenn Berry\" \/>\n<meta property=\"og:description\" content=\"For Day 18 of this series, we start out with Query #41, which is Memory Clerk Usage. This query retrieves information from the sys.dm_os_memory_clerks dynamic management view about total memory usage by your active memory clerks. Query #41 is shown in Figure 1. 1: -- Memory Clerk Usage for instance (Query 41) (Memory Clerk Usage) […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/\" \/>\n<meta property=\"og:site_name\" content=\"Glenn Berry\" \/>\n<meta property=\"article:published_time\" content=\"2016-01-18T20:03:54+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2017-04-13T19:28:50+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=\"6 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-18\/\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/\",\"name\":\"SQL Server Diagnostic Information Queries Detailed, Day 18 - Glenn Berry\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website\"},\"datePublished\":\"2016-01-18T20:03:54+00:00\",\"dateModified\":\"2017-04-13T19:28:50+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-18\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/#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 18\"}]},{\"@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 18 - 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-18\/","og_locale":"en_US","og_type":"article","og_title":"SQL Server Diagnostic Information Queries Detailed, Day 18 - Glenn Berry","og_description":"For Day 18 of this series, we start out with Query #41, which is Memory Clerk Usage. This query retrieves information from the sys.dm_os_memory_clerks dynamic management view about total memory usage by your active memory clerks. Query #41 is shown in Figure 1. 1: -- Memory Clerk Usage for instance (Query 41) (Memory Clerk Usage) […]","og_url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/","og_site_name":"Glenn Berry","article_published_time":"2016-01-18T20:03:54+00:00","article_modified_time":"2017-04-13T19:28:50+00:00","author":"Glenn Berry","twitter_misc":{"Written by":"Glenn Berry","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/","url":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/","name":"SQL Server Diagnostic Information Queries Detailed, Day 18 - Glenn Berry","isPartOf":{"@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/#website"},"datePublished":"2016-01-18T20:03:54+00:00","dateModified":"2017-04-13T19:28:50+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-18\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqlskills.com\/blogs\/glenn\/sql-server-diagnostic-information-queries-detailed-day-18\/#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 18"}]},{"@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\/1041","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=1041"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/posts\/1041\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/media?parent=1041"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/categories?post=1041"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/glenn\/wp-json\/wp\/v2\/tags?post=1041"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}