Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions .changeset/table-sort-aliased-columns.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
---
'@hyperdx/app': patch
'@hyperdx/common-utils': patch
---

fix: Fix table sorting for formula, group by, and multi-series metric aliases
221 changes: 220 additions & 1 deletion packages/app/src/components/DBTable/__tests__/sorting.test.ts
Original file line number Diff line number Diff line change
@@ -1,4 +1,13 @@
import { numericRowSortingFn } from '@/components/DBTable/sorting';
import {
BuilderChartConfig,
DisplayType,
MetricsDataType,
} from '@hyperdx/common-utils/dist/types';

import {
getAliasedResultColumns,
numericRowSortingFn,
} from '@/components/DBTable/sorting';

function makeRow(value: unknown) {
return { getValue: (_key: string) => value } as any;
Expand Down Expand Up @@ -60,3 +69,213 @@ describe('numericRowSortingFn', () => {
).toBeGreaterThan(0);
});
});

describe('getAliasedResultColumns', () => {
const METRIC_TABLES = {
gauge: 'otel_metrics_gauge',
sum: 'otel_metrics_sum',
histogram: 'otel_metrics_histogram',
summary: 'otel_metrics_summary',
'exponential histogram': 'otel_metrics_exponential_histogram',
};

const makeConfig = (
overrides: Partial<BuilderChartConfig>,
): BuilderChartConfig => ({
displayType: DisplayType.Table,
connection: 'conn',
from: { databaseName: 'default', tableName: 'otel_traces' },
timestampValueExpression: 'Timestamp',
where: '',
select: [],
...overrides,
});

const meta = (...names: string[]) =>
names.map(name => ({ name, type: 'Float64' }));

const gauge = (alias?: string) => ({
aggFn: 'avg' as const,
valueExpression: 'Value',
metricName: 'cpu',
metricType: MetricsDataType.Gauge,
alias,
});

it('includes series aliases but not unaliased series', () => {
const config = makeConfig({
select: [
{ aggFn: 'count', valueExpression: '' },
{ aggFn: 'avg', valueExpression: 'Duration', alias: 'duration min' },
{ aggFn: 'max', valueExpression: 'Duration', alias: ' ' },
],
});
expect(
getAliasedResultColumns(
config,
meta('count()', 'duration min', 'max(Duration)'),
),
).toEqual(new Set(['duration min']));
});

it('includes every formula column, and operands only when aliased', () => {
const config = makeConfig({
select: [
{ aggFn: 'count', valueExpression: '' },
{ aggFn: 'avg', valueExpression: 'Duration', alias: 'avg dur' },
],
formulas: [
{ expression: 'B / A', alias: 'duration min' },
{ expression: 'A * 2' },
],
});
expect(
getAliasedResultColumns(
config,
meta('count()', 'avg dur', 'duration min', 'A * 2'),
),
).toEqual(new Set(['avg dur', 'duration min', 'A * 2']));
});

it('includes formula columns when the operands are hidden', () => {
const config = makeConfig({
select: [
{ aggFn: 'count', valueExpression: '' },
{ aggFn: 'avg', valueExpression: 'Duration' },
],
formulas: [{ expression: 'B / A', alias: 'duration min' }],
showOperandSeries: false,
groupBy: 'ServiceName',
});
expect(
getAliasedResultColumns(config, meta('duration min', 'ServiceName')),
).toEqual(new Set(['duration min']));
});

it('excludes the merged ratio column', () => {
const config = makeConfig({
select: [
{ aggFn: 'count', valueExpression: '', alias: 'errors' },
{ aggFn: 'count', valueExpression: '', alias: 'total' },
],
seriesReturnType: 'ratio',
});
expect(
getAliasedResultColumns(config, meta('divide(errors, total)')),
).toEqual(new Set());
});

it('includes aliased group-by entries from a group-by string', () => {
const config = makeConfig({
select: [{ aggFn: 'count', valueExpression: '' }],
groupBy: `ServiceName, SpanAttributes['http.method'], ResourceAttributes['service.name'] AS "svc name", toString(Duration > 1000) as slow`,
});
expect(
getAliasedResultColumns(
config,
meta(
'count()',
'ServiceName',
"arrayElement(SpanAttributes, 'http.method')",
'svc name',
'slow',
),
),
).toEqual(new Set(['svc name', 'slow']));
});

it('includes aliased entries from a structured group-by', () => {
const config = makeConfig({
select: [{ aggFn: 'count', valueExpression: '' }],
groupBy: [
{ valueExpression: 'ServiceName' },
{
valueExpression: "ResourceAttributes['service.name']",
alias: 'svc name',
},
],
});
expect(
getAliasedResultColumns(
config,
meta('count()', 'ServiceName', 'svc name'),
),
).toEqual(new Set(['svc name']));
});

it('treats a single-series metric like any other query', () => {
const config = makeConfig({
metricTables: METRIC_TABLES,
select: [gauge()],
groupBy: `ServiceName, ResourceAttributes['service.name'] AS "svc name"`,
});
expect(
getAliasedResultColumns(
config,
meta(
'avg(toFloat64OrDefault(toString(LastValue)))',
'ServiceName',
'svc name',
),
),
).toEqual(new Set(['svc name']));
});

it.each([
{
name: 'multiple series',
select: [gauge('cpu avg'), gauge()],
formulas: undefined,
},
{
name: 'a single series with a formula',
select: [gauge()],
formulas: [{ expression: 'A * 100' }],
},
])(
'includes every column of a metric query with $name',
({ select, formulas }) => {
const config = makeConfig({
metricTables: METRIC_TABLES,
select,
formulas,
groupBy: `ServiceName, Attributes['host']`,
});
const names = [
'avg(cpu)',
'ServiceName',
"arrayElement(Attributes, 'host')",
];
expect(getAliasedResultColumns(config, meta(...names))).toEqual(
new Set(names),
);
},
);

it('leaves the packed group column of a histogram bare', () => {
const config = makeConfig({
metricTables: METRIC_TABLES,
select: [
{
aggFn: 'quantile',
level: 0.95,
valueExpression: 'Value',
metricName: 'latency',
metricType: MetricsDataType.Histogram,
alias: 'p95 lat',
},
],
groupBy: `ServiceName, Attributes['host'] AS "the host"`,
});
expect(getAliasedResultColumns(config, meta('group', 'p95 lat'))).toEqual(
new Set(['p95 lat']),
);
});

it('returns nothing for a string select', () => {
const config = makeConfig({ select: 'count() AS "total count"' });
expect(getAliasedResultColumns(config, meta('total count'))).toEqual(
new Set(),
);
});
});
52 changes: 52 additions & 0 deletions packages/app/src/components/DBTable/sorting.ts
Original file line number Diff line number Diff line change
Expand Up @@ -2,8 +2,13 @@ import {
ColumnMetaType,
convertCHDataTypeToJSType,
} from '@hyperdx/common-utils/dist/clickhouse';
import { isComposedMetricChartConfig } from '@hyperdx/common-utils/dist/core/renderChartConfig';
import { BuilderChartConfig } from '@hyperdx/common-utils/dist/types';
import { Row, SortingFnOption } from '@tanstack/react-table';

import { getBuilderGroupByColumns } from '@/hooks/useResultColumnFilterKeys';
import { getBuilderValueColumnCount, getFormulaConfig } from '@/source';

export const numericRowSortingFn = ((
a: Row<unknown>,
b: Row<unknown>,
Expand Down Expand Up @@ -38,3 +43,50 @@ export const getClientSideSortingFn = (
// metadata indicates that the column type is date (in which case the value will be a string type in JS)
return 'alphanumeric';
};

const isNonEmptyAlias = (alias: string | undefined) =>
alias != null && alias.trim() !== '';

/**
* The result columns of a builder table query that are explicit aliases in
* its final SELECT. ORDER BY must reference those by their quoted name, and
* every other column by its bare expression: ClickHouse re-evaluates a bare
* expression, but can't resolve a quoted auto-generated name like `"count()"`.
*/
export function getAliasedResultColumns(
config: BuilderChartConfig,
meta: ColumnMetaType[],
): Set<string> {
if (!Array.isArray(config.select)) {
return new Set();
}
if (isComposedMetricChartConfig(config)) {
return new Set(meta.map(column => column.name));
}

// Matched by name, not position: a histogram puts its packed group column
// ahead of the value column, and a ratio merges its series into one
// unaliased column.
const seriesAliases = new Set(
config.select.flatMap(s => (isNonEmptyAlias(s.alias) ? [s.alias] : [])),
);
const aliased = new Set(
meta.map(column => column.name).filter(name => seriesAliases.has(name)),
);
// Formula columns are always aliased, by their alias or expression, and
// follow the operand columns. They're matched by position because duplicate
// names get a suffix.
const formulaConfig = getFormulaConfig(config);
if (formulaConfig) {
const operandCount = formulaConfig.operandsHidden
? 0
: config.select.length;
meta
.slice(operandCount, getBuilderValueColumnCount(config))
.forEach(column => aliased.add(column.name));
}
for (const { column, alias } of getBuilderGroupByColumns(config, meta)) {
if (alias != null) aliased.add(column.name);
}
return aliased;
}
43 changes: 19 additions & 24 deletions packages/app/src/components/DBTableChart.tsx
Original file line number Diff line number Diff line change
@@ -1,6 +1,9 @@
import { useCallback, useMemo, useState } from 'react';
import { inferNumericColumn } from '@hyperdx/common-utils/dist/clickhouse';
import { isRatioChartConfig } from '@hyperdx/common-utils/dist/core/renderChartConfig';
import {
isRatioChartConfig,
quotedColumnName,
} from '@hyperdx/common-utils/dist/core/renderChartConfig';
import {
isBuilderChartConfig,
isPromqlChartConfig,
Expand Down Expand Up @@ -39,7 +42,10 @@ import ChartErrorState, {
ChartErrorStateVariant,
} from './charts/ChartErrorState';
import type { CellFilterHandler } from './DBTable/DBRowTableFieldWithPopover';
import { getClientSideSortingFn } from './DBTable/sorting';
import {
getAliasedResultColumns,
getClientSideSortingFn,
} from './DBTable/sorting';
import MVOptimizationIndicator from './MaterializedViews/MVOptimizationIndicator';

export default function DBTableChart({
Expand Down Expand Up @@ -139,25 +145,14 @@ export default function DBTableChart({
});
const { observerRef: fetchMoreRef } = useIntersectionObserver(fetchNextPage);

// Returns an array of aliases, so we can check if something is using an alias
const aliasMap = useMemo(() => {
if (isRawSqlChartConfig(config) || isPromqlChartConfig(config)) {
return [];
}

// If the config.select is a string, we can't infer this.
// One day, we could potentially run this through chSqlToAliasMap but AST parsing
// doesn't work for most DBTableChart queries.
if (typeof config.select === 'string') {
return [];
}
return config.select.reduce((acc, select) => {
if (select.alias) {
acc.push(select.alias);
}
return acc;
}, [] as string[]);
}, [config]);
const resultMeta = data?.meta;
const aliasedColumns = useMemo(
() =>
isBuilderChartConfig(queriedConfig) && resultMeta
? getAliasedResultColumns(queriedConfig, resultMeta)
: new Set<string>(),
[queriedConfig, resultMeta],
);

const { formatByColumn } = useChartNumberFormats(queriedConfig, data?.meta);

Expand Down Expand Up @@ -257,8 +252,8 @@ export default function DBTableChart({
return orderedKeys
.filter(key => !hiddenColumns?.includes(key))
.map(key => ({
// If it's an alias, wrap in quotes to support a variety of formats (ex "Time (ms)", "Req/s", etc)
id: aliasMap.includes(key) ? `"${key}"` : key,
// The sort id becomes the ORDER BY expression (see queriedConfig).
id: aliasedColumns.has(key) ? quotedColumnName(key) : key,
Comment thread
pulpdrew marked this conversation as resolved.
Resolved
dataKey: key,
displayName: key,
numberFormat: groupByKeys.includes(key)
Expand All @@ -276,7 +271,7 @@ export default function DBTableChart({
queriedConfig,
hiddenColumns,
filterKeyByColumn,
aliasMap,
aliasedColumns,
formatByColumn,
colorByColumn,
rulesByColumn,
Expand Down
Loading
Loading