fix: Gate aggressive join stripping behind opt-in option

The join-condition exclusion logic from a198c97 strips INNER JOINs
where the table is only referenced in its own ON clause. This removes
filter conditions (e.g. AND b.Type = 'B') that affect row counts,
causing incorrect results (29K vs 24K rows in production).

Add AggressiveJoinStripping option (default false) to control this
behavior. The default now uses the safe threshold-of-1 logic. Users
can opt in via --aggressive-join-stripping on the CLI.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: stevehansen

src/SqlInliner.Tests/SimpleTests.cs

@@ -171,13 +171,14 @@ public void CountColumnReferences()
     public void StripJoinWithMultipleConditionsWhenUnused()
     {
         // A join with multiple ON conditions (e.g. AND b.Type = 'B') where the joined table
-        // is only referenced in its own ON clause should still be stripped.
+        // is only referenced in its own ON clause should still be stripped when aggressive mode is on.
         connection.AddViewDefinition(DatabaseConnection.ToObjectName("dbo", "VFilteredJoin"),
             "CREATE VIEW dbo.VFilteredJoin AS SELECT a.Id, a.Name FROM dbo.A a INNER JOIN dbo.B b ON a.BId = b.Id AND b.Type = 'B'");
 
         const string viewSql = "CREATE VIEW dbo.VTest AS SELECT fj.Id, fj.Name FROM dbo.VFilteredJoin fj";
 
-        var inliner = new DatabaseViewInliner(connection, viewSql, options);
+        var aggressiveOptions = new InlinerOptions { StripUnusedColumns = true, StripUnusedJoins = true, AggressiveJoinStripping = true };
+        var inliner = new DatabaseViewInliner(connection, viewSql, aggressiveOptions);
         inliner.Errors.Count.ShouldBe(0);
 
         var result = inliner.Result;
@@ -186,6 +187,24 @@ public void StripJoinWithMultipleConditionsWhenUnused()
         result.ConvertedSql.ShouldContain("dbo.A");
     }
 
+    [Test]
+    public void KeepJoinWithMultipleConditionsWhenNotAggressive()
+    {
+        // Without AggressiveJoinStripping, a join with filter conditions in ON should be kept
+        // because the ON clause acts as a filter for INNER JOINs.
+        connection.AddViewDefinition(DatabaseConnection.ToObjectName("dbo", "VFilteredJoinSafe"),
+            "CREATE VIEW dbo.VFilteredJoinSafe AS SELECT a.Id, a.Name FROM dbo.A a INNER JOIN dbo.B b ON a.BId = b.Id AND b.Type = 'B'");
+
+        const string viewSql = "CREATE VIEW dbo.VTest AS SELECT fj.Id, fj.Name FROM dbo.VFilteredJoinSafe fj";
+
+        var inliner = new DatabaseViewInliner(connection, viewSql, options);
+        inliner.Errors.Count.ShouldBe(0);
+
+        var result = inliner.Result;
+        result.ShouldNotBeNull();
+        result.ConvertedSql.ShouldContain("dbo.B");
+    }
+
     [Test]
     public void KeepJoinWithMultipleConditionsWhenUsedInSelect()
     {

src/SqlInliner/DatabaseViewInliner.cs

@@ -325,10 +325,12 @@ private void DetectUnusedTablesToStrip(ReferencesVisitor references, List<TableR
             {
                 var alias = referenced.Alias?.Value ?? referenced.SchemaObject.BaseIdentifier.Value;
 
-                // Exclude column references from the join condition that introduces this table,
-                // so that filter conditions like "AND b.Type = 'B'" don't prevent stripping.
+                // When AggressiveJoinStripping is enabled, exclude column references from the
+                // join condition that introduces this table. This allows stripping joins where
+                // the table is only referenced in its own ON clause (e.g. AND b.Type = 'B').
+                // WARNING: This can change results for INNER JOINs where the ON clause filters rows.
                 HashSet<ColumnReferenceExpression>? joinConditionRefs = null;
-                if (references.JoinConditions.TryGetValue(referenced, out var searchCondition))
+                if (options.AggressiveJoinStripping && references.JoinConditions.TryGetValue(referenced, out var searchCondition))
                     joinConditionRefs = CollectColumnReferences(searchCondition);
 
                 var columns = references.ColumnReferences

src/SqlInliner/InlinerOptions.cs

@@ -15,6 +15,14 @@ public sealed class InlinerOptions
     /// </summary>
     public bool StripUnusedJoins { get; set; }
 
+    /// <summary>
+    /// Gets or sets whether join condition column references should be excluded from the usage count when stripping joins.
+    /// When <c>true</c>, a table referenced only in its own ON clause (e.g. <c>INNER JOIN b ON a.Id = b.Id AND b.Type = 'X'</c>)
+    /// will be stripped. This is more aggressive and can change results for INNER JOINs where the ON clause acts as a filter.
+    /// Defaults to <c>false</c>.
+    /// </summary>
+    public bool AggressiveJoinStripping { get; set; }
+
     /// <summary>
     /// Gets the recommended options that should be used for optimal results.
     /// </summary>

src/SqlInliner/Program.cs

@@ -16,6 +16,7 @@ private static int Main(string[] args)
         var viewPathOption = new Option<FileInfo>("--view-path", "-vp") { Description = "The path of the view as a .sql file (including create statement)" };
         var stripUnusedColumnsOption = new Option<bool>("--strip-unused-columns", "-suc") { DefaultValueFactory = _ => true };
         var stripUnusedJoinsOption = new Option<bool>("--strip-unused-joins", "-suj");
+        var aggressiveJoinStrippingOption = new Option<bool>("--aggressive-join-stripping") { Description = "Exclude join condition references from usage count when stripping joins (can change results for INNER JOINs)" };
         var generateCreateOrAlterOption = new Option<bool>("--generate-create-or-alter") { DefaultValueFactory = _ => true };
         var outputPathOption = new Option<FileInfo?>("--output-path", "-op") { Description = "Optional path of the file to write the resulting SQL to" };
         var logPathOption = new Option<FileInfo?>("--log-path", "-lp") { Description = "Optional path of the file to write debug information to" };
@@ -26,6 +27,7 @@ private static int Main(string[] args)
                 viewPathOption,
                 stripUnusedColumnsOption,
                 stripUnusedJoinsOption,
+                aggressiveJoinStrippingOption,
                 generateCreateOrAlterOption,
                 outputPathOption,
                 logPathOption,
@@ -39,6 +41,7 @@ private static int Main(string[] args)
             var viewPath = parseResult.GetValue(viewPathOption);
             var stripUnusedColumns = parseResult.GetValue(stripUnusedColumnsOption);
             var stripUnusedJoins = parseResult.GetValue(stripUnusedJoinsOption);
+            var aggressiveJoinStripping = parseResult.GetValue(aggressiveJoinStrippingOption);
             var generateCreateOrAlter = parseResult.GetValue(generateCreateOrAlterOption);
             var outputPath = parseResult.GetValue(outputPathOption);
             var logPath = parseResult.GetValue(logPathOption);
@@ -67,6 +70,7 @@ private static int Main(string[] args)
             {
                 StripUnusedColumns = stripUnusedColumns,
                 StripUnusedJoins = stripUnusedJoins,
+                AggressiveJoinStripping = aggressiveJoinStripping,
             });
 
             if (outputPath != null)