apache/druid · error · ISE

Unsupported type[ ]

Error message

Unsupported type[%s]

What it means

ColumnProcessors.makeProcessorInternal builds a per-column processor based on the column's effective type. If the effective type is not one of the handled switch cases (e.g. it falls through to default), Druid throws this IllegalStateException. It signals an unsupported or unknown column type reaching the processor factory, typically an internal invariant violation rather than user error.

Solutions

1. Check the column's effective type via ColumnCapabilities.asTypeString() and ensure your input column is of a supported type (STRING, LONG, FLOAT, DOUBLE, ARRAY, COMPLEX).
2. If using a custom processor factory, ensure it's registered for a type handled by the switch, or upgrade/patch ColumnProcessors to handle the new type.
3. Verify segment metadata isn't corrupted; re-ingest or re-segment the data if the column type is wrong.
4. Upgrade Druid to a version that supports the column type in question.

Example fix

// before: passing a column with unknown capabilities directly
ColumnProcessorFactory<?> factory = ...;
ColumnProcessors.makeProcessor(typeName, factory, capabilities, columnSelectorFactory);
// after: validate the type first
if (capabilities == null || capabilities.getType() == null) {
  throw new ISE("Column [%s] has unknown type", typeName);
}

if (capabilities != null && capabilities.getType() != null &&
    !SUPPORTED_TYPES.contains(capabilities.getType())) {
  throw new IllegalArgumentException("Column type not supported for processing: " + capabilities.getType());
}

boolean isSupported(ColumnCapabilities caps) {
  return caps != null && caps.getType() != null && caps.getType().isSetValueType();
}

try {
  return ColumnProcessors.makeProcessor(typeName, factory, capabilities, selectorFactory);
} catch (IllegalStateException e) {
  if (e.getMessage().startsWith("Unsupported type")) {
    throw new QueryUnsupportedException("Column type not supported: " + typeName, e);
  }
  throw e;
}

When it happens

Trigger: Calling ColumnProcessors.makeProcessor (or makeProcessorWithObjectiveSupport) on a column whose ColumnCapabilities effectiveType resolves to a type not covered by the switch (e.g. an uninitialized/unknown type), or a custom ColumnProcessorFactory registered for a column type the switch does not enumerate.

Common situations: Custom extensions introducing a new ValueType without updating ColumnProcessors; reading segments written by a newer/older Druid version with a type the current code doesn't handle; corrupted segment metadata yielding a null/unknown effective type.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

• Cannot create comparator for array type
• Cannot handle column
• Cannot handle column
• Cannot handle column
• Cannot handle column

AI-assisted analysis of apache/druid@9b90983fd2 (2026-09-07). Data as JSON: /api/errors/11b8f52014965736. Report an issue: GitHub.

Appendix: source

Thrown at processing/src/main/java/org/apache/druid/segment/ColumnProcessors.java:297

        return processorFactory.makeDimensionProcessor(
            dimensionSelectorFn.apply(selectorFactory),
            mayBeMultiValue(capabilities)
        );
      case LONG:
        return processorFactory.makeLongProcessor(valueSelectorFunction.apply(selectorFactory));
      case FLOAT:
        return processorFactory.makeFloatProcessor(valueSelectorFunction.apply(selectorFactory));
      case DOUBLE:
        return processorFactory.makeDoubleProcessor(valueSelectorFunction.apply(selectorFactory));
      case ARRAY:
        return processorFactory.makeArrayProcessor(
            valueSelectorFunction.apply(selectorFactory),
            capabilities
        );
      case COMPLEX:
        return processorFactory.makeComplexProcessor(valueSelectorFunction.apply(selectorFactory));
      default:
        throw new ISE("Unsupported type[%s]", effectiveType.asTypeString());
    }
  }

  /**
   * Creates "column processors", which are objects that wrap a single input column and provide some
   * functionality on top of it.
   *
   * @param inputCapabilitiesFn            function that returns capabilities of the column being processed. The type provided
   *                                       by these capabilities will be used to determine what kind of selector to create. If
   *                                       this function returns null, then it is assumed that the column does not exist.
   *                                       Note: this is different behavior from the non-vectorized version.
   * @param singleValueDimensionSelectorFn function that creates a singly-valued dimension selector for the column being
   *                                       processed. Will be called if the column is singly-valued string.
   * @param multiValueDimensionSelectorFn  function that creates a multi-valued dimension selector for the column being
   *                                       processed. Will be called if the column is multi-valued string.
   * @param valueSelectorFn                function that creates a value selector for the column being processed. Will be
   *                                       called if the column type is long, float, or double.
   * @param objectSelectorFn               function that creates an object selector for the column being processed. Will

View on GitHub (pinned to 9b90983fd2)