This article is a major Kudos to the CouchDB developers. In particular I would like to thank Jan Lehnardt, Paul J. Davis and Robert Newson from the CouchDB fame. Let me explain why…

For all the skeptics (As I was and still am with some concepts) I have to admit that jumping both feet into CouchDB is scary, especially coming from an RDBMS-core background. I think in joins, I see relations, I’m a normalized database person. Coming with the idea that de-normalization can actually be ok if it’s done correctly was hell for me.

So the first things we did when using Couch was creating databases, until then, in my head, using “many” databases was always a big no-no simply because it was making management of connections and everything hectic. However, with CouchDB it’s a bit different and that’s a concept that Jan helped me understand and it can indeed be correctly done if planned thoroughly.

After finding myself in many dead-ends after starting CouchDB, the previously mentioned helpers were always there even for the simplest, most ridiculous questions I could have answered myself by re-reading my questions.

Imagine the following scenario where you have a list of documents that have two fields. “time” and “type“. the “type” field can be either “love” or “hate” and and “time” field is a unix timestamp (php -r ‘echo time() . PHP_EOL;’).

We need to create views in order to retrieve the data. The first scenario involves counting the amount of types. So how many documents with type “love” and how many documents (entries) with the field type with value “hate“.

You will mostly likely have to do a reduce function as well as your view. So using futon you can create your simple view that’ll look like such:

View:

1
2
3
4
5

function(doc) {
    if(doc.type) {
        emit(doc.type, 1);
    }
}

and your reduce function to look somewhat like:

1
2
3

function(key, values) {
    return sum(values);
}

Now Save this as design document “example” and view name “countdocbytype“. (See image below)

This is all very nice but what does that give you the ability of doing? Remember that “WHERE type = ‘get’” in SQL? Well now that you saved that view you can effectively search on the key you are returning in your emit() function. In this case you are returning the doc.type thus “hate” or “love” which means that if you want to get a count of type “hate” you will invoke your view as such:

http://localhost:5984/databasename/_design/example/_view/countdocbytype?group=true&key=”hate”

Remember that this is all JSON lovin’ so the key you are passing has to be JSON encoded (So key=”hate“ instead of key=hate). This view (Query for SQL people) will return a count of entries/documents with the field “type” that has the value “hate”

For the second example let’s introduce a new field in our documents, let’s name the field “phone” and it’ll be “iphone” and “android“. Update your documents and put as many “iphone” and “androids” as you want. The next example is going to be finding how many people hate iphones (This implies searching for a count of field “phone” with value “iphone” and field “type” with value “hate“).

Documents updated? Good.

Now let’s make our view:

1
2
3
4
5
6

function(doc) {
    if (doc.phone && doc.type) {
        var keys = [doc.phone, doc.type];
        emit(keys, 1);
    }
}

and the reduce to return a sum of the values:

1
2
3

function(key, values) {
    return sum(values);
}

In Futon it would look somewhat like:

With the results looking like:

So now again save it as design “example” and view name “countdocbyphoneandtype” and now you can invoke the following URL.

http://localhost:5984/databasename/_design/example/_view/countdocbyphoneandtype?group=true&key=["iphone", "hate"]

As you can see, we are passing an array in the “key” field with the values “iphone” and “hate“. This retrieves all the “phone” fields with value “iphone” and then from that resultset all the field “type” with value “hate“. It gives us the following type of output:

1
2
3
4
5
6

{
    "rows":[{
        "key":["iphone","hate"],
        "value":2
    }]
}

You now have a query that searches for “two” fields in your document.

I strongly suggest to read the wiki and anything related to views if you are remotely interested in using CouchDB as they are going to be your main source of nightmares and happiness. The latter example, was nicely explained to me on the IRC channel even though it was plain black and white on the wiki… Apparently I just couldn’t see it clearly enough. There are loads of little things with the views that require user experience instead of wiki reading and the people on the IRC channel have used CouchDB, they’ll get you by

Moving on, on top of many exciting upcoming features (as such as continuous replication, bulk inserts, etc.) the project has online documentation, online books for people to read for free (Even though I strongly recommend buying the book), a vibrant IRC channel with the nicest helpers from extensive users to software developers/creators to book authors.

When in need of direction, if you really can’t find it online or don’t understand how it’s explained, you can hop on the IRC channel and get your well formulated questions answered at all times. With a thorough patch review process and code quality insurance,in my opinion, it makes CouchDB a very solid open source project that should be respected and should serve as example for any new software that wants to make it into the open source world.

At first, I first had a hack that involved handling the “keyup” event myself then sending a request to a JSON URL, and then involve the “autocompleteArray” method from Autocomplete. It was a mess considering that the autocomplete method is already sending the value of your defined input to the server as a GET parameter. I was repeating the behavior of the function in order to receive a simple JSON array. I was unhappy, and felt it to be a very annoying solution because I wanted to take advantage of the internal caching system of jQuery Autocomplete.

So I decided to give a look at the code and came up with a much cleaner solution. I directly added a JSON option to the Autocomplete. So for anyone interested you can find the patch here: jQuery Autocomplete JSON patch.

The first step thing you’ll need is to patch Autocomplete using the patch command (Google patch) and then include the jQuery and Autocomplete JavaScript sources into your code.

1
2
3
4
5

<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="jquery.autocomplete.js"></script>
<style type="text/css">
    @import "jquery.autocomplete.css";
</style>

Once you are done, you need to setup your input field on which the autocomplete calls and function is going to be executed from.

1

<input type="text" size="25" id="input" />

And of course you need to make the event hook to make sure your autocomplete is done but in the hook you need to make sure the new option “json” is set to true. This is how you proceed:

1
2
3

$(function() {
    $('#input').autocomplete('url.php', {json: true});
});

The complete version should look somewhat like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
  <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   <style type="text/css">
       @import "jquery.autocomplete.css";
   </style>
  </head>
  <body>
   <label for="input">Input any text</label>
   <input type="text" id="input" />
  </body>
  <script type="text/javascript" src="jquery.js"></script>
  <script type="text/javascript" src="jquery.autocomplete.js"></script>
  <script type="text/javascript">
      $(function() {
          $('#input').autocomplete('url.php', {json: true});
      });
  </script>
</html>

You can even try it now if you want.