Merge lp:~hingo/drizzle/drizzle-json_server-keyvalue into lp:drizzle

[Henrik Ingo]

This is 0.2 of json_server plugin. It adds a "pure json" key value api at the uri /json/. (The previous sql-over-http api is at URI /sql/.)

The new functionality still lacks tests, and all of this lacks documentation. We are already working on both, however it would be good to merge this now, because it is easier for us to work against trunk. We will shortly follow up with more tests and docs.

[Brian Aker (brianaker)]

Started by upstream project "drizzle-build" build number 1994
Building remotely on ubuntu-11.04-slicehost-174.143.253.46 in workspace /home/jenkins/workspace/drizzle-build-ubuntu-debug

Deleting project workspace... done

Cleaning workspace...
$ bzr branch lp:drizzle/build /home/jenkins/workspace/drizzle-build-ubuntu-debug
You have not informed bzr of your Launchpad ID, and you must do this to
write to Launchpad or access private data. See "bzr help launchpad-login".
Branched 2556 revision(s).
Getting local revision...
$ bzr revision-info -d /home/jenkins/workspace/drizzle-build-ubuntu-debug
info result: bzr revision-info -d /home/jenkins/workspace/drizzle-build-ubuntu-debug returned 0. Command output: "2556 <email address hidden>
" stderr: ""
RevisionState revno:2556 revid:<email address hidden>
[drizzle-build-ubuntu-debug] $ /bin/sh -xe /tmp/hudson1749308941142382677.sh
+ ./config/autorun.sh
: running `python config/pandora-plugin write'
: running `/usr/bin/autoreconf --install --force --verbose -Wall'
autoreconf: Entering directory `.'
autoreconf: configure.ac: not using Gettext
autoreconf: running: aclocal --force --warnings=all -I m4 --force
autoreconf: configure.ac: tracing
configure.ac:27: warning: The macro `AC_PROG_LIBTOOL' is obsolete.
configure.ac:27: You should run autoupdate.
aclocal.m4:123: AC_PROG_LIBTOOL is expanded from...
m4/pandora_libtool.m4:6: PANDORA_LIBTOOL is expanded from...
m4/pandora_canonical.m4:41: PANDORA_CANONICAL_TARGET is expanded from...
configure.ac:27: the top level
configure.ac:27: warning: The macro `AC_LANG_SAVE' is obsolete.
configure.ac:27: You should run autoupdate.
../../lib/autoconf/lang.m4:126: AC_LANG_SAVE is expanded from...
../../lib/m4sugar/m4sh.m4:598: AS_IF is expanded from...
../../lib/autoconf/general.m4:2019: AC_CACHE_VAL is expanded from...
../../lib/autoconf/general.m4:2040: AC_CACHE_CHECK is expanded from...
m4/pandora_header_stdcxx_98.m4:21: AC_CXX_HEADER_STDCXX_98 is expanded from...
m4/pandora_check_cxx_standard.m4:6: PANDORA_CHECK_CXX_STANDARD is expanded from...
configure.ac:27: warning: The macro `AC_LANG_CPLUSPLUS' is obsolete.
configure.ac:27: You should run autoupdate.
../../lib/autoconf/c.m4:252: AC_LANG_CPLUSPLUS is expanded from...
configure.ac:27: warning: The macro `AC_TRY_COMPILE' is obsolete.
configure.ac:27: You should run autoupdate.
../../lib/autoconf/general.m4:2602: AC_TRY_COMPILE is expanded from...
configure.ac:27: warning: The macro `AC_LANG_RESTORE' is obsolete.
configure.ac:27: You should run autoupdate.
../../lib/autoconf/lang.m4:135: AC_LANG_RESTORE is expanded from...
m4/pandora_cstdint.m4:12: PANDORA_CXX_CSTDINT is expanded from...
m4/pandora_cinttypes.m4:12: PANDORA_CXX_CINTTYPES is expanded from...
configure.ac:27: warning: The macro `AC_CHECK_LIBM' is obsolete.
configure.ac:27: You should run autoupdate.
aclocal.m4:3301: AC_CHECK_LIBM is expanded from...
m4/pandora_visibility.m4:23: PANDORA_CHECK_VISIBILITY is expanded from...
m4/pandora_visibility.m4:71: PANDORA_ENABLE_VISIBILITY is expanded from...
configure.ac:27: warning: AC_RUN_IFELSE called without default to allow cross compiling
../../lib/autocon...

[Henrik Ingo (hingo)]

Right. json_server now requires version 2.0 of libevent library. I've now pushed an addition to pandora_have_libevent.m4 that adds a PANDORA_LIBEVENT_RECENT check. Basically, you need Ubuntu Oneiric or newer to have libevent 2.0, otherwise json_server will not be built. (I don't know about Fedora, on Centos I think they still have too old libevent.)

Also pushed the documentation that we finished on Friday.

review: Needs Resubmitting

=== modified file 'drizzled/plugin/client/cached.h'
--- drizzled/plugin/client/cached.h	2011-12-23 09:24:47 +0000
+++ drizzled/plugin/client/cached.h	2012-05-20 15:31:19 +0000
@@ -47,17 +47,20 @@
   virtual void sendFields(List<Item>& list)
   {
     List<Item>::iterator it(list.begin());
-
     column= 0;
     max_column= 0;
 
     while (Item* item= it++)
     {
-      SendField field;
+      // max_column starts from 0, ColumnCount from 1
+      _result_set->setColumnCount(max_column+1);
+      // Get pointer to next column metadata class
+      SendField field = _result_set->getColumnInfo(max_column);
       item->make_field(&field);
+      // Is this necessary or does it just set the same pointer back?
+      _result_set->setColumnInfo(max_column, field);
       max_column++;
     }
-    _result_set->setColumnCount(max_column);
     // Moved to checkRowBegin()
     //_result_set->createRow();
   }
@@ -75,7 +78,7 @@
     }
   }
 
-virtual void checkRowEnd()
+  virtual void checkRowEnd()
   {
     column++;
   }
 
=== modified file 'drizzled/sql/result_set.h'
--- drizzled/sql/result_set.h	2011-04-21 05:05:53 +0000
+++ drizzled/sql/result_set.h	2012-05-20 15:31:19 +0000
@@ -34,6 +34,7 @@
 #include <drizzled/visibility.h>
 #include <drizzled/sql/exception.h>
 #include <drizzled/sql/result_set_meta_data.h>
+#include <drizzled/field.h>
 #include <cassert>
 #include <queue>
 
@@ -94,19 +95,48 @@
   bool error() const;
   sql::Exception getException() const;
 
-  ResultSet(size_t fields) :
+  ResultSet(size_t columns) :
     _has_next_been_called(false),
     _current_row(_results.end()),
-    _meta_data(fields)
-  {
-  }
-
-  void setColumnCount(size_t fields)
-  {
-    _meta_data.setColumnCount(fields);
-  }
-
-  ~ResultSet();
+    _meta_data(columns)
+  {
+  }
+
+  void setColumnCount(size_t columns)
+  {
+    _meta_data.setColumnCount(columns);
+  }
+
+  void setColumnInfo(size_t column_number, const SendField& field)
+  {
+    _meta_data.setColumnInfo(column_number, field);
+  }
+
+  /**
+   * @brief Get object that holds column meta data.
+   * 
+   * The following info is available:
+   * 
+   * metadata = rs.getColumnInfo(0);
+   * metadata.db_name;
+   * metadata.org_table_name;
+   * metadata.org_col_name;
+   * metadata.table_name;
+   * metadata.col_name;
+   * metadata.charsetnr;
+   * metadata.flags;
+   * metadata.type;
+   * metadata.length;
+   * metadata.decimals;
+   * 
+   * @see drizzled/item.cc to see where these are set.
+   */
+  SendField getColumnInfo(size_t column_number)
+  {
+    return _meta_data.getColumnInfo(column_number);
+  }
+
+~ResultSet();
 
   void createRow();
   void setColumn(size_t column_number, const std::string &arg);
 
=== modified file 'drizzled/sql/result_set_meta_data.h'
--- drizzled/sql/result_set_meta_data.h	2011-04-21 05:05:53 +0000
+++ drizzled/sql/result_set_meta_data.h	2012-05-20 15:31:19 +0000
@@ -33,10 +33,13 @@
 
 #include <cassert>
 #include <queue>
+#include <vector>
+#include <drizzled/field.h>
 
 namespace drizzled {
 namespace sql {
 
+
 class ResultSetMetaData
 {
 public:
@@ -51,17 +54,31 @@
   ResultSetMetaData(size_t columns) :
     _columns(columns)
   {
-  }
-
-  void setColumnCount(size_t fields)
-  {
-    _columns= fields;
-  }
-
+    _columnInfo.resize(columns);
+  }
+
+  void setColumnCount(size_t columns)
+  {
+    _columns= columns;
+    _columnInfo.resize(columns);
+  }
+
+  void setColumnInfo(size_t column_number, const SendField& field)
+  {
+    _columnInfo.at(column_number) = field;
+  }
+
+  SendField getColumnInfo(size_t column_number)
+  {
+    return _columnInfo.at(column_number);
+  }
+  
 private: // Member methods
 
 private: // Member variables
   size_t _columns;
+  typedef std::vector<SendField> ColumnInfoVector;
+  ColumnInfoVector _columnInfo;
 };
 
 std::ostream& operator<<(std::ostream& output, const ResultSetMetaData &result_set);
 
=== modified file 'm4/pandora_have_libevent.m4'
--- m4/pandora_have_libevent.m4	2011-03-07 16:42:18 +0000
+++ m4/pandora_have_libevent.m4	2012-05-20 15:31:19 +0000
@@ -64,3 +64,16 @@
 AC_DEFUN([PANDORA_REQUIRE_LIBEVENT],[
   AC_REQUIRE([_PANDORA_REQUIRE_LIBEVENT])
 ])
+
+AC_DEFUN([PANDORA_LIBEVENT_RECENT],[
+  dnl FIXME I really wanted to check for existence of EVHTTP_REQ_DELETE, 
+  dnl but autoconf gods were not favorable to me, so the below is all I got
+  AC_CACHE_CHECK([if libevent is recent enough],
+    [pandora_cv_libevent_recent],
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#include <event2/event.h>
+#include <event2/http.h>
+    ]])],
+    [pandora_cv_libevent_recent=yes],
+    [pandora_cv_libevent_recent=no])])
+])
 
=== modified file 'plugin/json_server/docs/index.rst'
--- plugin/json_server/docs/index.rst	2011-10-23 05:45:09 +0000
+++ plugin/json_server/docs/index.rst	2012-05-20 15:31:19 +0000
@@ -3,7 +3,12 @@
 JSON Server
 ===========
 
-JSON HTTP interface.
+JSON Server implements a simple HTTP server that allows you to access your
+Drizzle database with JSON based protocols. Currently two API's are supported:
+a SQL-over-HTTP protocol allows you to execute any single statement SQL
+transactions and a pure JSON protocol currently supports storing of JSON
+documents as blobs in a key-value table.
+
 
 .. _json_server_loading:
 
@@ -51,30 +56,380 @@
 
    :Scope: Global
    :Dynamic: No
-   :Option: :option:`--json-server.port`
 
    Port number to use for connection or 0 for default (port 8086) 
 
-.. _json_server_examples:
-
-Examples
---------
-
-Sorry, there are no examples for this plugin.
+.. _json_server_apis:
+
+APIs
+----
+
+JSON Server supports a few APIs that offer different functionalities. Each API
+is accessed via it's own URI, and parameters can be given in the query string
+or in the POST data. 
+
+The APIs are versioned, the version number is prepended to the API name. If 
+functionality is added or changed, it will not be available if an API is 
+accessed via an earlier version number. Finally, the latest version of each API
+is also available from the root, without any version number.
+
+As of this writing, the following APIs exist:
+
+.. code-block:: none
+
+    /0.1/sql
+    /0.2/sql
+    /sql
+
+Because the SQL API did not change between 0.1 and 0.2, all of the above URIs
+are exactly the same.
+
+.. code-block:: none
+
+    /0.2/json
+    /json
+
+The pure JSON API did not exist in the 0.1 release, as you can see from above.
+
+.. code-block:: none
+
+    /version
+    /
+
+The ``/version`` URI will return the version of Drizzle (in a JSON document, of 
+course):
+
+.. code-block:: none
+
+    $ curl http://localhost:8086/version
+    {
+      "version" : "7.1.31.2451-snapshot"
+    }
+
+The root URI returns a simple HTML GUI that can be used to test both the SQL and
+pure JSON APIs. Just point your browser to http://localhost:8086/ and try it!
+
+.. _json_server_sql_api:
+
+The SQL-over-HTTP API: /sql
+---------------------------
+
+The first API in JSON Server is the SQL-over-HTTP API. It allows you to execute
+almost any SQL and the result is returned as a 2 dimensional JSON array.
+
+On the HTTP level this is a simple API. The method is always ``POST`` and the
+functionality is determined by the SQL statement you send.
+
+.. code-block:: none
+  
+  POST /sql
+  
+  SELECT * from test.foo;
+
+Returns:
+
+.. code-block:: none
+
+  {
+   "query" : "SELECT * from test.foo;\n",
+   "result_set" : [
+      [ "1", "Hello Drizzle Day Audience!" ],
+      [ "2", "this text came in over http" ]
+   ],
+   "sqlstate" : "00000"
+  }
+
+The above corresponds to the following query from a drizzle command line:
+
+.. code-block:: mysql
+
+  drizzle> select * from test.foo;
+
++----+-----------------------------+
+| id | bar                         |
++====+=============================+
+|  1 | Hello Drizzle Day Audience! | 
++----+-----------------------------+
+|  2 | this text came in over http | 
++----+-----------------------------+
+
+
+.. _json_server_json_api:
+
+Pure JSON key-value API: /json
+------------------------------
+
+The pure JSON key-value API is found at the URI ``/json``. It takes a rather
+opposite approach than the ``/sql`` API. Queries are expressed as JSON query 
+documents, similar to what is found in Metabase, CouchDB or MongoDB. It is not
+possible to use any SQL.
+
+The purpose of the ``/json`` API is to use Drizzle as a key-value document 
+storage. This means that the table layout is determined by the JSON Server 
+module. Therefore, it is not possible for the user to access arbitrary 
+relational tables via the ``/json`` API, rather tables must adhere to the 
+format explained further below, and it must contain valid JSON documents in the 
+data columns.
+
+If you post (insert) a document to a table that doesn't exist, it will be 
+automatically created. For this reason, a user mostly doesn't need to even
+know the specific format of a JSON server table. 
+
+.. _json_server_json_parameters:
+
+Parameters
+^^^^^^^^^^
+
+Following parameters can be passed in the URI query string:
+
+.. _json_server_json_parameters_id:
+
+``_id``
+
+   :Type: Unsigned integer
+   :Mandatory: No
+   :Default: 
+
+   Optionally, a user may also specify the _id value which is requested. 
+   Typically this is given in the JSON query document instead. If both are given
+   the _id value in the query document has precedence.
+
+.. _json_server_json_parameters_query:
+
+``query``
+
+   :Type: JSON query document
+   :Mandatory: No
+   :Default: 
+
+   A JSON document, the so called *query document*. This document specifies
+   which records/documents to return from the database. Currently it is only
+   possible to query for a single value by the primary key, which is 
+   called ``_id``. Any other fields in the query document will be ignored.
+
+   The query parameter is used for GET, PUT and DELETE where it is passed in 
+   URL encoded form in the URI query string. For POST requests the query 
+   document is passed as the POST data. (In that case only the query document
+   is passed, there is no ``query=`` part, in other words the data is never
+   encoded in www-form-urlencoded format.)
+
+   Example query document:
+
+   .. code-block:: none
+
+       { "_id" : 1 }
+
+.. _json_server_json_parameters_schema:
+
+``schema``
+
+   :Type: String
+   :Mandatory: No
+   :Default: test
+
+   Name of the schema which we are querying. The schema must exist. 
+
+.. _json_server_parameters_table:
+
+``table``
+
+   :Type: String
+   :Mandatory: No
+   :Default: jsonkv
+
+   Name of the table which we are querying. For POST requests, if the table 
+   doesn't exist, it will be automatically created. For other requests the
+   table must exist, otherwise an error is returned.
+
+POSTing a document
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: none
+  
+  POST /json?schema=test&table=people HTTP/1.1
+
+  {
+    "_id" : 2, 
+    "document" : { "firstname" : "Henrik", "lastname" : "Ingo", "age" : 35}
+  }
+
+Returns:
+
+.. code-block:: none
+
+  HTTP/1.1 200 OK
+  Content-Type: text/html
+
+  {
+       "query" : {
+              "_id" : 2,
+              "document" : {
+                   "age" : 35,
+                   "firstname" : "Henrik",
+                   "lastname" : "Ingo"
+                  }
+           },
+       "sqlstate" : "00000"
+  }
+
+
+(The use of Content-type: text/html is considered a bug and will be
+fixed in a future version.)
+
+Under the hood, this has inserted the following record into a table "jsontable":
+
+.. code-block:: mysql
+
+  drizzle> select * from people where _id=2;
+
++-----+--------------------------+
+| _id | document                 |
++=====+==========================+
+|   2 |{                         |
+|     |"age" : 35,               |
+|     |"firstname" : "Henrik",   |
+|     |"lastname" : "Ingo"       |
+|     |}                         |
++-----+--------------------------+
+
+The ``_id`` field is always present. If it isn't specified, an auto_increment
+value will be generated. If a record with the given ``_id`` already exists in
+the table, the record will be updated (using REPLACE INTO).
+
+In addition there are one or more columns of type TEXT.
+The column name(s) corresponds to the top level key(s) that were specified in the
+POSTed JSON document. You can use any name(s) for the top level key(s), but
+the name ``document`` is commonly used as a generic name. The contents of such a
+column is the value of the corresponding top level key and has to be valid JSON.
+
+A table of this format is automatically created when the first document is
+POSTed to the table. This means that the column names are defined from the top
+level key(s) of that first document and future JSON documents must use the same 
+top level key(s). Below the top level key(s) the JSON document can be of any 
+arbitrary structure. A common practice is to always use ``_id`` and ``document``
+as the top level keys, and place the actual JSON document, which can be of
+arbitrary structure, under the ``document`` key.
+
+
+GET a document
+^^^^^^^^^^^^^^
+
+The equivalent of an SQL SELECT is HTTP GET.
+
+Below we use the query document ``{"_id" : 1 }`` in URL encoded form:
+
+.. code-block:: none
+  
+  GET /json?schema=test&table=people&query=%7B%22_id%22%20%3A%201%7D%0A
+
+Returns
+
+.. code-block:: none
+  
+  HTTP/1.0 200 OK
+  Content-Type: text/html
+  
+  {
+    "query" : {
+        "_id" : 1
+         },
+       "result_set" : [
+              {
+                 "_id" : 1,
+                 "document" : {
+                        "age" : 21,
+                        "firstname" : "Mohit",
+                        "lastname" : "Srivastava"
+                     }
+              }
+           ],
+       "sqlstate" : "00000"
+  }
+
+It is also allowed to specify the ``_id`` as a URI query string parameter and
+omit the query document:
+
+.. code-block:: none
+  
+  GET /json?schema=test&table=people&_id=1
+
+If both are specified, the query document takes precedence.
+
+Finally, it is possible to issue a GET request to a table without specifying
+neither the ``_id`` parameter or a query document. In this case all records of 
+the whole table is returned.
+
+
+Updating a record
+^^^^^^^^^^^^^^^^^
+
+To update a record, POST new version of json document with same ``_id`` as an 
+already existing record.
+
+(PUT is currently not supported, instead POST is used for both inserting and
+updating.)
+
+Deleting a record
+^^^^^^^^^^^^^^^^^
+ 
+Below we use the query document ``{"_id" : 1 }`` in URL encoded form:
+
+.. code-block:: none
+  
+  DELETE http://14.139.228.217:8086/json?schema=test&table=people&query=%7B%22_id%22%20%3A%201%7D
+
+Returns:
+
+.. code-block:: none
+  
+  HTTP/1.0 200 OK
+  Content-Type: text/html
+
+  {
+       "query" : {
+              "_id" : 1
+         },
+       "sqlstate" : "00000"
+  }
+
+It is also allowed to specify the ``_id`` as a URI query string parameter and
+omit the query document:
+
+.. code-block:: none
+  
+  DELETE /json?schema=test&table=people&_id=1
+
+If both are specified, the query document takes precedence.
+ 
+.. _json_server_limitations:
+
+Limitations
+^^^^^^^^^^^
+
+The ``/sql`` and ``/json`` APIs are both feature complete, yet JSON Server is
+still an experimental module. There are known crashes, the module is still
+single threaded and there is no authentication... and that's just a start! 
+These limitations are being worked on. For a full list of the current state of 
+JSON Server, please follow 
+`this launchpad blueprint <https://blueprints.launchpad.net/drizzle/+spec/json-server>`_.
+
+An inherent limitation is that each HTTP request is its own transaction. While
+it would be possible to support maintaining a complex SQL transaction over the
+span of multiple HTTP requests, we currently do not plan to support that.
 
 .. _json_server_authors:
 
 Authors
 -------
 
-Stewart Smith
+Stewart Smith, Henrik Ingo, Mohit Srivastava
 
 .. _json_server_version:
 
 Version
 -------
 
-This documentation applies to **json_server 0.1**.
+This documentation applies to **json_server 0.2**.
 
 To see which version of the plugin a Drizzle server is running, execute:
 
@@ -87,4 +442,11 @@
 
 v0.1
 ^^^^
-* First release.
+* /sql API
+* Simple web based GUI at /
+* /version API
+
+v0.2
+^^^^
+* /json API supporting pure JSON key-value operations (POST, GET, DELETE)
+* Automatic creation of table on first post. 
 
=== modified file 'plugin/json_server/json/json_value.cpp'
--- plugin/json_server/json/json_value.cpp	2011-08-20 13:41:35 +0000
+++ plugin/json_server/json/json_value.cpp	2012-05-20 15:31:19 +0000
@@ -40,6 +40,7 @@
 #include <plugin/json_server/json/value.h>
 #include <plugin/json_server/json/writer.h>
 
+#include <cstdio>
 #include <cassert>
 #include <cstring>
 #include <iostream>
@@ -308,6 +309,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    switch ( type_arg )
    {
@@ -351,6 +353,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.int_ = value;
 }
@@ -362,6 +365,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.uint_ = value;
 }
@@ -372,6 +376,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.real_ = value;
 }
@@ -383,6 +388,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.string_ = valueAllocator()->duplicateStringValue( value );
 }
@@ -396,6 +402,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.string_ = valueAllocator()->duplicateStringValue( beginValue, 
                                                             UInt(endValue - beginValue) );
@@ -409,6 +416,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.string_ = valueAllocator()->duplicateStringValue( value.c_str(), 
                                                             (unsigned int)value.length() );
@@ -422,6 +430,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.string_ = const_cast<char *>( value.c_str() );
 }
@@ -435,6 +444,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.string_ = valueAllocator()->duplicateStringValue( value, value.length() );
 }
@@ -446,6 +456,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    value_.bool_ = value;
 }
@@ -457,6 +468,7 @@
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
    , itemIsUsed_( 0 )
 #endif
+   , value_as_string_( 0 )
 {
    switch ( type_ )
    {
@@ -504,7 +516,6 @@
    }
 }
 
-
 Value::~Value()
 {
    switch ( type_ )
@@ -514,7 +525,9 @@
    case uintValue:
    case realValue:
    case booleanValue:
-      break;
+       if ( value_as_string_ )
+           valueAllocator()->releaseStringValue( value_as_string_ );
+       break;
    case stringValue:
       if ( allocated_ )
          valueAllocator()->releaseStringValue( value_.string_ );
@@ -715,9 +728,12 @@
    return value_.string_;
 }
 
-
+/**
+ * If type_ is not stringValue, we will here convert other values to value_as_string_ field,
+ * then return it.
+ */
 std::string 
-Value::asString() const
+Value::asString()
 {
    switch ( type_ )
    {
@@ -728,8 +744,29 @@
    case booleanValue:
       return value_.bool_ ? "true" : "false";
    case intValue:
+      if(!value_as_string_)
+      {
+          char buf[64];
+          sprintf(buf, "%d", value_.int_);
+          value_as_string_ = valueAllocator()->duplicateStringValue( buf );
+      }
+      return value_as_string_;
    case uintValue:
+      if(!value_as_string_)
+      {
+          char buf[64];
+          sprintf(buf, "%d", value_.uint_);
+          value_as_string_ = valueAllocator()->duplicateStringValue( buf );
+      }
+      return value_as_string_;
    case realValue:
+      if(!value_as_string_)
+      {
+          char buf[256];
+          sprintf(buf, "%f", value_.real_);
+          value_as_string_ = valueAllocator()->duplicateStringValue( buf );
+      }
+      return value_as_string_;
    case arrayValue:
    case objectValue:
       JSON_ASSERT_MESSAGE( false, "Type is not convertible to string" );
 
=== modified file 'plugin/json_server/json/value.h'
--- plugin/json_server/json/value.h	2011-08-19 09:52:50 +0000
+++ plugin/json_server/json/value.h	2012-05-20 15:31:19 +0000
@@ -263,7 +263,7 @@
       int compare( const Value &other );
 
       const char *asCString() const;
-      std::string asString() const;
+      std::string asString();
 # ifdef JSON_USE_CPPTL
       CppTL::ConstString asConstString() const;
 # endif
@@ -481,6 +481,7 @@
       int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
 # endif
       CommentInfo *comments_;
+      char *value_as_string_; // Used when asString is called on non-string types.
    };
 
 
 
=== modified file 'plugin/json_server/json_server.cc'
--- plugin/json_server/json_server.cc	2012-01-16 02:37:54 +0000
+++ plugin/json_server/json_server.cc	2012-05-20 15:31:19 +0000
@@ -1,7 +1,7 @@
 /* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
- *  Copyright (C) 2011 Stewart Smith
+ *  Copyright (C) 2011 Stewart Smith, Henrik Ingo, Mohit Srivastava
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,21 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
-
+/**
+ * @file Implements an HTTP server that will parse JSON and SQL queries
+ * 
+ * @todo Refactoring ideas:
+ *  - Anything HTML should really be a separate file, not strings embedded
+ *    in C++.
+ *  - Put all json handling into try/catch blocks, the parser likes to throw
+ *    exceptions which crash drizzled if not caught.
+ *  - Need to implement a worker thread pool. Make workers proper OO classes.
+ * 
+ * @todo Implement HTTP response codes other than just 200 as defined in
+ *       http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html
+ *
+ * @todo Shouldn't we be using event2/http.h? Why does this even work without it?
+ */
 
 #include <config.h>
 
@@ -76,7 +90,11 @@
 extern "C" void process_root_request(struct evhttp_request *req, void* );
 extern "C" void process_api01_version_req(struct evhttp_request *req, void* );
 extern "C" void process_api01_sql_req(struct evhttp_request *req, void* );
-
+extern "C" void process_api02_json_req(struct evhttp_request *req, void* );
+extern "C" void process_api02_json_get_req(struct evhttp_request *req, void* );
+extern "C" void process_api02_json_post_req(struct evhttp_request *req, void* );
+/* extern "C" void process_api02_json_put_req(struct evhttp_request *req, void* ); */
+extern "C" void process_api02_json_delete_req(struct evhttp_request *req, void* );
 extern "C" void process_request(struct evhttp_request *req, void* )
 {
   struct evbuffer *buf = evbuffer_new();
@@ -92,40 +110,78 @@
 
   std::string output;
 
-  output.append("<html><head><title>JSON DATABASE interface demo</title></head>"
-                "<body>"
-                "<script lang=\"javascript\">"
-                "function to_table(obj) {"
-                " var str = '<table>';"
-                "for (var r=0; r< obj.length; r++) {"
-                " str+='<tr>';"
-                "  for (var c=0; c < obj[r].length; c++) {"
-                "    str+= '<td>' + obj[r][c] + '</td>';"
-                "  }"
-                " str+='</tr>';"
-                "}"
-                "str+='</table>';"
-                "return str;"
-                "}"
-                "function run_query()\n"
-                "{"
-                "var url = document.getElementById(\"baseurl\").innerHTML;\n"
-                "var query= document.getElementById(\"query\").value;\n"
+  output.append("<html><head><title>JSON DATABASE interface demo</title></head>\n"
+                "<body>\n"
+                "<script lang=\"javascript\">\n"
+                "function to_table(obj) {\n"
+                " var str = '<table border=\"1\">';\n"
+                "for (var r=0; r< obj.length; r++) {\n"
+                " str+='<tr>';\n"
+                "  for (var c=0; c < obj[r].length; c++) {\n"
+                "    str+= '<td>' + obj[r][c] + '</td>';\n"
+                "  }\n"
+                " str+='</tr>';\n"
+                "}\n"
+                "str+='</table>';\n"
+                "return str;\n"
+                "}\n"
+                "function to_table_from_json(obj) {\n"
+                " var str = '<table border=\"1\">';\n"
+                "for (var r=0; r< obj.length; r++) {\n"
+                " str+='<tr>';\n"
+                " str+='<td>' + obj[r]['_id'] + '</td>';\n"
+                " str+='<td>' + JSON.stringify(obj[r]['document']) + '</td>';\n"
+                " str+='</tr>';\n"
+                "}\n"
+                "str+='</table>';\n"
+                "return str;\n"
+                "}\n"
+                "function run_sql_query()\n"
+                "{\n"
+                "var url = window.location;\n"
+                "var query= document.getElementById(\"sql_query\").value;\n"
                 "var xmlHttp = new XMLHttpRequest();\n"
                 "xmlHttp.onreadystatechange = function () {\n"
+                "document.getElementById(\"responseText\").value = xmlHttp.responseText;\n"
                 "if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {\n"
                 "var info = eval ( \"(\" + xmlHttp.responseText + \")\" );\n"
                 "document.getElementById( \"resultset\").innerHTML= to_table(info.result_set);\n"
                 "}\n"
                 "};\n"
-                "xmlHttp.open(\"POST\", url + \"/0.1/sql\", true);"
-                "xmlHttp.send(query);"
-                "}"
+                "xmlHttp.open(\"POST\", url + \"sql\", true);\n"
+                "xmlHttp.send(query);\n"
+                "}\n"
+                "\n\n"
+                "function run_json_query()\n"
+                "{\n"
+//"alert('run_json_query');"
+                    "var url = window.location;\n"
+                    "var method= document.getElementById(\"json_method\").value;\n"
+                    "var query= document.getElementById(\"json_query\").value;\n"
+                    "var schema= document.getElementById(\"schema\").value;\n"
+                    "var table= document.getElementById(\"table\").value;\n"
+                    "var xmlHttp = new XMLHttpRequest();\n"
+                    "xmlHttp.onreadystatechange = function () {\n"
+//"alert(xmlHttp.responseText);"
+                    "document.getElementById(\"responseText\").value = xmlHttp.responseText;\n"
+                    "if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {\n"
+                    "var info = eval ( \"(\" + xmlHttp.responseText + \")\" );\n"
+                    "document.getElementById( \"resultset\").innerHTML= to_table_from_json(info.result_set);\n"
+                    "}\n"
+                    "};\n"
+                    "if( method == \"POST\" ) {\n"
+                        "xmlHttp.open(method, url + \"json?schema=\" + schema + \"&table=\" + table, true);\n"
+                        "xmlHttp.send(query);\n"
+                    "} else {\n"
+                        "xmlHttp.open(method, url + \"json?schema=\" + schema + \"&table=\" + table + \"&query=\" + encodeURIComponent(query), true);\n"
+                        "xmlHttp.send();\n"
+                    "}\n"
+                "}\n"
                 "\n\n"
                 "function update_version()\n"
-                "{drizzle_version(document.getElementById(\"baseurl\").innerHTML);}\n\n"
-                "function drizzle_version($url)"
-                "{"
+                "{drizzle_version(window.location);}\n\n"
+                "function drizzle_version($url)\n"
+                "{\n"
                 "var xmlHttp = new XMLHttpRequest();\n"
                 "xmlHttp.onreadystatechange = function () {\n"
                 "if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {\n"
@@ -133,19 +189,32 @@
                 "document.getElementById( \"drizzleversion\").innerHTML= info.version;\n"
                 "}\n"
                 "};\n"
-                "xmlHttp.open(\"GET\", $url + \"/0.1/version\", true);"
-                "xmlHttp.send(null);"
-                "}"
-                "</script>"
-                "<p>Drizzle Server at: <a id=\"baseurl\">http://localhost:8765</a></p>"
-                "<p>Drizzle server version: <a id=\"drizzleversion\"></a></p>"
-                "<p><textarea rows=\"3\" cols=\"40\" id=\"query\">"
-                "SELECT * from DATA_DICTIONARY.GLOBAL_STATUS;"
-                "</textarea>"
-                "<button type=\"button\" onclick=\"run_query();\">Execute Query</button>"
-                "<div id=\"resultset\"/>"
-                "<script lang=\"javascript\">update_version(); run_query();</script>"
-                "</body></html>");
+                "xmlHttp.open(\"GET\", $url + \"version\", true);\n"
+                "xmlHttp.send(null);\n"
+                "}\n"
+                "</script>\n"
+                "<p>Drizzle server version: <a id=\"drizzleversion\"></a></p>\n"
+                "<p><textarea rows=\"3\" cols=\"80\" id=\"sql_query\">\n"
+                "SELECT * from DATA_DICTIONARY.GLOBAL_STATUS;\n"
+                "</textarea>\n"
+                "<button type=\"button\" onclick=\"run_sql_query();\">Execute SQL Query</button>\n"
+                "</p><p>\n"
+                "<textarea rows=\"8\" cols=\"80\" id=\"json_query\">\n"
+                "{\"_id\" : 1}\n"
+                "</textarea>\n"
+                "<button type=\"button\" onclick=\"run_json_query();\">Execute JSON Query</button>\n"
+                "<br />\n"
+                "<select id=\"json_method\"><option value=\"GET\">GET</option>"
+                "<option value=\"POST\">POST</option>"
+                "<option value=\"PUT\">PUT</option>"
+                "<option value=\"DELETE\">DELETE</option></select>"
+                "<script lang=\"javascript\">document.write(window.location);</script>json?schema=\n"
+                "<input type=\"text\" id=\"schema\" value=\"test\"/>"
+                "&amp;table=<input type=\"text\" id=\"table\" value=\"jsonkv\"/>\n"
+                "</p><hr />\n<div id=\"resultset\"></div>\n"
+                "<hr /><p><textarea rows=\"12\" cols=\"80\" id=\"responseText\" ></textarea></p>"
+                "<script lang=\"javascript\">update_version(); run_sql_query();</script>\n"
+                "</body></html>\n");
 
   evbuffer_add(buf, output.c_str(), output.length());
   evhttp_send_reply(req, HTTP_OK, "OK", buf);
@@ -203,6 +272,7 @@
   {
     root["error_message"]= exception.getErrorMessage();
     root["error_code"]= exception.getErrorCode();
+    root["schema"]= "test";
   }
 
   while (result_set.next())
@@ -227,6 +297,515 @@
   evhttp_send_reply(req, HTTP_OK, "OK", buf);
 }
 
+extern "C" void process_api02_json_req(struct evhttp_request *req, void* )
+{
+    if( req->type == EVHTTP_REQ_GET )
+    {
+        process_api02_json_get_req( req, NULL);
+//    } elseif ( req->type == EVHTTP_REQ_PUT ) {
+        //process_api02_json_put_req( req, NULL);
+    } else if ( req->type == EVHTTP_REQ_POST ) {
+        process_api02_json_post_req( req, NULL);
+    } else if ( req->type == EVHTTP_REQ_DELETE ) {
+        process_api02_json_delete_req( req, NULL);
+    }
+}
+
+/**
+ * Transform a HTTP GET to SELECT and return results based on input json document
+ * 
+ * @todo allow DBA to set default schema (also in post,del methods)
+ * @todo allow DBA to set whether to use strict mode for parsing json (should get rid of white space), especially for POST of course.
+ * 
+ * @param req should contain a "table" parameter in request uri. "query", "_id" and "schema" are optional.
+ * @return a json document is returned to client with evhttp_send_reply()
+ */
+void process_api02_json_get_req(struct evhttp_request *req, void* )
+{
+  int http_response_code = HTTP_OK;
+  const char *http_response_text;
+  http_response_text = "OK";
+  
+  struct evbuffer *buf = evbuffer_new();
+  if (buf == NULL) return;
+
+  Json::Value json_out;
+
+  std::string input;
+  // Schema and table are given in request uri.
+  // TODO: If we want to be really NoSQL, we will some day allow to use synonyms like "collection" instead of "table".
+  // For GET, also the query is in the uri
+  const char *schema;
+  const char *table;
+  const char *query;
+  const char *id;
+  evhttp_parse_query(evhttp_request_uri(req), req->input_headers);
+  schema = (char *)evhttp_find_header(req->input_headers, "schema");
+  table = (char *)evhttp_find_header(req->input_headers, "table");
+  query = (char *)evhttp_find_header(req->input_headers, "query");
+  id = (char *)evhttp_find_header(req->input_headers, "_id");
+  
+  // query can be null if _id was given
+  if ( query == NULL || strcmp(query, "") == 0 )
+  {
+      // Empty JSON object
+      query = "{}";
+  }
+  input.append(query, strlen(query));
+
+  // Set test as default schema
+  if ( !strcmp( schema, "") || schema == NULL)
+  {
+      schema = "test";
+  }
+  
+  // Parse "input" into "json_in".
+  Json::Value  json_in;
+  Json::Features json_conf;
+  Json::Reader reader(json_conf);
+  bool retval = reader.parse(input, json_in);
+  if (retval != true) {
+    json_out["error_type"]="json error";
+    json_out["error_message"]= reader.getFormatedErrorMessages();
+  }
+  else if (strcmp( table, "") == 0 || table == NULL) {
+    json_out["error_type"]="http error";
+    json_out["error_message"]= "You must specify \"table\" in the request uri query string.";
+    http_response_code = HTTP_NOTFOUND;
+    http_response_text = "You must specify \"table\" in the request uri query string.";
+  }
+  else {    
+    // It is allowed to specify _id in the uri and leave it out from the json query.
+    // In that case we put the value from uri into json_in here.
+    // If both are specified, the one existing in json_in wins. (This is still valid, no error.)
+    if ( ! json_in["_id"].asBool() )
+    {
+      if( id ) {
+        json_in["_id"] = (Json::Value::UInt) atol(id);
+      }
+    }
+    
+    // TODO: In a later stage we'll allow the situation where _id isn't given but some other column for where.
+    // TODO: Need to do json_in[].type() first and juggle it from there to be safe. See json/value.h
+    // TODO: Don't SELECT * but only fields given in json query document
+    char sqlformat[1024];;
+    char buffer[1024];
+    if ( json_in["_id"].asBool() )
+    {
+      // Now we build an SQL query, using _id from json_in
+      sprintf(sqlformat, "%s", "SELECT * FROM `%s`.`%s` WHERE _id=%i;");
+      sprintf(buffer, sqlformat, schema, table, json_in["_id"].asInt());
+    }
+    else {
+      // If neither _id nor query are given, we return the full table. (No error, maybe this is what you really want? Blame yourself.)
+      sprintf(sqlformat, "%s", "SELECT * FROM `%s`.`%s`;");
+      sprintf(buffer, sqlformat, schema, table);
+    }
+
+    std::string sql = "";
+    sql.append(buffer, strlen(buffer));
+    
+    // We have sql string. Use Execute API to run it and convert results back to JSON.
+    drizzled::Session::shared_ptr _session= drizzled::Session::make_shared(drizzled::plugin::Listen::getNullClient(),
+                                            drizzled::catalog::local());
+    drizzled::identifier::user::mptr user_id= identifier::User::make_shared();
+    user_id->setUser("");
+    _session->setUser(user_id);
+    //_session->set_schema("test");
+
+    drizzled::Execute execute(*(_session.get()), true);
+
+    drizzled::sql::ResultSet result_set(1);
+
+    /* Execute wraps the SQL to run within a transaction */
+    execute.run(sql, result_set);
+    drizzled::sql::Exception exception= result_set.getException();
+
+    drizzled::error_t err= exception.getErrorCode();
+
+    json_out["sqlstate"]= exception.getSQLState();
+
+    if ((err != drizzled::EE_OK) && (err != drizzled::ER_EMPTY_QUERY))
+    {
+        json_out["error_type"]="sql error";
+        json_out["error_message"]= exception.getErrorMessage();
+        json_out["error_code"]= exception.getErrorCode();
+        json_out["internal_sql_query"]= sql;
+        json_out["schema"]= "test";
+    }
+
+    while (result_set.next())
+    {
+        Json::Value json_row;
+        bool got_error = false; 
+        for (size_t x= 0; x < result_set.getMetaData().getColumnCount() && got_error == false; x++)
+        {
+            if (not result_set.isNull(x))
+            {
+                // The values are now serialized json. We must first
+                // parse them to make them part of this structure, only to immediately
+                // serialize them again in the next step. For large json documents
+                // stored into the blob this must be very, very inefficient.
+                // TODO: Implement a smarter way to push the blob value directly to the client. Probably need to hand code some string appending magic.
+                // TODO: Massimo knows of a library to create JSON in streaming mode.
+                Json::Value  json_doc;
+                Json::Reader readrow(json_conf);
+                std::string col_name = result_set.getColumnInfo(x).col_name;
+                bool r = readrow.parse(result_set.getString(x), json_doc);
+                if (r != true) {
+                    json_out["error_type"]="json parse error on row value";
+                    json_out["error_internal_sql_column"]=col_name;
+                    json_out["error_message"]= reader.getFormatedErrorMessages();
+                    // Just put the string there as it is, better than nothing.
+                    json_row[col_name]= result_set.getString(x);
+                    got_error=true;
+                    break;
+                }
+                else {
+                    json_row[col_name]= json_doc;
+                }
+            }
+        }
+        // When done, append this to result set tree
+        json_out["result_set"].append(json_row);
+    }
+
+    json_out["query"]= json_in;
+  }
+  // Return either the results or an error message, in json.
+  Json::StyledWriter writer;
+  std::string output= writer.write(json_out);
+  evbuffer_add(buf, output.c_str(), output.length());
+  evhttp_send_reply(req, http_response_code, http_response_text, buf);
+}
+
+/**
+ * Input json document or update existing one from HTTP POST (and PUT?).
+ * 
+ * If json document specifies _id field, then record is updated. If it doesn't
+ * exist, then a new record is created with that _id.
+ * 
+ * If _id field is not specified, then a new record is created using 
+ * auto_increment value. The _id of the created value is returned in the http
+ * response.
+ * 
+ * @todo If there are multiple errors, last one overwrites the previous in json_out. Make them lists.
+ * 
+ * @param req should contain a "table" parameter in request uri. "schema" is optional.
+ * @return a json document is returned to client with evhttp_send_reply()
+ */
+void process_api02_json_post_req(struct evhttp_request *req, void* )
+{
+  bool table_exists = true;
+  Json::Value json_out;
+
+  struct evbuffer *buf = evbuffer_new();
+  if (buf == NULL) return;
+
+  // Read from http to string "input".
+  std::string input;
+  char buffer[1024];
+  int l=0;
+  do {
+    l= evbuffer_remove(req->input_buffer, buffer, 1024);
+    input.append(buffer, l);
+  }while(l);
+
+  // Schema and table are given in request uri.
+  // TODO: If we want to be really NoSQL, we will some day allow to use synonyms like "collection" instead of "table".
+  const char *schema;
+  const char *table;
+  const char *id;
+  evhttp_parse_query(evhttp_request_uri(req), req->input_headers);
+  schema = (char *)evhttp_find_header(req->input_headers, "schema");
+  table = (char *)evhttp_find_header(req->input_headers, "table");
+  id = (char *)evhttp_find_header(req->input_headers, "_id");
+  
+  // Set test as default schema
+  if ( !strcmp( schema, "") || schema == NULL)
+  {
+      schema = "test";
+  }
+  
+  // Parse "input" into "json_in".
+  Json::Value  json_in;
+  Json::Features json_conf;
+  Json::Reader reader(json_conf);
+  bool retval = reader.parse(input, json_in);
+  if (retval != true) {
+    json_out["error_type"]="json error";
+    json_out["error_message"]= reader.getFormatedErrorMessages();
+  } 
+  else {
+    // It is allowed to specify _id in the uri and leave it out from the json query.
+    // In that case we put the value from uri into json_in here.
+    // If both are specified, the one existing in json_in wins. (This is still valid, no error.)
+    if ( ! json_in["_id"].asBool() )
+    {
+      if( id ) {
+        json_in["_id"] = (Json::Value::UInt) atol(id);
+      }
+    }
+
+    // For POST method, we check if table exists.
+    // If it doesn't, we automatically CREATE TABLE that matches the structure
+    // in the given json document. (This means, your first JSON document must
+    // contain all top-level keys you'd like to use.)
+    drizzled::Session::shared_ptr _session= drizzled::Session::make_shared(drizzled::plugin::Listen::getNullClient(),
+                                            drizzled::catalog::local());
+    drizzled::identifier::user::mptr user_id= identifier::User::make_shared();
+    user_id->setUser("");
+    _session->setUser(user_id);
+    drizzled::Execute execute(*(_session.get()), true);
+
+    drizzled::sql::ResultSet result_set(1);
+    std::string sql="select count(*) from information_schema.tables where table_schema = '";
+    sql.append(schema);
+    sql.append("' AND table_name = '");
+    sql.append(table); sql.append("';"); 
+    /* Execute wraps the SQL to run within a transaction */
+    execute.run(sql, result_set);
+
+    drizzled::sql::Exception exception= result_set.getException();
+
+    drizzled::error_t err= exception.getErrorCode();
+    while(result_set.next())
+    {
+      if(result_set.getString(0)=="0")
+      {
+        table_exists = false;
+      }
+    }
+    if(table_exists == false)
+    {
+      std::string tmp = "CREATE TABLE ";
+      tmp.append(schema);
+      tmp.append(".");
+      tmp.append(table);
+      tmp.append(" (_id BIGINT PRIMARY KEY auto_increment,");
+      // Iterate over json_in keys
+      Json::Value::Members createKeys( json_in.getMemberNames() );
+      for ( Json::Value::Members::iterator it = createKeys.begin(); it != createKeys.end(); ++it )
+      {
+        const std::string &key = *it;
+        if(key=="_id") {
+           continue;
+        }
+        tmp.append(key);
+        tmp.append(" TEXT");
+        if( it !=createKeys.end()-1 && key !="_id")
+        {
+          tmp.append(",");
+        }
+      }  
+      tmp.append(")"); 
+      vector<string> csql;       
+      csql.clear();
+      csql.push_back("COMMIT");
+      csql.push_back (tmp);
+      sql.clear();       
+      BOOST_FOREACH(string& it, csql)
+      {
+        sql.append(it);
+        sql.append("; ");
+      }
+      drizzled::sql::ResultSet createtable_result_set(1);
+      execute.run(sql, createtable_result_set);
+        
+      exception= createtable_result_set.getException();
+      err= exception.getErrorCode();
+    }
+    // Now we "parse" the json_in object and build an SQL query
+    sql.clear();
+    sql.append("REPLACE INTO `");
+    sql.append(schema);
+    sql.append("`.`");
+    sql.append(table);
+    sql.append("` SET ");    
+    // Iterate over json_in keys
+    Json::Value::Members keys( json_in.getMemberNames() );
+    for ( Json::Value::Members::iterator it = keys.begin(); it != keys.end(); ++it )
+    {
+      if ( it != keys.begin() )
+      {
+        sql.append(", ");
+      }
+      // TODO: Need to do json_in[].type() first and juggle it from there to be safe. See json/value.h
+      const std::string &key = *it;
+      sql.append(key); sql.append("=");
+      Json::StyledWriter writeobject;
+      switch ( json_in[key].type() )
+      {
+        case Json::nullValue:
+          sql.append("NULL");
+          break;
+        case Json::intValue:
+        case Json::uintValue:
+        case Json::realValue:
+        case Json::booleanValue:
+          sql.append(json_in[key].asString());
+          break;
+        case Json::stringValue:
+          sql.append("'\"");
+          // TODO: MUST be sql quoted!
+          sql.append(json_in[key].asString());
+          sql.append("\"'");
+          break;
+        case Json::arrayValue:
+        case Json::objectValue:
+          sql.append("'");
+          sql.append(writeobject.write(json_in[key]));
+          sql.append("'");
+          break;
+        default:
+          sql.append("'Error in json_server.cc. This should never happen.'");
+          json_out["error_type"]="json error";
+          json_out["error_message"]= "json_in object had a value that wasn't of any of the types that we recognize.";
+        break;
+      }
+      sql.append(" ");
+    }
+    sql.append(";");
+    drizzled::sql::ResultSet replace_result_set(1);
+
+    // Execute wraps the SQL to run within a transaction
+    execute.run(sql, replace_result_set);
+   
+    exception= replace_result_set.getException();
+
+    err= exception.getErrorCode();
+
+    json_out["sqlstate"]= exception.getSQLState();
+
+    // TODO: I should be able to return number of rows inserted/updated.
+    // TODO: Return last_insert_id();
+    if ((err != drizzled::EE_OK) && (err != drizzled::ER_EMPTY_QUERY))
+    {
+      json_out["error_type"]="sql error";
+      json_out["error_message"]= exception.getErrorMessage();
+      json_out["error_code"]= exception.getErrorCode();
+      json_out["internal_sql_query"]= sql;
+      json_out["schema"]= "test";
+    }
+    json_out["query"]= json_in;
+  }
+  // Return either the results or an error message, in json.
+  Json::StyledWriter writer;
+  std::string output= writer.write(json_out);
+  evbuffer_add(buf, output.c_str(), output.length());
+  evhttp_send_reply(req, HTTP_OK, "OK", buf);
+}
+
+/*
+void process_api02_json_put_req(struct evhttp_request *req, void* )
+{
+  struct evbuffer *buf = evbuffer_new();
+  if (buf == NULL) return;
+  evhttp_send_reply(req, HTTP_OK, "OK", buf);
+}
+*/
+
+void process_api02_json_delete_req(struct evhttp_request *req, void* )
+{
+  struct evbuffer *buf = evbuffer_new();
+  if (buf == NULL) return;
+
+  Json::Value json_out;
+
+  std::string input;
+  char buffer[1024];
+
+  // Schema and table are given in request uri.
+  // TODO: If we want to be really NoSQL, we will some day allow to use synonyms like "collection" instead of "table".
+  // For GET, also the query is in the uri
+  const char *schema;
+  const char *table;
+  const char *query;
+  const char *id;
+  evhttp_parse_query(evhttp_request_uri(req), req->input_headers);
+  schema = (char *)evhttp_find_header(req->input_headers, "schema");
+  table = (char *)evhttp_find_header(req->input_headers, "table");
+  query = (char *)evhttp_find_header(req->input_headers, "query");
+  id = (char *)evhttp_find_header(req->input_headers, "_id");
+
+  // query can be null if _id was given
+  if ( query == NULL || strcmp(query, "") == 0 )
+  {
+      // Empty JSON object
+      query = "{}";
+  }
+  input.append(query, strlen(query));
+
+  // Set test as default schema
+  if ( !strcmp( schema, "") || schema == NULL)
+  {
+      schema = "test";
+  }
+
+  // Parse "input" into "json_in".
+  Json::Value  json_in;
+  Json::Features json_conf;
+  json_conf.strictMode();
+  Json::Reader reader(json_conf);
+  bool retval = reader.parse(input, json_in);
+  if (retval != true) {
+    json_out["error_type"]="json error";
+    json_out["error_message"]= reader.getFormatedErrorMessages();
+  }
+  else {
+    // It is allowed to specify _id in the uri and leave it out from the json query.
+    // In that case we put the value from uri into json_in here.
+    // If both are specified, the one existing in json_in wins. (This is still valid, no error.)
+    if ( ! json_in["_id"].asBool() )
+    {
+      if( id ) {
+        json_in["_id"] = (Json::Value::UInt) atol(id);
+      }
+    }
+    // Now we "parse" the json_in object and build an SQL query
+    char sqlformat[1024] = "DELETE FROM `%s`.`%s` WHERE _id=%i;";
+    sprintf(buffer, sqlformat, schema, table, json_in["_id"].asInt());
+    std::string sql = "";
+    sql.append(buffer, strlen(buffer));
+
+    // We have sql string. Use Execute API to run it and convert results back to JSON.
+    drizzled::Session::shared_ptr _session= drizzled::Session::make_shared(drizzled::plugin::Listen::getNullClient(),
+                                            drizzled::catalog::local());
+    drizzled::identifier::user::mptr user_id= identifier::User::make_shared();
+    user_id->setUser("");
+    _session->setUser(user_id);
+
+    drizzled::Execute execute(*(_session.get()), true);
+
+    drizzled::sql::ResultSet result_set(1);
+
+    /* Execute wraps the SQL to run within a transaction */
+    execute.run(sql, result_set);
+    drizzled::sql::Exception exception= result_set.getException();
+
+    drizzled::error_t err= exception.getErrorCode();
+
+    json_out["sqlstate"]= exception.getSQLState();
+
+   if ((err != drizzled::EE_OK) && (err != drizzled::ER_EMPTY_QUERY))
+    {
+        json_out["error_type"]="sql error";
+        json_out["error_message"]= exception.getErrorMessage();
+        json_out["error_code"]= exception.getErrorCode();
+        json_out["internal_sql_query"]= sql;
+        json_out["schema"]= "test";
+    }
+    json_out["query"]= json_in;
+  }
+  // Return either the results or an error message, in json.
+  Json::StyledWriter writer;
+  std::string output= writer.write(json_out);
+  evbuffer_add(buf, output.c_str(), output.length());
+  evhttp_send_reply(req, HTTP_OK, "OK", buf);
+  
+ }
+
+
 static void shutdown_event(int fd, short, void *arg)
 {
   struct event_base *base= (struct event_base *)arg;
@@ -302,10 +881,25 @@
       return false;
     }
 
+    // These URLs are available. Bind worker method to each of them. 
+    // Please group by api version. Also unchanged functions must be copied to next version!
     evhttp_set_cb(httpd, "/", process_root_request, NULL);
+    // API 0.1
     evhttp_set_cb(httpd, "/0.1/version", process_api01_version_req, NULL);
     evhttp_set_cb(httpd, "/0.1/sql", process_api01_sql_req, NULL);
-    evhttp_set_gencb(httpd, process_request, NULL);
+    // API 0.2
+    evhttp_set_cb(httpd, "/0.2/version", process_api01_version_req, NULL);
+    evhttp_set_cb(httpd, "/0.2/sql", process_api01_sql_req, NULL);
+    evhttp_set_cb(httpd, "/0.2/json", process_api02_json_req, NULL);
+    // API "latest" and also available in top level
+    evhttp_set_cb(httpd, "/latest/version", process_api01_version_req, NULL);
+    evhttp_set_cb(httpd, "/latest/sql", process_api01_sql_req, NULL);
+    evhttp_set_cb(httpd, "/latest/json", process_api02_json_req, NULL);
+    evhttp_set_cb(httpd, "/version", process_api01_version_req, NULL);
+    evhttp_set_cb(httpd, "/sql", process_api01_sql_req, NULL);
+    evhttp_set_cb(httpd, "/json", process_api02_json_req, NULL);    
+    // Catch all does nothing and returns generic message.
+    //evhttp_set_gencb(httpd, process_request, NULL);
 
     event_set(&wakeup_event, wakeup_fd[0], EV_READ | EV_PERSIST, shutdown_event, base);
     event_base_set(base, &wakeup_event);
@@ -367,7 +961,7 @@
   DRIZZLE_VERSION_ID,
   "json_server",
   "0.1",
-  "Stewart Smith",
+  "Stewart Smith, Henrik Ingo, Mohit Srivastava",
   N_("JSON HTTP interface"),
   PLUGIN_LICENSE_GPL,
   drizzle_plugin::json_server::json_server_init,
 
=== modified file 'plugin/json_server/plugin.ac'
--- plugin/json_server/plugin.ac	2011-04-21 01:27:52 +0000
+++ plugin/json_server/plugin.ac	2012-05-20 15:31:19 +0000
@@ -1,1 +1,9 @@
 PANDORA_HAVE_LIBEVENT
+
+AS_IF([test "x$ac_cv_libevent" = "xno"],
+  AC_MSG_WARN([libevent not found: not building json_server.]))
+
+PANDORA_LIBEVENT_RECENT
+
+AS_IF([test "$pandora_cv_libevent_recent" = "no"],
+  AC_MSG_WARN([Your version of libevent is too old. json_server requires v 2.0 or newer: not building json_server.]))
 
=== modified file 'plugin/json_server/plugin.ini'
--- plugin/json_server/plugin.ini	2012-01-14 22:02:03 +0000
+++ plugin/json_server/plugin.ini	2012-05-20 15:31:19 +0000
@@ -17,5 +17,5 @@
   json/json_reader.cpp
   json/json_value.cpp
   json/json_writer.cpp
-build_conditional="x${ac_cv_libevent}" = "xyes" -a "x${ac_cv_libcurl}" = "xyes"
+build_conditional="x${ac_cv_libevent}" = "xyes" -a "x$pandora_cv_libevent_recent" = "xyes" -a "x${ac_cv_libcurl}" = "xyes"
 ldflags=${LTLIBEVENT}