Add like_regex predicate to JSON path

core/trino-main/src/main/java/io/trino/json/PathPredicateEvaluationVisitor.java

@@ -25,12 +25,14 @@
 import io.trino.json.ir.IrExistsPredicate;
 import io.trino.json.ir.IrIsUnknownPredicate;
 import io.trino.json.ir.IrJsonPathVisitor;
+import io.trino.json.ir.IrLikeRegexPredicate;
 import io.trino.json.ir.IrNegationPredicate;
 import io.trino.json.ir.IrPathNode;
 import io.trino.json.ir.IrPredicate;
 import io.trino.json.ir.IrStartsWithPredicate;
 import io.trino.json.ir.JsonLiteralConversionException;
 import io.trino.json.ir.TypedValue;
+import io.trino.json.regex.XQuerySqlRegex;
 import io.trino.operator.scalar.StringFunctions;
 import io.trino.spi.function.OperatorType;
 import io.trino.spi.type.CharType;
@@ -381,6 +383,42 @@ protected Boolean visitIrIsUnknownPredicate(IrIsUnknownPredicate node, PathEvalu
         return predicateResult == null;
     }
 
+    @Override
+    protected Boolean visitIrLikeRegexPredicate(IrLikeRegexPredicate node, PathEvaluationContext context)
+    {
+        List<Object> valueSequence;
+        try {
+            valueSequence = pathVisitor.process(node.value(), context);
+        }
+        catch (PathEvaluationException e) {
+            return null;
+        }
+
+        if (lax) {
+            valueSequence = unwrapArrays(valueSequence);
+        }
+        if (valueSequence.isEmpty()) {
+            return FALSE;
+        }
+
+        XQuerySqlRegex regex = node.regex();
+        boolean found = false;
+        for (Object object : valueSequence) {
+            Slice value = getText(object);
+            if (value == null) {
+                return null;
+            }
+            if (regex.match(value)) {
+                found = true;
+                if (lax) {
+                    return TRUE;
+                }
+            }
+        }
+
+        return found;
+    }
+
     @Override
     protected Boolean visitIrNegationPredicate(IrNegationPredicate node, PathEvaluationContext context)
     {

core/trino-main/src/main/java/io/trino/json/ir/IrJsonPathVisitor.java

@@ -132,6 +132,11 @@ protected R visitIrLastIndexVariable(IrLastIndexVariable node, C context)
         return visitIrPathNode(node, context);
     }
 
+    protected R visitIrLikeRegexPredicate(IrLikeRegexPredicate node, C context)
+    {
+        return visitIrPredicate(node, context);
+    }
+
     protected R visitIrLiteral(IrLiteral node, C context)
     {
         return visitIrPathNode(node, context);

core/trino-main/src/main/java/io/trino/json/ir/IrLikeRegexPredicate.java

@@ -0,0 +1,69 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.ir;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.errorprone.annotations.DoNotCall;
+import io.trino.json.regex.XQuerySqlRegex;
+
+import java.util.Optional;
+
+import static java.util.Objects.requireNonNull;
+
+public record IrLikeRegexPredicate(IrPathNode value, @JsonIgnore XQuerySqlRegex regex)
+        implements IrPredicate
+{
+    public IrLikeRegexPredicate
+    {
+        requireNonNull(value, "value is null");
+        requireNonNull(regex, "regex is null");
+    }
+
+    @JsonCreator
+    @DoNotCall
+    public static IrLikeRegexPredicate fromJson(
+            @JsonProperty("value") IrPathNode value,
+            @JsonProperty("pattern") String pattern,
+            @JsonProperty("flags") Optional<String> flags)
+    {
+        XQuerySqlRegex regex = XQuerySqlRegex.compile(pattern, flags);
+        return new IrLikeRegexPredicate(value, regex);
+    }
+
+    @Override
+    public <R, C> R accept(IrJsonPathVisitor<R, C> visitor, C context)
+    {
+        return visitor.visitIrLikeRegexPredicate(this, context);
+    }
+
+    @JsonProperty
+    public IrPathNode getValue()
+    {
+        return value;
+    }
+
+    @JsonProperty
+    public String getPattern()
+    {
+        return regex.getPattern();
+    }
+
+    @JsonProperty
+    public Optional<String> getFlags()
+    {
+        return regex.getFlags();
+    }
+}

core/trino-main/src/main/java/io/trino/json/ir/IrPathNode.java

@@ -43,6 +43,7 @@
         @JsonSubTypes.Type(value = IrJsonNull.class, name = "jsonnull"),
         @JsonSubTypes.Type(value = IrKeyValueMethod.class, name = "keyvalue"),
         @JsonSubTypes.Type(value = IrLastIndexVariable.class, name = "last"),
+        @JsonSubTypes.Type(value = IrLikeRegexPredicate.class, name = "likeregex"),
         @JsonSubTypes.Type(value = IrLiteral.class, name = "literal"),
         @JsonSubTypes.Type(value = IrMemberAccessor.class, name = "memberaccessor"),
         @JsonSubTypes.Type(value = IrNamedJsonVariable.class, name = "namedjsonvariable"),

core/trino-main/src/main/java/io/trino/json/ir/IrPredicate.java

@@ -21,7 +21,15 @@
 
 public sealed interface IrPredicate
         extends IrPathNode
-        permits IrComparisonPredicate, IrConjunctionPredicate, IrDisjunctionPredicate, IrExistsPredicate, IrIsUnknownPredicate, IrNegationPredicate, IrStartsWithPredicate
+        permits
+        IrComparisonPredicate,
+        IrConjunctionPredicate,
+        IrDisjunctionPredicate,
+        IrExistsPredicate,
+        IrIsUnknownPredicate,
+        IrLikeRegexPredicate,
+        IrNegationPredicate,
+        IrStartsWithPredicate
 {
     @Override
     default <R, C> R accept(IrJsonPathVisitor<R, C> visitor, C context)

core/trino-main/src/main/java/io/trino/json/regex/Atom.java

@@ -0,0 +1,28 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+sealed interface Atom
+        extends RegexNode
+        permits
+        BackReference,
+        CharacterClassEscape,
+        CharacterClassExpression,
+        EndMetaCharacter,
+        NormalCharacter,
+        StartMetaCharacter,
+        SubExpression,
+        WildcardEscape
+{
+}

core/trino-main/src/main/java/io/trino/json/regex/BackReference.java

@@ -0,0 +1,31 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+record BackReference(int subExpressionIndex)
+        implements Atom
+{
+    public BackReference
+    {
+        checkArgument(subExpressionIndex >= 1, "subExpressionIndex must be >= 1");
+    }
+
+    @Override
+    public <R> R accept(RegexTreeVisitor<R> visitor)
+    {
+        return visitor.visitBackReference(this);
+    }
+}

core/trino-main/src/main/java/io/trino/json/regex/Branch.java

@@ -0,0 +1,35 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+import static java.util.Objects.requireNonNull;
+
+record Branch(List<Piece> pieces)
+        implements RegexNode
+{
+    public Branch
+    {
+        pieces = ImmutableList.copyOf(requireNonNull(pieces, "pieces is null"));
+    }
+
+    @Override
+    public <R> R accept(RegexTreeVisitor<R> visitor)
+    {
+        return visitor.visitBranch(this);
+    }
+}

core/trino-main/src/main/java/io/trino/json/regex/CategoryEscape.java

@@ -0,0 +1,31 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+import static java.util.Objects.requireNonNull;
+
+record CategoryEscape(String characterProperty, boolean complement)
+        implements CharacterClassEscape
+{
+    public CategoryEscape
+    {
+        requireNonNull(characterProperty, "characterProperty is null");
+    }
+
+    @Override
+    public <R> R accept(RegexTreeVisitor<R> visitor)
+    {
+        return visitor.visitCategoryEscape(this);
+    }
+}

core/trino-main/src/main/java/io/trino/json/regex/CharacterClassEscape.java

@@ -0,0 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+sealed interface CharacterClassEscape
+        extends Atom, CharacterGroupElement
+        permits CategoryEscape, MultiCharacterEscape, SingleCharacterEscape
+{
+}

core/trino-main/src/main/java/io/trino/json/regex/CharacterClassExpression.java

@@ -0,0 +1,37 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+import java.util.Optional;
+
+import static java.util.Objects.requireNonNull;
+
+record CharacterClassExpression(boolean negative, List<CharacterGroupElement> elements, Optional<CharacterClassExpression> subtrahend)
+        implements Atom
+{
+    public CharacterClassExpression
+    {
+        elements = ImmutableList.copyOf(requireNonNull(elements, "elements is null"));
+        requireNonNull(subtrahend, "subtrahend is null");
+    }
+
+    @Override
+    public <R> R accept(RegexTreeVisitor<R> visitor)
+    {
+        return visitor.visitCharacterClassExpression(this);
+    }
+}

core/trino-main/src/main/java/io/trino/json/regex/CharacterGroupElement.java

@@ -0,0 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.json.regex;
+
+sealed interface CharacterGroupElement
+        extends RegexNode
+        permits CharacterClassEscape, CharacterRange, NormalCharacter
+{
+}