public static Regex likePattern(Slice pattern) { return likePattern(pattern.toStringUtf8(), '0', false); }
private Regex getConstantPattern(LikePredicate node) { Regex result = likePatternCache.get(node); if (result == null) { StringLiteral pattern = (StringLiteral) node.getPattern(); if (node.getEscape().isPresent()) { Slice escape = ((StringLiteral) node.getEscape().get()).getSlice(); result = LikeFunctions.likePattern(pattern.getSlice(), escape); } else { result = LikeFunctions.likePattern(pattern.getSlice()); } likePatternCache.put(node, result); } return result; }
@ScalarOperator(OperatorType.CAST) @LiteralParameters("x") @SqlType(LikePatternType.NAME) public static Regex castVarcharToLikePattern(@SqlType("varchar(x)") Slice pattern) { return likePattern(pattern); }
@ScalarOperator(OperatorType.CAST) @LiteralParameters("x") @SqlType(LikePatternType.NAME) public static Regex castCharToLikePattern(@LiteralParameter("x") Long charLength, @SqlType("char(x)") Slice pattern) { return likePattern(padSpaces(pattern, charLength.intValue())); }
@Test public void testLikeNewlineInMatch() { Regex regex = likePattern(utf8Slice("f%b%")); assertTrue(likeVarchar(utf8Slice("foo\nbar"), regex)); }
@Test public void testBackslashesNoSpecialTreatment() { Regex regex = likePattern(utf8Slice("\\abc\\/\\\\")); assertTrue(likeVarchar(utf8Slice("\\abc\\/\\\\"), regex)); }
@Test public void testLikeNewlineBeforeMatch() { Regex regex = likePattern(utf8Slice("%b%")); assertTrue(likeVarchar(utf8Slice("foo\nbar"), regex)); }
@Test public void testLikeNewlineInPattern() { Regex regex = likePattern(utf8Slice("%o\nbar")); assertTrue(likeVarchar(utf8Slice("foo\nbar"), regex)); }
@SuppressWarnings("NumericCastThatLosesPrecision") @Test(timeOut = 1000) public void testLikeInvalidUtf8Value() { Slice value = Slices.wrappedBuffer(new byte[] {'a', 'b', 'c', (byte) 0xFF, 'x', 'y'}); Regex regex = likePattern(utf8Slice("%b%"), utf8Slice("\\")); assertTrue(likeVarchar(value, regex)); }
@Test public void testSelfEscaping() { Regex regex = likePattern(utf8Slice("\\\\abc\\%"), utf8Slice("\\")); assertTrue(likeVarchar(utf8Slice("\\abc%"), regex)); }
@Test(timeOut = 1000) public void testLikeUtf8Pattern() { Regex regex = likePattern(utf8Slice("%\u540d\u8a89%"), utf8Slice("\\")); assertFalse(likeVarchar(utf8Slice("foo"), regex)); }
@Test public void testAlternateEscapedCharacters() { Regex regex = likePattern(utf8Slice("xxx%x_abcxx"), utf8Slice("x")); assertTrue(likeVarchar(utf8Slice("x%_abcx"), regex)); }
@Test public void testInvalidLikePattern() { assertThrows(PrestoException.class, () -> likePattern(utf8Slice("#"), utf8Slice("#"))); assertThrows(PrestoException.class, () -> likePattern(utf8Slice("abc#abc"), utf8Slice("#"))); assertThrows(PrestoException.class, () -> likePattern(utf8Slice("abc#"), utf8Slice("#"))); }
@Test public void testLikeBasic() { Regex regex = likePattern(utf8Slice("f%b__")); assertTrue(likeVarchar(utf8Slice("foobar"), regex)); assertFunction("'foob' LIKE 'f%b__'", BOOLEAN, false); assertFunction("'foob' LIKE 'f%b'", BOOLEAN, true); }
@ScalarFunction @LiteralParameters({"x", "y"}) @SqlType(LikePatternType.NAME) public static Regex likePattern(@SqlType("varchar(x)") Slice pattern, @SqlType("varchar(y)") Slice escape) { return likePattern(pattern.toStringUtf8(), getEscapeChar(escape), true); }
@Test public void testLike() throws Exception { for (String value : stringLefts) { for (String pattern : stringLefts) { Boolean expected = null; if (value != null && pattern != null) { Regex regex = LikeFunctions.likePattern(utf8Slice(pattern), utf8Slice("\\")); expected = LikeFunctions.likeVarchar(utf8Slice(value), regex); } assertExecute(generateExpression("%s like %s", value, pattern), BOOLEAN, expected); } } Futures.allAsList(futures).get(); }
@Test public void testLikeSpacesInPattern() { Regex regex = likePattern(utf8Slice("ala ")); assertTrue(likeVarchar(utf8Slice("ala "), regex)); assertFalse(likeVarchar(utf8Slice("ala"), regex)); regex = castCharToLikePattern(5L, utf8Slice("ala")); assertTrue(likeVarchar(utf8Slice("ala "), regex)); assertFalse(likeVarchar(utf8Slice("ala"), regex)); }
@Test public void testLikeChar() { Regex regex = likePattern(utf8Slice("f%b__")); assertTrue(likeChar(6L, utf8Slice("foobar"), regex)); assertTrue(likeChar(6L, utf8Slice("foob"), regex)); assertFalse(likeChar(7L, utf8Slice("foob"), regex)); assertFunction("cast('foob' as char(6)) LIKE 'f%b__'", BOOLEAN, true); assertFunction("cast('foob' as char(7)) LIKE 'f%b__'", BOOLEAN, false); }
Regex regex; if (escape == null) { regex = LikeFunctions.likePattern((Slice) pattern); regex = LikeFunctions.likePattern((Slice) pattern, (Slice) escape);
@SuppressWarnings("NumericCastThatLosesPrecision") @Test(timeOut = 1000) public void testLikeInvalidUtf8Value() { Slice value = Slices.wrappedBuffer(new byte[] {'a', 'b', 'c', (byte) 0xFF, 'x', 'y'}); Regex regex = likePattern(utf8Slice("%b%"), utf8Slice("\\")); assertTrue(like(value, regex)); }