class AnyOperator extends Operator<Object>
    permits AnyEqOperator, AnyNeqOperator, AnyRangeOperator, AnyLikeOperator, AnyNotLikeOperator {

    public static final String OPERATOR_PREFIX = "any_";
    public static final List<String> OPERATOR_NAMES = List.of(
        AnyEqOperator.NAME,
        AnyNeqOperator.NAME,
        AnyRangeOperator.Comparison.GT.opName(),
        AnyRangeOperator.Comparison.GTE.opName(),
        AnyRangeOperator.Comparison.LT.opName(),
        AnyRangeOperator.Comparison.LTE.opName(),
        LikeOperators.ANY_LIKE,
        LikeOperators.ANY_ILIKE,
        LikeOperators.ANY_NOT_LIKE,
        LikeOperators.ANY_NOT_ILIKE
    );

    public static final Set<String> SUPPORTED_COMPARISONS = Set.of(
        ComparisonExpression.Type.EQUAL.getValue(),
        ComparisonExpression.Type.NOT_EQUAL.getValue(),
        ComparisonExpression.Type.LESS_THAN.getValue(),
        ComparisonExpression.Type.LESS_THAN_OR_EQUAL.getValue(),
        ComparisonExpression.Type.GREATER_THAN.getValue(),
        ComparisonExpression.Type.GREATER_THAN_OR_EQUAL.getValue()
    );

    protected final DataType<Object> leftType;

    public static void register(Functions.Builder builder) {
        reg(builder, AnyEqOperator.NAME, (sig, boundSig) -> new AnyEqOperator(sig, boundSig));
        reg(builder, AnyNeqOperator.NAME, (sig, boundSig) -> new AnyNeqOperator(sig, boundSig));
        regRange(builder, AnyRangeOperator.Comparison.GT);
        regRange(builder, AnyRangeOperator.Comparison.GTE);
        regRange(builder, AnyRangeOperator.Comparison.LT);
        regRange(builder, AnyRangeOperator.Comparison.LTE);
    }

    private static void regRange(Functions.Builder builder, Comparison comparison) {
        reg(builder, comparison.opName(), (sig, boundSig) -> new AnyRangeOperator(sig, boundSig, comparison));
    }

    private static void reg(Functions.Builder builder, String name, FunctionFactory operatorFactory) {
        builder.add(
            Signature.scalar(
                name,
                TypeSignature.parse("E"),
                TypeSignature.parse("array(E)"),
                Operator.RETURN_TYPE.getTypeSignature()
            ).withTypeVariableConstraints(TypeVariableConstraint.typeVariable("E")),
            operatorFactory
        );
    }

    @SuppressWarnings("unchecked")
    AnyOperator(Signature signature, BoundSignature boundSignature) {
        super(signature, boundSignature);
        this.leftType = (DataType<Object>) boundSignature.argTypes().get(0);
    }

    abstract boolean matches(Object probe, Object candidate);

    protected abstract Query refMatchesAnyArrayLiteral(Function any, Reference probe, Literal<?> candidates, Context context);

    protected abstract Query literalMatchesAnyArrayRef(Function any, Literal<?> probe, Reference candidates, Context context);

    @Override
    @SafeVarargs
    public final Boolean evaluate(TransactionContext txnCtx, NodeContext nodeCtx, Input<Object> ... args) {<FILL_FUNCTION_BODY>}

    @Override
    public Query toQuery(Function function, Context context) {
        List<Symbol> args = function.arguments();
        Symbol probe = args.get(0);
        Symbol candidates = args.get(1);
        while (candidates instanceof Function fn && fn.signature().equals(ArrayUnnestFunction.SIGNATURE)) {
            candidates = fn.arguments().get(0);
        }
        if (probe instanceof Literal<?> literal && candidates instanceof Reference ref) {
            return literalMatchesAnyArrayRef(function, literal, ref, context);
        } else if (probe instanceof Reference ref && candidates instanceof Literal<?> literal) {
            return refMatchesAnyArrayLiteral(function, ref, literal, context);
        } else {
            return null;
        }
    }
}

        assert args != null : "args must not be null";
        assert args.length == 2 : "number of args must be 2";
        assert args[0] != null : "1st argument must not be null";

        Object item = args[0].value();
        Object items = args[1].value();
        if (items == null || item == null) {
            return null;
        }
        boolean anyNulls = false;
        for (Object rightValue : (Iterable<?>) items) {
            if (rightValue == null) {
                anyNulls = true;
                continue;
            }
            if (matches(item, rightValue)) {
                return true;
            }
        }
        return anyNulls ? null : false;
    
<methods>public io.crate.expression.symbol.Symbol normalizeSymbol(io.crate.expression.symbol.Function, io.crate.metadata.TransactionContext, io.crate.metadata.NodeContext) <variables>public static final java.lang.String PREFIX,public static final io.crate.types.BooleanType RETURN_TYPE