Some more cleanup

- Use EMPTY_ARRAY instead of returning a new array each time from the EmptyGridModel
  - Reduces re-renders
- Save the current viewport in IrisGridProxyModel, and apply it to the new model if the columns haven't changed
- Clean up hydration/dehydration
  - Needed to dehydrate the value correctly

packages/iris-grid/src/EmptyIrisGridModel.ts

@@ -18,6 +18,7 @@ import {
   Table,
 } from '@deephaven/jsapi-types';
 import { ColumnName, Formatter } from '@deephaven/jsapi-utils';
+import { EMPTY_ARRAY, EMPTY_MAP } from '@deephaven/utils';
 import IrisGridModel from './IrisGridModel';
 import ColumnHeaderGroup from './ColumnHeaderGroup';
 import {
@@ -52,27 +53,27 @@ class EmptyIrisGridModel extends IrisGridModel {
   }
 
   get columns(): readonly Column[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   getColumnIndexByName(name: string): ModelIndex | undefined {
     return undefined;
   }
 
   get initialMovedColumns(): readonly MoveOperation[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   get initialMovedRows(): readonly MoveOperation[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   get initialColumnHeaderGroups(): readonly ColumnHeaderGroup[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   get groupedColumns(): readonly Column[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   formatForCell(column: ModelIndex, row: ModelIndex): Format | undefined {
@@ -84,23 +85,23 @@ class EmptyIrisGridModel extends IrisGridModel {
   }
 
   get filter(): readonly FilterCondition[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   set filter(filter: readonly FilterCondition[]) {
     // No-op
   }
 
   get partition(): readonly unknown[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   set partition(partition: readonly unknown[]) {
     // No-op
   }
 
   get partitionColumns(): readonly Column[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   get formatter(): Formatter {
@@ -119,24 +120,24 @@ class EmptyIrisGridModel extends IrisGridModel {
     return '';
   }
 
-  get sort(): Sort[] {
-    return [];
+  get sort(): readonly Sort[] {
+    return EMPTY_ARRAY;
   }
 
-  set sort(sort: Sort[]) {
+  set sort(sort: readonly Sort[]) {
     // No-op
   }
 
   get customColumns(): readonly ColumnName[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   set customColumns(customColumns: readonly ColumnName[]) {
     // No-op
   }
 
   get formatColumns(): readonly CustomColumn[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   updateFrozenColumns(columns: readonly ColumnName[]): void {
@@ -168,15 +169,15 @@ class EmptyIrisGridModel extends IrisGridModel {
   }
 
   get selectDistinctColumns(): readonly ColumnName[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   set selectDistinctColumns(selectDistinctColumns: readonly ColumnName[]) {
     // No-op
   }
 
   get pendingDataMap(): PendingDataMap {
-    return new Map();
+    return EMPTY_MAP;
   }
 
   set pendingDataMap(map: PendingDataMap) {
@@ -192,7 +193,7 @@ class EmptyIrisGridModel extends IrisGridModel {
   }
 
   get pendingDataErrors(): PendingDataErrorMap {
-    return new Map();
+    return EMPTY_MAP;
   }
 
   commitPending(): Promise<void> {
@@ -240,15 +241,15 @@ class EmptyIrisGridModel extends IrisGridModel {
   }
 
   get columnHeaderGroups(): readonly ColumnHeaderGroup[] {
-    return [];
+    return EMPTY_ARRAY;
   }
 
   set columnHeaderGroups(groups: readonly ColumnHeaderGroup[]) {
     // No-op
   }
 
   get columnHeaderGroupMap(): ReadonlyMap<string, ColumnHeaderGroup> {
-    return new Map();
+    return EMPTY_MAP;
   }
 
   getColumnHeaderParentGroup(

packages/iris-grid/src/IrisGridPartitionSelector.tsx

@@ -1,4 +1,5 @@
 import React, { Component } from 'react';
+import memoizee from 'memoizee';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { Button } from '@deephaven/components';
 import { vsChevronRight, vsMerge, vsKey } from '@deephaven/icons';
@@ -271,6 +272,15 @@ class IrisGridPartitionSelector extends Component<
     this.setState({ partitionFilters });
   }
 
+  getCachedChangeCallback = memoizee(
+    (index: number) => (value: unknown) =>
+      this.handlePartitionSelect(index, value)
+  );
+
+  getCachedFormatValueCallback = memoizee(
+    (index: number) => (value: unknown) => this.getDisplayValue(index, value)
+  );
+
   render(): JSX.Element {
     const { model, partitionConfig } = this.props;
     const { isLoading, partitionFilters, partitionTables } = this.state;
@@ -285,12 +295,12 @@ class IrisGridPartitionSelector extends Component<
           table={partitionTables?.[index]}
           column={column}
           filter={partitionFilters?.[index]}
-          onChange={value => this.handlePartitionSelect(index, value)}
+          onChange={this.getCachedChangeCallback(index)}
           selectedValue={mode === 'partition' ? partitions[index] : undefined}
           disabled={
             (index > 0 && partitionConfig.mode !== 'partition') || isLoading
           }
-          formatValue={value => this.getDisplayValue(index, value)}
+          formatValue={this.getCachedFormatValueCallback(index)}
         />
         {model.partitionColumns.length - 1 === index || (
           <FontAwesomeIcon icon={vsChevronRight} />

packages/iris-grid/src/IrisGridProxyModel.ts

@@ -91,6 +91,12 @@ class IrisGridProxyModel extends IrisGridModel implements PartitionedGridModel {
 
   selectDistinct: ColumnName[];
 
+  currentViewport?: {
+    top: number;
+    bottom: number;
+    columns?: Column[];
+  };
+
   constructor(
     dh: DhType,
     table: Table | TreeTable | PartitionedTable,
@@ -132,6 +138,7 @@ class IrisGridProxyModel extends IrisGridModel implements PartitionedGridModel {
     log.debug('setModel', model);
 
     const oldModel = this.model;
+    const { columns: oldColumns } = oldModel;
 
     if (oldModel !== this.originalModel) {
       oldModel.close();
@@ -143,11 +150,17 @@ class IrisGridProxyModel extends IrisGridModel implements PartitionedGridModel {
       this.addListeners(model);
     }
 
-    this.dispatchEvent(
-      new EventShimCustomEvent(IrisGridModel.EVENT.COLUMNS_CHANGED, {
-        detail: model.columns,
-      })
-    );
+    if (oldColumns !== model.columns) {
+      this.dispatchEvent(
+        new EventShimCustomEvent(IrisGridModel.EVENT.COLUMNS_CHANGED, {
+          detail: model.columns,
+        })
+      );
+    } else if (this.currentViewport != null) {
+      // If the columns haven't changed, the current viewport should still valid, and needs to be set on the new model
+      const { top, bottom, columns } = this.currentViewport;
+      model.setViewport(top, bottom, columns);
+    }
 
     if (isIrisGridTableModelTemplate(model)) {
       this.dispatchEvent(
@@ -710,8 +723,10 @@ class IrisGridProxyModel extends IrisGridModel implements PartitionedGridModel {
   isFilterable: IrisGridTableModel['isFilterable'] = (...args) =>
     this.model.isFilterable(...args);
 
-  setViewport = (top: number, bottom: number, columns?: Column[]): void =>
+  setViewport = (top: number, bottom: number, columns?: Column[]): void => {
+    this.currentViewport = { top, bottom, columns };
     this.model.setViewport(top, bottom, columns);
+  };
 
   snapshot: IrisGridModel['snapshot'] = (...args) =>
     this.model.snapshot(...args);

packages/iris-grid/src/IrisGridTableModel.ts

@@ -210,30 +210,16 @@ class IrisGridTableModel
   async partitionTable(partitions: unknown[]): Promise<Table> {
     log.debug('getting partition table for partitions', partitions);
 
-    const partitionFilters = [];
+    const partitionFilters: FilterCondition[] = [];
     for (let i = 0; i < this.partitionColumns.length; i += 1) {
       const partition = partitions[i];
       const partitionColumn = this.partitionColumns[i];
 
-      if (
-        partition != null &&
-        !(TableUtils.isCharType(partitionColumn.type) && partition === '')
-      ) {
-        const partitionText = TableUtils.isCharType(partitionColumn.type)
-          ? this.displayString(
-              partition,
-              partitionColumn.type,
-              partitionColumn.name
-            )
-          : partition.toString();
-        const partitionFilter = this.tableUtils.makeQuickFilterFromComponent(
-          partitionColumn,
-          partitionText
-        );
-        if (partitionFilter !== null) {
-          partitionFilters.push(partitionFilter);
-        }
-      }
+      const partitionFilter = this.tableUtils.makeFilterRawValue(
+        partitionColumn.type,
+        partition
+      );
+      partitionFilters.push(partitionColumn.filter().eq(partitionFilter));
     }
 
     const t = await this.table.copy();

packages/iris-grid/src/IrisGridUtils.ts

@@ -100,6 +100,8 @@ export type DehydratedUserColumnWidth = [ColumnName, number];
 
 export type DehydratedUserRowHeight = [number, number];
 
+export type DehydratedPartitionConfig = PartitionConfig;
+
 /** @deprecated Use `DehydratedSort` instead */
 export interface LegacyDehydratedSort {
   column: ModelIndex;
@@ -143,7 +145,7 @@ export interface DehydratedIrisGridState {
   pendingDataMap: DehydratedPendingDataMap<string | CellData | null>;
   frozenColumns: readonly ColumnName[];
   columnHeaderGroups?: readonly ColumnGroup[];
-  partitionConfig?: PartitionConfig;
+  partitionConfig?: DehydratedPartitionConfig;
 }
 
 export interface DehydratedIrisGridPanelStateV1 {
@@ -1208,7 +1210,7 @@ class IrisGridUtils {
         children: item.children,
         color: item.color,
       })),
-      partitionConfig,
+      partitionConfig: this.dehydratePartitionConfig(columns, partitionConfig),
     };
   }
 
@@ -1304,7 +1306,7 @@ class IrisGridUtils {
         model,
         columnHeaderGroups ?? model.layoutHints?.columnGroups ?? []
       ).groups,
-      partitionConfig,
+      partitionConfig: this.hydratePartitionConfig(columns, partitionConfig),
     };
   }
 
@@ -1498,6 +1500,38 @@ class IrisGridUtils {
     );
   }
 
+  dehydratePartitionConfig(
+    columns: readonly Column[],
+    partitionConfig: PartitionConfig | undefined
+  ): PartitionConfig | undefined {
+    if (partitionConfig == null) {
+      return partitionConfig;
+    }
+
+    return {
+      ...partitionConfig,
+      partitions: partitionConfig.partitions.map((partition, index) =>
+        this.dehydrateValue(partition, columns[index].type)
+      ),
+    };
+  }
+
+  hydratePartitionConfig(
+    columns: readonly Column[],
+    partitionConfig: PartitionConfig | undefined
+  ): PartitionConfig | undefined {
+    if (partitionConfig == null) {
+      return partitionConfig;
+    }
+
+    return {
+      ...partitionConfig,
+      partitions: partitionConfig.partitions.map((partition, index) =>
+        this.hydrateValue(partition, columns[index].type)
+      ),
+    };
+  }
+
   /**
    * Dehydrates/serializes a value for storage.
    * @param  value The value to dehydrate