fix(column-bulk): backport column grid alphabetical sort to 1.13 (#29699)

openmetadata-service/src/main/java/org/openmetadata/service/search/ColumnMetadataGrouper.java

@@ -16,6 +16,7 @@
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -101,6 +102,17 @@ public static List<ColumnGridItem> groupColumns(
       gridItems.add(gridItem);
     }
 
+    // groupColumns is the single sink for every query path. The input map's iteration order is not
+    // guaranteed (current callers build it as a HashMap), so sort here for a stable alphabetical
+    // order. Case-insensitive for natural listing, with a case-sensitive tie-breaker so names that
+    // differ only in case (e.g. "Name"/"name") stay stable instead of relying on map order.
+    // nullsLast guards against a null column name (e.g. a null map key) rather than throwing.
+    gridItems.sort(
+        Comparator.comparing(
+                ColumnGridItem::getColumnName, Comparator.nullsLast(String.CASE_INSENSITIVE_ORDER))
+            .thenComparing(
+                ColumnGridItem::getColumnName, Comparator.nullsLast(Comparator.naturalOrder())));
+
     return gridItems;
   }
 

openmetadata-service/src/test/java/org/openmetadata/service/search/ColumnMetadataGrouperTest.java

@@ -19,7 +19,9 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
@@ -337,4 +339,102 @@ void testGroupColumns_emptyMap() {
     assertNotNull(result);
     assertEquals(0, result.size());
   }
+
+  @Test
+  void testGroupColumns_resultsAreSortedAscendingByColumnName() {
+    // Feed columns in a non-alphabetical order (LinkedHashMap keeps the input order deterministic)
+    // and verify the grid is returned sorted ascending by column name.
+    Map<String, List<ColumnMetadataGrouper.ColumnWithContext>> columnsByName =
+        new LinkedHashMap<>();
+    List<String> scrambled =
+        List.of(
+            "c_admpkg",
+            "c_addin",
+            "c_active_agent_id",
+            "c_admincare",
+            "c_address",
+            "c_admission_date",
+            "c_acasclop",
+            "c_abnorm",
+            "c_abbrevation");
+    for (String name : scrambled) {
+      columnsByName.put(name, singleOccurrence(name));
+    }
+
+    List<ColumnGridItem> result = ColumnMetadataGrouper.groupColumns(columnsByName);
+
+    List<String> actual = result.stream().map(ColumnGridItem::getColumnName).toList();
+    List<String> expected = new ArrayList<>(scrambled);
+    expected.sort(String.CASE_INSENSITIVE_ORDER);
+    assertEquals(expected, actual);
+    assertEquals("c_abbrevation", actual.get(0));
+    assertEquals("c_abnorm", actual.get(1));
+  }
+
+  @Test
+  void testGroupColumns_sortIsCaseInsensitive() {
+    // Insertion order (Zebra, apple, Mango) is non-alphabetical and preserved by LinkedHashMap.
+    Map<String, List<ColumnMetadataGrouper.ColumnWithContext>> columnsByName =
+        new LinkedHashMap<>();
+    for (String name : List.of("Zebra", "apple", "Mango")) {
+      columnsByName.put(name, singleOccurrence(name));
+    }
+
+    List<ColumnGridItem> result = ColumnMetadataGrouper.groupColumns(columnsByName);
+
+    List<String> actual = result.stream().map(ColumnGridItem::getColumnName).toList();
+    assertEquals(List.of("apple", "Mango", "Zebra"), actual);
+  }
+
+  @Test
+  void testGroupColumns_caseOnlyCollisionsAreDeterministic() {
+    // Names differing only in case are equal under CASE_INSENSITIVE_ORDER, so the case-sensitive
+    // tie-breaker decides their order. Insert in reverse of the expected result to prove the sort,
+    // not the map, determines it.
+    Map<String, List<ColumnMetadataGrouper.ColumnWithContext>> columnsByName =
+        new LinkedHashMap<>();
+    for (String name : List.of("name", "Name")) {
+      columnsByName.put(name, singleOccurrence(name));
+    }
+
+    List<ColumnGridItem> result = ColumnMetadataGrouper.groupColumns(columnsByName);
+
+    List<String> actual = result.stream().map(ColumnGridItem::getColumnName).toList();
+    // Natural String order: 'N' (0x4E) precedes 'n' (0x6E).
+    assertEquals(List.of("Name", "name"), actual);
+  }
+
+  @Test
+  void testGroupColumns_nullColumnNameSortsLastWithoutError() {
+    // A null column name (e.g. a null map key) must not throw; it sorts last (nullsLast).
+    Map<String, List<ColumnMetadataGrouper.ColumnWithContext>> columnsByName =
+        new LinkedHashMap<>();
+    columnsByName.put("beta", singleOccurrence("beta"));
+    columnsByName.put(null, singleOccurrence(null));
+    columnsByName.put("alpha", singleOccurrence("alpha"));
+
+    List<ColumnGridItem> result = ColumnMetadataGrouper.groupColumns(columnsByName);
+
+    List<String> actual = result.stream().map(ColumnGridItem::getColumnName).toList();
+    assertEquals(Arrays.asList("alpha", "beta", null), actual);
+  }
+
+  private static List<ColumnMetadataGrouper.ColumnWithContext> singleOccurrence(String columnName) {
+    Column column = new Column();
+    column.setName(columnName);
+    column.setDataType(ColumnDataType.STRING);
+    column.setFullyQualifiedName("sample_data.db.schema.table1." + columnName);
+
+    List<ColumnMetadataGrouper.ColumnWithContext> occurrences = new ArrayList<>();
+    occurrences.add(
+        new ColumnMetadataGrouper.ColumnWithContext(
+            column,
+            "table",
+            "sample_data.db.schema.table1",
+            "Table 1",
+            "sample_data",
+            "db",
+            "schema"));
+    return occurrences;
+  }
 }