{"record":{"id":"edde4aa945b5f1fc","repo":"apache/iceberg","slug":"type-not-supported-in-orc-searcharguments","errorCode":null,"errorMessage":"Type  not supported in ORC SearchArguments","messagePattern":"Type  not supported in ORC SearchArguments","errorType":"exception","errorClass":"UnsupportedOperationException","httpStatus":null,"severity":"error","filePath":"orc/src/main/java/org/apache/iceberg/orc/ExpressionToSearchArgument.java","lineNumber":317,"sourceCode":"        return PredicateLeaf.Type.BOOLEAN;\n      case INTEGER:\n      case LONG:\n      case TIME:\n        return PredicateLeaf.Type.LONG;\n      case FLOAT:\n      case DOUBLE:\n        return PredicateLeaf.Type.FLOAT;\n      case DATE:\n        return PredicateLeaf.Type.DATE;\n      case TIMESTAMP:\n      case TIMESTAMP_NANO:\n        return PredicateLeaf.Type.TIMESTAMP;\n      case STRING:\n        return PredicateLeaf.Type.STRING;\n      case DECIMAL:\n        return PredicateLeaf.Type.DECIMAL;\n      default:\n        throw new UnsupportedOperationException(\n            \"Type \" + icebergType + \" not supported in ORC SearchArguments\");\n    }\n  }\n\n  private <T> Object literal(Type icebergType, T icebergLiteral) {\n    switch (icebergType.typeId()) {\n      case BOOLEAN:\n      case LONG:\n      case TIME:\n      case DOUBLE:\n        return icebergLiteral;\n      case INTEGER:\n        return ((Integer) icebergLiteral).longValue();\n      case FLOAT:\n        return ((Float) icebergLiteral).doubleValue();\n      case STRING:\n        return icebergLiteral.toString();\n      case DATE:","sourceCodeStart":299,"sourceCodeEnd":335,"githubUrl":"https://github.com/apache/iceberg/blob/86d9c8fc543e7c56c9f624eb725f76c9baff9570/orc/src/main/java/org/apache/iceberg/orc/ExpressionToSearchArgument.java#L299-L335","documentation":"ExpressionToSearchArgument converts Iceberg expressions into ORC SearchArguments for predicate pushdown. When a leaf predicate references an Iceberg type that has no ORC PredicateLeaf.Type mapping (anything not BOOLEAN, LONG/integer, DOUBLE/float, DATE, TIMESTAMP, STRING, DECIMAL), the type conversion throws UnsupportedOperationException. This means the predicate cannot be pushed down to the ORC reader and must be evaluated elsewhere.","triggerScenarios":"Calling type() via isNull, notNull, isNaN, lt, ltEq, or gt on an expression whose operand type is one of the unmapped Iceberg types (e.g. UUID, BINARY, Fixed, Time, TimestampNano, struct/list/map types).","commonSituations":"Filtering ORC scans on binary/fixed columns, UUID columns, or timestamp-nano columns; newer Iceberg types added after the switch was written; engine-generated filters pushed down over non-primitive columns.","solutions":["Check the ORC schema/table columns involved in the filter and remove or rewrite predicates on unsupported types (UUID, BINARY, Fixed, Time, TimestampNano)","Add a redundant cast/filter form that operates on a supported type (e.g. compare string representations)","Upgrade Iceberg; support for more types in SearchArgument conversion may have been added in later versions","Wrap the scan so unsupported predicates are evaluated post-scan (residual filter) instead of pushed down"],"exampleFix":"// before: filter on a binary column triggers the error\nTableScan scan = table.newScan().filter(Expressions.equal(\"payload_bytes\", value));\n// after: filter on a supported column, or evaluate the unsupported predicate after the scan\nTableScan scan = table.newScan().filter(Expressions.equal(\"payload_string\", value));","handlingStrategy":"type-guard","validationCode":"import org.apache.iceberg.types.Types;\nstatic final Set<Types.TypeID> ORC_SUPPORTED = Set.of(Types.TypeID.BOOLEAN, Types.TypeID.INTEGER, Types.TypeID.LONG, Types.TypeID.FLOAT, Types.TypeID.DOUBLE, Types.TypeID.DATE, Types.TypeID.TIMESTAMP, Types.TypeID.STRING, Types.TypeID.DECIMAL);\nboolean pushdownSafe(Expression expr) {\n  return new ExpressionVisitors.ExpressionVisitor<Boolean>() {\n    @Override public <T> Boolean predicate(BoundPredicate<T> p) { return ORC_SUPPORTED.contains(p.term().type().typeId()); }\n  }.visit(expr);\n}","typeGuard":"static boolean orcPushdownSupported(Types.TypeID id) {\n  return switch (id) { case BOOLEAN, INTEGER, LONG, FLOAT, DOUBLE, DATE, TIMESTAMP, STRING, DECIMAL -> true; default -> false; };\n}","tryCatchPattern":"try {\n  searchArgument = ExpressionToSearchArgument.convert(expr);\n} catch (UnsupportedOperationException e) {\n  log.warn(\"Predicate not pushable to ORC, evaluating residually: {}\", e.getMessage());\n  searchArgument = null; // full scan; filter applied by engine\n}","preventionTips":["Restrict ORC table filters to primitive columns (string/number/date/timestamp/decimal/boolean)","Avoid filtering on UUID, BINARY, Fixed, and Time columns in ORC scans","Keep Iceberg upgraded so newly supported types are picked up","Test predicate pushdown coverage for your query patterns"],"tags":["orc","predicate-pushdown","unsupported-type","filter"],"backgroundTag":"unsupported-enum-value","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"}