:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import './DataTable.scss'
import clsx from 'clsx'
import { BindLogic, BuiltLogic, LogicWrapper, useActions, useValues } from 'kea'
import { useCallback, useMemo, useRef, useState } from 'react'
import { PreAggregatedBadge } from 'lib/components/PreAggregatedBadge'
import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { TaxonomicPopover } from 'lib/components/TaxonomicPopover/TaxonomicPopover'
import ViewRecordingButton, { RecordingPlayerType } from 'lib/components/ViewRecordingButton/ViewRecordingButton'
import { dayjs } from 'lib/dayjs'
import { useFeatureFlag } from 'lib/hooks/useFeatureFlag'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonDivider } from 'lib/lemon-ui/LemonDivider'
import { LemonTable, LemonTableColumn } from 'lib/lemon-ui/LemonTable'
import { useAttachedLogic } from 'lib/logic/scenes/useAttachedLogic'
import { InsightEmptyState, InsightErrorState } from 'scenes/insights/EmptyStates'
import { createMarketingAnalyticsOrderBy } from 'scenes/web-analytics/tabs/marketing-analytics/frontend/logic/utils'
import { DataNodeLogicProps, dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
import { DateRange } from '~/queries/nodes/DataNode/DateRange'
import { ElapsedTime } from '~/queries/nodes/DataNode/ElapsedTime'
import { LoadNext } from '~/queries/nodes/DataNode/LoadNext'
import { Reload } from '~/queries/nodes/DataNode/Reload'
import { SupportTracesFilters } from '~/queries/nodes/DataNode/SupportTracesFilters'
import { TestAccountFilters } from '~/queries/nodes/DataNode/TestAccountFilters'
import { BackToSource } from '~/queries/nodes/DataTable/BackToSource'
import { buildSampleTable } from '~/queries/nodes/DataTable/buildSampleTable'
import { ColumnConfigurator } from '~/queries/nodes/DataTable/ColumnConfigurator/ColumnConfigurator'
import { DataTableCount } from '~/queries/nodes/DataTable/DataTableCount'
import { DataTableExport } from '~/queries/nodes/DataTable/DataTableExport'
import { DataTableLogicProps, DataTableRow, dataTableLogic } from '~/queries/nodes/DataTable/dataTableLogic'
import { DataTableSavedFilters } from '~/queries/nodes/DataTable/DataTableSavedFilters'
import { DataTableSavedFiltersButton } from '~/queries/nodes/DataTable/DataTableSavedFiltersButton'
import { EventRowActions } from '~/queries/nodes/DataTable/EventRowActions'
import { InsightActorsQueryOptions } from '~/queries/nodes/DataTable/InsightActorsQueryOptions'
import { QueryFeature } from '~/queries/nodes/DataTable/queryFeatures'
import { DATETIME_KEYS, getContextColumn, renderColumn } from '~/queries/nodes/DataTable/renderColumn'
import { renderColumnMeta } from '~/queries/nodes/DataTable/renderColumnMeta'
import { SavedQueries } from '~/queries/nodes/DataTable/SavedQueries'
import { TableViewSelector } from '~/queries/nodes/DataTable/TableView/TableViewSelector'
import {
extractExpressionComment,
getDataNodeDefaultColumns,
orderByForSelectKey,
removeAsAlias,
removeExpressionComment,
} from '~/queries/nodes/DataTable/utils'
import { EventName } from '~/queries/nodes/EventsNode/EventName'
import { EventPropertyFilters } from '~/queries/nodes/EventsNode/EventPropertyFilters'
import { EventsFilter } from '~/queries/nodes/EventsNode/EventsFilter'
import { HogQLQueryEditor } from '~/queries/nodes/HogQLQuery/HogQLQueryEditor'
import { insightVizDataNodeKey } from '~/queries/nodes/InsightViz/insightVizKeys'
import { EditHogQLButton } from '~/queries/nodes/Node/EditHogQLButton'
import { OpenEditorButton } from '~/queries/nodes/Node/OpenEditorButton'
import { PersonPropertyFilters } from '~/queries/nodes/PersonsNode/PersonPropertyFilters'
import { PersonsSearch } from '~/queries/nodes/PersonsNode/PersonsSearch'
import { SessionPropertyFilters } from '~/queries/nodes/SessionsNode/SessionPropertyFilters'
import { TracesSearch } from '~/queries/nodes/TracesQuery/TracesSearch'
import { isActorsQuery, isHogQLQuery } from '~/queries/schema/node-guards'
import {
ActorsQuery,
AnyResponseType,
DataTableNode,
EventsNode,
EventsQuery,
GroupsQuery,
HogQLQuery,
MarketingAnalyticsTableQuery,
NodeKind,
PersonsNode,
SessionAttributionExplorerQuery,
SessionsQuery,
TracesQuery,
WebAnalyticsPreComputeStrategy,
} from '~/queries/schema/schema-general'
import { QueryContext } from '~/queries/types'
import {
isEventsQuery,
isGroupsQuery,
isHogQLAggregation,
isInsightActorsQuery,
isMarketingAnalyticsTableQuery,
isSessionsQuery,
taxonomicEventFilterToHogQL,
taxonomicGroupFilterToHogQL,
taxonomicPersonFilterToHogQL,
taxonomicSessionFilterToHogQL,
} from '~/queries/utils'
import { CampaignMappingCellActions } from '~/scenes/web-analytics/tabs/marketing-analytics/frontend/components/CampaignMapping/CampaignMappingCellActions'
import { getMappableColumn } from '~/scenes/web-analytics/tabs/marketing-analytics/frontend/components/CampaignMapping/mappingUtils'
import { EventType, InsightLogicProps } from '~/types'
import { ViewLinkButton } from 'products/data_warehouse/frontend/shared/components/ViewLinkModal'
import { PersonDeleteModal } from 'products/persons/frontend/components/PersonDeleteModal'
import { GroupPropertyFilters } from '../GroupsQuery/GroupPropertyFilters'
import { GroupsSearch } from '../GroupsQuery/GroupsSearch'
import { DataTableOpenEditor } from './DataTableOpenEditor'
import { DataTableViewReplays } from './DataTableViewReplays'
import { ExpandedEventRow } from './ExpandedEventRow'
import { TableViewSupportedQueryType } from './TableView/tableViewLogic'
export enum ColumnFeature {
canSort = 'canSort',
canEdit = 'canEdit',
canAddColumns = 'canAddColumns',
canRemove = 'canRemove',
canPin = 'canPin',
}
interface DataTableProps {
uniqueKey?: string | number
query: DataTableNode
setQuery: (query: DataTableNode) => void
/** Custom table columns and export configuration */
context?: QueryContext<DataTableNode>
/* Cached Results are provided when shared or exported,
the data node logic becomes read only implicitly */
cachedResults?: AnyResponseType
// Override the data logic node key if needed
dataNodeLogicKey?: string
readOnly?: boolean
/*
Set a data-attr on the LemonTable component
*/
dataAttr?: string
/** Attach ourselves to another logic, such as the scene logic */
attachTo?: BuiltLogic | LogicWrapper
}
const eventGroupTypes = [
TaxonomicFilterGroupType.HogQLExpression,
TaxonomicFilterGroupType.EventProperties,
TaxonomicFilterGroupType.PersonProperties,
TaxonomicFilterGroupType.EventFeatureFlags,
]
const personGroupTypes = [TaxonomicFilterGroupType.HogQLExpression, TaxonomicFilterGroupType.PersonProperties]
const sessionGroupTypes = [
TaxonomicFilterGroupType.HogQLExpression,
TaxonomicFilterGroupType.SessionProperties,
TaxonomicFilterGroupType.PersonProperties,
]
// Stable empty-rows reference: a fresh `[]` per render would defeat row memoization downstream.
const NO_ROWS: DataTableRow[] = []
const DEFAULT_COLUMN_FEATURES = [
ColumnFeature.canSort,
ColumnFeature.canEdit,
ColumnFeature.canAddColumns,
ColumnFeature.canRemove,
]
let uniqueNode = 0
export function DataTable({
uniqueKey,
query,
setQuery,
context,
cachedResults,
readOnly,
dataAttr,
attachTo,
}: DataTableProps): JSX.Element {
const [uniqueNodeKey] = useState(() => uniqueNode++)
const [dataKey] = useState(() => `DataNode.${uniqueKey || uniqueNodeKey}`)
const insightProps: InsightLogicProps<DataTableNode> = context?.insightProps || {
dashboardItemId: `new-AdHoc.${dataKey}`,
dataNodeCollectionId: dataKey,
}
// support for existing column features by default
const columnFeatures = context?.columnFeatures || DEFAULT_COLUMN_FEATURES
const vizKey = insightVizDataNodeKey(insightProps)
const dataNodeLogicProps: DataNodeLogicProps = {
query: query.source,
key: context?.dataNodeLogicKey ?? vizKey,
cachedResults: cachedResults,
retainResponseOnUnmount: insightProps.retainResponseOnUnmount,
dataNodeCollectionId: context?.insightProps?.dataNodeCollectionId || dataKey,
refresh: context?.refresh,
maxPaginationLimit: context?.dataTableMaxPaginationLimit,
maxPaginationRows: context?.dataTableMaxPaginationRows,
limitContext: context?.limitContext,
}
const {
response,
responseLoading,
responseError,
responseErrorObject,
queryId,
queryCancelled,
nextDataLoading,
newDataLoading,
highlightedRows,
backToSourceQuery,
canLoadNextData,
} = useValues(dataNodeLogic(dataNodeLogicProps))
const { loadData } = useActions(dataNodeLogic(dataNodeLogicProps))
const canUseWebAnalyticsPreAggregatedTables = useFeatureFlag('SETTINGS_WEB_ANALYTICS_PRE_AGGREGATED_TABLES')
const hasCustomerAnalyticsEnabled = useFeatureFlag('CUSTOMER_ANALYTICS')
const preComputeStrategy = response && 'preComputeStrategy' in response ? response.preComputeStrategy : undefined
const usedWebAnalyticsPreAggregatedTables =
canUseWebAnalyticsPreAggregatedTables &&
preComputeStrategy === WebAnalyticsPreComputeStrategy.PreAggregated &&
response &&
'hogql' in response &&
response.hogql
// Lazy precompute can be on without the v2 pre-agg flag, so it surfaces a
// badge regardless of `canUseWebAnalyticsPreAggregatedTables`.
const usedWebAnalyticsLazyPrecompute = preComputeStrategy === WebAnalyticsPreComputeStrategy.LazyPrecompute
const preComputedAt = response && 'preComputedAt' in response ? response.preComputedAt : undefined
const preComputeStale = response && 'preComputeStale' in response ? response.preComputeStale : undefined
const dataTableLogicProps: DataTableLogicProps = {
query,
vizKey: uniqueKey ? String(uniqueKey) : vizKey,
dataKey,
dataNodeLogicKey: dataNodeLogicProps.key,
context,
}
const {
dataTableRows,
columnsInQuery,
columnsInResponse,
queryWithDefaults,
canSort,
sourceFeatures,
expandedRows,
} = useValues(dataTableLogic(dataTableLogicProps))
const { toggleRowExpanded } = useActions(dataTableLogic(dataTableLogicProps))
useAttachedLogic(dataNodeLogic(dataNodeLogicProps), attachTo)
useAttachedLogic(dataTableLogic(dataTableLogicProps), attachTo)
const {
showActions,
showRecordingColumn,
showDateRange,
showTestAccountFilters,
showSearch,
showEventFilter,
showEventsFilter,
showPropertyFilter,
showHogQLEditor,
showReload,
showCount,
showExport,
showElapsedTime,
showColumnConfigurator,
showPersistentColumnConfigurator,
showSavedQueries,
showSavedFilters,
showTableViews,
expandable,
embedded,
showOpenEditorButton,
showResultsTable,
showTimings,
showSourceQueryOptions,
} = queryWithDefaults
const isReadOnly = !!readOnly
const eventActionsColumnShown =
showActions && sourceFeatures.has(QueryFeature.eventActionsColumn) && columnsInResponse?.includes('*')
const recordingColumnShown =
showRecordingColumn && sourceFeatures.has(QueryFeature.eventActionsColumn) && columnsInResponse?.includes('*')
const hideRecordingButton = recordingColumnShown || context?.hideRecordingButton
const allColumns = useMemo(
() =>
sourceFeatures.has(QueryFeature.columnsInResponse) ? (columnsInResponse ?? columnsInQuery) : columnsInQuery,
[sourceFeatures, columnsInResponse, columnsInQuery]
)
const contextColumns = context?.columns
const columnFormatsRef = useRef<(string | null)[] | undefined>(undefined)
columnFormatsRef.current =
isHogQLQuery(query.source) && response && 'column_formats' in response
? (response.column_formats as (string | null)[] | undefined)
: undefined
const columnsInLemonTable = useMemo(
() =>
allColumns.filter((colName) => {
const col = getContextColumn(colName, contextColumns)
return !col?.queryContextColumn?.hidden
}),
[allColumns, contextColumns]
)
const sampleRowsSource = context?.dataTableSampleRows
const hasRows = !!dataTableRows?.length
const sampleTable = useMemo(
() =>
sampleRowsSource && !hasRows
? buildSampleTable(sampleRowsSource, columnsInLemonTable, query, context, dayjs())
: undefined,
[sampleRowsSource, hasRows, columnsInLemonTable, query, context]
)
const orderByForKey = useCallback(
(key: string): string => {
const rawSelect = sourceFeatures.has(QueryFeature.selectAndOrderByColumns)
? ((query.source as EventsQuery).select ?? [])
: []
return orderByForSelectKey(key, rawSelect)
},
[sourceFeatures, query.source]
)
const rowFillFractionIndex = allColumns.findIndex((colName) => {
const col = getContextColumn(colName, context?.columns)
return col?.queryContextColumn?.isRowFillFraction
})
const contextRowPropsFn = context?.rowProps
const onRow = useCallback(
(record: DataTableRow) => {
const rowProps = contextRowPropsFn?.(record)
const rowFillFraction =
rowFillFractionIndex >= 0 && Array.isArray(record.result)
? record.result[rowFillFractionIndex]
: undefined
if (
typeof rowFillFraction === 'number' &&
!Number.isNaN(rowFillFraction) &&
rowFillFraction >= 0 &&
rowFillFraction <= 1
) {
return {
...rowProps,
style: {
...rowProps?.style,
'--data-table-fraction-fill': `${Math.round(rowFillFraction * 100)}%`,
},
}
}
return rowProps ?? {}
},
[contextRowPropsFn, rowFillFractionIndex]
)
const groupTypes = isActorsQuery(query.source)
? personGroupTypes
: isSessionsQuery(query.source)
? sessionGroupTypes
: eventGroupTypes
// Memoized so the columns array keeps its identity between data refreshes: LemonTable derives
// column groups from it and passes those to every memoized TableRow, so a per-render rebuild
// here re-renders every row each poll cycle. Intentionally NOT keyed on the response itself.
const lemonColumns: LemonTableColumn<DataTableRow, any>[] = useMemo(
() =>
[
...columnsInLemonTable.map((key, index) => {
return {
dataIndex: key as any,
...renderColumnMeta(key, query, context),
render: function RenderDataTableColumn(
_: any,
{ result, label }: DataTableRow,
recordIndex: number,
rowCount: number
) {
if (label) {
if (index === (expandable ? 1 : 0)) {
return {
children: label,
props: { colSpan: columnsInLemonTable.length + (recordingColumnShown ? 1 : 0) },
}
}
return { props: { colSpan: 0 } }
} else if (result) {
const value = sourceFeatures.has(QueryFeature.resultIsArrayOfArrays)
? (result as any[])[index]
: (result as Record<string, any>)[key]
return renderColumn(
key,
value,
result,
recordIndex,
rowCount,
query,
setQuery,
context,
columnFormatsRef.current?.[index]
)
}
},
sorter: undefined, // using custom sorting code
cellActions:
sourceFeatures.has(QueryFeature.campaignMappingActions) && !!getMappableColumn(key)
? (_: unknown, record: DataTableRow) => {
if (!record.result) {
return null
}
const value = sourceFeatures.has(QueryFeature.resultIsArrayOfArrays)
? (record.result as any[])[index]
: (record.result as Record<string, any>)[key]
return <CampaignMappingCellActions columnName={key} value={value} />
}
: undefined,
more:
!isReadOnly && showActions && sourceFeatures.has(QueryFeature.selectAndOrderByColumns) ? (
<>
<div className="px-2 py-1 max-w-md">
<div className="font-mono font-bold truncate">
{extractExpressionComment(key)}
</div>
{extractExpressionComment(key) !== removeExpressionComment(key) && (
<div className="font-mono truncate">{removeExpressionComment(key)}</div>
)}
</div>
{(isEventsQuery(query.source) || isActorsQuery(query.source)) &&
DATETIME_KEYS.includes(removeExpressionComment(key)) ? (
<>
<LemonDivider />
<LemonButton
fullWidth
data-attr="datatable-toggle-absolute-time"
onClick={() => {
setQuery?.({
...query,
showAbsoluteTime: !query.showAbsoluteTime,
})
}}
>
{query.showAbsoluteTime ? 'Show relative time' : 'Show absolute time'}
</LemonButton>
</>
) : null}
{columnFeatures.includes(ColumnFeature.canEdit) && (
<>
<LemonDivider />
<TaxonomicPopover
groupType={TaxonomicFilterGroupType.HogQLExpression}
value={key}
groupTypes={groupTypes}
metadataSource={query.source}
renderValue={() => <>Edit column</>}
type="tertiary"
fullWidth
selectingKeyOnly
onChange={(v, g) => {
const hogQl = isActorsQuery(query.source)
? taxonomicPersonFilterToHogQL(g, v)
: isSessionsQuery(query.source)
? taxonomicSessionFilterToHogQL(g, v)
: taxonomicEventFilterToHogQL(g, v)
if (
setQuery &&
hogQl &&
sourceFeatures.has(QueryFeature.selectAndOrderByColumns)
) {
// Typecasting to a query type with select and order_by fields.
// The actual query may or may not be an events query.
const source = query.source as EventsQuery
const columns =
columnsInLemonTable ?? getDataNodeDefaultColumns(source)
const isAggregation = isHogQLAggregation(hogQl)
const orderKey = orderByForKey(key)
const isOrderBy = source.orderBy?.[0] === orderKey
const isDescOrderBy =
source.orderBy?.[0] === `${orderKey} DESC` ||
source.orderBy?.[0] === `${orderKey}\n DESC`
setQuery({
...query,
source: {
...source,
select: columns
.map((s, i) => (i === index ? hogQl : s))
.filter((c) =>
isAggregation
? c !== '*' && c !== 'person.$delete'
: true
),
orderBy:
isOrderBy || isDescOrderBy
? [
isDescOrderBy
? `${removeAsAlias(hogQl)}\n DESC`
: removeAsAlias(hogQl),
]
: source.orderBy,
},
})
}
}}
/>
</>
)}
{canSort &&
key !== 'person.$delete' &&
key !== 'person' &&
columnFeatures.includes(ColumnFeature.canSort) ? (
<>
<LemonDivider />
<LemonButton
fullWidth
data-attr="datatable-sort-asc"
onClick={() => {
const orderBy =
query.source.kind === NodeKind.MarketingAnalyticsTableQuery
? createMarketingAnalyticsOrderBy(key, 'ASC')
: [orderByForKey(key)]
setQuery?.({
...query,
source: {
...query.source,
orderBy,
} as EventsQuery,
})
}}
>
Sort ascending
</LemonButton>
<LemonButton
fullWidth
data-attr="datatable-sort-desc"
onClick={() => {
const orderBy =
query.source.kind === NodeKind.MarketingAnalyticsTableQuery
? createMarketingAnalyticsOrderBy(key, 'DESC')
: [`${orderByForKey(key)}\n DESC`]
setQuery?.({
...query,
source: {
...query.source,
orderBy,
} as EventsQuery,
})
}}
>
Sort descending
</LemonButton>
<LemonButton
fullWidth
data-attr="datatable-reset-sort"
onClick={() => {
setQuery?.({
...query,
source: {
...query.source,
orderBy: [],
} as EventsQuery,
})
}}
>
Reset sorting
</LemonButton>
</>
) : null}
{columnFeatures.includes(ColumnFeature.canAddColumns) && (
<>
<LemonDivider />
<TaxonomicPopover
groupType={TaxonomicFilterGroupType.HogQLExpression}
value=""
groupTypes={groupTypes}
metadataSource={query.source}
placeholder={<span className="not-italic">Add column left</span>}
data-attr="datatable-add-column-left"
type="tertiary"
fullWidth
onChange={(v, g) => {
const hogQl = isActorsQuery(query.source)
? taxonomicPersonFilterToHogQL(g, v)
: isGroupsQuery(query.source)
? taxonomicGroupFilterToHogQL(g, v)
: isSessionsQuery(query.source)
? taxonomicSessionFilterToHogQL(g, v)
: taxonomicEventFilterToHogQL(g, v)
if (
setQuery &&
hogQl &&
sourceFeatures.has(QueryFeature.selectAndOrderByColumns)
) {
const isAggregation = isHogQLAggregation(hogQl)
const source = query.source as EventsQuery
const columns =
columnsInLemonTable ?? getDataNodeDefaultColumns(source)
setQuery({
...query,
source: {
...source,
select: [
...columns.slice(0, index),
hogQl,
...columns.slice(index),
].filter((c) =>
isAggregation
? c !== '*' && c !== 'person.$delete'
: true
),
} as EventsQuery | ActorsQuery,
})
}
}}
/>
<TaxonomicPopover
groupType={TaxonomicFilterGroupType.HogQLExpression}
value=""
groupTypes={groupTypes}
metadataSource={query.source}
placeholder={<span className="not-italic">Add column right</span>}
data-attr="datatable-add-column-right"
type="tertiary"
fullWidth
onChange={(v, g) => {
const hogQl = isActorsQuery(query.source)
? taxonomicPersonFilterToHogQL(g, v)
: isGroupsQuery(query.source)
? taxonomicGroupFilterToHogQL(g, v)
: isSessionsQuery(query.source)
? taxonomicSessionFilterToHogQL(g, v)
: taxonomicEventFilterToHogQL(g, v)
if (
setQuery &&
hogQl &&
sourceFeatures.has(QueryFeature.selectAndOrderByColumns)
) {
const isAggregation = isHogQLAggregation(hogQl)
const source = query.source as EventsQuery
const columns =
columnsInLemonTable ?? getDataNodeDefaultColumns(source)
setQuery?.({
...query,
source: {
...source,
select: [
...columns.slice(0, index + 1),
hogQl,
...columns.slice(index + 1),
].filter((c) =>
isAggregation
? c !== '*' && c !== 'person.$delete'
: true
),
} as EventsQuery | ActorsQuery,
})
}
}}
/>
</>
)}
{columnsInQuery.filter((c) => c !== '*').length > 1 &&
columnFeatures.includes(ColumnFeature.canRemove) && (
<>
<LemonDivider />
<LemonButton
fullWidth
status="danger"
data-attr="datatable-remove-column"
onClick={() => {
const cleanColumnKey = removeExpressionComment(key)
const newSource: EventsQuery = {
...(query.source as EventsQuery),
select: (query.source as EventsQuery).select.filter(
(_, i) => i !== index
),
// remove the current column from orderBy if it's there
orderBy: (
query.source as
| EventsQuery
| MarketingAnalyticsTableQuery
).orderBy?.find((orderKey) => {
if (
typeof orderKey === 'object' &&
isMarketingAnalyticsTableQuery(query.source)
) {
return orderKey[0] === cleanColumnKey
} else if (typeof orderKey === 'string') {
return (
removeExpressionComment(orderKey) ===
cleanColumnKey ||
removeExpressionComment(orderKey) ===
`-${cleanColumnKey}`
)
}
})
? undefined
: (query.source as EventsQuery).orderBy,
}
const newPinnedColumns = query.pinnedColumns?.filter(
(column) => column !== key
)
setQuery?.({
...query,
source: newSource,
pinnedColumns: newPinnedColumns,
})
}}
>
Remove column
</LemonButton>
</>
)}
{columnFeatures.includes(ColumnFeature.canPin) && (
<>
<LemonDivider />
<LemonButton
fullWidth
data-attr="datatable-pin-column"
onClick={() => {
let newPinnedColumns = new Set(query.pinnedColumns ?? [])
if (newPinnedColumns.has(key)) {
newPinnedColumns.delete(key)
} else {
newPinnedColumns.add(key)
}
setQuery?.({
...query,
pinnedColumns: Array.from(newPinnedColumns),
})
}}
>
{query.pinnedColumns?.includes(key) ? 'Unpin' : 'Pin column'}
</LemonButton>
</>
)}
</>
) : undefined,
}
}),
...(recordingColumnShown
? [
{
dataIndex: '__recording' as any,
title: '',
render: function RenderRecording(_: any, { label, result }: DataTableRow) {
if (label) {
return { props: { colSpan: 0 } }
}
if (result && columnsInResponse?.includes('*')) {
const event = (result as any[])[columnsInResponse.indexOf('*')]
return (
<ViewRecordingButton
sessionId={event?.properties?.$session_id}
recordingStatus={event?.properties?.$recording_status}
timestamp={event?.timestamp}
hasRecording={event?.properties?.$has_recording as boolean | undefined}
openPlayerIn={RecordingPlayerType.Modal}
size="xsmall"
type="secondary"
/>
)
}
return null
},
width: 100,
align: 'center' as const,
},
]
: []),
].filter((column) => !query.hiddenColumns?.includes(column.dataIndex) && column.dataIndex !== '*'),
[
columnsInLemonTable,
query,
setQuery,
context,
expandable,
recordingColumnShown,
sourceFeatures,
isReadOnly,
showActions,
columnFeatures,
groupTypes,
canSort,
columnsInQuery,
columnsInResponse,
orderByForKey,
]
)
// Hoisted from the LemonTable JSX so these props keep their identity between renders — an
// inline object/closure would defeat TableRow's memo for every row on every render.
const contextExpandable = context?.expandable
const expandableConfig = useMemo(
() =>
contextExpandable
? contextExpandable
: expandable && columnsInResponse?.includes('*')
? {
isRowExpanded: (_: DataTableRow, rowIndex: number) => expandedRows.includes(rowIndex),
onRowExpand: (_: DataTableRow, rowIndex: number) => toggleRowExpanded(rowIndex),
onRowCollapse: (_: DataTableRow, rowIndex: number) => toggleRowExpanded(rowIndex),
expandedRowRender: function renderExpand({ result }: DataTableRow) {
const event =
isEventsQuery(query.source) && Array.isArray(result)
? (result[columnsInResponse.indexOf('*')] ?? {})
: result && !Array.isArray(result)
? (result as EventType)
: null
if (!event) {
return undefined
}
return <ExpandedEventRow event={event} />
},
rowExpandable: ({ result }: DataTableRow) => !!result,
noIndent: true,
}
: undefined,
[contextExpandable, expandable, columnsInResponse, expandedRows, toggleRowExpanded, query.source]
)
const rowActions = useMemo(
() =>
eventActionsColumnShown
? ({ result, label }: DataTableRow) => {
if (label) {
return null
}
if (result && columnsInResponse?.includes('*')) {
return (
<EventRowActions
event={(result as any[])[columnsInResponse.indexOf('*')]}
hideRecordingButton={hideRecordingButton}
/>
)
}
return null
}
: undefined,
[eventActionsColumnShown, columnsInResponse, hideRecordingButton, sourceFeatures]
)
const setQuerySource = useCallback(
(
source:
| EventsNode
| EventsQuery
| PersonsNode
| ActorsQuery
| GroupsQuery
| HogQLQuery
| SessionAttributionExplorerQuery
| SessionsQuery
| TracesQuery
| MarketingAnalyticsTableQuery
) => setQuery?.({ ...query, source }),
[setQuery, query]
)
const firstRowLeft = [
showSourceQueryOptions && backToSourceQuery ? <BackToSource key="return-to-source" /> : null,
showSourceQueryOptions &&
backToSourceQuery &&
isActorsQuery(query.source) &&
isInsightActorsQuery(query.source.source) ? (
<InsightActorsQueryOptions
query={query.source.source}
setQuery={(q) =>
setQuerySource({
...query.source,
source: { ...(query.source as ActorsQuery).source, ...q },
} as ActorsQuery)
}
key="source-query-options"
/>
) : null,
showDateRange && sourceFeatures.has(QueryFeature.dateRangePicker) ? (
<DateRange
key="date-range"
query={
query.source as
| HogQLQuery
| EventsQuery
| SessionAttributionExplorerQuery
| SessionsQuery
| TracesQuery
}
setQuery={setQuerySource}
/>
) : null,
showEventFilter && sourceFeatures.has(QueryFeature.eventNameFilter) ? (
<EventName
key="event-name"
query={query.source as EventsQuery | SessionsQuery}
setQuery={setQuerySource}
includeHiddenEvents={context?.includeHiddenEvents}
/>
) : null,
showEventsFilter && isEventsQuery(query.source) ? (
<EventsFilter
key="events-filter"
query={query.source}
setQuery={setQuerySource}
includeHiddenEvents={context?.includeHiddenEvents}
/>
) : null,
showSearch && sourceFeatures.has(QueryFeature.personsSearch) ? (
<PersonsSearch key="persons-search" query={query.source as PersonsNode} setQuery={setQuerySource} />
) : null,
showSearch && sourceFeatures.has(QueryFeature.groupsSearch) ? (
<GroupsSearch
key="groups-search"
query={query.source as GroupsQuery}
setQuery={setQuerySource}
groupTypeLabel={context?.groupTypeLabel}
/>
) : null,
showSearch && sourceFeatures.has(QueryFeature.tracesSearch) ? (
<TracesSearch key="traces-search" query={query.source as TracesQuery} setQuery={setQuerySource} />
) : null,
showPropertyFilter &&
sourceFeatures.has(QueryFeature.eventPropertyFilters) &&
!isSessionsQuery(query.source) ? (
<EventPropertyFilters
key="event-property"
query={query.source as EventsQuery | HogQLQuery | SessionAttributionExplorerQuery | TracesQuery}
setQuery={setQuerySource}
taxonomicGroupTypes={Array.isArray(showPropertyFilter) ? showPropertyFilter : undefined}
/>
) : null,
showSavedFilters && uniqueKey ? (
<DataTableSavedFiltersButton
key="saved-filters-button"
uniqueKey={String(uniqueKey)}
query={query}
setQuery={setQuery}
/>
) : null,
showTableViews &&
query.contextKey &&
(isActorsQuery(query.source) || isGroupsQuery(query.source) || isEventsQuery(query.source)) ? (
<TableViewSelector
key="table-views"
contextKey={String(query.contextKey)}
query={query.source as TableViewSupportedQueryType}
setQuery={setQuerySource}
/>
) : null,
showPropertyFilter && sourceFeatures.has(QueryFeature.personPropertyFilters) ? (
<PersonPropertyFilters
key="person-property"
query={query.source as PersonsNode}
setQuery={setQuerySource}
/>
) : null,
showPropertyFilter && sourceFeatures.has(QueryFeature.sessionPropertyFilters) ? (
<SessionPropertyFilters
key="session-property"
query={query.source as SessionsQuery}
setQuery={setQuerySource}
/>
) : null,
showPropertyFilter && sourceFeatures.has(QueryFeature.groupPropertyFilters) ? (
<div className="flex gap-2">
<GroupPropertyFilters
key="group-property"
query={query.source as GroupsQuery}
setQuery={setQuerySource}
/>
</div>
) : null,
].filter((x) => !!x)
const firstRowRight = [
showTestAccountFilters && sourceFeatures.has(QueryFeature.testAccountFilters) ? (
<TestAccountFilters key="test-account-filters" query={query.source} setQuery={setQuerySource} />
) : null,
sourceFeatures.has(QueryFeature.supportTracesFilters) ? (
<SupportTracesFilters key="support-traces-filters" query={query.source} setQuery={setQuerySource} />
) : null,
showSavedQueries && sourceFeatures.has(QueryFeature.savedEventsQueries) ? (
<SavedQueries key="saved-queries" query={query} setQuery={setQuery} />
) : null,
].filter((x) => !!x)
const shouldShowCount = showCount && sourceFeatures.has(QueryFeature.showCount)
const secondRowLeft = [
showReload ? <Reload key="reload" /> : null,
showCount && sourceFeatures.has(QueryFeature.showCount) ? (
<DataTableCount key="count" nouns={context?.dataTableNouns} />
) : null,
shouldShowCount && showElapsedTime ? <LemonDivider vertical={true} key="divider" /> : null,
showElapsedTime ? <ElapsedTime key="elapsed-time" showTimings={showTimings} /> : null,
].filter((x) => !!x)
const secondRowRight = [
sourceFeatures.has(QueryFeature.linkDataButton) && hasCustomerAnalyticsEnabled ? (
<ViewLinkButton key="view-link-button" tableName="groups" />
) : null,
...(context?.customActions
? Array.isArray(context.customActions)
? context.customActions
: [context.customActions]
: []),
(showColumnConfigurator || showPersistentColumnConfigurator) &&
sourceFeatures.has(QueryFeature.columnConfigurator) ? (
<ColumnConfigurator key="column-configurator" query={queryWithDefaults} setQuery={setQuery} />
) : null,
<DataTableViewReplays key="data-table-view-replays" />,
showExport ? (
<DataTableExport
key="data-table-export"
query={query}
setQuery={setQuery}
fileNameForExport={context?.fileNameForExport}
excludedColumns={context?.dataTableExportExcludedColumns}
downloadQuery={context?.dataTableExportQuery}
iconOnly={context?.dataTableExportIconOnly}
/>
) : null,
showExport && showOpenEditorButton ? (
<DataTableOpenEditor key="data-table-open-editor" query={query} setQuery={setQuery} />
) : null,
].filter((x) => !!x)
const showFirstRow = !isReadOnly && (firstRowLeft.length > 0 || firstRowRight.length > 0)
const showSecondRow = !isReadOnly && (secondRowLeft.length > 0 || secondRowRight.length > 0)
const inlineEditorButtonOnRow = showFirstRow ? 1 : showSecondRow ? 2 : 0
const editorButton = (
<>
<OpenEditorButton query={query} />
{response && 'hogql' in response && response?.hogql ? <EditHogQLButton hogql={response.hogql} /> : null}
</>
)
// The editor button moved under "export". Show only if there's no export button.
if (!showExport && showOpenEditorButton && !isReadOnly) {
if (inlineEditorButtonOnRow === 1) {
firstRowRight.push(editorButton)
} else if (inlineEditorButtonOnRow === 2) {
secondRowRight.push(editorButton)
}
}
const compactToolbarLeft = [...(showFirstRow ? firstRowLeft : []), ...(showSecondRow ? secondRowLeft : [])]
const compactToolbarRight = [...(showFirstRow ? firstRowRight : []), ...(showSecondRow ? secondRowRight : [])]
return (
<BindLogic logic={dataTableLogic} props={dataTableLogicProps}>
<BindLogic logic={dataNodeLogic} props={dataNodeLogicProps}>
<div className="relative w-full flex flex-col gap-2 flex-1 h-full min-h-0">
{showHogQLEditor && isHogQLQuery(query.source) && !isReadOnly ? (
<HogQLQueryEditor query={query.source} setQuery={setQuerySource} embedded={embedded} />
) : null}
{context?.compactDataTableToolbar ? (
<>
{compactToolbarLeft.length > 0 || compactToolbarRight.length > 0 ? (
<div
className={clsx(
'flex gap-2 items-center flex-wrap',
context?.dataTableToolbarClassName
)}
>
{compactToolbarLeft}
{compactToolbarLeft.length > 0 && compactToolbarRight.length > 0 ? (
<div className="flex-1" />
) : null}
{compactToolbarRight}
</div>
) : null}
{showSavedFilters && uniqueKey ? (
<DataTableSavedFilters
uniqueKey={String(uniqueKey)}
query={query}
setQuery={setQuery}
/>
) : null}
</>
) : (
<>
{showFirstRow && (
<div className="flex gap-2 items-center flex-wrap">
{firstRowLeft}
{firstRowLeft.length > 0 && firstRowRight.length > 0 ? (
<div className="flex-1" />
) : null}
{firstRowRight}
</div>
)}
{showSavedFilters && uniqueKey && (
<DataTableSavedFilters
uniqueKey={String(uniqueKey)}
query={query}
setQuery={setQuery}
/>
)}
{showFirstRow && showSecondRow && <LemonDivider className="my-0" />}
{showSecondRow && secondRowLeft.length > 0 && secondRowRight.length > 0 && (
<div className="flex gap-2 justify-between flex-wrap DataTable__second-row empty:hidden">
<div className="flex gap-2 items-center">{secondRowLeft}</div>
<div className="flex gap-2 items-center">{secondRowRight}</div>
</div>
)}
</>
)}
{showOpenEditorButton && inlineEditorButtonOnRow === 0 && !isReadOnly ? (
<div className="absolute right-0 z-10 p-1">{editorButton}</div>
) : null}
{showResultsTable && (
<div
className={clsx(
'relative',
context?.dataTableAllowContentScroll && 'min-h-0 flex-1 overflow-hidden'
)}
>
{usedWebAnalyticsLazyPrecompute ? (
<PreAggregatedBadge
variant="precomputed"
onDisable={context?.onDisableWebAnalyticsPrecompute}
computedAt={preComputedAt}
stale={preComputeStale}
/>
) : usedWebAnalyticsPreAggregatedTables ? (
<PreAggregatedBadge variant="preagg" />
) : null}
<LemonTable
data-attr={dataAttr}
className="DataTable"
allowContentScroll={context?.dataTableAllowContentScroll}
stickyHeader={context?.dataTableStickyHeader}
loading={responseLoading && !nextDataLoading && !newDataLoading}
columns={lemonColumns}
tableLayout={context?.tableLayout}
tableStyle={context?.tableStyle}
embedded={embedded}
key={
[...(columnsInResponse ?? []), ...columnsInQuery].join(
'::'
) /* Bust the LemonTable cache when columns change */
}
dataSource={dataTableRows ?? NO_ROWS}
rowKey={(_, rowIndex) => {
return rowIndex
}}
sorting={null}
useURLForSorting={false}
emptyState={
responseError ? (
sourceFeatures.has(QueryFeature.displayResponseError) ? (
<InsightErrorState
query={query}
queryId={responseErrorObject?.queryId ?? queryId}
titleStatus={responseErrorObject?.status}
retryAfterTimestamp={responseErrorObject?.retryAfterTimestamp}
// A cancel is the user's own action: no apology or bug-report guidance
excludeDetail={queryCancelled}
onRetry={() => loadData('force_blocking')}
title={
queryCancelled
? 'The query was cancelled'
: response && 'error' in response
? response.error
: responseError
}
/>
) : (
<InsightErrorState
query={query}
titleStatus={responseErrorObject?.status}
retryAfterTimestamp={responseErrorObject?.retryAfterTimestamp}
onRetry={() => loadData('force_blocking')}
/>
)
) : (
<InsightEmptyState
heading={context?.emptyStateHeading}
detail={context?.emptyStateDetail}
icon={context?.emptyStateIcon}
sampleDataVariant="table"
sampleTable={sampleTable}
insightProps={insightProps}
/>
)
}
expandable={expandableConfig}
rowClassName={({ result, label }) =>
clsx('DataTable__row', {
'DataTable__row--highlight_once': result && highlightedRows.has(result),
'DataTable__row--category_row': !!label,
'border border-x-danger-dark bg-danger-highlight':
sourceFeatures.has(QueryFeature.highlightExceptionEventRows) &&
result &&
(result as any[])[0] &&
(result as any[])[0]['event'] === '$exception',
DataTable__has_pinned_columns: (query.pinnedColumns ?? []).length > 0,
})
}
footer={
(dataTableRows ?? []).length > 0 &&
(context?.showLoadNextButton ||
!sourceFeatures.has(QueryFeature.hideLoadNextButton)) &&
(!context?.dataTableHideLoadNextWhenComplete ||
canLoadNextData ||
nextDataLoading) ? (
<LoadNext
query={query.source}
nouns={context?.dataTableNouns}
expectedTotalRows={context?.dataTableExpectedTotalRows}
/>
) : null
}
nouns={context?.dataTableNouns}
onRow={onRow}
pinnedColumns={query.pinnedColumns}
rowActions={rowActions}
/>
</div>
)}
{/* TODO: this doesn't seem like the right solution... */}
<PersonDeleteModal />
</div>
</BindLogic>
</BindLogic>
)
}