{"id":1091,"date":"2025-07-04T10:11:58","date_gmt":"2025-07-04T15:11:58","guid":{"rendered":"https:\/\/www.sqltabletalk.com\/?p=1091"},"modified":"2025-07-07T17:36:08","modified_gmt":"2025-07-07T22:36:08","slug":"avoiding-halloween-problem-sql-server","status":"publish","type":"post","link":"https:\/\/www.sqltabletalk.com\/?p=1091","title":{"rendered":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns"},"content":{"rendered":"<p>The Halloween Problem is a classic relational database behavior that can quietly affect performance and query plans during <code>UPDATE<\/code> or <code>DELETE<\/code> operations. While SQL Server includes internal protections to prevent it, relying solely on the engine can lead to unpredictable execution plans and unnecessary overhead. Fortunately, with a few simple patterns, you can avoid the issue entirely.<\/p>\n<h2>What Is the Halloween Problem?<\/h2>\n<p>The Halloween Problem occurs when an <code>UPDATE<\/code> statement modifies a column that\u2019s part of the index used to locate the rows being updated. If SQL Server isn\u2019t careful, it might re-encounter the same row after it\u2019s been updated\u2014leading to multiple updates of the same row in a single statement.<\/p>\n<p>For example:<\/p>\n<pre><code>UPDATE Employees\nSET Salary = Salary + 10000\nWHERE Salary &lt; 80000;<\/code><\/pre>\n<p>If <code>Salary<\/code> is indexed, SQL Server might use that index to find rows. But as it updates the <code>Salary<\/code>, the row could move within the index and be picked up again.<\/p>\n<h2>How SQL Server Avoids the Halloween Problem<\/h2>\n<p>To prevent this, SQL Server inserts a Table Spool (Eager Spool) into the execution plan to avoid multiple updates to the same row. This operator materializes the qualifying rows into a temporary structure before the update begins. It ensures that even if a row\u2019s position in the index changes, it won\u2019t be reprocessed.<\/p>\n<p>But now we are left with a spool in our plan. \ud83d\ude41<\/p>\n<h2>Why Relying on Spools for Halloween Protection Can Hurt Performance<\/h2>\n<p>While SQL Server\u2019s optimizer is smart enough to detect and prevent this behavior, the protection comes at a cost:<\/p>\n<ul>\n<li>Extra memory and I\/O for the spool operation<\/li>\n<li>Less predictable execution plans<\/li>\n<li>Potential performance degradation under load<\/li>\n<\/ul>\n<h2>A Better Pattern: Materialize First, Then Update<\/h2>\n<p>To avoid this, you can rewrite your <code>UPDATE<\/code> to separate the read and write phases. Two common approaches are:<\/p>\n<p><strong>Example 1. Using a CTE<\/strong><\/p>\n<pre><code>;WITH TargetRows AS (\n    SELECT EmployeeID\n    FROM Employees\n    WHERE Salary &lt; 80000\n)\n\nUPDATE E\nSET Salary = Salary + 10000\nFROM Employees E\nJOIN TargetRows T ON E.EmployeeID = T.EmployeeID;<\/code><\/pre>\n<p><strong>Example 2. Using a Temp Table<\/strong><\/p>\n<pre><code>SELECT EmployeeID\nINTO #ToUpdate\nFROM Employees\nWHERE Salary &lt; 80000;\n\nUPDATE E\nSET Salary = Salary + 10000\nFROM Employees E\nJOIN #ToUpdate T ON E.EmployeeID = T.EmployeeID;<\/code><\/pre>\n<p>Both approaches ensure that the set of rows to be updated is materialized before the update begins, eliminating the need for Halloween protection mechanisms.<\/p>\n<p>CTEs and temp tables have their own problems, but this pattern opens up more opportunities to control batch sizes in large bulk updates. Let&#8217;s talk about that next.<\/p>\n<h2>Batch Updates to Control Locking<\/h2>\n<p>Another benefit of this pattern is that it makes batch updates easy. You can limit the number of rows updated in each batch to reduce the risk of lock escalation. This gives you fine-grained control over concurrency and resource usage.<\/p>\n<pre><code>WHILE 1 = 1\nBEGIN\n    ;WITH TargetRows AS (\n        SELECT TOP (1000) EmployeeID\n        FROM Employees\n        WHERE Salary &lt; 80000\n    )\n    UPDATE E\n    SET Salary = Salary + 10000\n    FROM Employees E\n    JOIN TargetRows T ON E.EmployeeID = T.EmployeeID;\n    IF @@ROWCOUNT = 0\n        BREAK;\nEND<\/code><\/pre>\n<p>This simple loop updates rows in batches of 1,000, avoids the Halloween \u201cfix,\u201d reduces lock escalation, and improves concurrency and performance.<\/p>\n<h2>How to Detect Halloween Protection<\/h2>\n<h3>For Developers<\/h3>\n<p>Use Actual Execution Plans in SSMS or Azure Data Studio:<\/p>\n<ul>\n<li>Look for a <strong>Table Spool (Eager Spool)<\/strong> operator.<\/li>\n<li>This could indicate SQL Server is applying Halloween Protection.<\/li>\n<\/ul>\n<h3>For DBAs and Developers<\/h3>\n<p>Use Query Store to find plans with spools:<\/p>\n<pre><code>SELECT\n    qsqt.query_sql_text,\n    CAST(REPLACE(CAST(qsp.query_plan AS NVARCHAR(MAX)), NCHAR(160), N' ') AS XML) AS query_plan_xml,\n    qsp.plan_id,\n    qsq.query_id,\n    qsp.last_execution_time\nFROM sys.query_store_plan qsp\nJOIN sys.query_store_query qsq\n    ON qsp.query_id = qsq.query_id\nJOIN sys.query_store_query_text qsqt\n    ON qsq.query_text_id = qsqt.query_text_id\nWHERE CAST(REPLACE(CAST(qsp.query_plan AS NVARCHAR(MAX)), NCHAR(160), N' ') AS XML).exist(\n    '\n    declare namespace p=\"http:\/\/schemas.microsoft.com\/sqlserver\/2004\/07\/showplan\";\n    \/\/p:RelOp[contains(@PhysicalOp, \"Spool\")]\n    '\n) = 1;<\/code><\/pre>\n<p>This helps identify queries and plans that have spools. Plug the <code>query_id<\/code> into the Query Store Tracked Queries report to see its performance over time.<\/p>\n<h2>Additional Reading<\/h2>\n<ul>\n<li><a href=\"https:\/\/en.wikipedia.org\/wiki\/Halloween_Problem\">Halloween Problem &#8211; Wikipedia<\/a><\/li>\n<li><a href=\"https:\/\/techcommunity.microsoft.com\/blog\/sqlserver\/sql-server-2025-introducing-optimized-halloween-protection\/4413454\">SQL Server 2025: introducing optimized Halloween protection | Microsoft Community Hub<\/a><\/li>\n<\/ul>\n\n\n<p><\/p>\n","protected":false},"excerpt":{"rendered":"<p>The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency. <\/p>\n","protected":false},"author":49,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[35,12,5],"tags":[583,501,581,579,4,327,39,131,52,580,582],"class_list":["post-1091","post","type-post","status-publish","format-standard","hentry","category-data-integrity","category-internals","category-performance","tag-batch-updates","tag-cte","tag-eager-spool","tag-halloween-problem","tag-internals","tag-lock-escalation","tag-performance-tuning","tag-sql-server","tag-sql-server-performance","tag-table-spool","tag-temp-table"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.1.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk<\/title>\n<meta name=\"description\" content=\"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.\" \/>\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.sqltabletalk.com\/?p=1091\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk\" \/>\n<meta property=\"og:description\" content=\"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqltabletalk.com\/?p=1091\" \/>\n<meta property=\"og:site_name\" content=\"SQL Table Talk\" \/>\n<meta property=\"article:published_time\" content=\"2025-07-04T15:11:58+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-07-07T22:36:08+00:00\" \/>\n<meta name=\"author\" content=\"Jon Russell\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jon Russell\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091\"},\"author\":{\"name\":\"Jon Russell\",\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/8f5916388cc3b793a960dea33ff1ed86\"},\"headline\":\"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns\",\"datePublished\":\"2025-07-04T15:11:58+00:00\",\"dateModified\":\"2025-07-07T22:36:08+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091\"},\"wordCount\":511,\"commentCount\":2,\"publisher\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0\"},\"keywords\":[\"Batch Updates\",\"CTE\",\"Eager Spool\",\"Halloween Problem\",\"Internals\",\"Lock Escalation\",\"performance tuning\",\"SQL Server\",\"SQL Server performance\",\"Table Spool\",\"Temp Table\"],\"articleSection\":[\"Data Integrity\",\"Internals\",\"Performance\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.sqltabletalk.com\/?p=1091#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091\",\"url\":\"https:\/\/www.sqltabletalk.com\/?p=1091\",\"name\":\"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/#website\"},\"datePublished\":\"2025-07-04T15:11:58+00:00\",\"dateModified\":\"2025-07-07T22:36:08+00:00\",\"description\":\"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqltabletalk.com\/?p=1091\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqltabletalk.com\/?p=1091#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.sqltabletalk.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.sqltabletalk.com\/#website\",\"url\":\"https:\/\/www.sqltabletalk.com\/\",\"name\":\"SQL Table Talk\",\"description\":\"Breaking Down SQL Server, One Post at a Time.\",\"publisher\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.sqltabletalk.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0\",\"name\":\"Stephen Planck\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/64181114edc3de3d99072c049bcec024f025c9536dc89fc8ff1bac58976ca81e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/64181114edc3de3d99072c049bcec024f025c9536dc89fc8ff1bac58976ca81e?s=96&d=mm&r=g\",\"caption\":\"Stephen Planck\"},\"logo\":{\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/\"},\"sameAs\":[\"https:\/\/dexterwiki.com\",\"https:\/\/www.linkedin.com\/in\/stephen-planck-4611b692?trk=people-guest_people_search-card&challengeId=AQErf8gbBmcVMwAAAYsyIsxO-0UvU8z7cHrBpZoo_n3xt9qEKpRN5B_jd_LmAMu-OfeArkQ7GDjobJ2uRoQQV35EQdh_rR6kxA&submissionId=09de7067-c335-8e17-40b8-8dc32b60ed6c&challengeSource=AgEcUCw35zpPmAAAAYsyI4vAWhJTV7Nt4vZYKc3V1qiDBpCkKgUvtlOBgYXcE84&challegeType=AgE_wZiTT09IAQAAAYsyI4vDmNvbZIYe6XHju5V2bXVvM3IVxnJslgY&memberId=AgESFTkUShzs_gAAAYsyI4vGYk0Gic1uc5kB6cKOABA26Gw&recognizeDevice=AgHdSZyUSI5CEwAAAYsyI4vKd_koF9JgpsCJShT8QfbK1QMiv8SI\",\"https:\/\/www.youtube.com\/linuxmate\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/8f5916388cc3b793a960dea33ff1ed86\",\"name\":\"Jon Russell\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/f35049bc3903cae9c596247b2dfe95c0d9b003dd0c758b9690cc00544216aa7c?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/f35049bc3903cae9c596247b2dfe95c0d9b003dd0c758b9690cc00544216aa7c?s=96&d=mm&r=g\",\"caption\":\"Jon Russell\"},\"url\":\"https:\/\/www.sqltabletalk.com\/?author=49\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk","description":"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.","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.sqltabletalk.com\/?p=1091","og_locale":"en_US","og_type":"article","og_title":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk","og_description":"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.","og_url":"https:\/\/www.sqltabletalk.com\/?p=1091","og_site_name":"SQL Table Talk","article_published_time":"2025-07-04T15:11:58+00:00","article_modified_time":"2025-07-07T22:36:08+00:00","author":"Jon Russell","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Jon Russell","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.sqltabletalk.com\/?p=1091#article","isPartOf":{"@id":"https:\/\/www.sqltabletalk.com\/?p=1091"},"author":{"name":"Jon Russell","@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/8f5916388cc3b793a960dea33ff1ed86"},"headline":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns","datePublished":"2025-07-04T15:11:58+00:00","dateModified":"2025-07-07T22:36:08+00:00","mainEntityOfPage":{"@id":"https:\/\/www.sqltabletalk.com\/?p=1091"},"wordCount":511,"commentCount":2,"publisher":{"@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0"},"keywords":["Batch Updates","CTE","Eager Spool","Halloween Problem","Internals","Lock Escalation","performance tuning","SQL Server","SQL Server performance","Table Spool","Temp Table"],"articleSection":["Data Integrity","Internals","Performance"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.sqltabletalk.com\/?p=1091#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.sqltabletalk.com\/?p=1091","url":"https:\/\/www.sqltabletalk.com\/?p=1091","name":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns - SQL Table Talk","isPartOf":{"@id":"https:\/\/www.sqltabletalk.com\/#website"},"datePublished":"2025-07-04T15:11:58+00:00","dateModified":"2025-07-07T22:36:08+00:00","description":"The Halloween Problem can silently degrade SQL Server performance by causing rows to be updated multiple times in a single statement. This post explains how SQL Server\u2019s internal table spool (eager spool) protects against it\u2014and why that can hurt your workload under heavy load. You\u2019ll learn two simple patterns\u2014using CTEs or temp tables\u2014to materialize target rows before the update, eliminating the need for spooky spools. Finally, we cover how batch updates help control locking, reduce escalation risk, and improve concurrency.","breadcrumb":{"@id":"https:\/\/www.sqltabletalk.com\/?p=1091#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqltabletalk.com\/?p=1091"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqltabletalk.com\/?p=1091#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.sqltabletalk.com\/"},{"@type":"ListItem","position":2,"name":"Avoiding the Halloween Problem in SQL Server with Safer UPDATE Patterns"}]},{"@type":"WebSite","@id":"https:\/\/www.sqltabletalk.com\/#website","url":"https:\/\/www.sqltabletalk.com\/","name":"SQL Table Talk","description":"Breaking Down SQL Server, One Post at a Time.","publisher":{"@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.sqltabletalk.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/1947e42a9438bccd91691d8b791888e0","name":"Stephen Planck","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/64181114edc3de3d99072c049bcec024f025c9536dc89fc8ff1bac58976ca81e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/64181114edc3de3d99072c049bcec024f025c9536dc89fc8ff1bac58976ca81e?s=96&d=mm&r=g","caption":"Stephen Planck"},"logo":{"@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/"},"sameAs":["https:\/\/dexterwiki.com","https:\/\/www.linkedin.com\/in\/stephen-planck-4611b692?trk=people-guest_people_search-card&challengeId=AQErf8gbBmcVMwAAAYsyIsxO-0UvU8z7cHrBpZoo_n3xt9qEKpRN5B_jd_LmAMu-OfeArkQ7GDjobJ2uRoQQV35EQdh_rR6kxA&submissionId=09de7067-c335-8e17-40b8-8dc32b60ed6c&challengeSource=AgEcUCw35zpPmAAAAYsyI4vAWhJTV7Nt4vZYKc3V1qiDBpCkKgUvtlOBgYXcE84&challegeType=AgE_wZiTT09IAQAAAYsyI4vDmNvbZIYe6XHju5V2bXVvM3IVxnJslgY&memberId=AgESFTkUShzs_gAAAYsyI4vGYk0Gic1uc5kB6cKOABA26Gw&recognizeDevice=AgHdSZyUSI5CEwAAAYsyI4vKd_koF9JgpsCJShT8QfbK1QMiv8SI","https:\/\/www.youtube.com\/linuxmate"]},{"@type":"Person","@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/8f5916388cc3b793a960dea33ff1ed86","name":"Jon Russell","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqltabletalk.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/f35049bc3903cae9c596247b2dfe95c0d9b003dd0c758b9690cc00544216aa7c?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/f35049bc3903cae9c596247b2dfe95c0d9b003dd0c758b9690cc00544216aa7c?s=96&d=mm&r=g","caption":"Jon Russell"},"url":"https:\/\/www.sqltabletalk.com\/?author=49"}]}},"jetpack_featured_media_url":"","jetpack-related-posts":[],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/posts\/1091","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/users\/49"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1091"}],"version-history":[{"count":6,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/posts\/1091\/revisions"}],"predecessor-version":[{"id":1125,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=\/wp\/v2\/posts\/1091\/revisions\/1125"}],"wp:attachment":[{"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1091"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1091"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqltabletalk.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1091"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}