refactor useLogicalView

diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java
index 42e25cc..58b33df 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java

@@ -236,7 +236,8 @@
   // Logical View Analysis
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean hasViewsInQuery = false;
+  private boolean useLogicalView = false;
+
   private List<Pair<Expression, String>> outputExpressions = null;
 
   /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -691,12 +692,12 @@
   // Logical View Analysis
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public void setHasViewsInQuery(boolean hasViewsInQuery) {
-    this.hasViewsInQuery = this.hasViewsInQuery || hasViewsInQuery;
+  public void setUseLogicalView(boolean useLogicalView) {
+    this.useLogicalView = useLogicalView;
   }
 
-  public boolean hasViewsInQuery() {
-    return this.hasViewsInQuery;
+  public boolean useLogicalView() {
+    return this.useLogicalView;
   }
 
   public void setOutputExpressions(List<Pair<Expression, String>> outputExpressions) {

diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java
index d720f04..ec31b5d 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java

@@ -267,7 +267,7 @@
       }
 
       // make sure paths in logical view is fetched
-      updateSchemaTreeByViews(schemaTree);
+      updateSchemaTreeByViews(analysis, schemaTree);
 
       // extract global time filter from query filter and determine if there is a value filter
       analyzeGlobalTimeFilter(analysis, queryStatement);
@@ -446,23 +446,25 @@
 
     for (Expression selectExpression : selectExpressions) {
       sourceExpressions.addAll(
-          ExpressionAnalyzer.bindSchemaForExpression(selectExpression, analysis, schemaTree));
+          ExpressionAnalyzer.bindSchemaForExpression(selectExpression, schemaTree));
     }
     analysis.setSourceExpressions(sourceExpressions);
   }
 
-  private void updateSchemaTreeByViews(ISchemaTree originSchemaTree) {
+  private void updateSchemaTreeByViews(Analysis analysis, ISchemaTree originSchemaTree) {
     if (!originSchemaTree.hasLogicalViewMeasurement()) {
       return;
     }
 
     PathPatternTree patternTree = new PathPatternTree();
     boolean needToReFetch = false;
+    boolean useLogicalView = false;
     try {
       Pair<List<MeasurementPath>, Integer> tempPair =
           originSchemaTree.searchMeasurementPaths(new PartialPath("root.**"));
       for (MeasurementPath measurementPath : tempPair.left) {
         if (measurementPath.getMeasurementSchema().isLogicalView()) {
+          useLogicalView = true;
           LogicalViewSchema logicalViewSchema =
               (LogicalViewSchema) measurementPath.getMeasurementSchema();
           ViewExpression viewExpression = logicalViewSchema.getExpression();
@@ -483,6 +485,7 @@
       allDatabases.addAll(originSchemaTree.getDatabases());
       originSchemaTree.setDatabases(allDatabases);
     }
+    analysis.setUseLogicalView(useLogicalView);
   }
 
   private Map<Integer, List<Pair<Expression, String>>> analyzeSelect(
@@ -505,8 +508,7 @@
 
       boolean hasAlias = resultColumn.hasAlias();
       List<Expression> resultExpressions =
-          ExpressionAnalyzer.bindSchemaForExpression(
-              resultColumn.getExpression(), analysis, schemaTree);
+          ExpressionAnalyzer.bindSchemaForExpression(resultColumn.getExpression(), schemaTree);
 
       for (Expression expression : resultExpressions) {
         if (paginationController.hasCurOffset()) {
@@ -1298,7 +1300,7 @@
     for (Expression expressionForItem : queryStatement.getExpressionSortItemList()) {
       // Expression in a sortItem only indicates one column
       List<Expression> expressions =
-          ExpressionAnalyzer.bindSchemaForExpression(expressionForItem, analysis, schemaTree);
+          ExpressionAnalyzer.bindSchemaForExpression(expressionForItem, schemaTree);
       if (expressions.size() != 1) {
         throw new SemanticException("One sort item in order by should only indicate one value");
       }
@@ -1454,7 +1456,7 @@
       groupByExpression = groupByComponent.getControlColumnExpression();
       // Expression in group by variation clause only indicates one column
       List<Expression> expressions =
-          ExpressionAnalyzer.bindSchemaForExpression(groupByExpression, analysis, schemaTree);
+          ExpressionAnalyzer.bindSchemaForExpression(groupByExpression, schemaTree);
       if (expressions.size() != 1) {
         throw new SemanticException("Expression in group by should indicate one value");
       }
@@ -3214,7 +3216,7 @@
               "Columns in the query statement is empty. Please check your SQL."));
       return new Pair<>(null, analysis);
     }
-    if (queryAnalysis.hasViewsInQuery()) {
+    if (queryAnalysis.useLogicalView()) {
       analysis.setFinishQueryAfterAnalyze(true);
       analysis.setFailStatus(
           RpcUtils.getStatus(
@@ -3229,7 +3231,7 @@
     return new Pair<>(expressionList, analysis);
   }
 
-  private Analysis checkViewsInSource(
+  private void checkViewsInSource(
       Analysis analysis, List<Expression> sourceExpressionList, MPPQueryContext context) {
     List<PartialPath> pathsNeedCheck = new ArrayList<>();
     for (Expression expression : sourceExpressionList) {
@@ -3246,7 +3248,7 @@
           RpcUtils.getStatus(
               TSStatusCode.UNSUPPORTED_OPERATION.getStatusCode(),
               "Can not create a logical view based on non-exist time series."));
-      return analysis;
+      return;
     }
     Pair<List<PartialPath>, PartialPath> viewInSourceCheckResult =
         findAllViewsInPaths(pathsNeedCheck, schemaOfNeedToCheck.left);
@@ -3259,7 +3261,7 @@
               "Path "
                   + viewInSourceCheckResult.right.toString()
                   + " does not exist! You can not create a logical view based on non-exist time series."));
-      return analysis;
+      return;
     }
     if (viewInSourceCheckResult.left.size() > 0) {
       // some source paths is logical view
@@ -3268,9 +3270,7 @@
           RpcUtils.getStatus(
               TSStatusCode.UNSUPPORTED_OPERATION.getStatusCode(),
               "Can not create a logical view based on existing views."));
-      return analysis;
     }
-    return analysis;
   }
 
   private Analysis checkPathsInCreateLogicalView(

diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java
index 06025ab..f283eb7 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java

@@ -411,14 +411,8 @@
    *     expressions
    */
   public static List<Expression> bindSchemaForExpression(
-      Expression expression, Analysis analysis, ISchemaTree schemaTree) {
-    BindSchemaForExpressionVisitor bindSchemaForExpressionVisitor =
-        new BindSchemaForExpressionVisitor();
-    BindSchemaForExpressionVisitor.Context context =
-        new BindSchemaForExpressionVisitor.Context(schemaTree);
-    List<Expression> expressions = bindSchemaForExpressionVisitor.process(expression, context);
-    analysis.setHasViewsInQuery(context.isHasProcessedLogicalView());
-    return expressions;
+      Expression expression, ISchemaTree schemaTree) {
+    return new BindSchemaForExpressionVisitor().process(expression, schemaTree);
   }
 
   /**

diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/cartesian/BindSchemaForExpressionVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/cartesian/BindSchemaForExpressionVisitor.java
index 19de729..5cce6f3 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/cartesian/BindSchemaForExpressionVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/cartesian/BindSchemaForExpressionVisitor.java

@@ -42,18 +42,17 @@
 import static org.apache.iotdb.db.mpp.plan.analyze.ExpressionUtils.reconstructFunctionExpressions;
 import static org.apache.iotdb.db.utils.TypeInferenceUtils.bindTypeForAggregationNonSeriesInputExpressions;
 
-public class BindSchemaForExpressionVisitor
-    extends CartesianProductVisitor<BindSchemaForExpressionVisitor.Context> {
+public class BindSchemaForExpressionVisitor extends CartesianProductVisitor<ISchemaTree> {
 
   @Override
   public List<Expression> visitFunctionExpression(
-      FunctionExpression functionExpression, Context context) {
+      FunctionExpression functionExpression, ISchemaTree schemaTree) {
     // One by one, remove the wildcards from the input expressions. In most cases, an expression
     // will produce multiple expressions after removing the wildcards. We use extendedExpressions
     // to collect the produced expressions.
     List<List<Expression>> extendedExpressions = new ArrayList<>();
     for (Expression originExpression : functionExpression.getExpressions()) {
-      List<Expression> actualExpressions = process(originExpression, context);
+      List<Expression> actualExpressions = process(originExpression, schemaTree);
       if (actualExpressions.isEmpty()) {
         // Let's ignore the eval of the function which has at least one non-existence series as
         // input. See IOTDB-1212: https://github.com/apache/iotdb/pull/3101
@@ -83,16 +82,15 @@
 
   @Override
   public List<Expression> visitTimeSeriesOperand(
-      TimeSeriesOperand timeSeriesOperand, Context context) {
+      TimeSeriesOperand timeSeriesOperand, ISchemaTree schemaTree) {
     PartialPath timeSeriesOperandPath = timeSeriesOperand.getPath();
     List<MeasurementPath> actualPaths =
-        context.getSchemaTree().searchMeasurementPaths(timeSeriesOperandPath).left;
+        schemaTree.searchMeasurementPaths(timeSeriesOperandPath).left;
     // process logical view
     List<MeasurementPath> nonViewActualPaths = new ArrayList<>();
     List<MeasurementPath> viewPaths = new ArrayList<>();
     for (MeasurementPath measurementPath : actualPaths) {
       if (measurementPath.getMeasurementSchema().isLogicalView()) {
-        context.setHasProcessedLogicalView();
         viewPaths.add(measurementPath);
       } else {
         nonViewActualPaths.add(measurementPath);
@@ -102,7 +100,7 @@
         ExpressionUtils.reconstructTimeSeriesOperands(nonViewActualPaths);
     // handle logical views
     for (MeasurementPath measurementPath : viewPaths) {
-      Expression replacedExpression = transformViewPath(measurementPath, context.getSchemaTree());
+      Expression replacedExpression = transformViewPath(measurementPath, schemaTree);
       replacedExpression.setViewPath(measurementPath);
       reconstructTimeSeriesOperands.add(replacedExpression);
     }
@@ -111,12 +109,13 @@
 
   @Override
   public List<Expression> visitTimeStampOperand(
-      TimestampOperand timestampOperand, Context context) {
+      TimestampOperand timestampOperand, ISchemaTree schemaTree) {
     return Collections.singletonList(timestampOperand);
   }
 
   @Override
-  public List<Expression> visitConstantOperand(ConstantOperand constantOperand, Context context) {
+  public List<Expression> visitConstantOperand(
+      ConstantOperand constantOperand, ISchemaTree schemaTree) {
     return Collections.singletonList(constantOperand);
   }
 
@@ -135,25 +134,4 @@
               "Can not construct expression using non view path in transformViewPath!"));
     }
   }
-
-  public static class Context {
-    private final ISchemaTree schemaTree;
-    private boolean isHasProcessedLogicalView = false;
-
-    public Context(ISchemaTree schemaTree) {
-      this.schemaTree = schemaTree;
-    }
-
-    public ISchemaTree getSchemaTree() {
-      return schemaTree;
-    }
-
-    public boolean isHasProcessedLogicalView() {
-      return isHasProcessedLogicalView;
-    }
-
-    public void setHasProcessedLogicalView() {
-      isHasProcessedLogicalView = true;
-    }
-  }
 }