~drizzle-trunk/drizzle/development

/* -*- 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;