{"id":2483,"date":"2014-07-16T16:00:45","date_gmt":"2014-07-16T20:00:45","guid":{"rendered":"http:\/\/sqlity.net\/en\/?p=2483"},"modified":"2014-11-13T13:35:18","modified_gmt":"2014-11-13T18:35:18","slug":"partition-boundaries","status":"publish","type":"post","link":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/","title":{"rendered":"Partition Boundaries – Left or Right: That is the Question"},"content":{"rendered":"
\n

Introduction<\/h3>\n

\nPartition boundaries can be set to be a left range or a right range. While this is a seemingly simple decision, it starts getting complex if you are really trying to understand what those two options mean. That is not necessarily helped by the fact that different terminologies seem to contradict each other. For example, a left range builds intervals that are right side inclusive.\n<\/p>\n

Left and Right Ranges and Partition Boundaries<\/h3>\n

\nSQL Server partitioning uses two constructs, the partition scheme and the partition function. An un-partitioned table is placed in a filegroup during creation: CREATE TABLE \u2026 ON PRIMARY<\/span>. If you are creating a table that is partitioned, instead of placing it into a filegroup, you place it on a partition scheme. The partition scheme is basically a collection of storage units called partitions, each being assigned to a filegroup. (However, multiple partitions can live in the same filegroup.)\n<\/p>\n

\nThe partition function decides which row in the table ends up in which partition based on a single column. Let us assume that that column is an INT<\/span> column, say the id<\/span> column. (I am using INT<\/span> as an example. However, the concept is the same for other data types.) The partition function does not go and assigns blocks of values to partitions directly; instead, it splits the entirety of possible values into sections. An INT<\/span> can store values from -2147483648<\/span> to 2147483647<\/span>.\n<\/p>\n

\nTo split that into two sections, we have to define just one boundary. If we chose the value 3<\/span> for that first boundary, we would create two partitions: One that accepts values from -2147483648<\/span> to 3<\/span> and one for values from 3<\/span> to 2147483647<\/span>. If we now add a second boundary at 6<\/span>, we end up with three partitions: The first one still accepting values from -2147483648<\/span> to 3<\/span>, the second for values from 3<\/span> to 6<\/span>, and the last one finally for values from 6<\/span> to 2147483647<\/span>.\n<\/p>\n

\nYou might have noticed an ambiguity in the preceding paragraph. The English language is particularly fuzzy on boundary conditions. The text above does not specify, which partitions the boundary values themselves belong to. Do the go to the left or the right?\n<\/p>\n

\nLet me use a diagram to clarify:\n<\/p>\n

\n\"Two<\/a>\n<\/p>\n

\nFor each boundary, you have to decide if the boundary value is part of the preceding partition or part of the following. As we commonly write from left to right, you can ask that same question this way: Is the boundary value part of the partition to its left or part of the partition to its right?\n<\/p>\n

\nSQL Server does not allow us to make that decision individually for each boundary. Instead, you decide for all boundaries in a partition function at once.\n<\/p>\n

The CREATE PARTITION FUNCTION Statement<\/h3>\n

\nTo create a partition function you have to use the CREATE PARTITION FUNCTION<\/span> statement. In this statement you decide if the boundary values are in their left or right partition by specifying either RANGE LEFT<\/span> or RANGE RIGHT<\/span>, followed by a comma separated list of the actual boundary values:\n<\/p>\n

\n[sql]\nCREATE PARTITION FUNCTION ThreeStepLeft(INT)
\nAS RANGE LEFT FOR VALUES(3,6);<\/p>\n

CREATE PARTITION FUNCTION ThreeStepRight(INT)
\nAS RANGE RIGHT FOR VALUES(3,6);
\n[\/sql]\n<\/p><\/div>\n

\nNow that we have those two partition functions (using the same two boundary values) in place, we can actually compare their behavior.\n<\/p>\n

RANGE LEFT vs RANGE RIGHT<\/h3>\n

\nFirst, let us finish the setup by creating two tables that are partitioned based on these functions:\n<\/p>\n

\n[sql]\nCREATE PARTITION SCHEME ThreeStepLeftScheme AS PARTITION ThreeStepLeft ALL TO([PRIMARY]);<\/p>\n

CREATE TABLE dbo.LeftTable
\n(
\n Id INT PRIMARY KEY CLUSTERED,
\n OtherValue INT DEFAULT CHECKSUM(NEWID())
\n) ON ThreeStepLeftScheme(id);<\/p>\n

INSERT INTO dbo.LeftTable(id) VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9);<\/p>\n

--<\/p>\n

CREATE PARTITION SCHEME ThreeStepRightScheme AS PARTITION ThreeStepRight ALL TO([PRIMARY]);<\/p>\n

CREATE TABLE dbo.RightTable
\n(
\n Id INT PRIMARY KEY CLUSTERED,
\n OtherValue INT DEFAULT CHECKSUM(NEWID())
\n) ON ThreeStepRightScheme(id);<\/p>\n

INSERT INTO dbo.RightTable(id) VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9);
\n[\/sql]\n<\/p><\/div>\n

\nThe above SQL snippet defines a partition scheme for each of the two partition functions. The schemes are of the most simple type, assigning all partitions to the primary filegroup. The snippet also creates a table for each partition scheme and inserts rows with id<\/span> values ranging from 1<\/span> to 9<\/span>.\n<\/p>\n

\nTwo years ago, I published a query that lists all partitions<\/a> in a database together with their boundaries. Below you can find an improved version of that query:\n<\/p>\n

\n[sql]\nSELECT f.NAME AS file_group_name,
\n SCHEMA_NAME(t.schema_id) AS table_schema,
\n t.name AS table_name,
\n p.partition_number,
\n ISNULL(CAST(left_prv.value AS VARCHAR(MAX))+ CASE WHEN pf.boundary_value_on_right = 0 THEN ' < '
\n ELSE ' <= '
\n END , '-INF < ')
\n + 'X' + ISNULL(CASE WHEN pf.boundary_value_on_right = 0 THEN ' <= '
\n ELSE ' < '
\n END + CAST(right_prv.value AS NVARCHAR(MAX)), ' < INF') AS range_desc,
\n pf.boundary_value_on_right,
\n ps.name AS partition_schem_name,
\n pf.name AS partition_function_name,
\n left_prv.value AS left_boundary,
\n right_prv.value AS right_boundary
\nFROM sys.partitions p
\nJOIN sys.tables t
\n ON p.object_id = t.object_id
\nJOIN sys.indexes i
\n ON p.object_id = i.object_id
\n AND p.index_id = i.index_id
\nJOIN sys.allocation_units au
\n ON p.hobt_id = au.container_id
\nJOIN sys.filegroups f
\n ON au.data_space_id = f.data_space_id
\nLEFT JOIN sys.partition_schemes ps
\n ON ps.data_space_id = i.data_space_id
\nLEFT JOIN sys.partition_functions pf
\n ON ps.function_id = pf.function_id
\nLEFT JOIN sys.partition_range_values left_prv
\n ON left_prv.function_id = ps.function_id
\n AND left_prv.boundary_id + 1 = p.partition_number
\nLEFT JOIN sys.partition_range_values right_prv
\n ON right_prv.function_id = ps.function_id
\n AND right_prv.boundary_id = p.partition_number
\n[\/sql]\n<\/div>\n

\nFiltered to include only those two tables we created before, the query returns this result:\n<\/p>\n

\n\"A<\/a>\n<\/p>\n

\nThere are a few more columns in there that did not fit on the screen, but the more important ones are included. I would like you to look at partition_number<\/span>, range_desc<\/span> and boundary_value_on_right<\/span> for a second. The latter is set to 1<\/span> is the partition function was created with the RANGE RIGHT<\/span> clause, which means that each boundary belongs to the partition on its right. The range_desc<\/span> column explains what values will be stored in each partition.\n<\/p>\n

\nI would ask you to trust me on that query, but I know you rather see proof that the range description is actually, what happens under the covers.\n<\/p>\n

Determining the Partition in Which a Particular Row is Stored<\/h3>\n

\nThere is no documented way to directly determine the partition a particular table row is stored in. There is a way to pass any value to a partition function<\/a> and receive a (partition) number in return. However, that does not really tell us that the row actually was stored in that partition.\n<\/p>\n

\nLuckily, if we combine two pieces of undocumented functionality, we can still see which partition a particular row is stored in. Those two functions are the %%physloc%%<\/span> virtual column<\/a> that returns the file_id<\/span> and page_id<\/span> of the page the row is stored in and the sys.dm_db_database_page_allocations<\/span> DMF<\/a> that lists all the database pages that belong to a partition.\n<\/p>\n

\nTogether these two provide enough information to determine the actual partition of a row in a partitioned table. However, before we can use them we need to execute two more steps. First we need to translate the output of the %%physloc%%<\/span> column into separate values for the file and page ids. For that we can use the sys.fn_PhysLocCracker<\/span> function. Second, we do not know the partition of our row upfront, so we need to get the full list of pages to compare with. That can be achieved by passing in NULL<\/span> to all parameters but the first of the sys.dm_db_database_page_allocations<\/span> DMF. With that, it returns all pages in the specified database.\n<\/p>\n

\nPutting this all together, we can write a query like the following:\n<\/p>\n

\n[sql]\nSELECT T.*,
\n DDDPA.partition_id AS partition_number,
\n ISNULL
\n (
\n CAST(LEFT_PRV.value AS VARCHAR(MAX)) +
\n CASE WHEN PF.boundary_value_on_right = 0 THEN ' < ' ELSE ' <= ' END ,
\n '-INF < '
\n ) +
\n 'X' +
\n ISNULL
\n (
\n CASE WHEN PF.boundary_value_on_right = 0 THEN ' <= ' ELSE ' < ' END +
\n CAST(RIGHT_PRV.value AS NVARCHAR(MAX)),
\n ' < INF'
\n ) AS range_desc,
\n PF.boundary_value_on_right
\n FROM dbo.LeftTable AS T
\n CROSS APPLY sys.fn_PhysLocCracker(T.%%physloc%%) AS FPLC
\n JOIN sys.dm_db_database_page_allocations(DB_ID(),NULL,NULL,NULL,NULL) AS DDDPA
\n ON DDDPA.allocated_page_page_id = FPLC.page_id
\n AND DDDPA.allocated_page_file_id = FPLC.file_id
\n JOIN sys.indexes AS I
\n ON DDDPA.object_id = I.object_id
\n AND DDDPA.index_id = I.index_id
\n LEFT JOIN sys.partition_schemes PS
\n ON PS.data_space_id = I.data_space_id
\n LEFT JOIN sys.partition_functions pf
\n ON ps.function_id = pf.function_id
\n LEFT JOIN sys.partition_range_values left_prv
\n ON left_prv.function_id = ps.function_id
\n AND left_prv.boundary_id + 1 = DDDPA.partition_id
\n LEFT JOIN sys.partition_range_values right_prv
\n ON right_prv.function_id = ps.function_id
\n AND right_prv.boundary_id = DDDPA.partition_id;
\n[\/sql]\n<\/div>\n

\nThis query, in addition to determining the actual partition of a row, also uses part of the previous query to create the range_desc<\/span> column of the identified partition for easier comparison. The important column however is DDDPA.partition_id<\/span>, aliased as partition_number<\/span>. That is the column that returns the partition number for each row.\n<\/p>\n

\nIf you want to use this query on a different table, all you have to do is replace the single occurrence of dbo.LeftTable<\/span> with the new table name. The two screenshots below show the output of this query for both the dbo.LeftTable<\/span> and the dbo.RightTable<\/span>.\n<\/p>\n

\n\"Row<\/a>\n<\/p>\n

\n\"Row<\/a>\n<\/p>\n

\nAs you can now clearly see, when looking at the id<\/span> and the partition_number<\/span> columns, the output in the range_desc<\/span> column is accurate.\n<\/p>\n

The Take-Away<\/h3>\n

\nNow that you, I hope, understand partition boundaries a little better, let use recap what we found out.\n<\/p>\n

    \n
  1. A partition function cuts the entire range of possible values in \"partitions\", based on boundary values. The number of partitions is always one higher than the number of boundary values.<\/li>\n
  2. Each boundary separates two partitions from each other: A left partition with smaller values and a right partition with larger values.<\/li>\n
  3. Each boundary value for a single partition function belongs either to the partition to its left or the partition to its right. Which one is depending on the partition function having been created with RANGE LEFT<\/span> or RANGE RIGHT<\/span> respectively.<\/li>\n<\/ol>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

    Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover a unique query to determine the actual partition a row is stored in. With this query you can quickly confirm your RANGE-assumption or find out where you got it wrong.<\/p>\n

    [more…]<\/a><\/p>\n","protected":false},"author":3,"featured_media":2486,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[29,5,27,14,105],"tags":[117,210,211,15],"class_list":["post-2483","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-fundamentals","category-general","category-series","category-sql-server-internals","category-storage-wednesday","tag-partition","tag-partition-boundary","tag-partition-function","tag-sql-server"],"acf":[],"yoast_head":"\nPartition Boundaries - Left or Right: That is the Question - sqlity.net<\/title>\n<meta name=\"description\" content=\"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Partition Boundaries - Left or Right: That is the Question - sqlity.net\" \/>\n<meta property=\"og:description\" content=\"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/\" \/>\n<meta property=\"og:site_name\" content=\"sqlity.net\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/sqlity.net\" \/>\n<meta property=\"article:published_time\" content=\"2014-07-16T20:00:45+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2014-11-13T18:35:18+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"856\" \/>\n\t<meta property=\"og:image:height\" content=\"394\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Sebastian Meine\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@sqlity\" \/>\n<meta name=\"twitter:site\" content=\"@sqlity\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sebastian Meine\" \/>\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\":\"Article\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/\"},\"author\":{\"name\":\"Sebastian Meine\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/#\\\/schema\\\/person\\\/bcffd8c572bc2f1bd10fdba80135e53c\"},\"headline\":\"Partition Boundaries – Left or Right: That is the Question\",\"datePublished\":\"2014-07-16T20:00:45+00:00\",\"dateModified\":\"2014-11-13T18:35:18+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/\"},\"wordCount\":1901,\"commentCount\":3,\"image\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/sqlity.net\\\/wp-content\\\/uploads\\\/2014\\\/07\\\/interpretation_of_partition_boundaries.jpg\",\"keywords\":[\"Partition\",\"partition boundary\",\"partition function\",\"SQL Server\"],\"articleSection\":[\"Fundamentals\",\"General\",\"Series\",\"SQL Server Internals\",\"Storage Wednesday\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/\",\"url\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/\",\"name\":\"Partition Boundaries - Left or Right: That is the Question - sqlity.net\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/sqlity.net\\\/wp-content\\\/uploads\\\/2014\\\/07\\\/interpretation_of_partition_boundaries.jpg\",\"datePublished\":\"2014-07-16T20:00:45+00:00\",\"dateModified\":\"2014-11-13T18:35:18+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/#\\\/schema\\\/person\\\/bcffd8c572bc2f1bd10fdba80135e53c\"},\"description\":\"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#primaryimage\",\"url\":\"https:\\\/\\\/sqlity.net\\\/wp-content\\\/uploads\\\/2014\\\/07\\\/interpretation_of_partition_boundaries.jpg\",\"contentUrl\":\"https:\\\/\\\/sqlity.net\\\/wp-content\\\/uploads\\\/2014\\\/07\\\/interpretation_of_partition_boundaries.jpg\",\"width\":856,\"height\":394,\"caption\":\"Two possible interpretations of the partition Boundaries.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/2483\\\/partition-boundaries\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/sqlity.net\\\/en\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Partition Boundaries – Left or Right: That is the Question\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/sqlity.net\\\/en\\\/\",\"name\":\"sqlity.net\",\"description\":\"Quality for SQL\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/sqlity.net\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/sqlity.net\\\/en\\\/#\\\/schema\\\/person\\\/bcffd8c572bc2f1bd10fdba80135e53c\",\"name\":\"Sebastian Meine\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g\",\"caption\":\"Sebastian Meine\"},\"sameAs\":[\"http:\\\/\\\/sqlity.net\",\"https:\\\/\\\/x.com\\\/sqlity\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Partition Boundaries - Left or Right: That is the Question - sqlity.net","description":"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.","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:\/\/sqlity.net\/en\/2483\/partition-boundaries\/","og_locale":"en_US","og_type":"article","og_title":"Partition Boundaries - Left or Right: That is the Question - sqlity.net","og_description":"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.","og_url":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/","og_site_name":"sqlity.net","article_publisher":"https:\/\/www.facebook.com\/sqlity.net","article_published_time":"2014-07-16T20:00:45+00:00","article_modified_time":"2014-11-13T18:35:18+00:00","og_image":[{"width":856,"height":394,"url":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","type":"image\/jpeg"}],"author":"Sebastian Meine","twitter_card":"summary_large_image","twitter_creator":"@sqlity","twitter_site":"@sqlity","twitter_misc":{"Written by":"Sebastian Meine","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#article","isPartOf":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/"},"author":{"name":"Sebastian Meine","@id":"https:\/\/sqlity.net\/en\/#\/schema\/person\/bcffd8c572bc2f1bd10fdba80135e53c"},"headline":"Partition Boundaries – Left or Right: That is the Question","datePublished":"2014-07-16T20:00:45+00:00","dateModified":"2014-11-13T18:35:18+00:00","mainEntityOfPage":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/"},"wordCount":1901,"commentCount":3,"image":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#primaryimage"},"thumbnailUrl":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","keywords":["Partition","partition boundary","partition function","SQL Server"],"articleSection":["Fundamentals","General","Series","SQL Server Internals","Storage Wednesday"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/","url":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/","name":"Partition Boundaries - Left or Right: That is the Question - sqlity.net","isPartOf":{"@id":"https:\/\/sqlity.net\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#primaryimage"},"image":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#primaryimage"},"thumbnailUrl":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","datePublished":"2014-07-16T20:00:45+00:00","dateModified":"2014-11-13T18:35:18+00:00","author":{"@id":"https:\/\/sqlity.net\/en\/#\/schema\/person\/bcffd8c572bc2f1bd10fdba80135e53c"},"description":"Do you know the difference between a RANGE LEFT and a RANGE RIGHT partition function? Read on and discover how the partition boundaries actually work.","breadcrumb":{"@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#primaryimage","url":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","contentUrl":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","width":856,"height":394,"caption":"Two possible interpretations of the partition Boundaries."},{"@type":"BreadcrumbList","@id":"https:\/\/sqlity.net\/en\/2483\/partition-boundaries\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/sqlity.net\/en\/"},{"@type":"ListItem","position":2,"name":"Partition Boundaries – Left or Right: That is the Question"}]},{"@type":"WebSite","@id":"https:\/\/sqlity.net\/en\/#website","url":"https:\/\/sqlity.net\/en\/","name":"sqlity.net","description":"Quality for SQL","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/sqlity.net\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/sqlity.net\/en\/#\/schema\/person\/bcffd8c572bc2f1bd10fdba80135e53c","name":"Sebastian Meine","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/4ab0a6d02dd494849a584a2c3c8bc3bdcef1d0aa5f87e98bf905dbdb9ad2ce3a?s=96&d=mm&r=g","caption":"Sebastian Meine"},"sameAs":["http:\/\/sqlity.net","https:\/\/x.com\/sqlity"]}]}},"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/sqlity.net\/wp-content\/uploads\/2014\/07\/interpretation_of_partition_boundaries.jpg","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p2wXuw-E3","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/posts\/2483","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/comments?post=2483"}],"version-history":[{"count":0,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/posts\/2483\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/media\/2486"}],"wp:attachment":[{"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/media?parent=2483"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/categories?post=2483"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sqlity.net\/en\/wp-json\/wp\/v2\/tags?post=2483"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}