{"id":2003,"date":"2013-09-19T11:00:00","date_gmt":"2013-09-19T18:00:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/dataplatforminsider\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/"},"modified":"2024-01-22T22:49:10","modified_gmt":"2024-01-23T06:49:10","slug":"in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber","status":"publish","type":"post","link":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/","title":{"rendered":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber"},"content":{"rendered":"

As the SQL Server 2014 In-memory OLTP team began working with customers we recognized some common design patterns where the In-memory OLTP engine was a great fit. The intent of this blog is to call out one of those architectures which we call: High data input rate\/Shock Absorber <\/i><\/b>and how implementing SQL Server 2014 In-memory OLTP can help improve the performance of applications with this scenario.<\/span><\/p>\n

What are some characteristics of this architecture?<\/strong><\/span><\/i><\/p>\n

A common application pattern we have experienced in working with customers is characterized by the need for the database to ingest a very high input rate of data. There are a wide variety of patterns, where the number of sources of data, frequency in which the data is input (burst or steady stream) and requirements around the amount of data input varies. However, the common characteristic is the need to handle either spikes or a constant rate in the incoming workload which may significantly exceed the capabilities of a classic RDBMS. We call this \u201cShock Absorber\u201d as the scenario includes one or a few tables which are able to \u201cabsorb\u201d this input rate (which is the \u201cshock\u201d to the system). Typically this part of the scenario may be a piece of a larger application architecture involving other tables, data and queries. However, in many cases this ingestion rate has become a primary bottleneck within the application. <\/span><\/p>\n

There are also a number of applications which have exhibited more of an ETL scenario where the data might not just be inserted, but updates, deletes (and data transformation) may occur. In this case a common pattern would be to have a \u201cstaging\u201d table to handle the initial load or loading directly into the end-table and scaling the writes and reads concurrently. The bottleneck around ingesting the data remains the same.<\/span><\/p>\n

There are a wide variety of business solutions which we have found with this type of pattern and some intriguing scenarios where implementing In-memory OLTP can improve the overall application performance significantly.<\/span><\/p>\n

How can In-memory OLTP help?<\/strong><\/span><\/i><\/p>\n

These scenarios can benefit from In-memory OLTP in a number of ways. First, in a number of cases the \u201cshock\u201d or overflow of the input workload is bottlenecked on latching or locking contention within the table structure. In some cases, people will architect around last page insert scenarios via reverse indexes or secondary indexing implementations. However they can only scale to a point and can lead to other consequences. With memory-optimized tables all the latching and lock contention is eliminated due to the way data is accessed in-memory and row-versioned. This can provide for much greater scale in particular when running into these contention points.<\/span><\/p>\n

Another common bottleneck in these scenarios is due to the overhead of the log writes which can extend the time it takes to complete a transaction. This may be a bottleneck around IO capacity of the disk or just the amount of logging as an overhead. The advantages of memory-optimized tables in this case would include: <\/span><\/p>\n

    \n
  1. The ability to minimize IO\u2019s by creating the memory-optimized tables as SCHEMA_ONLY. <\/span><\/li>\n
  2. Decrease in the number of times the log is updated for memory-optimized tables as compared to disk based objects (i.e. no index logging).<\/span><\/li>\n<\/ol>\n

    Furthermore, in cases where the transaction throughput into the database is unable to \u201ckeep-up\u201d with the input and additional scale (i.e. adding additional clients or threads) are not able to help or be easily implemented, native compiled stored procedures can help improve the latency characteristics of the T-SQL execution. Other content may address this further, but it is important to call-out that the more performance critical code one can place into the native compiled stored procedure and the In-memory OLTP engine in general, the more chance you have to improve the overall execution performance. <\/span><\/p>\n

    My database doesn\u2019t all \u201cfit\u201d in memory<\/strong><\/span><\/i><\/p>\n

    In many scenarios where memory-optimized tables and native compiled stored procedures can be utilized to target the \u201chot\u201d OLTP dataset where the bottleneck is exhibited there may be other data which is needed in the database but not necessarily desired to be stored in the In-memory OLTP engine. Some examples would include 1. A need for archive data 2. The query workload pattern is not OLTP and\/or different indexing structures are required to satisfy the workload or 3. Physical memory limits would require some tables to be disk-based (standard b-tree) for larger datasets. <\/span><\/p>\n

    As In-memory OLTP is integrated into SQL Server and you can have both memory-optimized tables and disk-based tables in the same database, separating the data storage and retrieval mechanisms between these table structures is also a common pattern. Typically a user created \u201cbackground\u201d process can execute, for example, on a timed basis, to move data from the memory-optimized table to the disk based table and remove that data from the current memory-optimized table (or potentially just purge). <\/span><\/p>\n

    Ok, but how much does it really help?<\/strong><\/span><\/i><\/p>\n

    Great question! As this is a common scenario we have worked with customers doing testing and here are some early results:<\/span><\/p>\n

      \n
    1. \nEdgenet had business requirements to handle much higher data input and gain near real-time input in their SaaS implementation. With In-memory OLTP they were able to gain 7x throughput performance<\/b> on their ETL like input, using durable tables. For further information reference: <\/span>http:\/\/www.microsoft.com\/casestudies\/Case_Study_Detail.aspx?CaseStudyID=710000003026<\/span><\/a>\n<\/li>\n
    2. We worked with another customer who would collect data from a number of servers in their environment for analysis. At times the data input rate would exceed their capacity due to latching. Implementing In-memory OLTP has provided them with gains of<\/b> 3x <\/b>providing them with capacity to handle the spikes in their workload and deliver the data to consumers without input delays.<\/span><\/li>\n
    3. \nA third case is discussed by Ferranti in their case study <\/span>here<\/span><\/a>.<\/span>\n<\/li>\n<\/ol>\n

      So, do you have scenarios you would like to use a relational database for, but running into issues with regards to the amount of data you can ingest into tables? Consider SQL Server In-memory OLTP engine for meeting your transaction volume and application performance with the database in the critical path. <\/span><\/p>\n

      Interested in more patterns where we have seen success with SQL Server 2014 In-memory OLTP? Stay tuned for a follow-up whitepaper which will include more scenarios and considerations to help you migrate to SQL Server 2014 In-memory OLTP.<\/span><\/p>\n

      Download SQL Server CTP1<\/a> and get started today, or see more blogs in the series introduction and index here<\/a>!<\/p>\n","protected":false},"excerpt":{"rendered":"

      As the SQL Server 2014 In-memory OLTP team began working with customers we recognized some common design patterns where the In-memory OLTP engine was a great fit.<\/p>\n","protected":false},"author":1457,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ep_exclude_from_search":false,"_classifai_error":"","_classifai_text_to_speech_error":"","footnotes":""},"post_tag":[],"product":[],"content-type":[2424],"topic":[],"coauthors":[2487],"class_list":["post-2003","post","type-post","status-publish","format-standard","hentry","content-type-best-practices"],"yoast_head":"\nIn-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog<\/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.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog\" \/>\n<meta property=\"og:description\" content=\"As the SQL Server 2014 In-memory OLTP team began working with customers we recognized some common design patterns where the In-memory OLTP engine was a great fit.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\" \/>\n<meta property=\"og:site_name\" content=\"Microsoft SQL Server Blog\" \/>\n<meta property=\"article:publisher\" content=\"http:\/\/www.facebook.com\/sqlserver\" \/>\n<meta property=\"article:published_time\" content=\"2013-09-19T18:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-01-23T06:49:10+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/08\/cropped-microsoft_logo_element.png\" \/>\n\t<meta property=\"og:image:width\" content=\"512\" \/>\n\t<meta property=\"og:image:height\" content=\"512\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"SQL Server Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@SQLServer\" \/>\n<meta name=\"twitter:site\" content=\"@SQLServer\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"SQL Server Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 min read\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\"},\"author\":[{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/author\/sql-server-team\/\",\"@type\":\"Person\",\"@name\":\"SQL Server Team\"}],\"headline\":\"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber\",\"datePublished\":\"2013-09-19T18:00:00+00:00\",\"dateModified\":\"2024-01-23T06:49:10+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\"},\"wordCount\":1078,\"commentCount\":5,\"publisher\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\",\"url\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\",\"name\":\"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog\",\"isPartOf\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#website\"},\"datePublished\":\"2013-09-19T18:00:00+00:00\",\"dateModified\":\"2024-01-23T06:49:10+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#website\",\"url\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/\",\"name\":\"Microsoft SQL Server Blog\",\"description\":\"Official News from Microsoft\u2019s Information Platform\",\"publisher\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization\",\"name\":\"Microsoft SQL Server Blog\",\"url\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png\",\"contentUrl\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png\",\"width\":259,\"height\":194,\"caption\":\"Microsoft SQL Server Blog\"},\"image\":{\"@id\":\"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"http:\/\/www.facebook.com\/sqlserver\",\"https:\/\/x.com\/SQLServer\",\"https:\/\/www.youtube.com\/user\/MSCloudOS\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog","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.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/","og_locale":"en_US","og_type":"article","og_title":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog","og_description":"As the SQL Server 2014 In-memory OLTP team began working with customers we recognized some common design patterns where the In-memory OLTP engine was a great fit.","og_url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/","og_site_name":"Microsoft SQL Server Blog","article_publisher":"http:\/\/www.facebook.com\/sqlserver","article_published_time":"2013-09-19T18:00:00+00:00","article_modified_time":"2024-01-23T06:49:10+00:00","og_image":[{"width":512,"height":512,"url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/08\/cropped-microsoft_logo_element.png","type":"image\/png"}],"author":"SQL Server Team","twitter_card":"summary_large_image","twitter_creator":"@SQLServer","twitter_site":"@SQLServer","twitter_misc":{"Written by":"SQL Server Team","Est. reading time":"4 min read"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#article","isPartOf":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/"},"author":[{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/author\/sql-server-team\/","@type":"Person","@name":"SQL Server Team"}],"headline":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber","datePublished":"2013-09-19T18:00:00+00:00","dateModified":"2024-01-23T06:49:10+00:00","mainEntityOfPage":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/"},"wordCount":1078,"commentCount":5,"publisher":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization"},"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/","url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/","name":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber - Microsoft SQL Server Blog","isPartOf":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#website"},"datePublished":"2013-09-19T18:00:00+00:00","dateModified":"2024-01-23T06:49:10+00:00","breadcrumb":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/2013\/09\/19\/in-memory-oltp-common-design-pattern-high-data-input-rateshock-absorber\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/"},{"@type":"ListItem","position":2,"name":"In-Memory OLTP Common Design Pattern \u2013 High Data Input Rate\/Shock Absorber"}]},{"@type":"WebSite","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#website","url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/","name":"Microsoft SQL Server Blog","description":"Official News from Microsoft\u2019s Information Platform","publisher":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#organization","name":"Microsoft SQL Server Blog","url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png","contentUrl":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png","width":259,"height":194,"caption":"Microsoft SQL Server Blog"},"image":{"@id":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/"},"sameAs":["http:\/\/www.facebook.com\/sqlserver","https:\/\/x.com\/SQLServer","https:\/\/www.youtube.com\/user\/MSCloudOS"]}]}},"msxcm_display_generated_audio":false,"msxcm_animated_featured_image":null,"_links":{"self":[{"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts\/2003","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/users\/1457"}],"replies":[{"embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/comments?post=2003"}],"version-history":[{"count":0,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts\/2003\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/media?parent=2003"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/post_tag?post=2003"},{"taxonomy":"product","embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/product?post=2003"},{"taxonomy":"content-type","embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/content-type?post=2003"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/topic?post=2003"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.microsoft.com\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/coauthors?post=2003"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}