Azure Cosmos DB Transactions from .NET

I received a comment to my Optimistic Concurrency in Azure Cosmos DB a couple weeks ago from Jerry Goyal:

Can we somehow handle the concurrency among multiple documents (transactions)?

Since ETags are defined on each document, you must build your concurrency around them. However, this made me start to wonder how to update multiple documents at the same time using their respective ETags. Meaning you would want both documents to update together only if both of their ETags were current. If one was valid and the other was out of date, none of the documents would update.

Transactions

It’s pretty obvious that I’m looking for transactions within Azure Cosmos DB.

Azure Cosmos DB supports language-integrated transactions via JavaScript stored procedures and triggers. All database operations inside scripts are executed under snapshot isolation scoped to the collection if it is a single-partition collection, or documents with the same partition key value within a collection, if the collection is partitioned.

There is no client transaction scope you can use with the .NET SDK. Meaning from the client (.NET) you cannot create a transaction scope. It has to be done on the Azure Cosmos DB server via stored procedure or trigger.

Azure Cosmos DB Emulator

There are several ways you can create a stored procedure. One of which is via the Azure Cosmos DB Emulator web UI.

You can create a store procedure under any given collection.

You can also create stored procedures via the .NET SDK using the CreateStoredProcedureAsync. However for this demo, I’m going to be creating it via the emulator.

Stored Procedure

For demo purposes I wanted a way to do a bulk insert. If any of the customers failed to be added to the collection, due to the Name being falsey, I don’t want any to be created.

Here is the stored procedure I created called sp_bulkinsert. Notice the getContext() method which is available to. Check out the JavaScript docs for more on the Context/Request/Response.

	function sp_demo(customers){
	var context = getContext();
	var collection = context.getCollection();
	var collectionLink = collection.getSelfLink();

	for (var x in customers) {
	if (!customers[x].Name) throw "Invalid Customer Name";
	collection.createDocument(collectionLink, customers[x]);
	}

	var response = context.getResponse();
	response.setBody(customers.length);
	}

view raw sproc.js hosted with ❤ by GitHub

Client

Here are a couple tests using the .NET SDK which call the stored procedure passing in an array of new customers.

The first test passes returning the number of created customer documents. The second test fails because the customer name is empty/blank.

	using System;
	using System.Linq;
	using System.Net;
	using System.Threading.Tasks;
	using Microsoft.Azure.Documents;
	using Microsoft.Azure.Documents.Client;
	using Shouldly;
	using Xunit;

	namespace Demo
	{
	public class OptimtimisticConcurrencyTests
	{
	private readonly DocumentClient _client;
	private const string EndpointUrl = "https://localhost:8081";
	private const string AuthorizationKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
	private const string DatabaseId = "ConcurrencyDemo";
	private const string CollectionId = "Customers";

	public OptimtimisticConcurrencyTests()
	{
	_client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);
	}

	[Fact]
	public async Task Should_insert_multiple_customers()
	{
	// Setup our Database and add a new Customer
	var dbSetup = new DatabaseSetup(_client);
	await dbSetup.Init(DatabaseId, CollectionId);

	dynamic[] customers = {
	new Customer(Guid.NewGuid().ToString(), "Test1 Customer1"),
	new Customer(Guid.NewGuid().ToString(), "Test1 Customer2")
	};

	var sproc = dbSetup.Client.CreateStoredProcedureQuery(dbSetup.Collection.SelfLink).Where(x => x.Id == "sp_bulkinsert").AsEnumerable().First();
	var imported = await dbSetup.Client.ExecuteStoredProcedureAsync<int>(sproc.SelfLink, new dynamic[] { customers });
	imported.Response.ShouldBe(2);
	}

	[Fact]
	public async Task Should_not_insert_any()
	{
	// Setup our Database and add a new Customer
	var dbSetup = new DatabaseSetup(_client);
	await dbSetup.Init(DatabaseId, CollectionId);

	string customer1Id = Guid.NewGuid().ToString();

	dynamic[] customers = {
	new Customer(customer1Id, "Test2 Customer1"),
	new Customer(Guid.NewGuid().ToString(), "")
	};

	var sproc = dbSetup.Client.CreateStoredProcedureQuery(dbSetup.Collection.SelfLink).Where(x => x.Id == "sp_bulkinsert").AsEnumerable().First();
	await dbSetup.Client.ExecuteStoredProcedureAsync<int>(sproc.SelfLink, new dynamic[] {customers}).ShouldThrowAsync<DocumentClientException>();

	var document = (from f in dbSetup.Client.CreateDocumentQuery(dbSetup.Collection.SelfLink)
	where f.Id == customer1Id
	select f).AsEnumerable().FirstOrDefault();

	document.ShouldBeNull();
	}
	}
	}

view raw client.cs hosted with ❤ by GitHub

Demo Source Code

I’ve put together a small .NET Core sample with an XUnit test from above. All the source code for this series is available on GitHub.

Are you using Azure Cosmos DB? I’d love to hear your experiences so far along. Let me know on twitter or in the comments.

Follow @codeopinion

3 thoughts on “Azure Cosmos DB Transactions from .NET”

Onur April 12, 2017 at 1:52 am


The thing I don’t like about documentdb is that it doesn’t support aggregations nor paging.
1. Derek Comartin April 12, 2017 at 7:15 am
  
  
  Pretty sure you can accomplish paging via sending the RequestContinuation in the FeedOptions using the .NET SDK. I’ll create a post around this to demo.
2. Derek Comartin April 17, 2017 at 12:27 pm
  
  
  I’ve created a post on how to implement query continuations. I realize this isn’t full on paging, but worth mentioning the capabilities.
  https://codeopinion.com/paging-documentdb-query-results-from-net/