{"record":{"id":"1ed33a2d3169ae91","repo":"databendlabs/databend","slug":"internal-error-entered-unreachable-code-1ed33a","errorCode":null,"errorMessage":"internal error: entered unreachable code","messagePattern":"internal error: entered unreachable code","errorType":"panic","errorClass":null,"httpStatus":null,"severity":"error","filePath":"src/query/service/src/physical_plans/physical_range_join.rs","lineNumber":328,"sourceCode":"            for (idx, arg) in [arg1, arg2].iter().enumerate() {\n                let join_predicate = JoinPredicate::new(arg, left_prop, right_prop);\n                match join_predicate {\n                    JoinPredicate::Left(_) => {\n                        left = Some(arg.type_check(left_schema.as_ref())?.project_column_ref(\n                            |index| left_schema.index_of(&index.to_string()),\n                        )?);\n                    }\n                    JoinPredicate::Right(_) => {\n                        if idx == 0 {\n                            opposite = true;\n                        }\n                        right = Some(arg.type_check(right_schema.as_ref())?.project_column_ref(\n                            |index| right_schema.index_of(&index.to_string()),\n                        )?);\n                    }\n                    JoinPredicate::ALL(_)\n                    | JoinPredicate::Both { .. }\n                    | JoinPredicate::Other(_) => unreachable!(),\n                }\n            }\n            let op = if opposite {\n                match func.func_name.as_str() {\n                    \"gt\" => \"lt\",\n                    \"lt\" => \"gt\",\n                    \"gte\" => \"lte\",\n                    \"lte\" => \"gte\",\n                    _ => unreachable!(),\n                }\n            } else {\n                func.func_name.as_str()\n            };\n            Ok(RangeJoinCondition {\n                left_expr: left.unwrap().as_remote_expr(),\n                right_expr: right.unwrap().as_remote_expr(),\n                operator: op.to_string(),\n            })","sourceCodeStart":310,"sourceCodeEnd":346,"githubUrl":"https://github.com/databendlabs/databend/blob/288d84d76e20a2f8f7173bda9691eb6ece301aa9/src/query/service/src/physical_plans/physical_range_join.rs#L310-L346","documentation":"A `unreachable!()` in `resolve_range_condition` (called by RangeJoin planning). When processing join predicate sides, the code asserts only `JoinPredicate::Single` (left/right) values occur at that point — `ALL`, `Both`, and `Other` predicate kinds are treated as impossible. Hitting it means a range-join condition was built from a predicate shape the range-join planner does not support but received anyway.","triggerScenarios":"Planning a range join (e.g., join with inequality conditions) whose source `JoinPredicate` is `ALL`, `Both{..}`, or `Other` at the point where only single-sided predicates are expected.","commonSituations":"Queries with complex range join conditions (non-equi joins, OR-combined predicates) that the planner classifies into an unsupported JoinPredicate variant; optimizer changes that alter predicate classification.","solutions":["Simplify the range join condition into supported single-sided inequality predicates (one left column op right column per condition)","Check whether a newer Databend version handles the predicate shape or rejects the query gracefully; upgrade","Rewrite the join to avoid Other/complex predicates in range joins, e.g., split into multiple joins or move logic into a WHERE clause","File the failing query with Databend maintainers so unsupported predicate kinds are rejected at planning rather than panicking"],"exampleFix":"// before\nJoinPredicate::ALL(_) | JoinPredicate::Both { .. } | JoinPredicate::Other(_) => unreachable!(),\n// after\nJoinPredicate::ALL(_) | JoinPredicate::Both { .. } | JoinPredicate::Other(_) => {\n    return Err(ErrorCode::Unimplemented(\"unsupported join predicate for range join\"))\n}","handlingStrategy":"validation","validationCode":"// Validate predicate shape before planning a range join\nmatch predicate {\n    JoinPredicate::Single(_) => plan_range_join(predicate),\n    _ => return Err(ErrorCode::Unimplemented(\"range join requires single-sided predicates\")),\n}","typeGuard":"fn is_single(p: &JoinPredicate) -> bool { matches!(p, JoinPredicate::Single(_)) }","tryCatchPattern":"catch_unwind around RangeJoin planning; return a planning error suggesting query rewrite instead of a panic","preventionTips":["Only emit range joins for predicates that resolve to Single left/right comparisons","Reject ALL/Both/Other predicate kinds at logical planning with a clear error","Add optimizer tests covering each JoinPredicate variant reaching range-join planning","Keep join predicate classification and range-join support matrix in one place"],"tags":["rust","panic","unreachable","range-join","join-predicate","internal-invariant"],"backgroundTag":"internal-invariant-violation","analyzedSha":"288d84d76e20a2f8f7173bda9691eb6ece301aa9","analyzedAt":"2026-09-11T11:29:36.208Z","contentChangedAt":"2026-09-11T11:29:36.208Z","schemaVersion":2},"datasetVersion":"2026-09-16T04:17:20.429Z"}