Implement robust ParseDataType to skip unknown elements.

MySQL documentation is not strict about DTD_IDENTIFIER field.
It says: The DTD_IDENTIFIER value contains the type name and
possibly other information such as the precision or length.
So we should not fail on additional elements appearing after
the type and parse only known stuff.

Signed-off-by: Carl Sverre <[email protected]>

Author: Carl Sverre

src/MySqlConnector/Core/CachedProcedure.cs

@@ -194,14 +194,6 @@ internal static List<CachedParameter> ParseParameters(string parametersSql)
 
 		internal static string ParseDataType(string sql, out bool unsigned, out int length)
 		{
-			if (sql.EndsWith(" ZEROFILL", StringComparison.OrdinalIgnoreCase))
-				sql = sql.Substring(0, sql.Length - 9);
-			unsigned = false;
-			if (sql.EndsWith(" UNSIGNED", StringComparison.OrdinalIgnoreCase))
-			{
-				unsigned = true;
-				sql = sql.Substring(0, sql.Length - 9);
-			}
 			sql = Regex.Replace(sql, " (CHARSET|CHARACTER SET) [A-Za-z0-9_]+", "", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
 			sql = Regex.Replace(sql, " (COLLATE) [A-Za-z0-9_]+", "", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
 			sql = Regex.Replace(sql, @"ENUM\s*\([^)]+\)", "ENUM", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
@@ -214,40 +206,40 @@ internal static string ParseDataType(string sql, out bool unsigned, out int leng
 				sql = Regex.Replace(sql, @"\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\)", "");
 			}
 
-			sql = sql.Trim();
-
-			// normalize alternate data type names
-			if (sql.Equals("BOOL", StringComparison.OrdinalIgnoreCase) || sql.Equals("BOOLEAN", StringComparison.OrdinalIgnoreCase))
-			{
-				sql = "TINYINT";
-				length = 1;
-			}
-			else if (sql.Equals("INTEGER", StringComparison.OrdinalIgnoreCase))
-			{
-				sql = "INT";
-			}
-			else if (sql.Equals("NUMERIC", StringComparison.OrdinalIgnoreCase) || sql.Equals("FIXED", StringComparison.OrdinalIgnoreCase))
-			{
-				sql = "DECIMAL";
-			}
-			else if (sql.Equals("REAL", StringComparison.OrdinalIgnoreCase) || sql.Equals("DOUBLE PRECISION", StringComparison.OrdinalIgnoreCase))
+			var typeMapping = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
 			{
-				sql = "DOUBLE";
-			}
-			else if (sql.Equals("NVARCHAR", StringComparison.OrdinalIgnoreCase) || sql.Equals("CHARACTER VARYING", StringComparison.OrdinalIgnoreCase) || sql.Equals("NATIONAL VARCHAR", StringComparison.OrdinalIgnoreCase))
-			{
-				sql = "VARCHAR";
-			}
-			else if (sql.Equals("NCHAR", StringComparison.OrdinalIgnoreCase) || sql.Equals("CHARACTER", StringComparison.OrdinalIgnoreCase) || sql.Equals("NATIONAL CHAR", StringComparison.OrdinalIgnoreCase))
-			{
-				sql = "CHAR";
-			}
-			else if (sql.Equals("CHAR BYTE", StringComparison.OrdinalIgnoreCase))
+				{"BOOL", "TINYINT"},
+				{"BOOLEAN", "TINYINT"},
+				{"INTEGER", "INT"},
+				{"NUMERIC", "DECIMAL"},
+				{"FIXED", "DECIMAL"},
+				{"REAL", "DOUBLE"},
+				{"DOUBLE PRECISION", "DOUBLE"},
+				{"NVARCHAR", "VARCHAR"},
+				{"CHARACTER VARYING", "VARCHAR"},
+				{"NATIONAL VARCHAR", "VARCHAR"},
+				{"NCHAR", "CHAR"},
+				{"CHARACTER", "CHAR"},
+				{"NATIONAL CHAR", "CHAR"},
+				{"CHAR BYTE", "BINARY"}
+			};
+
+			var list = sql.Trim().Split(new char[] {' '});
+			var type = string.Empty;
+
+			if (list.Length < 2 || !typeMapping.TryGetValue(list[0] + ' ' + list[1], out type))
 			{
-				sql = "BINARY";
+				if (typeMapping.TryGetValue(list[0], out type))
+				{
+					if (list[0].StartsWith("BOOL", StringComparison.OrdinalIgnoreCase))
+					{
+						length = 1;
+					}
+				}
 			}
 
-			return sql;
+			unsigned = list.Contains("UNSIGNED", StringComparer.OrdinalIgnoreCase);
+			return type ?? list[0];
 		}
 
 		private static CachedParameter CreateCachedParameter(int ordinal, string? direction, string name, string dataType, bool unsigned, int length, string originalSql)

tests/MySqlConnector.Tests/CachedProcedureTests.cs

@@ -166,7 +166,7 @@ param5 bigint(20) unsigned zerofill,
 param1 boolean,
 param2 nvarchar,
 param3 real(20,10),
-	-- ignored INT	
+	-- ignored INT
 param4 INTEGER(3)
 ",
 					new object[]
@@ -183,20 +183,33 @@ param4 INTEGER(3)
 		[Theory]
 		[InlineData("INT", "INT", false, 0)]
 		[InlineData("INTEGER", "INT", false, 0)]
+		[InlineData("INTEGER UNSIGNED", "INT", true, 0)]
 		[InlineData("INT(11)", "INT", false, 11)]
 		[InlineData("INTEGER(11)", "INT", false, 11)]
 		[InlineData("INT(11) UNSIGNED", "INT", true, 11)]
+		[InlineData("INT(11) UNSIGNED NOT NULL", "INT", true, 11)]
+		[InlineData("INT(11) UNSIGNED NULL", "INT", true, 11)]
+		[InlineData("INT(11) UNSIGNED NULL DEFAULT NULL", "INT", true, 11)]
 		[InlineData("INT(11) ZEROFILL", "INT", false, 11)]
 		[InlineData("INT(11) UNSIGNED ZEROFILL", "INT", true, 11)]
 		[InlineData("BIGINT(20)", "BIGINT", false, 20)]
 		[InlineData("TINYINT(1) UNSIGNED", "TINYINT", true, 1)]
 		[InlineData("BOOL", "TINYINT", false, 1)]
+		[InlineData("Bool", "TINYINT", false, 1)]
 		[InlineData("NUMERIC(30,20)", "DECIMAL", false, 30)]
 		[InlineData("VARCHAR(300)", "VARCHAR", false, 300)]
 		[InlineData("VARCHAR(300) CHARSET utf8mb4", "VARCHAR", false, 300)]
 		[InlineData("VARCHAR(300) COLLATE ascii_general_ci", "VARCHAR", false, 300)]
+		[InlineData("VARCHAR(300) COLLATE ascii_general_ci NOT NULL DEFAULT 'test'", "VARCHAR", false, 300)]
+		[InlineData("CHARACTER VARYING(300) COLLATE ascii_general_ci NOT NULL DEFAULT 'test'", "VARCHAR", false, 300)]
+		[InlineData("NATIONAL VARCHAR(50) COLLATE ascii_general_ci NOT NULL DEFAULT 'test'", "VARCHAR", false, 50)]
 		[InlineData("BINARY(16)", "BINARY", false, 16)]
+		[InlineData("CHAR BYTE(16)", "BINARY", false, 16)]
 		[InlineData("CHAR(36)", "CHAR", false, 36)]
+		[InlineData("REAL", "DOUBLE", false, 0)]
+		[InlineData("REAL NOT NULL DEFAULT 0", "DOUBLE", false, 0)]
+		[InlineData("NUMERIC(12)", "DECIMAL", false, 12)]
+		[InlineData("FIXED(12)", "DECIMAL", false, 12)]
 		[InlineData("ENUM('a','b','c')", "ENUM", false, 0)]
 		public void ParseDataType(string sql, string expectedDataType, bool expectedUnsigned, int expectedLength)
 		{