From 2c23ba4a88b0462a58c04af45527adeed4565a85 Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 14:18:31 -0500 Subject: [PATCH] chore(sonar)!: return empty IQueryable instead of null from GetQuery (S1168) Replaces `null` returns from `SqlBreakdownBase.GetQuery()` and its four overrides (LinqQueryBreakdown, SqlServer/PostgreSql/Snowflake QueryBreakdown) with `Enumerable.Empty().AsQueryable()`, and tightens the signature from `IQueryable?` to `IQueryable`. The "we can't reconstruct" semantic now lives in "the query yields zero rows" rather than a nullable return, which is what callers in LINQ pipelines actually want. Three LinqQueryBreakdownTests tests asserting `Is.Null` are renamed and updated to assert `Is.Empty`. BREAKING CHANGE: SqlBreakdownBase.GetQuery and the SqlServer / PostgreSql / Snowflake / LinqToSql QueryBreakdown.GetQuery overrides no longer return `IQueryable?`; they now return a non-nullable `IQueryable` that is empty when reconstruction isn't possible. External NuGet consumers null- checking the result must switch to `.Any()` / `Is.Empty` checks instead. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../Breakdowns/LinqQueryBreakdown.cs | 22 ++++++------------- .../Breakdowns/QueryBreakdown.cs | 12 ++++------ .../Breakdowns/QueryBreakdown.cs | 12 ++++------ .../Classes/SqlBreakdownBase.cs | 6 ++--- .../Breakdowns/QueryBreakdown.cs | 12 ++++------ .../LinqQueryBreakdownTests.cs | 16 +++++++------- 6 files changed, 30 insertions(+), 50 deletions(-) diff --git a/src/Strata.SqlTools.LinqToSql/Breakdowns/LinqQueryBreakdown.cs b/src/Strata.SqlTools.LinqToSql/Breakdowns/LinqQueryBreakdown.cs index 341b1fa..db49c0a 100644 --- a/src/Strata.SqlTools.LinqToSql/Breakdowns/LinqQueryBreakdown.cs +++ b/src/Strata.SqlTools.LinqToSql/Breakdowns/LinqQueryBreakdown.cs @@ -185,39 +185,31 @@ public class LinqQueryBreakdown : QueryBreakdown /// Gets a LINQ to SQL query of the specified type based on this breakdown. /// /// The entity type for the query. - /// An IQueryable of the specified type reconstructed from the breakdown, or null if the type doesn't match the original entity type. + /// An IQueryable of the specified type reconstructed from the breakdown; an empty queryable if the type doesn't match the original entity type or the original data source isn't available. /// /// This method attempts to reconstruct a LINQ query from the analyzed components (WHERE, ORDER BY, etc.). /// If a data source (IQueryable) is available in the breakdown's OriginalExpression, it will be used. - /// Otherwise, returns null to indicate the query cannot be reconstructed without the original data source. + /// Otherwise, returns an empty queryable — breakdown analysis is one-way; reconstruction requires the original provider. /// - public override IQueryable? GetQuery() where T : class + public override IQueryable GetQuery() where T : class { - // If we don't have the original expression, we cannot reconstruct the LINQ query if (OriginalExpression == null) { - return null; + return Enumerable.Empty().AsQueryable(); } - // The original expression is the full LINQ query that was analyzed - // To use it, we need it to be an IQueryable try { - // If the original expression can be converted to IQueryable, use it - // Otherwise, we cannot safely reconstruct without the original query provider if (OriginalExpression is Expression && EntityType == typeof(T)) { - // We have the expression, but we don't have the provider to create IQueryable - // The breakdown analysis is one-way; reconstruction requires the original provider - return null; + return Enumerable.Empty().AsQueryable(); } - return null; + return Enumerable.Empty().AsQueryable(); } catch { - // If any error occurs during reconstruction, return null - return null; + return Enumerable.Empty().AsQueryable(); } } diff --git a/src/Strata.SqlTools.PostgreSql/Breakdowns/QueryBreakdown.cs b/src/Strata.SqlTools.PostgreSql/Breakdowns/QueryBreakdown.cs index 30d2f74..0a07d1c 100644 --- a/src/Strata.SqlTools.PostgreSql/Breakdowns/QueryBreakdown.cs +++ b/src/Strata.SqlTools.PostgreSql/Breakdowns/QueryBreakdown.cs @@ -272,17 +272,13 @@ public class QueryBreakdown : SqlServerQueryBreakdown /// Gets a LINQ to SQL query of the specified type based on this breakdown. /// /// The entity type for the query. - /// null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. + /// An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. /// - /// This PostgreSQL-specific implementation returns null since PostgreSQL QueryBreakdown represents parsed SQL statements. + /// This PostgreSQL-specific implementation returns an empty queryable since PostgreSQL QueryBreakdown + /// represents parsed SQL statements and has no built-in way to create LINQ queries. /// Derived classes can override this method to reconstruct LINQ queries from the analyzed components. /// - public override IQueryable? GetQuery() where T : class - { - // PostgreSQL breakdown represents parsed SQL statements and does not have a built-in way to create LINQ queries - // Override in derived classes to provide LINQ query reconstruction if needed - return null; - } + public override IQueryable GetQuery() where T : class => Enumerable.Empty().AsQueryable(); } diff --git a/src/Strata.SqlTools.Snowflake/Breakdowns/QueryBreakdown.cs b/src/Strata.SqlTools.Snowflake/Breakdowns/QueryBreakdown.cs index 4ab2451..773f3f7 100644 --- a/src/Strata.SqlTools.Snowflake/Breakdowns/QueryBreakdown.cs +++ b/src/Strata.SqlTools.Snowflake/Breakdowns/QueryBreakdown.cs @@ -863,17 +863,13 @@ public class QueryBreakdown : SqlServerQueryBreakdown /// Gets a LINQ to SQL query of the specified type based on this breakdown. /// /// The entity type for the query. - /// null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. + /// An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. /// - /// This Snowflake-specific implementation returns null since Snowflake QueryBreakdown represents parsed SQL statements. + /// This Snowflake-specific implementation returns an empty queryable since Snowflake QueryBreakdown + /// represents parsed SQL statements and has no built-in way to create LINQ queries. /// Derived classes can override this method to reconstruct LINQ queries from the analyzed components. /// - public override IQueryable? GetQuery() where T : class - { - // Snowflake breakdown represents parsed SQL statements and does not have a built-in way to create LINQ queries - // Override in derived classes to provide LINQ query reconstruction if needed - return null; - } + public override IQueryable GetQuery() where T : class => Enumerable.Empty().AsQueryable(); } diff --git a/src/Strata.SqlTools.SqlBreakdown/Classes/SqlBreakdownBase.cs b/src/Strata.SqlTools.SqlBreakdown/Classes/SqlBreakdownBase.cs index fa3d00a..4663657 100644 --- a/src/Strata.SqlTools.SqlBreakdown/Classes/SqlBreakdownBase.cs +++ b/src/Strata.SqlTools.SqlBreakdown/Classes/SqlBreakdownBase.cs @@ -57,13 +57,13 @@ public abstract class SqlBreakdownBase : ISqlBreakdown /// Gets a LINQ to SQL query of the specified type based on this breakdown. /// /// The entity type for the query. - /// An IQueryable of the specified type, or null if the breakdown cannot be converted to a LINQ query. + /// An IQueryable of the specified type; an empty queryable if the breakdown cannot be converted to a LINQ query. /// /// This method allows derived breakdown classes to reconstruct or generate LINQ queries /// from the analyzed components (SELECT, WHERE, ORDER BY, etc.). - /// The default implementation returns null. + /// The default implementation returns an empty queryable. /// - public virtual IQueryable? GetQuery() where T : class => null; + public virtual IQueryable GetQuery() where T : class => Enumerable.Empty().AsQueryable(); /// /// Gets the complete SQL query including optional setup and finish clauses. diff --git a/src/Strata.SqlTools.SqlServer/Breakdowns/QueryBreakdown.cs b/src/Strata.SqlTools.SqlServer/Breakdowns/QueryBreakdown.cs index 5fe8692..d99f887 100644 --- a/src/Strata.SqlTools.SqlServer/Breakdowns/QueryBreakdown.cs +++ b/src/Strata.SqlTools.SqlServer/Breakdowns/QueryBreakdown.cs @@ -731,18 +731,14 @@ public class QueryBreakdown : SqlBreakdownBase, IQueryBreakdown /// Gets a LINQ to SQL query of the specified type based on this breakdown. /// /// The entity type for the query. - /// null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. + /// An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction. /// - /// This base implementation returns null since QueryBreakdown represents parsed SQL statements. + /// This base implementation returns an empty queryable since QueryBreakdown represents parsed SQL statements + /// and has no built-in way to create LINQ queries. /// Derived classes (such as LinqQueryBreakdown) can override this method to reconstruct LINQ queries /// from the analyzed components. /// - public override IQueryable? GetQuery() where T : class - { - // Base implementation returns null - SQL-based breakdowns don't have a built-in way to create LINQ queries - // Override in derived classes (e.g., LinqQueryBreakdown) to provide LINQ query reconstruction - return null; - } + public override IQueryable GetQuery() where T : class => Enumerable.Empty().AsQueryable(); /// /// Gets the complete SQL query string (interface implementation). diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs index 2a7f9b3..04c579d 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs @@ -513,21 +513,21 @@ public class GetQueryTests } [Test] - public void GetQuery_LinqBreakdown_ReturnsNullByDefault() + public void GetQuery_LinqBreakdown_ReturnsEmptyByDefault() { // Arrange var query = TestDataContext.Users.Where(u => u.Age > 18); var breakdown = LinqQueryBreakdown.Analyze(query); - // Act - GetQuery returns null because LinqQueryBreakdown needs the original provider + // Act - GetQuery returns empty because LinqQueryBreakdown needs the original provider var result = breakdown.GetQuery(); // Assert - Assert.That(result, Is.Null); + Assert.That(result, Is.Empty); } [Test] - public void GetQuery_SqlServerQueryBreakdown_ReturnsNull() + public void GetQuery_SqlServerQueryBreakdown_ReturnsEmpty() { // Arrange var breakdown = new QueryBreakdown("Id, Name", "Users", "Age > 18"); @@ -536,11 +536,11 @@ public class GetQueryTests var result = breakdown.GetQuery(); // Assert - Assert.That(result, Is.Null); + Assert.That(result, Is.Empty); } [Test] - public void GetQuery_MultipleBreakdownTypes_AllReturnNull() + public void GetQuery_MultipleBreakdownTypes_AllReturnEmpty() { // Arrange var linqBreakdown = LinqQueryBreakdown.Analyze(TestDataContext.Users); @@ -553,8 +553,8 @@ public class GetQueryTests Assert.Multiple(() => { // Assert - Assert.That(linqResult, Is.Null); - Assert.That(sqlResult, Is.Null); + Assert.That(linqResult, Is.Empty); + Assert.That(sqlResult, Is.Empty); }); }