public Predicate convert(List<ScalarOperator> operators, DeltaLakeContext context) {
        DeltaLakeExprVisitor visitor = new DeltaLakeExprVisitor();
        List<Predicate> predicates = Lists.newArrayList();

        for (ScalarOperator operator : operators) {
            Predicate predicate = operator.accept(visitor, context);
            if (predicate != null) {
                predicates.add(predicate);
            }
        }

        Optional<Predicate> result = predicates.stream().reduce(And::new);
        return result.orElse(ALWAYS_TRUE);
    }
@Test
    public void testConvertCastLitervalValue() {
        ScalarOperationToDeltaLakeExpr converter = new ScalarOperationToDeltaLakeExpr();
        ScalarOperationToDeltaLakeExpr.DeltaLakeContext context =
                new ScalarOperationToDeltaLakeExpr.DeltaLakeContext(schema, new HashSet<>());
        List<ScalarOperator> operators;
        ConstantOperator value;
        ScalarOperator operator;

        // int -> boolean
        value = ConstantOperator.createInt(0);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cBoolCol, value);
        operators = new ArrayList<>(List.of(operator));
        Predicate convertExpr = converter.convert(operators, context);
        Predicate expectedExpr = new Predicate("=", cDeltaBoolCol, Literal.ofBoolean(false));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // int -> smallint
        value = ConstantOperator.createInt(5);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cShortCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaShortCol, Literal.ofShort((short) 5));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // bigint -> int
        value = ConstantOperator.createBigint(5);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cIntCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaIntCol, Literal.ofLong(5));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // int -> bigint
        value = ConstantOperator.createInt(5);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cLongCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaLongCol, Literal.ofInt(5));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // string -> date
        value = ConstantOperator.createVarchar("2023-01-05");
        operator = new BinaryPredicateOperator(BinaryType.EQ, cDateCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaDateCol, Literal.ofDate(19362));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // string -> datetime
        value = ConstantOperator.createVarchar("2023-01-05 01:01:01");
        operator = new BinaryPredicateOperator(BinaryType.EQ, cTimestampCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaTimestampCol, Literal.ofTimestamp(1672851661000000L));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // date -> string
        value = ConstantOperator.createDate(LocalDateTime.of(2023, 1, 5, 0, 0));
        operator = new BinaryPredicateOperator(BinaryType.EQ, cVarcharCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaVarcharCol, Literal.ofString("2023-01-05"));
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // int -> string (not supported)
        value = ConstantOperator.createInt(12345);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cVarcharCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = AlwaysTrue.ALWAYS_TRUE;
        Assert.assertEquals(expectedExpr.toString(), convertExpr.toString());

        // not supported
        value = ConstantOperator.createInt(12345);
        operator = new BinaryPredicateOperator(BinaryType.EQ, cDoubleCol, value);
        operators = new ArrayList<>(List.of(operator));
        convertExpr = converter.convert(operators, context);
        Assert.assertEquals(AlwaysTrue.ALWAYS_TRUE.toString(), convertExpr.toString());
    }