Added new optional connection options: charset, compress, initCommand, readTimeout, reconnect, sslVerifyServer, timeout, writeTimeout

Author: mariano

src/connection.cc

@@ -2,7 +2,13 @@
 #include "./connection.h"
 
 node_db_mysql::Connection::Connection()
-    : connection(NULL) {
+    : compress(false),
+      readTimeout(0),
+      reconnect(false),
+      sslVerifyServer(false),
+      timeout(0),
+      writeTimeout(0),
+      connection(NULL) {
     this->connection = new MYSQL();
     if (this->connection == NULL) {
         throw node_db::Exception("Cannot create MYSQL handle");
@@ -17,17 +23,67 @@ node_db_mysql::Connection::~Connection() {
     }
 }
 
-void node_db_mysql::Connection::setSocket(const std::string& socket) {
+void node_db_mysql::Connection::setCharset(const std::string& charset) throw() {
+    this->charset = charset;
+}
+
+void node_db_mysql::Connection::setCompress(const bool compress) throw() {
+    this->compress = compress;
+}
+
+void node_db_mysql::Connection::setReadTimeout(const uint32_t readTimeout) throw() {
+    this->readTimeout = readTimeout;
+}
+
+void node_db_mysql::Connection::setInitCommand(const std::string& initCommand) throw() {
+    this->initCommand = initCommand;
+}
+
+void node_db_mysql::Connection::setSocket(const std::string& socket) throw() {
     this->socket = socket;
 }
 
-std::string node_db_mysql::Connection::getSocket() const {
-    return this->socket;
+void node_db_mysql::Connection::setTimeout(const uint32_t timeout) throw() {
+    this->timeout = timeout;
+}
+
+void node_db_mysql::Connection::setWriteTimeout(const uint32_t writeTimeout) throw() {
+    this->writeTimeout = writeTimeout;
 }
 
 void node_db_mysql::Connection::open() throw(node_db::Exception&) {
     this->close();
 
+    if (!this->charset.empty()) {
+        mysql_options(this->connection, MYSQL_SET_CHARSET_NAME, this->charset.c_str());
+    }
+
+    if (this->compress) {
+        mysql_options(this->connection, MYSQL_OPT_COMPRESS, 0);
+    }
+
+    if (!this->initCommand.empty()) {
+        mysql_options(this->connection, MYSQL_INIT_COMMAND, this->initCommand.c_str());
+    }
+
+    if (this->readTimeout > 0) {
+        mysql_options(this->connection, MYSQL_OPT_READ_TIMEOUT, &this->readTimeout);
+    }
+
+#if MYSQL_VERSION_ID >= 50013
+    mysql_options(this->connection, MYSQL_OPT_RECONNECT, &this->reconnect);
+#endif
+
+    mysql_options(this->connection, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &this->sslVerifyServer);
+
+    if (this->timeout > 0) {
+        mysql_options(this->connection, MYSQL_OPT_CONNECT_TIMEOUT, &this->timeout);
+    }
+
+    if (this->writeTimeout > 0) {
+        mysql_options(this->connection, MYSQL_OPT_WRITE_TIMEOUT, &this->writeTimeout);
+    }
+
     this->opened = mysql_real_connect(
         this->connection,
         this->hostname.c_str(),
@@ -37,6 +93,12 @@ void node_db_mysql::Connection::open() throw(node_db::Exception&) {
         this->port,
         !this->socket.empty() ? this->socket.c_str() : NULL,
         0);
+
+#if MYSQL_VERSION_ID >= 50013 && MYSQL_VERSION_ID < 50019
+    // MySQL incorrectly resets the MYSQL_OPT_RECONNECT option to its default value before MySQL 5.0.19
+    mysql_options(this->connection, MYSQL_OPT_RECONNECT, &this->reconnect);
+#endif
+
     if (!this->opened) {
         throw node_db::Exception(mysql_error(this->connection));
     }

src/connection.h

@@ -12,16 +12,31 @@ class Connection : public node_db::Connection {
     public:
         Connection();
         ~Connection();
-        std::string getSocket() const;
-        void setSocket(const std::string& user);
+        void setCharset(const std::string& charset) throw();
+        void setCompress(const bool compress) throw();
+        void setInitCommand(const std::string& initCommand) throw();
+        void setReadTimeout(const uint32_t readTimeout) throw();
+        void setReconnect(const bool reconnect) throw();
+        void setSocket(const std::string& socket) throw();
+        void setSslVerifyServer(const bool sslVerifyServer) throw();
+        void setTimeout(const uint32_t timeout) throw();
+        void setWriteTimeout(const uint32_t writeTimeout) throw();
         void open() throw(node_db::Exception&);
         void close();
         std::string escape(const std::string& string) const throw(node_db::Exception&);
         std::string version() const;
         node_db::Result* query(const std::string& query) const throw(node_db::Exception&);
 
     protected:
+        std::string charset;
+        bool compress;
+        std::string initCommand;
+        uint32_t readTimeout;
+        bool reconnect;
         std::string socket;
+        bool sslVerifyServer;
+        uint32_t timeout;
+        uint32_t writeTimeout;
 
     private:
         MYSQL* connection;

src/mysql.cc

@@ -52,15 +52,58 @@ v8::Handle<v8::Value> node_db_mysql::Mysql::set(const v8::Arguments& args) {
     v8::Handle<v8::Value> result = node_db::Binding::set(args);
 
     v8::Local<v8::Object> options = args[0]->ToObject();
+
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_STRING(options, charset);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_BOOL(options, compress);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_STRING(options, initCommand);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_UINT32(options, readTimeout);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_BOOL(options, reconnect);
     ARG_CHECK_OBJECT_ATTR_OPTIONAL_STRING(options, socket);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_BOOL(options, sslVerifyServer);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_UINT32(options, timeout);
+    ARG_CHECK_OBJECT_ATTR_OPTIONAL_UINT32(options, writeTimeout);
 
     node_db_mysql::Connection* connection = static_cast<node_db_mysql::Connection*>(this->connection);
 
+    if (options->Has(charset_key)) {
+        v8::String::Utf8Value charset(options->Get(charset_key)->ToString());
+        connection->setCharset(*charset);
+    }
+
+    if (options->Has(compress_key)) {
+        connection->setCompress(options->Get(compress_key)->IsTrue());
+    }
+
+    if (options->Has(initCommand_key)) {
+        v8::String::Utf8Value initCommand(options->Get(initCommand_key)->ToString());
+        connection->setInitCommand(*initCommand);
+    }
+
+    if (options->Has(readTimeout_key)) {
+        connection->setReadTimeout(options->Get(readTimeout_key)->ToInt32()->Value());
+    }
+
+    if (options->Has(reconnect_key)) {
+        connection->setReconnect(options->Get(reconnect_key)->IsTrue());
+    }
+
     if (options->Has(socket_key)) {
         v8::String::Utf8Value socket(options->Get(socket_key)->ToString());
         connection->setSocket(*socket);
     }
 
+    if (options->Has(sslVerifyServer_key)) {
+        connection->setSslVerifyServer(options->Get(sslVerifyServer_key)->IsTrue());
+    }
+
+    if (options->Has(timeout_key)) {
+        connection->setTimeout(options->Get(timeout_key)->ToInt32()->Value());
+    }
+
+    if (options->Has(writeTimeout_key)) {
+        connection->setWriteTimeout(options->Get(writeTimeout_key)->ToInt32()->Value());
+    }
+
     return result;
 }