{"record":{"id":"bfdf3bb7a7287eb3","repo":"apache/iceberg","slug":"unsupported-primitive-type-type","errorCode":null,"errorMessage":"Unsupported primitive type: <type>","messagePattern":"Unsupported primitive type: <type>","errorType":"exception","errorClass":"IllegalArgumentException","httpStatus":null,"severity":"error","filePath":"parquet/src/main/java/org/apache/iceberg/parquet/ParquetConversions.java","lineNumber":71,"sourceCode":"      case FIXED:\n      case BINARY:\n        return (T) ((Binary) value).toByteBuffer();\n      case DECIMAL:\n        int scale =\n            ((DecimalLogicalTypeAnnotation) parquetType.getLogicalTypeAnnotation()).getScale();\n        switch (parquetType.getPrimitiveTypeName()) {\n          case INT32:\n          case INT64:\n            return (T) BigDecimal.valueOf(((Number) value).longValue(), scale);\n          case FIXED_LEN_BYTE_ARRAY:\n          case BINARY:\n            return (T) new BigDecimal(new BigInteger(((Binary) value).getBytes()), scale);\n          default:\n            throw new IllegalArgumentException(\n                \"Unsupported primitive type for decimal: \" + parquetType.getPrimitiveTypeName());\n        }\n      default:\n        throw new IllegalArgumentException(\"Unsupported primitive type: \" + type);\n    }\n  }\n\n  static Function<Object, Object> converterFromParquet(\n      PrimitiveType parquetType, Type icebergType) {\n    Function<Object, Object> fromParquet = converterFromParquet(parquetType);\n    if (icebergType != null) {\n      if (icebergType.typeId() == Type.TypeID.LONG\n          && parquetType.getPrimitiveTypeName() == PrimitiveType.PrimitiveTypeName.INT32) {\n        return value -> ((Integer) fromParquet.apply(value)).longValue();\n      } else if (icebergType.typeId() == Type.TypeID.DOUBLE\n          && parquetType.getPrimitiveTypeName() == PrimitiveType.PrimitiveTypeName.FLOAT) {\n        return value -> ((Float) fromParquet.apply(value)).doubleValue();\n      } else if (icebergType.typeId() == Type.TypeID.UUID) {\n        return binary -> UUIDUtil.convert(((Binary) binary).toByteBuffer());\n      }\n    }\n","sourceCodeStart":53,"sourceCodeEnd":89,"githubUrl":"https://github.com/apache/iceberg/blob/86d9c8fc543e7c56c9f624eb725f76c9baff9570/parquet/src/main/java/org/apache/iceberg/parquet/ParquetConversions.java#L53-L89","documentation":"Thrown by ParquetConversions.convertValue's outer default branch when the requested Iceberg primitive type has no Parquet-to-Iceberg value conversion implemented. The switch over the Iceberg type only handles known primitives; any other or unmapped type falls through to this error.","triggerScenarios":"Passing an Iceberg type to convertValue that the converter does not support (e.g. a composite/nested type or a newer primitive added to the spec but not the converter), usually from converterFromParquet wiring.","commonSituations":"Custom read pipelines converting values manually; version skew where a new Iceberg type is read by an older converter; misuse of the public converter API with non-primitive types.","solutions":["Use a supported Iceberg primitive type in the converter call.","Upgrade Iceberg so the type is supported by ParquetConversions.","Convert nested/complex values through the dedicated readers (value readers/struct readers) instead of convertValue."],"exampleFix":"// before\nconverter(parquetType, Types.NestedField.of(..., Types.StructType.get()))\n// after\nconverter(parquetType, Types.IntegerType.get()) // or handle complex types with the standard readers","handlingStrategy":"type-guard","validationCode":"if (icebergType.isPrimitiveType()) {\n  switch (icebergType.asPrimitiveType().typeId()) {\n    case BOOLEAN: case INT: case LONG: case FLOAT: case DOUBLE: case DATE: case TIME:\n    case TIMESTAMP: case STRING: case UUID: case FIXED: case BINARY: case DECIMAL: break;\n    default: throw new IllegalArgumentException(\"Type not convertible: \" + icebergType);\n  }\n}","typeGuard":"boolean convertible(Type t) {\n  return t.isPrimitiveType();\n}","tryCatchPattern":"try {\n  Object v = ParquetConversions.convertValue(parquetType, type, scale, value);\n} catch (IllegalArgumentException e) {\n  LOG.error(\"Unsupported type {} for Parquet conversion\", type, e);\n  throw e;\n}","preventionTips":["Only use convertValue/converterFromParquet for supported primitives.","Keep Iceberg and writer versions aligned so new types have converter support.","Route complex types through the generic value readers instead."],"tags":["parquet","conversion","unsupported-type"],"backgroundTag":"unsupported-operation","analyzedSha":"86d9c8fc543e7c56c9f624eb725f76c9baff9570","analyzedAt":"2026-09-12T00:46:39.097Z","contentChangedAt":"2026-09-12T00:46:39.097Z","schemaVersion":2},"datasetVersion":"2026-09-23T08:17:48.524Z"}