{"id":2193,"date":"2013-07-22T10:00:00","date_gmt":"2013-07-22T17:00:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/dataplatforminsider\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/"},"modified":"2024-01-22T22:49:13","modified_gmt":"2024-01-23T06:49:13","slug":"architectural-overview-of-sql-server-2014s-in-memory-oltp-technology","status":"publish","type":"post","link":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/","title":{"rendered":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology"},"content":{"rendered":"

At the SQL PASS conference last November, we announced the In-memory OLTP database technology (code-named \u201cHekaton\u201d) for a future SQL Server release. Microsoft\u2019s technical fellow Dave Campbell\u2019s blog<\/a> provided a broad overview of the motivation and design principles behind the technology and discussed four architectural principles: (1) optimize for main memory data access, (2) Accelerate business logic processing, (3) Provide frictionless scale-up, (4) Built-in to SQL Server. This post will focus on the components behind the first three principles \u2013 both the motivation for the new components and how they achieve efficiency and scaling integral to the first three principles.<\/p>\n

\"Architectural<\/a><\/span>The new In-Memory OLTP architecture achieves much of its performance by executing stored procedures more efficiently. This focus on efficiency is critical as individual CPU cores are not getting significantly faster<\/a> and there is not much opportunity for multi-core parallelism within OLTP stored procedures that access relatively few rows. The inescapable conclusion, supported by research<\/a> and SQL\u2019s performance engineering team, is that to achieve dramatic improvements in performance the database system code must get more dramatically more efficient.<\/p>\n

\u00a0But, what areas of the database engine need to be more efficient? To answer that question we have to understand where time is spent in the database system. The component stack diagram on the left shows, very roughly, the percentage of time spent in various components in an OLTP workload running on previous versions of SQL Server. The green boxes correspond to what is frequently called the relational engine<\/em> while the blue boxes correspond to the storage engine<\/em>.<\/p>\n

\u00a0The first observation from this diagram is that speeding up any one area will not lead to factors better performance. Second, even building an infinitely fast main-memory engine (effectively a streamlined storage engine) will at most get you twice the efficiency, since there is significant time spent in query and stored procedure processing. Adding to the challenge is the fact that SQL Server has been continuously optimized with each successive release.<\/p>\n

\u00a0Rather than change the existing SQL Server components that are already highly optimized for what they do best, the approach we too was to focus on new streamlined components that optimize for OLTP workload patterns and the reality that the hottest, most performance critical, data always reside in memory. Then, incorporate these components directly into SQL Server.<\/p>\n

\u00a0This focus on efficiency leads aligns directly to two key architectural components: a memory-optimized engine and a compiler that converts stored procedures and queries into machine code running against the memory-optimized engine.<\/p>\n

Memory-Optimized Engine<\/h3>\n

\u00a0The memory optimized engine manages all aspects of indexing, transactions, checkpoint (i.e. storage) and recovery for tables denoted as memory_optimized<\/a> and as such it takes the place of core pieces of SQL Server\u2019s storage engine for these tables.<\/p>\n

In Dave Campbell\u2019s blog<\/a> post he pointed out that the engine achieves much of its performance gains by optimizing around its data always residing in memory. More generally, one might say that it achieves its performance by taking an \u201coptimistic\u201d approach and streamlining and optimizing for common cases and eliminating rare situations or just accepting that rare situations will not be as fast. Assuming that data resides in memory is indeed optimistic, but it\u2019s also the reality for high-performance scenarios. For example, even in 2008 Facebook was deploying 28 terabytes of main-memory to accelerate databases<\/a>.<\/p>\n

This optimistic approach shows up in more subtle ways. For example SQL Server\u2019s storage engine generates a transaction log record for every update to any table or index. This log record contains information not only for redoing the operation but also for undoing it and the log record must be placed in a log buffer immediately (a highly contentious operation<\/a>) \u2013 this is all necessary because the storage engine is operating around the pessimistic assumption that the buffer page containing the recently updated record may be checkpointed or forced to disk before the updating transaction has committed. In reality, this is very unlikely for typical OLTP transactions and buffer pools of reasonable size. Instead, the engine takes an optimistic approach and simply doesn\u2019t allow uncommitted changes to be checkpointed or flushed to disk and therefore doesn\u2019t need to log undo information for these changes nor push them into log buffers aggressively. Instead, for short transactions, it generates a single log record describing the transaction when the transaction commits.<\/p>\n

One of the most significant areas of optimism in in the engine architecture is based around optimistic concurrency control where the engine is optimized around transactions that don\u2019t conflict. Multi-versioning eliminates many potential conflicts between transactions and the rest are handled by rolling back one of the conflicting transactions rather than blocking.\u00a0<\/p>\n

This avoidance of blocking is central to the engine design and goes beyond transaction concurrency. The proliferation of processor cores requires that database engines be highly tuned for running large numbers of concurrent transactions. While SQL Server scales very well for many OLTP workloads, there are cases, such as contention on the tail of an index, where some applications encounter scaling limitations. The engine design eliminates such contention points by avoiding any latches or spinlocks in any performance critical areas and uses multi-version optimistic concurrency control to eliminate the contention and overhead of locking<\/a>. The combination of optimistic concurrency control, multi-versioning and latch-free data structures results in a system where threads execute without stalling or waiting. This is critical because the blocking implies context switches which are very expensive relative to the efficiency that engine operates at. In fact in the earlier diagram, the lower gray box partially accounts for this context switch time as \u201cthread management\u201d overhead.<\/p>\n

Stored Procedure Compiler<\/h3>\n

As noted earlier, a fast engine deals with less than half the cost of executing an OLTP transaction. The cost of interpreting T-SQL stored procedures and their query plans is also quite significant. For an OLTP workload the primary goal is to support efficient execution of compile-once-and-execute-many-times workloads as opposed to optimizing the execution of ad hoc queries. This is where the stored procedure compiler comes into play. It transforms T-SQL stored procedures (marked as native_compiled<\/a>) including their queries into highly customized native code. The compiler reuses much of the SQL Server T-SQL language stack including the metadata, parser, name resolution, type derivation, and query optimizer. This tight integration helps achieve syntactic and semantic equivalence with the existing SQL Server T-SQL language. The output of the stored procedure compiler is C code and the compiler leverages Microsoft\u2019s Visual C\/C++ compiler to convert the C code into machine code.<\/p>\n

The efficiency of the resulting code is the result of many optimizations. Most of these are related to having specialized code generated rather than executing a general purpose interpreter. In other words the system pushes work to compilation time in order to further optimize execution time. Other optimizations are also done. For example, the generated code can take advantage of properties of the memory-optimized engine such as the fact that row versions are immutable. Because of this the generated code is not obligated to make copies of rows and instead can use direct pointers to the live database rows in memory.<\/p>\n

Conclusion<\/h3>\n

The end result of the main_memory engine and stored procedure compiler is stored procedures and queries that execute with 10x-40x fewer instructions and processor cycles compared to regular SQL Server running on in-memory data. There is other computation in the system that is outside the scope of the generated code and the engine, such as client server communication and transaction log processing, that contributed to execution time and thus any particular workload will see less of a speedup. We intend to address these areas in future releases.<\/p>\n

Of course fast and scalable components alone don\u2019t make a database product \u2013 customers expect security, high-availability, administration tools, rich programming languages, and more. The in-memory OLTP system achieves this by integrating its highly optimized components into SQL Server in a way that leverages what customers know and expect from SQL Server and yet still unleashes the components raw performance. That\u2019s a topic for another post.<\/p>\n

For a more in-depth understanding of the components discussed here and their integration with SQL Server, see our recent SIGMOD 2013 article<\/a>, download SQL Server 2014 CTP1<\/a>, or see more blogs in the series introduction and index here<\/span><\/a>!<\/p>\n

\u00a0<\/p>\n","protected":false},"excerpt":{"rendered":"

At the SQL PASS conference last November, we announced the In-memory OLTP database technology (code-named \u201cHekaton\u201d) for a future SQL Server release.<\/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":[2448],"topic":[],"coauthors":[2487],"class_list":["post-2193","post","type-post","status-publish","format-standard","hentry","content-type-updates","review-flag-1593580427-503","review-flag-1593580419-556","review-flag-1-1593580431-15","review-flag-2-1593580436-981","review-flag-3-1593580441-293","review-flag-4-1593580446-456","review-flag-alway-1593580309-407","review-flag-free-1593619513-128","review-flag-new-1593580247-437"],"yoast_head":"\nArchitectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - 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:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - Microsoft SQL Server Blog\" \/>\n<meta property=\"og:description\" content=\"At the SQL PASS conference last November, we announced the In-memory OLTP database technology (code-named \u201cHekaton\u201d) for a future SQL Server release.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\" \/>\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-07-22T17:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-01-23T06:49:13+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.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=\"6 min read\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\"},\"author\":[{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/author\/sql-server-team\/\",\"@type\":\"Person\",\"@name\":\"SQL Server Team\"}],\"headline\":\"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology\",\"datePublished\":\"2013-07-22T17:00:00+00:00\",\"dateModified\":\"2024-01-23T06:49:13+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\"},\"wordCount\":1390,\"commentCount\":8,\"publisher\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\",\"url\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\",\"name\":\"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - Microsoft SQL Server Blog\",\"isPartOf\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png\",\"datePublished\":\"2013-07-22T17:00:00+00:00\",\"dateModified\":\"2024-01-23T06:49:13+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage\",\"url\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png\",\"contentUrl\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#website\",\"url\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/\",\"name\":\"Microsoft SQL Server Blog\",\"description\":\"Official News from Microsoft\u2019s Information Platform\",\"publisher\":{\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/cm-edgetun.pages.dev\/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:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization\",\"name\":\"Microsoft SQL Server Blog\",\"url\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png\",\"contentUrl\":\"https:\/\/cm-edgetun.pages.dev\/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:\/\/cm-edgetun.pages.dev\/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":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - 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:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/","og_locale":"en_US","og_type":"article","og_title":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - Microsoft SQL Server Blog","og_description":"At the SQL PASS conference last November, we announced the In-memory OLTP database technology (code-named \u201cHekaton\u201d) for a future SQL Server release.","og_url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/","og_site_name":"Microsoft SQL Server Blog","article_publisher":"http:\/\/www.facebook.com\/sqlserver","article_published_time":"2013-07-22T17:00:00+00:00","article_modified_time":"2024-01-23T06:49:13+00:00","og_image":[{"url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png","type":"","width":"","height":""}],"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":"6 min read"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#article","isPartOf":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/"},"author":[{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/author\/sql-server-team\/","@type":"Person","@name":"SQL Server Team"}],"headline":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology","datePublished":"2013-07-22T17:00:00+00:00","dateModified":"2024-01-23T06:49:13+00:00","mainEntityOfPage":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/"},"wordCount":1390,"commentCount":8,"publisher":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization"},"image":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage"},"thumbnailUrl":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png","inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/","url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/","name":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology - Microsoft SQL Server Blog","isPartOf":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage"},"image":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage"},"thumbnailUrl":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png","datePublished":"2013-07-22T17:00:00+00:00","dateModified":"2024-01-23T06:49:13+00:00","breadcrumb":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#primaryimage","url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png","contentUrl":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2018\/03\/5141.SQL-Pillar-Graph_thumb_4E902104.png"},{"@type":"BreadcrumbList","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/2013\/07\/22\/architectural-overview-of-sql-server-2014s-in-memory-oltp-technology\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/"},{"@type":"ListItem","position":2,"name":"Architectural Overview of SQL Server 2014\u2019s In-Memory OLTP Technology"}]},{"@type":"WebSite","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#website","url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/","name":"Microsoft SQL Server Blog","description":"Official News from Microsoft\u2019s Information Platform","publisher":{"@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/cm-edgetun.pages.dev\/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:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#organization","name":"Microsoft SQL Server Blog","url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-content\/uploads\/2019\/08\/Microsoft-Logo.png","contentUrl":"https:\/\/cm-edgetun.pages.dev\/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:\/\/cm-edgetun.pages.dev\/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:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts\/2193","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/users\/1457"}],"replies":[{"embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/comments?post=2193"}],"version-history":[{"count":0,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/posts\/2193\/revisions"}],"wp:attachment":[{"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/media?parent=2193"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/post_tag?post=2193"},{"taxonomy":"product","embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/product?post=2193"},{"taxonomy":"content-type","embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/content-type?post=2193"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/topic?post=2193"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/cm-edgetun.pages.dev\/en-us\/sql-server\/blog\/wp-json\/wp\/v2\/coauthors?post=2193"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}