Merge lp:~hingo/drizzle/drizzle-js_eval into lp:~drizzle-trunk/drizzle/development

[Henrik Ingo]

Hi

I've written a plugin that embeds the v8 javascript engine and exposes it as a function JS(<javascript code snippet>, <arg1>, <arg2>, ...). The code is now feature complete for the first iteration. It still lacks test cases and documentation. I intend to complete those before this is merged, but I'm sending this to ask for a first review at this stage. This is my first Drizzle code I've ever written, so getting feedback at this stage would be appreciated. So please note, I'm asking for review but not yet asking to merge this.

The primary reason to do this is to get a JSON parser + ability to manipulate and return the JSON documents. This is analogous to the MySQL functions ExtractValue() and UpdateXML() for XML strings, there just isn't a counterpart to XPath in JSON. The side effect of being able to execute arbitrary Javascript inside Drizzle is cool, and can be built upon in the future. Currently there is no Drizzle functionality available inside the javascript environment, for instance you couldn't query any tables or do anything else you typically do with stored procedures.

The code comments still contain some todos which are more like questions - things I'd like to learn about Drizzle internals. If the reviewer can answer those in feedback via drizzle-discuss, that would be great.

The code comments also contain todos which I don't intend to fix in the first version, they are mostly performance work in particular related to the fact that v8 is very single threaded (Chrome browser has a separate browser and separate v8 instance for each tab). The intent is to focus short term on feature completeness and leave the performance work for later. (The current code will not degrade Drizzle performance in general, but it would not be a good idea to do a hundred simultaneous calls to JS().)

Usage examples can be seen in the comments to this blog post:
http://openlife.cc/blogs/2011/august/stored-procedures-javascript-my-drizzle-repository-can-do-it

Please note that the function is now called JS(...) and there is no JS_EVAL(...).

[lp:~hingo/drizzle/drizzle-js_eval]

2385. By Henrik Ingo on 2011-09-24

Added tests for JS().

[Olaf van der Spek (olafvdspek)]

Some style comments, I hope you don't mind.

206 +namespace drizzle_plugin {
207 +
208 +namespace js {

Redundant empty line

220 +class JsFunction :public Item_str_func

Missing space after ':'

221 +{
222 +public:
223 + JsFunction() :Item_str_func() {}
224 + ~JsFunction() {}

Empty constructors and destructors aren't necessary.

260 +void emit_drizzle_error(v8::TryCatch* try_catch) {

'{' should be on the next line

Greetings,

Olaf

[lp:~hingo/drizzle/drizzle-js_eval]

2386. By Henrik Ingo on 2011-09-29

Add 2 tests I forgot:
 - connect from 2 clients to make sure we are handling multi threaded
   mode correctly.
 - run a script that gives JavaScript syntax error.

2387. By Henrik Ingo on 2011-10-01

Wrote end user documentation for JS().
Labeled this as version 0.9.
This is now ready to start the journey towards trunk!

2388. By Henrik Ingo on 2011-10-01

Small style fixes from Olaf's review (thanks).
Removed @todo items that have been done.

=== modified file 'configure.ac'
--- configure.ac	2011-08-16 01:07:54 +0000
+++ configure.ac	2011-10-01 10:16:24 +0000
@@ -155,7 +155,7 @@
 PANDORA_DRIZZLE_BUILD
 PANDORA_HAVE_BOOST_TEST
 PANDORA_HAVE_LIBSQLITE3
-
+PANDORA_HAVE_LIBV8
 
 
 #########################################################################

=== modified file 'drizzled/error.cc'
--- drizzled/error.cc	2011-08-16 11:47:29 +0000
+++ drizzled/error.cc	2011-10-01 10:16:24 +0000
@@ -639,6 +639,9 @@
   ADD_ERROR_MESSAGE(ER_USE_DATA_DICTIONARY, N_("Engine status is now stored in the data_dictionary tables, please use these instead."));
   ADD_ERROR_MESSAGE(ER_TRANSACTION_ALREADY_STARTED, N_("There is already a transaction in progress"));
   ADD_ERROR_MESSAGE(ER_NO_LOCK_HELD, N_("No lock is held by this connection."));
+  
+  // Errors in scripts, such as JavaScript
+  ADD_ERROR_MESSAGE(ER_SCRIPT, N_("Script error: %s"));
 }
 
 } /* namespace drizzled */

=== modified file 'drizzled/error_t.h'
--- drizzled/error_t.h	2011-08-16 11:47:29 +0000
+++ drizzled/error_t.h	2011-10-01 10:16:24 +0000
@@ -866,7 +866,8 @@
   ER_USE_DATA_DICTIONARY,
   ER_TRANSACTION_ALREADY_STARTED,
   ER_CARTESIAN_JOIN_ATTEMPTED,
-  ER_NO_LOCK_HELD
+  ER_NO_LOCK_HELD,
+  ER_SCRIPT                                         /* Error executing script: (such as JavaScript) */
 };
 
 

=== modified file 'drizzled/temporal.h'
--- drizzled/temporal.h	2011-03-29 12:45:08 +0000
+++ drizzled/temporal.h	2011-10-01 10:16:24 +0000
@@ -76,7 +76,7 @@
 /**
  * Base class for all temporal data classes.
  */
-class Temporal
+class DRIZZLED_API Temporal
 {
 protected:
   enum calendar _calendar;
@@ -188,7 +188,7 @@
  * Class representing temporal components in a valid
  * SQL date range, with no time component
  */
-class Date: public Temporal
+class DRIZZLED_API Date: public Temporal
 {
 public:
   Date() :Temporal() {}
@@ -435,7 +435,7 @@
  * Class representing temporal components having only
  * a time component, with no date structure
  */
-class Time: public Temporal
+class DRIZZLED_API Time: public Temporal
 {
 public:
   Time() :Temporal() {}
@@ -567,7 +567,7 @@
  * Class representing temporal components in a valid
  * SQL datetime range, including a time component
  */
-class DateTime: public Date
+class DRIZZLED_API DateTime: public Date
 {
 public:
   DateTime() :Date() {}
@@ -680,7 +680,7 @@
 /**
  * Class representing temporal components in the UNIX epoch
  */
-class Timestamp: public DateTime
+class DRIZZLED_API Timestamp: public DateTime
 {
 public:
   Timestamp() :DateTime() {}
@@ -746,7 +746,7 @@
  * Class representing temporal components in the UNIX epoch
  * with an additional microsecond component.
  */
-class MicroTimestamp: public Timestamp
+class DRIZZLED_API MicroTimestamp: public Timestamp
 {
 public:
   MicroTimestamp() :Timestamp() {}
@@ -789,7 +789,7 @@
  * Class representing temporal components in the UNIX epoch
  * with an additional nanosecond component.
  */
-class NanoTimestamp: public Timestamp
+class DRIZZLED_API NanoTimestamp: public Timestamp
 {
 public:
   NanoTimestamp() :Timestamp() {}

=== added file 'm4/pandora_have_libv8.m4'
--- m4/pandora_have_libv8.m4	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libv8.m4	2011-10-01 10:16:24 +0000
@@ -0,0 +1,53 @@
+dnl  Copyright (C) 2009 Sun Microsystems, Inc.
+dnl This file is free software; Sun Microsystems, Inc.
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+#--------------------------------------------------------------------
+# Check for libv8
+#--------------------------------------------------------------------
+
+
+AC_DEFUN([_PANDORA_SEARCH_LIBV8],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  # v8 is written in C++, need to use g++ for test link below
+  AC_LANG_CPLUSPLUS
+
+  AC_LIB_HAVE_LINKFLAGS(v8, pthread,
+  [
+    #include <v8.h>
+  ],[
+    v8::HandleScope handle_scope;
+  ]) 
+
+  AM_CONDITIONAL(HAVE_LIBV8, [test "x${ac_cv_libv8}" = "xyes"])
+])
+
+AC_DEFUN([_PANDORA_HAVE_LIBV8],[
+  AC_ARG_ENABLE([libv8],
+    [AS_HELP_STRING([--disable-libv8],
+      [Build with libv8 support @<:@default=on@:>@])],
+    [ac_enable_libv8="$enableval"],
+    [ac_enable_libv8="yes"])
+
+  _PANDORA_SEARCH_LIBV8
+])
+
+
+AC_DEFUN([PANDORA_HAVE_LIBV8],[
+  AC_REQUIRE([_PANDORA_HAVE_LIBV8])
+])
+
+AC_DEFUN([_PANDORA_REQUIRE_LIBV8],[
+  ac_enable_libv8="yes"
+  _PANDORA_SEARCH_LIBV8
+
+  AS_IF([test x$ac_cv_libv8 = xno],[
+    PANDORA_MSG_ERROR([libv8 is required for ${PACKAGE}. On Debian this can be found in libv8-dev. On RedHat this can be found in libv8-devel.])
+  ])
+])
+
+AC_DEFUN([PANDORA_REQUIRE_LIBV8],[
+  AC_REQUIRE([_PANDORA_REQUIRE_LIBV8])
+])

=== added directory 'plugin/js'
=== added directory 'plugin/js/docs'
=== added file 'plugin/js/docs/index.rst'
--- plugin/js/docs/index.rst	1970-01-01 00:00:00 +0000
+++ plugin/js/docs/index.rst	2011-10-01 10:16:24 +0000
@@ -0,0 +1,230 @@
+JS
+===========
+
+.. code-block:: mysql
+
+	JS(javascript_code [, arg1 [AS arg_name]] [, ...]) 
+
+``JS()`` executes a JavaScript code snippet and returns the value of the last executed statement. Additional arguments are passed to the JavaScript environment and are available in the ``arguments[]`` array. If the optional ``AS arg_name`` is used, the same argument value is made available as a global variable with that name.
+
+
+.. _js_loading:
+
+Loading
+-------
+
+This plugin is loaded by default.
+
+If you want to prevent the loading of this plugin, start :program:`drizzled` with::
+
+   --plugin-remove=js
+
+.. _js_examples:
+
+Examples
+--------
+
+The first argument is required and should be a string of valid JavaScript code. The value of the last statement is returned, note that you should not use a ``return`` keyword. This is a top level JavaScript code snippet, not a JavaScript function.
+
+.. code-block:: mysql
+
+	SELECT JS('var d = new Date(); "Drizzle started running JavaScript at: " + d;');
+
+Will output
+
++----------------------------------------------------------------------------------+
+| JS('var d = new Date(); "Drizzle started running JavaScript at: " + d;')         |
++==================================================================================+
+| Drizzle started running JavaScript at: Mon Aug 29 2011 00:23:31 GMT+0300 (EEST)  |
++----------------------------------------------------------------------------------+
+
+
+Additional arguments are passed to the JavaScript environment and are available in the ``arguments[]`` array. 
+
+.. code-block:: mysql
+
+	SELECT JS("arguments[0] + arguments[1] + arguments[2];", 1, 2, 3) AS 'JS(...)';
+
+Will output
+
++--------------+
+| JS(...)      |
++==============+
+| 6            |
++--------------+
+
+
+
+If the optional ``AS arg_name`` is used, the same argument value is made available as a global variable with that name.
+
+.. code-block:: mysql
+
+	SELECT JS("first + second + third;", 1 AS 'first', 2.0 AS 'second', 3.5 AS 'third') AS 'JS(...)';
+
+Will output
+
++--------------+
+| JS(...)      |
++==============+
+| 6.5          |
++--------------+
+
+.. _json_parse:
+
+Using JS() to parse JSON documents
+-----------------------------------
+
+JavaScript includes a JSON parser. This means you can use ``JS()`` as a JSON parser, and optionally use JavaScript to manipulate or select fragments of the JSON document. To do this, pass your JSON document as an argument, and use the ``JSON.parse()`` method to return it as a JavaScript object:
+
+.. code-block:: mysql
+
+	SELECT JS("var jsondoc = JSON.parse(arguments[0]); jsondoc['name']['firstname'];", 
+	          '{ "name" : {"firstname" : "Henrik", "lastname" : "Ingo"} }') AS 'JS(...)';
+
+Will output
+
++--------------+
+| JS(...)      |
++==============+
+| Henrik       |
++--------------+
+
+
+To return a JSON document from JavaScript, use ``JSON.stringify()``:
+
+.. code-block:: mysql
+
+	SELECT JS("var jsondoc = JSON.parse(arguments[0]); 
+	           JSON.stringify(jsondoc['name']);", 
+	          '{ "name" : {"firstname" : "Henrik", "lastname" : "Ingo"} }') AS 'JS(...)';
+
+
+Will output
+
++------------------------------------------+
+| JS(...)                                  |
++==========================================+
+| {"firstname":"Henrik","lastname":"Ingo"} |
++------------------------------------------+
+
+Note that since a Drizzle function can only return scalar values, if you want to return arrays or objects from your JavaScript, JSON is a recommended way of doing that.
+
+.. _js_queries:
+
+Using JS in queries, passing columns as arguments
+-------------------------------------------------
+
+Naturally, the arguments can also be columns in a query. For instance in the case of JSON data, if you have stored JSON documents as TEXT or BLOB in a table, you can now use ``JSON.parse()`` to select individual fields out of it:
+
+.. code-block:: mysql
+
+	CREATE TABLE t (k INT PRIMARY KEY auto_increment, v TEXT);
+	INSERT INTO t (v) VALUES ('{ "person" : { "firstname" : "Roland", "lastname" : "Bouman" } }');
+	INSERT INTO t (v) VALUES ('{ "person" : { "firstname" : "Henrik", "lastname" : "Ingo" } }');
+	INSERT INTO t (v) VALUES ('{ "person" : { "firstname" : "Brian", "lastname" : "Aker" } }');
+	SELECT JS('var person = JSON.parse(jsondoc); person["person"]["firstname"];', 
+	          v as jsondoc) AS 'JS(...)' 
+	FROM t WHERE k=2;
+
+
+Will output
+
++--------------+
+| JS(...)      |
++==============+
+| Henrik       |
++--------------+
+
+
+And
+
+.. code-block:: mysql
+
+	SELECT k, JS('var person = JSON.parse(jsondoc); person["person"]["firstname"];', 
+	             v as jsondoc) AS 'firstname', 
+	          JS('var person = JSON.parse(jsondoc); person["person"]["lastname"];', 
+	             v as jsondoc) AS 'lastname' 
+	FROM t;
+
+Will break your unstructured JSON data back into a relational table:
+
++---+-----------+----------+
+| k | firstname | lastname |
++===+===========+==========+
+| 1 | Roland    | Bouman   |
++---+-----------+----------+
+| 2 | Henrik    | Ingo     |
++---+-----------+----------+
+| 3 | Brian     | Aker     |
++---+-----------+----------+
+
+.. _js_stored_procedure_surrogate:
+
+Using JS as surrogate for stored procedures:
+--------------------------------------------
+
+Especially if the JavaScript you want to use is more complex, it might be a good idea to store the javascript itself in a table in Drizzle, or alternatively a variable. This simplifies queries that use the script:
+
+.. code-block:: mysql
+
+	CREATE TABLE sp (name VARCHAR(255) PRIMARY KEY, script TEXT);
+	INSERT INTO sp (name, script) VALUES ('get_person_property', 'var person = JSON.parse(jsondoc); person["person"][property];');
+	SELECT k, JS( (SELECT script FROM sp WHERE name='get_person_property'), 
+	             v as jsondoc, 'firstname' as 'property') AS 'firstname', 
+	          JS( (SELECT script FROM sp WHERE name='get_person_property'), 
+	             v as jsondoc, 'lastname' as 'property') AS 'lastname' 
+	FROM t;
+
+
+Will output the same result as above:
+
++---+-----------+----------+
+| k | firstname | lastname |
++===+===========+==========+
+| 1 | Roland    | Bouman   |
++---+-----------+----------+
+| 2 | Henrik    | Ingo     |
++---+-----------+----------+
+| 3 | Brian     | Aker     |
++---+-----------+----------+
+
+.. _js_future_work:
+
+Limitations and future work
+---------------------------
+
+The current version of ``JS()`` is complete in the sense that any type of arguments (integer, real, decimal, string, date) can be used, JavaScript code can be of arbitrary complexity and scalar values of any type can be returned. However, apart from the input parameters and the return value, there is no way to interact with Drizzle from the JavaScript environment. The plan is that in a future version ``JS()`` will expose some Drizzle API's, such as the ``Execute()`` API, so that one could query Drizzle tables and call other Drizzle functions from the JavaScript environment. This would essentially make JS() a form of JavaScript stored procedures. Of course, a next step after that could be to actually support ``STORED PROCEDURE`` syntax and permissions.
+
+Values of type ``DECIMAL`` will be passed as JavaScript ``Double`` values. This may lead to loss of precision. If you want to keep the precision, you must explicitly cast ``DECIMAL`` values into ``CHAR`` when you pass them as arguments. Note that this will affect how the JavaScript ``+`` operator works on the value (string concatenation instead of addition).
+
+The current version lacks several obvious performance optimizations. Most importantly the v8 JavaScript engine is single threaded, so heavy use of ``JS()`` on busy production servers is not recommended. A future version will use the v8 Isolate class to run several instances of the single threaded v8 engine.
+
+.. _js_authors:
+
+Authors
+-------
+
+Henrik Ingo
+
+Thanks to Roland Bouman for suggesting to use v8 engine instead of just a JSON parser and for review and comments on JavaScript and JSON conventions.
+
+.. _js_version:
+
+Version
+-------
+
+This documentation applies to **js 0.9**.
+
+To see which version of the plugin a Drizzle server is running, execute:
+
+.. code-block:: mysql
+
+   SELECT MODULE_VERSION FROM DATA_DICTIONARY.MODULES WHERE MODULE_NAME='js'
+
+
+Changelog
+---------
+
+v0.9
+^^^^
+* First release. Complete JS() functionality, but no APIs back to Drizzle are exposed yet and several performance optimizations were left for later release.

=== added file 'plugin/js/js.cc'
--- plugin/js/js.cc	1970-01-01 00:00:00 +0000
+++ plugin/js/js.cc	2011-10-01 10:16:24 +0000
@@ -0,0 +1,371 @@
+/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2011, Henrik Ingo.
+ *
+ *  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
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <config.h>
+#include <stdio.h>
+
+#include <drizzled/error.h>
+#include <drizzled/plugin/function.h>
+#include <drizzled/function/str/strfunc.h>
+#include <drizzled/temporal.h>
+
+#include <v8.h>
+#define JS_ENGINE "v8"
+
+using namespace std;
+using namespace drizzled;
+
+
+namespace drizzle_plugin {
+namespace js {
+
+v8::Handle<v8::Value> V8Version(const v8::Arguments& args);
+v8::Handle<v8::Value> JsEngine(const v8::Arguments& args);
+const char* v8_to_char(const v8::String::Utf8Value& value);
+void emit_drizzle_error(v8::TryCatch* try_catch);
+
+
+// TODO: So this is a function that returns strings? 
+// What is the class for functions that return mixed types?
+// Or is this as it should be, apparently js('1') + js('2') does the right thing already.
+
+class JsFunction : public Item_str_func
+{
+public:
+  String *val_str(String *);
+
+  const char *func_name() const 
+  { 
+    return "js"; 
+  }
+
+  void fix_length_and_dec() 
+  { 
+    maybe_null= 1;
+    max_length= MAX_BLOB_WIDTH;   
+  }
+
+  bool check_argument_count(int n)
+  {
+    return (n >= 1);
+  }
+};
+
+/**
+ * @brief Extracts a C string from a V8 Utf8Value
+ * 
+ * Idea copied from v8 sources, samples/shell.cc. Makes code easier to read than
+ * (char *)(*utf8value)
+ */
+const char* v8_to_char(const v8::String::Utf8Value& value) {
+  return *value ? *value : "<javascript v8 string conversion failed>";
+}
+
+/**
+ * @brief Take v8 exception and emit Drizzle error to client
+ * 
+ * This is adapted from ReportException() in v8 samples/shell.cc. 
+ */
+void emit_drizzle_error(v8::TryCatch* try_catch)
+{
+  v8::HandleScope handle_scope;
+  v8::String::Utf8Value exception(try_catch->Exception());
+  const char* exception_string = v8_to_char(exception);
+  v8::Handle<v8::Message> message = try_catch->Message();
+  if (message.IsEmpty()) {
+    // V8 didn't provide any extra information about this error; just
+    // print the exception.
+    my_error(ER_SCRIPT, MYF(0), exception_string);
+  } else {
+    char buf[2048]; 
+    int linenum = message->GetLineNumber();
+    sprintf(buf, "At line %i: %.1900s (Do SHOW ERRORS for more information.)", linenum, exception_string);
+    my_error(ER_SCRIPT, MYF(0), buf);
+    // Print line of source code and where error happened.
+    v8::String::Utf8Value sourceline(message->GetSourceLine());
+    const char* sourceline_string = v8_to_char(sourceline);
+    sprintf(buf, "Line %i: %.160s", linenum, sourceline_string);
+    my_error(ER_SCRIPT, MYF(0), buf);    
+    int start = message->GetStartColumn();
+    sprintf(buf, "Check your script starting at: '%.50s'", &sourceline_string[start]);
+    my_error(ER_SCRIPT, MYF(0), buf);
+    v8::String::Utf8Value stack_trace(try_catch->StackTrace());
+    if (stack_trace.length() > 0) {
+      const char* stack_trace_string = v8_to_char(stack_trace);
+      my_error(ER_SCRIPT, MYF(0), stack_trace_string);
+    }
+  }
+}
+
+/**
+ * @brief Implements js() - execute JavaScript code
+ * 
+ * @todo row_result types are not yet handled, what are they anyway?
+ * @todo Lot's of performance optimizations postponed for later version:
+ *  * When available, use v8::Isolate instead of v8::Locker for multithreading 
+ * (or a mix of both). 
+ *  * As part of this work, refactor v8 stuff into separate 
+ * function, proxy, factory or something...
+ *  * Save the compiled script so it can be used again if same script is run
+ * many times
+ *  * Some of the v8 stuff should be done in initialize()
+ * 
+ * @note DECIMAL_RESULT type is now a double in JavaScript. This could lose 
+ * precision. But to send them as strings would also be awkward (+ operator will 
+ * do unexpected things). In any case, we'd need some biginteger (bigdecimal?) 
+ * kind of library to do anything with higher precision values anyway. If you 
+ * want to keep the precision, you can cast your decimal values to strings 
+ * explicitly when passing them as arguments.
+ * 
+ * @param res Pointer to the drizzled::String object that will contain the result
+ * @return a drizzled::String containing the value returned by executed JavaScript code (value of last executed statement) 
+ */
+String *JsFunction::val_str( String *str )
+{
+  assert( fixed == 1 );
+  // If we return from any of the error conditions during method, then 
+  // return value of the drizzle function is null.
+  null_value= true; 
+  
+  String *source_str=NULL;
+  source_str = args[0]->val_str( str ); 
+  
+  // Need to use Locker in multi-threaded app. v8 is unlocked by the destructor 
+  // when locker goes out of scope.
+  // TODO: Newer versions of v8 provide an Isolate class where you can get a 
+  // separate instance of v8 (ie one per thread). v8 2.5.9.9 in Ubuntu 11.04 does 
+  // not yet offer it.
+  v8::Locker locker;
+  // Pass code and arguments into v8...
+  v8::HandleScope handle_scope;
+  // Create a template for the global object and populate a drizzle object.
+  v8::Handle<v8::ObjectTemplate> global  = v8::ObjectTemplate::New();
+  // Drizzle will contain API's to drizzle variables, functions and tables
+  v8::Handle<v8::ObjectTemplate> db = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> js = v8::ObjectTemplate::New();
+  // Bind the 'version' function 
+  global->Set( v8::String::New("db"), db );
+  db->Set( v8::String::New("js"), js );
+  js->Set( v8::String::New("version"), v8::FunctionTemplate::New(V8Version) );
+  js->Set( v8::String::New("engine"), v8::FunctionTemplate::New(JsEngine) );
+  
+  // Now bind the arguments into argv[]
+  // v8::Array can only be created when context is already entered (otherwise v8 segfaults!)
+  v8::Persistent<v8::Context> context = v8::Context::New( NULL, global );
+  if ( context.IsEmpty() ) {
+    char buf[100];
+    sprintf(buf, "Error in js() while creating JavaScript context in %s.", JS_ENGINE);
+    my_error(ER_SCRIPT, MYF(0), buf);
+    return NULL;
+  }
+  context->Enter();
+   
+  v8::Handle<v8::Array> a = v8::Array::New(arg_count-1);
+  for( uint64_t n = 1; n < arg_count; n++ )
+  {
+    // Need to do this differently for ints, doubles and strings
+    // TODO: There is also ROW_RESULT. Is that relevant here? What does it look like? I could pass rows as an array or object.
+    if( args[n]->result_type() == INT_RESULT ){
+      // TODO: Turns out Drizzle doesn't do unsigned. So this code path can never happen? (I can't test it at least...)
+      if( args[n]->is_unsigned() ) {
+        a->Set( n-1, v8::Integer::NewFromUnsigned( (uint32_t) args[n]->val_uint() ) );
+      } else {
+        a->Set( n-1, v8::Integer::New((int32_t)args[n]->val_int() ) );
+      }
+    } else if ( args[n]->result_type() == REAL_RESULT || args[n]->result_type() == DECIMAL_RESULT ) {
+      a->Set( n-1, v8::Number::New(args[n]->val_real() ) );
+    } else if ( true || args[n]->result_type() == STRING_RESULT ) {
+      if ( args[n]->is_datetime() ) {
+        // DATE/TIME values are also STRING_RESULT, make them a Date type in v8
+        // Now we need to get the unix timestamp integer, surprisingly tricky...
+        // TODO: This should really be just args[n]->get_epoch_seconds(). I need to write a separate patch for Item class one of these days.
+        type::Time ltime;
+        Timestamp temporal;
+        args[n]->get_date(ltime, 0);
+        temporal.set_years(ltime.year);
+        temporal.set_months(ltime.month);
+        temporal.set_days(ltime.day);
+        temporal.set_hours(ltime.hour);
+        temporal.set_minutes(ltime.minute);
+        temporal.set_seconds(ltime.second);
+        temporal.set_epoch_seconds();
+        if (temporal.is_valid())
+        {
+          time_t tmp;
+          temporal.to_time_t(tmp);
+          // Pay attention, Ecmascript defines a date as *milliseconds* since unix epoch
+          // Also, on platforms where time_t is 32 bit, we need explicit cast to 64 bit integer
+          a->Set( n-1, v8::Date::New(((uint64_t)tmp)*1000) );
+        } else {
+          a->Set( n-1, v8::String::New(args[n]->val_str(str)->c_str() ) );
+        }
+      } else {
+        // Default to creating string values in JavaScript
+        a->Set( n-1, v8::String::New(args[n]->val_str(str)->c_str() ) );
+      }
+    }
+    // If user has given a name to the arguments, pass these as global variables
+    if( ! args[n]->is_autogenerated_name ) {
+      if( args[n]->result_type() == INT_RESULT ){
+        if( args[n]->is_unsigned() ) {
+          context->Global()->Set( v8::String::New( args[n]->name ), v8::Integer::NewFromUnsigned( (uint32_t) args[n]->val_uint() ) );
+        } else {
+          context->Global()->Set( v8::String::New( args[n]->name ), v8::Integer::New((int32_t)args[n]->val_int() ) );
+        }
+      } else if ( args[n]->result_type() == REAL_RESULT || args[n]->result_type() == DECIMAL_RESULT ) {
+        context->Global()->Set( v8::String::New( args[n]->name ), v8::Number::New(args[n]->val_real() ) );
+      } else if ( true || args[n]->result_type() == STRING_RESULT ) {
+      if ( args[n]->is_datetime() ) {
+        // DATE/TIME values are also STRING_RESULT, make them a Date type in v8
+        // Now we need to get the unix timestamp integer, surprisingly tricky...
+        // TODO: This should really be just args[n]->get_epoch_seconds(). I need to write a separate patch for Item class one of these days.
+        type::Time ltime;
+        Timestamp temporal;
+        args[n]->get_date(ltime, 0);
+        temporal.set_years(ltime.year);
+        temporal.set_months(ltime.month);
+        temporal.set_days(ltime.day);
+        temporal.set_hours(ltime.hour);
+        temporal.set_minutes(ltime.minute);
+        temporal.set_seconds(ltime.second);
+        temporal.set_epoch_seconds();
+        if (temporal.is_valid())
+        {
+          time_t tmp;
+          temporal.to_time_t(tmp);
+          // Pay attention, Ecmascript defines a date as *milliseconds* since unix epoch
+          // Also, on platforms where time_t is 32 bit, we need explicit cast to 64 bit integer
+          context->Global()->Set( v8::String::New( args[n]->name ), v8::Date::New(((uint64_t)tmp)*1000) );
+        } else {
+          context->Global()->Set( v8::String::New( args[n]->name ), v8::String::New(args[n]->val_str(str)->c_str() ) );
+        }
+      } else {
+        context->Global()->Set( v8::String::New( args[n]->name ), v8::String::New(args[n]->val_str(str)->c_str() ) );
+      }
+      }
+    }
+  }
+  //Need to fetch the global element back from context, global doesn't work anymore
+  context->Global()->Set( v8::String::New("arguments"), a );
+
+  
+  
+  // Compile the source code.
+  v8::TryCatch try_catch;
+  v8::Handle<v8::Value> result;
+  // Create a v8 string containing the JavaScript source code.
+  // Convert from drizzled::String to char* string to v8::String.
+  v8::Handle<v8::String> source = v8::String::New(source_str->c_str());
+  v8::Handle<v8::Script> script = v8::Script::Compile(source);
+  if ( script.IsEmpty() ) {
+    emit_drizzle_error(&try_catch);
+    return NULL;
+  } else {
+    result = script->Run();
+    if ( result.IsEmpty() ) {
+      assert( try_catch.HasCaught() );
+      emit_drizzle_error( &try_catch );
+      // Dispose of Persistent objects before returning. (Is it needed?)
+      context->Exit();
+      context.Dispose();
+      return NULL;
+    } else {
+      assert( !try_catch.HasCaught() );
+      if ( result->IsUndefined() ) {
+        // Nothing wrong here, but we return Undefined as NULL.
+        // Dispose of Persistent objects before returning. (Is it needed?)
+        context->Exit();
+        context.Dispose();
+        return NULL;
+      }
+    }
+  }
+    
+  // Run the script to get the result.
+  //v8::Handle<v8::Value> foo = script->Run();
+  v8::Handle<v8::String> rstring = result->ToString();
+  
+  // Convert the result to a drizzled::String and print it.
+  // Allocate space to the drizzled::String 
+  str->free(); //TODO: Check the source for alloc(), but apparently I don't need this line?
+  str->alloc( rstring->Utf8Length() );
+  // Now copy string from v8 heap to drizzled heap
+  rstring->WriteUtf8( str->ptr() );
+  // drizzled::String doesn't actually set string length properly in alloc(), so set it now
+  str->length( rstring->Utf8Length() );
+ 
+  context->Exit();
+  context.Dispose();
+
+  // There was no error and value returned is not undefined, so it's not null.
+  null_value= false;
+  return str;
+}
+
+
+
+
+plugin::Create_function<JsFunction> *js_function = NULL;
+
+static int initialize( module::Context &context )
+{
+  js_function = new plugin::Create_function<JsFunction>("js");
+  context.add( js_function );
+  // Initialize V8
+  v8::V8::Initialize();
+  return 0;
+}
+
+
+/* Functions that are part of the JavaScript API ***************************/
+
+/**
+ * @brief Binds as db.js.version() inside JavaScript.
+ * @return Version number of v8 engine
+ */
+v8::Handle<v8::Value> V8Version( const v8::Arguments& ) {
+  return v8::String::New( v8::V8::GetVersion() );
+}
+
+/**
+ * @brief Binds as db.js.engine() inside JavaScript.
+ * @return The string "v8"
+ */
+v8::Handle<v8::Value> JsEngine( const v8::Arguments& ) {
+  return v8::String::New( JS_ENGINE );
+}
+
+} // namespace js
+
+} // namespace drizzle_plugin
+
+DRIZZLE_DECLARE_PLUGIN
+{
+  DRIZZLE_VERSION_ID,
+  "js",
+  "0.9",
+  "Henrik Ingo",
+  "Execute JavaScript code with supplied arguments",
+  PLUGIN_LICENSE_GPL,
+  drizzle_plugin::js::initialize, /* Plugin Init */
+  NULL,   /* depends */              
+  NULL    /* config options */
+}
+DRIZZLE_DECLARE_PLUGIN_END;
+       
\ No newline at end of file

=== added file 'plugin/js/plugin.ini'
--- plugin/js/plugin.ini	1970-01-01 00:00:00 +0000
+++ plugin/js/plugin.ini	2011-10-01 10:16:24 +0000
@@ -0,0 +1,10 @@
+[plugin]
+name=js
+version=0.9
+author=Henrik Ingo
+license=PLUGIN_LICENSE_GPL
+title=Execute JavaScript Code
+description=Execute JavaScript code with supplied parameters
+load_by_default=yes
+build_conditional="$ac_cv_libv8" = "yes"
+ldflags=${LTLIBV8}

=== added directory 'plugin/js/tests'
=== added directory 'plugin/js/tests/r'
=== added file 'plugin/js/tests/r/js.result'
--- plugin/js/tests/r/js.result	1970-01-01 00:00:00 +0000
+++ plugin/js/tests/r/js.result	2011-10-01 10:16:24 +0000
@@ -0,0 +1,35 @@
+SELECT JS("var foo = 'Hello'; foo + ', World';");
+JS("var foo = 'Hello'; foo + ', World';")
+Hello, World
+SELECT JS("var foo = 'Hello'; foo + ', ' + arguments[0];", "World");
+JS("var foo = 'Hello'; foo + ', ' + arguments[0];", "World")
+Hello, World
+SELECT JS("var foo = 'Hello'; foo + ', ' + bar;", "World" AS 'bar');
+JS("var foo = 'Hello'; foo + ', ' + bar;", "World" AS 'bar')
+Hello, World
+CREATE TABLE jstest (id INT PRIMARY KEY auto_increment, i INT, d DOUBLE, t TIMESTAMP, dt DATETIME);
+INSERT INTO jstest VALUES (1, -5, 7.5, '2001-02-16 20:38:40', '2011-09-24 22:26:31');
+SELECT JS("arguments[0] + 1", i) FROM jstest WHERE id=1;
+JS("arguments[0] + 1", i)
+-4
+SELECT JS("arguments[0] + 1.1", d) FROM jstest WHERE id=1;
+JS("arguments[0] + 1.1", d)
+8.6
+SELECT JS("var d = arguments[0]; d.getUTCFullYear() + ' - ' + d.getUTCHours() + ' - ' +  + d.getUTCSeconds();", t) FROM jstest WHERE id=1;
+JS("var d = arguments[0]; d.getUTCFullYear() + ' - ' + d.getUTCHours() + ' - ' +  + d.getUTCSeconds();", t)
+2001 - 20 - 40
+SELECT JS("var d = arguments[0]; d.getUTCDate() + ' - ' + d.getUTCHours() + ' - ' + d.getUTCMinutes();", dt) FROM jstest WHERE id=1;
+JS("var d = arguments[0]; d.getUTCDate() + ' - ' + d.getUTCHours() + ' - ' + d.getUTCMinutes();", dt)
+24 - 22 - 26
+SELECT JS("var num = arguments[0] + arguments[1]; arguments[2] + num;", i, d, "The sum is: ") FROM jstest WHERE id=1;
+JS("var num = arguments[0] + arguments[1]; arguments[2] + num;", i, d, "The sum is: ")
+The sum is: 2.5
+SELECT JS('var jsondoc = JSON.parse(arguments[0]); JSON.stringify(jsondoc["name"]["firstname"]);', '{ "name" : {"firstname" : "Henrik", "lastname" : "Ingo"} }');
+JS('var jsondoc = JSON.parse(arguments[0]); JSON.stringify(jsondoc["name"]["firstname"]);', '{ "name" : {"firstname" : "Henrik", "lastname" : "Ingo"} }')
+"Henrik"
+DROP TABLE jstest;
+SELECT JS("this is not javascript");
+ERROR HY000: Script error: At line 1: SyntaxError: Unexpected identifier (Do SHOW ERRORS for more information.)
+SELECT JS("var foo = 'Another'; foo + ' thread';");
+JS("var foo = 'Another'; foo + ' thread';")
+Another thread

=== added directory 'plugin/js/tests/t'
=== added file 'plugin/js/tests/t/js.test'
--- plugin/js/tests/t/js.test	1970-01-01 00:00:00 +0000
+++ plugin/js/tests/t/js.test	2011-10-01 10:16:24 +0000
@@ -0,0 +1,35 @@
+# Basic Hello world test plust testing arguments with and without name
+SELECT JS("var foo = 'Hello'; foo + ', World';");
+SELECT JS("var foo = 'Hello'; foo + ', ' + arguments[0];", "World");
+SELECT JS("var foo = 'Hello'; foo + ', ' + bar;", "World" AS 'bar');
+
+# Test all data types are passed correctly as arguments (string was handled above)
+
+CREATE TABLE jstest (id INT PRIMARY KEY auto_increment, i INT, d DOUBLE, t TIMESTAMP, dt DATETIME);
+
+INSERT INTO jstest VALUES (1, -5, 7.5, '2001-02-16 20:38:40', '2011-09-24 22:26:31');
+SELECT JS("arguments[0] + 1", i) FROM jstest WHERE id=1;
+SELECT JS("arguments[0] + 1.1", d) FROM jstest WHERE id=1;
+SELECT JS("var d = arguments[0]; d.getUTCFullYear() + ' - ' + d.getUTCHours() + ' - ' +  + d.getUTCSeconds();", t) FROM jstest WHERE id=1;
+SELECT JS("var d = arguments[0]; d.getUTCDate() + ' - ' + d.getUTCHours() + ' - ' + d.getUTCMinutes();", dt) FROM jstest WHERE id=1;
+
+# Test combinations
+SELECT JS("var num = arguments[0] + arguments[1]; arguments[2] + num;", i, d, "The sum is: ") FROM jstest WHERE id=1;
+
+# And the JSON test, why all this was created in the first place
+SELECT JS('var jsondoc = JSON.parse(arguments[0]); JSON.stringify(jsondoc["name"]["firstname"]);', '{ "name" : {"firstname" : "Henrik", "lastname" : "Ingo"} }');
+
+DROP TABLE jstest;
+
+# Make deliberate error
+--error ER_SCRIPT
+SELECT JS("this is not javascript");
+
+# Why does this crash drizzletest?
+# SHOW ERRORS;
+
+# Make another connection and make sure we are handling multi-threaded mode correctly
+# (V8 is single threaded only by default.)
+connect (con2,localhost,test,jstest,mysql);
+SELECT JS("var foo = 'Another'; foo + ' thread';");
+disconnect con2;