Back-port changes for #117.

Author: sdanyliv

Source/LinqToDB.EntityFrameworkCore/EFCoreMetadataReader.cs

@@ -191,25 +191,28 @@ public T[] GetAttributes<T>(Type type, MemberInfo memberInfo, bool inherit = tru
 						var fk = navigation.ForeignKey;
 						if (!navigation.IsDependentToPrincipal())
 						{
-							var thisKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
+							// Could not track when EF decides to do INNER JOIN
+							var canBeNull = true;
+
+							var thisKey  = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
 							var otherKey = string.Join(",", fk.Properties.Select(p => p.Name));
 							associations.Add(new AssociationAttribute
 							{
-								ThisKey = thisKey,
-								OtherKey = otherKey,
-								CanBeNull = !fk.IsRequired,
+								ThisKey         = thisKey,
+								OtherKey        = otherKey,
+								CanBeNull       = canBeNull,
 								IsBackReference = false
 							});
 						}
 						else
 						{
-							var thisKey = string.Join(",", fk.Properties.Select(p => p.Name));
+							var thisKey  = string.Join(",", fk.Properties.Select(p => p.Name));
 							var otherKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
 							associations.Add(new AssociationAttribute
 							{
-								ThisKey = thisKey,
-								OtherKey = otherKey,
-								CanBeNull = !fk.IsRequired,
+								ThisKey         = thisKey,
+								OtherKey        = otherKey,
+								CanBeNull       = !fk.IsRequired,
 								IsBackReference = true
 							});
 						}

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/IssueTests.cs

@@ -1,22 +1,25 @@
 using System.Linq;
 using LinqToDB.EntityFrameworkCore.BaseTests;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind;
+using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel;
 using Microsoft.EntityFrameworkCore;
 using NUnit.Framework;
-using NUnit.Framework.Constraints;
 
 namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests
 {
 	[TestFixture]
 	public class IssueTests : TestsBase
 	{
-		private DbContextOptions<IssueContext> _options;
+		private DbContextOptions<IssueContext>? _options;
 		private bool _created;
 
 		public IssueTests()
+		{
+			InitOptions();
+		}
+
+		private void InitOptions()
 		{
 			var optionsBuilder = new DbContextOptionsBuilder<IssueContext>();
-			//new SqlServerDbContextOptionsBuilder(optionsBuilder);
 
 			optionsBuilder.UseSqlServer("Server=.;Database=IssuesEFCore;Integrated Security=SSPI");
 			optionsBuilder.UseLoggerFactory(TestUtils.LoggerFactory);
@@ -34,6 +37,7 @@ private IssueContext CreateContext()
 				ctx.Database.EnsureCreated();
 				_created = true;
 			}
+
 			return ctx;
 		}
 
@@ -53,5 +57,26 @@ public void Issue73Test()
 			AreEqual(efItems, linq2dbItems);
 		}
 
+		[Test]
+		public void Issue117Test()
+		{
+			using var ctx = CreateContext();
+
+			var userId = 1;
+
+			var query =
+				from p in ctx.Patents.Include(p => p.Assessment)
+				where p.Assessment == null || (p.Assessment.TechnicalReviewerId != userId)
+				select new { PatentId = p.Id, UserId = userId };
+
+			var resultEF = query.ToArray();
+
+			using var db = ctx.CreateLinqToDbConnection();
+
+			_ = query.ToLinqToDB(db).ToArray();
+
+			Assert.That(db.LastQuery, Does.Not.Contain("INNER"));
+		}
+
 	}
 }

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/Issue117Entities.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel
+{
+	public class Patent
+	{
+		[Key]
+		public int Id { get; set; }
+		public PatentAssessment? Assessment { get; set; }
+	}
+
+	public class PatentAssessment
+	{
+		[Key]
+		public int PatentId { get; set; }
+		public Patent Patent { get; set; } = null!;
+		public int? TechnicalReviewerId { get; set; }
+	}
+}

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/IssueContext.cs

@@ -1,17 +1,13 @@
-using System.Reflection;
-using LinqToDB.EntityFrameworkCore.BaseTests.Models.Northwind;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind.Mapping;
-using LinqToDB.Expressions;
-using LinqToDB.Extensions;
-using Microsoft.EntityFrameworkCore;
-
-namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind
+using Microsoft.EntityFrameworkCore;
+
+namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel
 {
 	public class IssueContext : DbContext
 	{
 		public DbSet<Issue73Entity> Issue73Entities { get; set; } = null!;
 
+		public DbSet<Patent> Patents { get; set; } = null!;
+
 		public IssueContext(DbContextOptions options) : base(options)
 		{
 
@@ -43,6 +39,14 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 					},
 				});
 			});
+
+			modelBuilder
+				.Entity<Patent>()
+				.HasOne(p => p.Assessment)
+				.WithOne(pa => pa.Patent)
+				.HasForeignKey<PatentAssessment>(pa => pa.PatentId)
+				.OnDelete(DeleteBehavior.Restrict);
+
 		}
 	}
 }

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/QueryableExtensions.cs

@@ -48,5 +48,62 @@ public static IIncludableQueryable<TEntity, TProp> IncludeInline<TEntity, TProp,
 
 			return includable;
 		}
+
+		public static Expression<Func<T, bool>> MakePropertiesPredicate<T, TValue>(Expression<Func<TValue, TValue, bool>> pattern, TValue searchValue, bool isOr)
+		{
+			var parameter = Expression.Parameter(typeof(T), "e");
+			var searchExpr = Expression.Constant(searchValue);
+
+			var predicateBody = typeof(T).GetProperties()
+				.Where(p => p.PropertyType == typeof(TValue))
+				.Select(p =>
+					ExpressionReplacer.GetBody(pattern, Expression.MakeMemberAccess(
+						parameter, p), searchExpr))
+				.Aggregate(isOr ? Expression.OrElse : Expression.AndAlso);
+
+			return Expression.Lambda<Func<T, bool>>(predicateBody, parameter);
+		}
+
+		public static IQueryable<T> FilterByProperties<T, TValue>(this IQueryable<T> query, TValue searchValue,
+			Expression<Func<TValue, TValue, bool>> pattern, bool isOr)
+		{
+			return query.Where(MakePropertiesPredicate<T, TValue>(pattern, searchValue, isOr));
+		}
+
+		class ExpressionReplacer : ExpressionVisitor
+		{
+			readonly IDictionary<Expression, Expression> _replaceMap;
+
+			public ExpressionReplacer(IDictionary<Expression, Expression> replaceMap)
+			{
+				_replaceMap = replaceMap ?? throw new ArgumentNullException(nameof(replaceMap));
+			}
+
+			public override Expression Visit(Expression node)
+			{
+				if (node != null && _replaceMap.TryGetValue(node, out var replacement))
+					return replacement;
+				return base.Visit(node);
+			}
+
+			public static Expression Replace(Expression expr, Expression toReplace, Expression toExpr)
+			{
+				return new ExpressionReplacer(new Dictionary<Expression, Expression> { { toReplace, toExpr } }).Visit(expr);
+			}
+
+			public static Expression Replace(Expression expr, IDictionary<Expression, Expression> replaceMap)
+			{
+				return new ExpressionReplacer(replaceMap).Visit(expr);
+			}
+
+			public static Expression GetBody(LambdaExpression lambda, params Expression[] toReplace)
+			{
+				if (lambda.Parameters.Count != toReplace.Length)
+					throw new InvalidOperationException();
+
+				return new ExpressionReplacer(Enumerable.Range(0, lambda.Parameters.Count)
+					.ToDictionary(i => (Expression)lambda.Parameters[i], i => toReplace[i])).Visit(lambda.Body);
+			}
+		}
 	}
 }

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

@@ -809,6 +809,19 @@ public void TestCreateTempTable([Values(true, false)] bool enableFilter)
 		}
 
 
+		[Test]
+		public void TestForeignKey([Values(true, false)] bool enableFilter)
+		{
+			using (var ctx = CreateContext(enableFilter))
+			{
+				var resultEF = ctx.Employees.Include(e => e.ReportsToNavigation).ToArray();
+				var result = ctx.Employees.Include(e => e.ReportsToNavigation).ToLinqToDB().ToArray();
+
+				AreEqual(resultEF, result);
+			}
+		}
+
+
 		[Test]
 		public void TestCommandTimeout()
 		{