Merge pull request #114 from Sage/dont-throw

Dont throw

Author: joeferner

src/connection.cpp

@@ -57,11 +57,11 @@ Handle<Value> Connection::Execute(const Arguments& args) {
 
   String::Utf8Value sqlVal(sql);
 
-  ExecuteBaton* baton;
-  try {
-    baton = new ExecuteBaton(connection, *sqlVal, &values, &callback);
-  } catch(NodeOracleException &ex) {
-    return scope.Close(ThrowException(Exception::Error(String::New(ex.getMessage().c_str()))));
+  ExecuteBaton* baton = new ExecuteBaton(connection, *sqlVal, &values, &callback);
+  if (baton->error) {
+    Local<String> message = String::New(baton->error->c_str());
+    delete baton;
+    return scope.Close(ThrowException(Exception::Error(message)));
   }
 
   uv_work_t* req = new uv_work_t();
@@ -102,12 +102,7 @@ Handle<Value> Connection::Commit(const Arguments& args) {
 
   REQ_FUN_ARG(0, callback);
 
-  CommitBaton* baton;
-  try {
-    baton = new CommitBaton(connection, &callback);
-  } catch(NodeOracleException &ex) {
-    return scope.Close(ThrowException(Exception::Error(String::New(ex.getMessage().c_str()))));
-  }
+  CommitBaton* baton = new CommitBaton(connection, &callback);
 
   uv_work_t* req = new uv_work_t();
   req->data = baton;
@@ -124,12 +119,7 @@ Handle<Value> Connection::Rollback(const Arguments& args) {
 
   REQ_FUN_ARG(0, callback);
 
-  RollbackBaton* baton;
-  try {
-    baton = new RollbackBaton(connection, &callback);
-  } catch(NodeOracleException &ex) {
-    return scope.Close(ThrowException(Exception::Error(String::New(ex.getMessage().c_str()))));
-  }
+  RollbackBaton* baton = new RollbackBaton(connection, &callback);
 
   uv_work_t* req = new uv_work_t();
   req->data = baton;
@@ -172,7 +162,8 @@ void RandomBytesFree(char* data, void* hint) {
   delete[] data;
 }
 
-int Connection::SetValuesOnStatement(oracle::occi::Statement* stmt, vector<value_t*> &values) {
+int Connection::SetValuesOnStatement(oracle::occi::Statement* stmt, ExecuteBaton* baton) {
+  std::vector<value_t*> &values = baton->values;
   uint32_t index = 1;
   int outputParam = -1;
   OutParam * outParam = NULL;
@@ -254,19 +245,21 @@ int Connection::SetValuesOnStatement(oracle::occi::Statement* stmt, vector<value
             {
               ostringstream oss;
               oss << "SetValuesOnStatement: Unknown OutParam type: " << outParamType;
-              throw NodeOracleException(oss.str());
+              baton->error = new std::string(oss.str());
+              return -2;
             }
         }
         outputParam = index;
         break;
       default:
-        throw NodeOracleException("SetValuesOnStatement: Unhandled value type");
+        baton->error = new std::string("SetValuesOnStatement: Unhandled value type");
+        return -2;
     }
   }
   return outputParam;
 }
 
-void Connection::CreateColumnsFromResultSet(oracle::occi::ResultSet* rs, vector<column_t*> &columns) {
+void Connection::CreateColumnsFromResultSet(oracle::occi::ResultSet* rs, ExecuteBaton* baton, vector<column_t*> &columns) {
   vector<oracle::occi::MetaData> metadata = rs->getColumnListMetaData();
   for (vector<oracle::occi::MetaData>::iterator iterator = metadata.begin(), end = metadata.end(); iterator != end; ++iterator) {
     oracle::occi::MetaData metadata = *iterator;
@@ -308,14 +301,14 @@ void Connection::CreateColumnsFromResultSet(oracle::occi::ResultSet* rs, vector<
         ostringstream message;
         message << "CreateColumnsFromResultSet: Unhandled oracle data type: " << type;
         delete col;
-        throw NodeOracleException(message.str());
-        break;
+        baton->error = new std::string(message.str());
+        return;
     }
     columns.push_back(col);
   }
 }
 
-row_t* Connection::CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs, vector<column_t*> &columns) {
+row_t* Connection::CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs, ExecuteBaton* baton, vector<column_t*> &columns) {
   row_t* row = new row_t();
   int colIndex = 1;
   for (vector<column_t*>::iterator iterator = columns.begin(), end = columns.end(); iterator != end; ++iterator, colIndex++) {
@@ -345,8 +338,9 @@ row_t* Connection::CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs,
         default:
           ostringstream message;
           message << "CreateRowFromCurrentResultSetRow: Unhandled type: " << col->type;
-          throw NodeOracleException(message.str());
-          break;
+          baton->error = new std::string(message.str());
+          delete row;
+          return NULL;
       }
     }
   }
@@ -401,12 +395,14 @@ void Connection::EIO_Execute(uv_work_t* req) {
   oracle::occi::ResultSet* rs = NULL;
   try {
     if(! baton->connection->m_connection) {
-      throw NodeOracleException("Connection already closed");
+      baton->error = new std::string("Connection already closed");
+      return;
     }
     stmt = baton->connection->m_connection->createStatement(baton->sql);
     stmt->setAutoCommit(baton->connection->m_autoCommit);
     if (baton->connection->m_prefetchRowCount > 0) stmt->setPrefetchRowCount(baton->connection->m_prefetchRowCount);
-    int outputParam = SetValuesOnStatement(stmt, baton->values);
+    int outputParam = SetValuesOnStatement(stmt, baton);
+    if (baton->error) goto cleanup;
 
     int status = stmt->execute();
     if(status == oracle::occi::Statement::UPDATE_COUNT_AVAILABLE) {
@@ -430,10 +426,12 @@ void Connection::EIO_Execute(uv_work_t* req) {
               break;
             case OutParam::OCCICURSOR:
               rs = stmt->getCursor(output->index);
-              CreateColumnsFromResultSet(rs, output->columns);
+              CreateColumnsFromResultSet(rs, baton, output->columns);
+              if (baton->error) goto cleanup;
               output->rows = new vector<row_t*>();
               while(rs->next()) {
-                row_t* row = CreateRowFromCurrentResultSetRow(rs, output->columns);
+                row_t* row = CreateRowFromCurrentResultSetRow(rs, baton, output->columns);
+                if (baton->error) goto cleanup;
                 output->rows->push_back(row);
               }
               break;
@@ -456,31 +454,32 @@ void Connection::EIO_Execute(uv_work_t* req) {
               {
                 ostringstream oss;
                 oss << "Unknown OutParam type: " << output->type;
-                throw NodeOracleException(oss.str());
+                baton->error = new std::string(oss.str());
+                goto cleanup;
               }
           }
         }
       }
     } else if(status == oracle::occi::Statement::RESULT_SET_AVAILABLE) {
       rs = stmt->getResultSet();
-      CreateColumnsFromResultSet(rs, baton->columns);
+      CreateColumnsFromResultSet(rs, baton, baton->columns);
+      if (baton->error) goto cleanup;
       baton->rows = new vector<row_t*>();
 
       while(rs->next()) {
-        row_t* row = CreateRowFromCurrentResultSetRow(rs, baton->columns);
+        row_t* row = CreateRowFromCurrentResultSetRow(rs, baton, baton->columns);
+        if (baton->error) goto cleanup;
         baton->rows->push_back(row);
       }
     }
   } catch(oracle::occi::SQLException &ex) {
     baton->error = new string(ex.getMessage());
-  } catch(NodeOracleException &ex) {
-    baton->error = new string(ex.getMessage());
   } catch (const exception& ex) {
     baton->error = new string(ex.what());
   } catch (...) {
     baton->error = new string("Unknown Error");
   }
-
+cleanup:
   if(stmt && rs) {
     stmt->closeResultSet(rs);
     rs = NULL;
@@ -533,7 +532,7 @@ Local<Date> OracleTimestampToV8Date(oracle::occi::Timestamp* d) {
   return date;
 }
 
-Local<Object> Connection::CreateV8ObjectFromRow(vector<column_t*> columns, row_t* currentRow) {
+Local<Object> Connection::CreateV8ObjectFromRow(ExecuteBaton* baton, vector<column_t*> columns, row_t* currentRow) {
   Local<Object> obj = Object::New();
   uint32_t colIndex = 0;
   for (vector<column_t*>::iterator iterator = columns.begin(), end = columns.end(); iterator != end; ++iterator, colIndex++) {
@@ -639,21 +638,22 @@ Local<Object> Connection::CreateV8ObjectFromRow(vector<column_t*> columns, row_t
         default:
           ostringstream oss;
           oss << "CreateV8ObjectFromRow: Unhandled type: " << col->type;
-          throw NodeOracleException(oss.str());
-          break;
+          baton->error = new std::string(oss.str());
+          return obj;
       }
     }
   }
   return obj;
 }
 
-Local<Array> Connection::CreateV8ArrayFromRows(vector<column_t*> columns, vector<row_t*>* rows) {
+Local<Array> Connection::CreateV8ArrayFromRows(ExecuteBaton* baton, vector<column_t*> columns, vector<row_t*>* rows) {
   size_t totalRows = rows->size();
   Local<Array> retRows = Array::New(totalRows);
   uint32_t index = 0;
   for (vector<row_t*>::iterator iterator = rows->begin(), end = rows->end(); iterator != end; ++iterator, index++) {
     row_t* currentRow = *iterator;
-    Local<Object> obj = CreateV8ObjectFromRow(columns, currentRow);
+    Local<Object> obj = CreateV8ObjectFromRow(baton, columns, currentRow);
+    if (baton->error) return retRows;
     retRows->Set(index, obj);
   }
   return retRows;
@@ -669,11 +669,6 @@ void Connection::EIO_AfterExecute(uv_work_t* req, int status) {
     Handle<Value> argv[2];
     handleResult(baton, argv);
     node::MakeCallback(Context::GetCurrent()->Global(), baton->callback, 2, argv);
-  } catch(NodeOracleException &ex) {
-    Handle<Value> argv[2];
-    argv[0] = Exception::Error(String::New(ex.getMessage().c_str()));
-    argv[1] = Undefined();
-    node::MakeCallback(Context::GetCurrent()->Global(), baton->callback, 2, argv);
   } catch(const exception &ex) {
     Handle<Value> argv[2];
     argv[0] = Exception::Error(String::New(ex.what()));
@@ -686,12 +681,14 @@ void Connection::EIO_AfterExecute(uv_work_t* req, int status) {
 
 void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
   if(baton->error) {
+failed:
     argv[0] = Exception::Error(String::New(baton->error->c_str()));
     argv[1] = Undefined();
   } else {
     argv[0] = Undefined();
     if(baton->rows) {
-      argv[1] = CreateV8ArrayFromRows(baton->columns, baton->rows);
+      argv[1] = CreateV8ArrayFromRows(baton, baton->columns, baton->rows);
+      if (baton->error) goto failed; // delete argv[1] ??
     } else {
       Local<Object> obj = Object::New();
       obj->Set(String::New("updateCount"), Integer::New(baton->updateCount));
@@ -721,7 +718,8 @@ void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
             obj->Set(String::New(returnParam.c_str()), Number::New(output->floatVal));
             break;
           case OutParam::OCCICURSOR:
-            obj->Set(String::New(returnParam.c_str()), CreateV8ArrayFromRows(output->columns, output->rows));
+            obj->Set(String::New(returnParam.c_str()), CreateV8ArrayFromRows(baton, output->columns, output->rows));
+            if (baton->error) goto failed;
             break;
           case OutParam::OCCICLOB:
             {
@@ -771,7 +769,8 @@ void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
             {
               ostringstream oss;
               oss << "Unknown OutParam type: " << output->type;
-              throw NodeOracleException(oss.str());
+              baton->error = new std::string(oss.str());
+              goto failed;
             }
         }
       }
@@ -794,11 +793,11 @@ Handle<Value> Connection::ExecuteSync(const Arguments& args) {
 
   String::Utf8Value sqlVal(sql);
 
-  ExecuteBaton* baton;
-  try {
-    baton = new ExecuteBaton(connection, *sqlVal, &values, NULL);
-  } catch(NodeOracleException &ex) {
-    return ThrowException(Exception::Error(String::New(ex.getMessage().c_str())));
+  ExecuteBaton* baton = new ExecuteBaton(connection, *sqlVal, &values, NULL);
+  if (baton->error) {
+    Local<String> message = String::New(baton->error->c_str());
+    delete baton;
+    return scope.Close(ThrowException(Exception::Error(message)));
   }
 
   uv_work_t* req = new uv_work_t();

src/connection.h

@@ -10,7 +10,6 @@
 #include <occi.h>
 #include <oro.h>
 #include "utils.h"
-#include "nodeOracleException.h"
 #include "executeBaton.h"
 
 using namespace node;
@@ -44,11 +43,11 @@ class Connection : ObjectWrap {
   oracle::occi::Environment* getEnvironment() { return m_environment; }
 
 private:
-  static int SetValuesOnStatement(oracle::occi::Statement* stmt, std::vector<value_t*> &values);
-  static void CreateColumnsFromResultSet(oracle::occi::ResultSet* rs, std::vector<column_t*> &columns);
-  static row_t* CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs, std::vector<column_t*> &columns);
-  static Local<Array> CreateV8ArrayFromRows(std::vector<column_t*> columns, std::vector<row_t*>* rows);
-  static Local<Object> CreateV8ObjectFromRow(std::vector<column_t*> columns, row_t* currentRow);
+  static int SetValuesOnStatement(oracle::occi::Statement* stmt, ExecuteBaton* baton);
+  static void CreateColumnsFromResultSet(oracle::occi::ResultSet* rs, ExecuteBaton* baton, std::vector<column_t*> &columns);
+  static row_t* CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs, ExecuteBaton* baton, std::vector<column_t*> &columns);
+  static Local<Array> CreateV8ArrayFromRows(ExecuteBaton* baton, std::vector<column_t*> columns, std::vector<row_t*>* rows);
+  static Local<Object> CreateV8ObjectFromRow(ExecuteBaton* baton, std::vector<column_t*> columns, row_t* currentRow);
   static void handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]);
 
   oracle::occi::Connection* m_connection;

src/executeBaton.cpp

@@ -1,7 +1,6 @@
 
 #include "executeBaton.h"
 #include "outParam.h"
-#include "nodeOracleException.h"
 #include "connection.h"
 #include <iostream>
 using namespace std;
@@ -13,8 +12,8 @@ ExecuteBaton::ExecuteBaton(Connection* connection, const char* sql, v8::Local<v8
     this->callback = Persistent<Function>::New(*callback);
   }
   this->outputs = new std::vector<output_t*>();
-  CopyValuesToBaton(this, values);
   this->error = NULL;
+  CopyValuesToBaton(this, values);
 }
 
 ExecuteBaton::~ExecuteBaton() {
@@ -130,8 +129,9 @@ void ExecuteBaton::CopyValuesToBaton(ExecuteBaton* baton, v8::Local<v8::Array>*
     else {
         //XXX leaks new value on error
       std::ostringstream message;
-      message << "CopyValuesToBaton: Unhandled value type";
-      throw NodeOracleException(message.str());
+      message << "CopyValuesToBaton: Unhandled value type: " << (val->IsUndefined() ? "undefined" : "unknown");
+      baton->error = new std::string(message.str());
+      return;
     }
 
   }

src/nodeOracleException.h

@@ -3,7 +3,6 @@
 #define _nodeOracleException_h_
 
 #include <string>
-
 class NodeOracleException {
 public:
   NodeOracleException(std::string message) : m_message(message) {

src/outParam.cpp

@@ -1,6 +1,5 @@
 
 #include "outParam.h"
-#include "nodeOracleException.h"
 #include <iostream>
 using namespace std;
 
@@ -62,7 +61,7 @@ Handle<Value> OutParam::New(const Arguments& args) {
         break;
       }
       default:
-        throw NodeOracleException("Unhandled OutPram type!");
+        return scope.Close(ThrowException(Exception::Error(String::New("Unhandled OutPram type!"))));
       }
     }
   }