Skip to content

: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.

64.7 KB
Raw Blame
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>
    )
}