Fix type validation.

teo-tsirpanis · teo-tsirpanis · commit bbcbb947e61a · 2023-03-10T18:12:58.000+02:00
diff --git a/sources/TileDB.CSharp/Array.cs b/sources/TileDB.CSharp/Array.cs
@@ -498,14 +498,14 @@ static void GetDomain<T>(Array array, string dimName, uint i, NonEmptyDomain non
         /// <exception cref="ArgumentException"><typeparamref name="T"/> is not the dimension's type.</exception>
         public (T Start, T End, bool IsEmpty) NonEmptyDomain<T>(uint index) where T : struct
         {
-            var datatype = EnumUtil.TypeToDataType(typeof(T));
             using (var schema = Schema())
             using (var domain = schema.Domain())
             using (var dimension = domain.Dimension(index))
             {
-                if (datatype != dimension.Type())
+                var datatype = dimension.Type();
+                if (EnumUtil.DataTypeToType(datatype) != typeof(T))
                 {
-                    throw new ArgumentException("Array.NonEmptyDomain, not valid datatype!");
+                    ThrowHelpers.ThrowTypeMismatch(datatype);
                 }
             }
 
@@ -528,14 +528,14 @@ static void GetDomain<T>(Array array, string dimName, uint i, NonEmptyDomain non
         /// <exception cref="ArgumentException"><typeparamref name="T"/> is not the dimension's type.</exception>
         public (T Start, T End, bool IsEmpty) NonEmptyDomain<T>(string name) where T : struct
         {
-            var datatype = EnumUtil.TypeToDataType(typeof(T));
             using (var schema = Schema())
             using (var domain = schema.Domain())
             using (var dimension = domain.Dimension(name))
             {
-                if (datatype != dimension.Type())
+                var datatype = dimension.Type();
+                if (EnumUtil.DataTypeToType(datatype) != typeof(T))
                 {
-                    throw new ArgumentException("Array.NonEmptyDomain, not valid datatype!");
+                    ThrowHelpers.ThrowTypeMismatch(datatype);
                 }
             }
 
diff --git a/sources/TileDB.CSharp/DimensionLabel.cs b/sources/TileDB.CSharp/DimensionLabel.cs
@@ -129,7 +129,7 @@ public string GetUri()
         /// <inheritdoc/>
         public void Dispose()
         {
-            throw new NotImplementedException();
+            _handle.Dispose();
         }
     }
 }
diff --git a/sources/TileDB.CSharp/FragmentInfo.cs b/sources/TileDB.CSharp/FragmentInfo.cs
@@ -651,7 +651,7 @@ private static void ValidateDomainType<T>(DataType dataType)
             {
                 ThrowHelpers.ThrowStringTypeMismatch(dataType);
             }
-            if (dataType != EnumUtil.TypeToDataType(typeof(T)))
+            if (EnumUtil.DataTypeToType(dataType) != typeof(T))
             {
                 ThrowHelpers.ThrowTypeMismatch(dataType);
             }
diff --git a/sources/TileDB.CSharp/Query.cs b/sources/TileDB.CSharp/Query.cs
@@ -913,7 +913,7 @@ public Tuple<ulong, ulong> FragmentTimestampRange(ulong idx)
 
         private void CheckDataType<T>(DataType dataType)
         {
-            if (EnumUtil.TypeToDataType(typeof(T)) != dataType)
+            if (typeof(T) != EnumUtil.DataTypeToType(dataType))
             {
                 if (!(dataType== DataType.StringAscii && (typeof(T)==typeof(byte) || typeof(T) == typeof(sbyte) || typeof(T) == typeof(string)))
                    && !(dataType == DataType.Boolean && typeof(T) == typeof(byte)))
diff --git a/sources/TileDB.CSharp/Subarray.cs b/sources/TileDB.CSharp/Subarray.cs
@@ -118,12 +118,11 @@ public void SetSubarray<T>(params T[] data) where T : struct
         public void SetSubarray<T>(ReadOnlySpan<T> data) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
-            var dataType = EnumUtil.TypeToDataType(typeof(T));
             (var domainType, var nDim) = GetDomainInfo();
 
-            if (dataType != domainType)
+            if (EnumUtil.DataTypeToType(domainType) != typeof(T))
             {
-                ThrowHelpers.ThrowTypeMismatch(dataType);
+                ThrowHelpers.ThrowTypeMismatch(domainType);
             }
             if (data.Length != nDim * 2)
             {
@@ -141,23 +140,22 @@ public void SetSubarray<T>(ReadOnlySpan<T> data) where T : struct
         private void ValidateLabelType<T>(string name) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
-            var dataType = EnumUtil.TypeToDataType(typeof(T));
             using var schema = _array.Schema();
             using var label = schema.DimensionLabel(name);
-            if (label.DataType != dataType)
+            if (EnumUtil.DataTypeToType(label.DataType) != typeof(T))
             {
-                ThrowHelpers.ThrowTypeMismatch(dataType);
+                ThrowHelpers.ThrowTypeMismatch(label.DataType);
             }
         }
 
         private void ValidateType<T>(string name) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
-            var dataType = EnumUtil.TypeToDataType(typeof(T));
             using var schema = _array.Schema();
             using var domain = schema.Domain();
             using var dimension = domain.Dimension(name);
-            if (dimension.Type() != dataType)
+            var dataType = dimension.Type();
+            if (EnumUtil.DataTypeToType(dataType) != typeof(T))
             {
                 ThrowHelpers.ThrowTypeMismatch(dataType);
             }
@@ -166,11 +164,11 @@ private void ValidateType<T>(string name) where T : struct
         private void ValidateType<T>(uint index) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
-            var dataType = EnumUtil.TypeToDataType(typeof(T));
             using var schema = _array.Schema();
             using var domain = schema.Domain();
             using var dimension = domain.Dimension(index);
-            if (dimension.Type() != dataType)
+            var dataType = dimension.Type();
+            if (EnumUtil.DataTypeToType(dataType) != typeof(T))
             {
                 ThrowHelpers.ThrowTypeMismatch(dataType);
             }

Original file line number	Diff line number	Diff line change
`@@ -498,14 +498,14 @@ static void GetDomain<T>(Array array, string dimName, uint i, NonEmptyDomain non`
`498`	`498`	`/// <exception cref="ArgumentException"><typeparamref name="T"/> is not the dimension's type.</exception>`
`499`	`499`	`public (T Start, T End, bool IsEmpty) NonEmptyDomain<T>(uint index) where T : struct`
`500`	`500`	`{`
`501`		`- var datatype = EnumUtil.TypeToDataType(typeof(T));`
`502`	`501`	`using (var schema = Schema())`
`503`	`502`	`using (var domain = schema.Domain())`
`504`	`503`	`using (var dimension = domain.Dimension(index))`
`505`	`504`	`{`
`506`		`- if (datatype != dimension.Type())`
	`505`	`+ var datatype = dimension.Type();`
	`506`	`+ if (EnumUtil.DataTypeToType(datatype) != typeof(T))`
`507`	`507`	`{`
`508`		`- throw new ArgumentException("Array.NonEmptyDomain, not valid datatype!");`
	`508`	`+ ThrowHelpers.ThrowTypeMismatch(datatype);`
`509`	`509`	`}`
`510`	`510`	`}`
`511`	`511`
`@@ -528,14 +528,14 @@ static void GetDomain<T>(Array array, string dimName, uint i, NonEmptyDomain non`
`528`	`528`	`/// <exception cref="ArgumentException"><typeparamref name="T"/> is not the dimension's type.</exception>`
`529`	`529`	`public (T Start, T End, bool IsEmpty) NonEmptyDomain<T>(string name) where T : struct`
`530`	`530`	`{`
`531`		`- var datatype = EnumUtil.TypeToDataType(typeof(T));`
`532`	`531`	`using (var schema = Schema())`
`533`	`532`	`using (var domain = schema.Domain())`
`534`	`533`	`using (var dimension = domain.Dimension(name))`
`535`	`534`	`{`
`536`		`- if (datatype != dimension.Type())`
	`535`	`+ var datatype = dimension.Type();`
	`536`	`+ if (EnumUtil.DataTypeToType(datatype) != typeof(T))`
`537`	`537`	`{`
`538`		`- throw new ArgumentException("Array.NonEmptyDomain, not valid datatype!");`
	`538`	`+ ThrowHelpers.ThrowTypeMismatch(datatype);`
`539`	`539`	`}`
`540`	`540`	`}`
`541`	`541`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ public string GetUri()`
`129`	`129`	`/// <inheritdoc/>`
`130`	`130`	`public void Dispose()`
`131`	`131`	`{`
`132`		`- throw new NotImplementedException();`
	`132`	`+ _handle.Dispose();`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -651,7 +651,7 @@ private static void ValidateDomainType<T>(DataType dataType)`
`651`	`651`	`{`
`652`	`652`	`ThrowHelpers.ThrowStringTypeMismatch(dataType);`
`653`	`653`	`}`
`654`		`- if (dataType != EnumUtil.TypeToDataType(typeof(T)))`
	`654`	`+ if (EnumUtil.DataTypeToType(dataType) != typeof(T))`
`655`	`655`	`{`
`656`	`656`	`ThrowHelpers.ThrowTypeMismatch(dataType);`
`657`	`657`	`}`
Original file line number	Diff line number	Diff line change
`@@ -913,7 +913,7 @@ public Tuple<ulong, ulong> FragmentTimestampRange(ulong idx)`
`913`	`913`
`914`	`914`	`private void CheckDataType<T>(DataType dataType)`
`915`	`915`	`{`
`916`		`- if (EnumUtil.TypeToDataType(typeof(T)) != dataType)`
	`916`	`+ if (typeof(T) != EnumUtil.DataTypeToType(dataType))`
`917`	`917`	`{`
`918`	`918`	`if (!(dataType== DataType.StringAscii && (typeof(T)==typeof(byte) \|\| typeof(T) == typeof(sbyte) \|\| typeof(T) == typeof(string)))`
`919`	`919`	`&& !(dataType == DataType.Boolean && typeof(T) == typeof(byte)))`
Original file line number	Diff line number	Diff line change
`@@ -118,12 +118,11 @@ public void SetSubarray<T>(params T[] data) where T : struct`
`118`	`118`	`public void SetSubarray<T>(ReadOnlySpan<T> data) where T : struct`
`119`	`119`	`{`
`120`	`120`	`ErrorHandling.ThrowIfManagedType<T>();`
`121`		`- var dataType = EnumUtil.TypeToDataType(typeof(T));`
`122`	`121`	`(var domainType, var nDim) = GetDomainInfo();`
`123`	`122`
`124`		`- if (dataType != domainType)`
	`123`	`+ if (EnumUtil.DataTypeToType(domainType) != typeof(T))`
`125`	`124`	`{`
`126`		`- ThrowHelpers.ThrowTypeMismatch(dataType);`
	`125`	`+ ThrowHelpers.ThrowTypeMismatch(domainType);`
`127`	`126`	`}`
`128`	`127`	`if (data.Length != nDim * 2)`
`129`	`128`	`{`
`@@ -141,23 +140,22 @@ public void SetSubarray<T>(ReadOnlySpan<T> data) where T : struct`
`141`	`140`	`private void ValidateLabelType<T>(string name) where T : struct`
`142`	`141`	`{`
`143`	`142`	`ErrorHandling.ThrowIfManagedType<T>();`
`144`		`- var dataType = EnumUtil.TypeToDataType(typeof(T));`
`145`	`143`	`using var schema = _array.Schema();`
`146`	`144`	`using var label = schema.DimensionLabel(name);`
`147`		`- if (label.DataType != dataType)`
	`145`	`+ if (EnumUtil.DataTypeToType(label.DataType) != typeof(T))`
`148`	`146`	`{`
`149`		`- ThrowHelpers.ThrowTypeMismatch(dataType);`
	`147`	`+ ThrowHelpers.ThrowTypeMismatch(label.DataType);`
`150`	`148`	`}`
`151`	`149`	`}`
`152`	`150`
`153`	`151`	`private void ValidateType<T>(string name) where T : struct`
`154`	`152`	`{`
`155`	`153`	`ErrorHandling.ThrowIfManagedType<T>();`
`156`		`- var dataType = EnumUtil.TypeToDataType(typeof(T));`
`157`	`154`	`using var schema = _array.Schema();`
`158`	`155`	`using var domain = schema.Domain();`
`159`	`156`	`using var dimension = domain.Dimension(name);`
`160`		`- if (dimension.Type() != dataType)`
	`157`	`+ var dataType = dimension.Type();`
	`158`	`+ if (EnumUtil.DataTypeToType(dataType) != typeof(T))`
`161`	`159`	`{`
`162`	`160`	`ThrowHelpers.ThrowTypeMismatch(dataType);`
`163`	`161`	`}`
`@@ -166,11 +164,11 @@ private void ValidateType<T>(string name) where T : struct`
`166`	`164`	`private void ValidateType<T>(uint index) where T : struct`
`167`	`165`	`{`
`168`	`166`	`ErrorHandling.ThrowIfManagedType<T>();`
`169`		`- var dataType = EnumUtil.TypeToDataType(typeof(T));`
`170`	`167`	`using var schema = _array.Schema();`
`171`	`168`	`using var domain = schema.Domain();`
`172`	`169`	`using var dimension = domain.Dimension(index);`
`173`		`- if (dimension.Type() != dataType)`
	`170`	`+ var dataType = dimension.Type();`
	`171`	`+ if (EnumUtil.DataTypeToType(dataType) != typeof(T))`
`174`	`172`	`{`
`175`	`173`	`ThrowHelpers.ThrowTypeMismatch(dataType);`
`176`	`174`	`}`