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.
     /// </summary>
     /// <typeparam name="T">The entity type for the query.</typeparam>
-    /// <returns>An IQueryable of the specified type reconstructed from the breakdown, or null if the type doesn't match the original entity type.</returns>
+    /// <returns>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.</returns>
     /// <remarks>
     /// 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.
     /// </remarks>
-    public override IQueryable<T>? GetQuery<T>() where T : class
+    public override IQueryable<T> GetQuery<T>() 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<T>().AsQueryable();
         }
 
-        // The original expression is the full LINQ query that was analyzed
-        // To use it, we need it to be an IQueryable<T>
         try
         {
-            // If the original expression can be converted to IQueryable<T>, 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<T>
-                // The breakdown analysis is one-way; reconstruction requires the original provider
-                return null;
+                return Enumerable.Empty<T>().AsQueryable();
             }
 
-            return null;
+            return Enumerable.Empty<T>().AsQueryable();
         }
         catch
         {
-            // If any error occurs during reconstruction, return null
-            return null;
+            return Enumerable.Empty<T>().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.
     /// </summary>
     /// <typeparam name="T">The entity type for the query.</typeparam>
-    /// <returns>null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
+    /// <returns>An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
     /// <remarks>
-    /// 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.
     /// </remarks>
-    public override IQueryable<T>? GetQuery<T>() 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<T> GetQuery<T>() where T : class => Enumerable.Empty<T>().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.
     /// </summary>
     /// <typeparam name="T">The entity type for the query.</typeparam>
-    /// <returns>null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
+    /// <returns>An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
     /// <remarks>
-    /// 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.
     /// </remarks>
-    public override IQueryable<T>? GetQuery<T>() 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<T> GetQuery<T>() where T : class => Enumerable.Empty<T>().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.
     /// </summary>
     /// <typeparam name="T">The entity type for the query.</typeparam>
-    /// <returns>An IQueryable of the specified type, or null if the breakdown cannot be converted to a LINQ query.</returns>
+    /// <returns>An IQueryable of the specified type; an empty queryable if the breakdown cannot be converted to a LINQ query.</returns>
     /// <remarks>
     /// 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.
     /// </remarks>
-    public virtual IQueryable<T>? GetQuery<T>() where T : class => null;
+    public virtual IQueryable<T> GetQuery<T>() where T : class => Enumerable.Empty<T>().AsQueryable();
 
     /// <summary>
     /// 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.
     /// </summary>
     /// <typeparam name="T">The entity type for the query.</typeparam>
-    /// <returns>null by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
+    /// <returns>An empty queryable by default, as QueryBreakdown operates on SQL. Override in derived classes to provide LINQ query reconstruction.</returns>
     /// <remarks>
-    /// 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.
     /// </remarks>
-    public override IQueryable<T>? GetQuery<T>() 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<T> GetQuery<T>() where T : class => Enumerable.Empty<T>().AsQueryable();
 
     /// <summary>
     /// 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<User>();
 
         // 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<User>();
 
         // 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);
         });
     }