{"record":{"id":"454921ce9b5e2677","repo":"apache/seatunnel","slug":"invalid-like-pattern-s-supported-patterns-are","errorCode":null,"errorMessage":"Invalid LIKE pattern: '%s'. Supported patterns are: 'prefix%', '%suffix', and '%substring%'. Please ensure your pattern matches one of these formats.","messagePattern":"Invalid LIKE pattern: '(.+?)'\\. Supported patterns are: 'prefix%', '(.+?)uffix', and '(.+?)ubstring%'\\. Please ensure your pattern matches one of these formats\\.","errorType":"exception","errorClass":"IllegalArgumentException","httpStatus":null,"severity":"error","filePath":"seatunnel-connectors-v2/connector-paimon/src/main/java/org/apache/seatunnel/connectors/seatunnel/paimon/source/converter/SqlToPaimonPredicateConverter.java","lineNumber":297,"sourceCode":"            Matcher beginMatcher = BEGIN_PATTERN.matcher(rightVal.toString());\n            if (beginMatcher.matches()) {\n                return builder.startsWith(\n                        columnIndex, BinaryString.fromString(beginMatcher.group(1)));\n            }\n\n            Pattern END_PATTERN = Pattern.compile(\"^%([^%]+)\");\n            Matcher endMatcher = END_PATTERN.matcher(rightVal.toString());\n            if (endMatcher.matches()) {\n                return builder.endsWith(columnIndex, BinaryString.fromString(endMatcher.group(1)));\n            }\n\n            Pattern CONTAINS_PATTERN = Pattern.compile(\"^%([^%]+)%$\");\n            Matcher containsMatcher = CONTAINS_PATTERN.matcher(rightVal.toString());\n            if (containsMatcher.matches()) {\n                return builder.contains(\n                        columnIndex, BinaryString.fromString(containsMatcher.group(1)));\n            }\n            throw new IllegalArgumentException(\n                    String.format(\n                            \"Invalid LIKE pattern: '%s'. Supported patterns are: 'prefix%%', '%%suffix', and '%%substring%%'. \"\n                                    + \"Please ensure your pattern matches one of these formats.\",\n                            rightVal.toString()));\n\n        } else if (expression instanceof Parenthesis) {\n            Parenthesis parenthesis = (Parenthesis) expression;\n            return parseExpressionToPredicate(builder, rowType, parenthesis.getExpression());\n        } else if (expression instanceof InExpression) {\n            return handleInExpression(builder, rowType, (InExpression) expression);\n        }\n        throw new IllegalArgumentException(\n                \"Unsupported expression type: \" + expression.getClass().getSimpleName());\n    }\n\n    private static Predicate handleInExpression(\n            PredicateBuilder builder, RowType rowType, InExpression expr) {\n        Expression left = expr.getLeftExpression();","sourceCodeStart":279,"sourceCodeEnd":315,"githubUrl":"https://github.com/apache/seatunnel/blob/cf67b549a7a6c35fa0beb12d83c62892427ea919/seatunnel-connectors-v2/connector-paimon/src/main/java/org/apache/seatunnel/connectors/seatunnel/paimon/source/converter/SqlToPaimonPredicateConverter.java#L279-L315","documentation":"This error is thrown by SqlToPaimonPredicateConverter.parseExpressionToPredicate when a SQL WHERE clause contains a LIKE operator whose pattern does not match one of the three supported shapes: 'prefix%', '%suffix', or '%substring%'. The converter translates JSqlParser expressions into Paimon Predicates, and LIKE patterns that cannot map to a Paimon contains/prefix/suffix predicate (e.g. '_x%' or 'a%b') are rejected rather than silently dropped.","triggerScenarios":"A pushdown WHERE clause like `col LIKE 'a_b%'`, `col LIKE 'a%b'`, or any pattern with multiple/escaped wildcards reaches the LIKE branch; the compiled PREFIX/SUFFIX/CONTAINS regexes all fail to match rightVal, so the final throw fires.","commonSituations":"Users writing SQL filters with underscore wildcards, patterns containing escapes, or patterns copied from other SQL engines that allow regex-like LIKE; multi-wildcard patterns such as 'pre%suf'.","solutions":["Rewrite the LIKE pattern to one of 'prefix%', '%suffix', or '%substring%' forms.","Move unsupported LIKE patterns out of pushdown and filter rows after read.","Check for typos like double wildcards '%%' or underscore '_' in the pattern.","If full LIKE support is needed, extend the converter with a Paimon PredicateBuilder fallback or an explicit runtime filter."],"exampleFix":"// before: WHERE name LIKE 'a_b%' | // after: WHERE name LIKE 'ab%' (or filter after read)","handlingStrategy":"validation","validationCode":"static boolean isSupportedLike(String pat) { return pat != null && (pat.matches(\"^[^%_]+%$\") || pat.matches(\"^%[^%_]+$\") || pat.matches(\"^%[^%_]+%$\")); }","typeGuard":null,"tryCatchPattern":"try { pred = converter.convertSqlWhereToPaimonPredicate(where, rowType); } catch (IllegalArgumentException e) { log.warn(\"LIKE pattern unsupported, skipping pushdown: {}\", e.getMessage()); /* filter after read */ }","preventionTips":["Only emit LIKE patterns of the form 'prefix%', '%suffix', '%substring%'.","Avoid '_' wildcard and multi-wildcard patterns in pushdown filters.","Pre-validate WHERE clauses for unsupported LIKE shapes before submitting.","Document supported LIKE forms for query authors."],"tags":["sql","paimon","predicate-pushdown","like-pattern"],"backgroundTag":"invalid-regex-pattern","analyzedSha":"cf67b549a7a6c35fa0beb12d83c62892427ea919","analyzedAt":"2026-09-10T21:44:55.265Z","contentChangedAt":"2026-09-10T21:44:55.265Z","schemaVersion":2},"datasetVersion":"2026-09-14T05:17:10.506Z"}