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 testConvertBinaryPredicate() {
        ScalarOperationToDeltaLakeExpr converter = new ScalarOperationToDeltaLakeExpr();
        Literal literal = Literal.ofInt(5);
        ScalarOperationToDeltaLakeExpr.DeltaLakeContext context =
                new ScalarOperationToDeltaLakeExpr.DeltaLakeContext(schema, new HashSet<>());
        List<ScalarOperator> operators;

        // <
        ConstantOperator value = ConstantOperator.createInt(5);
        ScalarOperator ltOperator = new BinaryPredicateOperator(BinaryType.LT, cIntCol, value);
        operators = new ArrayList<>(List.of(ltOperator));
        Predicate convertExpr = converter.convert(operators, context);
        Predicate expectedExpr = new Predicate("<", cDeltaIntCol, literal);
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());

        // <=
        ScalarOperator leOperator = new BinaryPredicateOperator(BinaryType.LE, cIntCol, value);
        operators = new ArrayList<>(List.of(leOperator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("<=", cDeltaIntCol, literal);
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());

        // >
        ScalarOperator gtOperator = new BinaryPredicateOperator(BinaryType.GT, cIntCol, value);
        operators = new ArrayList<>(List.of(gtOperator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate(">", cDeltaIntCol, literal);
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());

        // >=
        ScalarOperator geOperator = new BinaryPredicateOperator(BinaryType.GE, cIntCol, value);
        operators = new ArrayList<>(List.of(geOperator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate(">=", cDeltaIntCol, literal);
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());

        // ==
        ScalarOperator eqOperator = new BinaryPredicateOperator(BinaryType.EQ, cIntCol, value);
        operators = new ArrayList<>(List.of(eqOperator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("=", cDeltaIntCol, literal);
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());

        // !=
        ScalarOperator neOperator = new BinaryPredicateOperator(BinaryType.NE, cIntCol, value);
        operators = new ArrayList<>(List.of(neOperator));
        convertExpr = converter.convert(operators, context);
        expectedExpr = new Predicate("NOT", new Predicate("=", cDeltaIntCol, literal));
        Assert.assertEquals(convertExpr.toString(), expectedExpr.toString());
    }