[Internal] Subpartitioning: Adds SDK changes to support subpartitioning.

Microsoft.Azure.Cosmos/src/PartitionKey.cs

@@ -4,6 +4,8 @@
 namespace Microsoft.Azure.Cosmos
 {
     using System;
+    using System.Linq;
+    using Microsoft.Azure.Documents;
     using Microsoft.Azure.Documents.Routing;
 
     /// <summary>
@@ -95,6 +97,50 @@ internal PartitionKey(object value)
             this.IsNone = false;
         }
 
+        /// <summary>
+        /// Creates a new partition key value.
+        /// </summary>
+        /// <param name="value">An object of Type PartitionKeyValueList which supports multiple partition key paths.</param>
+        internal PartitionKey(PartitionKeyValueList value)
+        {
+            /*
+             * Why these checks?
+             * These changes are being added in the PR for SDK to support multiple paths in a partition key. 
+             *
+             * Currently, when a resource does not specify a value for the PartitionKey,
+             * we assign a temporary value `PartitionKey.None` and later discern whether 
+             * it is a PartitionKey.Undefined or PartitionKey.Empty based on the Collection Type.
+             *
+             * For collections with multiple path keys, absence of a partition key values is
+             * always treated as a PartitionKey.Undefined.
+             */
+            if (value == null
+                || value.partitionKeyValues.Count == 0
+                || (value.partitionKeyValues.Count == 1 && object.ReferenceEquals(value.partitionKeyValues[0], PartitionKeyValueList.NoneType)))
+            {
+                this.InternalKey = PartitionKey.None.InternalKey;
+                this.IsNone = true;
+            }
+            else
+            {
+                object[] valueArray = new object[value.partitionKeyValues.Count];
+                int i = 0;
+                foreach (object val in value.partitionKeyValues)
+                {
+                    if (object.ReferenceEquals(PartitionKeyValueList.NoneType, val))
+                    {
+                        valueArray[i++] = Undefined.Value;
+                    }
+                    else
+                    {
+                        valueArray[i++] = val;
+                    }
+                }
+                this.InternalKey = new Documents.PartitionKey(valueArray).InternalKey;
+                this.IsNone = false;
+            }
+        }
+
         /// <summary>
         /// Creates a new partition key value.
         /// </summary>

Microsoft.Azure.Cosmos/src/PartitionKeyValueList.cs

@@ -0,0 +1,81 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+namespace Microsoft.Azure.Cosmos
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using Microsoft.Azure.Documents;
+    using Microsoft.Azure.Documents.Routing;
+
+    /// <summary>
+    /// Represents a partition key value list in the Azure Cosmos DB service.
+    /// </summary>
+    public sealed class PartitionKeyValueList
+    {
+        internal readonly IList<object> partitionKeyValues;
+
+        internal static readonly object NoneType = new object();
+
+        /// <summary>
+        /// Creates a new partition key value list object.
+        /// </summary>
+        public PartitionKeyValueList()
+        {
+            this.partitionKeyValues = new List<object>();
+        }
+
+        /// <summary>
+        /// Adds a partition key value of type string to the list.
+        /// </summary>
+        /// <param name="val">The value of type string to be used as partitionKey.</param>
+        public void Add(string val)
+        {
+            if (val == null)
+            {
+                this.AddNullValue();
+            }
+            else
+            {
+                this.partitionKeyValues.Add(val);
+            }
+        }
+
+        /// <summary>
+        /// Adds a partition key value of type double to the list.
+        /// </summary>
+        /// <param name="val">The value of type double to be used as partitionKey.</param>
+        public void Add(double val)
+        {
+            this.partitionKeyValues.Add(val);
+        }
+
+        /// <summary>
+        /// Adds a partition key value of type bool to the list.
+        /// </summary>
+        /// <param name="val">The value of type bool to be used as partitionKey.</param>
+        public void Add(bool val)
+        {
+            this.partitionKeyValues.Add(val);
+        }
+
+        /// <summary>
+        /// Adds a partition key value which is null
+        /// </summary>
+        public void AddNullValue()
+        {
+            this.partitionKeyValues.Add(null);
+        }
+
+        internal void AddUndefined()
+        {
+            this.partitionKeyValues.Add(Undefined.Value);
+        }
+
+        internal void AddNoneType()
+        {
+            this.partitionKeyValues.Add(NoneType);
+        }
+    }
+}

Microsoft.Azure.Cosmos/src/Resource/Container/ContainerCore.Items.cs

@@ -626,6 +626,12 @@ private async Task<ResponseMessage> ExtractPartitionKeyAndProcessItemStreamAsync
             // User specified PK value, no need to extract it
             if (partitionKey.HasValue)
             {
+                PartitionKeyDefinition pKeyDefinition = await this.GetPartitionKeyDefinitionAsync();
+                if (((PartitionKey)partitionKey).InternalKey.Components.Count != pKeyDefinition.Paths.Count)
+                {
+                    throw new ArgumentException(RMResources.MissingPartitionKeyValue);
+                }
+
                 return await this.ProcessItemStreamAsync(
                         partitionKey,
                         itemId,
@@ -708,7 +714,7 @@ private async Task<ResponseMessage> ProcessItemStreamAsync(
 
             return responseMessage;
         }
-
+     
         public override async Task<PartitionKey> GetPartitionKeyValueFromStreamAsync(
             Stream stream,
             CancellationToken cancellation = default(CancellationToken))
@@ -733,21 +739,17 @@ public override async Task<PartitionKey> GetPartitionKeyValueFromStreamAsync(
                 IJsonNavigatorNode jsonNavigatorNode = jsonNavigator.GetRootNode();
                 CosmosObject pathTraversal = CosmosObject.Create(jsonNavigator, jsonNavigatorNode);
 
-                string[] tokens = await this.GetPartitionKeyPathTokensAsync(cancellation);
-                for (int i = 0; i < tokens.Length - 1; i++)
-                {
-                    if (!pathTraversal.TryGetValue(tokens[i], out pathTraversal))
-                    {
-                        return PartitionKey.None;
-                    }
-                }
+                IReadOnlyList<string[]> tokenslist = await this.GetPartitionKeyPathTokensAsync(cancellation);
+                CosmosElement[] cosmosElementArray = new CosmosElement[tokenslist.Count];
 
-                if (!pathTraversal.TryGetValue(tokens[tokens.Length - 1], out CosmosElement partitionKeyValue))
+                int index = 0;
+                foreach (string[] tokens in tokenslist)
                 {
-                    return PartitionKey.None;
+                    CosmosElement partitionKeyValue = this.ParseTokenListForElement(pathTraversal, tokens);
+                    cosmosElementArray[index++] = partitionKeyValue;
                 }
 
-                return this.CosmosElementToPartitionKeyObject(partitionKeyValue);
+                return this.CosmosElementToPartitionKeyObject(cosmosElementArray);
             }
             finally
             {
@@ -756,31 +758,69 @@ public override async Task<PartitionKey> GetPartitionKeyValueFromStreamAsync(
             }
         }
 
-        private PartitionKey CosmosElementToPartitionKeyObject(CosmosElement cosmosElement)
+        private CosmosElement ParseTokenListForElement(CosmosObject pathTraversal, string[] tokens)
         {
-            // TODO: Leverage original serialization and avoid re-serialization (bug)
-            switch (cosmosElement.Type)
+            CosmosElement partitionKeyValue;
+
+            for (int i = 0; i < tokens.Length - 1; i++)
             {
-                case CosmosElementType.String:
-                    CosmosString cosmosString = cosmosElement as CosmosString;
-                    return new PartitionKey(cosmosString.Value);
+                if (!pathTraversal.TryGetValue(tokens[i], out pathTraversal))
+                {
+                    return null;
+                }
+            }
 
-                case CosmosElementType.Number:
-                    CosmosNumber cosmosNumber = cosmosElement as CosmosNumber;
-                    double value = Number64.ToDouble(cosmosNumber.Value);
-                    return new PartitionKey(value);
+            if (!pathTraversal.TryGetValue(tokens[tokens.Length - 1], out partitionKeyValue))
+            {
+                return null;
+            }
 
-                case CosmosElementType.Boolean:
-                    CosmosBoolean cosmosBool = cosmosElement as CosmosBoolean;
-                    return new PartitionKey(cosmosBool.Value);
+            return partitionKeyValue;
+        }
 
-                case CosmosElementType.Null:
-                    return PartitionKey.Null;
+        private PartitionKey CosmosElementToPartitionKeyObject(CosmosElement[] cosmosElementArray)
+        {
+            PartitionKeyValueList partitionKeyValueList = new PartitionKeyValueList();
 
-                default:
-                    throw new ArgumentException(
-                        string.Format(CultureInfo.InvariantCulture, RMResources.UnsupportedPartitionKeyComponentValue, cosmosElement));
+            foreach (CosmosElement cosmosElement in cosmosElementArray)
+            {
+                if (cosmosElement == null)
+                {
+                    partitionKeyValueList.AddNoneType();
+                }
+                else
+                {
+                    // TODO: Leverage original serialization and avoid re-serialization (bug)
+                    switch (cosmosElement.Type)
+                    {
+                        case CosmosElementType.String:
+                            CosmosString cosmosString = cosmosElement as CosmosString;
+                            partitionKeyValueList.Add(cosmosString.Value);
+                            break;
+
+                        case CosmosElementType.Number:
+                            CosmosNumber cosmosNumber = cosmosElement as CosmosNumber;
+                            double value = Number64.ToDouble(cosmosNumber.Value);
+                            partitionKeyValueList.Add(value);
+                            break;
+
+                        case CosmosElementType.Boolean:
+                            CosmosBoolean cosmosBool = cosmosElement as CosmosBoolean;
+                            partitionKeyValueList.Add(cosmosBool.Value);
+                            break;
+
+                        case CosmosElementType.Null:
+                            partitionKeyValueList.AddNullValue();
+                            break;
+
+                        default:
+                            throw new ArgumentException(
+                                string.Format(CultureInfo.InvariantCulture, RMResources.UnsupportedPartitionKeyComponentValue, cosmosElement));
+                    }
+                }
             }
+
+            return new PartitionKey(partitionKeyValueList);
         }
 
         private Uri GetResourceUri(RequestOptions requestOptions, OperationType operationType, string itemId)

Microsoft.Azure.Cosmos/src/Resource/Container/ContainerCore.cs

@@ -347,7 +347,7 @@ public override async Task<string> GetRIDAsync(CancellationToken cancellationTok
         /// </summary>
         /// <param name="cancellationToken"></param>
         /// <returns>Returns the partition key path</returns>
-        public override async Task<string[]> GetPartitionKeyPathTokensAsync(CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task<IReadOnlyList<string[]>> GetPartitionKeyPathTokensAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
             ContainerProperties containerProperties = await this.GetCachedContainerPropertiesAsync(cancellationToken);
             if (containerProperties == null)

Microsoft.Azure.Cosmos/src/Resource/Container/ContainerInternal.cs

@@ -40,7 +40,8 @@ public abstract Task<ThroughputResponse> ReplaceThroughputIfExistsAsync(
         public abstract Task<ContainerProperties> GetCachedContainerPropertiesAsync(
             CancellationToken cancellationToken = default(CancellationToken));
 
-        public abstract Task<string[]> GetPartitionKeyPathTokensAsync(CancellationToken cancellationToken = default(CancellationToken));
+        public abstract Task<IReadOnlyList<string[]>> GetPartitionKeyPathTokensAsync(
+            CancellationToken cancellationToken = default(CancellationToken));
 
         public abstract Task<Documents.Routing.PartitionKeyInternal> GetNonePartitionKeyValueAsync(
             CancellationToken cancellationToken);

Microsoft.Azure.Cosmos/src/Resource/Settings/ContainerProperties.cs

@@ -5,6 +5,7 @@
 namespace Microsoft.Azure.Cosmos
 {
     using System;
+    using System.Collections.Generic;
     using System.Collections.ObjectModel;
     using Microsoft.Azure.Documents;
     using Microsoft.Azure.Documents.Routing;
@@ -70,7 +71,7 @@ public class ContainerProperties
         [JsonProperty(PropertyName = Constants.Properties.ConflictResolutionPolicy, NullValueHandling = NullValueHandling.Ignore)]
         private ConflictResolutionPolicy conflictResolutionInternal;
 
-        private string[] partitionKeyPathTokens;
+        private IReadOnlyList<string[]> partitionKeyPathTokens;
         private string id;
 
         /// <summary>
@@ -510,7 +511,7 @@ internal ContainerProperties(string id, PartitionKeyDefinition partitionKeyDefin
 
         internal bool HasPartitionKey => this.PartitionKey != null;
 
-        internal string[] PartitionKeyPathTokens
+        internal IReadOnlyList<string[]> PartitionKeyPathTokens
         {
             get
             {
@@ -519,7 +520,7 @@ internal string[] PartitionKeyPathTokens
                     return this.partitionKeyPathTokens;
                 }
 
-                if (this.PartitionKey.Paths.Count > 1)
+                if (this.PartitionKey.Paths.Count > 1 && this.PartitionKey.Kind != PartitionKind.MultiHash) 
                 {
                     throw new NotImplementedException("PartitionKey extraction with composite partition keys not supported.");
                 }
@@ -529,7 +530,13 @@ internal string[] PartitionKeyPathTokens
                     throw new ArgumentOutOfRangeException($"Container {this.Id} is not partitioned");
                 }
 
-                this.partitionKeyPathTokens = this.PartitionKeyPath.Split(ContainerProperties.partitionKeyTokenDelimeter, StringSplitOptions.RemoveEmptyEntries);
+                Collection<string[]> partitionKeyPathTokensList = new Collection<string[]>();
+                foreach (string s in this.PartitionKey?.Paths)
+                {
+                    partitionKeyPathTokensList.Add(s.Split(ContainerProperties.partitionKeyTokenDelimeter, StringSplitOptions.RemoveEmptyEntries));
+                }
+
+                this.partitionKeyPathTokens = partitionKeyPathTokensList;
                 return this.partitionKeyPathTokens;
             }
         }
@@ -559,5 +566,6 @@ internal void ValidateRequiredProperties()
                 this.indexingPolicyInternal.IncludedPaths.Add(new IncludedPath() { Path = IndexingPolicy.DefaultPath });
             }
         }
+
     }
 }

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosContainerTests.cs

@@ -1115,7 +1115,7 @@ private void ValidateCreateContainerResponseContract(ContainerResponse container
 
             Assert.IsNotNull(containerSettings.PartitionKeyPath);
             Assert.IsNotNull(containerSettings.PartitionKeyPathTokens);
-            Assert.AreEqual(1, containerSettings.PartitionKeyPathTokens.Length);
+            Assert.AreEqual(1, containerSettings.PartitionKeyPathTokens[0].Length);
             Assert.AreEqual("id", containerSettings.PartitionKeyPathTokens[0]);
 
             ContainerInternal containerCore = containerResponse.Container as ContainerInlineCore;