Too aggressive query optimization

Query like that:

db.Table1
    .Where(_ =>
        db.Table2
            .Where(r => r.Table1Id == _.Id)
            .OrderByDescending(r => r.SomeField)
            .Select(r => r.AssociationProperty.TextField)
            .First()
            .Contains(filterText))

Generates invalid subquery SQL without logic added by Select and Contains:

SELECT *
FROM Table1
WHERE
(
        SELECT TOP (1)
            *
        FROM
            Table2
        WHERE
            Table2.fk_id = table1.id
        ORDER BY
            Table2.SomeField DESC
)

Such query rejected by database engine (MSSQ) and miss join on association, text field selection and LIKE predicate

If you will need exact test-case to reproduce issue, I could provide it a bit later.

[MaceWindu]

Of course.

Test query

[DataContextSource]
public void Issue269(string context)
{
	using (var db = new TestDataConnection(context))
	using (db.BeginTransaction())
	{
		var result = db.Patient
			.Where(pat => db.Person
				.Where(per => per.ID == pat.PersonID)
				.OrderByDescending(per => per.FirstName)
				.Select(c => c.Patient.Diagnosis)
				.First()
				.Contains("with"))
			.ToArray();
	}
}

Generated SQL (invalid). Similar to one in defect but a bit different. Maybe because of different relations schema but I assume it is due to changes made to linq2db for last two years.

SELECT
	[t1].[PersonID],
	[t1].[Diagnosis]
FROM
	[Patient] [t1]
WHERE
	1 = (
		SELECT TOP (1)
			*
		FROM
			[Person] [t2]
		WHERE
			[t2].[PersonID] = [t1].[PersonID]
		ORDER BY
			[t2].[FirstName] DESC
	)

Also commenting First call produce interesting results. Contains converted to comparison instead of LIKE:

SELECT
	[t1].[PersonID],
	[t1].[Diagnosis]
FROM
	[Patient] [t1]
WHERE
	EXISTS(
		SELECT
			*
		FROM
			[Person] [t3]
				LEFT JOIN [Patient] [t2] ON [t3].[PersonID] = [t2].[PersonID]
		WHERE
			[t3].[PersonID] = [t1].[PersonID] AND [t2].[Diagnosis] = N'with'
	)

[sdanyliv]

1. Maybe i have learn SQL before .NET, for me it is more explainable and really keeps you closer to SQL.
2. I’m choosing both techniques, but for SQL I’m trying to use linq queries, especially when group by or join are used.