Issue-2: added support for bool, int, uint, byte, sbyte, short, ushort, long, ulong, fload, double, string

Author: messieurMe

src/EfCore.Ydb/src/Storage/Internal/Mapping/YdbBoolTypeMapping.cs

@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace EfCore.Ydb.Storage.Internal.Mapping;
+
+public class YdbBoolTypeMapping : BoolTypeMapping
+{
+    public new static YdbBoolTypeMapping Default { get; } = new();
+
+    public YdbBoolTypeMapping() : base("BOOL")
+    {
+    }
+
+    protected YdbBoolTypeMapping(RelationalTypeMappingParameters parameters)
+        : base(parameters)
+    {
+    }
+
+    protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters)
+        => new YdbBoolTypeMapping(parameters);
+
+    protected override string GenerateNonNullSqlLiteral(object value)
+        => (bool)value ? "true" : "false";
+}

src/EfCore.Ydb/src/Storage/Internal/YdbTypeMappingSource.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Data;
+using EfCore.Ydb.Storage.Internal.Mapping;
 using Microsoft.EntityFrameworkCore.Storage;
 
 namespace EfCore.Ydb.Storage.Internal;
@@ -13,7 +14,22 @@ public class YdbTypeMappingSource : RelationalTypeMappingSource
 
     #region Mappings
 
+    private readonly YdbBoolTypeMapping _bool = YdbBoolTypeMapping.Default;
+
+    private readonly SByteTypeMapping _int8 = new("INT8", DbType.Byte);
+    private readonly ShortTypeMapping _int16 = new("INT16", DbType.Int16);
     private readonly IntTypeMapping _int32 = new("INT32", DbType.Int32);
+    private readonly LongTypeMapping _int64 = new("INT64", DbType.Int64);
+
+    private readonly ByteTypeMapping _uint8 = new("UINT8", DbType.SByte);
+    private readonly UShortTypeMapping _uint16 = new("UINT16", DbType.UInt16);
+    private readonly UIntTypeMapping _uint32 = new("UINT32", DbType.UInt32);
+    private readonly ULongTypeMapping _uint64 = new("UINT64", DbType.UInt64);
+
+    private readonly FloatTypeMapping _float = new("FLOAT", DbType.Single);
+    private readonly DoubleTypeMapping _double = new("DOUBLE", DbType.Double);
+
+    private readonly StringTypeMapping _string = new("STRING", DbType.String);
 
     #endregion
 
@@ -24,11 +40,41 @@ RelationalTypeMappingSourceDependencies relationalDependencies
     {
         var storeTypeMappings = new Dictionary<string, RelationalTypeMapping[]>(StringComparer.OrdinalIgnoreCase)
         {
-            { "integer", [_int32] }
+            { "bool", [_bool] },
+
+            { "int8", [_int8] },
+            { "int16", [_int16] },
+            { "int32", [_int32] },
+            { "int64", [_int64] },
+
+            { "uint8", [_uint8] },
+            { "uint16", [_uint16] },
+            { "uint32", [_uint32] },
+            { "uint64", [_uint64] },
+
+            { "float", [_float] },
+            { "double", [_double] },
+
+            { "string", [_string] }
         };
         var clrTypeMappings = new Dictionary<Type, RelationalTypeMapping>
         {
-            { typeof(int), _int32 }
+            { typeof(bool), _bool },
+
+            { typeof(sbyte), _int8 },
+            { typeof(short), _int16 },
+            { typeof(int), _int32 },
+            { typeof(long), _int64 },
+
+            { typeof(byte), _uint8 },
+            { typeof(ushort), _uint16 },
+            { typeof(uint), _uint32 },
+            { typeof(ulong), _uint64 },
+
+            { typeof(float), _float },
+            { typeof(double), _double },
+
+            { typeof(string), _string }
         };
 
         StoreTypeMapping = new ConcurrentDictionary<string, RelationalTypeMapping[]>(storeTypeMappings);
@@ -66,7 +112,6 @@ RelationalTypeMappingSourceDependencies relationalDependencies
                 return mapping;
             }
         }
-
         return null;
     }
 }