Added support for JSON data type

.gitignore

@@ -0,0 +1,9 @@
+*.[oa]
+*.so
+*.lib
+*.dll
+*.exe
+.dub
+
+# Executable file name when 'dub' is run on linux
+mysql-native

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "mysql-native",
 	"description": "A native MySQL driver implementation based on Steve Teale's original",
-	"homepage": "https://github.com/rejectedsoftware/mysql-native",
+	"license": "BSL-1.0",
 	"copyright": "Copyright (c) 2011 Steve Teale",
 	"authors": [
 		"Steve Teale",
@@ -11,6 +11,9 @@
 		"sshamov",
 		"Nick Sabalausky"
 	],
+	"dependencies": {
+		"vibe-d": {"version": ">=0.7.17", "optional": true}
+	},
 	"configurations": [
 	 	{
 	 		"name": "application",
@@ -22,4 +25,4 @@
 			"excludedSourceFiles": ["source/app.d"]
 		}
 	]
-}
+}

source/mysql/common.d

@@ -0,0 +1,185 @@
+module mysql.common;
+
+import std.algorithm;
+import std.conv;
+import std.datetime;
+import std.digest.sha;
+import std.exception;
+import std.range;
+import std.socket;
+import std.stdio;
+import std.string;
+import std.traits;
+import std.variant;
+
+version(Have_vibe_d)
+{
+    static if(__traits(compiles, (){ import vibe.core.net; } ))
+        import vibe.core.net;
+    else
+        static assert(false, "mysql-native can't find Vibe.d's 'vibe.core.net'.");
+}
+
+/**
+ * An exception type to distinguish exceptions thrown by this module.
+ */
+class MySQLException: Exception
+{
+    this(string msg, string file = __FILE__, size_t line = __LINE__) pure
+    {
+        super(msg, file, line);
+    }
+}
+alias MySQLException MYX;
+
+/**
+ * Received invalid data from the server which violates the MySQL network protocol.
+ */
+class MySQLProtocolException: MySQLException
+{
+    this(string msg, string file, size_t line) pure
+    {
+        super(msg, file, line);
+    }
+}
+alias MySQLProtocolException MYXProtocol;
+
+// Phobos/Vibe.d type aliases
+package alias std.socket.TcpSocket PlainPhobosSocket;
+version(Have_vibe_d)
+{
+    package alias vibe.core.net.TCPConnection PlainVibeDSocket;
+}
+else
+{
+    // Dummy types
+    package alias Object PlainVibeDSocket;
+}
+
+alias PlainPhobosSocket function(string,ushort) OpenSocketCallbackPhobos;
+alias PlainVibeDSocket  function(string,ushort) OpenSocketCallbackVibeD;
+
+enum MySQLSocketType { phobos, vibed }
+
+// A minimal socket interface similar to Vibe.d's TCPConnection.
+// Used to wrap both Phobos and Vibe.d sockets with a common interface.
+package interface MySQLSocket
+{
+    void close();
+    @property bool connected() const;
+    void read(ubyte[] dst);
+    void write(in ubyte[] bytes);
+
+    void acquire();
+    void release();
+    bool isOwner();
+    bool amOwner();
+}
+
+// Wraps a Phobos socket with the common interface
+package class MySQLSocketPhobos : MySQLSocket
+{
+    private PlainPhobosSocket socket;
+
+    // The socket should already be open
+    this(PlainPhobosSocket socket)
+    {
+        enforceEx!MYX(socket, "Tried to use a null Phobos socket - Maybe the 'openSocket' callback returned null?");
+        enforceEx!MYX(socket.isAlive, "Tried to use a closed Phobos socket - Maybe the 'openSocket' callback created a socket but forgot to open it?");
+        this.socket = socket;
+    }
+
+    invariant()
+    {
+        assert(!!socket);
+    }
+
+    void close()
+    {
+        socket.shutdown(SocketShutdown.BOTH);
+        socket.close();
+    }
+
+    @property bool connected() const
+    {
+        return socket.isAlive;
+    }
+
+    void read(ubyte[] dst)
+    {
+        // Note: I'm a little uncomfortable with this line as it doesn't
+        // (and can't) update Connection._open. Not sure what can be done,
+        // but perhaps Connection._open should be eliminated in favor of
+        // querying the socket's opened/closed state directly.
+        scope(failure) socket.close();
+
+        for (size_t off, len; off < dst.length; off += len) {
+            len = socket.receive(dst[off..$]);
+            enforceEx!MYX(len != 0, "Server closed the connection");
+            enforceEx!MYX(len != socket.ERROR, "Received std.socket.Socket.ERROR");
+        }
+    }
+
+    void write(in ubyte[] bytes)
+    {
+        socket.send(bytes);
+    }
+
+    void acquire() { /+ Do nothing +/ }
+    void release() { /+ Do nothing +/ }
+    bool isOwner() { return true; }
+    bool amOwner() { return true; }
+}
+
+// Wraps a Vibe.d socket with the common interface
+version(Have_vibe_d) {
+    package class MySQLSocketVibeD : MySQLSocket
+    {
+        private PlainVibeDSocket socket;
+
+        // The socket should already be open
+        this(PlainVibeDSocket socket)
+        {
+            enforceEx!MYX(socket, "Tried to use a null Vibe.d socket - Maybe the 'openSocket' callback returned null?");
+            enforceEx!MYX(socket.connected, "Tried to use a closed Vibe.d socket - Maybe the 'openSocket' callback created a socket but forgot to open it?");
+            this.socket = socket;
+        }
+
+        invariant()
+        {
+            assert(!!socket);
+        }
+
+        void close()
+        {
+            socket.close();
+        }
+
+        @property bool connected() const
+        {
+            return socket.connected;
+        }
+
+        void read(ubyte[] dst)
+        {
+            socket.read(dst);
+        }
+
+        void write(in ubyte[] bytes)
+        {
+            socket.write(bytes);
+        }
+
+        static if (is(typeof(&TCPConnection.isOwner))) {
+            void acquire() { socket.acquire(); }
+            void release() { socket.release(); }
+            bool isOwner() { return socket.isOwner(); }
+            bool amOwner() { return socket.isOwner(); }
+        } else {
+            void acquire() { /+ Do nothing +/ }
+            void release() { /+ Do nothing +/ }
+            bool isOwner() { return true; }
+            bool amOwner() { return true; }
+        }
+    }
+}