Develop a design by storing multiple entity types in the same container

Developing a design that effectively stores multiple entity types in the same container is crucial when working with Microsoft Azure Cosmos DB for designing and implementing native applications. Azure Cosmos DB is a globally-distributed, multi-model database service that allows seamless scaling, low latency, and high availability. This article will explore the best practices and guidelines for designing such a system.

1. Defining the Entity Models

Firstly, we need to define the entity models for customers and orders. These can be represented as JSON documents. Here’s an example:

{
“id”: “customer1”,
“firstName”: “John”,
“lastName”: “Doe”,
“email”: “[email protected]”
}

{
“id”: “order1”,
“customerID”: “customer1”,
“status”: “Pending”,
“orderDate”: “2022-01-01”,
“totalAmount”: 99.99
}

2. Creating the Container

Next, we create a Cosmos DB container to store both customers and orders. The partition key serves as the primary organizing principle for distributing and scaling data. In this example, we’ll use the “customerID” property as the partition key. Here’s an example of creating a container using the Azure Cosmos DB SDK for .NET:

csharp
/* Code Example 3: Create a container */
var database = cosmosClient.GetDatabase(databaseId);
var containerProperties = new ContainerProperties(“myContainer”, “/customerID”);
var container = await database.CreateContainerIfNotExistsAsync(containerProperties);

3. Inserting Entities

To store customer and order entities, we can use the Cosmos DB SDK to insert these entities into the container. Here’s an example:

csharp
/* Code Example 4: Insert a customer entity */
var customer = new Customer
{
Id = “customer1”,
FirstName = “John”,
LastName = “Doe”,
Email = “[email protected]”
};

await container.CreateItemAsync(customer);

/* Code Example 5: Insert an order entity */
var order = new Order
{
Id = “order1”,
CustomerID = “customer1”,
Status = “Pending”,
OrderDate = DateTime.UtcNow,
TotalAmount = 99.99
};

await container.CreateItemAsync(order);

4. Querying Entities

Azure Cosmos DB provides powerful querying capabilities using a SQL-based query language. We can easily query both customer and order entities using the same container. Here’s an example:

csharp
/* Code Example 6: Query customers */
var customerQuery = container.GetItemQueryIterator(
“SELECT * FROM c WHERE c.id = ‘customer1′”);

while (customerQuery.HasMoreResults)
{
var response = await customerQuery.ReadNextAsync();
foreach (var customer in response)
{
Console.WriteLine($”Customer: {customer.FirstName} {customer.LastName}”);
}
}

/* Code Example 7: Query orders */
var orderQuery = container.GetItemQueryIterator(
“SELECT * FROM c WHERE c.customerID = ‘customer1′”);

while (orderQuery.HasMoreResults)
{
var response = await orderQuery.ReadNextAsync();
foreach (var order in response)
{
Console.WriteLine($”Order ID: {order.Id}, Total Amount: {order.TotalAmount}”);
}
}

By designing a system that stores multiple entity types in the same container, we can achieve greater simplicity and flexibility in our native applications using Microsoft Azure Cosmos DB. This design approach allows efficient querying, scalability, and performance while maintaining data integrity. Leveraging the features and capabilities of Azure Cosmos DB empowers developers to build robust, scalable, and globally distributed applications.

These are the essential steps to develop a design by storing multiple entity types in the same container in Microsoft Azure Cosmos DB. With this guidance, you can successfully implement this pattern in your native applications.