sync mv don't support unnest

Author: starocean999

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/CreateMaterializedViewCommand.java

@@ -67,6 +67,7 @@
 import org.apache.doris.nereids.trees.expressions.functions.agg.Min;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Sum;
 import org.apache.doris.nereids.trees.expressions.functions.combinator.StateCombinator;
+import org.apache.doris.nereids.trees.expressions.functions.generator.Unnest;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToBitmap;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToBitmapWithCheck;
 import org.apache.doris.nereids.trees.expressions.literal.BigIntLiteral;
@@ -299,7 +300,7 @@ public Plan visitLogicalFilter(LogicalFilter<? extends Plan> filter, ValidateCon
                 throw new AnalysisException(
                         String.format("Only support one filter node, the second is %s", filter.getPredicate()));
             }
-            checkNoNondeterministicFunction(filter);
+            checkNoNondeterministicFunctionOrUnnest(filter);
             Set<Expression> conjuncts = filter.getConjuncts().stream().filter(expr -> {
                 Set<Slot> slots = expr.getInputSlots();
                 for (Slot slot : slots) {
@@ -343,7 +344,7 @@ public Plan visitLogicalAggregate(LogicalAggregate<? extends Plan> aggregate, Va
                 throw new AnalysisException(String.format("Only support one agg node, the second is %s", aggregate));
             }
             context.keysType = KeysType.AGG_KEYS;
-            checkNoNondeterministicFunction(aggregate);
+            checkNoNondeterministicFunctionOrUnnest(aggregate);
             for (AggregateFunction aggregateFunction : aggregate.getAggregateFunctions()) {
                 validateAggFunnction(aggregateFunction);
             }
@@ -369,7 +370,7 @@ public Plan visitLogicalSort(LogicalSort<? extends Plan> sort, ValidateContext c
             if (context.orderByExprs != null) {
                 throw new AnalysisException(String.format("Only support one sort node, the second is %s", sort));
             }
-            checkNoNondeterministicFunction(sort);
+            checkNoNondeterministicFunctionOrUnnest(sort);
             if (sort.getOrderKeys().stream().anyMatch((
                     orderKey -> orderKey.getExpr().getDataType().isObjectOrVariantType()))) {
                 throw new AnalysisException(Type.OnlyMetricTypeErrorMsg);
@@ -390,7 +391,7 @@ public Plan visitLogicalSort(LogicalSort<? extends Plan> sort, ValidateContext c
         @Override
         public Plan visitLogicalProject(LogicalProject<? extends Plan> project, ValidateContext context) {
             super.visit(project, context);
-            checkNoNondeterministicFunction(project);
+            checkNoNondeterministicFunctionOrUnnest(project);
             List<NamedExpression> outputs = project.getOutputs();
             if (!context.exprReplaceMap.isEmpty()) {
                 outputs = ExpressionUtils.replaceNamedExpressions(outputs, context.exprReplaceMap);
@@ -642,14 +643,15 @@ private Expression getAggFunctionFirstParam(AggregateFunction aggregateFunction)
             return aggregateFunction.child(0);
         }
 
-        private void checkNoNondeterministicFunction(Plan plan) {
+        private void checkNoNondeterministicFunctionOrUnnest(Plan plan) {
             for (Expression expression : plan.getExpressions()) {
-                Set<Expression> nondeterministicFunctions = expression
-                        .collect(expr -> !((ExpressionTrait) expr).isDeterministic()
-                                && expr instanceof FunctionTrait);
-                if (!nondeterministicFunctions.isEmpty()) {
+                Set<Expression> unsupportedFunctions = expression
+                        .collect(expr -> expr instanceof Unnest || (!((ExpressionTrait) expr).isDeterministic()
+                                && expr instanceof FunctionTrait));
+                if (!unsupportedFunctions.isEmpty()) {
                     throw new AnalysisException(String.format(
-                            "can not contain nonDeterministic expression, the expression is %s ", expression));
+                            "can not contain nonDeterministic expression or unnest, the expression is %s ",
+                            expression));
                 }
             }
         }