{"id":487,"date":"2012-05-11T02:08:00","date_gmt":"2012-05-11T02:08:00","guid":{"rendered":"\/blogs\/paul\/post\/Understanding-data-vs-log-usage-in-tempdb.aspx"},"modified":"2017-04-13T12:47:43","modified_gmt":"2017-04-13T19:47:43","slug":"understanding-data-vs-log-usage-for-spills-in-tempdb","status":"publish","type":"post","link":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/","title":{"rendered":"Understanding data vs log usage for spills in tempdb"},"content":{"rendered":"

\nEarlier this morning I noticed a discussion on the SQL MCM distribution list (that all the original MCM instructors are part of) that was trying to make sense of a huge disparity between tempdb data file usage and log file usage. I explained the answer and thought I'd share it with you all too. <\/font>\n<\/p>\n

\nThe situation was a tempdb where the data files grew from 30GB to 120GB, running out of space on the disk, but the tempdb log file did not grow at all from its initial size of 1GB! How could that be? <\/font>\n<\/p>\n

\nOne of the things to consider about tempdb is that logging in tempdb is ultra-efficient. Log records for updates in tempdb, for instance, only log the before image of the data instead of logging both before and after images. There is no need to log the after image – as that is only used for the REDO portion of crash recovery. As tempdb never gets crash-recovered, REDO never occurs. The before image *is* necessary, however, because transactions can be rolled back in tempdb, just like other databases, and so the before image of an update must be available to be able to successfully roll back the update. <\/font>\n<\/p>\n

\nGetting to the question though, I can easily explain the observed behavior by considering how a sort spill happens with tempdb. <\/font>\n<\/p>\n

\nI can simulate this using a gnarly query on the SalesDB<\/font> database you can download from our <\/font>resources page<\/font><\/a> (see the top of the page for the sample databases to download). <\/font>\n<\/p>\n

\nI'm going to do a join of my Sales<\/font> and Products<\/font> tables and then sort the multi-million row result set by product name: <\/font>\n<\/p>\n

\n

\n\tSELECT S.*, P.* from Sales S
\n\tJOIN Products P ON P.ProductID = S.ProductID
\n\tORDER BY P.Name;
\n\tGO  <\/font>\n\t<\/p>\n<\/blockquote>\n

\nThe query plan for this is (using <\/font>Plan Explorer<\/font><\/a>): <\/font>\n<\/p>\n

\n\"\"<\/font>\n<\/p>\n

\nI know that the sort is going to spill out of memory into tempdb in this case. First I checkpoint tempdb (to clear out the log) and then after running the query, I can analyze the transaction log for tempdb.<\/font>\n<\/p>\n

\nLooking at the operation in the log:<\/font>\n<\/p>\n

\n

\n\tSELECT
\n\t     [Current LSN],
\n\t     [Operation],
\n\t     [Context],
\n\t     [Transaction ID],
\n\t     [Log Record Length],
\n\t     [Description]
\n\tFROM fn_dblog (null, null);
\n\tGO<\/p>\n

\tCurrent LSN            Operation       Context  Transaction ID Len Description
\n\t———————- ————— ——– ————– — ———————————————————-
\n\t000000c0:00000077:0001 LOP_BEGIN_XACT  LCX_NULL 0000:00005e4d  120 sort_init;<snip>
\n\t000000c0:00000077:0002 LOP_BEGIN_XACT  LCX_NULL 0000:00005e4e  132 FirstPage Alloc;<snip>
\n\t000000c0:00000077:0003 LOP_SET_BITS    LCX_GAM  0000:00005e4e  60  Allocated 1 extent(s) starting at page 0001:0000aa48
\n\t000000c0:00000077:0004 LOP_MODIFY_ROW  LCX_PFS  0000:00005e4e  88  Allocated 0001:0000aa48;Allocated 0001:0000aa49;
\n\t000000c0:00000077:0005 LOP_MODIFY_ROW  LCX_PFS  0000:00005e4d  80  Allocated 0001:00000123
\n\t000000c0:00000077:0006 LOP_FORMAT_PAGE LCX_IAM  0000:00005e4d  84               
\n\t000000c0:00000077:0007 LOP_SET_BITS    LCX_IAM  0000:00005e4e  60               
\n\t000000c0:00000077:0009 LOP_COMMIT_XACT LCX_NULL 0000:00005e4e  52               
\n\t000000c0:00000077:000a LOP_BEGIN_XACT  LCX_NULL 0000:00005e4f  128 soAllocExtents;<snip>
\n\t000000c0:00000077:000b LOP_SET_BITS    LCX_GAM  0000:00005e4f  60  Allocated 1 extent(s) starting at page 0001:0000aa50
\n\t000000c0:00000077:000c LOP_MODIFY_ROW  LCX_PFS  0000:00005e4f  88  Allocated 0001:0000aa50;Allocated 0001:0000aa51;<snip>
\n\t000000c0:00000077:000d LOP_SET_BITS    LCX_IAM  0000:00005e4f  60               
\n\t000000c0:00000077:000e LOP_SET_BITS    LCX_GAM  0000:00005e4f  60  Allocated 1 extent(s) starting at page 0001:0000aa58
\n\t000000c0:00000077:000f LOP_MODIFY_ROW  LCX_PFS  0000:00005e4f  88  Allocated 0001:0000aa58;Allocated 0001:0000aa59;<snip>
\n\t000000c0:00000077:0010 LOP_SET_BITS    LCX_IAM  0000:00005e4f  60               
\n\t000000c0:00000077:0011 LOP_SET_BITS    LCX_GAM  0000:00005e4f  60  Allocated 1 extent(s) starting at page 0001:0000aa60
\n\t000000c0:00000077:0012 LOP_MODIFY_ROW  LCX_PFS  0000:00005e4f  88  Allocated 0001:0000aa60;Allocated 0001:0000aa61;<snip>
\n\t000000c0:00000077:0013 LOP_SET_BITS    LCX_IAM  0000:00005e4f  60               
\n\t000000c0:00000077:0014 LOP_COMMIT_XACT LCX_NULL 0000:00005e4f  52               
\n\t000000c0:00000077:0015 LOP_BEGIN_XACT  LCX_NULL 0000:00005e50  128 soAllocExtents;<snip>
\n\t000000c0:00000077:0016 LOP_SET_BITS    LCX_GAM  0000:00005e50  60  Allocated 1 extent(s) starting at page 0001:0000aa68
\n\t000000c0:00000077:0017 LOP_MODIFY_ROW  LCX_PFS  0000:00005e50  88  Allocated 0001:0000aa68;Allocated 0001:0000aa69;<snip>
\n\t000000c0:00000077:0018 LOP_SET_BITS    LCX_IAM  0000:00005e50  60               
\n\t000000c0:00000077:0019 LOP_SET_BITS    LCX_GAM  0000:00005e50  60  Allocated 1 extent(s) starting at page 0001:0000aa70
\n\t000000c0:00000077:001a LOP_MODIFY_ROW  LCX_PFS  0000:00005e50  88  Allocated 0001:0000aa70;Allocated 0001:0000aa71;<snip>
\n\t000000c0:00000077:001b LOP_SET_BITS    LCX_IAM  0000:00005e50  60               
\n\t000000c0:00000077:001c LOP_SET_BITS    LCX_GAM  0000:00005e50  60  Allocated 1 extent(s) starting at page 0001:0000aa78
\n\t000000c0:00000077:001d LOP_MODIFY_ROW  LCX_PFS  0000:00005e50  88  Allocated 0001:0000aa78;Allocated 0001:0000aa79;<snip>
\n\t000000c0:00000077:001e LOP_SET_BITS    LCX_IAM  0000:00005e50  60               
\n\t000000c0:00000077:001f LOP_SET_BITS    LCX_GAM  0000:00005e50  60  Allocated 1 extent(s) starting at page 0001:0000aa80
\n\t000000c0:00000077:0020 LOP_MODIFY_ROW  LCX_PFS  0000:00005e50  88  Allocated 0001:0000aa80;Allocated 0001:0000aa81;<snip>
\n\t000000c0:00000077:0021 LOP_SET_BITS    LCX_IAM  0000:00005e50  60               
\n\t000000c0:00000077:0022 LOP_COMMIT_XACT LCX_NULL 0000:00005e50  52               
\n\t000000c0:00000077:0023 LOP_BEGIN_XACT  LCX_NULL 0000:00005e51  128 soAllocExtents;<snip><\/font>\n\t<\/p>\n

\n\t<snip><\/font>\n\t<\/p>\n

\n\t000000cd:00000088:01d3 LOP_SET_BITS    LCX_GAM  0000:000078fc  60  Deallocated 1 extent(s) starting at page 0001:00010e50
\n\t000000cd:00000088:01d4 LOP_COMMIT_XACT LCX_NULL 0000:000078fc  52               
\n\t000000cd:00000088:01d5 LOP_BEGIN_XACT  LCX_NULL 0000:000078fd  140 ExtentDeallocForSort;<snip>
\n\t000000cd:00000088:01d6 LOP_SET_BITS    LCX_IAM  0000:000078fd  60               
\n\t000000cd:00000088:01d7 LOP_MODIFY_ROW  LCX_PFS  0000:000078fd  88  Deallocated 0001:00010e68;Deallocated 0001:00010e69;<snip>
\n\t000000cd:00000088:01d8 LOP_SET_BITS    LCX_GAM  0000:000078fd  60  Deallocated 1 extent(s) starting at page 0001:00010e68
\n\t000000cd:00000088:01d9 LOP_COMMIT_XACT LCX_NULL 0000:000078fd  52               
\n\t000000cd:00000088:01da LOP_MODIFY_ROW  LCX_PFS  0000:00005fac  80  Deallocated 0001:00000109
\n\t000000cd:00000088:01db LOP_SET_BITS    LCX_SGAM 0000:00005fac  60  ClearBit 0001:00000108
\n\t000000cd:00000088:01dc LOP_SET_BITS    LCX_GAM  0000:00005fac  60  Deallocated 1 extent(s) starting at page 0001:00000108
\n\t000000cd:00000088:01dd LOP_COMMIT_XACT LCX_NULL 0000:00005fac  52                <\/font>\n\t<\/p>\n<\/blockquote>\n

\n(I snipped out a few extraneous log records plus the 6 extra 'Allocated' and 'Deallocated' for each of the PFS row modifications.) <\/font>\n<\/p>\n

\nOne of the things I notice is that the sort spill space is allocated in extents, and almost the entire sort – from initialization, through allocating all the extents, to deallocating them – is contained in a few very large transactions. But the transactions aren't actually that large.<\/font>\n<\/p>\n

\nLook at the soAllocExtents<\/font> transaction with Transaction ID<\/font> 00005e50. It's allocating 4 extents – i.e. 256KB – in a single system transction (4 x mark an extent as unavailable in the GAM, 4 x bulk set the 8 PFS bytes for the 8 pages in the extent, 4 x mark an extent allocated in the IAM). The total size of the log records for this transaction is 1012 bytes. (The first soAllocExtents<\/font> system transaction only allocates 3 extents, all the others allocate 4 extents.)<\/font>\n<\/p>\n

\nWhen the sort ends, the extents are deallocated one-at-a-time in system transactions called ExtentDeallocForSort<\/font>. An example is the transaction with Transaction ID<\/font> 000078fd. It generates log records totalling 400 bytes. This means each 256KB takes 4 x 400 = 1600 bytes to deallocate.<\/font>\n<\/p>\n

\nCombining the allocation and deallocation operations, each 256KB of the sort that spills into tempdb generates 2612 bytes of log records.<\/font>\n<\/p>\n

\nNow let's consider the original behavior that I explained. If the 90GB was all sort space:<\/font>\n<\/p>\n

    \n
  • \n
    \n\t90GB is 90 x 1024 x 1024 = 94371840KB, which is 94371840 \/ 256 = 368640 x 256KB chunks.<\/font>\n\t<\/div>\n<\/li>\n
  • \n
    \n\tEach 256KB chunk takes 2612 bytes to allocate and deallocate, so our 90GB would take 368640 x 2612 = 962887680 bytes of log, which is 962887680 \/ 1024 \/ 1024 = ~918MB of log.<\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n

    \nAnd this would explain the observed behavior. 90GB of tempdb space can be allocated and used for a sort spill with roughly 918MB of transaction log, give or take a bit from my rough calculations.<\/font>\n<\/p>\n

    \nTempdb logs things very efficiently – especially things that spill out of memory. The next stop in debugging such a problem would be regularly capturing the output of sys.dm_db_task_space_usage<\/font> to figure out who is using all the space and then digging in from there.<\/font>\n<\/p>\n

    \nHope this helps explain things!<\/font><\/p>\n","protected":false},"excerpt":{"rendered":"

    Earlier this morning I noticed a discussion on the SQL MCM distribution list (that all the original MCM instructors are part of) that was trying to make sense of a huge disparity between tempdb data file usage and log file usage. I explained the answer and thought I'd share it with you all too. The […]<\/p>\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[66,93,98],"tags":[],"class_list":["post-487","post","type-post","status-publish","format-standard","hentry","category-performance-tuning","category-tempdb","category-transaction-log"],"yoast_head":"\nUnderstanding data vs log usage for spills in tempdb - Paul S. Randal<\/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\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Understanding data vs log usage for spills in tempdb - Paul S. Randal\" \/>\n<meta property=\"og:description\" content=\"Earlier this morning I noticed a discussion on the SQL MCM distribution list (that all the original MCM instructors are part of) that was trying to make sense of a huge disparity between tempdb data file usage and log file usage. I explained the answer and thought I'd share it with you all too. The […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/\" \/>\n<meta property=\"og:site_name\" content=\"Paul S. Randal\" \/>\n<meta property=\"article:published_time\" content=\"2012-05-11T02:08:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2017-04-13T19:47:43+00:00\" \/>\n<meta name=\"author\" content=\"Paul Randal\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Paul Randal\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/\",\"name\":\"Understanding data vs log usage for spills in tempdb - Paul S. Randal\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\"},\"datePublished\":\"2012-05-11T02:08:00+00:00\",\"dateModified\":\"2017-04-13T19:47:43+00:00\",\"author\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Understanding data vs log usage for spills in tempdb\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\",\"name\":\"Paul S. Randal\",\"description\":\"In Recovery...\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/?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\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\",\"name\":\"Paul Randal\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"caption\":\"Paul Randal\"},\"sameAs\":[\"http:\/\/3.209.169.194\/blogs\/paul\"],\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Understanding data vs log usage for spills in tempdb - Paul S. Randal","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\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/","og_locale":"en_US","og_type":"article","og_title":"Understanding data vs log usage for spills in tempdb - Paul S. Randal","og_description":"Earlier this morning I noticed a discussion on the SQL MCM distribution list (that all the original MCM instructors are part of) that was trying to make sense of a huge disparity between tempdb data file usage and log file usage. I explained the answer and thought I'd share it with you all too. The […]","og_url":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/","og_site_name":"Paul S. Randal","article_published_time":"2012-05-11T02:08:00+00:00","article_modified_time":"2017-04-13T19:47:43+00:00","author":"Paul Randal","twitter_misc":{"Written by":"Paul Randal","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/","name":"Understanding data vs log usage for spills in tempdb - Paul S. Randal","isPartOf":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website"},"datePublished":"2012-05-11T02:08:00+00:00","dateModified":"2017-04-13T19:47:43+00:00","author":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce"},"breadcrumb":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/understanding-data-vs-log-usage-for-spills-in-tempdb\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.sqlskills.com\/blogs\/paul\/"},{"@type":"ListItem","position":2,"name":"Understanding data vs log usage for spills in tempdb"}]},{"@type":"WebSite","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/","name":"Paul S. Randal","description":"In Recovery...","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.sqlskills.com\/blogs\/paul\/?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\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce","name":"Paul Randal","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","caption":"Paul Randal"},"sameAs":["http:\/\/3.209.169.194\/blogs\/paul"],"url":"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/"}]}},"_links":{"self":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/487","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/comments?post=487"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/487\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/media?parent=487"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/categories?post=487"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/tags?post=487"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}