Add API for creating hierarchical PartitionKeys

sdk/data/azcosmos/emulator_cosmos_item_test.go

@@ -515,6 +515,7 @@ func TestItemCRUDHierarchicalPartitionKey(t *testing.T) {
 		ID: "aContainer",
 		PartitionKeyDefinition: PartitionKeyDefinition{
 			Paths: []string{"/id", "/type"},
+			Kind:  MultiHash,
 		},
 	}
 

sdk/data/azcosmos/partition_key_definition.go

@@ -3,11 +3,84 @@
 
 package azcosmos
 
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type PartitionKeyKind string
+
+const (
+	Hash      PartitionKeyKind = "Hash"
+	MultiHash PartitionKeyKind = "MultiHash"
+)
+
 // PartitionKeyDefinition represents a partition key definition in the Azure Cosmos DB database service.
 // A partition key definition defines the path for the partition key property.
 type PartitionKeyDefinition struct {
+	// Kind returns the kind of partition key definition.
+	Kind PartitionKeyKind `json:"kind"`
 	// Paths returns the list of partition key paths of the container.
 	Paths []string `json:"paths"`
 	// Version returns the version of the hash partitioning of the container.
 	Version int `json:"version,omitempty"`
 }
+
+// MarshalJSON implements the json.Marshaler interface
+// If the Kind is not set, it will be inferred based on the number of paths.
+func (pkd PartitionKeyDefinition) MarshalJSON() ([]byte, error) {
+	var paths_length = len(pkd.Paths)
+
+	var kind PartitionKeyKind
+	if pkd.Kind != "" {
+		kind = pkd.Kind
+	} else if pkd.Kind == "" && paths_length == 1 {
+		kind = Hash
+	} else if pkd.Kind == "" && paths_length > 1 {
+		kind = MultiHash
+	}
+
+	return json.Marshal(struct {
+		Kind    PartitionKeyKind `json:"kind"`
+		Paths   []string         `json:"paths"`
+		Version int              `json:"version,omitempty"`
+	}{
+		Kind:    kind,
+		Paths:   pkd.Paths,
+		Version: pkd.Version,
+	})
+
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface
+func (pkd *PartitionKeyDefinition) UnmarshalJSON(data []byte) error {
+	var rawMsg map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawMsg); err != nil {
+		return fmt.Errorf("unmarshalling type %T: %v", pkd, err)
+	}
+
+	for key, value := range rawMsg {
+		switch key {
+		case "kind":
+			if err := json.Unmarshal(value, &pkd.Kind); err != nil {
+				return fmt.Errorf("unmarshalling type %T: %v", pkd, err)
+			}
+		case "paths":
+			if err := json.Unmarshal(value, &pkd.Paths); err != nil {
+				return fmt.Errorf("unmarshalling type %T: %v", pkd, err)
+			}
+		case "version":
+			if err := json.Unmarshal(value, &pkd.Version); err != nil {
+				return fmt.Errorf("unmarshalling type %T: %v", pkd, err)
+			}
+		}
+	}
+
+	if pkd.Kind == "" && len(pkd.Paths) == 1 {
+		pkd.Kind = Hash
+	} else if pkd.Kind == "" && len(pkd.Paths) > 1 {
+		pkd.Kind = MultiHash
+	}
+
+	return nil
+}

sdk/data/azcosmos/partition_key_definition_test.go

@@ -0,0 +1,145 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package azcosmos
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestPartitionKeyDefinitionSerialization(t *testing.T) {
+	pkd_kind_unset_len_one := PartitionKeyDefinition{
+		Paths:   []string{"somePath"},
+		Version: 2,
+	}
+
+	jsonString, err := pkd_kind_unset_len_one.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := `{"kind":"Hash","paths":["somePath"],"version":2}`
+	if string(jsonString) != expected {
+		t.Errorf("Expected serialization %v, but got %v", expected, string(jsonString))
+	}
+
+	pkd_kind_unset_len_two := PartitionKeyDefinition{
+		Paths:   []string{"somePath", "someOtherPath"},
+		Version: 2,
+	}
+
+	jsonString, err = pkd_kind_unset_len_two.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected = `{"kind":"MultiHash","paths":["somePath","someOtherPath"],"version":2}`
+	if string(jsonString) != expected {
+		t.Errorf("Expected serialization %v, but got %v", expected, string(jsonString))
+	}
+
+	pkd_kind_set := PartitionKeyDefinition{
+		Kind:    MultiHash,
+		Paths:   []string{"somePath"},
+		Version: 2,
+	}
+
+	jsonString, err = pkd_kind_set.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected = `{"kind":"MultiHash","paths":["somePath"],"version":2}`
+	if string(jsonString) != expected {
+		t.Errorf("Expected serialization %v, but got %v", expected, string(jsonString))
+	}
+}
+
+func TestPartitionKeyDefinitionDeserialization(t *testing.T) {
+	def := PartitionKeyDefinition{
+		Paths:   []string{"somePath"},
+		Version: 2,
+	}
+
+	jsonString, err := def.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var otherDef PartitionKeyDefinition
+	err = otherDef.UnmarshalJSON(jsonString)
+
+	if err != nil {
+		t.Fatal(err, string(jsonString))
+	}
+
+	// Kind is inferred based on the number of paths
+	if otherDef.Kind != Hash {
+		t.Errorf("Expected Kind to be %v, but got %v", def.Kind, otherDef.Kind)
+	}
+
+	if !reflect.DeepEqual(def.Paths, otherDef.Paths) {
+		t.Errorf("Expected Paths to be %v, but got %v", def.Paths, otherDef.Paths)
+	}
+
+	if def.Version != otherDef.Version {
+		t.Errorf("Expected Version to be %v, but got %v", def.Version, otherDef.Version)
+	}
+
+	def = PartitionKeyDefinition{
+		Paths:   []string{"somePath", "someOtherPath"},
+		Version: 2,
+	}
+
+	jsonString, err = def.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = otherDef.UnmarshalJSON(jsonString)
+	if err != nil {
+		t.Fatal(err, string(jsonString))
+	}
+
+	// Kind is inferred based on the number of paths
+	if otherDef.Kind != MultiHash {
+		t.Errorf("Expected Kind to be %v, but got %v", MultiHash, otherDef.Kind)
+	}
+
+	if !reflect.DeepEqual(def.Paths, otherDef.Paths) {
+		t.Errorf("Expected Paths to be %v, but got %v", def.Paths, otherDef.Paths)
+	}
+
+	if def.Version != otherDef.Version {
+		t.Errorf("Expected Version to be %v, but got %v", def.Version, otherDef.Version)
+	}
+
+	def = PartitionKeyDefinition{
+		Kind:    MultiHash,
+		Paths:   []string{"somePath"},
+		Version: 2,
+	}
+
+	jsonString, err = def.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = otherDef.UnmarshalJSON(jsonString)
+	if err != nil {
+		t.Fatal(err, string(jsonString))
+	}
+
+	if def.Kind != otherDef.Kind {
+		t.Errorf("Expected Kind to be %v, but got %v", def.Kind, otherDef.Kind)
+	}
+
+	if !reflect.DeepEqual(def.Paths, otherDef.Paths) {
+		t.Errorf("Expected Paths to be %v, but got %v", def.Paths, otherDef.Paths)
+	}
+
+	if def.Version != otherDef.Version {
+		t.Errorf("Expected Version to be %v, but got %v", def.Version, otherDef.Version)
+	}
+}