fix(csharp): address issue #525

Author: peco-engineer-bot[bot]

csharp/src/StatementExecution/MetadataCommands/MetadataCommandBase.cs

@@ -35,6 +35,32 @@ protected static string QuoteIdentifier(string identifier)
             return $"`{identifier.Replace("`", "``")}`";
         }
 
+        /// <summary>
+        /// Returns true if the pattern contains an unescaped SQL-LIKE wildcard
+        /// (<c>_</c> or <c>%</c>). Centralizes the single wildcard rule shared by both
+        /// protocols (see <see cref="ConvertPattern"/>): a backslash escapes the next
+        /// character, so <c>\_</c>/<c>\%</c> are literals and not treated as wildcards.
+        /// </summary>
+        internal static bool ContainsWildcard(string? pattern)
+        {
+            if (pattern == null)
+                return false;
+
+            for (int i = 0; i < pattern.Length; i++)
+            {
+                char c = pattern[i];
+                if (c == '\\')
+                {
+                    // Skip the escaped character; an escaped _ or % is a literal.
+                    i++;
+                    continue;
+                }
+                if (c == '%' || c == '_')
+                    return true;
+            }
+            return false;
+        }
+
         protected static string ConvertPattern(string? pattern)
         {
             if (pattern == null)

csharp/src/StatementExecution/StatementExecutionConnection.cs

@@ -701,13 +701,49 @@ async Task<IReadOnlyList<string>> IGetObjectsDataProvider.GetCatalogsAsync(strin
             return result;
         }
 
+        /// <summary>
+        /// Resolves a catalog pattern (from GetObjects) to the concrete catalog names to query.
+        /// Centralizes the single wildcard rule for the catalog argument so SEA matches the
+        /// objects Thrift would (Thrift expands <c>_</c>/<c>%</c> server-side; SEA's SHOW commands
+        /// take the catalog as a literal backtick identifier, so we expand wildcards client-side):
+        ///   - null               → returns null, meaning "all catalogs" (SHOW ... IN ALL CATALOGS).
+        ///   - no wildcard         → returns the literal name as-is (no extra round-trip).
+        ///   - contains _ or %     → runs SHOW CATALOGS LIKE pattern and returns matched names.
+        /// </summary>
+        private async Task<IReadOnlyList<string>?> ResolveCatalogsAsync(string? catalogPattern, CancellationToken cancellationToken)
+        {
+            if (catalogPattern == null)
+                return null;
+
+            if (!MetadataCommandBase.ContainsWildcard(catalogPattern))
+                return new[] { catalogPattern };
+
+            return await ((IGetObjectsDataProvider)this).GetCatalogsAsync(catalogPattern, cancellationToken).ConfigureAwait(false);
+        }
+
         async Task<IReadOnlyList<(string catalog, string schema)>> IGetObjectsDataProvider.GetSchemasAsync(string? catalogPattern, string? schemaPattern, CancellationToken cancellationToken)
         {
-            // Note: catalogPattern comes from GetObjectsResultBuilder which resolves individual
-            // catalog names before calling this method. Despite the "pattern" name (from the
-            // IGetObjectsDataProvider interface), the value passed to ShowSchemasCommand is used
-            // as a literal catalog identifier (backtick-quoted), not a wildcard pattern.
-            string sql = new ShowSchemasCommand(catalogPattern, schemaPattern).Build();
+            var result = new List<(string, string)>();
+
+            // Expand catalog wildcards to concrete catalog names (see ResolveCatalogsAsync).
+            // A null result means "all catalogs"; each concrete catalog is queried individually.
+            var catalogs = await ResolveCatalogsAsync(catalogPattern, cancellationToken).ConfigureAwait(false);
+            if (catalogs == null)
+            {
+                await CollectSchemasAsync(null, schemaPattern, result, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                foreach (var catalog in catalogs)
+                    await CollectSchemasAsync(catalog, schemaPattern, result, cancellationToken).ConfigureAwait(false);
+            }
+            return result;
+        }
+
+        private async Task CollectSchemasAsync(string? catalog, string? schemaPattern,
+            List<(string, string)> result, CancellationToken cancellationToken)
+        {
+            string sql = new ShowSchemasCommand(catalog, schemaPattern).Build();
 
             List<RecordBatch> batches;
             try
@@ -716,14 +752,13 @@ async Task<IReadOnlyList<string>> IGetObjectsDataProvider.GetCatalogsAsync(strin
             }
             catch (DatabricksException ex) when (ex.IsObjectNotFoundException())
             {
-                return System.Array.Empty<(string, string)>();
+                return;
             }
 
             // SHOW SCHEMAS IN ALL CATALOGS returns 2 columns: databaseName, catalog
             // SHOW SCHEMAS IN `catalog` returns 1 column: databaseName
-            bool showSchemasInAllCatalogs = catalogPattern == null;
+            bool showSchemasInAllCatalogs = catalog == null;
 
-            var result = new List<(string, string)>();
             foreach (var batch in batches)
             {
                 StringArray? catalogArray = null;
@@ -743,19 +778,38 @@ async Task<IReadOnlyList<string>> IGetObjectsDataProvider.GetCatalogsAsync(strin
                 for (int i = 0; i < batch.Length; i++)
                 {
                     if (schemaArray.IsNull(i)) continue;
-                    string catalog = catalogArray != null && !catalogArray.IsNull(i)
+                    string catalogValue = catalogArray != null && !catalogArray.IsNull(i)
                         ? catalogArray.GetString(i)
-                        : catalogPattern ?? "";
-                    result.Add((catalog, schemaArray.GetString(i)));
+                        : catalog ?? "";
+                    result.Add((catalogValue, schemaArray.GetString(i)));
                 }
             }
-            return result;
         }
 
         async Task<IReadOnlyList<(string catalog, string schema, string table, string tableType)>> IGetObjectsDataProvider.GetTablesAsync(
             string? catalogPattern, string? schemaPattern, string? tableNamePattern, IReadOnlyList<string>? tableTypes, CancellationToken cancellationToken)
         {
-            string sql = new ShowTablesCommand(catalogPattern, schemaPattern, tableNamePattern).Build();
+            var result = new List<(string, string, string, string)>();
+
+            // Expand catalog wildcards to concrete catalog names (see ResolveCatalogsAsync).
+            // A null result means "all catalogs"; each concrete catalog is queried individually.
+            var catalogs = await ResolveCatalogsAsync(catalogPattern, cancellationToken).ConfigureAwait(false);
+            if (catalogs == null)
+            {
+                await CollectTablesAsync(null, schemaPattern, tableNamePattern, tableTypes, result, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                foreach (var catalog in catalogs)
+                    await CollectTablesAsync(catalog, schemaPattern, tableNamePattern, tableTypes, result, cancellationToken).ConfigureAwait(false);
+            }
+            return result;
+        }
+
+        private async Task CollectTablesAsync(string? catalog, string? schemaPattern, string? tableNamePattern,
+            IReadOnlyList<string>? tableTypes, List<(string, string, string, string)> result, CancellationToken cancellationToken)
+        {
+            string sql = new ShowTablesCommand(catalog, schemaPattern, tableNamePattern).Build();
 
             List<RecordBatch> batches;
             try
@@ -764,9 +818,8 @@ async Task<IReadOnlyList<string>> IGetObjectsDataProvider.GetCatalogsAsync(strin
             }
             catch (DatabricksException ex) when (ex.IsObjectNotFoundException())
             {
-                return System.Array.Empty<(string, string, string, string)>();
+                return;
             }
-            var result = new List<(string, string, string, string)>();
             foreach (var batch in batches)
             {
                 var catalogArray = TryGetColumn<StringArray>(batch, "catalogName");
@@ -795,18 +848,31 @@ async Task<IReadOnlyList<string>> IGetObjectsDataProvider.GetCatalogsAsync(strin
                         tableArray.GetString(i), tableType));
                 }
             }
-            return result;
         }
 
         async Task IGetObjectsDataProvider.PopulateColumnInfoAsync(string? catalogPattern, string? schemaPattern,
             string? tablePattern, string? columnPattern,
             Dictionary<string, Dictionary<string, Dictionary<string, TableInfo>>> catalogMap,
             CancellationToken cancellationToken)
         {
-            List<RecordBatch> batches;
+            // Expand catalog wildcards to concrete catalog names (see ResolveCatalogsAsync) so a
+            // wildcard catalog isn't sent to SHOW COLUMNS as a literal backtick identifier. A null
+            // resolution means "all catalogs" — ExecuteShowColumnsAsync(null, ...) handles that by
+            // iterating every catalog itself.
+            var catalogs = await ResolveCatalogsAsync(catalogPattern, cancellationToken).ConfigureAwait(false);
+
+            List<RecordBatch> batches = new List<RecordBatch>();
             try
             {
-                batches = await ExecuteShowColumnsAsync(catalogPattern, schemaPattern, tablePattern, columnPattern, cancellationToken).ConfigureAwait(false);
+                if (catalogs == null)
+                {
+                    batches.AddRange(await ExecuteShowColumnsAsync(null, schemaPattern, tablePattern, columnPattern, cancellationToken).ConfigureAwait(false));
+                }
+                else
+                {
+                    foreach (var catalog in catalogs)
+                        batches.AddRange(await ExecuteShowColumnsAsync(catalog, schemaPattern, tablePattern, columnPattern, cancellationToken).ConfigureAwait(false));
+                }
             }
             catch (DatabricksException ex) when (ex.IsObjectNotFoundException())
             {

csharp/test/E2E/StatementExecution/StatementExecutionDriverE2ETests.cs

@@ -17,6 +17,8 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading.Tasks;
+using Apache.Arrow;
 using AdbcDrivers.HiveServer2;
 using AdbcDrivers.HiveServer2.Spark;
 using Apache.Arrow.Adbc;
@@ -483,5 +485,73 @@ public void ExecuteQuery_PollTimeMs_DrivesSeaPollingCadence()
                 $"completed in {sw.ElapsedMilliseconds}ms (expected >= 1800ms). " +
                 $"This indicates polltime_ms is not wired into SEA's polling interval.");
         }
+
+        // Issue #525: the SEA path treated the catalog argument as a literal backtick
+        // identifier, so SQL-LIKE wildcards (`_`, `%`) in the catalog pattern were not
+        // honored when enumerating schemas/tables/columns — diverging from Thrift, which
+        // expands them server-side. With "main" expressed as a single-char `_` wildcard
+        // ("mai_"), GetObjects(DbSchemas) must still return main's schemas. Before the
+        // fix the wildcard is quoted literally (SHOW SCHEMAS IN `mai_`), the backend
+        // finds no catalog named "mai_", and zero schema rows come back.
+        [SkippableFact]
+        public async Task GetObjects_CatalogUnderscoreWildcard_MatchesCatalog()
+        {
+            SkipIfNotConfigured();
+
+            using var connection = CreateRestConnection(new Dictionary<string, string>
+            {
+                [DatabricksParameters.EnableMultipleCatalogSupport] = "true",
+            });
+
+            // "mai_" uses the single-char `_` wildcard, which matches the catalog "main".
+            var schemas = await CollectDbSchemas(connection, catalogPattern: "mai_");
+
+            Assert.Contains(
+                schemas,
+                s => string.Equals(s.catalog, "main", StringComparison.OrdinalIgnoreCase));
+        }
+
+        private static async Task<List<(string catalog, string schema)>> CollectDbSchemas(
+            AdbcConnection connection, string? catalogPattern)
+        {
+            var result = new List<(string, string)>();
+            using var stream = connection.GetObjects(
+                AdbcConnection.GetObjectsDepth.DbSchemas,
+                catalogPattern: catalogPattern,
+                dbSchemaPattern: null,
+                tableNamePattern: null,
+                tableTypes: null,
+                columnNamePattern: null);
+
+            while (true)
+            {
+                using var batch = await stream.ReadNextRecordBatchAsync();
+                if (batch == null) break;
+
+                var catalogArray = batch.Column("catalog_name") as StringArray;
+                var dbSchemasArray = batch.Column("catalog_db_schemas") as ListArray;
+                if (catalogArray == null) continue;
+
+                for (int catIdx = 0; catIdx < batch.Length; catIdx++)
+                {
+                    if (catalogArray.IsNull(catIdx)) continue;
+                    string catalog = catalogArray.GetString(catIdx);
+
+                    if (dbSchemasArray == null || dbSchemasArray.IsNull(catIdx)) continue;
+                    if (dbSchemasArray.GetSlicedValues(catIdx) is not StructArray schemaStruct) continue;
+
+                    var schemaNameArray = schemaStruct.Fields.Count > 0 ? schemaStruct.Fields[0] as StringArray : null;
+                    if (schemaNameArray == null) continue;
+
+                    for (int schemaIdx = 0; schemaIdx < schemaStruct.Length; schemaIdx++)
+                    {
+                        if (schemaNameArray.IsNull(schemaIdx)) continue;
+                        result.Add((catalog, schemaNameArray.GetString(schemaIdx)));
+                    }
+                }
+            }
+
+            return result;
+        }
     }
 }

csharp/test/Unit/StatementExecution/ShowCommandTests.cs

@@ -188,5 +188,20 @@ public void ShowCatalogs_EmptyPattern()
         {
             Assert.Equal("SHOW CATALOGS LIKE ''", new ShowCatalogsCommand("").Build());
         }
+
+        // ContainsWildcard — the single, shared wildcard rule (issue #525).
+
+        [Theory]
+        [InlineData(null, false)]
+        [InlineData("", false)]
+        [InlineData("main", false)]
+        [InlineData("comparator_tests", true)]   // unescaped _ is a wildcard
+        [InlineData("ma%", true)]                 // unescaped % is a wildcard
+        [InlineData("comparator\\_tests", false)] // escaped \_ is a literal
+        [InlineData("ma\\%", false)]              // escaped \% is a literal
+        public void ContainsWildcard_DetectsUnescapedWildcards(string? pattern, bool expected)
+        {
+            Assert.Equal(expected, MetadataCommandBase.ContainsWildcard(pattern));
+        }
     }
 }