Refactor: Mark Exists and NotExists methods as obsolete and add updat…

…ed versions - Marked `Exists(this SelectQuery query, FluentTable validationTable, IEnumerable<string> keyColumnNames)` as obsolete. - Marked `NotExists(this SelectQuery query, FluentTable validationTable, IEnumerable<string> keyColumnNames)` as obsolete. - Added updated versions of the `Exists` and `NotExists` methods that take `IEnumerable<string> keyColumnNames` and `FluentTable validationTable`. - Implemented improved query logic with support for checking key columns and validation tables.
mk3008 · Oct 13, 2024 · 76319d6 · 76319d6
1 parent c6fc74b
commit 76319d6
Show file tree

Hide file tree

Showing 4 changed files with 117 additions and 11 deletions.
diff --git a/demo/DatasourceCompare/Program.cs b/demo/DatasourceCompare/Program.cs
@@ -292,7 +292,7 @@ static CreateTableQuery GenerateDifferentCreateTableQuery(string tableName,
     var request = FluentTable.Create("select sale_id from request", "req", "r");
 
     var query = reverseQuery.UnionAll(currentQuery)
-        .Exists(request, ["sale_id"])
+        .Exists(["sale_id"], request)
         .ToCreateTableQuery(tableName, true)
         .Comment(nameof(GenerateDifferentCreateTableQuery));
 

diff --git a/src/Carbunql/Fluent/SelectQueryWhereExtensions.cs b/src/Carbunql/Fluent/SelectQueryWhereExtensions.cs
@@ -476,11 +476,24 @@ public static SelectQuery BetweenInclusive(this SelectQuery query, string tableN
         return query;
     }
 
-    public static SelectQuery Exists(this SelectQuery query, FluentTable table, IEnumerable<string> keyColumnNames)
+    [Obsolete("use 'Exists(this SelectQuery query, IEnumerable<string> keyColumnNames, FluentTable validationTable)'")]
+    public static SelectQuery Exists(this SelectQuery query, FluentTable validationTable, IEnumerable<string> keyColumnNames)
     {
-        if (table.IsCommonTable)
+        return query.Exists(keyColumnNames, validationTable);
+    }
+
+    /// <summary>
+    /// Applies an Exists query to the specified validation table based on the key column names.
+    /// </summary>
+    /// <param name="query">The SelectQuery object to operate on.</param>
+    /// <param name="keyColumnNames">A list of key column names used in the query.</param>
+    /// <param name="validationTable">The FluentTable object used for validation.</param>
+    /// <returns>Returns the updated SelectQuery object.</returns>
+    public static SelectQuery Exists(this SelectQuery query, IEnumerable<string> keyColumnNames, FluentTable validationTable)
+    {
+        if (validationTable.IsCommonTable)
         {
-            query.With(table);
+            query.With(validationTable);
         }
 
         query.GetQuerySources()
@@ -491,8 +504,42 @@ public static SelectQuery Exists(this SelectQuery query, FluentTable table, IEnu
             {
                 qs.Query.Where(() =>
                 {
-                    var sq = new SelectQuery().From(table);
-                    keyColumnNames.ForEach(keyColumn => sq.Where($"{table.Alias}.{keyColumn} = {qs.Alias}.{keyColumn}"));
+                    var sq = new SelectQuery().From(validationTable);
+                    keyColumnNames.ForEach(keyColumn => sq.Where($"{validationTable.Alias}.{keyColumn} = {qs.Alias}.{keyColumn}"));
+                    return sq.ToExists();
+                });
+            });
+
+        return query;
+    }
+
+    /// <summary>
+    /// Applies an Exists query to the specified validation table based on the given table and key column names.
+    /// </summary>
+    /// <param name="query">The SelectQuery object to operate on.</param>
+    /// <param name="table">The FluentTable object to operate on.</param>
+    /// <param name="keyColumnNames">A list of key column names used in the query.</param>
+    /// <param name="validationTable">The FluentTable object used for validation.</param>
+    /// <returns>Returns the updated SelectQuery object.</returns>
+    public static SelectQuery Exists(this SelectQuery query, FluentTable table, IEnumerable<string> keyColumnNames, FluentTable validationTable)
+    {
+        if (validationTable.IsCommonTable)
+        {
+            query.With(validationTable);
+        }
+
+        query.GetQuerySources()
+            .Where(x => x.HasTable(table.Alias, true))
+            .EnsureAny($"table:{table.Alias}")
+            .Where(x => keyColumnNames.All(keyColumn => x.ColumnNames.Contains(keyColumn)))
+            .EnsureAny($"columns:{string.Join(",", keyColumnNames)}")
+            .GetRootsByQuery()
+            .ForEach(qs =>
+            {
+                qs.Query.Where(() =>
+                {
+                    var sq = new SelectQuery().From(validationTable);
+                    keyColumnNames.ForEach(keyColumn => sq.Where($"{validationTable.Alias}.{keyColumn} = {qs.Alias}.{keyColumn}"));
                     return sq.ToExists();
                 });
             });
@@ -512,7 +559,20 @@ public static SelectQuery Exists(this SelectQuery query, string tableName, IEnum
         return query;
     }
 
-    public static SelectQuery NotExists(this SelectQuery query, FluentTable table, IEnumerable<string> keyColumnNames)
+    [Obsolete("use 'NotExists(this SelectQuery query, IEnumerable<string> keyColumnNames, FluentTable validationTable)'")]
+    public static SelectQuery NotExists(this SelectQuery query, FluentTable validationTable, IEnumerable<string> keyColumnNames)
+    {
+        return query.NotExists(keyColumnNames, validationTable);
+    }
+
+    /// <summary>
+    /// Applies a NotExists query to the specified validation table based on the key column names.
+    /// </summary>
+    /// <param name="query">The SelectQuery object to operate on.</param>
+    /// <param name="keyColumnNames">A list of key column names used in the query.</param>
+    /// <param name="validationTable">The FluentTable object used for validation.</param>
+    /// <returns>Returns the updated SelectQuery object.</returns>
+    public static SelectQuery NotExists(this SelectQuery query, IEnumerable<string> keyColumnNames, FluentTable validationTable)
     {
         if (table.IsCommonTable)
         {
@@ -536,6 +596,40 @@ public static SelectQuery NotExists(this SelectQuery query, FluentTable table, I
         return query;
     }
 
+    /// <summary>
+    /// Applies a NotExists query to the specified validation table based on the given table and key column names.
+    /// </summary>
+    /// <param name="query">The SelectQuery object to operate on.</param>
+    /// <param name="table">The FluentTable object to operate on.</param>
+    /// <param name="keyColumnNames">A list of key column names used in the query.</param>
+    /// <param name="validationTable">The FluentTable object used for validation.</param>
+    /// <returns>Returns the updated SelectQuery object.</returns>
+    public static SelectQuery NotExists(this SelectQuery query, FluentTable table, IEnumerable<string> keyColumnNames, FluentTable validationTable)
+    {
+        if (validationTable.IsCommonTable)
+        {
+            query.With(validationTable);
+        }
+
+        query.GetQuerySources()
+            .Where(x => x.HasTable(table.Alias, true))
+            .EnsureAny($"table:{table.Alias}")
+            .Where(x => keyColumnNames.All(keyColumn => x.ColumnNames.Contains(keyColumn)))
+            .EnsureAny($"columns:{string.Join(",", keyColumnNames)}")
+            .GetRootsByQuery()
+            .ForEach(qs =>
+            {
+                qs.Query.Where(() =>
+                {
+                    var sq = new SelectQuery().From(validationTable);
+                    keyColumnNames.ForEach(keyColumn => sq.Where($"{validationTable.Alias}.{keyColumn} = {qs.Alias}.{keyColumn}"));
+                    return sq.ToNotExists();
+                });
+            });
+
+        return query;
+    }
+
     public static SelectQuery NotExists(this SelectQuery query, IEnumerable<string> keyColumnNames, string validationTableName)
     {
         query.AddNotExists(keyColumnNames, validationTableName);

diff --git a/src/Carbunql/IQuerySource.cs b/src/Carbunql/IQuerySource.cs
@@ -125,5 +125,17 @@ public static HashSet<int> GetReferenceIndexes(this IQuerySource source)
         var lst = q.ToHashSet();
         return lst;
     }
+
+    public static bool HasTable(this IQuerySource source, string tableName, bool isAliasIncluded)
+    {
+        if (isAliasIncluded && source.Alias.IsEqualNoCase(tableName))
+        {
+            return true;
+        }
+        else
+        {
+            return source.GetTableFullName().IsEqualNoCase(tableName);
+        }
+    }
 }
 
diff --git a/src/Carbunql/SelectQuery.cs b/src/Carbunql/SelectQuery.cs
@@ -1141,7 +1141,7 @@ public SelectQuery AddWhere(Func<string> adder)
     public SelectQuery AddWhere(string tableName, string columnName, Func<IQuerySource, string> adder, bool isAliasIncluded = false)
     {
         GetQuerySources()
-            .Where(x => HasTable(x, tableName, true))
+            .Where(x => x.HasTable(tableName, true))
             .EnsureAny($"table:{tableName}")
             .Where(x => HasColumn(x, columnName, isAliasIncluded))
             .EnsureAny($"The table exists, but there is no corresponding column in the table. table:{tableName}, column:{columnName}")
@@ -1164,7 +1164,7 @@ public SelectQuery AddWhere(string tableName, string columnName, Func<IQuerySour
     public SelectQuery AddWhere(string tableName, string columnName, Func<IQuerySource, string, string> adder, bool isAliasIncluded = false)
     {
         GetQuerySources()
-            .Where(x => HasTable(x, tableName, true))
+            .Where(x => x.HasTable(tableName, true))
             .EnsureAny($"table:{tableName}")
             .Where(x => HasColumn(x, columnName, isAliasIncluded))
             .EnsureAny($"The table exists, but there is no corresponding column in the table. table:{tableName}, column:{columnName}")
@@ -1215,7 +1215,7 @@ public SelectQuery AddExists(IEnumerable<string> keyColumnNames, string validati
     public SelectQuery AddExists(string sourceTableName, IEnumerable<string> keyColumnNames, string validationTableName, Action<IQuerySource>? action = null)
     {
         GetQuerySources()
-            .Where(x => HasTable(x, sourceTableName, true))
+            .Where(x => x.HasTable(sourceTableName, true))
             .EnsureAny($"table:{sourceTableName}")
             .Where(x => keyColumnNames.All(keyColumn => x.ColumnNames.Contains(keyColumn)))
             .EnsureAny($"The table exists, but there is no corresponding column in the table. table:{sourceTableName}, columns:{string.Join(",", keyColumnNames)}")
@@ -1273,7 +1273,7 @@ public SelectQuery AddNotExists(IEnumerable<string> keyColumnNames, string valid
     public SelectQuery AddNotExists(string sourceTableName, IEnumerable<string> keyColumnNames, string validationTableName, Action<IQuerySource>? action = null)
     {
         GetQuerySources()
-            .Where(x => HasTable(x, sourceTableName, true))
+            .Where(x => x.HasTable(sourceTableName, true))
             .EnsureAny($"table:{sourceTableName}")
             .Where(x => keyColumnNames.All(keyColumn => x.ColumnNames.Contains(keyColumn)))
             .EnsureAny($"The table exists, but there is no corresponding column in the table. table:{sourceTableName}, columns:{string.Join(",", keyColumnNames)}")