influxdata/influxdb · error · TimestampMinMaxError

Could not convert Parquet schema to Arrow schema

Error message

Could not convert Parquet schema to Arrow schema: {0}

What it means

TimestampMinMaxError::SchemaConversion — converting the Parquet schema to an Arrow schema failed while computing timestamp min/max values. Wrapped parquet::errors::ParquetError; indicates an incompatibility between the file's Parquet types and Arrow's supported type space.

Solutions

1. Upgrade the parquet and arrow crates to compatible versions supporting the file's logical types
2. Reject foreign schemas before calling the min/max helper (validate against the expected IOx schema)
3. Inspect the underlying ParquetError message for the specific unsupported type

Example fix

// caller-side handling
match parquet_file.timestamp_min_max() {
    Err(TimestampMinMaxError::SchemaConversion(e)) => warn!("unsupported schema: {e}"),
    r => r?,
}

let arrow_schema = parquet::arrow::parquet_to_arrow_schema(&md.file_metadata(), None)?; // early check

match ts_min_max {
    Err(TimestampMinMaxError::SchemaConversion(e)) => { warn!("schema unsupported: {e}"); fallback(); }
    other => other?,
}

When it happens

Trigger: Calling the timestamp min/max helper on a file containing Parquet logical/physical types the arrow schema converter rejects (exotic logical types, unsupported repetition/def levels).

Common situations: Foreign Parquet files with newer logical types than the pinned parquet/arrow crates support, version skew between parquet and arrow crate versions.

Understand the failure class

Background: Schema validation failed / invalid input schema: payload rejected because its shape doesn't match the expected schema — this error's family across 28 libraries.

Related errors

• Expected time column to have type Int64; instead found
• parquet error
• Type mismatch, expected
• unexpected physical type for timestamp column
• Arrow csv printing error

AI-assisted analysis of influxdata/influxdb@06200ef96b (2026-09-19). Data as JSON: /api/errors/08708e455df91c01. Report an issue: GitHub.

Appendix: source

Thrown at core/parquet_file/src/metadata.rs:1011

    parquet_metadata: &ParquetMetaData,
) -> Result<Option<TimestampMinMax>, TimestampMinMaxError> {
    let timestamp_min_maxes = parquet_metadata
        .row_groups()
        .iter()
        .map(timestamp_min_max)
        .collect::<Result<Vec<_>, _>>()?;
    let file_timestamp_min_max = timestamp_min_maxes
        .into_iter()
        .reduce(|acc, i| acc.union(&i));

    Ok(file_timestamp_min_max)
}

/// Errors that may happen while collecting the min and max timestamps
#[expect(missing_docs)]
#[derive(Debug, Error)]
pub enum TimestampMinMaxError {
    #[error("Could not convert Parquet schema to Arrow schema: {0}")]
    SchemaConversion(#[from] parquet::errors::ParquetError),

    #[error("Could not find a time column")]
    NoTimeColumnFound,

    #[error("Could not find time column statistics")]
    NoColumnStatisticsFound,

    #[error("Expected time column to have type Int64; instead found {actual:?}")]
    IncorrectTimeColumnType { actual: parquet::basic::Type },
}

fn timestamp_min_max(
    row_group: &ParquetRowGroupMetaData,
) -> Result<TimestampMinMax, TimestampMinMaxError> {
    let statistics = row_group
        .columns()
        .iter()

View on GitHub (pinned to 06200ef96b)