Add TableDefinition column name helpers

engine/table/src/main/java/io/deephaven/engine/table/impl/BaseTable.java

@@ -1058,7 +1058,7 @@ void copySortableColumns(BaseTable<?> destination, MatchPair[] renamedColumns) {
         // Process the original set of sortable columns, adding them to the new set if one of the below
         // 1) The column exists in the new table and was not renamed in any way but the Identity (C1 = C1)
         // 2) The column does not exist in the new table, but was renamed to another (C2 = C1)
-        final Set<String> resultColumnNames = destination.getDefinition().getColumnNameMap().keySet();
+        final Set<String> resultColumnNames = destination.getDefinition().getColumnNameSet();
         for (final String columnName : currentSortableColumns) {
             // Only add it to the set of sortable columns if it hasn't changed in an unknown way
             final String maybeRenamedColumn = columnMapping.get(columnName);

engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java

@@ -1787,7 +1787,7 @@ public Table dropColumns(String... columnNames) {
 
                             copyAttributes(resultTable, CopyAttributeOperation.DropColumns);
                             copySortableColumns(resultTable,
-                                    resultTable.getDefinition().getColumnNameMap()::containsKey);
+                                    resultTable.getDefinition().getColumnNameSet()::contains);
                             maybeCopyColumnDescriptions(resultTable);
 
                             if (snapshotControl != null) {

engine/table/src/main/java/io/deephaven/engine/table/impl/by/ChunkedOperatorAggregationHelper.java

@@ -111,7 +111,7 @@ public static QueryTable aggregation(
                 final ColumnDefinition<?> initialKeysDef = initialKeys.getDefinition().getColumn(keyName);
                 if (!inputDef.isCompatible(initialKeysDef)) {
                     throw new IllegalArgumentException(String.format(
-                            "aggregation: column definition mismatch between input table and initial groups table for %s input has %s, initial groups has %s",
+                            "aggregation: column definition mismatch between input table and initial groups table for %s; input has %s, initial groups has %s",
                             keyName,
                             inputDef.describeForCompatibility(),
                             initialKeysDef.describeForCompatibility()));

engine/table/src/main/java/io/deephaven/engine/table/impl/by/PartitionByChunkedOperator.java

@@ -41,6 +41,7 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
@@ -167,11 +168,10 @@ public interface AttributeCopier {
             shiftDataBuilders = new ObjectArraySource<>(RowSetShiftData.SmartCoalescingBuilder.class);
 
             final Set<String> keyColumnNameSet = Arrays.stream(keyColumnNames).collect(Collectors.toSet());
-            final Set<String> unadjustedParentColumnNameSet =
-                    new LinkedHashSet<>(unadjustedParentTable.getDefinition().getColumnNames());
+            final Set<String> unadjustedParentColumnNameSet = unadjustedParentTable.getDefinition().getColumnNameSet();
             final String[] retainedResultColumnNames = parentTable.getDefinition().getColumnStream()
                     .map(ColumnDefinition::getName)
-                    .filter(cn -> !keyColumnNameSet.contains(cn))
+                    .filter(Predicate.not(keyColumnNameSet::contains))
                     .filter(unadjustedParentColumnNameSet::contains)
                     .toArray(String[]::new);
             final ModifiedColumnSet[] retainedResultModifiedColumnSets = Arrays.stream(retainedResultColumnNames)

engine/table/src/main/java/io/deephaven/engine/table/impl/hierarchical/RollupTableImpl.java

@@ -465,7 +465,7 @@ public static RollupTable makeRollup(
                 source.getAttributes(ak -> shouldCopyAttribute(ak, CopyAttributeOperation.Rollup)),
                 source, aggregations, includeConstituents, groupByColumns,
                 levelTables, levelRowLookups, levelNodeTableSources, null, null, null, null, null);
-        source.copySortableColumns(result, baseLevel.getDefinition().getColumnNameMap()::containsKey);
+        source.copySortableColumns(result, baseLevel.getDefinition().getColumnNameSet()::contains);
         result.setColumnDescriptions(AggregationDescriptions.of(aggregations));
         return result;
     }

engine/table/src/main/java/io/deephaven/engine/table/impl/updateby/UpdateBy.java

@@ -1189,7 +1189,7 @@ public static Table updateBy(@NotNull final QueryTable source,
 
         final Collection<List<ColumnUpdateOperation>> windowSpecs =
                 updateByOperatorFactory.getWindowOperatorSpecs(clauses);
-        if (windowSpecs.size() == 0) {
+        if (windowSpecs.isEmpty()) {
             throw new IllegalArgumentException("At least one operator must be specified");
         }
 
@@ -1199,7 +1199,7 @@ public static Table updateBy(@NotNull final QueryTable source,
 
         final MutableObject<String> timestampColumnName = new MutableObject<>(null);
         // create an initial set of all source columns
-        final LinkedHashSet<String> preservedColumnSet = new LinkedHashSet<>(source.getDefinition().getColumnNames());
+        final LinkedHashSet<String> preservedColumnSet = new LinkedHashSet<>(source.getDefinition().getColumnNameSet());
 
         final Set<String> problems = new LinkedHashSet<>();
         final Map<String, ColumnSource<?>> opResultSources = new LinkedHashMap<>();

engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableAggregationTest.java

@@ -116,12 +116,12 @@ private static Table individualStaticByTest(@NotNull final Table input,
                     Arrays.stream(keySelectColumns).map(SelectColumn::getName).distinct().toArray(String[]::new);
 
             if (keyColumns.length == 0) {
-                expectedKeys = TableTools.emptyTable(adjustedInput.size() > 0 ? 1 : 0);
+                expectedKeys = TableTools.emptyTable(!adjustedInput.isEmpty() ? 1 : 0);
                 expected = adjustedInput;
             } else {
                 final Set<String> retainedColumns =
-                        new LinkedHashSet<>(adjustedInput.getDefinition().getColumnNameMap().keySet());
-                retainedColumns.removeAll(Arrays.stream(keyNames).collect(Collectors.toSet()));
+                        new LinkedHashSet<>(adjustedInput.getDefinition().getColumnNameSet());
+                Arrays.asList(keyNames).forEach(retainedColumns::remove);
                 final List<SelectColumn> allSelectColumns =
                         Stream.concat(Arrays.stream(keySelectColumns), retainedColumns.stream().map(SourceColumn::new))
                                 .collect(Collectors.toList());
@@ -887,7 +887,7 @@ public void testKeyColumnTypes() {
                         new BigDecimalGenerator(),
                         new IntGenerator()));
 
-        final Set<String> keyColumnSet = new LinkedHashSet<>(table.getDefinition().getColumnNames());
+        final Set<String> keyColumnSet = new LinkedHashSet<>(table.getDefinition().getColumnNameSet());
         keyColumnSet.remove("NonKey");
         final String[] keyColumns = keyColumnSet.toArray(CollectionUtil.ZERO_LENGTH_STRING_ARRAY);
 

engine/test-utils/src/main/java/io/deephaven/engine/testutil/TstUtils.java

@@ -20,6 +20,8 @@
 import io.deephaven.engine.table.Table;
 import io.deephaven.engine.table.impl.AbstractColumnSource;
 import io.deephaven.engine.table.impl.BaseTable;
+import io.deephaven.engine.table.impl.NoSuchColumnException;
+import io.deephaven.engine.table.impl.NoSuchColumnException.Type;
 import io.deephaven.engine.table.impl.PrevColumnSource;
 import io.deephaven.engine.table.impl.QueryTable;
 import io.deephaven.engine.table.impl.select.Formula;
@@ -173,11 +175,12 @@ public static void addToTable(final Table table, final RowSet rowSet, final Colu
             }
         }
 
-        if (!usedNames.containsAll(table.getDefinition().getColumnNameSet())) {
-            final Set<String> expected = new LinkedHashSet<>(table.getDefinition().getColumnNameSet());
-            expected.removeAll(usedNames);
-            throw new IllegalStateException("Not all columns were populated, missing " + expected);
-        }
+        NoSuchColumnException.throwIf(
+                table.getDefinition().getColumnNameSet(),
+                usedNames,
+                "Not all columns were populated, missing [%s], available [%s]",
+                Type.MISSING,
+                Type.AVAILABLE);
 
         table.getRowSet().writableCast().insert(rowSet);
         if (table.isFlat()) {

engine/test-utils/src/main/java/io/deephaven/engine/testutil/locations/TableBackedColumnLocation.java

@@ -26,7 +26,7 @@ public final class TableBackedColumnLocation
             @NotNull final TableBackedTableLocation tableLocation,
             @NotNull final String name) {
         super(tableLocation, name);
-        columnSource = tableLocation.table().getDefinition().getColumnNameMap().containsKey(name)
+        columnSource = tableLocation.table().getDefinition().getColumnNameSet().contains(name)
                 ? ReinterpretUtils.maybeConvertToPrimitive(tableLocation.table().getColumnSource(name))
                 : null;
     }

server/src/main/java/io/deephaven/server/table/ops/SelectDistinctGrpcImpl.java

@@ -14,9 +14,9 @@
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
 @Singleton
 public class SelectDistinctGrpcImpl extends GrpcTableOperation<SelectDistinctRequest> {
@@ -34,8 +34,10 @@ public Table create(final SelectDistinctRequest request,
         final Table parent = sourceTables.get(0).get();
 
         // explicitly disallow column expressions
-        final Set<String> requestedMissing = new HashSet<>(request.getColumnNamesList());
-        requestedMissing.removeAll(parent.getDefinition().getColumnNameMap().keySet());
+        final List<String> requestedMissing = request.getColumnNamesList()
+                .stream()
+                .filter(Predicate.not(parent.getDefinition().getColumnNameSet()::contains))
+                .collect(Collectors.toList());
         if (!requestedMissing.isEmpty()) {
             throw Exceptions.statusRuntimeException(Code.FAILED_PRECONDITION,
                     "column(s) not found: " + String.join(", ", requestedMissing));