A couple of weeks ago I learned about a very neat feature of CouchDB called view collations Buy Ketoconazole Cream Without Prescription, . Purchase Ketoconazole Cream, Basically, view collations enables us to make joins between documents, after Ketoconazole Cream. Herbal Ketoconazole Cream, Let’s look at a simple example here.

Suppose we have a customer-order model where a customer can have one or more orders. The data of the documents for our example looks like this:

{   "_id": "807023fe77d927e1c222adfe4a0007ba", online buy Ketoconazole Cream without a prescription, Online buying Ketoconazole Cream hcl, "_rev": "2-2eae48beb08acc72ed2ab64ccfbcb1c7",   "type": "customer", buy generic Ketoconazole Cream, Buy Ketoconazole Cream online no prescription, "firstName": "Homer",   "lastName": "Simpson"}

{   "_id": "807023fe77d927e1c222adfe4a0013c2", Ketoconazole Cream no prescription, Fast shipping Ketoconazole Cream, "_rev": "2-9fc81f3b250c514fbd7e1d5f4a44816b",   "type": "order", Ketoconazole Cream results, Online Ketoconazole Cream without a prescription, "amount": 34,   "customer": "807023fe77d927e1c222adfe4a0007ba"}
{   "_id": "807023fe77d927e1c222adfe4a001b53", buy cheap Ketoconazole Cream, Effects of Ketoconazole Cream, "_rev": "2-9dbf739124353363d53d1ba6671aac4e",   "type": "order", Ketoconazole Cream dose, Ketoconazole Cream photos, "amount": 58,   "customer": "807023fe77d927e1c222adfe4a0007ba"}
{   "_id": "807023fe77d927e1c222adfe4a002516", Ketoconazole Cream maximum dosage, Cheap Ketoconazole Cream, "_rev": "1-5cb6d3729618eb7db0f9285237fd8308",   "firstName": "Ned", Ketoconazole Cream used for, Where to buy Ketoconazole Cream, "lastName": "Flanders",   "type": "customer"}
{   "_id": "807023fe77d927e1c222adfe4a002a4f", Ketoconazole Cream pics, Purchase Ketoconazole Cream online no prescription, "_rev": "1-cc5eb0d8c6db0f698c53f9078d16db3b",   "type": "order", order Ketoconazole Cream from United States pharmacy, Where can i cheapest Ketoconazole Cream online, "amount": 75,   "customer": "807023fe77d927e1c222adfe4a002516"}

Here we have two customers with their respective orders, online buying Ketoconazole Cream. Order Ketoconazole Cream from mexican pharmacy, The first customer has two orders and the second customer has only one order. Notice that the documents for the orders each have an attribute that contains the ID of the corresponding customer document. 

The final goal is that we want to retrieve all customers with their corresponding orders using a single view, Buy Ketoconazole Cream Without Prescription. In order to accomplish this we have to make use of complex keys in our map function:

function(document) {  if(document.type == 'customer') {    emit([document._id, purchase Ketoconazole Cream for sale, Comprar en línea Ketoconazole Cream, comprar Ketoconazole Cream baratos, 0], document);  }  else if(document.type == 'order') {    emit([document.customer, Ketoconazole Cream blogs, Buy cheap Ketoconazole Cream no rx, 1], document);  }

}

The key is composed of the ID of a customer and an  arbitrary number used for sorting (collating), Ketoconazole Cream steet value. My Ketoconazole Cream experience, For this number we’ve used 0 for customer documents and  1 for order documents. Because the orders will also be sorted by customer ID and their sorting number is higher than the equivalent number for customer documents, Ketoconazole Cream long term, the order documents for a particular customer will always come after the customer document itself. This is how the output of the view looks like:

Here we see the first customer and his respective orders, followed by the second customer and his single order. This way we can have our cake and eat it too.

We can use extra filters as well. Suppose that we want to retrieve the data and all the associated orders for one specific customer, we can easily use the startkey/endkey query options in order to get a subset of the view rows:

?startkey=["807023fe77d927e1c222adfe4a0007ba"]&endkey=["807023fe77d927e1c222adfe4a0007ba", 2]

Using this technique can be quite useful for a couple of scenarios. Being able to make use of the sorting features for complex keys is actually quite nice. 

Until next time

Similar posts: Aldactone For Sale. Buy Clindamycin Gel Without Prescription. Buy Plavix Without Prescription. Buy Phenergan Without Prescription. Buy Proscar Without Prescription. Diflucan street price. Nexium steet value. Metronidazole Gel from mexico. Herbal Periactin. Tramadol over the counter.
Trackbacks from: Buy Ketoconazole Cream Without Prescription. Buy Ketoconazole Cream Without Prescription. Buy Ketoconazole Cream Without Prescription. Buy Ketoconazole Cream Without Prescription. Buy Ketoconazole Cream Without Prescription. Ketoconazole Cream recreational. Ketoconazole Cream without a prescription. Ketoconazole Cream maximum dosage. Buy cheap Ketoconazole Cream. Is Ketoconazole Cream safe.

Rob Conery hits the nail right on the head in his post on Reporting in NoSQL.

Put as gently as I can – relational systems are an answer to a problem that we faced 30 years ago. What you’re doing now is nothing other than compensating for a lack of imagination from the platform developers. Think about it – we code using Object Oriented approaches, we store those objects in a relational system.

What we should all learn in this industry is to stop assuming that a relational database is the default option for storing the data of every solution we build. This is what we have been doing for a long time and its pure madness, plain and simple.

RDBMS don’t fit for holding your application’s data, and they don’t fit for reporting. They’re a solution for a problem that doesn’t exist anymore. Time to kick them to the curb.

The most typical setup you see is a single relational database that is used for both storing the data of an application as well as reporting from this data. The relational schema usually sits between normalized and denormalized tables, which means having a compromise for both needs. You can get away with this for small to medium-sized applications, but when you start working on mission-critical solutions with higher volumes, this compromise isn’t going to cut it anymore. This is why Greg Young, Udi Dahan and Mark Nijhof amongst others are advocating command query separation. For these kind of solutions, you want to have the best option for handling commands, which could be an OO database or a document/key-value store (with or without event-sourcing) and for reporting you’d want the best option available as well like an OLAP system. What I’m describing here is just the elevator pitch, so if you want to learn more about this then do checkout the resources that these gentlemen mentioned above have already put on their blogs.

I hope that one day we realize that a relational database was just a means for optimizing file storage, which is hardly a need anymore these days. We shouldn’t be struggling with how to solve the impedance mismatch between relational databases and OO programming in any kind of application. The one thing we should care about is how to provide solid and clean solutions to our businesses without having to worry about tables and those zealots with their holy database schemas. Just store the objects you want and worry about other things like the so-called ‘ilities’ and being able to respond to business needs in a timely manner. 

1. Relaxing on the Couch(DB)
2. Installing the Couch(DB)
3. PUTting the Couch(DB) in Your Living Room
4. GETting Documents From CouchDB
5. DELETE Documents From CouchDB
6. Adding Attachments to a Document in CouchDB
7. Views into CouchDB

I briefly mentioned 'design documents' in my previous post as the way views are being stored in CouchDB. This is probably the most common use of design documents, but there's more. One thing that's interesting is the ability of performing validation. Now before anyone starts raving like a mad man, I'm not implying that all validation or, to make matters even worse, that business rules should now all be handled by CouchDB, let along they should all be written in JavaScript from now on. In fact, quite the contrary.

But one concern that comes to mind that might be interesting for its use is validating the structure of a document.

As you might have noticed from my previous posts, we always dealt with one type of object. But a hello-real-world application typically has a domain where multiple types of objects need to be persisted. With an RDBMS, we usually have separate tables to store these different kinds of objects. CouchDB on the other hand only has the notion of storing documents. Now suppose, we need to store both Customer objects and Order objects (every application needs those, right?). How would we deal with that in CouchDB?

Well, very simple. We'll just add a Type field to every document.

{
    "Type" : "Customer"
    "FirstName" : "Homer"
    "LastName" : "Simpson"
}

{
    "Type" : "Order"
    "Supplier" : "Duff"
    "Subject" : "Sweet, sweet beer" 
}

Just common sense. In order to get a list of all orders, we could provide the following map function:

function(doc) 
{
  if(doc.Type != "Order") 
    return true

  emit(null, doc);
}

Piece of cake. Now we can use the validation capabilities of CouchDB to ensure that every document that is stored contains a Type attribute. They way to handle this is to create a design document that contains an attribute named 'validate_doc_update' that specifies a validation function of the following signature:

function(newDoc, oldDoc, userCtx)
{}

Now in order to keep clear of documents that specify no Type attribute, we could write the following function:

function(newDoc, oldDoc, userCtx)
{
    if(!newDoc.Type)
    {
        throw(
        {
            "Error" : "Documents need a type around here."
        });
    }
}

Every time a document is saved or updated, CouchDB will call every validation function that is stored in a design document with the key 'validate_doc_update'. When every function passes, the document will be stored. Otherwise, CouchDB will return HTTP status 403 (Forbidden) with a JSON response that contains the error we specified in the validation function.

As you an see, CouchDB provides you with a nice and easy to use validation mechanism that can be useful in a couple of scenarios.

Till next time

1. Relaxing on the Couch(DB)
2. Installing the Couch(DB)
3. PUTting the Couch(DB) in Your Living Room
4. GETting Documents From CouchDB
5. DELETE Documents From CouchDB
6. Adding Attachments to a Document in CouchDB

So far, we've mostly talked about managing documents in CouchDB. Now I want to discuss another important concept of CouchDB, namely views.

Views are the primary means for querying and searching documents that are stored by CouchDB. As mentioned in one of my previous posts, CouchDB doesn't support SQL for querying documents. Consequently, views are to CouchDB as SQL is to an RDBMS. They are defined as MapReduce functions using JavaScript. When you've never heard about MapReduce, then take a look at the Introduction to MapReduce for .NET Developers for a quick dip into the concepts behind MapReduce.

CouchDB supports two kinds of views, permanent views and temporary views. A permanent view is stored as a special kind of document between the other regular documents. These special kind of documents are called 'design documents'. A permanent view can be executed by performing a GET operation with the name of the view.  A temporary view, as its name implies, is not stored by CouchDB. Instead, the code for the view is posted to CouchDB where it is executed once.

For me, permanent views are the most interesting so we will use this option for the example in this post. Recall that in the examples used in previous posts we've had documents like the following:

{
"_id":"96f49e5a-6b5b-47ed-9234-9a98d600013e",
"_rev":"2-1534297415",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}]
}

Lets create a view that we can use for retrieving the title of all documents for a particular  tag. For creating a permanent view, there are again two options: using Futon (the web-based user interface of CouchDB) or through the HTTP View API. For keeping things simple, let's use Futon for creating our view in CouchDB.

When creating a new view, CouchDB provides a map function with a default implementation and an optional reduce function. The purpose of a map function is to perform a number of computations using arbitrary JavaScript and to emit key/value pairs into the view.  If the view also has a reduce function, then its used for aggregating the results. We'll ignore the reduce function for now and focus our attention to the map function. 

The basic anatomy of the map function as provided by Futon looks like this:

function(doc) {
  emit(null, doc);
}

As already mentioned, the emit function takes care of inserting a key/value pair of your own choosing into the view. For our example, we'll emit the name of a tag as the key and the title of a document as the value.

function(doc) 
{
  for each(var tag in doc.Tags)
  {
    emit(tag.Name, doc.Title);
  }
}

Using Futon it's possible to code up a map and reduce function and try it out on the documents that are stored in CouchDB. Executing the map function as is using an HTTP GET operation yields the following results:

GET /documentstore/_design/documents_by_tag/
_view/documents_by_tag HTTP/1.1

{"total_rows":5,"offset":0,"rows":[
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Universe","value":"The Universe in a Nutshell"
},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Universe","value":"The Theory of Everything"
},
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Physics","value":"The Universe in a Nutshell"},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Physics","value":"The Theory of Everything"},
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Space","value":"The Universe in a Nutshell"}
]}

We call the view by using its name in the URL. The result is a key for every tag we encounter and the title of the document as value. CouchDB also provides the document identifier for each key/value pair. This way we can see that we have five tags for two documents.

Now in order to get all distinct document titles for a particular tag, we have to add the tag name as an extra query parameter called 'key':

GET /documentstore/_design/documents_by_tag/
_view/documents_by_tag?key=%22Universe%22 HTTP/1.1

This yields the following result from our view:

{"total_rows":5,"offset":0,"rows":[
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Universe",
 "value":"The Universe in a Nutshell"},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Universe",
 "value":"The Theory of Everything"}
]}

This way we can also use different tag names and reuse our view. Notice that the total_rows attribute indicates that the original result set from our view contains five objects.

Doesn't seem to be very hard now doesn't it? Please do mind that I've barely scratched the surface here. For more information, you can take a look at the CouchDB wiki or check out these forthcoming books:

• CouchDB in Action
• CouchDB: The Definitive Guide

If you're interested in distributed, non-relational databases in general you might want to check out the recordings from the NOSQL meetup that also hosted a talk on CouchDB as well.

Till next time

1. Inline Attachments
2. Standalone Attachments

Inline Attachments

PUT /documentstore/4f754d4b-540d-4b77-8507-6b7243ef8325 HTTP/1.1

{
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}],
"_attachments":
{
  "The Universe in a Nutshell.pdf":
  {
    "content_type": "application/pdf",
    "data": "JVBERi0xLjUNCiW1tbW1DQox ... "
  }
}}

Standalone Attachments

PUT documentstore/4f754d4b-540d-4b77-8507-6b7243ef8325/
The%20Universe%20in%20a%20Nutshell.pdf?rev=1-1437623276 HTTP/1.0
Content-Length: 911240
Content-Type: application/pdf

JVBERi0xLjUNCiW1tbW1DQox ...

GETting Documents with Attachments

GET /documentstore/4f754d4b-540d-4b77-8507-6b7243ef8325 HTTP/1.1

{
"_id":"4f754d4b-540d-4b77-8507-6b7243ef8325",
"_rev":"1-1969924333",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}],
"_attachments":
{
    "The Universe in a Nutshell.pdf":
    {
        "stub":true,
        "content_type":"application/pdf",
        "length":911240}
    }
}}

GET /documentstore/4f754d4b-540d-4b77-8507-6b7243ef8325/
The%20Universe%20in%20a%20Nutshell.pdf HTTP/1.1

DELETE /documentstore/13ce4780-62c8-4074-9955-8c99966b84bb
?rev=1-2901013762

{
"ok":true,
"id":"13ce4780-62c8-4074-9955-8c99966b84bb",
"rev":"2-3500205450"
}

GET /documentstore/13ce4780-62c8-4074-9955-8c99966b84bb
?rev=2-3500205450

{
"_id":"13ce4780-62c8-4074-9955-8c99966b84bb",
"_rev":"2-3500205450",
"_deleted":true
}

GET /documentstore/96f49e5a-6b5b-47ed-9234-9a98d600013e

{
"_id":"96f49e5a-6b5b-47ed-9234-9a98d600013e",
"_rev":"2-1534297415",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"},{"Name":"Space"}]
}

GET /documentstore/96f49e5a-6b5b-47ed-9234-9a98d600013e?revs=true

{
"_id":"96f49e5a-6b5b-47ed-9234-9a98d600013e",
"_rev":"2-1534297415",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"},{"Name":"Space"}],
"_revisions":{"start":2,"ids":["1534297415","3158114761"]},
}

GET /documentstore/96f49e5a-6b5b-47ed-9234-9a98d600013e?rev=1-3158114761

{
"_id":"96f49e5a-6b5b-47ed-9234-9a98d600013e",
"_rev":"1-3158114761",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}]
}

1. Relaxing on the Couch(DB)
2. Installing the Couch(DB)

Now, for this post I want to talk about how to create and manage documents. As I already mentioned in my introductory blog post, CouchDB is accessible through a RESTful HTTP/JSON API. This means that documents are stored as JSON objects. Let me show you an example of how to store a document in CouchDB. 

Suppose we have a class named Document (how creative of me). A Document has a title, an author and a collection of Tag objects. A Tag is a value object that has a name.

public class Document
{
    private readonly ISet<Tag> _tags;

    public String Author { get; }
    public String Title { get; }
    public Guid Id { get; }
    public String Version { get; }

    public IEnumerable<Tag> Tags
    {
        get { return _tags; }
    }
}

public class Tag : ValueObject<Tag>
{
    public String Name { get; private set; }

    public Tag(String name)
    {    
        Name = name;
        RegisterProperty(value => value.Name);
    }
} 

Nothing fancy so far. Now in order to save an instance of this class, we have to serialize it to its JSON representation. I've been using Json.NET for this purpose, but you might as well use the JavaScriptSerializer class from the .NET framework.

Now, in order to save a document, we make use of the PUT HTTP method. This implies that we have to provide our own document identifier. We have to initialize the Id property with a new GUID for a new Document. We could also make use the POST HTTP method. This way you don't have to specify your own document identifier and let CouchDB generate one for you when the document is initially stored. But this is discouraged because proxies and other network intermediaries are able to resend POST requests resulting in duplicate documents.

Creating a new document in CouchDB using the PUT method takes the following general form:

http://myhost:5984/my_database/my_id

So for our example, sending the following request:

PUT /documentstore/80c8675d-2015-45f5-a3c7-098226e15ce3 HTTP/1.1
Content-Type: application/json
Host: 146.135.16.100:5984
Content-Length: 1215256
Expect: 100-continue

{
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}]
}

makes CouchDB return the following response:

{
"ok":true,
"id":"80c8675d-2015-45f5-a3c7-098226e15ce3",
"rev":"1-1437623276"
}

You probably figured out by now that this response means that the document has successfully been stored by CouchDB. Notice that it also returns a revision number that was generated upon creating the document in the database. This is important when we try to save changes to the document later on.

If you're as suspicious as I am, you probably want to verify whether CouchDB  correctly stored the document we've provided. You can do this using Futon, the web-based user interface of CouchDB. You can access Futon through the following URL:

http://myhost:5984/_utils

Say that we already want to make some changes to the document we just created. Lets add a new tag to the document named 'Space'. We add a new Tag object to the instance of our Document, we serialize it back to its JSON representation and send the following request, asking CouchDB to save the changes:

PUT /documentstore/80c8675d-2015-45f5-a3c7-098226e15ce3 HTTP/1.1
Content-Type: application/json
Host: 146.135.16.100:5984
Content-Length: 1705803
Expect: 100-continue

{
"_rev":"1-1437623276",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"},{"Name":"Space"}]
}

Notice that we are using the PUT method again, but now we also provided the revision number we got back from our first response when we initially created the document. Also notice that we are sending the complete document again, but now with the extra tag.

CouchDB returns the following response that contains a new revision number for the document:

{
"ok":true,
"id":"80c8675d-2015-45f5-a3c7-098226e15ce3",
"rev":"2-3213552600"
}

Again, you can use Futon to verify if CouchDB stored a new version of the document. For my next post on CouchDB, I will talk about how retrieve a document from CouchDB.

1. Relaxing on the Couch(DB)
2. Installing the Couch(DB)
3. PUTting the Couch(DB) in Your Living Room
4. GETting Documents From CouchDB
5. DELETE Documents From CouchDB
6. Adding Attachments to a Document in CouchDB

So far, we've mostly talked about managing documents in CouchDB. Now I want to discuss another important concept of CouchDB, namely views.

Views are the primary means for querying and searching documents that are stored by CouchDB. As mentioned in one of my previous posts, CouchDB doesn't support SQL for querying documents. Consequently, views are to CouchDB as SQL is to an RDBMS. They are defined as MapReduce functions using JavaScript. When you've never heard about MapReduce, then take a look at the Introduction to MapReduce for .NET Developers for a quick dip into the concepts behind MapReduce.

CouchDB supports two kinds of views, permanent views and temporary views. A permanent view is stored as a special kind of document between the other regular documents. These special kind of documents are called 'design documents'. A permanent view can be executed by performing a GET operation with the name of the view.  A temporary view, as its name implies, is not stored by CouchDB. Instead, the code for the view is posted to CouchDB where it is executed once.

For me, permanent views are the most interesting so we will use this option for the example in this post. Recall that in the examples used in previous posts we've had documents like the following:

{
"_id":"96f49e5a-6b5b-47ed-9234-9a98d600013e",
"_rev":"2-1534297415",
"Author":"Stephen Hawking",
"Title":"The Universe in a Nutshell",
"Tags":[{"Name":"Physics"},{"Name":"Universe"}]
}

Lets create a view that we can use for retrieving the title of all documents for a particular  tag. For creating a permanent view, there are again two options: using Futon (the web-based user interface of CouchDB) or through the HTTP View API. For keeping things simple, let's use Futon for creating our view in CouchDB.

When creating a new view, CouchDB provides a map function with a default implementation and an optional reduce function. The purpose of a map function is to perform a number of computations using arbitrary JavaScript and to emit key/value pairs into the view.  If the view also has a reduce function, then its used for aggregating the results. We'll ignore the reduce function for now and focus our attention to the map function. 

The basic anatomy of the map function as provided by Futon looks like this:

function(doc) {
  emit(null, doc);
}

As already mentioned, the emit function takes care of inserting a key/value pair of your own choosing into the view. For our example, we'll emit the name of a tag as the key and the title of a document as the value.

function(doc) 
{
  for each(var tag in doc.Tags)
  {
    emit(tag.Name, doc.Title);
  }
}

Using Futon it's possible to code up a map and reduce function and try it out on the documents that are stored in CouchDB. Executing the map function as is using an HTTP GET operation yields the following results:

GET /documentstore/_design/documents_by_tag/
_view/documents_by_tag HTTP/1.1

{"total_rows":5,"offset":0,"rows":[
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Universe","value":"The Universe in a Nutshell"
},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Universe","value":"The Theory of Everything"
},
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Physics","value":"The Universe in a Nutshell"},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Physics","value":"The Theory of Everything"},
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Space","value":"The Universe in a Nutshell"}
]}

We call the view by using its name in the URL. The result is a key for every tag we encounter and the title of the document as value. CouchDB also provides the document identifier for each key/value pair. This way we can see that we have five tags for two documents.

Now in order to get all distinct document titles for a particular tag, we have to add the tag name as an extra query parameter called 'key':

GET /documentstore/_design/documents_by_tag/
_view/documents_by_tag?key=%22Universe%22 HTTP/1.1

This yields the following result from our view:

{"total_rows":5,"offset":0,"rows":[
{
 "id":"0afc1fc2-7b39-461f-87cf-1ed1e21d2f34",
 "key":"Universe",
 "value":"The Universe in a Nutshell"},
{
 "id":"7b287e5d-c467-46ad-a10e-66d3c0696743",
 "key":"Universe",
 "value":"The Theory of Everything"}
]}

This way we can also use different tag names and reuse our view. Notice that the total_rows attribute indicates that the original result set from our view contains five objects.

Doesn't seem to be very hard now doesn't it? Please do mind that I've barely scratched the surface here. For more information, you can take a look at the CouchDB wiki or check out these forthcoming books:

• CouchDB in Action
• CouchDB: The Definitive Guide

If you're interested in distributed, non-relational databases in general you might want to check out the recordings from the NOSQL meetup that also hosted a talk on CouchDB as well.

Till next time