influxdata/influxdb · critical

Unsupported InfluxQL data type

Error message

Unsupported InfluxQL data type: {dt}

What it means

This panic fires inside the iox_v1_query_api value conversion layer when an Arrow DataType from a query result cannot be mapped to any InfluxQL ValueType. The mapping handles String, Timestamp, UInt64 and Null explicitly; any other Arrow type (e.g. Int64, Float64, Boolean, Dictionary) reaching this match is considered a bug in the query planner/schema, so the code panics instead of returning a recoverable error. It is an internal invariant violation, not a user-input error.

Solutions

1. Check the panic message's displayed DataType and add an explicit DataType => ValueType mapping arm for it in core/iox_v1_query_api/src/value.rs (or convert the column beforehand)
2. If the column is genuinely not representable in InfluxQL, filter or coerce it to a supported type before the conversion
3. Fix the upstream planner so unsupported data types never reach this conversion; file an issue if the type came from data written by a supported path

Example fix

// before
dt => panic!("Unsupported InfluxQL data type: {dt}"),
// after
DataType::Int64 => ValueType::Integer,
DataType::Float64 => ValueType::Float,
dt => panic!("Unsupported InfluxQL data type: {dt}"),

fn is_supported(dt: &DataType) -> bool {
    matches!(dt, DataType::Utf8 | DataType::Timestamp(TimeUnit::Nanosecond, _) | DataType::UInt64 | DataType::Null)
}
if !is_supported(&arr.data_type()) { /* convert or skip column */ }

fn as_supported_value_type(dt: &DataType) -> Option<ValueType> {
    match dt {
        DataType::Utf8 => Some(ValueType::String),
        DataType::Timestamp(TimeUnit::Nanosecond, tz) => Some(ValueType::Timestamp(tz.clone())),
        DataType::UInt64 => Some(ValueType::Unsigned),
        DataType::Null => Some(ValueType::Null),
        _ => None,
    }
}

When it happens

Trigger: Calling the value_type conversion (used by fmt/eq paths when formatting or comparing query results) on a column whose Arrow DataType is one of the unmapped variants, e.g. a schema change produces Int64/Float64 columns where the InfluxQL v1 layer only expects String, Timestamp(ns), UInt64 or Null.

Common situations: A Parquet/Arrow schema produced by a newer writer version contains field types the v1 query path never anticipated; a query returns a computed column (aggregation producing Int64/Float64) fed into this conversion; unit tests constructing arrays with unsupported dtypes.

Related errors

• should have gotten a DictionaryArray
• should have gotten a StringArray
• time column was an unexpected type
• Arrow error
• Bind parameter ' ' was provided but not found in the…

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

Appendix: source

Thrown at core/iox_v1_query_api/src/value.rs:62

        }
    }

    /// Return the InfluxQL type of the value.
    pub(crate) fn value_type(&self) -> ValueType {
        match self.arr.data_type() {
            DataType::Boolean => ValueType::Boolean,
            DataType::Int64 => ValueType::Integer,
            DataType::Float64 | DataType::Float32 | DataType::Float16 => ValueType::Float,
            DataType::Utf8 => ValueType::String,
            DataType::Dictionary(k, v)
                if k.equals_datatype(&DataType::Int32) && v.equals_datatype(&DataType::Utf8) =>
            {
                ValueType::String
            }
            DataType::Timestamp(TimeUnit::Nanosecond, tz) => ValueType::Timestamp(tz.clone()),
            DataType::UInt64 => ValueType::Unsigned,
            DataType::Null => ValueType::Null,
            dt => panic!("Unsupported InfluxQL data type: {dt}"),
        }
    }

    /// Return the value as a boolean, if it is one.
    pub(crate) fn as_boolean_opt(&self) -> Option<bool> {
        if self.arr.is_valid(self.row) {
            self.arr.as_boolean_opt().map(|a| a.value(self.row))
        } else {
            None
        }
    }

    /// Return the value as an integer, if it is one.
    pub(crate) fn as_integer_opt(&self) -> Option<i64> {
        self.as_primitive_opt::<Int64Type>()
    }

    /// Return the value as a float, if it is one.

View on GitHub (pinned to 06200ef96b)