Merge branch 'master' of https://github.com/linq2db/linq2db.EntityFrameworkCore

Author: sdanyliv

Directory.Packages.props

@@ -5,8 +5,8 @@
 		<PackageVersion Include="NUnit" Version="3.13.3" />
 		<PackageVersion Include="FluentAssertions" Version="6.10.0" />
 
-		<PackageVersion Include="linq2db" Version="5.0.0" />
-		<PackageVersion Include="linq2db.Tools" Version="5.0.0" />
+		<PackageVersion Include="linq2db" Version="5.1.0" />
+		<PackageVersion Include="linq2db.Tools" Version="5.1.0" />
 
 		<PackageVersion Include="Microsoft.SourceLink.GitHub" Version="1.1.1" />
 

NuGet.config

@@ -1,12 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
 	<packageSources>
-		<add key="NuGet" value="https://api.nuget.org/v3/index.json" />
-		<add key="linq2db" value="https://pkgs.dev.azure.com/linq2db/linq2db/_packaging/linq2db/nuget/v3/index.json" />
+		<clear />
+		<add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
 	</packageSources>
-	<packageSourceMapping>
-		<packageSource key="NuGet">
-			<package pattern="*" />
-		</packageSource>
-	</packageSourceMapping>
 </configuration>

NuGet/linq2db.EntityFrameworkCore.nuspec

@@ -16,7 +16,7 @@
 		<dependencies>
 			<group targetFramework="net6.0">
 				<dependency id="Microsoft.EntityFrameworkCore.Relational" version="7.0.0" />
-				<dependency id="linq2db" version="5.0.0" />
+				<dependency id="linq2db" version="5.1.0" />
 			</group>
 		</dependencies>
 	</metadata>

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFToolsImplDefault.cs

@@ -560,6 +560,13 @@ public virtual MappingSchema GetMappingSchema(
 
 		static readonly MethodInfo ToSql = MemberHelper.MethodOfGeneric(() => Sql.ToSql(1));
 
+		private static readonly MethodInfo AsSqlServerTable    = MemberHelper.MethodOfGeneric<ITable<object>>(q => DataProvider.SqlServer.SqlServerTools.AsSqlServer(q));
+		private static readonly MethodInfo TemporalAsOfTable   = MemberHelper.MethodOfGeneric<ISqlServerSpecificTable<object>>(t => SqlServerHints.TemporalTableAsOf(t, default));
+		private static readonly MethodInfo TemporalFromTo      = MemberHelper.MethodOfGeneric<ISqlServerSpecificTable<object>>(t => SqlServerHints.TemporalTableFromTo(t, default, default));
+		private static readonly MethodInfo TemporalBetween     = MemberHelper.MethodOfGeneric<ISqlServerSpecificTable<object>>(t => SqlServerHints.TemporalTableBetween(t, default, default));
+		private static readonly MethodInfo TemporalContainedIn = MemberHelper.MethodOfGeneric<ISqlServerSpecificTable<object>>(t => SqlServerHints.TemporalTableContainedIn(t, default, default));
+		private static readonly MethodInfo TemporalAll         = MemberHelper.MethodOfGeneric<ISqlServerSpecificTable<object>>(t => SqlServerHints.TemporalTableAll(t));
+
 		/// <summary>
 		/// Removes conversions from expression.
 		/// </summary>
@@ -726,6 +733,27 @@ static List<Expression> CompactTree(List<Expression> items, ExpressionType nodeT
 			return result;
 		}
 
+		/// <summary>
+		/// Gets current property value via reflection.
+		/// </summary>
+		/// <typeparam name="TValue">Property value type.</typeparam>
+		/// <param name="obj">Object instance</param>
+		/// <param name="propName">Property name</param>
+		/// <returns>Property value.</returns>
+		/// <exception cref="InvalidOperationException"></exception>
+		protected static TValue GetPropValue<TValue>(object obj, string propName)
+		{
+			var prop = obj.GetType().GetProperty(propName);
+			if (prop == null)
+			{
+				throw new InvalidOperationException($"Property {obj.GetType().Name}.{propName} not found.");
+			}
+			var propValue = prop.GetValue(obj);
+			if (propValue == default)
+				return default!;
+			return (TValue)propValue;
+		}
+
 		/// <summary>
 		/// Transforms EF Core expression tree to LINQ To DB expression.
 		/// Method replaces EF Core <see cref="EntityQueryable{TResult}"/> instances with LINQ To DB
@@ -948,19 +976,12 @@ TransformInfo LocalTransform(Expression e)
 
 					case ExpressionType.Extension:
 					{
-						if (dc != null && e is FromSqlQueryRootExpression fromSqlQueryRoot)
-						{
-							//convert the arguments from the FromSqlOnQueryable method from EF, to a L2DB FromSql call
-							return new TransformInfo(Expression.Call(null,
-								L2DBFromSqlMethodInfo.MakeGenericMethod(fromSqlQueryRoot.EntityType.ClrType),
-								Expression.Constant(dc),
-								Expression.New(RawSqlStringConstructor, Expression.Constant(fromSqlQueryRoot.Sql)),
-								fromSqlQueryRoot.Argument));
-						}
-						else if (dc != null && e is EntityQueryRootExpression queryRoot)
+						if (dc != null)
 						{
-							var newExpr = Expression.Call(null, Methods.LinqToDB.GetTable.MakeGenericMethod(queryRoot.EntityType.ClrType), Expression.Constant(dc));
-							return new TransformInfo(newExpr);
+							if (e is QueryRootExpression queryRoot)
+							{
+								return new TransformInfo(TransformQueryRootExpression(dc, queryRoot));
+							}
 						}
 
 						break;
@@ -982,6 +1003,97 @@ TransformInfo LocalTransform(Expression e)
 			return newExpression;
 		}
 
+		/// <summary>
+		/// Transforms <see cref="QueryRootExpression"/> descendants to linq2db analogue. Handles Temporal tables also.
+		/// </summary>
+		/// <param name="dc">Data context.</param>
+		/// <param name="queryRoot">Query root expression</param>
+		/// <returns>Transformed expression.</returns>
+		protected virtual Expression TransformQueryRootExpression(IDataContext dc, QueryRootExpression queryRoot)
+		{
+			static Expression GetAsOfSqlServer(Expression getTableExpr, Type entityType)
+			{
+				return Expression.Call(
+					AsSqlServerTable.MakeGenericMethod(entityType),
+					getTableExpr);
+			}
+
+			if (queryRoot is FromSqlQueryRootExpression fromSqlQueryRoot)
+			{
+				//convert the arguments from the FromSqlOnQueryable method from EF, to a L2DB FromSql call
+				return Expression.Call(null,
+					L2DBFromSqlMethodInfo.MakeGenericMethod(fromSqlQueryRoot.EntityType.ClrType),
+					Expression.Constant(dc),
+					Expression.New(RawSqlStringConstructor, Expression.Constant(fromSqlQueryRoot.Sql)),
+					fromSqlQueryRoot.Argument);
+			}
+
+			var entityType = queryRoot.ElementType;
+			var getTableExpr = Expression.Call(null, Methods.LinqToDB.GetTable.MakeGenericMethod(entityType),
+				Expression.Constant(dc));
+
+			var expressionTypeName = queryRoot.GetType().Name;
+			if (expressionTypeName == "TemporalAsOfQueryRootExpression")
+			{
+				var pointInTime = GetPropValue<DateTime>(queryRoot, "PointInTime");
+
+				var asOf = Expression.Call(TemporalAsOfTable.MakeGenericMethod(entityType), 
+					GetAsOfSqlServer(getTableExpr, entityType),
+					Expression.Constant(pointInTime));
+
+				return asOf;
+			}
+
+			if (expressionTypeName == "TemporalFromToQueryRootExpression")
+			{
+				var from = GetPropValue<DateTime>(queryRoot, "From");
+				var to = GetPropValue<DateTime>(queryRoot, "To");
+
+				var fromTo = Expression.Call(TemporalFromTo.MakeGenericMethod(entityType),
+					GetAsOfSqlServer(getTableExpr, entityType),
+					Expression.Constant(from),
+					Expression.Constant(to));
+
+				return fromTo;
+			}
+
+			if (expressionTypeName == "TemporalBetweenQueryRootExpression")
+			{
+				var from = GetPropValue<DateTime>(queryRoot, "From");
+				var to = GetPropValue<DateTime>(queryRoot, "To");
+
+				var fromTo = Expression.Call(TemporalBetween.MakeGenericMethod(entityType),
+					GetAsOfSqlServer(getTableExpr, entityType),
+					Expression.Constant(from),
+					Expression.Constant(to));
+
+				return fromTo;
+			}
+
+			if (expressionTypeName == "TemporalContainedInQueryRootExpression")
+			{
+				var from = GetPropValue<DateTime>(queryRoot, "From");
+				var to = GetPropValue<DateTime>(queryRoot, "To");
+
+				var fromTo = Expression.Call(TemporalContainedIn.MakeGenericMethod(entityType),
+					GetAsOfSqlServer(getTableExpr, entityType),
+					Expression.Constant(from),
+					Expression.Constant(to));
+
+				return fromTo;
+			}
+
+			if (expressionTypeName == "TemporalAllQueryRootExpression")
+			{
+				var all = Expression.Call(TemporalAll.MakeGenericMethod(entityType),
+					GetAsOfSqlServer(getTableExpr, entityType));
+
+				return all;
+			}
+
+			return getTableExpr;
+		}
+
 		static Expression EnsureEnumerable(Expression expression, MappingSchema mappingSchema)
 		{
 			var enumerable = typeof(IEnumerable<>).MakeGenericType(GetEnumerableElementType(expression.Type, mappingSchema));

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/Northwind.Mapping/ProductsMap.cs

@@ -8,6 +8,8 @@ public class ProductsMap : BaseEntityMap<Product>
 	{
 		public override void Configure(EntityTypeBuilder<Product> builder)
 		{
+			builder.ToTable(t => t.IsTemporal());
+
 			builder.HasKey(e => e.ProductId);
 
 			builder.HasIndex(e => e.CategoryId)

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/Northwind/NorthwindContext.cs

@@ -26,6 +26,7 @@ public class NorthwindContext : DbContext
 
 		public NorthwindContext(DbContextOptions options) : base(options)
 		{
+			
 		}
 
 		[DbFunction("ProcessLong", "dbo")]

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/ToolsTests.cs

@@ -835,5 +835,36 @@ public void TestTagWith([Values(true, false)] bool enableFilter)
 			}
 		}
 
+
+		[Test]
+		public void TestTemporalTables([Values(true, false)] bool enableFilter)
+		{
+			using (var ctx = CreateContext(enableFilter))
+			{
+				var query1 = ctx.Products.TemporalAsOf(DateTime.UtcNow);
+				var query2 = ctx.Products.TemporalFromTo(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow);
+				var query3 = ctx.Products.TemporalAll();
+				var query4 = ctx.Products.TemporalBetween(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow);
+				var query5 = ctx.Products.TemporalContainedIn(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow);
+
+				var result1 = query1.ToLinqToDB().ToArray();
+				var result2 = query2.ToLinqToDB().ToArray();
+				var result3 = query3.ToLinqToDB().ToArray();
+				var result4 = query4.ToLinqToDB().ToArray();
+				var result5 = query5.ToLinqToDB().ToArray();
+
+				var allQuery =
+					from p in ctx.Products.ToLinqToDB()
+					from q1 in ctx.Products.TemporalAsOf(DateTime.UtcNow).Where(q => q.ProductId == p.ProductId).DefaultIfEmpty()
+					from q2 in ctx.Products.TemporalFromTo(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow).Where(q => q.ProductId == p.ProductId).DefaultIfEmpty()
+					from q3 in ctx.Products.TemporalAll().Where(q => q.ProductId == p.ProductId).DefaultIfEmpty()	
+					from q4 in ctx.Products.TemporalBetween(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow).Where(q => q.ProductId == p.ProductId).DefaultIfEmpty()
+					from q5 in ctx.Products.TemporalContainedIn(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow).Where(q => q.ProductId == p.ProductId).DefaultIfEmpty()
+					select p;
+
+				var result = allQuery.ToArray();
+			}
+		}
+
 	}
 }