Create a safe and unsafe command module, separating out the two systems. Add a

MySQLSafeMode version to prepare for users that want to switch. This
should be fully backwards compatible.

Author: schveiguy

source/mysql/commands.d

@@ -9,7 +9,7 @@ import std.socket;
 import std.string;
 import std.typecons;
 
-import mysql.commands;
+import mysql.safe.commands;
 import mysql.exceptions;
 import mysql.prepared;
 import mysql.protocol.comms;
@@ -309,14 +309,14 @@ struct BackwardCompatPrepared
 	deprecated("Change 'preparedStmt.query()' to 'conn.query(preparedStmt)'")
 	ResultRange query()
 	{
-		return .query(_conn, _prepared);
+		return .query(_conn, _prepared).unsafe;
 	}
 
 	///ditto
 	deprecated("Change 'preparedStmt.queryRow()' to 'conn.queryRow(preparedStmt)'")
 	Nullable!Row queryRow()
 	{
-		return .queryRow(_conn, _prepared);
+		return .queryRow(_conn, _prepared).unsafe;
 	}
 
 	///ditto
@@ -328,9 +328,9 @@ struct BackwardCompatPrepared
 
 	///ditto
 	deprecated("Change 'preparedStmt.queryValue()' to 'conn.queryValue(preparedStmt)'")
-	Nullable!MySQLVal queryValue()
+	Nullable!Variant queryValue() @system
 	{
-		return .queryValue(_conn, _prepared);
+		return .queryValue(_conn, _prepared).asVariant;
 	}
 }
 

source/mysql/connection.d

@@ -6,7 +6,7 @@ import std.conv;
 import std.datetime;
 import std.exception;
 
-import mysql.commands;
+import mysql.safe.commands;
 import mysql.exceptions;
 import mysql.protocol.sockets;
 import mysql.result;

source/mysql/metadata.d

@@ -7,7 +7,7 @@ import std.traits;
 import std.typecons;
 import std.variant;
 
-import mysql.commands;
+import mysql.safe.commands;
 import mysql.exceptions;
 import mysql.protocol.comms;
 import mysql.protocol.constants;
@@ -241,7 +241,6 @@ public:
 			setArg(index, val.get(), psn);
 	}
 
-	deprecated("Using Variant is deprecated, please use MySQLVal instead")
 	void setArg(T)(size_t index, T val, ParameterSpecialization psn = PSN(0, SQLType.INFER_FROM_D_TYPE, 0, null)) @system
 		if(is(T == Variant))
 	{
@@ -362,7 +361,6 @@ public:
 	}
 
 	/// ditto
-	deprecated("Using Variant is deprecated, please use MySQLVal instead")
 	void setArgs(Variant[] args, ParameterSpecialization[] psnList=null) @system
 	{
 		enforce!MYX(args.length == _numParams, "Param count supplied does not match prepared statement");
@@ -393,7 +391,6 @@ public:
 	}
 
 	/// ditto
-	deprecated("Using Variant is deprecated, please use getArg instead")
 	Variant vGetArg(size_t index) @system
 	{
 		// convert to Variant.
@@ -438,7 +435,7 @@ public:
 		immutable selectSQL = "SELECT * FROM `setNullArg`";
 		auto preparedInsert = cn.prepare(insertSQL);
 		assert(preparedInsert.sql == insertSQL);
-		Row[] rs;
+		SafeRow[] rs;
 
 		{
 			Nullable!int nullableInt;

source/mysql/prepared.d

@@ -809,7 +809,7 @@ package(mysql) ubyte[] makeToken(string password, ubyte[] authBuf)
 }
 
 /// Get the next `mysql.result.Row` of a pending result set.
-package(mysql) Row getNextRow(Connection conn)
+package(mysql) SafeRow getNextRow(Connection conn)
 {
 	scope(failure) conn.kill();
 
@@ -819,7 +819,7 @@ package(mysql) Row getNextRow(Connection conn)
 		conn._headersPending = false;
 	}
 	ubyte[] packet;
-	Row rr;
+	SafeRow rr;
 	packet = conn.getPacket();
 	if(packet.front == ResultPacketMarker.error)
 		throw new MYXReceived(OKErrorPacket(packet), __FILE__, __LINE__);
@@ -830,9 +830,9 @@ package(mysql) Row getNextRow(Connection conn)
 		return rr;
 	}
 	if (conn._binaryPending)
-		rr = Row(conn, packet, conn._rsh, true);
+		rr = SafeRow(conn, packet, conn._rsh, true);
 	else
-		rr = Row(conn, packet, conn._rsh, false);
+		rr = SafeRow(conn, packet, conn._rsh, false);
 	//rr._valid = true;
 	return rr;
 }

source/mysql/protocol/comms.d

@@ -5,14 +5,15 @@ import std.conv;
 import std.exception;
 import std.range;
 import std.string;
-import std.variant;
 
 import mysql.connection;
 import mysql.exceptions;
 import mysql.protocol.comms;
 import mysql.protocol.extra_types;
 import mysql.protocol.packets;
 public import mysql.types;
+import std.typecons : Nullable;
+import std.variant;
 
 /++
 A struct to represent a single row of a result set.
@@ -28,7 +29,7 @@ I have been agitating for some kind of null indicator that can be set for a
 Variant without destroying its inherent type information. If this were the
 case, then the bool array could disappear.
 +/
-struct Row
+struct SafeRow
 {
 	import mysql.connection;
 
@@ -88,7 +89,7 @@ public:
 	unittest
 	{
 		import mysql.test.common;
-		import mysql.commands;
+		import mysql.safe.commands;
 		mixin(scopedCn);
 		cn.exec("DROP TABLE IF EXISTS `row_getName`");
 		cn.exec("CREATE TABLE `row_getName` (someValue INTEGER, another INTEGER) ENGINE=InnoDB DEFAULT CHARSET=utf8");
@@ -177,21 +178,41 @@ public:
 }
 
 /// ditto
-deprecated("Usage of Variant is deprecated. Please switch code to use safe MySQLVal types")
-UnsafeRow unsafe(Row r)
+struct UnsafeRow
 {
-	return UnsafeRow(r);
+	SafeRow _safe;
+	alias _safe this;
+	Variant opIndex(size_t idx) {
+		return _safe[idx].asVariant;
+	}
 }
 
 /// ditto
-struct UnsafeRow
+UnsafeRow unsafe(SafeRow r) @safe
 {
-	Row safe;
-	alias safe this;
-	deprecated("Variant support is deprecated. Please switch to using MySQLVal")
-	Variant opIndex(size_t idx) {
-		return safe[idx].asVariant;
-	}
+	return Row(r);
+}
+
+/// ditto
+Nullable!UnsafeRow unsafe(Nullable!SafeRow r) @safe
+{
+	if(r.isNull)
+		return Nullable!UnsafeRow();
+	return Nullable!UnsafeRow(r.get.unsafe);
+}
+
+
+SafeRow safe(UnsafeRow r) @safe
+{
+	return r._safe;
+}
+
+
+Nullable!SafeRow safe(Nullable!UnsafeRow r) @safe
+{
+	if(r.isNull)
+		return Nullable!SafeRow();
+	return Nullable!SafeRow(r.get.safe);
 }
 
 /++
@@ -224,13 +245,13 @@ ResultRange oneAtATime = myConnection.query("SELECT * from myTable");
 Row[]       allAtOnce  = myConnection.query("SELECT * from myTable").array;
 ---
 +/
-struct ResultRange
+struct SafeResultRange
 {
 private:
 @safe:
 	Connection       _con;
 	ResultSetHeaders _rsh;
-	Row              _row; // current row
+	SafeRow          _row; // current row
 	string[]         _colNames;
 	size_t[string]   _colNameIndicies;
 	ulong            _numRowsFetched;
@@ -280,7 +301,7 @@ public:
 	/++
 	Gets the current row
 	+/
-	@property inout(Row) front() pure inout
+	@property inout(SafeRow) front() pure inout
 	{
 		ensureValid();
 		enforce!MYX(!empty, "Attempted 'front' on exhausted result sequence.");
@@ -345,21 +366,13 @@ public:
 	@property ulong rowCount() const pure nothrow { return _numRowsFetched; }
 }
 
-/// ditto
-deprecated("Usage of Variant is deprecated. Please switch code to use safe MySQLVal types")
-auto unsafe(ResultRange r)
-{
-	return UnsafeResultRange(r);
-}
-
 /// ditto
 struct UnsafeResultRange
 {
-	ResultRange safe;
+	SafeResultRange safe;
 	alias safe this;
-	inout(UnsafeRow) front() inout { return inout(UnsafeRow)(safe.front); }
+	inout(Row) front() inout { return inout(Row)(safe.front); }
 
-	deprecated("Variant support is deprecated. Please switch to using MySQLVal")
 	Variant[string] asAA()
 	{
 		ensureValid();
@@ -370,3 +383,20 @@ struct UnsafeResultRange
 		return aa;
 	}
 }
+
+/// ditto
+UnsafeResultRange unsafe(SafeResultRange r) @safe
+{
+	return UnsafeResultRange(r);
+}
+
+version(MySQLSafeMode)
+{
+	alias Row = SafeRow;
+	alias ResultRange = SafeResultRange;
+}
+else
+{
+	alias Row = UnsafeRow;
+	alias ResultRange = UnsafeResultRange;
+}