So, we have a perf problem in the managed leveldb implementation. I pulled out dotTrace and looked at the numbers:

Do you see where the problem is?

I used the following in a lecture called “Why you should never write your own database”. It has never been run, tested, or anything, but it serves as a good way to discuss the challenges involved in building real world  databases.

Here is the server side code:

   1: public class NoSqlDbController : ApiController

   2: {

   3:     static readonly ConcurrentDictionary<string, byte[]> data = 

   4:         new ConcurrentDictionary<string, byte[]>(StringComparer.InvariantCultureIgnoreCase); 

   5:  

   6:     public HttpResponseMessage Get(string key)

   7:     {

   8:         byte[] value;

   9:         if(data.TryGetValue(key, out value) == false)

  10:             return new HttpResponseMessage(HttpStatusCode.NotFound);

  11:  

  12:         return new HttpResponseMessage

  13:             {

  14:                 Content = new ByteArrayContent(value)

  15:             };

  16:     }

  17:  

  18:     public void Put(string key, [FromBody]byte[] value)

  19:     {

  20:         data.AddOrUpdate(key, value, (_, __) => value);

  21:     }

  22:  

  23:     public void Delete(string key)

  24:     {

  25:         byte[] value;

  26:         data.TryRemove(key, out value);

  27:     }

  28: }

And the client side code:

   1: public class NoSqlDbClient

   2: {

   3:     private readonly HttpClient[] clients;

   4:  

   5:     public NoSqlDbClient(string[] urls)

   6:     {

   7:         clients = new HttpClient[urls.Length];

   8:         for (var i = 0; i < urls.Length; i++)

   9:         {

  10:             clients[i] = new HttpClient { BaseAddress = new Uri(urls[i]) };

  11:         }

  12:     }

  13:  

  14:     public Task PutAsync(string key, byte[] data)

  15:     {

  16:         var client = clients[key.GetHashCode()%clients.Length];

  17:         return client.PutAsync("?key=" + key, new ByteArrayContent(data));

  18:     }

  19:  

  20:     public Task DeleteAsync(string key, byte[] data)

  21:     {

  22:         var client = clients[key.GetHashCode() % clients.Length];

  23:         return client.DeleteAsync("?key=" + key);

  24:     }

  25:  

  26:     public async Task<byte[]> GetAsync(string key)

  27:     {

  28:         var client = clients[key.GetHashCode() % clients.Length];

  29:         var r = await client.GetAsync("?key=" + key);

  30:         return await r.Content.ReadAsByteArrayAsync();

  31:  

  32:     }

  33: }

And yes, that is a fully functional, scale out capable, sharding enabled No SQL Key/Value store in less than 60 lines of code.

Do you see it? It took me ages to find it.

I am not sure what to think about this, to be perfectly honest. But it is quite funny.