Enhance pool.release() to drop connections known to be unusable

Christopher Jones · Christopher Jones · commit f579f8167b83 · 2015-09-02T22:40:46.000+10:00
diff --git a/src/dpi/include/dpiConn.h b/src/dpi/include/dpiConn.h
@@ -64,6 +64,7 @@ class Conn
   virtual void stmtCacheSize(unsigned int stmtCacheSize) = 0;
   virtual unsigned int stmtCacheSize() const = 0;
   virtual int getByteExpansionRatio () = 0;
+  virtual void setErrState ( int errNum ) = 0;
 
   virtual void lobPrefetchSize(unsigned int lobPrefetchSize) = 0;
   virtual unsigned int lobPrefetchSize() const = 0;
diff --git a/src/dpi/src/dpiConnImpl.cpp b/src/dpi/src/dpiConnImpl.cpp
@@ -48,6 +48,14 @@
 
 #include <iostream>
 
+// Error numbers to set the drop_sess flag in sessionRelease()
+#define DPI_CONNERR_INVALID_SESS                  22
+#define DPI_CONNERR_SESS_KILLED                   28
+#define DPI_CONNERR_SESS_MARKED_KILL              31
+#define DPI_CONNERR_SESS_TERM_NO_REPLY            45
+#define DPI_CONNERR_ORA_NOT_LOGGED_ON             1012
+#define DPI_CONNERR_MAX_IDLE_TIMEOUT              2396
+
 using namespace std;
 
 
@@ -80,7 +88,7 @@ ConnImpl::ConnImpl(EnvImpl *env, OCIEnv *envh, bool externalAuth,
 
 try :  env_(env), pool_(NULL),
        envh_(envh), errh_(NULL), auth_(NULL), svch_(NULL), sessh_(NULL),
-       hasTxn_(false)
+       hasTxn_(false), srvh_(NULL), dropConn_(false)
 {
 
   this->initConnImpl ( false, externalAuth, connClass,
@@ -122,7 +130,7 @@ ConnImpl::ConnImpl(PoolImpl *pool, OCIEnv *envh, bool externalAuth,
 
 try :  env_(NULL), pool_(pool),
        envh_(envh), errh_(NULL), auth_(NULL),
-       svch_(NULL), sessh_(NULL), hasTxn_(false)
+       svch_(NULL), sessh_(NULL), hasTxn_(false), srvh_(NULL), dropConn_(false)
 {
   this->initConnImpl ( true, externalAuth, connClass, poolName, poolNameLen,
                        "", "" );
@@ -473,6 +481,46 @@ void ConnImpl::breakExecution()
   }
 }
 
+/*****************************************************************************/
+/*
+  DESCRIPTION
+    set the flag if the non-recoverable error happens to connection
+
+  PARAMETERS
+    errNum  - Error number
+
+  RETURNS:
+    -NONE_
+*/
+void ConnImpl::setErrState ( int errNum )
+{
+  /*
+   * This flag applicable for only Pool, non pooled connection anyway gets
+   * terminated upon release. This code is NOT thread-safe. But, we are only
+   * setting the flag to TRUE - multiple threads can try and only will update
+   * to TRUE only, so it is okay setting this flag.
+   */
+
+  if ( pool_ )
+  {
+    switch ( errNum )
+    {
+      // Error numbers to set drop_sess flag
+      case DPI_CONNERR_INVALID_SESS:
+      case DPI_CONNERR_SESS_KILLED:
+      case DPI_CONNERR_SESS_MARKED_KILL:
+      case DPI_CONNERR_SESS_TERM_NO_REPLY:
+      case DPI_CONNERR_ORA_NOT_LOGGED_ON:
+      case DPI_CONNERR_MAX_IDLE_TIMEOUT:
+        dropConn_ = true;
+        break;
+
+      default:
+        break;
+    }
+  }
+}
+
 
 /*---------------------------------------------------------------------------
                           PRIVATE METHODS
@@ -499,7 +547,6 @@ void ConnImpl::initConnImpl ( bool pool, bool externalAuth,
                    const string& connClass, OraText *poolNmRconnStr,
                    ub4 nameLen, const string &user, const string &password )
 {
-  OCIServer *srvh = NULL;
   ub4 mode        = OCI_DEFAULT;
   ub2 csid        = 0;
 
@@ -551,14 +598,15 @@ void ConnImpl::initConnImpl ( bool pool, bool externalAuth,
                          OCI_ATTR_SESSION, errh_ ), errh_ );
 
   // Initialize the server handle from service handle
-  ociCall ( OCIAttrGet ( svch_, OCI_HTYPE_SVCCTX, ( void * ) &srvh, 0,
+  ociCall ( OCIAttrGet ( svch_, OCI_HTYPE_SVCCTX, ( void * ) &srvh_, 0,
                         ( ub4 ) OCI_ATTR_SERVER, errh_ ), errh_ );
 
   // Get the DBCHARSET from server
-  ociCall ( OCIAttrGet ( srvh, ( ub4 ) OCI_HTYPE_SERVER, ( void * ) &csid,
+  ociCall ( OCIAttrGet ( srvh_, ( ub4 ) OCI_HTYPE_SERVER, ( void * ) &csid,
                          ( ub4 * ) 0, ( ub4 ) OCI_ATTR_CHARSET_ID, errh_ ),
                           errh_ );
-    csratio_ = getCsRatio ( csid );
+
+  csratio_ = getCsRatio ( csid );
 }
 
 /*****************************************************************************/
@@ -579,9 +627,25 @@ void ConnImpl::initConnImpl ( bool pool, bool externalAuth,
 
 void ConnImpl::cleanup()
 {
+  ub4 relMode      = OCI_DEFAULT;
+  ub4 serverStatus = OCI_SERVER_NORMAL;
+
   if (svch_)
   {
-    OCISessionRelease(svch_, errh_, NULL, 0, OCI_DEFAULT);
+    if ( pool_ )
+    {
+      // Get the connection status
+      if ( !dropConn_ )
+        ociCall ( OCIAttrGet ( ( void * ) srvh_, OCI_HTYPE_SERVER,
+                               ( void * ) &serverStatus, ( ub4 * ) 0,
+                               OCI_ATTR_SERVER_STATUS, errh_ ), errh_ );
+
+      // Remove the session from pool in case of unusable
+      if ( dropConn_ || ( serverStatus != OCI_SERVER_NORMAL ) )
+        relMode |= OCI_SESSRLS_DROPSESS;
+    }
+
+    OCISessionRelease(svch_, errh_, NULL, 0, relMode);
     svch_ = NULL;
   }
 
diff --git a/src/dpi/src/dpiConnImpl.h b/src/dpi/src/dpiConnImpl.h
@@ -115,6 +115,8 @@ class ConnImpl : public Conn
 
   virtual DpiHandle *getErrh (){return (DpiHandle *)errh_;};
 
+  virtual void setErrState ( int errNum );
+
   #if OCI_MAJOR_VERSION < 12
     inline void hasTxn(boolean connHasTxn)
     {
@@ -133,6 +135,7 @@ class ConnImpl : public Conn
   void initConnImpl( bool pool, bool externalAuth, const string& connClass,
                      OraText *poolNmRconnStr, ub4 nameLen,
                      const string &user, const string &password );
+
   int getCsRatio ( ub2 csid )
   {
     return ( csid == DPI_AL32UTF8 ) ? DPI_BESTCASE_CHAR_CONVERSION_RATIO :
@@ -152,6 +155,8 @@ class ConnImpl : public Conn
   OCISession  *sessh_;          // OCI Session handle. Do not free this.
   boolean     hasTxn_;          // set if transaction is in progress
   int         csratio_;         // character expansion ratio
+  OCIServer   *srvh_;           // OCI server handle
+  bool        dropConn_;        // Set flag in case of unusable connection
 };
 
 
diff --git a/src/dpi/src/dpiUtils.h b/src/dpi/src/dpiUtils.h
@@ -50,10 +50,4 @@ void ociCall(sword rc, OCIError *errh);
 
 void ociCallEnv(sword rc, OCIEnv *envh);
 
-void getDriverName ( char *name, unsigned int namelen );
-
-
-
-
-
 #endif                                              /* DPIUTILS_ORACLE */
diff --git a/src/njs/src/njsConnection.cpp b/src/njs/src/njsConnection.cpp
@@ -205,6 +205,7 @@ NAN_PROPERTY_GETTER(Connection::GetStmtCacheSize)
   }
   catch(dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), njsConn->dpiconn_ );
     NJS_SET_EXCEPTION(e.what(), strlen(e.what()));
     NanReturnUndefined();
   }
@@ -968,6 +969,7 @@ void Connection::Async_Execute (uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), executeBaton->dpiconn );
     // In Case of DML Returning, if the buffer is small, and if the callback
     // is called multiple times, an ORA error 24343 was reported. Converting
     // that error to errInsufficientBufferForBinds.
@@ -2410,6 +2412,7 @@ void Connection::Async_Release(uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), releaseBaton->dpiconn );
     releaseBaton->error = std::string(e.what());
   }
   exitAsyncRelease:
@@ -2504,6 +2507,7 @@ void Connection::Async_Commit (uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), commitBaton->dpiconn );
     commitBaton->error = std::string(e.what());
   }
   exitAsyncCommit:
@@ -2596,6 +2600,7 @@ void Connection::Async_Rollback (uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), rollbackBaton->dpiconn );
     rollbackBaton->error = std::string(e.what());
   }
   exitAsyncRollback:
@@ -2691,6 +2696,7 @@ void Connection::Async_Break(uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS (  e.errnum(), breakBaton->dpiconn );
     breakBaton->error = std::string(e.what());
   }
   exitAsyncBreak:
diff --git a/src/njs/src/njsIntLob.cpp b/src/njs/src/njsIntLob.cpp
@@ -87,7 +87,7 @@ Persistent<FunctionTemplate> ILob::iLobTemplate_s;
  */
 
 ILob::ILob():
-  lobLocator_(NULL), svch_(NULL), errh_(NULL),
+  lobLocator_(NULL), dpiconn_(NULL), svch_(NULL), errh_(NULL),
   isValid_(false), state_(INACTIVE), buf_(NULL), bufSize_(0), chunkSize_(0),
   length_(0), offset_(1), amountRead_(0)
 {
@@ -205,6 +205,7 @@ void ILob::setILob(eBaton *executeBaton, ProtoILob *protoILob)
 
     fetchType_ = protoILob->fetchType_;
   
+    dpiconn_ = executeBaton->dpiconn;
     svch_ = executeBaton->dpiconn->getSvch();
 
     errh_ = protoILob->errh_;
@@ -227,6 +228,7 @@ void ILob::setILob(eBaton *executeBaton, ProtoILob *protoILob)
 
   catch (dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), executeBaton->dpiconn );
     executeBaton->error = std::string(e.what());
     cleanup();
   }
@@ -408,6 +410,7 @@ NAN_PROPERTY_GETTER(ILob::GetChunkSize)
 
   catch(dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
     NJS_SET_EXCEPTION(e.what(), strlen(e.what()));
     NanReturnUndefined();
   }
@@ -471,6 +474,7 @@ NAN_PROPERTY_GETTER(ILob::GetLength)
 
   catch(dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
     NJS_SET_EXCEPTION(e.what(), strlen(e.what()));
     NanReturnUndefined();
   }
@@ -532,6 +536,7 @@ NAN_PROPERTY_GETTER(ILob::GetPieceSize)
 
   catch(dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
     NJS_SET_EXCEPTION(e.what(), strlen(e.what()));
     NanReturnUndefined();
   }
@@ -610,6 +615,7 @@ NAN_PROPERTY_GETTER(ILob::GetOffset)
 
   catch(dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
     NJS_SET_EXCEPTION(e.what(), strlen(e.what()));
     NanReturnUndefined();
   }
@@ -732,13 +738,13 @@ NAN_METHOD(ILob::Read)
 void ILob::Async_Read(uv_work_t *req)
 {
   LobBaton *lobBaton = (LobBaton *)req->data;
+  ILob *iLob         = lobBaton->iLob;
 
   if(!(lobBaton->error).empty())
     goto exitAsyncRead;
 
   try
   {
-    ILob         *iLob = lobBaton->iLob;
     unsigned long long byteAmount = (unsigned long int)iLob->bufSize_;
     unsigned long long charAmount = 0; 
     
@@ -759,10 +765,10 @@ void ILob::Async_Read(uv_work_t *req)
     else
       iLob->offset_ += byteAmount;
   }
-
   catch (dpi::Exception& e)
   {
-      lobBaton->error = std::string(e.what());
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
+    lobBaton->error = std::string(e.what());
   }
 
  exitAsyncRead:
@@ -917,13 +923,13 @@ NAN_METHOD(ILob::Write)
 void ILob::Async_Write(uv_work_t *req)
 {
   LobBaton *lobBaton = (LobBaton *)req->data;
+  ILob         *iLob = lobBaton->iLob;
 
   if(!(lobBaton->error).empty())
     goto exitAsyncWrite;
 
   try
   {
-    ILob         *iLob = lobBaton->iLob;
     unsigned long long byteAmount = lobBaton->writelen;
     unsigned long long charAmount = 0; // interested in byte amount only
     
@@ -938,10 +944,10 @@ void ILob::Async_Write(uv_work_t *req)
     else
       iLob->offset_ += byteAmount;
   }
-
   catch (dpi::Exception& e)
   {
-      lobBaton->error = std::string(e.what());
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );
+    lobBaton->error = std::string(e.what());
   }
 
  exitAsyncWrite:
@@ -1021,9 +1027,9 @@ try : lobLocator_(lobLocator), fetchType_(fetchType), errh_(NULL),
                               errh_, lobLocator_);
   length_ = Lob::length(executeBaton->dpiconn->getSvch(), errh_, lobLocator_);
 }
-
 catch (dpi::Exception &e)
 {
+  NJS_SET_CONN_ERR_STATUS ( e.errnum(), executeBaton->dpiconn );
   executeBaton->error = std::string(e.what());
   cleanup();
 }
diff --git a/src/njs/src/njsIntLob.h b/src/njs/src/njsIntLob.h
@@ -198,6 +198,7 @@ class ILob : public ObjectWrap
   Descriptor    *lobLocator_;
   unsigned short fetchType_;
   
+  dpi::Conn     *dpiconn_;
   DpiHandle     *svch_;
   DpiHandle     *errh_;
   bool           isValid_;
diff --git a/src/njs/src/njsOracle.cpp b/src/njs/src/njsOracle.cpp
@@ -712,6 +712,7 @@ void Oracledb::Async_GetConnection (uv_work_t *req)
   }
   catch (dpi::Exception& e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), NULL );
     connBaton->error = std::string(e.what());
   }
   exitAsync_GetConnection:
@@ -859,6 +860,7 @@ void Oracledb::Async_CreatePool (uv_work_t *req)
   }
   catch (dpi::Exception &e)
   {
+    NJS_SET_CONN_ERR_STATUS ( e.errnum(), NULL );
     poolBaton->error = std::string (e.what() );
   }
   exitAsyncCreatePool:
diff --git a/src/njs/src/njsPool.cpp b/src/njs/src/njsPool.cpp
diff --git a/src/njs/src/njsResultSet.cpp b/src/njs/src/njsResultSet.cpp
diff --git a/src/njs/src/njsUtils.h b/src/njs/src/njsUtils.h

Original file line number	Diff line number	Diff line change
`@@ -205,6 +205,7 @@ NAN_PROPERTY_GETTER(Connection::GetStmtCacheSize)`
`205`	`205`	`}`
`206`	`206`	`catch(dpi::Exception &e)`
`207`	`207`	`{`
	`208`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), njsConn->dpiconn_ );`
`208`	`209`	`NJS_SET_EXCEPTION(e.what(), strlen(e.what()));`
`209`	`210`	`NanReturnUndefined();`
`210`	`211`	`}`
`@@ -968,6 +969,7 @@ void Connection::Async_Execute (uv_work_t *req)`
`968`	`969`	`}`
`969`	`970`	`catch (dpi::Exception& e)`
`970`	`971`	`{`
	`972`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), executeBaton->dpiconn );`
`971`	`973`	`// In Case of DML Returning, if the buffer is small, and if the callback`
`972`	`974`	`// is called multiple times, an ORA error 24343 was reported. Converting`
`973`	`975`	`// that error to errInsufficientBufferForBinds.`
`@@ -2410,6 +2412,7 @@ void Connection::Async_Release(uv_work_t *req)`
`2410`	`2412`	`}`
`2411`	`2413`	`catch (dpi::Exception& e)`
`2412`	`2414`	`{`
	`2415`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), releaseBaton->dpiconn );`
`2413`	`2416`	`releaseBaton->error = std::string(e.what());`
`2414`	`2417`	`}`
`2415`	`2418`	`exitAsyncRelease:`
`@@ -2504,6 +2507,7 @@ void Connection::Async_Commit (uv_work_t *req)`
`2504`	`2507`	`}`
`2505`	`2508`	`catch (dpi::Exception& e)`
`2506`	`2509`	`{`
	`2510`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), commitBaton->dpiconn );`
`2507`	`2511`	`commitBaton->error = std::string(e.what());`
`2508`	`2512`	`}`
`2509`	`2513`	`exitAsyncCommit:`
`@@ -2596,6 +2600,7 @@ void Connection::Async_Rollback (uv_work_t *req)`
`2596`	`2600`	`}`
`2597`	`2601`	`catch (dpi::Exception& e)`
`2598`	`2602`	`{`
	`2603`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), rollbackBaton->dpiconn );`
`2599`	`2604`	`rollbackBaton->error = std::string(e.what());`
`2600`	`2605`	`}`
`2601`	`2606`	`exitAsyncRollback:`
`@@ -2691,6 +2696,7 @@ void Connection::Async_Break(uv_work_t *req)`
`2691`	`2696`	`}`
`2692`	`2697`	`catch (dpi::Exception& e)`
`2693`	`2698`	`{`
	`2699`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), breakBaton->dpiconn );`
`2694`	`2700`	`breakBaton->error = std::string(e.what());`
`2695`	`2701`	`}`
`2696`	`2702`	`exitAsyncBreak:`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ Persistent<FunctionTemplate> ILob::iLobTemplate_s;`
`87`	`87`	`*/`
`88`	`88`
`89`	`89`	`ILob::ILob():`
`90`		`- lobLocator_(NULL), svch_(NULL), errh_(NULL),`
	`90`	`+ lobLocator_(NULL), dpiconn_(NULL), svch_(NULL), errh_(NULL),`
`91`	`91`	`isValid_(false), state_(INACTIVE), buf_(NULL), bufSize_(0), chunkSize_(0),`
`92`	`92`	`length_(0), offset_(1), amountRead_(0)`
`93`	`93`	`{`
`@@ -205,6 +205,7 @@ void ILob::setILob(eBaton executeBaton, ProtoILob protoILob)`
`205`	`205`
`206`	`206`	`fetchType_ = protoILob->fetchType_;`
`207`	`207`
	`208`	`+ dpiconn_ = executeBaton->dpiconn;`
`208`	`209`	`svch_ = executeBaton->dpiconn->getSvch();`
`209`	`210`
`210`	`211`	`errh_ = protoILob->errh_;`
`@@ -227,6 +228,7 @@ void ILob::setILob(eBaton executeBaton, ProtoILob protoILob)`
`227`	`228`
`228`	`229`	`catch (dpi::Exception &e)`
`229`	`230`	`{`
	`231`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), executeBaton->dpiconn );`
`230`	`232`	`executeBaton->error = std::string(e.what());`
`231`	`233`	`cleanup();`
`232`	`234`	`}`
`@@ -408,6 +410,7 @@ NAN_PROPERTY_GETTER(ILob::GetChunkSize)`
`408`	`410`
`409`	`411`	`catch(dpi::Exception &e)`
`410`	`412`	`{`
	`413`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
`411`	`414`	`NJS_SET_EXCEPTION(e.what(), strlen(e.what()));`
`412`	`415`	`NanReturnUndefined();`
`413`	`416`	`}`
`@@ -471,6 +474,7 @@ NAN_PROPERTY_GETTER(ILob::GetLength)`
`471`	`474`
`472`	`475`	`catch(dpi::Exception &e)`
`473`	`476`	`{`
	`477`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
`474`	`478`	`NJS_SET_EXCEPTION(e.what(), strlen(e.what()));`
`475`	`479`	`NanReturnUndefined();`
`476`	`480`	`}`
`@@ -532,6 +536,7 @@ NAN_PROPERTY_GETTER(ILob::GetPieceSize)`
`532`	`536`
`533`	`537`	`catch(dpi::Exception &e)`
`534`	`538`	`{`
	`539`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
`535`	`540`	`NJS_SET_EXCEPTION(e.what(), strlen(e.what()));`
`536`	`541`	`NanReturnUndefined();`
`537`	`542`	`}`
`@@ -610,6 +615,7 @@ NAN_PROPERTY_GETTER(ILob::GetOffset)`
`610`	`615`
`611`	`616`	`catch(dpi::Exception &e)`
`612`	`617`	`{`
	`618`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
`613`	`619`	`NJS_SET_EXCEPTION(e.what(), strlen(e.what()));`
`614`	`620`	`NanReturnUndefined();`
`615`	`621`	`}`
`@@ -732,13 +738,13 @@ NAN_METHOD(ILob::Read)`
`732`	`738`	`void ILob::Async_Read(uv_work_t *req)`
`733`	`739`	`{`
`734`	`740`	`LobBaton lobBaton = (LobBaton )req->data;`
	`741`	`+ ILob *iLob = lobBaton->iLob;`
`735`	`742`
`736`	`743`	`if(!(lobBaton->error).empty())`
`737`	`744`	`goto exitAsyncRead;`
`738`	`745`
`739`	`746`	`try`
`740`	`747`	`{`
`741`		`- ILob *iLob = lobBaton->iLob;`
`742`	`748`	`unsigned long long byteAmount = (unsigned long int)iLob->bufSize_;`
`743`	`749`	`unsigned long long charAmount = 0;`
`744`	`750`
`@@ -759,10 +765,10 @@ void ILob::Async_Read(uv_work_t *req)`
`759`	`765`	`else`
`760`	`766`	`iLob->offset_ += byteAmount;`
`761`	`767`	`}`
`762`		`-`
`763`	`768`	`catch (dpi::Exception& e)`
`764`	`769`	`{`
`765`		`- lobBaton->error = std::string(e.what());`
	`770`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
	`771`	`+ lobBaton->error = std::string(e.what());`
`766`	`772`	`}`
`767`	`773`
`768`	`774`	`exitAsyncRead:`
`@@ -917,13 +923,13 @@ NAN_METHOD(ILob::Write)`
`917`	`923`	`void ILob::Async_Write(uv_work_t *req)`
`918`	`924`	`{`
`919`	`925`	`LobBaton lobBaton = (LobBaton )req->data;`
	`926`	`+ ILob *iLob = lobBaton->iLob;`
`920`	`927`
`921`	`928`	`if(!(lobBaton->error).empty())`
`922`	`929`	`goto exitAsyncWrite;`
`923`	`930`
`924`	`931`	`try`
`925`	`932`	`{`
`926`		`- ILob *iLob = lobBaton->iLob;`
`927`	`933`	`unsigned long long byteAmount = lobBaton->writelen;`
`928`	`934`	`unsigned long long charAmount = 0; // interested in byte amount only`
`929`	`935`
`@@ -938,10 +944,10 @@ void ILob::Async_Write(uv_work_t *req)`
`938`	`944`	`else`
`939`	`945`	`iLob->offset_ += byteAmount;`
`940`	`946`	`}`
`941`		`-`
`942`	`947`	`catch (dpi::Exception& e)`
`943`	`948`	`{`
`944`		`- lobBaton->error = std::string(e.what());`
	`949`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), iLob->dpiconn_ );`
	`950`	`+ lobBaton->error = std::string(e.what());`
`945`	`951`	`}`
`946`	`952`
`947`	`953`	`exitAsyncWrite:`
`@@ -1021,9 +1027,9 @@ try : lobLocator_(lobLocator), fetchType_(fetchType), errh_(NULL),`
`1021`	`1027`	`errh_, lobLocator_);`
`1022`	`1028`	`length_ = Lob::length(executeBaton->dpiconn->getSvch(), errh_, lobLocator_);`
`1023`	`1029`	`}`
`1024`		`-`
`1025`	`1030`	`catch (dpi::Exception &e)`
`1026`	`1031`	`{`
	`1032`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), executeBaton->dpiconn );`
`1027`	`1033`	`executeBaton->error = std::string(e.what());`
`1028`	`1034`	`cleanup();`
`1029`	`1035`	`}`
Original file line number	Diff line number	Diff line change
`@@ -712,6 +712,7 @@ void Oracledb::Async_GetConnection (uv_work_t *req)`
`712`	`712`	`}`
`713`	`713`	`catch (dpi::Exception& e)`
`714`	`714`	`{`
	`715`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), NULL );`
`715`	`716`	`connBaton->error = std::string(e.what());`
`716`	`717`	`}`
`717`	`718`	`exitAsync_GetConnection:`
`@@ -859,6 +860,7 @@ void Oracledb::Async_CreatePool (uv_work_t *req)`
`859`	`860`	`}`
`860`	`861`	`catch (dpi::Exception &e)`
`861`	`862`	`{`
	`863`	`+ NJS_SET_CONN_ERR_STATUS ( e.errnum(), NULL );`
`862`	`864`	`poolBaton->error = std::string (e.what() );`
`863`	`865`	`}`
`864`	`866`	`exitAsyncCreatePool:`