Merge pull request #512 from bgrainger/mysqldatetime

bgrainger · web-flow · commit d6288a24e625 · 2018-06-09T14:59:14.000-07:00
Add MySqlDateTime and AllowZeroDateTime. Fixes #507
diff --git a/docs/content/connection-options.md b/docs/content/connection-options.md
@@ -188,6 +188,13 @@ These are the other options that MySqlConnector supports. They are set to sensib
     <td>Allows user-defined variables (prefixed with <code>@</code>) to be used in SQL statements. The default value (<code>false</code>)
     only allows <code>@</code>-prefixed names to refer to command parameters.</td>
   </tr>
+  <tr>
+    <td>AllowZeroDateTime, Allow Zero DateTime</td>
+    <td>false</td>
+    <td>If set to <c>true</c> all `DATE`, `DATETIME` and `TIMESTAMP` columns are returned as `MySqlDateTime` objects instead of `DateTime`.
+    This allows the special “zero” date value `0000-00-00` to be retrieved from the database. If <code>false</code> (the default)
+    date columns are returned as `DateTime` values, and an exception is thrown for unrepresentable dates.</td>
+  </tr>
   <tr>
     <td>Compress, Use Compression, UseCompression</td>
     <td>false</td>
diff --git a/docs/content/tutorials/migrating-from-connector-net.md b/docs/content/tutorials/migrating-from-connector-net.md
@@ -127,3 +127,4 @@ The following bugs in Connector/NET are fixed by switching to MySqlConnector.
 * [#89159](https://bugs.mysql.com/bug.php?id=89159): `MySqlDataReader` cannot outlive `MySqlCommand`
 * [#89335](https://bugs.mysql.com/bug.php?id=89335): `MySqlCommandBuilder.DeriveParameters` fails for `JSON` type
 * [#91123](https://bugs.mysql.com/bug.php?id=91123): Database names are case-sensitive when calling a stored procedure
+* [#91199](https://bugs.mysql.com/bug.php?id=91199): Can't insert `MySqlDateTime` values
diff --git a/src/MySqlConnector/Core/ConnectionSettings.cs b/src/MySqlConnector/Core/ConnectionSettings.cs
@@ -62,6 +62,7 @@ public ConnectionSettings(MySqlConnectionStringBuilder csb)
 			// Other Options
 			AllowPublicKeyRetrieval = csb.AllowPublicKeyRetrieval;
 			AllowUserVariables = csb.AllowUserVariables;
+			AllowZeroDateTime = csb.AllowZeroDateTime;
 			AutoEnlist = csb.AutoEnlist;
 			ConnectionTimeout = (int) csb.ConnectionTimeout;
 			ConvertZeroDateTime = csb.ConvertZeroDateTime;
@@ -135,6 +136,7 @@ private static MySqlGuidFormat GetEffectiveGuidFormat(MySqlGuidFormat guidFormat
 		// Other Options
 		public bool AllowPublicKeyRetrieval { get; }
 		public bool AllowUserVariables { get; }
+		public bool AllowZeroDateTime { get; }
 		public bool AutoEnlist { get; }
 		public int ConnectionTimeout { get; }
 		public bool ConvertZeroDateTime { get; }
diff --git a/src/MySqlConnector/Core/ResultSet.cs b/src/MySqlConnector/Core/ResultSet.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MySql.Data.MySqlClient;
+using MySql.Data.Types;
 using MySqlConnector.Protocol;
 using MySqlConnector.Protocol.Payloads;
 using MySqlConnector.Protocol.Serialization;
@@ -297,7 +298,10 @@ public Type GetFieldType(int ordinal)
 			if (ordinal < 0 || ordinal > ColumnDefinitions.Length)
 				throw new ArgumentOutOfRangeException(nameof(ordinal), "value must be between 0 and {0}.".FormatInvariant(ColumnDefinitions.Length));
 
-			return TypeMapper.Instance.GetColumnTypeMetadata(ColumnTypes[ordinal]).DbTypeMapping.ClrType;
+			var type = TypeMapper.Instance.GetColumnTypeMetadata(ColumnTypes[ordinal]).DbTypeMapping.ClrType;
+			if (Connection.AllowZeroDateTime && type == typeof(DateTime))
+				type = typeof(MySqlDateTime);
+			return type;
 		}
 
 		public int FieldCount => ColumnDefinitions?.Length ?? 0;
diff --git a/src/MySqlConnector/Core/Row.cs b/src/MySqlConnector/Core/Row.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Text;
 using MySql.Data.MySqlClient;
+using MySql.Data.Types;
 using MySqlConnector.Protocol;
 using MySqlConnector.Protocol.Serialization;
 using MySqlConnector.Utilities;
@@ -315,6 +316,14 @@ public double GetDouble(int ordinal)
 
 		public float GetFloat(int ordinal) => (float) GetValue(ordinal);
 
+		public MySqlDateTime GetMySqlDateTime(int ordinal)
+		{
+			var value = GetValue(ordinal);
+			if (value is DateTime dateTime)
+				return new MySqlDateTime(dateTime);
+			return (MySqlDateTime) value;
+		}
+
 		public int GetValues(object[] values)
 		{
 			int count = Math.Min(values.Length, ResultSet.ColumnDefinitions.Length);
@@ -451,7 +460,7 @@ private static void CheckBufferArguments<T>(long dataOffset, T[] buffer, int buf
 				throw new ArgumentException("bufferOffset + length cannot exceed buffer.Length", nameof(length));
 		}
 
-		private DateTime ParseDateTime(ReadOnlySpan<byte> value)
+		private object ParseDateTime(ReadOnlySpan<byte> value)
 		{
 			if (!Utf8Parser.TryParse(value, out int year, out var bytesConsumed) || bytesConsumed != 4)
 				goto InvalidDateTime;
@@ -468,36 +477,52 @@ private DateTime ParseDateTime(ReadOnlySpan<byte> value)
 			{
 				if (Connection.ConvertZeroDateTime)
 					return DateTime.MinValue;
+				if (Connection.AllowZeroDateTime)
+					return new MySqlDateTime();
 				throw new InvalidCastException("Unable to convert MySQL date/time to System.DateTime.");
 			}
 
+			int hour, minute, second, microseconds;
 			if (value.Length == 10)
-				return new DateTime(year, month, day, 0, 0, 0, Connection.DateTimeKind);
-
-			if (value[10] != 32)
-				goto InvalidDateTime;
-			if (!Utf8Parser.TryParse(value.Slice(11), out int hour, out bytesConsumed) || bytesConsumed != 2)
-				goto InvalidDateTime;
-			if (value.Length < 14 || value[13] != 58)
-				goto InvalidDateTime;
-			if (!Utf8Parser.TryParse(value.Slice(14), out int minute, out bytesConsumed) || bytesConsumed != 2)
-				goto InvalidDateTime;
-			if (value.Length < 17 || value[16] != 58)
-				goto InvalidDateTime;
-			if (!Utf8Parser.TryParse(value.Slice(17), out int second, out bytesConsumed) || bytesConsumed != 2)
-				goto InvalidDateTime;
-
-			if (value.Length == 19)
-				return new DateTime(year, month, day, hour, minute, second, Connection.DateTimeKind);
-			if (value[19] != 46)
-				goto InvalidDateTime;
+			{
+				hour = 0;
+				minute = 0;
+				second = 0;
+				microseconds = 0;
+			}
+			else
+			{
+				if (value[10] != 32)
+					goto InvalidDateTime;
+				if (!Utf8Parser.TryParse(value.Slice(11), out hour, out bytesConsumed) || bytesConsumed != 2)
+					goto InvalidDateTime;
+				if (value.Length < 14 || value[13] != 58)
+					goto InvalidDateTime;
+				if (!Utf8Parser.TryParse(value.Slice(14), out minute, out bytesConsumed) || bytesConsumed != 2)
+					goto InvalidDateTime;
+				if (value.Length < 17 || value[16] != 58)
+					goto InvalidDateTime;
+				if (!Utf8Parser.TryParse(value.Slice(17), out second, out bytesConsumed) || bytesConsumed != 2)
+					goto InvalidDateTime;
+
+				if (value.Length == 19)
+				{
+					microseconds = 0;
+				}
+				else
+				{
+					if (value[19] != 46)
+						goto InvalidDateTime;
 
-			if (!Utf8Parser.TryParse(value.Slice(20), out int microseconds, out bytesConsumed) || bytesConsumed != value.Length - 20)
-				goto InvalidDateTime;
-			for (; bytesConsumed < 6; bytesConsumed++)
-				microseconds *= 10;
+					if (!Utf8Parser.TryParse(value.Slice(20), out microseconds, out bytesConsumed) || bytesConsumed != value.Length - 20)
+						goto InvalidDateTime;
+					for (; bytesConsumed < 6; bytesConsumed++)
+						microseconds *= 10;
+				}
+			}
 
-			return new DateTime(year, month, day, hour, minute, second, microseconds / 1000, Connection.DateTimeKind).AddTicks(microseconds % 1000 * 10);
+			var dt = new DateTime(year, month, day, hour, minute, second, microseconds / 1000, Connection.DateTimeKind).AddTicks(microseconds % 1000 * 10);
+			return Connection.AllowZeroDateTime ? (object) new MySqlDateTime(dt) : dt;
 
 InvalidDateTime:
 			throw new FormatException("Couldn't interpret '{0}' as a valid DateTime".FormatInvariant(Encoding.UTF8.GetString(value)));
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnection.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnection.cs
@@ -346,6 +346,7 @@ internal async Task<CachedProcedure> GetCachedProcedure(IOBehavior ioBehavior, s
 
 		internal MySqlTransaction CurrentTransaction { get; set; }
 		internal bool AllowUserVariables => m_connectionSettings.AllowUserVariables;
+		internal bool AllowZeroDateTime => m_connectionSettings.AllowZeroDateTime;
 		internal bool ConvertZeroDateTime => m_connectionSettings.ConvertZeroDateTime;
 		internal DateTimeKind DateTimeKind => m_connectionSettings.DateTimeKind;
 		internal int DefaultCommandTimeout => GetConnectionSettings().DefaultCommandTimeout;
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnectionStringBuilder.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnectionStringBuilder.cs
@@ -147,6 +147,12 @@ public bool AllowUserVariables
 			set => MySqlConnectionStringOption.AllowUserVariables.SetValue(this, value);
 		}
 
+		public bool AllowZeroDateTime
+		{
+			get => MySqlConnectionStringOption.AllowZeroDateTime.GetValue(this);
+			set => MySqlConnectionStringOption.AllowZeroDateTime.SetValue(this, value);
+		}
+
 		public bool AutoEnlist
 		{
 			get => MySqlConnectionStringOption.AutoEnlist.GetValue(this);
@@ -322,6 +328,7 @@ internal abstract class MySqlConnectionStringOption
 		// Other Options
 		public static readonly MySqlConnectionStringOption<bool> AllowPublicKeyRetrieval;
 		public static readonly MySqlConnectionStringOption<bool> AllowUserVariables;
+		public static readonly MySqlConnectionStringOption<bool> AllowZeroDateTime;
 		public static readonly MySqlConnectionStringOption<bool> AutoEnlist;
 		public static readonly MySqlConnectionStringOption<string> CharacterSet;
 		public static readonly MySqlConnectionStringOption<uint> ConnectionTimeout;
@@ -454,6 +461,10 @@ static MySqlConnectionStringOption()
 				keys: new[] { "AllowUserVariables", "Allow User Variables" },
 				defaultValue: false));
 
+			AddOption(AllowZeroDateTime = new MySqlConnectionStringOption<bool>(
+				keys: new[] { "AllowZeroDateTime", "Allow Zero DateTime" },
+				defaultValue: false));
+
 			AddOption(AutoEnlist = new MySqlConnectionStringOption<bool>(
 				keys: new[] { "AutoEnlist", "Auto Enlist" },
 				defaultValue: true));
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlDataReader.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlDataReader.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MySql.Data.Types;
 using MySqlConnector.Core;
 using MySqlConnector.Protocol.Serialization;
 using MySqlConnector.Utilities;
@@ -224,6 +225,9 @@ public override long GetChars(int ordinal, long dataOffset, char[] buffer, int b
 		public DateTimeOffset GetDateTimeOffset(int ordinal) => GetResultSet().GetCurrentRow().GetDateTimeOffset(ordinal);
 		public DateTimeOffset GetDateTimeOffset(string name) => GetDateTimeOffset(GetOrdinal(name));
 
+		public MySqlDateTime GetMySqlDateTime(int ordinal) => GetResultSet().GetCurrentRow().GetMySqlDateTime(ordinal);
+		public MySqlDateTime GetMySqlDateTime(string name) => GetMySqlDateTime(GetOrdinal(name));
+
 		public TimeSpan GetTimeSpan(int ordinal) => (TimeSpan) GetValue(ordinal);
 		public TimeSpan GetTimeSpan(string name) => GetTimeSpan(GetOrdinal(name));
 
@@ -270,7 +274,7 @@ public override void Close()
 		public ReadOnlyCollection<DbColumn> GetColumnSchema()
 		{
 			return GetResultSet().ColumnDefinitions
-				.Select((c, n) => (DbColumn) new MySqlDbColumn(n, c, GetResultSet().ColumnTypes[n]))
+				.Select((c, n) => (DbColumn) new MySqlDbColumn(n, c, Connection.AllowZeroDateTime, GetResultSet().ColumnTypes[n]))
 				.ToList().AsReadOnly();
 		}
 
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlDbColumn.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlDbColumn.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using MySql.Data.Types;
 using MySqlConnector.Core;
 using MySqlConnector.Protocol;
 using MySqlConnector.Protocol.Payloads;
@@ -42,7 +43,7 @@ namespace MySql.Data.MySqlClient
 {
 	public sealed class MySqlDbColumn : System.Data.Common.DbColumn
 	{
-		internal MySqlDbColumn(int ordinal, ColumnDefinitionPayload column, MySqlDbType mySqlDbType)
+		internal MySqlDbColumn(int ordinal, ColumnDefinitionPayload column, bool allowZeroDateTime, MySqlDbType mySqlDbType)
 		{
 			var columnTypeMetadata = TypeMapper.Instance.GetColumnTypeMetadata(mySqlDbType);
 
@@ -59,7 +60,7 @@ internal MySqlDbColumn(int ordinal, ColumnDefinitionPayload column, MySqlDbType
 			ColumnName = column.Name;
 			ColumnOrdinal = ordinal;
 			ColumnSize = columnSize > int.MaxValue ? int.MaxValue : unchecked((int) columnSize);
-			DataType = type;
+			DataType = (allowZeroDateTime && type == typeof(DateTime)) ? typeof(MySqlDateTime) : type;
 			DataTypeName = columnTypeMetadata.SimpleDataTypeName;
 			if (mySqlDbType == MySqlDbType.String)
 				DataTypeName += string.Format(CultureInfo.InvariantCulture, "({0})", columnSize);
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlParameter.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlParameter.cs
@@ -3,6 +3,7 @@
 using System.Data;
 using System.Data.Common;
 using System.Diagnostics;
+using MySql.Data.Types;
 using MySqlConnector.Core;
 using MySqlConnector.Protocol.Serialization;
 using MySqlConnector.Utilities;
@@ -266,6 +267,13 @@ internal void AppendSqlString(ByteBufferWriter writer, StatementPreparerOptions
 				// NOTE: Utf8Formatter doesn't support "R"
 				writer.Write("{0:R}".FormatInvariant(Value));
 			}
+			else if (Value is MySqlDateTime mySqlDateTimeValue)
+			{
+				if (mySqlDateTimeValue.IsValidDateTime)
+					writer.Write("timestamp('{0:yyyy'-'MM'-'dd' 'HH':'mm':'ss'.'ffffff}')".FormatInvariant(mySqlDateTimeValue.GetDateTime()));
+				else
+					writer.Write("timestamp('0000-00-00')");
+			}
 			else if (Value is DateTime dateTimeValue)
 			{
 				if ((options & StatementPreparerOptions.DateTimeUtc) != 0 && dateTimeValue.Kind == DateTimeKind.Local)
diff --git a/src/MySqlConnector/MySql.Data.Types/MySqlConversionException.cs b/src/MySqlConnector/MySql.Data.Types/MySqlConversionException.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace MySql.Data.Types
+{
+	public class MySqlConversionException : Exception
+	{
+		public MySqlConversionException(string message)
+			: base(message)
+		{
+		}
+	}
+}
diff --git a/src/MySqlConnector/MySql.Data.Types/MySqlDateTime.cs b/src/MySqlConnector/MySql.Data.Types/MySqlDateTime.cs
@@ -0,0 +1,90 @@
+using System;
+
+namespace MySql.Data.Types
+{
+	public struct MySqlDateTime : IComparable
+	{
+		public MySqlDateTime(int year, int month, int day, int hour, int minute, int second, int microsecond)
+		{
+			Year = year;
+			Month = month;
+			Day = day;
+			Hour = hour;
+			Minute = minute;
+			Second = second;
+			Microsecond = microsecond;
+		}
+
+		public MySqlDateTime(DateTime dt)
+			: this(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, (int) (dt.Ticks % 10_000_000) / 10)
+		{
+		}
+
+		public MySqlDateTime(MySqlDateTime other)
+		{
+			Year = other.Year;
+			Month = other.Month;
+			Day = other.Day;
+			Hour = other.Hour;
+			Minute = other.Minute;
+			Second = other.Second;
+			Microsecond = other.Microsecond;
+		}
+
+		public bool IsValidDateTime => Year != 0 && Month != 0 && Day != 0;
+
+		public int Year { get; set; }
+		public int Month { get; set; }
+		public int Day { get; set; }
+		public int Hour { get; set; }
+		public int Minute { get; set; }
+		public int Second { get; set; }
+		public int Microsecond { get; set; }
+
+		public int Millisecond
+		{
+			get => Microsecond / 1000;
+			set => Microsecond = value * 1000;
+		}
+
+		public DateTime GetDateTime() =>
+			!IsValidDateTime ? throw new MySqlConversionException("Cannot convert MySqlDateTime to DateTime when IsValidDateTime is false.") : 
+				new DateTime(Year, Month, Day, Hour, Minute, Second, DateTimeKind.Unspecified).AddTicks(Microsecond * 10);
+
+		public override string ToString() => IsValidDateTime ? GetDateTime().ToString() : "0000-00-00";
+
+		public static explicit operator DateTime(MySqlDateTime val) => !val.IsValidDateTime ? DateTime.MinValue : val.GetDateTime();
+
+		int IComparable.CompareTo(object obj)
+		{
+			if (!(obj is MySqlDateTime other))
+				throw new ArgumentException("CompareTo can only be called with another MySqlDateTime", nameof(obj));
+
+			if (Year < other.Year)
+				return -1;
+			if (Year > other.Year)
+				return 1;
+			if (Month < other.Month)
+				return -1;
+			if (Month > other.Month)
+				return 1;
+			if (Day < other.Day)
+				return -1;
+			if (Day > other.Day)
+				return 1;
+			if (Hour < other.Hour)
+				return -1;
+			if (Hour > other.Hour)
+				return 1;
+			if (Minute < other.Minute)
+				return -1;
+			if (Minute > other.Minute)
+				return 1;
+			if (Second < other.Second)
+				return -1;
+			if (Second > other.Second)
+				return 1;
+			return Microsecond.CompareTo(other.Microsecond);
+		}
+	}
+}
diff --git a/tests/MySqlConnector.Tests/MySqlConnectionStringBuilderTests.cs b/tests/MySqlConnector.Tests/MySqlConnectionStringBuilderTests.cs
diff --git a/tests/MySqlConnector.Tests/MySqlDateTimeTests.cs b/tests/MySqlConnector.Tests/MySqlDateTimeTests.cs
diff --git a/tests/SideBySide/DataTypes.cs b/tests/SideBySide/DataTypes.cs
diff --git a/tests/SideBySide/InsertTests.cs b/tests/SideBySide/InsertTests.cs
