Various changes to the modules.

Also commited the remaining incomplete modules.

modules/mysql/Account.cpp

@@ -0,0 +1,122 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+Account::Account(CSStr host, CSStr user, CSStr pass, CSStr schema, Uint16 port, CSStr socket)
+    : m_Host(host ? host : _SC(""))
+    , m_User(user ? user : _SC(""))
+    , m_Pass(pass ? pass : _SC(""))
+    , m_Port(port)
+    , m_Schema(schema ? schema : _SC(""))
+    , m_Socket(socket ? socket : _SC(""))
+    , m_SSL_Key()
+    , m_SSL_Cert()
+    , m_SSL_CA()
+    , m_SSL_CA_Path()
+    , m_SSL_Cipher()
+    , m_Autocommit()
+    , m_Options()
+{
+    // Attempt to extract the port number from the host
+    String::size_type pos = m_Host.find(':');
+    // Was it specified in the host
+    if (pos != String::npos)
+    {
+        try
+        {
+            // Attempt to extract the numeric value
+            ULong num = std::stol(m_Host.substr(pos + 1));
+            // Is the port number withing range?
+            if (num > 0xFFFF)
+            {
+                SHROWF("Port number out of range: %lu");
+            }
+            // Assign the extracted port number
+            m_Port = static_cast< Uint16 >(num);
+            // Remove everything after the port number
+            m_Host = m_Host.substr(0, pos);
+        }
+        catch (const std::exception & e)
+        {
+            SHROWF("Cannot extract the port number [%s]", e.what());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void Account::SetSSL(CSStr key, CSStr cert, CSStr ca, CSStr ca_path, CSStr cipher)
+{
+    if (!key || *key == '\0')
+    {
+        m_SSL_Key.clear();
+        m_SSL_Cert.clear();
+        m_SSL_CA.clear();
+        m_SSL_CA_Path.clear();
+        m_SSL_Cipher.clear();
+    }
+    else
+    {
+        m_SSL_Key.assign(key ? key : _SC(""));
+        m_SSL_Cert.assign(cert ? cert : _SC(""));
+        m_SSL_CA.assign(ca ? ca : _SC(""));
+        m_SSL_CA_Path.assign(ca_path ? ca_path : _SC(""));
+        m_SSL_Cipher.assign(cipher ? cipher : _SC(""));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+Table Account::GetOptions() const
+{
+    // Allocate an empty table
+    Table tbl(DefaultVM::Get());
+    // Insert every option into the table
+    for (const auto & opt : m_Options)
+    {
+        tbl.SetValue(opt.first.c_str(), opt.second);
+    }
+    // Return the resulted table
+    return tbl;
+}
+
+// ------------------------------------------------------------------------------------------------
+const String & Account::GetOption(CSStr name) const
+{
+    // Make sure the specified name is valid
+    if (!name || *name == '\0')
+    {
+        SHROWF("Invalid or empty option name");
+    }
+    // Attempt to find the requested option
+    const Options::const_iterator itr = m_Options.find(name);
+    // Return the result
+    return (itr == m_Options.cend()) ? s_String : itr->second;
+}
+
+// ------------------------------------------------------------------------------------------------
+void Account::SetOption(CSStr name, CSStr value)
+{
+    // Make sure the specified name is valid
+    if (!name || *name == '\0')
+    {
+        SHROWF("Invalid or empty option name");
+    }
+    // Assign the specified value
+    m_Options[name] = value ? value : _SC("");
+}
+
+// ------------------------------------------------------------------------------------------------
+void Account::RemoveOption(CSStr name) const
+{
+    // Make sure the specified name is valid
+    if (!name || *name == '\0')
+    {
+        SHROWF("Invalid or empty option name");
+    }
+    // Erase the specified value
+    m_Options.erase(name);
+}
+
+} // Namespace:: SqMod

modules/mysql/Account.hpp

@@ -0,0 +1,272 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Helper class containing shared connection information to avoid repetition.
+*/
+class Account
+{
+public:
+
+    // --------------------------------------------------------------------------------------------
+    typedef std::unordered_map< String, String > Options;
+
+    /* --------------------------------------------------------------------------------------------
+     * Base Constructor.
+    */
+    Account(CSStr host, CSStr user)
+        : Account(host, user, _SC(""), _SC(""), 3306, _SC(""))
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base Constructor.
+    */
+    Account(CSStr host, CSStr user, CSStr pass)
+        : Account(host, user, pass, _SC(""), 3306, _SC(""))
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base Constructor.
+    */
+    Account(CSStr host, CSStr user, CSStr pass, CSStr schema)
+        : Account(host, user, pass, schema, 3306, _SC(""))
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base Constructor.
+    */
+    Account(CSStr host, CSStr user, CSStr pass, CSStr schema, Uint16 port)
+        : Account(host, user, pass, schema, 3306, _SC(""))
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base Constructor.
+    */
+    Account(CSStr host, CSStr user, CSStr pass, CSStr schema, Uint16 port, CSStr socket);
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    Account(const Account & o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor (disabled).
+    */
+    Account(Account && o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~Account() = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    Account & operator = (const Account & o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator (disabled).
+    */
+    Account & operator = (Account && o) = default;
+
+private:
+
+    // --------------------------------------------------------------------------------------------
+    String      m_Host; // Host address.
+    String      m_User; // User name.
+    String      m_Pass; // User password.
+    Uint16      m_Port; // Server port.
+
+    // --------------------------------------------------------------------------------------------
+    String      m_Schema; // Server schema.
+    String      m_Socket; // Unix socket.
+
+    // --------------------------------------------------------------------------------------------
+    String      m_SSL_Key; // SSL key.
+    String      m_SSL_Cert; // SSL certificate.
+    String      m_SSL_CA; // SSL certificate authority.
+    String      m_SSL_CA_Path; // SSL certificate authority path.
+    String      m_SSL_Cipher; // SSL Cipher.
+
+    // --------------------------------------------------------------------------------------------
+    bool        m_Autocommit; // Toggle autocommit.
+
+    // --------------------------------------------------------------------------------------------
+    Options     m_Options; // Option container.
+
+    // --------------------------------------------------------------------------------------------
+    static const String s_String; // Dummy used to return a reference to a null string.
+
+public:
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the host address specified during creation.
+    */
+    const String & GetHost() const
+    {
+        return m_Host;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the user name specified during creation.
+    */
+    const String & GetUser() const
+    {
+        return m_User;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the password specified during creation.
+    */
+    const String & GetPass() const
+    {
+        return m_Pass;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the server port specified during creation.
+    */
+    const Uint16 GetPort() const
+    {
+        return m_Port;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the server schema.
+    */
+    const String & GetSchema() const
+    {
+        return m_Schema;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set the server schema.
+    */
+    const String & GetSocket() const
+    {
+        return m_Socket;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the SSL key.
+    */
+    const String & GetSSL_Key() const
+    {
+        return m_SSL_Key;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the SSL certificate.
+    */
+    const String & GetSSL_Cert() const
+    {
+        return m_SSL_Cipher;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the SSL certificate authority.
+    */
+    const String & GetSSL_CA() const
+    {
+        return m_SSL_CA;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the SSL certificate authority path.
+    */
+    const String & GetSSL_CA_Path() const
+    {
+        return m_SSL_CA_Path;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the SSL cipher.
+    */
+    const String & GetSSL_Cipher() const
+    {
+        return m_SSL_Cipher;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set the SSL information.
+    */
+    void SetSSL(CSStr key, CSStr cert, CSStr ca, CSStr ca_path, CSStr cipher);
+
+    /* --------------------------------------------------------------------------------------------
+     * See whether autocommit is enabled or not.
+    */
+    bool GetAutocommit() const
+    {
+        return m_Autocommit;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set whether autocommit should be enabled or not.
+    */
+    void SetAutocommit(bool toggle)
+    {
+        m_Autocommit = toggle;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the entire options container.
+    */
+    Table GetOptions() const;
+
+    /* --------------------------------------------------------------------------------------------
+     * Get a value from the options container.
+    */
+    const String & GetOption(CSStr name) const;
+
+    /* --------------------------------------------------------------------------------------------
+     * Set a value in the options container.
+    */
+    void SetOption(CSStr name, CSStr value);
+
+    /* --------------------------------------------------------------------------------------------
+     * Remove a value from the options container.
+    */
+    void RemoveOption(CSStr name) const;
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the number of values in the options container.
+    */
+    Uint32 OptionsCount() const
+    {
+        return static_cast< Uint32 >(m_Options.size());
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * See whether the options container is empty or not.
+    */
+    bool OptionsEmpty() const
+    {
+        return m_Options.empty();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Remove all the options from the options container.
+    */
+    void OptionsClear()
+    {
+        m_Options.clear();
+    }
+};
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Bind.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Bind.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Column.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Column.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Common.cpp

@@ -0,0 +1,73 @@
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+#include "Module.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <stdlib.h>
+#include <stdarg.h>
+
+// ------------------------------------------------------------------------------------------------
+#include <sqrat.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+static SQChar g_Buffer[4096]; // Common buffer to reduce memory allocations.
+
+// ------------------------------------------------------------------------------------------------
+SStr GetTempBuff()
+{
+    return g_Buffer;
+}
+
+// ------------------------------------------------------------------------------------------------
+Uint32 GetTempBuffSize()
+{
+    return sizeof(g_Buffer);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SqThrowF(CSStr str, ...)
+{
+    // Initialize the argument list
+    va_list args;
+    va_start (args, str);
+    // Write the requested contents
+    if (snprintf(g_Buffer, sizeof(g_Buffer), str, args) < 0)
+        strcpy(g_Buffer, "Unknown error has occurred");
+    // Release the argument list
+    va_end(args);
+    // Throw the exception with the resulted message
+    throw Sqrat::Exception(g_Buffer);
+}
+
+// ------------------------------------------------------------------------------------------------
+CSStr FmtStr(CSStr str, ...)
+{
+    // Initialize the argument list
+    va_list args;
+    va_start (args, str);
+    // Write the requested contents
+    if (snprintf(g_Buffer, sizeof(g_Buffer), str, args) < 0)
+        g_Buffer[0] = 0; /* make sure the string is terminated */
+    // Release the argument list
+    va_end(args);
+    // Return the data from the buffer
+    return g_Buffer;
+}
+
+// ------------------------------------------------------------------------------------------------
+StackGuard::StackGuard(HSQUIRRELVM vm)
+    : m_Top(sq_gettop(vm)), m_VM(vm)
+{
+    /* ... */
+}
+
+// ------------------------------------------------------------------------------------------------
+StackGuard::~StackGuard()
+{
+    sq_pop(m_VM, sq_gettop(m_VM) - m_Top);
+}
+
+} // Namespace:: SqMod

modules/mysql/Common.hpp

@@ -0,0 +1,153 @@
+#ifndef _SQMYSQL_COMMON_HPP_
+#define _SQMYSQL_COMMON_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "ModBase.hpp"
+
+/* ------------------------------------------------------------------------------------------------
+ * Forward declaration of various MySQL types to avoid including the header where not necessary.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_stmt MYSQL_STMT;
+typedef struct st_mysql_bind MYSQL_BIND;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * SOFTWARE INFORMATION
+*/
+#define SQMYSQL_NAME "Squirrel MySQL Module"
+#define SQMYSQL_AUTHOR "Sandu Liviu Catalin (S.L.C)"
+#define SQMYSQL_COPYRIGHT "Copyright (C) 2016 Sandu Liviu Catalin"
+#define SQMYSQL_HOST_NAME "SqModMySQLHost"
+#define SQMYSQL_VERSION 001
+#define SQMYSQL_VERSION_STR "0.0.1"
+#define SQMYSQL_VERSION_MAJOR 0
+#define SQMYSQL_VERSION_MINOR 0
+#define SQMYSQL_VERSION_PATCH 1
+
+/* ------------------------------------------------------------------------------------------------
+ * Retrieve the temporary buffer.
+*/
+SStr GetTempBuff();
+
+/* ------------------------------------------------------------------------------------------------
+ * Retrieve the size of the temporary buffer.
+*/
+Uint32 GetTempBuffSize();
+
+/* ------------------------------------------------------------------------------------------------
+ * Throw a formatted exception.
+*/
+void SqThrowF(CSStr str, ...);
+
+/* ------------------------------------------------------------------------------------------------
+ * Generate a formatted string.
+*/
+CSStr FmtStr(CSStr str, ...);
+
+/* ------------------------------------------------------------------------------------------------
+ * Implements RAII to restore the VM stack to it's initial size on function exit.
+*/
+struct StackGuard
+{
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    StackGuard();
+
+    /* --------------------------------------------------------------------------------------------
+     * Base constructor.
+    */
+    StackGuard(HSQUIRRELVM vm);
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~StackGuard();
+
+private:
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    StackGuard(const StackGuard &);
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    StackGuard(StackGuard &&);
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator.
+    */
+    StackGuard & operator = (const StackGuard &);
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    StackGuard & operator = (StackGuard &&);
+
+private:
+
+    // --------------------------------------------------------------------------------------------
+    HSQUIRRELVM m_VM; // The VM where the stack should be restored.
+    Int32       m_Top; // The top of the stack when this instance was created.
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Helper structure for retrieving a value from the stack as a string or a formatted string.
+*/
+struct StackStrF
+{
+    // --------------------------------------------------------------------------------------------
+    CSStr       mPtr; // Pointer to the C string that was retrieved.
+    SQInteger   mLen; // The string length if it could be retrieved.
+    SQRESULT    mRes; // The result of the retrieval attempts.
+    HSQOBJECT   mObj; // Strong reference to the string object.
+    HSQUIRRELVM mVM; // The associated virtual machine.
+
+    /* --------------------------------------------------------------------------------------------
+     * Base constructor.
+    */
+    StackStrF(HSQUIRRELVM vm, SQInteger idx, bool fmt = true);
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor. (disabled)
+    */
+    StackStrF(const StackStrF & o) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor. (disabled)
+    */
+    StackStrF(StackStrF && o) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~StackStrF();
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor. (disabled)
+    */
+    StackStrF & operator = (const StackStrF & o) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor. (disabled)
+    */
+    StackStrF & operator = (StackStrF && o) = delete;
+};
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_COMMON_HPP_

modules/mysql/Connection.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Connection.hpp

@@ -0,0 +1,164 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * ...
+*/
+class Connection
+{
+
+protected:
+
+    /* --------------------------------------------------------------------------------------------
+     * Base constructor.
+    */
+    Connection(const Account & acc);
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    Connection(const Connection & o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    Connection(Connection && o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~Connection() = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator.
+    */
+    Connection & operator = (const Connection & o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    Connection & operator = (Connection && o) = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed connection handle and throw exception if it doesn't exist.
+    */
+    void Validate() const;
+
+private:
+
+    // --------------------------------------------------------------------------------------------
+    ConnHnd         m_Handle; // Handle to the actual database connection.
+
+public:
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the hosted connection handle.
+    */
+    operator ConnHnd ()
+    {
+        return m_Handle;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the hosted connection handle.
+    */
+    operator const ConnHnd & () const
+    {
+        return m_Handle;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Attempt to connect to the database.
+    */
+    bool Connect();
+
+    /* --------------------------------------------------------------------------------------------
+     * Disconnect from the currently connected database.
+    */
+    void Disconnect();
+
+    /* --------------------------------------------------------------------------------------------
+     * See whether a successful connection was made or not.
+    */
+    bool Connected() const
+    {
+        return (m_Handle != nullptr);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the account used to make the connection.
+    */
+    const Account::Ref & GetAccount() const
+    {
+        return m_Account;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the server schema.
+    */
+    const String & GetSchema() const
+    {
+        return m_Schema;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set the server schema.
+    */
+    void SetSchema(const String & schema);
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the character set.
+    */
+    const String & GetCharset() const
+    {
+        return m_Charset;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set the character set.
+    */
+    void SetCharset(const String & charset);
+
+    /* --------------------------------------------------------------------------------------------
+     * See whether auto-commit is enabled or not.
+    */
+    bool GetAutocommit() const
+    {
+        return m_Autocommit;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set whether auto-commit should be enabled or not.
+    */
+    void SetAutocommit(bool toggle);
+
+    /* --------------------------------------------------------------------------------------------
+     * Execute a query on the server.
+    */
+    Uint64 Execute(const String & query);
+
+    /* --------------------------------------------------------------------------------------------
+     * Execute a query on the server.
+    */
+    Uint64 Insert(const String & query);
+
+    /* --------------------------------------------------------------------------------------------
+     * Execute a query on the server.
+    */
+    Uint64 Query(const String & query);
+
+    /* --------------------------------------------------------------------------------------------
+     * 
+    */
+    StatementRef GetStatement(const String & query);
+};
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Datetime.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Datetime.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Decimal.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Decimal.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Handles.cpp

@@ -0,0 +1,25 @@
+// ------------------------------------------------------------------------------------------------
+#include "Handles.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+ConnHnd::Handle::~Handle()
+{
+    
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConnHnd::Handle::Create(CSStr host, CSStr user, CSStr pass, CSStr schema, Uint16 port, CSStr socket)
+{
+
+}
+
+// ------------------------------------------------------------------------------------------------
+Int32 ConnHnd::Handle::Flush(Uint32 num, Object & env, Function & func)
+{
+    return 0;
+}
+
+} // Namespace:: SqMod

modules/mysql/Handles.hpp

@@ -0,0 +1,691 @@
+#ifndef _SQMYSQL_HANDLES_HPP_
+#define _SQMYSQL_HANDLES_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <mysql.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Forward declarations.
+*/
+class Connection;
+class Statement;
+class Column;
+class Transaction;
+
+/* ------------------------------------------------------------------------------------------------
+ * Manages a reference counted database connection handle.
+*/
+class ConnHnd
+{
+    // --------------------------------------------------------------------------------------------
+    friend class Connection;
+    friend class Statement;
+
+public:
+
+    // --------------------------------------------------------------------------------------------
+    typedef MYSQL           Type; // The managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef Type*           Pointer; // Pointer to the managed type.
+    typedef const Type*     ConstPtr; // Constant pointer to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef Type&           Reference; // Reference to the managed type.
+    typedef const Type&     ConstRef; // Constant reference to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef unsigned int    Counter; // Reference counter type.
+
+protected:
+
+    // --------------------------------------------------------------------------------------------
+    typedef std::vector< String > QueryList; // Container used to queue queries.
+
+    /* --------------------------------------------------------------------------------------------
+     * The structure that holds the data associated with a certain connection.
+    */
+    struct Handle
+    {
+        // ----------------------------------------------------------------------------------------
+        Pointer     mPtr; // The connection handle resource.
+        Counter     mRef; // Reference count to the managed handle.
+
+        // ----------------------------------------------------------------------------------------
+        Uint32      mErrNo; // Last received error string.
+        String      mErrStr; // Last received error message.
+
+        // --------------------------------------------------------------------------------------------
+        String      mHost; // Host address.
+        String      mUser; // User name user.
+        String      mPass; // User password.
+        Uint16      mPort; // Server port.
+
+        // --------------------------------------------------------------------------------------------
+        String      mSchema; // Server schema.
+        String      mSocket; // Unix socket.
+
+        // --------------------------------------------------------------------------------------------
+        String      mSSL_Key; // SSL key.
+        String      mSSL_Cert; // SSL certificate.
+        String      mSSL_CA; // SSL certificate authority.
+        String      mSSL_CA_Path; // SSL certificate authority path.
+        String      mSSL_Cipher; // SSL Cipher.
+
+        // --------------------------------------------------------------------------------------------
+        Options     mOptions; // Option container.
+
+        // ----------------------------------------------------------------------------------------
+        QueryList   mQueue; // A queue of queries to be executed in groups.
+
+        // --------------------------------------------------------------------------------------------
+        bool        mAutocommit; // Whether autocommit is enabled on this connection.
+        bool        mInTransaction; // Whether the connection is in the middle of a transaction.
+
+        /* ----------------------------------------------------------------------------------------
+         * Base constructor.
+        */
+        Handle(Counter counter)
+            : mPtr(nullptr)
+            , mRef(counter)
+            , mErrNo(0)
+            , mErrStr(_SC(""))
+            , mHost(_SC(""))
+            , mUser(_SC(""))
+            , mPass(_SC(""))
+            , mPort(3306)
+            , mSchema(_SC(""))
+            , mSocket(_SC(""))
+            , mSSL_Key(_SC(""))
+            , mSSL_Cert(_SC(""))
+            , mSSL_CA(_SC(""))
+            , mSSL_CA_Path(_SC(""))
+            , mSSL_Cipher(_SC(""))
+            , mOptions(_SC(""))
+            , mQueue()
+            , mAutocommit(false)
+            , mInTransaction(false)
+        {
+            /* ... */
+        }
+
+        /* ----------------------------------------------------------------------------------------
+         * Destructor.
+        */
+        ~Handle();
+
+        /* ----------------------------------------------------------------------------------------
+         * Create the database connection resource.
+        */
+        void Create(CSStr host, CSStr user, CSStr pass, CSStr schema, Uint16 port, CSStr socket);
+
+        /* ----------------------------------------------------------------------------------------
+         * Execute a specific amount of queries from the queue.
+        */
+        Int32 Flush(Uint32 num, Object & env, Function & func);
+    };
+
+private:
+
+    // --------------------------------------------------------------------------------------------
+    Handle* m_Hnd;
+
+    /* --------------------------------------------------------------------------------------------
+     * Grab a strong reference to a connection handle.
+    */
+    void Grab()
+    {
+        if (m_Hnd)
+        {
+            ++(m_Hnd->mRef);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Drop a strong reference to a connection handle.
+    */
+    void Drop()
+    {
+        if (m_Hnd && --(m_Hnd->mRef) == 0)
+        {
+            delete m_Hnd; // Let the destructor take care of cleaning up (if necessary)
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base constructor.
+    */
+    ConnHnd(CSStr name)
+        : m_Hnd(name ? new Handle(1) : nullptr)
+    {
+        /* ... */
+    }
+
+public:
+
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor (null).
+    */
+    ConnHnd()
+        : m_Hnd(nullptr)
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    ConnHnd(const ConnHnd & o)
+        : m_Hnd(o.m_Hnd)
+    {
+        Grab();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    ConnHnd(ConnHnd && o)
+        : m_Hnd(o.m_Hnd)
+    {
+        o.m_Hnd = nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~ConnHnd()
+    {
+        Drop();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator.
+    */
+    ConnHnd & operator = (const ConnHnd & o)
+    {
+        if (m_Hnd != o.m_Hnd)
+        {
+            Drop();
+            m_Hnd = o.m_Hnd;
+            Grab();
+        }
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    ConnHnd & operator = (ConnHnd && o)
+    {
+        if (m_Hnd != o.m_Hnd)
+        {
+            m_Hnd = o.m_Hnd;
+            o.m_Hnd = nullptr;
+        }
+
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Status assignment operator.
+    */
+    ConnHnd & operator = (Int32 status)
+    {
+        if (m_Hnd)
+        {
+            m_Hnd->mErrNo = status;
+        }
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an equality comparison between two connection handles.
+    */
+    bool operator == (const ConnHnd & o) const
+    {
+        return (m_Hnd == o.m_Hnd);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an inequality comparison between two connection handles.
+    */
+    bool operator != (const ConnHnd & o) const
+    {
+        return (m_Hnd != o.m_Hnd);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an equality comparison with an integer value status.
+    */
+    bool operator == (Int32 status) const
+    {
+        if (m_Hnd)
+        {
+            return (m_Hnd->mErrNo == status);
+        }
+        return false;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an inequality comparison with an integer value status.
+    */
+    bool operator != (Int32 status) const
+    {
+        if (m_Hnd)
+        {
+            return (m_Hnd->mErrNo != status);
+        }
+        return false;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to boolean for use in boolean operations.
+    */
+    operator bool () const
+    {
+        return m_Hnd && m_Hnd->mPtr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Pointer ()
+    {
+        return m_Hnd ? m_Hnd->mPtr : nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Pointer () const
+    {
+        return m_Hnd ? m_Hnd->mPtr : nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Reference ()
+    {
+        assert(m_Hnd && m_Hnd->mPtr);
+        return *(m_Hnd->mPtr);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator ConstRef () const
+    {
+        assert(m_Hnd && m_Hnd->mPtr);
+        return *(m_Hnd->mPtr);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Member operator for dereferencing the managed pointer.
+    */
+    Handle * operator -> () const
+    {
+        assert(m_Hnd);
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Indirection operator for obtaining a reference of the managed pointer.
+    */
+    Handle & operator * () const
+    {
+        assert(m_Hnd);
+        return *m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the raw handle structure pointer.
+    */
+    Handle * HndPtr()
+    {
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the raw handle structure pointer.
+    */
+    Handle * HndPtr() const
+    {
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of active references to the managed instance.
+    */
+    Counter Count() const
+    {
+        return m_Hnd ? m_Hnd->mRef : 0;
+    }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Manages a reference counted database statement handle.
+*/
+class StmtHnd
+{
+    // --------------------------------------------------------------------------------------------
+    friend class Connection;
+    friend class Statement;
+
+public:
+
+    // --------------------------------------------------------------------------------------------
+    typedef MYSQL_STMT      Type; // The managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef Type*           Pointer; // Pointer to the managed type.
+    typedef const Type*     ConstPtr; // Constant pointer to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef Type&           Reference; // Reference to the managed type.
+    typedef const Type&     ConstRef; // Constant reference to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef MYSQL_BIND      BindType; // The managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef BindType*       BindPointer; // Pointer to the managed type.
+    typedef const BindType* BindConstPtr; // Constant pointer to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef BindType&       BindReference; // Reference to the managed type.
+    typedef const BindType& BindConstRef; // Constant reference to the managed type.
+
+    // --------------------------------------------------------------------------------------------
+    typedef unsigned int    Counter; // Reference counter type.
+
+protected:
+
+    // --------------------------------------------------------------------------------------------
+    typedef std::map< String, int > Indexes; // Container used to identify column indexes.
+
+    /* --------------------------------------------------------------------------------------------
+     * The structure that holds the data associated with a certain statement.
+    */
+    struct Handle
+    {
+        // --------------------------------------------------------------------------------------------
+        Pointer     mPtr; // The statement handle resource.
+        Counter     mRef; // Reference count to the managed handle.
+
+        // ----------------------------------------------------------------------------------------
+        Int32       mErrNo; // The last status code of this connection handle.
+
+        // ----------------------------------------------------------------------------------------
+        MYSQL_BIND* mBinds;
+
+        /* ----------------------------------------------------------------------------------------
+         * Base constructor.
+        */
+        Handle(const ConnHnd & conn, Counter counter)
+            : mPtr(nullptr)
+            , mRef(counter)
+            , mErrNo(0)
+        {
+            /* ... */
+        }
+
+        /* --------------------------------------------------------------------------------------------
+         * Destructor.
+        */
+        ~Handle();
+
+        /* --------------------------------------------------------------------------------------------
+         * Create the database statement resource.
+        */
+        void Create(CSStr query);
+    };
+
+private:
+
+    // --------------------------------------------------------------------------------------------
+    Handle* m_Hnd;
+
+    /* --------------------------------------------------------------------------------------------
+     * Grab a strong reference to a statement handle.
+    */
+    void Grab()
+    {
+        if (m_Hnd)
+        {
+            ++(m_Hnd->mRef);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Drop a strong reference to a statement handle.
+    */
+    void Drop()
+    {
+        if (m_Hnd && --(m_Hnd->mRef) == 0)
+        {
+            delete m_Hnd; // Let the destructor take care of cleaning up (if necessary)
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Base constructor.
+    */
+    StmtHnd(const ConnHnd & db)
+        : m_Hnd(new Handle(db, 1))
+    {
+        /* ... */
+    }
+
+public:
+
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor (null).
+    */
+    StmtHnd()
+        : m_Hnd(nullptr)
+    {
+        /* ... */
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    StmtHnd(const StmtHnd & o)
+        : m_Hnd(o.m_Hnd)
+
+    {
+        Grab();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    StmtHnd(StmtHnd && o)
+        : m_Hnd(o.m_Hnd)
+    {
+        o.m_Hnd = nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~StmtHnd()
+    {
+        Drop();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator.
+    */
+    StmtHnd & operator = (const StmtHnd & o)
+    {
+        if (m_Hnd != o.m_Hnd)
+        {
+            Drop();
+            m_Hnd = o.m_Hnd;
+            Grab();
+        }
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    StmtHnd & operator = (StmtHnd && o)
+    {
+        if (m_Hnd != o.m_Hnd)
+        {
+            m_Hnd = o.m_Hnd;
+            o.m_Hnd = nullptr;
+        }
+
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Status assignment operator.
+    */
+    StmtHnd & operator = (Int32 status)
+    {
+        if (m_Hnd)
+        {
+            m_Hnd->mErrNo = status;
+        }
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an equality comparison between two statement handles.
+    */
+    bool operator == (const StmtHnd & o) const
+    {
+        return (m_Hnd == o.m_Hnd);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an inequality comparison between two statement handles.
+    */
+    bool operator != (const StmtHnd & o) const
+    {
+        return (m_Hnd != o.m_Hnd);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an equality comparison with an integer value status.
+    */
+    bool operator == (Int32 status) const
+    {
+        if (m_Hnd)
+        {
+            return (m_Hnd->mErrNo == status);
+        }
+        return false;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Perform an inequality comparison with an integer status value.
+    */
+    bool operator != (Int32 status) const
+    {
+        if (m_Hnd)
+        {
+            return (m_Hnd->mErrNo != status);
+        }
+        return false;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to boolean for use in boolean operations.
+    */
+    operator bool () const
+    {
+        return m_Hnd && m_Hnd->mPtr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Pointer ()
+    {
+        return m_Hnd ? m_Hnd->mPtr : nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Pointer () const
+    {
+        return m_Hnd ? m_Hnd->mPtr : nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator Reference ()
+    {
+        assert(m_Hnd && m_Hnd->mPtr);
+        return *(m_Hnd->mPtr);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Implicit conversion to the managed instance.
+    */
+    operator ConstRef () const
+    {
+        assert(m_Hnd && m_Hnd->mPtr);
+        return *(m_Hnd->mPtr);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Member operator for dereferencing the managed pointer.
+    */
+    Handle * operator -> () const
+    {
+        assert(m_Hnd);
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Indirection operator for obtaining a reference of the managed pointer.
+    */
+    Handle & operator * () const
+    {
+        assert(m_Hnd);
+        return *m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the raw handle structure pointer.
+    */
+    Handle * HndPtr()
+    {
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the raw handle structure pointer.
+    */
+    Handle * HndPtr() const
+    {
+        return m_Hnd;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of active references to the managed instance.
+    */
+    Counter Count() const
+    {
+        return m_Hnd ? m_Hnd->mRef : 0;
+    }
+};
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_HANDLES_HPP_

modules/mysql/Module.cpp

@@ -0,0 +1,305 @@
+// --------------------------------------------------------------------------------------------
+#include "Module.hpp"
+#include "Common.hpp"
+
+// --------------------------------------------------------------------------------------------
+#include <sqrat.h>
+
+// --------------------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+// --------------------------------------------------------------------------------------------
+#if defined(WIN32) || defined(_WIN32)
+    #include <Windows.h>
+#endif
+
+namespace SqMod {
+
+// --------------------------------------------------------------------------------------------
+PluginFuncs*        _Func = nullptr;
+PluginCallbacks*    _Clbk = nullptr;
+PluginInfo*         _Info = nullptr;
+
+// --------------------------------------------------------------------------------------------
+HSQAPI              _SqAPI = nullptr;
+HSQEXPORTS          _SqMod = nullptr;
+HSQUIRRELVM         _SqVM = nullptr;
+
+/* ------------------------------------------------------------------------------------------------
+ * Bind speciffic functions to certain server events.
+*/
+void BindCallbacks();
+
+/* ------------------------------------------------------------------------------------------------
+ * Undo changes made with BindCallbacks().
+*/
+void UnbindCallbacks();
+
+/* --------------------------------------------------------------------------------------------
+ * Register the module API under the specified virtual machine.
+*/
+void RegisterAPI(HSQUIRRELVM vm);
+
+/* --------------------------------------------------------------------------------------------
+ * Initialize the plugin by obtaining the API provided by the host plugin.
+*/
+void OnSquirrelInitialize()
+{
+    // Attempt to import the plugin API exported by the host plugin
+    _SqMod = sq_api_import(_Func);
+    // Did we failed to obtain the plugin exports?
+    if(!_SqMod)
+        OutputError("Failed to attach [%s] on host plugin.", SQMYSQL_NAME);
+    else
+    {
+        // Obtain the Squirrel API
+        _SqAPI = _SqMod->GetSquirrelAPI();
+        // Expand the Squirrel API into global functions
+        sq_api_expand(_SqAPI);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------
+ * Load the module on the virtual machine provided by the host module.
+*/
+void OnSquirrelLoad()
+{
+    // Make sure that we have a valid plugin API
+    if (!_SqMod)
+        return; /* Unable to proceed. */
+    // Obtain the Squirrel API and VM
+    _SqVM = _SqMod->GetSquirrelVM();
+    // Make sure that a valid virtual machine exists
+    if (!_SqVM)
+        return; /* Unable to proceed. */
+    // Set this as the default database
+    DefaultVM::Set(_SqVM);
+    // Register the module API
+    RegisterAPI(_SqVM);
+    // Notify about the current status
+    OutputMessage("Registered: %s", SQMYSQL_NAME);
+}
+
+/* --------------------------------------------------------------------------------------------
+ * The virtual machine is about to be terminated and script resources should be released.
+*/
+void OnSquirrelTerminate()
+{
+    OutputMessage("Terminating: %s", SQMYSQL_NAME);
+    // Release the current virtual machine, if any
+    DefaultVM::Set(nullptr);
+    // Release script resources...
+}
+
+/* --------------------------------------------------------------------------------------------
+ * Validate the module API to make sure we don't run into issues.
+*/
+bool CheckAPIVer(CCStr ver)
+{
+    // Obtain the numeric representation of the API version
+    long vernum = strtol(ver, nullptr, 10);
+    // Check against version mismatch
+    if (vernum == SQMOD_API_VER)
+        return true;
+    // Log the incident
+    OutputError("API version mismatch on %s", SQMYSQL_NAME);
+    OutputMessage("=> Requested: %ld Have: %ld", vernum, SQMOD_API_VER);
+    // Invoker should not attempt to communicate through the module API
+    return false;
+}
+
+/* --------------------------------------------------------------------------------------------
+ * React to command sent by other plugins.
+*/
+static uint8_t OnPluginCommand(uint32_t command_identifier, CCStr message)
+{
+    switch(command_identifier)
+    {
+        case SQMOD_INITIALIZE_CMD:
+            if (CheckAPIVer(message))
+                OnSquirrelInitialize();
+        break;
+        case SQMOD_LOAD_CMD:
+            OnSquirrelLoad();
+        break;
+        case SQMOD_TERMINATE_CMD:
+            OnSquirrelTerminate();
+        break;
+        default: break;
+    }
+    return 1;
+}
+
+/* --------------------------------------------------------------------------------------------
+ * The server was initialized and this plugin was loaded successfully.
+*/
+static uint8_t OnServerInitialise()
+{
+    return 1;
+}
+
+static void OnServerShutdown(void)
+{
+    // The server may still send callbacks
+    UnbindCallbacks();
+}
+
+// ------------------------------------------------------------------------------------------------
+void BindCallbacks()
+{
+    _Clbk->OnServerInitialise       = OnServerInitialise;
+    _Clbk->OnServerShutdown         = OnServerShutdown;
+    _Clbk->OnPluginCommand          = OnPluginCommand;
+}
+
+// ------------------------------------------------------------------------------------------------
+void UnbindCallbacks()
+{
+    _Clbk->OnServerInitialise       = nullptr;
+    _Clbk->OnServerShutdown         = nullptr;
+    _Clbk->OnPluginCommand          = nullptr;
+}
+
+// --------------------------------------------------------------------------------------------
+void RegisterAPI(HSQUIRRELVM vm)
+{
+    SQMOD_UNUSED_VAR(vm);
+}
+
+// --------------------------------------------------------------------------------------------
+void OutputMessageImpl(const char * msg, va_list args)
+{
+#if defined(WIN32) || defined(_WIN32)
+    HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    CONSOLE_SCREEN_BUFFER_INFO csb_before;
+    GetConsoleScreenBufferInfo( hstdout, &csb_before);
+    SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN);
+    std::printf("[SQMOD] ");
+
+    SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
+    std::vprintf(msg, args);
+    std::puts("");
+
+    SetConsoleTextAttribute(hstdout, csb_before.wAttributes);
+#else
+    std::printf("%c[0;32m[SQMOD]%c[0m", 27, 27);
+    std::vprintf(msg, args);
+    std::puts("");
+#endif
+}
+
+// --------------------------------------------------------------------------------------------
+void OutputErrorImpl(const char * msg, va_list args)
+{
+#if defined(WIN32) || defined(_WIN32)
+    HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    CONSOLE_SCREEN_BUFFER_INFO csb_before;
+    GetConsoleScreenBufferInfo( hstdout, &csb_before);
+    SetConsoleTextAttribute(hstdout, FOREGROUND_RED | FOREGROUND_INTENSITY);
+    std::printf("[SQMOD] ");
+
+    SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
+    std::vprintf(msg, args);
+    std::puts("");
+
+    SetConsoleTextAttribute(hstdout, csb_before.wAttributes);
+#else
+    std::printf("%c[0;91m[SQMOD]%c[0m", 27, 27);
+    std::vprintf(msg, args);
+    std::puts("");
+#endif
+}
+
+// --------------------------------------------------------------------------------------------
+void OutputDebug(const char * msg, ...)
+{
+#ifdef _DEBUG
+    // Initialize the arguments list
+    va_list args;
+    va_start(args, msg);
+    // Call the output function
+    OutputMessageImpl(msg, args);
+    // Finalize the arguments list
+    va_end(args);
+#else
+    SQMOD_UNUSED_VAR(msg);
+#endif
+}
+
+// --------------------------------------------------------------------------------------------
+void OutputMessage(const char * msg, ...)
+{
+    // Initialize the arguments list
+    va_list args;
+    va_start(args, msg);
+    // Call the output function
+    OutputMessageImpl(msg, args);
+    // Finalize the arguments list
+    va_end(args);
+}
+
+// --------------------------------------------------------------------------------------------
+void OutputError(const char * msg, ...)
+{
+    // Initialize the arguments list
+    va_list args;
+    va_start(args, msg);
+    // Call the output function
+    OutputErrorImpl(msg, args);
+    // Finalize the arguments list
+    va_end(args);
+}
+
+} // Namespace:: SqMod
+
+// --------------------------------------------------------------------------------------------
+SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs* functions, PluginCallbacks* callbacks, PluginInfo* info)
+{
+    using namespace SqMod;
+    // Output plugin header
+    puts("");
+    OutputMessage("--------------------------------------------------------------------");
+    OutputMessage("Plugin: %s", SQMYSQL_NAME);
+    OutputMessage("Author: %s", SQMYSQL_AUTHOR);
+    OutputMessage("Legal: %s", SQMYSQL_COPYRIGHT);
+    OutputMessage("--------------------------------------------------------------------");
+    puts("");
+    // Attempt to find the host plugin ID
+    int host_plugin_id = functions->FindPlugin((char *)(SQMOD_HOST_NAME));
+    // See if our plugin was loaded after the host plugin
+    if (host_plugin_id < 0)
+    {
+        OutputError("%s could find the host plugin", SQMYSQL_NAME);
+        // Don't load!
+        return SQMOD_FAILURE;
+    }
+    // Should never reach this point but just in case
+    else if (static_cast< Uint32 >(host_plugin_id) > info->pluginId)
+    {
+        OutputError("%s loaded after the host plugin", SQMYSQL_NAME);
+        // Don't load!
+        return SQMOD_FAILURE;
+    }
+    // Store server proxies
+    _Func = functions;
+    _Clbk = callbacks;
+    _Info = info;
+    // Assign plugin version
+    _Info->pluginVersion = SQMYSQL_VERSION;
+    _Info->apiMajorVersion = PLUGIN_API_MAJOR;
+    _Info->apiMinorVersion = PLUGIN_API_MINOR;
+    // Assign the plugin name
+    std::snprintf(_Info->name, sizeof(_Info->name), "%s", SQMYSQL_HOST_NAME);
+    // Bind callbacks
+    BindCallbacks();
+    // Notify that the plugin was successfully loaded
+    OutputMessage("Successfully loaded %s", SQMYSQL_NAME);
+    // Dummy spacing
+    puts("");
+    // Done!
+    return SQMOD_SUCCESS;
+}

modules/mysql/Module.hpp

@@ -0,0 +1,41 @@
+#ifndef _SQMYSQL_MODULE_HPP_
+#define _SQMYSQL_MODULE_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "SqMod.h"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Proxies to comunicate with the server.
+*/
+extern PluginFuncs*         _Func;
+extern PluginCallbacks*     _Clbk;
+extern PluginInfo*          _Info;
+
+/* ------------------------------------------------------------------------------------------------
+ * Proxies to comunicate with the Squirrel plugin.
+*/
+extern HSQAPI               _SqAPI;
+extern HSQEXPORTS           _SqMod;
+extern HSQUIRRELVM          _SqVM;
+
+/* ------------------------------------------------------------------------------------------------
+ * Output a message only if the _DEBUG was defined.
+*/
+void OutputDebug(const char * msg, ...);
+
+/* ------------------------------------------------------------------------------------------------
+ * Output a formatted user message to the console.
+*/
+void OutputMessage(const char * msg, ...);
+
+/* ------------------------------------------------------------------------------------------------
+ * Output a formatted error message to the console.
+*/
+void OutputError(const char * msg, ...);
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_MODULE_HPP_

modules/mysql/Result.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Result.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Savepoint.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Savepoint.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Statement.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Statement.hpp

@@ -0,0 +1,23 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+class Statement
+{
+public:
+    Statement();
+    ~Statement();
+    
+};
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_

modules/mysql/Transaction.cpp

@@ -0,0 +1,10 @@
+// ------------------------------------------------------------------------------------------------
+#include "Account.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

modules/mysql/Transaction.hpp

@@ -0,0 +1,17 @@
+#ifndef _SQMYSQL_ACCOUNT_HPP_
+#define _SQMYSQL_ACCOUNT_HPP_
+
+// ------------------------------------------------------------------------------------------------
+#include "Common.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ *
+*/
+
+
+} // Namespace:: SqMod
+
+#endif // _SQMYSQL_ACCOUNT_HPP_