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.

56.6 KB
Raw Blame
import './DataGrid.scss'
import 'react-data-grid/lib/styles.css'

import clsx from 'clsx'
import { BindLogic, useActions, useMountedLogic, useValues } from 'kea'
import { useCallback, useMemo, useRef, useState } from 'react'
import DataGrid, {
    CellClickArgs,
    // CellMouseEvent, onCellContextMenu, and event.preventGridDefault() are beta-only APIs from the
    // exactly-pinned react-data-grid 7.0.0-beta.47; a manual bump could reshape them without a semver signal.
    CellMouseEvent,
    DataGridProps,
    RenderHeaderCellProps,
    SortColumn,
} from 'react-data-grid'

import {
    IconCode,
    IconColumns,
    IconCopy,
    IconDownload,
    IconExpand45,
    IconGear,
    IconGraph,
    IconMinus,
    IconPlus,
    IconShare,
    IconScreen,
    IconWarning,
} from '@posthog/icons'
import { LemonBanner, LemonButton, LemonDivider, LemonMenu, LemonModal, LemonTable, Tooltip } from '@posthog/lemon-ui'

import { ExportButton } from 'lib/components/ExportButton/ExportButton'
import { JSONViewer } from 'lib/components/JSONViewer'
import { MCPUseCaseCard } from 'lib/components/MCPHint/MCPUseCaseCard'
import { TZLabel } from 'lib/components/TZLabel'
import { PART_OF_WHOLE_DISPLAY_TYPES } from 'lib/constants'
import { useCellCopyContextMenu } from 'lib/hooks/useCellCopyContextMenu'
import { IconTableChart } from 'lib/lemon-ui/icons'
import { KeyboardShortcut } from 'lib/lemon-ui/KeyboardShortcut/KeyboardShortcut'
import { LoadingBar } from 'lib/lemon-ui/LoadingBar'
import { Resizer } from 'lib/lemon-ui/Resizer/Resizer'
import { type ResizerLogicProps, resizerLogic } from 'lib/lemon-ui/Resizer/resizerLogic'
import { Spinner } from 'lib/lemon-ui/Spinner/Spinner'
import { getAccessControlDisabledReason } from 'lib/utils/accessControlUtils'
import { copyToClipboard } from 'lib/utils/copyToClipboard'
import { tryJsonParse } from 'lib/utils/json'
import { InsightErrorState, StatelessInsightLoadingState } from 'scenes/insights/EmptyStates'
import { insightLogic } from 'scenes/insights/insightLogic'

import { themeLogic } from '~/layout/navigation-3000/themeLogic'
import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
import { ElapsedTime } from '~/queries/nodes/DataNode/ElapsedTime'
import { LoadPreviewText } from '~/queries/nodes/DataNode/LoadNext'
import { QueryExecutionDetails } from '~/queries/nodes/DataNode/QueryExecutionDetails'
import { WarehouseSyncWarningList } from '~/queries/nodes/DataNode/WarehouseSyncWarningList'
import { warehouseSyncWarnings } from '~/queries/nodes/DataNode/warehouseSyncWarnings'
import { DataTableRow } from '~/queries/nodes/DataTable/dataTableLogic'
import { PartOfWholeChart } from '~/queries/nodes/DataVisualization/Components/Charts/PartOfWholeChart'
import { SqlBoxPlot } from '~/queries/nodes/DataVisualization/Components/Charts/SqlBoxPlot'
import { isSqlChartVisualizationType, SqlChart } from '~/queries/nodes/DataVisualization/Components/Charts/SqlChart'
import { SqlMetricCard } from '~/queries/nodes/DataVisualization/Components/Charts/SqlMetricCard'
import { partOfWholeChartData } from '~/queries/nodes/DataVisualization/Components/Charts/sqlPieGraphAdapter'
import { SqlScatterGraph } from '~/queries/nodes/DataVisualization/Components/Charts/SqlScatterGraph'
import { TwoDimensionalHeatmap } from '~/queries/nodes/DataVisualization/Components/Heatmap/TwoDimensionalHeatmap'
import { seriesBreakdownLogic } from '~/queries/nodes/DataVisualization/Components/seriesBreakdownLogic'
import { SideBar } from '~/queries/nodes/DataVisualization/Components/SideBar'
import { Table } from '~/queries/nodes/DataVisualization/Components/Table'
import { TableDisplay } from '~/queries/nodes/DataVisualization/Components/TableDisplay'
import { DataTableVisualizationProps } from '~/queries/nodes/DataVisualization/DataVisualization'
import { dataVisualizationLogic } from '~/queries/nodes/DataVisualization/dataVisualizationLogic'
import { displayLogic } from '~/queries/nodes/DataVisualization/displayLogic'
import { renderHogQLX } from '~/queries/nodes/HogQLX/render'
import {
    type AccessControlFilterWarning,
    type DataTableNode,
    type HogQLQueryResponse,
    NodeKind,
} from '~/queries/schema/schema-general'
import {
    AccessControlLevel,
    AccessControlResourceType,
    ChartDisplayType,
    ExporterFormat,
    type ExportContext,
} from '~/types'

import { WarehouseWizardHint } from 'products/data_warehouse/frontend/shared/components/WarehouseWizardHint'
import { aiChartRecommendationLogic } from 'products/data_warehouse/frontend/sql_editor/aiChartRecommendationLogic'
import { HarnessLabel } from 'products/mcp_analytics/frontend/dashboard/HarnessLabel'
import { HogQLBoldNumber } from 'products/product_analytics/frontend/insights/shared/BoldNumber/BoldNumber'

import {
    copyTableToCsv,
    copyTableToExcel,
    copyTableToJson,
    copyTableToMarkdown,
} from '../../../queries/nodes/DataTable/clipboardUtils'
import { EditorQueryScanBanner } from './components/EditorQueryScanBanner'
import { FixErrorButton } from './components/FixErrorButton'
import { fixSQLErrorsLogic } from './fixSQLErrorsLogic'
import { QueryIndexUsageBar } from './output-pane-tabs/QueryIndexUsageBar'
import { OutputTab, outputPaneLogic } from './outputPaneLogic'
import { sqlEditorLogic } from './sqlEditorLogic'
import TabScroller from './TabScroller'

interface RowDetailsModalProps {
    isOpen: boolean
    onClose: () => void
    row: Record<string, any> | null
    columns: string[]
    columnKeys: string[]
}

const ONE_DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000

const CLICKHOUSE_TYPES = [
    'UUID',
    'String',
    'Nothing',
    'DateTime64',
    'DateTime32',
    'DateTime',
    'Date',
    'Date32',
    'UInt8',
    'UInt16',
    'UInt32',
    'UInt64',
    'Float8',
    'Float16',
    'Float32',
    'Float64',
    'Int8',
    'Int16',
    'Int32',
    'Int64',
    'Tuple',
    'Array',
    'Map',
    'Bool',
    'Decimal',
    'FixedString',
]

const copyMap = {
    [ExporterFormat.CSV]: {
        label: 'CSV',
        copyFn: copyTableToCsv,
    },
    [ExporterFormat.JSON]: {
        label: 'JSON',
        copyFn: copyTableToJson,
    },
    [ExporterFormat.XLSX]: {
        label: 'Excel',
        copyFn: copyTableToExcel,
    },
    [ExporterFormat.MARKDOWN]: {
        label: 'Markdown',
        copyFn: copyTableToMarkdown,
    },
}

const createDataTableQuery = (): DataTableNode => ({
    kind: NodeKind.DataTableNode,
    source: {
        kind: NodeKind.HogQLQuery,
        query: '',
    },
})

interface OutputTabConfig {
    key: OutputTab
    label: string
    icon: JSX.Element
}

const outputTabs: OutputTabConfig[] = [
    {
        key: OutputTab.Results,
        label: 'Results',
        icon: <IconTableChart />,
    },
    {
        key: OutputTab.Visualization,
        label: 'Visualization',
        icon: <IconGraph />,
    },
]

const cleanClickhouseType = (type: string | undefined): string | undefined => {
    if (!type) {
        return undefined
    }

    // Replace newline characters followed by empty space
    type = type.replace(/\n\s+/, '')

    if (type.startsWith('Nullable(')) {
        type = type.replace('Nullable(', '')
        type = type.substring(0, type.length - 1)
    }

    if (type.startsWith('Array(')) {
        const tokenifiedType = type.split(/(\W)/)
        type = tokenifiedType
            .filter((n) => {
                if (n === 'Nullable') {
                    return true
                }

                // Is a single character and not alpha-numeric
                if (n.length === 1 && !/^[a-z0-9]+$/i.test(n)) {
                    return true
                }

                return CLICKHOUSE_TYPES.includes(n)
            })
            .join('')
    }

    return type.replace(/\(.+\)+/, '')
}

const isDateTimeType = (type: string | undefined): boolean => {
    const cleanedType = cleanClickhouseType(type)
    return cleanedType === 'DateTime' || cleanedType === 'DateTime32' || cleanedType === 'DateTime64'
}

function RowDetailsModal({ isOpen, onClose, row, columns, columnKeys }: RowDetailsModalProps): JSX.Element {
    const [showRawJson, setShowRawJson] = useState<Record<string, boolean>>({})
    const [wordWrap, setWordWrap] = useState<Record<string, boolean>>({})

    if (!row) {
        return <></>
    }

    const isJsonString = (str: string): boolean => {
        try {
            const parsed = JSON.parse(str)
            return typeof parsed === 'object' && parsed !== null
        } catch {
            return false
        }
    }

    const tableData = columns.map((column, index) => {
        const columnKey = columnKeys[index]
        const value = row[columnKey]
        const isStringifiedJson = typeof value === 'string' && isJsonString(value)
        const isJson = typeof value === 'object' || isStringifiedJson
        const jsonValue = isStringifiedJson ? JSON.parse(value) : value

        return {
            column,
            isJson,
            rawValue:
                value === null
                    ? 'null'
                    : typeof value === 'object' || isStringifiedJson
                      ? JSON.stringify(value, null, 2)
                      : String(value),
            value:
                value === null ? (
                    <span className="text-muted">null</span>
                ) : isJson ? (
                    <div className="flex gap-2 w-full">
                        <div className="w-full overflow-hidden">
                            {showRawJson[column] ? (
                                <pre
                                    className={clsx(
                                        'm-0 font-mono',
                                        wordWrap[column]
                                            ? 'whitespace-pre-wrap break-all'
                                            : 'overflow-x-auto hide-scrollbar'
                                    )}
                                >
                                    {String(value)}
                                </pre>
                            ) : (
                                <div className="overflow-x-auto max-w-full">
                                    <JSONViewer src={jsonValue} name={null} collapsed={1} sortKeys={true} />
                                </div>
                            )}
                        </div>
                    </div>
                ) : (
                    <div className="overflow-x-auto">
                        <span className="whitespace-pre-wrap break-all font-mono">{String(value)}</span>
                    </div>
                ),
        }
    })

    return (
        <LemonModal title="Row Details" isOpen={isOpen} onClose={onClose} width={800}>
            <div className="RowDetailsModal max-h-[70vh] overflow-y-auto px-2 overflow-x-hidden">
                <LemonTable
                    dataSource={tableData}
                    className="w-full table-fixed"
                    columns={[
                        {
                            title: 'Column',
                            dataIndex: 'column',
                            className: 'font-semibold',
                            width: '35%',
                            render: (_, record) => <span title={record.column}>{record.column}</span>,
                        },
                        {
                            title: 'Value',
                            dataIndex: 'value',
                            className: 'px-4 overflow-hidden',
                            width: '65%',
                            render: (_, record) => (
                                <div className="flex items-center gap-2 w-full">
                                    <div className="flex-1 overflow-x-auto pr-2">{record.value}</div>
                                    <div className="flex flex-row gap-1 flex-shrink-0 ml-auto">
                                        {record.isJson && record.rawValue && record.rawValue != 'null' && (
                                            <LemonButton
                                                size="small"
                                                icon={<IconCode />}
                                                onClick={() =>
                                                    setShowRawJson((prev) => ({
                                                        ...prev,
                                                        [record.column]: !prev[record.column],
                                                    }))
                                                }
                                                tooltip={showRawJson[record.column] ? 'Show formatted' : 'Show raw'}
                                            />
                                        )}
                                        {showRawJson[record.column] && (
                                            <LemonButton
                                                size="small"
                                                icon={wordWrap[record.column] ? <IconMinus /> : <IconPlus />}
                                                onClick={() =>
                                                    setWordWrap((prev) => ({
                                                        ...prev,
                                                        [record.column]: !prev[record.column],
                                                    }))
                                                }
                                                tooltip={wordWrap[record.column] ? 'Collapse' : 'Expand'}
                                            />
                                        )}
                                        <LemonButton
                                            size="small"
                                            icon={<IconCopy />}
                                            onClick={() => void copyToClipboard(record.rawValue, 'value')}
                                            tooltip="Copy value"
                                        />
                                    </div>
                                </div>
                            ),
                        },
                    ]}
                />
            </div>
        </LemonModal>
    )
}

interface OutputTabLabelProps {
    tab: OutputTabConfig
    active: boolean
    onClick?: () => void
}

function OutputTabLabel({ tab, active, onClick }: OutputTabLabelProps): JSX.Element {
    return (
        <div
            className={clsx(
                'flex-1 flex-row flex items-center bold content-center px-2 pt-[3px] border-b-[medium] whitespace-nowrap',
                {
                    'font-semibold !border-brand-yellow': active,
                    'border-transparent': !active,
                    'cursor-pointer': !!onClick,
                    'cursor-default': !onClick,
                }
            )}
            onClick={onClick}
        >
            <span className="mr-1">{tab.icon}</span>
            {tab.label}
        </div>
    )
}

interface SplitOutputToggleProps {
    splitView: boolean
    onClick: () => void
}

function SplitOutputToggle({ splitView, onClick }: SplitOutputToggleProps): JSX.Element {
    return (
        <LemonButton
            active={splitView}
            className="self-center"
            type="secondary"
            size="small"
            icon={splitView ? <IconScreen /> : <IconColumns />}
            onClick={onClick}
            tooltip={splitView ? 'Show one output at a time' : 'Show results and visualization side by side'}
            data-attr="sql-editor-output-split-toggle"
        />
    )
}

interface VisualizationActionsProps {
    hasColumns: boolean
    settingsOpen: boolean
    onToggleChartSettingsPanel: () => void
}

function VisualizationActions({
    hasColumns,
    settingsOpen,
    onToggleChartSettingsPanel,
}: VisualizationActionsProps): JSX.Element {
    return (
        <div className="flex justify-end flex-wrap">
            <div className="flex gap-2 items-center flex-wrap">
                <TableDisplay disabledReason={!hasColumns ? 'No results to visualize' : undefined} />

                <LemonButton
                    disabledReason={!hasColumns ? 'No results to visualize' : undefined}
                    type={settingsOpen ? 'primary' : 'secondary'}
                    icon={<IconGear />}
                    size="small"
                    onClick={onToggleChartSettingsPanel}
                    tooltip="Visualization settings"
                    data-attr="sql-editor-visualization-settings-button"
                />
            </div>
        </div>
    )
}

/**
 * Transforms DataTable format back to DataTableRow format for clipboard operations
 */
function transformDataTableToDataTableRows(rows: Record<string, any>[], columns: string[]): DataTableRow[] {
    if (!columns.length || !rows.length) {
        return []
    }

    return rows.map((row) => ({
        result: columns.map((col, index) => {
            // Handle both direct column access and column_index format
            const columnKey = `${col}_${index}`
            return row[columnKey] !== undefined ? row[columnKey] : row[col]
        }),
    }))
}

interface ResultsActionsProps {
    response: HogQLQueryResponse | undefined
    rows: Record<string, any>[]
    hasColumns: boolean
    exportContext: ExportContext | undefined
    hasQueryInput: boolean
    isEmbeddedMode: boolean
    onShareTab?: () => void
}

function ResultsActions({
    response,
    rows,
    hasColumns,
    exportContext,
    hasQueryInput,
    isEmbeddedMode,
    onShareTab,
}: ResultsActionsProps): JSX.Element {
    // Copying or exporting results requires editor access to the export resource.
    const exportAccessControlDisabledReason = getAccessControlDisabledReason(
        AccessControlResourceType.Export,
        AccessControlLevel.Editor
    )

    return (
        <>
            <LemonMenu
                items={Object.values(copyMap).map(({ label, copyFn }) => ({
                    label,
                    onClick: () => {
                        if (response?.columns && rows.length > 0) {
                            const dataTableRows = transformDataTableToDataTableRows(rows, response.columns)
                            const query = createDataTableQuery()
                            copyFn(dataTableRows, response.columns, query)
                        }
                    },
                }))}
                placement="bottom-end"
            >
                <LemonButton
                    id="sql-editor-copy-dropdown"
                    disabledReason={
                        (!response?.columns || !rows.length ? 'No results to copy' : undefined) ??
                        exportAccessControlDisabledReason ??
                        undefined
                    }
                    type="secondary"
                    size="small"
                    icon={<IconCopy />}
                />
            </LemonMenu>
            {exportContext && (
                <Tooltip title="Export the table results" className={!hasColumns ? 'hidden' : ''}>
                    <ExportButton
                        id="sql-editor-export"
                        disabledReason={!hasColumns ? 'No results to export' : undefined}
                        type="secondary"
                        icon={<IconDownload />}
                        sideIcon={null}
                        buttonCopy=""
                        size="small"
                        items={[
                            {
                                export_format: ExporterFormat.CSV,
                                export_context: exportContext,
                            },
                            {
                                export_format: ExporterFormat.XLSX,
                                export_context: exportContext,
                            },
                        ]}
                    />
                </Tooltip>
            )}
            {!isEmbeddedMode && onShareTab && (
                <Tooltip title="Share your current query">
                    <LemonButton
                        id="sql-editor-share"
                        disabledReason={!hasQueryInput && 'No query to share'}
                        type="secondary"
                        size="small"
                        icon={<IconShare />}
                        onClick={onShareTab}
                    />
                </Tooltip>
            )}
        </>
    )
}

interface OutputActionsProps {
    activeTab: OutputTab
    response: HogQLQueryResponse | undefined
    rows: Record<string, any>[]
    hasColumns: boolean
    exportContext: ExportContext | undefined
    hasQueryInput: boolean
    isEmbeddedMode: boolean
    settingsOpen: boolean
    onShareTab?: () => void
    onToggleChartSettingsPanel: () => void
}

function OutputActions({
    activeTab,
    response,
    rows,
    hasColumns,
    exportContext,
    hasQueryInput,
    isEmbeddedMode,
    settingsOpen,
    onShareTab,
    onToggleChartSettingsPanel,
}: OutputActionsProps): JSX.Element | null {
    if (activeTab === OutputTab.Visualization) {
        return (
            <VisualizationActions
                hasColumns={hasColumns}
                settingsOpen={settingsOpen}
                onToggleChartSettingsPanel={onToggleChartSettingsPanel}
            />
        )
    }

    if (activeTab === OutputTab.Results) {
        return (
            <ResultsActions
                response={response}
                rows={rows}
                hasColumns={hasColumns}
                exportContext={exportContext}
                hasQueryInput={hasQueryInput}
                isEmbeddedMode={isEmbeddedMode}
                onShareTab={onShareTab}
            />
        )
    }

    return null
}

interface OutputPaneProps {
    tabId: string
    showToolbar?: boolean
    biMode?: boolean
    onShareTab?: () => void
}

/** The copyable text for a right-clicked grid cell, or null when the cell should fall through to the
 *  native context menu. Exported so the branches below (details column, empty value, HogQLX skip) are
 *  unit-testable, mirroring extractCellText in LemonTable. */
export function extractGridCellValue(columnKey: string, row: Record<string, any>): string | null {
    if (columnKey === '__details') {
        return null
    }
    const value = row[columnKey]
    if (value === null || value === undefined || value === '') {
        return null
    }
    // HogQLX-shaped values render as rich content (links, sparklines, recording buttons) via
    // renderHogQLX; copying String(value) would put the internal AST JSON on the clipboard, so skip
    // them and let the native menu handle the cell instead.
    if (typeof value === 'string' && value.startsWith('["__hx_tag",') && value.endsWith(']')) {
        return null
    }
    return String(value)
}

export function OutputPane({ tabId, showToolbar = true, biMode = false, onShareTab }: OutputPaneProps): JSX.Element {
    const { activeTab } = useValues(outputPaneLogic)
    const { setActiveTab } = useActions(outputPaneLogic)

    const {
        sourceQuery,
        exportContext,
        insightLoading,
        hasQueryInput,
        isEmbeddedMode,
        metadata,
        metadataLoading,
        indexReportStale,
    } = useValues(sqlEditorLogic)
    const { setSourceQuery, applyIndexQuickfix, fixIndexUsageWithAI } = useActions(sqlEditorLogic)
    const { responseLoading: fixWithAILoading } = useValues(fixSQLErrorsLogic)
    const { isDarkModeOn } = useValues(themeLogic)
    const {
        response: dataNodeResponse,
        responseLoading,
        responseError,
        queryId,
        pollResponse,
    } = useValues(dataNodeLogic)
    const { queryCancelled, isChartSettingsPanelOpen } = useValues(dataVisualizationLogic)
    const { toggleChartSettingsPanel } = useActions(dataVisualizationLogic)
    const visualizationLogic = useMountedLogic(dataVisualizationLogic)
    const chartRecommendationLogic = aiChartRecommendationLogic({
        visualizationProps: visualizationLogic.props,
        tabId: tabId || '',
    })
    const { choosingChart, statusMessage } = useValues(chartRecommendationLogic)
    const { skipRecommendation } = useActions(chartRecommendationLogic)

    const response = dataNodeResponse as HogQLQueryResponse | undefined
    const splitPaneRef = useRef<HTMLDivElement>(null)
    const splitView = !biMode && activeTab === OutputTab.Both
    const splitResizerProps = useMemo<ResizerLogicProps>(
        () => ({
            containerRef: splitPaneRef,
            logicKey: `sql-editor-output-split-${tabId || 'default'}`,
            placement: 'right' as const,
        }),
        [tabId]
    )
    const { desiredSize: splitPaneDesiredWidth } = useValues(resizerLogic(splitResizerProps))

    const [progressCache, setProgressCache] = useState<Record<string, number>>({})

    const vizKey = useMemo(() => `SQLEditorScene`, [])

    const [selectedRow, setSelectedRow] = useState<Record<string, any> | null>(null)
    const [selectedJson, setSelectedJson] = useState<object | null>(null)

    const setProgress = useCallback((loadId: string, progress: number) => {
        setProgressCache((prev) => ({ ...prev, [loadId]: progress }))
    }, [])

    const toggleVisualizationSettingsPanel = useCallback(() => {
        toggleChartSettingsPanel()
    }, [toggleChartSettingsPanel])

    const columns = useMemo(() => {
        const types = response?.types

        const baseColumns: DataGridProps<Record<string, any>>['columns'] = [
            {
                key: '__details',
                name: '',
                minWidth: 30,
                width: 30,
                renderCell: ({ row }: { row: any }) => (
                    <div className="hover-actions-cell flex justify-center items-center">
                        <LemonButton
                            size="xsmall"
                            icon={<IconExpand45 />}
                            onClick={(e) => {
                                e.stopPropagation()
                                setSelectedRow(row)
                            }}
                        />
                    </div>
                ),
            },
            ...(response?.columns?.map((column: string, index: number) => {
                const type = types?.[index]?.[1]
                const isDateTimeColumn = isDateTimeType(type)

                const maxContentLength = Math.max(
                    column.length,
                    ...(response.results || (response as any).result).map((row: any[]) => {
                        const content = row[index]
                        return typeof content === 'string'
                            ? content.length
                            : content === null
                              ? 0
                              : content.toString().length
                    })
                )
                const isLongContent = maxContentLength > 100
                const finalWidth = isLongContent ? 600 : undefined

                const baseColumn: DataGridProps<Record<string, any>>['columns'][0] = {
                    key: `${column}_${index}`,
                    name: (
                        <>
                            {column}{' '}
                            {type && (
                                <span className="text-[10px] font-medium italic">{cleanClickhouseType(type)}</span>
                            )}
                        </>
                    ),
                    resizable: true,
                    sortable: true,
                    width: finalWidth,
                    headerCellClass: 'cursor-pointer',
                    renderHeaderCell: ({ column: col, sortDirection }: RenderHeaderCellProps<any>) => (
                        <div className="flex items-center justify-between py-2">
                            <span>{col.name}</span>
                            <div className="flex flex-col ml-1">
                                <span
                                    className={`text-[7px] leading-none ${
                                        sortDirection === 'ASC' ? 'text-black-600' : 'text-gray-400'
                                    }`}
                                >
                                    ▲
                                </span>
                                <span
                                    className={`text-[7px] leading-none ${
                                        sortDirection === 'DESC' ? 'text-black-600' : 'text-gray-400'
                                    }`}
                                >
                                    ▼
                                </span>
                            </div>
                        </div>
                    ),
                }

                // Hack to get bools to render in the data grid
                if (cleanClickhouseType(type) === 'Bool') {
                    return {
                        ...baseColumn,
                        renderCell: (props: any) => {
                            const columnKey = `${column}_${index}`
                            if (props.row[columnKey] === null) {
                                return null
                            }
                            return props.row[columnKey].toString()
                        },
                    }
                }

                return {
                    ...baseColumn,
                    renderCell: (props: any) => {
                        const columnKey = `${column}_${index}`
                        const value = props.row[columnKey]
                        if (response.column_formats?.[index] === 'mcp_harness' && typeof value === 'string') {
                            return <HarnessLabel category={value} />
                        }
                        if (typeof value === 'string' && value.startsWith('["__hx_tag",') && value.endsWith(']')) {
                            try {
                                const parsedHogQLX = JSON.parse(value)
                                return renderHogQLX(parsedHogQLX)
                            } catch (e) {
                                console.error('Error parsing HogQLX value:', e)
                                return <span className="text-red">Error parsing value</span>
                            }
                        }

                        if (isDateTimeColumn && typeof value === 'string' && value) {
                            return <TZLabel time={value} timestampStyle="absolute" />
                        }

                        const parsedJson: unknown =
                            typeof value === 'string' && cleanClickhouseType(type) === 'String'
                                ? tryJsonParse(value)
                                : null
                        if (!parsedJson || typeof parsedJson !== 'object') {
                            return value
                        }

                        return (
                            <button
                                type="button"
                                className="block h-full w-full truncate text-left"
                                onClick={() => setSelectedJson(parsedJson)}
                            >
                                {value}
                            </button>
                        )
                    },
                }
            }) ?? []),
        ]

        return baseColumns
    }, [response, setSelectedRow])

    const rows = useMemo(() => {
        if (!response?.results) {
            return []
        }

        let processedRows = response.results.map((row: any[], index: number) => {
            const rowObject: Record<string, any> = { __index: index }
            response.columns?.forEach((column: string, i: number) => {
                const columnKey = `${column}_${i}`
                // Handling objects here as other viz methods can accept objects. Data grid does not for now
                if (typeof row[i] === 'object' && row[i] !== null) {
                    rowObject[columnKey] = JSON.stringify(row[i])
                } else {
                    rowObject[columnKey] = row[i]
                }
            })
            return rowObject
        })

        return processedRows
    }, [response])

    const hasColumns = columns.length > 1
    const splitPaneWidth = splitPaneDesiredWidth ? `${Math.max(splitPaneDesiredWidth, 256)}px` : '50%'
    const splitToggle = (
        <SplitOutputToggle
            splitView={splitView}
            onClick={() => setActiveTab(splitView ? OutputTab.Results : OutputTab.Both)}
        />
    )
    const sharedContentProps = {
        responseError,
        responseLoading,
        response,
        insightLoading,
        sourceQuery,
        queryCancelled,
        columns,
        rows,
        isDarkModeOn,
        vizKey,
        setSourceQuery,
        exportContext,
        queryId,
        pollResponse,
        setProgress,
        progress: queryId ? progressCache[queryId] : undefined,
        showVisualizationSettings: showToolbar && isChartSettingsPanelOpen,
        showQueryScan: !biMode,
        isEmbeddedMode,
    }
    const sharedActionsProps = {
        response,
        rows,
        hasColumns,
        exportContext,
        hasQueryInput,
        isEmbeddedMode,
        settingsOpen: isChartSettingsPanelOpen,
        onShareTab,
        onToggleChartSettingsPanel: toggleVisualizationSettingsPanel,
    }

    const outputContent = biMode ? (
        <div className="relative flex flex-1 min-h-0 bg-dark">
            {showToolbar ? (
                <LemonButton
                    className="absolute right-2 top-2 z-10"
                    disabledReason={!hasColumns ? 'No results to visualize' : undefined}
                    type={isChartSettingsPanelOpen ? 'primary' : 'secondary'}
                    icon={<IconGear />}
                    size="small"
                    onClick={toggleVisualizationSettingsPanel}
                    tooltip="Visualization settings"
                    data-attr="sql-editor-visualization-settings-button"
                />
            ) : null}
            <Content activeTab={OutputTab.Visualization} {...sharedContentProps} />
        </div>
    ) : splitView ? (
        <div className="flex flex-1 min-h-0 bg-dark @max-[48rem]/sql-output:flex-col @max-[48rem]/sql-output:overflow-y-auto">
            <div
                ref={splitPaneRef}
                className="relative flex min-w-64 flex-col bg-white dark:bg-black @max-[48rem]/sql-output:!w-full @max-[48rem]/sql-output:!max-w-full @max-[48rem]/sql-output:min-h-64 @max-[48rem]/sql-output:shrink-0"
                // eslint-disable-next-line react/forbid-dom-props
                style={{ width: splitPaneWidth, maxWidth: 'calc(100% - 16rem)' }}
            >
                {showToolbar ? (
                    <div className="flex flex-row justify-between align-center w-full min-h-[41px] overflow-y-auto border-r">
                        <div className="flex min-h-[41px] gap-2 ml-4">
                            {splitToggle}
                            <OutputTabLabel tab={outputTabs[0]} active />
                        </div>
                        <div className="flex gap-2 py-1 px-4 flex-shrink-0">
                            <OutputActions activeTab={OutputTab.Results} {...sharedActionsProps} />
                        </div>
                    </div>
                ) : null}
                <div className="flex flex-1 min-h-0 relative bg-dark border-r">
                    <Content activeTab={OutputTab.Results} {...sharedContentProps} />
                </div>
                <div className="@max-[48rem]/sql-output:hidden">
                    <Resizer {...splitResizerProps} />
                </div>
            </div>
            <div className="flex min-w-0 flex-1 flex-col bg-white dark:bg-black @max-[48rem]/sql-output:min-h-80 @max-[48rem]/sql-output:shrink-0">
                {showToolbar ? (
                    <div className="flex flex-row justify-between align-center w-full min-h-[41px] overflow-y-auto">
                        <div className="flex min-h-[41px] gap-2 ml-4">
                            <OutputTabLabel tab={outputTabs[1]} active />
                        </div>
                        <div className="flex gap-2 py-1 px-4 flex-shrink-0">
                            <OutputActions activeTab={OutputTab.Visualization} {...sharedActionsProps} />
                        </div>
                    </div>
                ) : null}
                <div className="flex flex-1 min-h-0 relative bg-dark">
                    <Content activeTab={OutputTab.Visualization} {...sharedContentProps} />
                </div>
            </div>
        </div>
    ) : (
        <>
            {showToolbar ? (
                <div className="flex flex-row justify-between align-center w-full min-h-[41px] overflow-y-auto">
                    <div className="flex min-h-[41px] gap-2 ml-4">
                        {splitToggle}
                        {outputTabs.map((tab) => (
                            <OutputTabLabel
                                key={tab.key}
                                tab={tab}
                                active={tab.key === activeTab}
                                onClick={() => setActiveTab(tab.key)}
                            />
                        ))}
                    </div>
                    <div className="flex gap-2 py-1 px-4 flex-shrink-0">
                        <OutputActions activeTab={activeTab} {...sharedActionsProps} />
                    </div>
                </div>
            ) : null}
            <div className="flex flex-1 min-h-0 relative bg-dark">
                <Content activeTab={activeTab} {...sharedContentProps} />
            </div>
        </>
    )

    return (
        <div className="OutputPane @container/sql-output flex flex-col w-full flex-1 min-h-0 bg-white dark:bg-black">
            <QueryIndexUsageBar
                predicates={metadata?.index_usage ?? []}
                refreshing={metadataLoading}
                stale={indexReportStale}
                onApplyQuickfix={applyIndexQuickfix}
                onFixWithAI={fixIndexUsageWithAI}
                fixWithAILoading={fixWithAILoading}
            />
            {choosingChart ? (
                <div
                    className="flex flex-1 min-h-0 flex-col items-center justify-center gap-3 p-4 border-t"
                    data-attr="sql-editor-chart-loading"
                    aria-busy="true"
                >
                    <div className="flex items-center gap-2" role="status">
                        <Spinner />
                        <span>Choosing a chart…</span>
                    </div>
                    <LemonButton size="small" type="secondary" onClick={skipRecommendation}>
                        Show results now
                    </LemonButton>
                </div>
            ) : (
                outputContent
            )}
            <div className="flex flex-wrap justify-between gap-x-4 px-2 border-t">
                <div className="flex flex-wrap items-center gap-x-4">
                    {response && !responseError ? <LoadPreviewText localResponse={response} /> : null}
                    {statusMessage ? (
                        <span className="text-xs text-muted" role="status" data-attr="sql-editor-chart-status">
                            {statusMessage}
                        </span>
                    ) : null}
                </div>
                <div className="flex items-center gap-4">
                    <ElapsedTime />
                    <QueryExecutionDetails />
                </div>
            </div>
            <RowDetailsModal
                isOpen={!!selectedRow}
                onClose={() => setSelectedRow(null)}
                row={selectedRow}
                columns={response?.columns || []}
                columnKeys={response?.columns?.map((column: string, index: number) => `${column}_${index}`) || []}
            />
            <LemonModal title="JSON" isOpen={selectedJson !== null} onClose={() => setSelectedJson(null)} width={800}>
                <pre className="max-h-[70vh] overflow-auto whitespace-pre-wrap break-words font-mono">
                    {selectedJson ? JSON.stringify(selectedJson, null, 2) : ''}
                </pre>
            </LemonModal>
        </div>
    )
}

function InternalDataTableVisualization(
    props: DataTableVisualizationProps & { showSettingsPanel: boolean }
): JSX.Element | null {
    const {
        query,
        effectiveVisualizationType,
        response,
        responseLoading,
        xData,
        yData,
        columns,
        chartSettings,
        dashboardId,
        dataVisualizationProps,
        presetChartHeight,
    } = useValues(dataVisualizationLogic)

    const {
        seriesBreakdownData,
        chartData: { xData: _xData, yData: _yData },
    } = useValues(seriesBreakdownLogic({ key: dataVisualizationProps.key }))
    const { goalLines } = useValues(displayLogic)
    const { editingInsight } = useValues(sqlEditorLogic)

    const isDateXAxis = xData?.column.type.name === 'DATE' || xData?.column.type.name === 'DATETIME'

    let component: JSX.Element | null = null

    // TODO(@Gilbert09): Better loading support for all components - e.g. using the `loading` param of `Table`
    if (!response || responseLoading) {
        component = (
            <div className="flex flex-col flex-1 justify-center items-center bg-surface-primary h-full">
                <LoadingBar />
            </div>
        )
    } else if (effectiveVisualizationType === ChartDisplayType.ActionsTable) {
        component = (
            <Table
                uniqueKey={props.uniqueKey}
                query={query}
                context={props.context}
                cachedResults={props.cachedResults as HogQLQueryResponse | undefined}
                embedded
            />
        )
    } else if (isSqlChartVisualizationType(effectiveVisualizationType)) {
        component = (
            <BindLogic logic={insightLogic} props={{ dashboardItemId: editingInsight?.short_id, doNotLoad: true }}>
                <SqlChart
                    className="p-2"
                    xData={_xData}
                    yData={_yData}
                    visualizationType={effectiveVisualizationType}
                    chartSettings={chartSettings}
                    dashboardId={dashboardId}
                    goalLines={goalLines}
                    insightNumericId={editingInsight?.id || 'new'}
                    showAnnotations={isDateXAxis && chartSettings.showAnnotations === true}
                    presetChartHeight={presetChartHeight}
                    embedded={props.embedded}
                />
            </BindLogic>
        )
    } else if (PART_OF_WHOLE_DISPLAY_TYPES.includes(effectiveVisualizationType)) {
        const pieData = partOfWholeChartData(seriesBreakdownData, xData, yData)

        component = (
            <PartOfWholeChart
                className="p-2"
                xData={pieData.xData}
                yData={pieData.yData}
                visualizationType={effectiveVisualizationType}
                chartSettings={chartSettings}
                presetChartHeight={presetChartHeight}
            />
        )
    } else if (effectiveVisualizationType === ChartDisplayType.ScatterPlot) {
        component = (
            <SqlScatterGraph
                className="p-2"
                xData={xData}
                yData={yData}
                chartSettings={chartSettings}
                presetChartHeight={presetChartHeight}
            />
        )
    } else if (effectiveVisualizationType === ChartDisplayType.BoxPlot) {
        const rows = ('results' in response ? response.results : 'result' in response ? response.result : []) ?? []
        component = (
            <SqlBoxPlot
                rows={Array.isArray(rows) ? rows : []}
                columns={columns}
                chartSettings={chartSettings}
                analyticsKey={dataVisualizationProps.key}
                presetChartHeight={presetChartHeight}
                className="p-2"
            />
        )
    } else if (effectiveVisualizationType === ChartDisplayType.TwoDimensionalHeatmap) {
        component = <TwoDimensionalHeatmap />
    } else if (effectiveVisualizationType === ChartDisplayType.BoldNumber) {
        component = <HogQLBoldNumber />
    } else if (effectiveVisualizationType === ChartDisplayType.Metric) {
        component = (
            <SqlMetricCard
                xData={xData}
                yData={yData}
                metricSettings={chartSettings.metric}
                presetChartHeight={presetChartHeight}
            />
        )
    }

    if (props.embedded && !props.showSettingsPanel) {
        return (
            <div
                className={clsx(
                    'DataVisualization InsightCard__viz',
                    effectiveVisualizationType === ChartDisplayType.Metric && 'InsightCard__viz--Metric'
                )}
            >
                {component}
            </div>
        )
    }

    return (
        <div className="DataVisualization h-full hide-scrollbar flex flex-1 gap-2">
            <div className="relative w-full flex flex-col gap-4 flex-1">
                <div className="flex flex-1 flex-row overflow-auto hide-scrollbar">
                    {props.showSettingsPanel && (
                        <>
                            <SideBar />
                            <LemonDivider vertical className="h-full" />
                        </>
                    )}
                    <div className={clsx('w-full h-full flex-1 overflow-auto')}>{component}</div>
                </div>
            </div>
        </div>
    )
}

// The shared `warnings` field is a tagged union; render one banner per warning kind present.
const QueryWarningsBanner = ({ warnings }: { warnings?: HogQLQueryResponse['warnings'] }): JSX.Element | null => {
    if (!warnings || warnings.length === 0) {
        return null
    }
    const syncWarnings = warehouseSyncWarnings(warnings)
    const acWarnings = warnings.filter((w): w is AccessControlFilterWarning => w.type === 'access_control')
    return (
        <>
            {syncWarnings.length > 0 && (
                <LemonBanner
                    type="warning"
                    className="m-2 flex-shrink-0"
                    data-attr="sql-editor-output-pane-sync-warnings"
                >
                    Some warehouse sources used by this query are out of date — results may not reflect current data:
                    <WarehouseSyncWarningList warnings={syncWarnings} />
                </LemonBanner>
            )}
            {acWarnings.length > 0 && (
                <LemonBanner
                    type="warning"
                    className="m-2 flex-shrink-0"
                    data-attr="sql-editor-output-pane-access-control-warnings"
                >
                    {/* The backend emits at most one access control warning; its message is the full sentence. */}
                    {acWarnings.map((warning, index) => (
                        <div key={index} className="font-semibold">
                            {warning.message}
                        </div>
                    ))}
                </LemonBanner>
            )}
        </>
    )
}

const ErrorState = ({
    responseError,
    sourceQuery,
    queryCancelled,
    response,
    showQueryScan,
}: any): JSX.Element | null => {
    const error = queryCancelled
        ? 'The query was cancelled'
        : response && 'error' in response && !!response.error
          ? response.error
          : responseError

    return (
        <div className={clsx('flex-1 absolute top-0 left-0 right-0 bottom-0 overflow-auto')}>
            <div className="flex min-h-full flex-col justify-center">
                <InsightErrorState
                    query={sourceQuery}
                    excludeDetail
                    title={
                        <pre className="text-xs bg-danger-highlight p-2 rounded overflow-auto max-h-40 max-w-[80%] mx-auto text-left whitespace-pre-wrap break-words">
                            {error}
                        </pre>
                    }
                    excludeActions={queryCancelled} // Don't display fix/debugger buttons if the query was cancelled
                    fixWithAIComponent={
                        <FixErrorButton contentOverride="Fix error with AI" type="primary" source="query-error" />
                    }
                />
                {showQueryScan && <EditorQueryScanBanner />}
            </div>
        </div>
    )
}

const EmptyResultsState = (): JSX.Element => {
    return (
        <div
            className="flex flex-1 justify-center items-center gap-2 border-t px-4 py-6 text-center"
            data-attr="sql-editor-output-pane-no-rows-state"
        >
            <IconWarning className="text-warning text-lg" />
            <span className="text-secondary">Query produced no results</span>
        </div>
    )
}

const Content = ({
    activeTab,
    responseError,
    responseLoading,
    response,
    sourceQuery,
    queryCancelled,
    columns,
    rows,
    isDarkModeOn,
    vizKey,
    setSourceQuery,
    exportContext,
    queryId,
    pollResponse,
    setProgress,
    progress,
    insightLoading,
    showVisualizationSettings,
    showQueryScan,
    isEmbeddedMode,
}: any): JSX.Element | null => {
    const { selectedDirectSource, singleStatement, showAgentHints } = useValues(sqlEditorLogic)
    // dataNodeLogic's timer resets on every loadData dispatch, so a rerun issued while a
    // query is still in flight restarts the count (a local isLoading-keyed timer wouldn't).
    const { loadingTimeSeconds } = useValues(dataNodeLogic)
    const [sortColumns, setSortColumns] = useState<SortColumn[]>([])

    const { closeCopyMenu, openCopyMenu, copyMenu } = useCellCopyContextMenu()

    // Right-click a results cell to copy its value. Unlike the LemonTable feature (which reads DOM
    // text), react-data-grid hands us the raw row value, so datetimes/numbers copy accurately.
    const handleGridCellContextMenu = useCallback(
        (args: CellClickArgs<any, any>, event: CellMouseEvent) => {
            const text = extractGridCellValue(args.column.key, args.row)
            if (text === null) {
                closeCopyMenu() // Not a copyable data cell — close any open menu and fall back to the native one
                return
            }
            event.preventGridDefault()
            event.preventDefault()
            openCopyMenu(event.currentTarget, text)
        },
        [closeCopyMenu, openCopyMenu]
    )

    const sortedRows = useMemo(() => {
        if (!sortColumns.length) {
            return rows
        }

        return [...rows].sort((a, b) => {
            for (const { columnKey, direction } of sortColumns) {
                const aVal = a[columnKey]
                const bVal = b[columnKey]

                if (aVal === bVal) {
                    continue
                }
                if (aVal == null) {
                    return 1
                }
                if (bVal == null) {
                    return -1
                }

                const result = aVal < bVal ? -1 : 1
                return direction === 'DESC' ? -result : result
            }
            return 0
        })
    }, [rows, sortColumns])
    const hasError = queryCancelled || !!responseError || !!(response && 'error' in response && !!response.error)

    if (hasError) {
        return (
            <ErrorState
                responseError={responseError}
                sourceQuery={sourceQuery}
                queryCancelled={queryCancelled}
                response={response}
                showQueryScan={showQueryScan}
            />
        )
    }

    if (activeTab === OutputTab.Visualization) {
        if (!response && !responseLoading && !insightLoading) {
            return (
                <div
                    className="flex min-w-0 flex-1 flex-col justify-center items-center border-t gap-4 p-4"
                    data-attr="sql-editor-output-pane-empty-state"
                >
                    <span className="text-secondary">
                        Query results will be visualized here. Press <KeyboardShortcut command enter /> to run the
                        query.
                    </span>
                    {showAgentHints ? (
                        <WarehouseWizardHint
                            className="max-w-140"
                            fallback={
                                <MCPUseCaseCard
                                    surfaceKey="sql.execute"
                                    expiresAfterMs={ONE_DAY_IN_MILLISECONDS}
                                    className="max-w-140"
                                />
                            }
                        />
                    ) : null}
                </div>
            )
        }

        return (
            <div className="absolute inset-0 flex flex-col border-t overflow-hidden">
                <QueryWarningsBanner warnings={response?.warnings} />
                {showQueryScan && <EditorQueryScanBanner />}
                <div className="flex flex-col flex-1 min-h-0 hide-scrollbar overflow-auto">
                    <InternalDataTableVisualization
                        uniqueKey={vizKey}
                        query={sourceQuery}
                        setQuery={setSourceQuery}
                        context={{}}
                        cachedResults={undefined}
                        exportContext={exportContext}
                        editMode
                        embedded={isEmbeddedMode}
                        showSettingsPanel={showVisualizationSettings}
                    />
                </div>
            </div>
        )
    }

    if (responseLoading || insightLoading) {
        return (
            <div className="flex flex-1 p-2 w-full justify-center items-center border-t">
                <StatelessInsightLoadingState
                    queryId={queryId}
                    pollResponse={pollResponse}
                    setProgress={setProgress}
                    progress={progress}
                    suggestion={
                        // Only worth saying once the query is demonstrably slow.
                        selectedDirectSource?.source_type === 'Motherduck' && loadingTimeSeconds >= 60 ? (
                            <p className="text-xs m-0 text-center">
                                This query runs live on your MotherDuck database. Speed depends on its capacity and
                                current load.
                            </p>
                        ) : undefined
                    }
                />
            </div>
        )
    }

    if (!response) {
        const msg =
            activeTab === OutputTab.Results
                ? 'Query results will appear here.'
                : 'Query results will be visualized here.'
        return (
            <div
                className="flex flex-1 flex-col justify-center items-center border-t px-4 py-6 gap-4 text-center"
                data-attr="sql-editor-output-pane-empty-state"
            >
                {singleStatement ? (
                    <span className="text-secondary max-w-xl">
                        {msg} Press <KeyboardShortcut command enter /> to run the query.
                    </span>
                ) : (
                    <span className="text-secondary max-w-xl">
                        {msg} Press <KeyboardShortcut command enter /> to run the query at your cursor. Separate
                        multiple statements with <code>;</code> to run them independently.
                    </span>
                )}
                {showAgentHints ? (
                    <WarehouseWizardHint
                        className="max-w-140"
                        fallback={
                            <MCPUseCaseCard
                                surfaceKey="sql.execute"
                                expiresAfterMs={ONE_DAY_IN_MILLISECONDS}
                                className="max-w-140"
                            />
                        }
                    />
                ) : null}
            </div>
        )
    }

    if (activeTab === OutputTab.Results) {
        return (
            <div className="flex flex-col flex-1 min-h-0 w-full overflow-hidden">
                <QueryWarningsBanner warnings={response?.warnings} />
                {showQueryScan && <EditorQueryScanBanner />}
                {rows.length === 0 ? (
                    <EmptyResultsState />
                ) : (
                    <TabScroller data-attr="sql-editor-output-pane-results">
                        <DataGrid
                            className={clsx(isDarkModeOn ? 'rdg-dark h-full' : 'rdg-light h-full', 'ph-no-capture')}
                            columns={columns}
                            rows={sortedRows}
                            sortColumns={sortColumns}
                            onSortColumnsChange={setSortColumns}
                            onCellContextMenu={handleGridCellContextMenu}
                        />
                        {copyMenu}
                    </TabScroller>
                )}
            </div>
        )
    }
    return null
}