apache/beam · error · UnsupportedOperationException

Converting BigQuery type to Beam type is unsupported

Error message

Converting BigQuery type  to Beam type is unsupported

What it means

BigQueryUtils.fromTableFieldSchemaType throws this UnsupportedOperationException while mapping a BigQuery TIMESTAMP column to a Beam FieldType when the column has picosecond (12-digit) timestamp precision and the configured PicosecondTimestampMapping option has no recognized case (MILLIS, MICROS, NANOS, PICOS). It signals that the user-supplied conversion option value is not one of the supported enum constants. Note the message renders an empty type name because the switch operates on the literal "TIMESTAMP" string and typeName is interpolated in a context where it appears blank in some builds.

Source

Thrown at sdks/java/io/google-cloud-platform/src/main/java/org/apache/beam/sdk/io/gcp/bigquery/BigQueryUtils.java:489

      case "TIMESTAMP":
        // Timestamp columns can only have 6 (micros) or 12 (picos) precision.
        // BigQuerySchema currently returns null for all microsecond timestamp
        // columns but this cannot be guaranteed forever.
        if ((schema.getTimestampPrecision() == null)
            || Long.valueOf(6L).equals(schema.getTimestampPrecision())) {
          return FieldType.DATETIME;
        }
        switch (options.getPicosecondTimestampMapping()) {
          case MILLIS:
            return FieldType.logicalType(Timestamp.MILLIS);
          case MICROS:
            return FieldType.logicalType(Timestamp.MICROS);
          case NANOS:
            return FieldType.logicalType(Timestamp.NANOS);
          case PICOS:
            return FieldType.STRING;
          default:
            throw new UnsupportedOperationException(
                "Converting BigQuery type " + typeName + " to Beam type is unsupported");
        }
      case "DATE":
        return FieldType.logicalType(SqlTypes.DATE);
      case "TIME":
        return FieldType.logicalType(SqlTypes.TIME);
      case "DATETIME":
        return FieldType.logicalType(SqlTypes.DATETIME);
      case "NUMERIC":
      case "BIGNUMERIC":
        return FieldType.DECIMAL;
      case "GEOGRAPHY":
      case "JSON":
        // TODO Add metadata for custom sql types ?
        return FieldType.STRING;
      case "RECORD":
      case "STRUCT":
        List<TableFieldSchema> nestedFields = schema.getFields();

View on GitHub (pinned to 12126d8942)

Solutions

1. Upgrade Apache Beam to a version that supports picosecond timestamps and the full PicosecondTimestampMapping enum.
2. Explicitly set SchemaConversionOptions.withPicosecondTimestampMapping(PicosecondTimestampMapping.MICROS) (or NANOS/PICOS/MILLIS) when calling fromTableSchema.
3. If upgrading is impossible, avoid picosecond-precision TIMESTAMP columns (use precision 6 / standard TIMESTAMP) or map them to STRING before conversion.

Example fix

// before
Schema beamSchema = BigQueryUtils.fromTableSchema(tableSchema);
// after
Schema beamSchema = BigQueryUtils.fromTableSchema(
    tableSchema,
    SchemaConversionOptions.builder()
        .setPicosecondTimestampMapping(PicosecondTimestampMapping.MICROS)
        .build());

TableFieldSchema tsField = /* find TIMESTAMP field */;
boolean pico = tsField.getTimestampPrecision() != null && tsField.getTimestampPrecision() == 12L;
if (pico) {
  // ensure a supported mapping is configured
  PicosecondTimestampMapping m = options.getPicosecondTimestampMapping();
  if (m != PicosecondTimestampMapping.MILLIS && m != PicosecondTimestampMapping.MICROS
      && m != PicosecondTimestampMapping.NANOS && m != PicosecondTimestampMapping.PICOS) {
    throw new IllegalStateException("Set a valid PicosecondTimestampMapping before converting");
  }
}

boolean hasSupportedPicoMapping(SchemaConversionOptions o) {
  Enum<?> m = o.getPicosecondTimestampMapping();
  return m != null && java.util.Arrays.stream(PicosecondTimestampMapping.values()).anyMatch(v -> v == m);
}

try {
  Schema s = BigQueryUtils.fromTableSchema(tableSchema, options);
} catch (UnsupportedOperationException e) {
  // fall back to a known-good mapping
  Schema s = BigQueryUtils.fromTableSchema(
      tableSchema,
      SchemaConversionOptions.builder()
          .setPicosecondTimestampMapping(PicosecondTimestampMapping.MICROS).build());
}

When it happens

Trigger: Reading a BigQuery table whose TIMESTAMP field carries timestampPrecision=12 (picoseconds) via BeamIO.bigqueryTableSchemaToSchema / fromTableSchema with a SchemaConversionOptions whose getPicosecondTimestampMapping() returns an unexpected value (e.g. null-deserialized or a future enum constant from a newer SDK being read by an older switch).

Common situations: Users on older Beam versions reading tables written by newer BigQuery clients that set picosecond precision; constructing SchemaConversionOptions programmatically with a wrong/legacy enum; deserialized pipeline options losing the mapping enum.

Related errors

• Array of collection is not supported in BigQuery.
• Unsupported precision for Timestamp logical type
• BigQuery data contained value %s with sub-millisecond precis
• Unsupported integer bit width: ${type.getBitWidth()}
• Unsupported floating-point precision: ${type.getPrecision().

AI-assisted analysis of apache/beam@12126d8942 (2026-09-13). Data as JSON: /api/errors/8ce001b707e73157. Report an issue: GitHub.