diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
new file mode 100644
index 000000000000..5ec4566c54ce
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceWithTemplateAggregationIT.java
@@ -0,0 +1,542 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.iotdb.db.it.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.ClusterIT;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.assertTestFail;
+import static org.apache.iotdb.db.it.utils.TestUtils.resultSetEqualTest;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class, ClusterIT.class})
+public class IoTDBAlignByDeviceWithTemplateAggregationIT {
+  private static final String[] sqls =
+      new String[] {
+        // non-aligned template
+        "CREATE database root.sg1;",
+        "CREATE schema template t1 (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+        "SET SCHEMA TEMPLATE t1 to root.sg1;",
+        "INSERT INTO root.sg1.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2), (5,5.5,true,5), (1314000000000,13.14,true,1314);",
+        "INSERT INTO root.sg1.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22), (5,50.0,false,5), (1314000000001,13.15,false,1315);",
+        "flush;",
+        "INSERT INTO root.sg1.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44), (8,8.8,false,4), (1314000000002,13.16,false,1316);",
+        "INSERT INTO root.sg1.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555), (8,0.8,true,10), (1314000000003,13.14,true,1314);",
+
+        // aligned template
+        "CREATE database root.sg2;",
+        "CREATE schema template t2 aligned (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+        "SET SCHEMA TEMPLATE t2 to root.sg2;",
+        "INSERT INTO root.sg2.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2), (5,5.5,true,5), (1314000000000,13.14,true,1314);",
+        "INSERT INTO root.sg2.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22), (5,50.0,false,5), (1314000000001,13.15,false,1315);",
+        "flush;",
+        "INSERT INTO root.sg2.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44), (8,8.8,false,4), (1314000000002,13.16,false,1316);",
+        "INSERT INTO root.sg2.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555), (8,0.8,true,10), (1314000000003,13.14,true,1314);",
+      };
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    EnvFactory.getEnv().initClusterEnvironment();
+    insertData();
+  }
+
+  @AfterClass
+  public static void tearDown() throws Exception {
+    EnvFactory.getEnv().cleanClusterEnvironment();
+  }
+
+  @Test
+  public void aggregationTest() {
+    // only descending test
+    // no value filter
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d1,1314000000000,13.14,true,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,1314000000003,13.14,true,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "root.sg2.d1,1314000000000,13.14,true,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,1314000000003,13.14,true,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** align by device;",
+        expectedHeader,
+        retArray);
+
+    // __endTime result is ambiguous
+
+    // not supported: group by session, condition, agg(*), agg(s1+1), count(s1+s2), non-aligned
+    // template
+  }
+
+  @Test
+  public void filterTest() {
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    // supported: ascending with descending aggregation descriptors
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),count(s2),first_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,4,11,",
+          "root.sg1.d3,1314000000002,13.16,2,4,",
+          "root.sg1.d4,5,5555.5,1,5555,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,4,11,",
+          "root.sg2.d3,1314000000002,13.16,2,4,",
+          "root.sg2.d4,5,5555.5,1,5555,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    // duplicate select expressions
+    expectedHeader =
+        new String[] {
+          "Device,max_time(s1),last_value(s1),count(s2),first_value(s3),last_value(s1)"
+        };
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,13.15,4,11,13.15,",
+          "root.sg1.d3,1314000000002,13.16,2,4,13.16,",
+          "root.sg1.d4,5,5555.5,1,5555,5555.5,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3), last_value(s1) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,4,11,13.15,",
+          "root.sg2.d3,1314000000002,13.16,2,4,13.16,",
+          "root.sg2.d4,5,5555.5,1,5555,5555.5,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3), last_value(s1) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    // alias
+    expectedHeader = new String[] {"Device,c1,first_value(s3),c2"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,4,11,4,", "root.sg1.d3,2,4,2,", "root.sg1.d4,1,5555,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count(s1) as c1, first_value(s3), count(s1) as c2 FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,4,11,4,", "root.sg2.d3,2,4,2,", "root.sg2.d4,1,5555,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count(s1) as c1, first_value(s3), count(s1) as c2 FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)>2 align by device;",
+        expectedHeader,
+        retArray);
+
+    // arithmetic expression
+    expectedHeader =
+        new String[] {"Device,max_time(s1),count(s1),last_value(s2),count(s1) + last_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d2,1314000000001,4,false,1319.0,",
+          "root.sg1.d3,1314000000002,2,false,1318.0,",
+          "root.sg1.d4,5,1,false,5556.0,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), count(s1), last_value(s2), count(s1)+last_value(s3) FROM root.sg1.** where s3+1=1316 or s2=false having avg(s1)+sum(s3)>5 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,4,false,1319.0,",
+          "root.sg2.d3,1314000000002,2,false,1318.0,",
+          "root.sg2.d4,5,1,false,5556.0,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), count(s1), last_value(s2), count(s1)+last_value(s3) FROM root.sg2.** where s3+1=1316 or s2=false having avg(s1)+sum(s3)>5 align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),count(s2),first_value(s3)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,1314000000000,13.14,3,2,",
+          "root.sg1.d2,1314000000001,13.15,4,11,",
+          "root.sg1.d3,1314000000002,13.16,3,44,",
+          "root.sg1.d4,1314000000003,13.14,4,1111,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg1.** where s3>1 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,1314000000000,13.14,3,2,",
+          "root.sg2.d2,1314000000001,13.15,4,11,",
+          "root.sg2.d3,1314000000002,13.16,3,44,",
+          "root.sg2.d4,1314000000003,13.14,4,1111,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), count(s2), first_value(s3) FROM root.sg2.** where s3>1 align by device;",
+        expectedHeader,
+        retArray);
+  }
+
+  @Test
+  public void countTimeTest() {
+    // no filter
+    String[] expectedHeader = new String[] {"Device,count_time(*)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d1,4,", "root.sg1.d2,4,", "root.sg1.d3,4,", "root.sg1.d4,4,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** align by device;", expectedHeader, retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,4,", "root.sg2.d2,4,", "root.sg2.d3,4,", "root.sg2.d4,4,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** align by device;", expectedHeader, retArray);
+
+    // and filter
+    expectedHeader = new String[] {"Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,2,", "root.sg1.d2,4,", "root.sg1.d3,2,", "root.sg1.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3>0 and s2=false align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,", "root.sg2.d2,4,", "root.sg2.d3,2,", "root.sg2.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3>0 and s2=false align by device;",
+        expectedHeader,
+        retArray);
+
+    // or filter
+    expectedHeader = new String[] {"Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "root.sg1.d1,2,", "root.sg1.d2,4,", "root.sg1.d3,2,", "root.sg1.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3+1=1316 or s2=false align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,", "root.sg2.d2,4,", "root.sg2.d3,2,", "root.sg2.d4,1,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3+1=1316 or s2=false align by device;",
+        expectedHeader,
+        retArray);
+
+    // group by
+    expectedHeader = new String[] {"Time,Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "1,root.sg1.d1,2,",
+          "6,root.sg1.d1,0,",
+          "1,root.sg1.d2,3,",
+          "6,root.sg1.d2,0,",
+          "1,root.sg1.d3,0,",
+          "6,root.sg1.d3,1,",
+          "1,root.sg1.d4,1,",
+          "6,root.sg1.d4,0,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg1.** where s3+1=1316 or s2=false group by ([1,10), 5ms) align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,count_time(*)"};
+    retArray =
+        new String[] {
+          "1,root.sg2.d1,2,",
+          "6,root.sg2.d1,0,",
+          "1,root.sg2.d2,3,",
+          "6,root.sg2.d2,0,",
+          "1,root.sg2.d3,0,",
+          "6,root.sg2.d3,1,",
+          "1,root.sg2.d4,1,",
+          "6,root.sg2.d4,0,",
+        };
+    resultSetEqualTest(
+        "SELECT count_time(*) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10), 5ms) align by device;",
+        expectedHeader,
+        retArray);
+  }
+
+  @Test
+  public void groupByTest() {
+    String[] expectedHeader =
+        new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "1,root.sg1.d1,2,2.2,false,",
+          "5,root.sg1.d1,5,5.5,true,",
+          "1,root.sg1.d2,2,22.2,false,",
+          "5,root.sg1.d2,5,50.0,false,",
+          "1,root.sg1.d3,1,111.1,true,",
+        };
+    resultSetEqualTest(
+        "select max_time(s1), last_value(s1), last_value(s2) from root.sg1.** group by ([1,10), 2ms) having last_value(s2) is not null limit 5 align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "1,root.sg2.d1,2,2.2,false,",
+          "5,root.sg2.d1,5,5.5,true,",
+          "1,root.sg2.d2,2,22.2,false,",
+          "5,root.sg2.d2,5,50.0,false,",
+          "1,root.sg2.d3,1,111.1,true,",
+        };
+    resultSetEqualTest(
+        "select max_time(s1), last_value(s1), last_value(s2) from root.sg2.** group by ([1,10), 2ms) having last_value(s2) is not null limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    // sliding window
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "1,root.sg1.d1,2,2.2,false,",
+          "1,root.sg1.d2,2,22.2,false,",
+          "3,root.sg1.d2,5,50.0,false,",
+          "5,root.sg1.d2,5,50.0,false,",
+          "7,root.sg1.d3,8,8.8,false,",
+          "3,root.sg1.d4,5,5555.5,false,",
+          "5,root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s3+1=1316 or s2=false group by ([1,10),3ms,2ms) having avg(s1)>0 align by device;",
+        expectedHeader,
+        retArray);
+    expectedHeader = new String[] {"Time,Device,max_time(s1),last_value(s1),last_value(s2)"};
+    retArray =
+        new String[] {
+          "1,root.sg2.d1,2,2.2,false,",
+          "1,root.sg2.d2,2,22.2,false,",
+          "3,root.sg2.d2,5,50.0,false,",
+          "5,root.sg2.d2,5,50.0,false,",
+          "7,root.sg2.d3,8,8.8,false,",
+          "3,root.sg2.d4,5,5555.5,false,",
+          "5,root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s3+1=1316 or s2=false group by ([1,10),3ms,2ms) having avg(s1)>0 align by device;",
+        expectedHeader,
+        retArray);
+  }
+
+  @Test
+  public void havingTest() {
+    String[] expectedHeader = new String[] {"Device,max_time(s1),last_value(s1),last_value(s2)"};
+    String[] retArray =
+        new String[] {
+          "root.sg1.d1,2,2.2,false,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+          "root.sg1.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s2=false having avg(s3) > 1 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,2.2,false,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+          "root.sg2.d4,5,5555.5,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having avg(s3) > 1 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg1.d1,2,2.2,false,",
+          "root.sg1.d2,1314000000001,13.15,false,",
+          "root.sg1.d3,1314000000002,13.16,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg1.** where s2=false having count(s3)+count(s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+    retArray =
+        new String[] {
+          "root.sg2.d1,2,2.2,false,",
+          "root.sg2.d2,1314000000001,13.15,false,",
+          "root.sg2.d3,1314000000002,13.16,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having count(s3)+count(s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+
+    retArray =
+        new String[] {
+          "root.sg2.d2,1314000000001,13.15,false,",
+        };
+    resultSetEqualTest(
+        "SELECT max_time(s1), last_value(s1), last_value(s2) FROM root.sg2.** where s2=false having count(s3+s1) > 2 align by device;",
+        expectedHeader,
+        retArray);
+  }
+
+  @Test
+  public void orderByTest() {
+    String[] expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    String[] retArray =
+        new String[] {
+          "4,root.sg1.d1,5.0,",
+          "4,root.sg1.d2,5.0,",
+          "4,root.sg1.d3,44.0,",
+          "4,root.sg1.d4,5555.0,",
+          "2,root.sg1.d1,2.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg1.** where s1>1 GROUP BY([0, 10), 2ms) order by time desc offset 8 limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
+        new String[] {
+          "4,root.sg2.d1,5.0,",
+          "4,root.sg2.d2,5.0,",
+          "4,root.sg2.d3,44.0,",
+          "4,root.sg2.d4,5555.0,",
+          "2,root.sg2.d1,2.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg2.** where s1>1 GROUP BY([0, 10), 2ms) order by time desc offset 8 limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
+        new String[] {
+          "0,root.sg1.d1,1.0,",
+          "2,root.sg1.d1,2.0,",
+          "4,root.sg1.d1,5.0,",
+          "0,root.sg1.d2,11.0,",
+          "2,root.sg1.d2,22.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg1.** where s1>1 GROUP BY([0, 10), 2ms) order by count(s2) desc limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    expectedHeader = new String[] {"Time,Device,sum(s3)"};
+    retArray =
+        new String[] {
+          "0,root.sg2.d1,1.0,",
+          "2,root.sg2.d1,2.0,",
+          "4,root.sg2.d1,5.0,",
+          "0,root.sg2.d2,11.0,",
+          "2,root.sg2.d2,22.0,",
+        };
+    resultSetEqualTest(
+        "select sum(s3) from root.sg2.** where s1>1 GROUP BY([0, 10), 2ms) order by count(s2) desc limit 5 align by device;",
+        expectedHeader,
+        retArray);
+
+    // order by non-existent measurement
+    assertTestFail(
+        "select sum(s3) from root.sg1.** where s1>1 order by count(s_null) desc limit 5 align by device;",
+        "count(s_null) in order by clause doesn't exist.");
+    assertTestFail(
+        "select sum(s3) from root.sg2.** where s1>1 order by count(s_null) desc limit 5 align by device;",
+        "count(s_null) in order by clause doesn't exist.");
+  }
+
+  protected static void insertData() {
+    try (Connection connection = EnvFactory.getEnv().getConnection();
+        Statement statement = connection.createStatement()) {
+
+      for (String sql : sqls) {
+        statement.execute(sql);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
index be5c98525bbf..5897f78b0ddd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/Analysis.java
@@ -293,7 +293,7 @@ aggregation results last_value(temperature) and last_value(status), whereas buck
   private Template deviceTemplate;
   // when deviceTemplate is not empty and all expressions in this query are templated measurements,
   // i.e. no aggregation and arithmetic expression
-  private boolean onlyQueryTemplateMeasurements = true;
+  private boolean noWhereAndAggregation = true;
   // if it is wildcard query in templated align by device query
   private boolean templateWildCardQuery;
   // all queried measurementList and schemaList in deviceTemplate.
@@ -437,8 +437,8 @@ public TSDataType getType(Expression expression) {
       return null;
     }
 
-    if (isAllDevicesInOneTemplate()
-        && (isOnlyQueryTemplateMeasurements() || expression instanceof TimeSeriesOperand)) {
+    if (allDevicesInOneTemplate()
+        && (noWhereAndAggregation() || expression instanceof TimeSeriesOperand)) {
       TimeSeriesOperand seriesOperand = (TimeSeriesOperand) expression;
       return deviceTemplate.getSchemaMap().get(seriesOperand.getPath().getMeasurement()).getType();
     }
@@ -921,7 +921,7 @@ public List<PartialPath> getDeviceList() {
   // All Queries Devices Set In One Template
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public boolean isAllDevicesInOneTemplate() {
+  public boolean allDevicesInOneTemplate() {
     return this.deviceTemplate != null;
   }
 
@@ -933,12 +933,12 @@ public void setDeviceTemplate(Template template) {
     this.deviceTemplate = template;
   }
 
-  public boolean isOnlyQueryTemplateMeasurements() {
-    return onlyQueryTemplateMeasurements;
+  public boolean noWhereAndAggregation() {
+    return noWhereAndAggregation;
   }
 
-  public void setOnlyQueryTemplateMeasurements(boolean onlyQueryTemplateMeasurements) {
-    this.onlyQueryTemplateMeasurements = onlyQueryTemplateMeasurements;
+  public void setNoWhereAndAggregation(boolean value) {
+    this.noWhereAndAggregation = value;
   }
 
   public List<String> getMeasurementList() {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
index 3ed7bbfd169f..90908302cf1d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeVisitor.java
@@ -209,7 +209,7 @@ public class AnalyzeVisitor extends StatementVisitor<Analysis, MPPQueryContext>
   static final Expression DEVICE_EXPRESSION =
       TimeSeriesOperand.constructColumnHeaderExpression(DEVICE, TSDataType.TEXT);
 
-  static final Expression END_TIME_EXPRESSION =
+  public static final Expression END_TIME_EXPRESSION =
       TimeSeriesOperand.constructColumnHeaderExpression(ENDTIME, TSDataType.INT64);
 
   private final List<String> lastQueryColumnNames =
@@ -1904,7 +1904,8 @@ private void checkGroupByConditionExpressionType(
           && rightExpression instanceof ConstantOperand)) {
         throw new SemanticException(
             String.format(
-                "Please check the keep condition ([%s]),it need to be a constant or a compare expression constructed by 'keep' and a long number.",
+                "Please check the keep condition ([%s]), "
+                    + "it need to be a constant or a compare expression constructed by 'keep' and a long number.",
                 keepExpression.getExpressionString()));
       }
       return;
@@ -1912,12 +1913,13 @@ private void checkGroupByConditionExpressionType(
     if (!(keepExpression instanceof ConstantOperand)) {
       throw new SemanticException(
           String.format(
-              "Please check the keep condition ([%s]),it need to be a constant or a compare expression constructed by 'keep' and a long number.",
+              "Please check the keep condition ([%s]), "
+                  + "it need to be a constant or a compare expression constructed by 'keep' and a long number.",
               keepExpression.getExpressionString()));
     }
   }
 
-  private void analyzeGroupByTime(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeGroupByTime(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.isGroupByTime()) {
       return;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
index ed292c03870e..f5dbad88a827 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/ExpressionTypeAnalyzer.java
@@ -65,7 +65,10 @@ private ExpressionTypeAnalyzer() {}
   public static TSDataType analyzeExpression(Analysis analysis, Expression expression) {
     if (!analysis.getExpressionTypes().containsKey(NodeRef.of(expression))) {
       ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
-      analyzer.analyze(expression, null);
+
+      Map<String, IMeasurementSchema> context =
+          analysis.allDevicesInOneTemplate() ? analysis.getDeviceTemplate().getSchemaMap() : null;
+      analyzer.analyze(expression, context);
 
       addExpressionTypes(analysis, analyzer);
     }
@@ -96,7 +99,9 @@ public static void analyzeExpressionUsingTemplatedInfo(
       Expression expression,
       TemplatedInfo templatedInfo) {
     ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer();
-    analyzer.analyze(expression, templatedInfo.getSchemaMap());
+
+    Map<String, IMeasurementSchema> schemaMap = templatedInfo.getSchemaMap();
+    analyzer.analyze(expression, schemaMap);
 
     types.putAll(analyzer.getExpressionTypes());
   }
@@ -369,6 +374,7 @@ public TSDataType visitTimeSeriesOperand(
         return setExpressionType(
             timeSeriesOperand, context.get(timeSeriesOperand.getOutputSymbol()).getType());
       }
+
       return setExpressionType(timeSeriesOperand, timeSeriesOperand.getPath().getSeriesType());
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
new file mode 100644
index 000000000000..3f6175908128
--- /dev/null
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAggregationAnalyze.java
@@ -0,0 +1,260 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.iotdb.db.queryengine.plan.analyze;
+
+import org.apache.iotdb.commons.path.PartialPath;
+import org.apache.iotdb.db.exception.sql.SemanticException;
+import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
+import org.apache.iotdb.db.queryengine.common.NodeRef;
+import org.apache.iotdb.db.queryengine.common.schematree.ISchemaTree;
+import org.apache.iotdb.db.queryengine.plan.expression.Expression;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.ConstantOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.multi.FunctionExpression;
+import org.apache.iotdb.db.queryengine.plan.statement.component.ResultColumn;
+import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
+import org.apache.iotdb.db.schemaengine.template.Template;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.utils.Pair;
+import org.apache.tsfile.write.schema.IMeasurementSchema;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.DEVICE_EXPRESSION;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeExpressionType;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeGroupByTime;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.analyzeOutput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.normalizeExpression;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDataPartition;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceToWhere;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeDeviceViewOutput;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAnalyze.analyzeFrom;
+import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.canPushDownLimitOffsetInGroupByTimeForDevice;
+import static org.apache.iotdb.db.queryengine.plan.optimization.LimitOffsetPushDown.pushDownLimitOffsetInGroupByTimeForDevice;
+
+/** Methods in this class are used for aggregation, templated with align by device situation. */
+public class TemplatedAggregationAnalyze {
+
+  static boolean canBuildAggregationPlanUseTemplate(
+      Analysis analysis,
+      QueryStatement queryStatement,
+      IPartitionFetcher partitionFetcher,
+      ISchemaTree schemaTree,
+      MPPQueryContext context,
+      Template template) {
+
+    // not support order by expression and non-aligned template
+    if (queryStatement.hasOrderByExpression() || !template.isDirectAligned()) {
+      return false;
+    }
+
+    analysis.setNoWhereAndAggregation(false);
+
+    List<PartialPath> deviceList = analyzeFrom(queryStatement, schemaTree);
+
+    if (canPushDownLimitOffsetInGroupByTimeForDevice(queryStatement)) {
+      // remove the device which won't appear in resultSet after limit/offset
+      deviceList = pushDownLimitOffsetInGroupByTimeForDevice(deviceList, queryStatement);
+    }
+
+    List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
+    boolean valid = analyzeSelect(queryStatement, analysis, outputExpressions, template);
+    if (!valid) {
+      analysis.setDeviceTemplate(null);
+      return false;
+    }
+
+    analyzeDeviceToWhere(analysis, queryStatement);
+    if (deviceList.isEmpty()) {
+      analysis.setFinishQueryAfterAnalyze(true);
+      return true;
+    }
+    analysis.setDeviceList(deviceList);
+
+    if (analysis.getWhereExpression() != null
+        && ConstantOperand.FALSE.equals(analysis.getWhereExpression())) {
+      analyzeOutput(analysis, queryStatement, outputExpressions);
+      analysis.setFinishQueryAfterAnalyze(true);
+      return true;
+    }
+
+    valid = analyzeHaving(analysis, queryStatement);
+    if (!valid) {
+      analysis.setDeviceTemplate(null);
+      return false;
+    }
+
+    analyzeDeviceToExpressions(analysis);
+
+    analyzeDeviceViewOutput(analysis, queryStatement);
+
+    // generate result set header according to output expressions
+    analyzeOutput(analysis, queryStatement, outputExpressions);
+
+    analyzeGroupByTime(analysis, queryStatement);
+    context.generateGlobalTimeFilter(analysis);
+
+    // fetch partition information
+    analyzeDataPartition(analysis, schemaTree, partitionFetcher, context.getGlobalTimeFilter());
+    return true;
+  }
+
+  private static boolean analyzeSelect(
+      QueryStatement queryStatement,
+      Analysis analysis,
+      List<Pair<Expression, String>> outputExpressions,
+      Template template) {
+    LinkedHashSet<Expression> selectExpressions = new LinkedHashSet<>();
+    selectExpressions.add(DEVICE_EXPRESSION);
+    if (queryStatement.isOutputEndTime()) {
+      return false;
+    }
+
+    analysis.setDeviceTemplate(template);
+
+    ColumnPaginationController paginationController =
+        new ColumnPaginationController(
+            queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
+
+    Set<Expression> aggregationExpressions = new LinkedHashSet<>();
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
+      if (paginationController.hasCurOffset()) {
+        paginationController.consumeOffset();
+      } else if (paginationController.hasCurLimit()) {
+        Expression selectExpression = resultColumn.getExpression();
+        outputExpressions.add(new Pair<>(selectExpression, resultColumn.getAlias()));
+        selectExpressions.add(selectExpression);
+        aggregationExpressions.add(selectExpression);
+        if (selectExpression instanceof FunctionExpression
+            && "count_time"
+                .equalsIgnoreCase(((FunctionExpression) selectExpression).getFunctionName())) {
+          analysis.getExpressionTypes().put(NodeRef.of(selectExpression), TSDataType.INT64);
+          ((FunctionExpression) selectExpression)
+              .setExpressions(Collections.singletonList(new TimestampOperand()));
+        } else {
+          analyzeExpressionType(analysis, selectExpression);
+        }
+      } else {
+        break;
+      }
+    }
+
+    List<String> measurementList = new ArrayList<>();
+    List<IMeasurementSchema> measurementSchemaList = new ArrayList<>();
+    Set<String> measurementSet = new HashSet<>();
+
+    if (queryStatement.isCountTimeAggregation()) {
+      measurementList = new ArrayList<>(template.getSchemaMap().keySet());
+      measurementSchemaList = new ArrayList<>(template.getSchemaMap().values());
+    } else {
+      int idx = 0;
+      for (Expression selectExpression : selectExpressions) {
+        idx++;
+        if (idx == 1
+            || (idx == 2 && ENDTIME.equalsIgnoreCase(selectExpression.getOutputSymbol()))) {
+          continue;
+        }
+
+        String measurement = selectExpression.getExpressions().get(0).getOutputSymbol();
+        //  not support agg(*), agg(s1+1) now
+        if (!template.getSchemaMap().containsKey(measurement)) {
+          return false;
+        }
+
+        // for agg1(s1) + agg2(s1), only record s1 for one time
+        if (!measurementSet.contains(measurement)) {
+          measurementSet.add(measurement);
+          measurementList.add(measurement);
+          measurementSchemaList.add(template.getSchemaMap().get(measurement));
+        }
+      }
+    }
+
+    analysis.setMeasurementList(measurementList);
+    analysis.setMeasurementSchemaList(measurementSchemaList);
+    analysis.setAggregationExpressions(aggregationExpressions);
+    analysis.setOutputExpressions(outputExpressions);
+    analysis.setSelectExpressions(selectExpressions);
+    return true;
+  }
+
+  private static boolean analyzeHaving(Analysis analysis, QueryStatement queryStatement) {
+    if (!queryStatement.hasHaving()) {
+      return true;
+    }
+
+    Set<String> measurementSet = new HashSet<>(analysis.getMeasurementList());
+    Set<Expression> aggregationExpressions = analysis.getAggregationExpressions();
+    Expression havingExpression = queryStatement.getHavingCondition().getPredicate();
+    for (Expression aggregationExpression : searchAggregationExpressions(havingExpression)) {
+      Expression normalizedAggregationExpression = normalizeExpression(aggregationExpression);
+
+      // not support having agg(s1+s2) temporarily
+      if (!((normalizedAggregationExpression).getExpressions().get(0)
+          instanceof TimeSeriesOperand)) {
+        return false;
+      }
+
+      String measurement =
+          normalizedAggregationExpression.getExpressions().get(0).getOutputSymbol();
+      if (!measurementSet.contains(measurement)) {
+        // adapt this case: select agg(s1) from xx having agg(s3)
+        measurementSet.add(measurement);
+        analysis.getMeasurementList().add(measurement);
+        analysis
+            .getMeasurementSchemaList()
+            .add(analysis.getDeviceTemplate().getSchema(measurement));
+      }
+
+      analyzeExpressionType(analysis, aggregationExpression);
+      analyzeExpressionType(analysis, normalizedAggregationExpression);
+
+      aggregationExpressions.add(aggregationExpression);
+    }
+
+    TSDataType outputType = analyzeExpressionType(analysis, havingExpression);
+    if (outputType != TSDataType.BOOLEAN) {
+      throw new SemanticException(
+          String.format(
+              "The output type of the expression in HAVING clause should be BOOLEAN, actual data type: %s.",
+              outputType));
+    }
+    analysis.setHavingExpression(havingExpression);
+
+    return true;
+  }
+
+  private static void analyzeDeviceToExpressions(Analysis analysis) {
+    analysis.setDeviceToSourceTransformExpressions(analysis.getDeviceToSelectExpressions());
+
+    analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
+    analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
+
+    analysis.setDeviceToAggregationExpressions(analysis.getDeviceToSelectExpressions());
+  }
+}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
index 87bea8c61a98..a1fcb4c18ee1 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedAnalyze.java
@@ -70,7 +70,9 @@
 import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.getTimePartitionSlotList;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.concatDeviceAndBindSchemaForExpression;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.getMeasurementExpression;
+import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchAggregationExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionTypeAnalyzer.analyzeExpressionForTemplatedQuery;
+import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedAggregationAnalyze.canBuildAggregationPlanUseTemplate;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -96,9 +98,7 @@ public static boolean canBuildPlanUseTemplate(
       IPartitionFetcher partitionFetcher,
       ISchemaTree schemaTree,
       MPPQueryContext context) {
-    if (queryStatement.isAggregationQuery()
-        || queryStatement.isGroupBy()
-        || queryStatement.isGroupByTime()
+    if (queryStatement.getGroupByComponent() != null
         || queryStatement.isSelectInto()
         || queryStatement.hasFill()
         || schemaTree.hasNormalTimeSeries()) {
@@ -106,62 +106,66 @@ public static boolean canBuildPlanUseTemplate(
     }
 
     List<Template> templates = schemaTree.getUsingTemplates();
-    if (templates.size() != 1) {
+    if (templates.size() != 1 || templates.get(0) == null) {
       return false;
     }
 
     Template template = templates.get(0);
 
+    if (queryStatement.isAggregationQuery()) {
+      return canBuildAggregationPlanUseTemplate(
+          analysis, queryStatement, partitionFetcher, schemaTree, context, template);
+    }
+
     List<Pair<Expression, String>> outputExpressions = new ArrayList<>();
     ColumnPaginationController paginationController =
         new ColumnPaginationController(
             queryStatement.getSeriesLimit(), queryStatement.getSeriesOffset());
-    if (template != null) {
-      for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
-        Expression expression = resultColumn.getExpression();
-        if ("*".equals(expression.getOutputSymbol())) {
-          for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              String measurementName = entry.getKey();
-              IMeasurementSchema measurementSchema = entry.getValue();
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              // reserve memory for this expression
-              context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
-              outputExpressions.add(new Pair<>(measurementPath, null));
-              paginationController.consumeLimit();
-            } else {
-              break;
-            }
-          }
-          if (queryStatement.getSelectComponent().getResultColumns().size() == 1
-              && queryStatement.getSeriesOffset() == 0
-              && queryStatement.getSeriesLimit() == 0) {
-            analysis.setTemplateWildCardQuery();
+
+    for (ResultColumn resultColumn : queryStatement.getSelectComponent().getResultColumns()) {
+      Expression expression = resultColumn.getExpression();
+      if ("*".equals(expression.getOutputSymbol())) {
+        for (Map.Entry<String, IMeasurementSchema> entry : template.getSchemaMap().entrySet()) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            String measurementName = entry.getKey();
+            IMeasurementSchema measurementSchema = entry.getValue();
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            // reserve memory for this expression
+            context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
+            outputExpressions.add(new Pair<>(measurementPath, null));
+            paginationController.consumeLimit();
+          } else {
+            break;
           }
-        } else if (expression instanceof TimeSeriesOperand) {
-          String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
-          if (template.getSchemaMap().containsKey(measurementName)) {
-            if (paginationController.hasCurOffset()) {
-              paginationController.consumeOffset();
-            } else if (paginationController.hasCurLimit()) {
-              IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
-              TimeSeriesOperand measurementPath =
-                  new TimeSeriesOperand(
-                      new MeasurementPath(new String[] {measurementName}, measurementSchema));
-              // reserve memory for this expression
-              context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
-              outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
-            } else {
-              break;
-            }
+        }
+        if (queryStatement.getSelectComponent().getResultColumns().size() == 1
+            && queryStatement.getSeriesOffset() == 0
+            && queryStatement.getSeriesLimit() == 0) {
+          analysis.setTemplateWildCardQuery();
+        }
+      } else if (expression instanceof TimeSeriesOperand) {
+        String measurementName = ((TimeSeriesOperand) expression).getPath().getMeasurement();
+        if (template.getSchemaMap().containsKey(measurementName)) {
+          if (paginationController.hasCurOffset()) {
+            paginationController.consumeOffset();
+          } else if (paginationController.hasCurLimit()) {
+            IMeasurementSchema measurementSchema = template.getSchemaMap().get(measurementName);
+            TimeSeriesOperand measurementPath =
+                new TimeSeriesOperand(
+                    new MeasurementPath(new String[] {measurementName}, measurementSchema));
+            // reserve memory for this expression
+            context.reserveMemoryForFrontEnd(measurementPath.ramBytesUsed());
+            outputExpressions.add(new Pair<>(measurementPath, resultColumn.getAlias()));
+          } else {
+            break;
           }
-        } else {
-          return false;
         }
+      } else {
+        return false;
       }
     }
 
@@ -192,7 +196,6 @@ public static boolean canBuildPlanUseTemplate(
     analyzeDeviceToSource(analysis);
 
     analyzeDeviceViewOutput(analysis, queryStatement);
-    analyzeDeviceViewInput(analysis);
 
     analyzeFill(analysis, queryStatement);
 
@@ -232,8 +235,7 @@ private static void analyzeSelect(
     analysis.setMeasurementSchemaList(measurementSchemaList);
   }
 
-  private static List<PartialPath> analyzeFrom(
-      QueryStatement queryStatement, ISchemaTree schemaTree) {
+  static List<PartialPath> analyzeFrom(QueryStatement queryStatement, ISchemaTree schemaTree) {
     // device path patterns in FROM clause
     List<PartialPath> devicePatternList = queryStatement.getFromComponent().getPrefixPaths();
 
@@ -250,12 +252,12 @@ private static List<PartialPath> analyzeFrom(
         : deviceSet.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
   }
 
-  private static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeDeviceToWhere(Analysis analysis, QueryStatement queryStatement) {
     if (!queryStatement.hasWhere()) {
       return;
     }
 
-    analysis.setOnlyQueryTemplateMeasurements(false);
+    analysis.setNoWhereAndAggregation(false);
     Expression wherePredicate =
         new TemplatedConcatRemoveUnExistentMeasurementVisitor()
             .process(
@@ -272,7 +274,7 @@ private static void analyzeDeviceToWhere(Analysis analysis, QueryStatement query
     }
   }
 
-  private static void analyzeDeviceToOrderBy(
+  static void analyzeDeviceToOrderBy(
       Analysis analysis,
       QueryStatement queryStatement,
       ISchemaTree schemaTree,
@@ -331,38 +333,46 @@ private static void analyzeDeviceToSourceTransform(Analysis analysis) {
     analysis.setDeviceToSourceTransformExpressions(analysis.getDeviceToSelectExpressions());
   }
 
-  private static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryStatement) {
+  static void analyzeDeviceViewOutput(Analysis analysis, QueryStatement queryStatement) {
     Set<Expression> selectExpressions = analysis.getSelectExpressions();
-    // TODO if no order by, just set deviceViewOutputExpressions as selectExpressions
-    Set<Expression> deviceViewOutputExpressions = new LinkedHashSet<>(selectExpressions);
-    if (queryStatement.hasOrderByExpression()) {
-      deviceViewOutputExpressions.addAll(analysis.getOrderByExpressions());
+    // if no order by, just set deviceViewOutputExpressions as selectExpressions
+    Set<Expression> deviceViewOutputExpressions = new LinkedHashSet<>();
+
+    if (queryStatement.isAggregationQuery()) {
+      deviceViewOutputExpressions.add(DEVICE_EXPRESSION);
+      if (queryStatement.isOutputEndTime()) {
+        deviceViewOutputExpressions.add(END_TIME_EXPRESSION);
+      }
+      for (Expression selectExpression : selectExpressions) {
+        deviceViewOutputExpressions.addAll(searchAggregationExpressions(selectExpression));
+      }
+      if (queryStatement.hasHaving()) {
+        deviceViewOutputExpressions.addAll(
+            searchAggregationExpressions(analysis.getHavingExpression()));
+      }
+      if (queryStatement.hasOrderByExpression()) {
+        for (Expression orderByExpression : analysis.getOrderByExpressions()) {
+          deviceViewOutputExpressions.addAll(searchAggregationExpressions(orderByExpression));
+        }
+      }
+    } else {
+      deviceViewOutputExpressions.addAll(selectExpressions);
+      if (queryStatement.hasOrderByExpression()) {
+        deviceViewOutputExpressions.addAll(analysis.getOrderByExpressions());
+      }
     }
+
     analysis.setDeviceViewOutputExpressions(deviceViewOutputExpressions);
     analysis.setDeviceViewSpecialProcess(
         analyzeDeviceViewSpecialProcess(deviceViewOutputExpressions, queryStatement, analysis));
   }
 
-  private static void analyzeDeviceViewInput(Analysis analysis) {
-    List<Integer> indexes = new ArrayList<>();
-
-    // index-0 is `Device`
-    for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
-      indexes.add(i);
-    }
-    Map<String, List<Integer>> deviceViewInputIndexesMap = new HashMap<>();
-    for (PartialPath devicePath : analysis.getDeviceList()) {
-      deviceViewInputIndexesMap.put(devicePath.getFullPath(), indexes);
-    }
-    analysis.setDeviceViewInputIndexesMap(deviceViewInputIndexesMap);
-  }
-
   private static void analyzeDeviceToSource(Analysis analysis) {
     analysis.setDeviceToSourceExpressions(analysis.getDeviceToSelectExpressions());
     analysis.setDeviceToOutputExpressions(analysis.getDeviceToSelectExpressions());
   }
 
-  private static void analyzeDataPartition(
+  static void analyzeDataPartition(
       Analysis analysis,
       ISchemaTree schemaTree,
       IPartitionFetcher partitionFetcher,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
index bd624f25634c..919efa8970c2 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/TemplatedInfo.java
@@ -23,6 +23,8 @@
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
 
@@ -58,8 +60,8 @@ public class TemplatedInfo {
   private final boolean queryAllSensors;
 
   // variables used in DeviceViewOperator
-  private final List<String> selectMeasurements;
-  private final List<Integer> deviceToMeasurementIndexes;
+  private final List<String> deviceViewOutputNames;
+  private List<Integer> deviceToMeasurementIndexes;
 
   // variables related to LIMIT/OFFSET push down
   private final long offsetValue;
@@ -71,43 +73,57 @@ public class TemplatedInfo {
 
   // utils variables, not serialize
   private Map<String, IMeasurementSchema> schemaMap;
-  private Map<String, List<InputLocation>> layoutMap;
+  private Map<String, List<InputLocation>> filterLayoutMap;
   private int maxTsBlockLineNum = -1;
 
   // variables related to predicate push down
   private Expression pushDownPredicate;
 
+  // variables related to aggregation
+  private final boolean aggregationQuery;
+  private final GroupByTimeParameter groupByTimeParameter;
+  private final boolean outputEndTime;
+  private List<AggregationDescriptor> ascendingDescriptorList;
+  private List<AggregationDescriptor> descendingDescriptorList;
+
   public TemplatedInfo(
       List<String> measurementList,
       List<IMeasurementSchema> schemaList,
       List<TSDataType> dataTypes,
       Ordering scanOrder,
       boolean queryAllSensors,
-      List<String> selectMeasurements,
+      List<String> deviceViewOutputNames,
       List<Integer> deviceToMeasurementIndexes,
       long offsetValue,
       long limitValue,
       Expression predicate,
       boolean keepNull,
       Map<String, IMeasurementSchema> schemaMap,
-      Map<String, List<InputLocation>> layoutMap,
-      Expression pushDownPredicate) {
+      Map<String, List<InputLocation>> filterLayoutMap,
+      Expression pushDownPredicate,
+      boolean aggregationQuery,
+      GroupByTimeParameter groupByTimeParameter,
+      boolean outputEndTime) {
     this.measurementList = measurementList;
     this.schemaList = schemaList;
     this.dataTypes = dataTypes;
     this.scanOrder = scanOrder;
     this.queryAllSensors = queryAllSensors;
-    this.selectMeasurements = selectMeasurements;
+    this.deviceViewOutputNames = deviceViewOutputNames;
     this.deviceToMeasurementIndexes = deviceToMeasurementIndexes;
     this.offsetValue = offsetValue;
     this.limitValue = limitValue;
     this.predicate = predicate;
     if (predicate != null) {
       this.keepNull = keepNull;
-      this.schemaMap = schemaMap;
-      this.layoutMap = layoutMap;
+      this.filterLayoutMap = filterLayoutMap;
     }
     this.pushDownPredicate = pushDownPredicate;
+    this.schemaMap = schemaMap;
+
+    this.aggregationQuery = aggregationQuery;
+    this.groupByTimeParameter = groupByTimeParameter;
+    this.outputEndTime = outputEndTime;
   }
 
   public List<String> getMeasurementList() {
@@ -130,8 +146,8 @@ public boolean isQueryAllSensors() {
     return this.queryAllSensors;
   }
 
-  public List<String> getSelectMeasurements() {
-    return this.selectMeasurements;
+  public List<String> getDeviceViewOutputNames() {
+    return this.deviceViewOutputNames;
   }
 
   public long getOffsetValue() {
@@ -146,6 +162,10 @@ public List<Integer> getDeviceToMeasurementIndexes() {
     return this.deviceToMeasurementIndexes;
   }
 
+  public void setDeviceToMeasurementIndexes(List<Integer> deviceToMeasurementIndexes) {
+    this.deviceToMeasurementIndexes = deviceToMeasurementIndexes;
+  }
+
   public Expression getPredicate() {
     return this.predicate;
   }
@@ -158,8 +178,8 @@ public Map<String, IMeasurementSchema> getSchemaMap() {
     return this.schemaMap;
   }
 
-  public Map<String, List<InputLocation>> getLayoutMap() {
-    return this.layoutMap;
+  public Map<String, List<InputLocation>> getFilterLayoutMap() {
+    return this.filterLayoutMap;
   }
 
   public Expression getPushDownPredicate() {
@@ -185,6 +205,34 @@ public Expression[] getProjectExpressions() {
     return projectExpressions;
   }
 
+  public boolean isAggregationQuery() {
+    return aggregationQuery;
+  }
+
+  public GroupByTimeParameter getGroupByTimeParameter() {
+    return this.groupByTimeParameter;
+  }
+
+  public boolean isOutputEndTime() {
+    return outputEndTime;
+  }
+
+  public List<AggregationDescriptor> getAscendingDescriptorList() {
+    return this.ascendingDescriptorList;
+  }
+
+  public void setAscendingDescriptorList(List<AggregationDescriptor> ascendingDescriptorList) {
+    this.ascendingDescriptorList = ascendingDescriptorList;
+  }
+
+  public List<AggregationDescriptor> getDescendingDescriptorList() {
+    return this.descendingDescriptorList;
+  }
+
+  public void setDescendingDescriptorList(List<AggregationDescriptor> descendingDescriptorList) {
+    this.descendingDescriptorList = descendingDescriptorList;
+  }
+
   public static Map<String, List<InputLocation>> makeLayout(List<String> measurementList) {
     Map<String, List<InputLocation>> outputMappings = new LinkedHashMap<>();
     int tsBlockIndex = 0;
@@ -215,9 +263,9 @@ public void serialize(ByteBuffer byteBuffer) {
     ReadWriteIOUtils.write(scanOrder.ordinal(), byteBuffer);
     ReadWriteIOUtils.write(queryAllSensors, byteBuffer);
 
-    ReadWriteIOUtils.write(selectMeasurements.size(), byteBuffer);
-    for (String selectMeasurement : selectMeasurements) {
-      ReadWriteIOUtils.write(selectMeasurement, byteBuffer);
+    ReadWriteIOUtils.write(deviceViewOutputNames.size(), byteBuffer);
+    for (String outputName : deviceViewOutputNames) {
+      ReadWriteIOUtils.write(outputName, byteBuffer);
     }
 
     ReadWriteIOUtils.write(deviceToMeasurementIndexes.size(), byteBuffer);
@@ -242,6 +290,30 @@ public void serialize(ByteBuffer byteBuffer) {
     } else {
       ReadWriteIOUtils.write((byte) 0, byteBuffer);
     }
+
+    if (aggregationQuery) {
+      ReadWriteIOUtils.write((byte) 1, byteBuffer);
+      if (groupByTimeParameter != null) {
+        ReadWriteIOUtils.write((byte) 1, byteBuffer);
+        groupByTimeParameter.serialize(byteBuffer);
+      } else {
+        ReadWriteIOUtils.write((byte) 0, byteBuffer);
+      }
+
+      ReadWriteIOUtils.write(outputEndTime, byteBuffer);
+
+      ReadWriteIOUtils.write(ascendingDescriptorList.size(), byteBuffer);
+      for (AggregationDescriptor descriptor : ascendingDescriptorList) {
+        descriptor.serialize(byteBuffer);
+      }
+
+      ReadWriteIOUtils.write(descendingDescriptorList.size(), byteBuffer);
+      for (AggregationDescriptor descriptor : descendingDescriptorList) {
+        descriptor.serialize(byteBuffer);
+      }
+    } else {
+      ReadWriteIOUtils.write((byte) 0, byteBuffer);
+    }
   }
 
   public void serialize(DataOutputStream stream) throws IOException {
@@ -258,9 +330,9 @@ public void serialize(DataOutputStream stream) throws IOException {
     ReadWriteIOUtils.write(scanOrder.ordinal(), stream);
     ReadWriteIOUtils.write(queryAllSensors, stream);
 
-    ReadWriteIOUtils.write(selectMeasurements.size(), stream);
-    for (String selectMeasurement : selectMeasurements) {
-      ReadWriteIOUtils.write(selectMeasurement, stream);
+    ReadWriteIOUtils.write(deviceViewOutputNames.size(), stream);
+    for (String outputName : deviceViewOutputNames) {
+      ReadWriteIOUtils.write(outputName, stream);
     }
 
     ReadWriteIOUtils.write(deviceToMeasurementIndexes.size(), stream);
@@ -285,6 +357,30 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write((byte) 0, stream);
     }
+
+    if (aggregationQuery) {
+      ReadWriteIOUtils.write((byte) 1, stream);
+      if (groupByTimeParameter != null) {
+        ReadWriteIOUtils.write((byte) 1, stream);
+        groupByTimeParameter.serialize(stream);
+      } else {
+        ReadWriteIOUtils.write((byte) 0, stream);
+      }
+
+      ReadWriteIOUtils.write(outputEndTime, stream);
+
+      ReadWriteIOUtils.write(ascendingDescriptorList.size(), stream);
+      for (AggregationDescriptor descriptor : ascendingDescriptorList) {
+        descriptor.serialize(stream);
+      }
+
+      ReadWriteIOUtils.write(descendingDescriptorList.size(), stream);
+      for (AggregationDescriptor descriptor : descendingDescriptorList) {
+        descriptor.serialize(stream);
+      }
+    } else {
+      ReadWriteIOUtils.write((byte) 0, stream);
+    }
   }
 
   public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
@@ -330,40 +426,75 @@ public static TemplatedInfo deserialize(ByteBuffer byteBuffer) {
     long limitValue = ReadWriteIOUtils.readLong(byteBuffer);
 
     Expression predicate = null;
-    byte hasFilter = ReadWriteIOUtils.readByte(byteBuffer);
-    Map<String, IMeasurementSchema> currentSchemaMap = null;
-    Map<String, List<InputLocation>> layoutMap = null;
     boolean keepNull = false;
+    Map<String, List<InputLocation>> filterLayoutMap = null;
+    byte hasFilter = ReadWriteIOUtils.readByte(byteBuffer);
     if (hasFilter == 1) {
       predicate = Expression.deserialize(byteBuffer);
       keepNull = ReadWriteIOUtils.readBool(byteBuffer);
-      currentSchemaMap = new HashMap<>();
-      for (IMeasurementSchema measurementSchema : measurementSchemaList) {
-        currentSchemaMap.put(measurementSchema.getMeasurementId(), measurementSchema);
-      }
-      layoutMap = makeLayout(measurementList);
+      filterLayoutMap = makeLayout(measurementList);
     }
 
+    Map<String, IMeasurementSchema> measurementSchemaMap =
+        new HashMap<>(measurementSchemaList.size());
+    measurementSchemaList.forEach(
+        measurementSchema ->
+            measurementSchemaMap.put(measurementSchema.getMeasurementId(), measurementSchema));
+
     Expression pushDownPredicate = null;
     byte hasPushDownFilter = ReadWriteIOUtils.readByte(byteBuffer);
     if (hasPushDownFilter == 1) {
       pushDownPredicate = Expression.deserialize(byteBuffer);
     }
 
-    return new TemplatedInfo(
-        measurementList,
-        measurementSchemaList,
-        dataTypeList,
-        scanOrder,
-        queryAllSensors,
-        selectMeasurements,
-        deviceToMeasurementIndexes,
-        offsetValue,
-        limitValue,
-        predicate,
-        keepNull,
-        currentSchemaMap,
-        layoutMap,
-        pushDownPredicate);
+    boolean aggregationQuery = ReadWriteIOUtils.readBool(byteBuffer);
+    GroupByTimeParameter groupByTimeParameter = null;
+    boolean outputEndTime = false;
+    List<AggregationDescriptor> ascendingDescriptorList = null;
+    List<AggregationDescriptor> descendingDescriptorList = null;
+
+    if (aggregationQuery) {
+      byte hasGroupByTime = ReadWriteIOUtils.readByte(byteBuffer);
+      if (hasGroupByTime == 1) {
+        groupByTimeParameter = GroupByTimeParameter.deserialize(byteBuffer);
+      }
+
+      outputEndTime = ReadWriteIOUtils.readBool(byteBuffer);
+
+      int size = ReadWriteIOUtils.readInt(byteBuffer);
+      ascendingDescriptorList = new ArrayList<>(size);
+      while (size-- > 0) {
+        ascendingDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+      }
+
+      size = ReadWriteIOUtils.readInt(byteBuffer);
+      descendingDescriptorList = new ArrayList<>(size);
+      while (size-- > 0) {
+        descendingDescriptorList.add(AggregationDescriptor.deserialize(byteBuffer));
+      }
+    }
+
+    TemplatedInfo templatedInfo =
+        new TemplatedInfo(
+            measurementList,
+            measurementSchemaList,
+            dataTypeList,
+            scanOrder,
+            queryAllSensors,
+            selectMeasurements,
+            deviceToMeasurementIndexes,
+            offsetValue,
+            limitValue,
+            predicate,
+            keepNull,
+            measurementSchemaMap,
+            filterLayoutMap,
+            pushDownPredicate,
+            aggregationQuery,
+            groupByTimeParameter,
+            outputEndTime);
+    templatedInfo.setAscendingDescriptorList(ascendingDescriptorList);
+    templatedInfo.setDescendingDescriptorList(descendingDescriptorList);
+    return templatedInfo;
   }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
index 7f7ba25c6d41..994f1a300560 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/AggregationPushDown.java
@@ -104,6 +104,10 @@ public PlanNode optimize(PlanNode plan, Analysis analysis, MPPQueryContext conte
   private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis analysis) {
     boolean isAlignByDevice = queryStatement.isAlignByDevice();
     if (isAlignByDevice) {
+      if (analysis.allDevicesInOneTemplate()) {
+        return cannotUseStatisticsForTemplate(analysis.getAggregationExpressions());
+      }
+
       // check any of the devices
       String device = analysis.getDeviceList().get(0).toString();
       return cannotUseStatistics(
@@ -117,8 +121,8 @@ private boolean cannotUseStatistics(QueryStatement queryStatement, Analysis anal
 
   private boolean cannotUseStatistics(
       Set<Expression> aggregationExpressions, Set<Expression> sourceTransformExpressions) {
-    for (Expression expression : aggregationExpressions) {
 
+    for (Expression expression : aggregationExpressions) {
       if (expression instanceof FunctionExpression) {
         FunctionExpression functionExpression = (FunctionExpression) expression;
         // Disable statistics optimization of UDAF for now
@@ -155,6 +159,32 @@ private boolean cannotUseStatistics(
     return false;
   }
 
+  private boolean cannotUseStatisticsForTemplate(Set<Expression> aggregationExpressions) {
+
+    for (Expression expression : aggregationExpressions) {
+      if (expression instanceof FunctionExpression) {
+        FunctionExpression functionExpression = (FunctionExpression) expression;
+        // Disable statistics optimization of UDAF for now
+        if (functionExpression.isExternalAggregationFunctionExpression()) {
+          return true;
+        }
+
+        // in template align by device query, device must be aligned
+        if (COUNT_TIME.equalsIgnoreCase(functionExpression.getFunctionName())) {
+          return false;
+        }
+
+        if (!BuiltinAggregationFunction.canUseStatistics(functionExpression.getFunctionName())) {
+          return true;
+        }
+      } else {
+        throw new IllegalArgumentException(
+            String.format("Invalid Aggregation Expression: %s", expression.getExpressionString()));
+      }
+    }
+    return false;
+  }
+
   private static class Rewriter extends PlanVisitor<PlanNode, RewriterContext> {
 
     @Override
@@ -184,6 +214,10 @@ public PlanNode visitDeviceView(DeviceViewNode node, RewriterContext context) {
       List<PlanNode> rewrittenChildren = new ArrayList<>();
       for (int i = 0; i < node.getDevices().size(); i++) {
         context.setCurDevice(node.getDevices().get(i));
+        if (context.analysis.allDevicesInOneTemplate()) {
+          context.setCurDevicePath(context.analysis.getDeviceList().get(i));
+        }
+
         rewrittenChildren.add(node.getChildren().get(i).accept(this, context));
       }
       node.setChildren(rewrittenChildren);
@@ -193,6 +227,7 @@ public PlanNode visitDeviceView(DeviceViewNode node, RewriterContext context) {
     @Override
     public PlanNode visitSingleDeviceView(SingleDeviceViewNode node, RewriterContext context) {
       context.setCurDevice(node.getDevice());
+      context.setCurDevicePath(new PartialPath(node.getDevice().split(",")));
       PlanNode rewrittenChild = node.getChild().accept(this, context);
       node.setChild(rewrittenChild);
       return node;
@@ -236,6 +271,10 @@ public PlanNode visitGroupByTag(GroupByTagNode node, RewriterContext context) {
 
     @Override
     public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterContext context) {
+      if (context.analysis.allDevicesInOneTemplate()) {
+        return visitRawDataAggregationTemplateCase(node, context);
+      }
+
       PlanNode child = node.getChild();
       if (child instanceof ProjectNode) {
         // remove ProjectNode
@@ -246,7 +285,6 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
         boolean isSingleSource = child instanceof SeriesScanSourceNode;
         boolean needCheckAscending = node.getGroupByTimeParameter() == null;
         if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
-          //          needCheckAscending = false;
           Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
           if (!PredicateUtils.predicateCanPushIntoScan(pushDownPredicate)) {
             // don't push down, simplify the BE side logic
@@ -275,7 +313,7 @@ public PlanNode visitRawDataAggregation(RawDataAggregationNode node, RewriterCon
         }
 
         List<PlanNode> sourceNodeList =
-            constructSourceNodeFromAggregationDescriptors(
+            constructSourceNodeFromAggregationsDescriptors(
                 sourceToAscendingAggregationsMap,
                 sourceToDescendingAggregationsMap,
                 sourceToCountTimeAggregationsMap,
@@ -384,7 +422,7 @@ private void createAggregationDescriptor(
       }
     }
 
-    private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
+    private List<PlanNode> constructSourceNodeFromAggregationsDescriptors(
         Map<PartialPath, List<AggregationDescriptor>> ascendingAggregations,
         Map<PartialPath, List<AggregationDescriptor>> descendingAggregations,
         Map<PartialPath, List<AggregationDescriptor>> countTimeAggregations,
@@ -392,7 +430,6 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
         GroupByTimeParameter groupByTimeParameter,
         RewriterContext context) {
       List<PlanNode> sourceNodeList = new ArrayList<>();
-      boolean needCheckAscending = groupByTimeParameter == null;
       Map<PartialPath, List<AggregationDescriptor>> groupedAscendingAggregations = null;
       if (!countTimeAggregations.isEmpty()) {
         groupedAscendingAggregations = countTimeAggregations;
@@ -408,9 +445,11 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
                 pathAggregationsEntry.getValue(),
                 scanOrder,
                 groupByTimeParameter,
-                context));
+                context,
+                countTimeAggregations.isEmpty() ? (byte) 0 : (byte) 2));
       }
 
+      boolean needCheckAscending = groupByTimeParameter == null;
       if (needCheckAscending) {
         Map<PartialPath, List<AggregationDescriptor>> groupedDescendingAggregations =
             MetaUtils.groupAlignedAggregations(descendingAggregations);
@@ -422,18 +461,122 @@ private List<PlanNode> constructSourceNodeFromAggregationDescriptors(
                   pathAggregationsEntry.getValue(),
                   scanOrder.reverse(),
                   null,
-                  context));
+                  context,
+                  (byte) 1));
         }
       }
       return sourceNodeList;
     }
 
+    public PlanNode visitRawDataAggregationTemplateCase(
+        RawDataAggregationNode node, RewriterContext context) {
+      PlanNode child = node.getChild();
+
+      if (child instanceof ProjectNode) {
+        node.setChild(((ProjectNode) child).getChild());
+        return visitRawDataAggregation(node, context);
+      }
+
+      if (child instanceof FullOuterTimeJoinNode || child instanceof SeriesScanSourceNode) {
+        boolean isSingleSource = child instanceof SeriesScanSourceNode;
+        if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
+          Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
+          if (!PredicateUtils.predicateCanPushIntoScan(pushDownPredicate)) {
+            // don't push down, simplify the BE side logic
+            return node;
+          }
+        }
+
+        List<PlanNode> sourceNodeList =
+            constructSourceNodeFromTemplateAggregationDescriptors(
+                context
+                    .getContext()
+                    .getTypeProvider()
+                    .getTemplatedInfo()
+                    .getAscendingDescriptorList(),
+                context
+                    .getContext()
+                    .getTypeProvider()
+                    .getTemplatedInfo()
+                    .getDescendingDescriptorList(),
+                node.getScanOrder(),
+                node.getGroupByTimeParameter(),
+                context);
+
+        if (isSingleSource && ((SeriesScanSourceNode) child).getPushDownPredicate() != null) {
+          Expression pushDownPredicate = ((SeriesScanSourceNode) child).getPushDownPredicate();
+          sourceNodeList.forEach(
+              sourceNode -> {
+                SeriesAggregationSourceNode aggregationSourceNode =
+                    (SeriesAggregationSourceNode) sourceNode;
+                aggregationSourceNode.setPushDownPredicate(pushDownPredicate);
+                if (aggregationSourceNode instanceof AlignedSeriesAggregationScanNode) {
+                  ((AlignedSeriesAggregationScanNode) aggregationSourceNode)
+                      .setAlignedPath(((AlignedSeriesScanNode) child).getAlignedPath());
+                }
+              });
+        }
+
+        PlanNode resultNode = convergeWithTimeJoin(sourceNodeList, node.getScanOrder(), context);
+        resultNode = planProject(resultNode, node, context);
+
+        // After pushing down the predicate, the original scan nodes are no longer needed, we should
+        // release the memory that they occupied.
+        context.releaseMemoryForFrontEnd(getRamBytesUsedOfOldScanNodes(child));
+        return resultNode;
+      }
+      // cannot push down
+      return node;
+    }
+
+    private List<PlanNode> constructSourceNodeFromTemplateAggregationDescriptors(
+        List<AggregationDescriptor> ascendingAggregations,
+        List<AggregationDescriptor> descendingAggregations,
+        Ordering scanOrder,
+        GroupByTimeParameter groupByTimeParameter,
+        RewriterContext context) {
+
+      List<PlanNode> sourceNodeList = new ArrayList<>();
+      PartialPath devicePath = context.curDevicePath;
+      List<String> measurementList = context.analysis.getMeasurementList();
+      List<IMeasurementSchema> measurementSchemaList = context.analysis.getMeasurementSchemaList();
+      boolean needCheckAscending = groupByTimeParameter == null;
+
+      if (!context.analysis.getDeviceTemplate().isDirectAligned()) {
+        throw new IllegalStateException(
+            "Aggregation descriptors with non aligned template are not supported");
+      }
+      AlignedPath alignedPath = new AlignedPath(devicePath);
+      alignedPath.setMeasurementList(measurementList);
+      alignedPath.addSchemas(measurementSchemaList);
+
+      if (!ascendingAggregations.isEmpty()) {
+        sourceNodeList.add(
+            createAggregationScanNode(
+                alignedPath,
+                ascendingAggregations,
+                scanOrder,
+                groupByTimeParameter,
+                context,
+                (byte) 0));
+      }
+
+      if (needCheckAscending && !descendingAggregations.isEmpty()) {
+        sourceNodeList.add(
+            createAggregationScanNode(
+                alignedPath, descendingAggregations, scanOrder, null, context, (byte) 1));
+      }
+
+      return sourceNodeList;
+    }
+
     private SeriesAggregationSourceNode createAggregationScanNode(
         PartialPath selectPath,
         List<AggregationDescriptor> aggregationDescriptorList,
         Ordering scanOrder,
         GroupByTimeParameter groupByTimeParameter,
-        RewriterContext context) {
+        RewriterContext context,
+        byte descriptorType) {
       if (selectPath instanceof MeasurementPath) { // non-aligned series
         SeriesAggregationSourceNode node =
             new SeriesAggregationScanNode(
@@ -448,18 +591,19 @@ private SeriesAggregationSourceNode createAggregationScanNode(
                 MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(node));
         return node;
       } else if (selectPath instanceof AlignedPath) { // aligned series
-        SeriesAggregationSourceNode node =
+        AlignedSeriesAggregationScanNode aggScanNode =
             new AlignedSeriesAggregationScanNode(
                 context.genPlanNodeId(),
                 (AlignedPath) selectPath,
                 aggregationDescriptorList,
                 scanOrder,
                 groupByTimeParameter);
+        aggScanNode.setDescriptorType(descriptorType);
         context
             .getContext()
             .reserveMemoryForFrontEnd(
-                MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(node));
-        return node;
+                MemoryEstimationHelper.getEstimatedSizeOfAccountableObject(aggScanNode));
+        return aggScanNode;
       } else {
         throw new IllegalArgumentException("unexpected path type");
       }
@@ -496,6 +640,7 @@ private static class RewriterContext {
     private final boolean isAlignByDevice;
 
     private String curDevice;
+    private PartialPath curDevicePath;
 
     private long bytesToBeReleased = 0;
 
@@ -518,13 +663,21 @@ public void setCurDevice(String curDevice) {
       this.curDevice = curDevice;
     }
 
+    public void setCurDevicePath(PartialPath devicePath) {
+      this.curDevicePath = devicePath;
+    }
+
     public MPPQueryContext getContext() {
       return context;
     }
 
     public Set<Expression> getAggregationExpressions() {
       if (isAlignByDevice) {
-        return analysis.getDeviceToAggregationExpressions().get(curDevice);
+        if (analysis.allDevicesInOneTemplate()) {
+          return analysis.getAggregationExpressions();
+        } else {
+          return analysis.getDeviceToAggregationExpressions().get(curDevice);
+        }
       }
       return analysis.getAggregationExpressions();
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
index 2207b94f6b89..65a7023bb311 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/optimization/PredicatePushDown.java
@@ -164,7 +164,10 @@ public PlanNode visitFullOuterTimeJoin(FullOuterTimeJoinNode node, RewriterConte
       if (!cannotPushDownConjuncts.isEmpty()) {
         resultNode =
             planFilter(
-                resultNode, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context);
+                resultNode,
+                PredicateUtils.combineConjuncts(cannotPushDownConjuncts),
+                context,
+                true);
       } else {
         resultNode = planTransform(resultNode, context);
         resultNode = planProject(resultNode, context);
@@ -249,7 +252,8 @@ private PlanNode planLeftOuterTimeJoin(
       return resultNode;
     }
 
-    private PlanNode planFilter(PlanNode child, Expression predicate, RewriterContext context) {
+    private PlanNode planFilter(
+        PlanNode child, Expression predicate, RewriterContext context, boolean isFromWhere) {
       FilterNode pushDownFilterNode = context.getPushDownFilterNode();
       return new FilterNode(
           context.genPlanNodeId(),
@@ -257,7 +261,8 @@ private PlanNode planFilter(PlanNode child, Expression predicate, RewriterContex
           pushDownFilterNode.getOutputExpressions(),
           predicate,
           pushDownFilterNode.isKeepNull(),
-          pushDownFilterNode.getScanOrder());
+          pushDownFilterNode.getScanOrder(),
+          isFromWhere);
     }
 
     @Override
@@ -330,7 +335,8 @@ public PlanNode visitSeriesScanSource(SeriesScanSourceNode node, RewriterContext
         resultNode = planProject(resultNode, context);
         return resultNode;
       } else {
-        return planFilter(node, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context);
+        return planFilter(
+            node, PredicateUtils.combineConjuncts(cannotPushDownConjuncts), context, true);
       }
     }
 
@@ -402,7 +408,7 @@ private static class RewriterContext {
     private RewriterContext(Analysis analysis, MPPQueryContext context, boolean isAlignByDevice) {
       this.queryId = context.getQueryId();
       this.isAlignByDevice = isAlignByDevice;
-      this.isBuildPlanUseTemplate = analysis.isAllDevicesInOneTemplate();
+      this.isBuildPlanUseTemplate = analysis.allDevicesInOneTemplate();
       this.templatedInfo = context.getTypeProvider().getTemplatedInfo();
       this.filterNodeFromWhereChecker = analysis::fromWhere;
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
index 9559b29e9763..5e614e16e28f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanBuilder.java
@@ -621,7 +621,9 @@ private void addSingleDeviceViewNodes(
               context.getQueryId().genPlanNodeId(),
               outputColumnNames,
               deviceName,
-              deviceToMeasurementIndexesMap.get(deviceName));
+              deviceToMeasurementIndexesMap == null
+                  ? null
+                  : deviceToMeasurementIndexesMap.get(deviceName));
 
       // put LIMIT-NODE below of SingleDeviceViewNode if exists value filter
       if (valueFilterLimit > 0) {
@@ -743,9 +745,6 @@ public LogicalPlanBuilder planSlidingWindowAggregation(
       GroupByTimeParameter groupByTimeParameter,
       AggregationStep curStep,
       Ordering scanOrder) {
-    if (aggregationExpressions == null) {
-      return this;
-    }
 
     this.root =
         createSlidingWindowAggregationNode(
@@ -753,7 +752,7 @@ public LogicalPlanBuilder planSlidingWindowAggregation(
     return this;
   }
 
-  private PlanNode createSlidingWindowAggregationNode(
+  protected PlanNode createSlidingWindowAggregationNode(
       PlanNode child,
       Set<Expression> aggregationExpressions,
       GroupByTimeParameter groupByTimeParameter,
@@ -858,7 +857,7 @@ private PlanNode createGroupByTagNode(
             .collect(Collectors.toList()));
   }
 
-  private List<AggregationDescriptor> constructAggregationDescriptorList(
+  protected List<AggregationDescriptor> constructAggregationDescriptorList(
       Set<Expression> aggregationExpressions, AggregationStep curStep) {
     return aggregationExpressions.stream()
         .map(
@@ -890,7 +889,8 @@ public LogicalPlanBuilder planFilterAndTransform(
             selectExpressions.toArray(new Expression[0]),
             filterExpression,
             isGroupByTime,
-            scanOrder);
+            scanOrder,
+            fromWhere);
     if (fromWhere) {
       analysis.setFromWhere(filterNode);
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
index 08990c5df472..3bec19321d3c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
@@ -134,7 +134,7 @@ public PlanNode visitExplainAnalyze(
 
   @Override
   public PlanNode visitQuery(QueryStatement queryStatement, MPPQueryContext context) {
-    if (analysis.isAllDevicesInOneTemplate()) {
+    if (analysis.allDevicesInOneTemplate()) {
       return new TemplatedLogicalPlan(analysis, queryStatement, context).visitQuery();
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
index cc1da9b7ec41..ae1e76658001 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/OperatorTreeGenerator.java
@@ -292,6 +292,7 @@
 import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING;
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor.getAggregationTypeByFuncName;
 import static org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.SeriesScanOptions.updateFilterUsingTTL;
+import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.ASC;
 import static org.apache.iotdb.db.utils.TimestampPrecisionUtils.TIMESTAMP_PRECISION;
 
 /** This Visitor is responsible for transferring PlanNode Tree to Operator Tree. */
@@ -450,7 +451,7 @@ public Operator visitAlignedSeriesScan(
             seriesScanOperator,
             templatedInfo.getProjectExpressions(),
             templatedInfo.getDataTypes(),
-            templatedInfo.getLayoutMap(),
+            templatedInfo.getFilterLayoutMap(),
             templatedInfo.isKeepNull(),
             node.getPlanNodeId(),
             templatedInfo.getScanOrder(),
@@ -497,10 +498,16 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
     List<String> inputColumnNames;
     List<String> outputColumnNames = node.getOutputColumnNames();
     if (outputColumnNames == null) {
-      outputColumnNames = context.getTypeProvider().getTemplatedInfo().getSelectMeasurements();
-      // skip device column
-      outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
-      inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+      if (context.getTypeProvider().getTemplatedInfo().isAggregationQuery()) {
+        outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
+        outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
+        inputColumnNames = node.getChild().getOutputColumnNames();
+      } else {
+        outputColumnNames = context.getTypeProvider().getTemplatedInfo().getDeviceViewOutputNames();
+        // skip device column
+        outputColumnNames = outputColumnNames.subList(1, outputColumnNames.size());
+        inputColumnNames = context.getTypeProvider().getTemplatedInfo().getMeasurementList();
+      }
     } else {
       inputColumnNames = node.getChild().getOutputColumnNames();
     }
@@ -526,7 +533,7 @@ public Operator visitProject(ProjectNode node, LocalExecutionPlanContext context
   public Operator visitSeriesAggregationScan(
       SeriesAggregationScanNode node, LocalExecutionPlanContext context) {
     PartialPath seriesPath = node.getSeriesPath();
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     List<Aggregator> aggregators = new ArrayList<>();
     aggregationDescriptors.forEach(
@@ -600,23 +607,64 @@ public Operator visitSeriesAggregationScan(
   @Override
   public Operator visitAlignedSeriesAggregationScan(
       AlignedSeriesAggregationScanNode node, LocalExecutionPlanContext context) {
-    AlignedPath seriesPath = node.getAlignedPath();
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    if (context.isBuildPlanUseTemplate()) {
+      Ordering scanOrder = context.getTemplatedInfo().getScanOrder();
+      List<AggregationDescriptor> aggregationDescriptors;
+      if (node.getDescriptorType() == 0 || node.getDescriptorType() == 2) {
+        aggregationDescriptors = context.getTemplatedInfo().getAscendingDescriptorList();
+      } else {
+        scanOrder = scanOrder.reverse();
+        aggregationDescriptors = context.getTemplatedInfo().getDescendingDescriptorList();
+      }
+
+      return constructAlignedSeriesAggregationScanOperator(
+          node.getPlanNodeId(),
+          node.getAlignedPath(),
+          aggregationDescriptors,
+          context.getTemplatedInfo().getPushDownPredicate(),
+          scanOrder,
+          context.getTemplatedInfo().getGroupByTimeParameter(),
+          context.getTemplatedInfo().isOutputEndTime(),
+          context);
+    }
+
+    return constructAlignedSeriesAggregationScanOperator(
+        node.getPlanNodeId(),
+        node.getAlignedPath(),
+        node.getAggregationDescriptorList(),
+        node.getPushDownPredicate(),
+        node.getScanOrder(),
+        node.getGroupByTimeParameter(),
+        node.isOutputEndTime(),
+        context);
+  }
+
+  private Operator constructAlignedSeriesAggregationScanOperator(
+      PlanNodeId planNodeId,
+      AlignedPath alignedPath,
+      List<AggregationDescriptor> aggregationDescriptorList,
+      Expression pushDownPredicate,
+      Ordering scanOrder,
+      GroupByTimeParameter groupByTimeParameter,
+      boolean outputEndTime,
+      LocalExecutionPlanContext context) {
+    boolean ascending = scanOrder == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     boolean canUseStatistics = true;
-    for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
+    for (AggregationDescriptor descriptor : aggregationDescriptorList) {
       checkArgument(
           descriptor.getInputExpressions().size() == 1,
           "descriptor's input expression size is not 1");
+
       Expression expression = descriptor.getInputExpressions().get(0);
       if (expression instanceof TimeSeriesOperand) {
         String inputSeries =
             ((TimeSeriesOperand) (descriptor.getInputExpressions().get(0)))
                 .getPath()
                 .getMeasurement();
-        int seriesIndex = seriesPath.getMeasurementList().indexOf(inputSeries);
+        int seriesIndex = alignedPath.getMeasurementList().indexOf(inputSeries);
         TSDataType seriesDataType =
-            seriesPath.getMeasurementSchema().getSubMeasurementsTSDataTypeList().get(seriesIndex);
+            alignedPath.getMeasurementSchema().getSubMeasurementsTSDataTypeList().get(seriesIndex);
         if (!judgeCanUseStatistics(descriptor.getAggregationType(), seriesDataType)) {
           canUseStatistics = false;
         }
@@ -653,23 +701,21 @@ public Operator visitAlignedSeriesAggregationScan(
       }
     }
 
-    GroupByTimeParameter groupByTimeParameter = node.getGroupByTimeParameter();
     ITimeRangeIterator timeRangeIterator =
         initTimeRangeIterator(groupByTimeParameter, ascending, true);
     long maxReturnSize =
         AggregationUtil.calculateMaxAggregationResultSize(
-            node.getAggregationDescriptorList(), timeRangeIterator, context.getTypeProvider());
+            aggregationDescriptorList, timeRangeIterator, context.getTypeProvider());
 
     SeriesScanOptions.Builder scanOptionsBuilder = getSeriesScanOptionsBuilder(context);
-    scanOptionsBuilder.withAllSensors(new HashSet<>(seriesPath.getMeasurementList()));
+    scanOptionsBuilder.withAllSensors(new HashSet<>(alignedPath.getMeasurementList()));
 
-    Expression pushDownPredicate = node.getPushDownPredicate();
     if (pushDownPredicate != null) {
       checkArgument(PredicateUtils.predicateCanPushIntoScan(pushDownPredicate));
       scanOptionsBuilder.withPushDownFilter(
           convertPredicateToFilter(
               pushDownPredicate,
-              node.getAlignedPath().getMeasurementList(),
+              alignedPath.getMeasurementList(),
               context.getTypeProvider().getTemplatedInfo() != null,
               context.getTypeProvider(),
               context.getZoneId()));
@@ -680,14 +726,14 @@ public Operator visitAlignedSeriesAggregationScan(
             .getDriverContext()
             .addOperatorContext(
                 context.getNextOperatorId(),
-                node.getPlanNodeId(),
+                planNodeId,
                 AlignedSeriesAggregationScanOperator.class.getSimpleName());
     AlignedSeriesAggregationScanOperator seriesAggregationScanOperator =
         new AlignedSeriesAggregationScanOperator(
-            node.getPlanNodeId(),
-            seriesPath,
-            node.getScanOrder(),
-            node.isOutputEndTime(),
+            planNodeId,
+            alignedPath,
+            scanOrder,
+            outputEndTime,
             scanOptionsBuilder.build(),
             operatorContext,
             aggregators,
@@ -698,7 +744,7 @@ public Operator visitAlignedSeriesAggregationScan(
 
     ((DataDriverContext) context.getDriverContext())
         .addSourceOperator(seriesAggregationScanOperator);
-    ((DataDriverContext) context.getDriverContext()).addPath(seriesPath);
+    ((DataDriverContext) context.getDriverContext()).addPath(alignedPath);
     context.getDriverContext().setInputDriver(true);
     return seriesAggregationScanOperator;
   }
@@ -967,7 +1013,10 @@ public Operator visitSingleDeviceView(
                 node.getPlanNodeId(),
                 SingleDeviceViewOperator.class.getSimpleName());
     Operator child = node.getChild().accept(this, context);
-    List<Integer> deviceColumnIndex = node.getDeviceToMeasurementIndexes();
+    List<Integer> deviceColumnIndex =
+        context.getTemplatedInfo() != null
+            ? context.getTemplatedInfo().getDeviceToMeasurementIndexes()
+            : node.getDeviceToMeasurementIndexes();
     List<TSDataType> outputColumnTypes =
         node.isCacheOutputColumnNames()
             ? getOutputColumnTypes(node, context.getTypeProvider())
@@ -989,10 +1038,18 @@ public Operator visitDeviceView(DeviceViewNode node, LocalExecutionPlanContext c
                 node.getPlanNodeId(),
                 DeviceViewOperator.class.getSimpleName());
     List<Operator> children = dealWithConsumeChildrenOneByOneNode(node, context);
-    List<List<Integer>> deviceColumnIndex =
-        node.getDevices().stream()
-            .map(deviceName -> node.getDeviceToMeasurementIndexesMap().get(deviceName))
-            .collect(Collectors.toList());
+    List<List<Integer>> deviceColumnIndex = new ArrayList<>(node.getDevices().size());
+    if (context.getTemplatedInfo() != null) {
+      for (int i = 0; i < node.getDevices().size(); i++) {
+        deviceColumnIndex.add(context.getTemplatedInfo().getDeviceToMeasurementIndexes());
+      }
+    } else {
+      deviceColumnIndex =
+          node.getDevices().stream()
+              .map(deviceName -> node.getDeviceToMeasurementIndexesMap().get(deviceName))
+              .collect(Collectors.toList());
+    }
+
     List<TSDataType> outputColumnTypes = getOutputColumnTypes(node, context.getTypeProvider());
 
     return new DeviceViewOperator(
@@ -1344,7 +1401,12 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
     final Map<NodeRef<Expression>, TSDataType> expressionTypes = new HashMap<>();
 
     for (Expression projectExpression : projectExpressions) {
-      ExpressionTypeAnalyzer.analyzeExpression(expressionTypes, projectExpression);
+      if (context.isBuildPlanUseTemplate()) {
+        ExpressionTypeAnalyzer.analyzeExpressionUsingTemplatedInfo(
+            expressionTypes, projectExpression, context.getTemplatedInfo());
+      } else {
+        ExpressionTypeAnalyzer.analyzeExpression(expressionTypes, projectExpression);
+      }
     }
 
     boolean hasNonMappableUDF = false;
@@ -1409,7 +1471,7 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
           node.isKeepNull(),
           context.getZoneId(),
           expressionTypes,
-          node.getScanOrder() == Ordering.ASC);
+          node.getScanOrder() == ASC);
     } catch (QueryProcessException e) {
       throw new RuntimeException(e);
     }
@@ -1417,25 +1479,32 @@ public Operator visitTransform(TransformNode node, LocalExecutionPlanContext con
 
   @Override
   public Operator visitFilter(FilterNode node, LocalExecutionPlanContext context) {
-    if (context.isBuildPlanUseTemplate()) {
+    if (context.isBuildPlanUseTemplate() && node.isFromWhere()) {
       TemplatedInfo templatedInfo = context.getTemplatedInfo();
       return constructFilterOperator(
           node.getPredicate(),
           generateOnlyChildOperator(node, context),
           templatedInfo.getProjectExpressions(),
           templatedInfo.getDataTypes(),
-          templatedInfo.getLayoutMap(),
+          templatedInfo.getFilterLayoutMap(),
           templatedInfo.isKeepNull(),
           node.getPlanNodeId(),
           templatedInfo.getScanOrder(),
           context);
     }
 
+    // 1. not use template
+    // 2. use template but the FilterNode is not generated by FilterNode
+    // the inputDataTypes should be generated by the outputColumns of children
     return constructFilterOperator(
         node.getPredicate(),
         generateOnlyChildOperator(node, context),
         node.getOutputExpressions(),
-        getInputColumnTypes(node, context.getTypeProvider()),
+        node.getChildren().stream()
+            .map(PlanNode::getOutputColumnNames)
+            .flatMap(List::stream)
+            .map(context.getTypeProvider()::getType)
+            .collect(Collectors.toList()),
         makeLayout(node),
         node.isKeepNull(),
         node.getPlanNodeId(),
@@ -1589,7 +1658,7 @@ private Operator constructFilterOperator(
           isKeepNull,
           context.getZoneId(),
           expressionTypes,
-          scanOrder == Ordering.ASC);
+          scanOrder == ASC);
     } catch (QueryProcessException e) {
       throw new RuntimeException(e);
     }
@@ -1601,7 +1670,7 @@ public Operator visitGroupByLevel(GroupByLevelNode node, LocalExecutionPlanConte
         !node.getGroupByLevelDescriptors().isEmpty(),
         "GroupByLevel descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<CrossSeriesAggregationDescriptor> aggregationDescriptors =
@@ -1658,7 +1727,7 @@ public Operator visitGroupByTag(GroupByTagNode node, LocalExecutionPlanContext c
 
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
 
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<List<String>> groups = new ArrayList<>();
     List<List<Aggregator>> groupedAggregators = new ArrayList<>();
@@ -1731,19 +1800,30 @@ public Operator visitSlidingWindowAggregation(
                 node.getPlanNodeId(),
                 SlidingWindowAggregationOperator.class.getSimpleName());
     Operator child = node.getChild().accept(this, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : aggregationDescriptors) {
       List<InputLocation[]> inputLocationList = calcInputLocationList(descriptor, layout);
+      List<TSDataType> dataTypes = new ArrayList<>();
+      for (Expression expression : descriptor.getInputExpressions()) {
+        if (context.isBuildPlanUseTemplate() && expression instanceof TimeSeriesOperand) {
+          dataTypes.add(
+              context
+                  .getTemplatedInfo()
+                  .getSchemaMap()
+                  .get(expression.getExpressionString())
+                  .getType());
+        } else {
+          dataTypes.add(context.getTypeProvider().getType(expression.getExpressionString()));
+        }
+      }
       aggregators.add(
           SlidingWindowAggregatorFactory.createSlidingWindowAggregator(
               descriptor.getAggregationFuncName(),
               descriptor.getAggregationType(),
-              descriptor.getInputExpressions().stream()
-                  .map(x -> context.getTypeProvider().getType(x.getExpressionString()))
-                  .collect(Collectors.toList()),
+              dataTypes,
               descriptor.getInputExpressions(),
               descriptor.getInputAttributes(),
               ascending,
@@ -1800,13 +1880,25 @@ public Operator visitOffset(OffsetNode node, LocalExecutionPlanContext context)
   @Override
   public Operator visitRawDataAggregation(
       RawDataAggregationNode node, LocalExecutionPlanContext context) {
+    Map<String, List<InputLocation>> layout;
+    if (context.isBuildPlanUseTemplate()) {
+      layout = context.getTemplatedInfo().getFilterLayoutMap();
+    } else {
+      layout = makeLayout(node);
+    }
+    return createRawDataAggregationOperator(node, context, layout);
+  }
+
+  private RawDataAggregationOperator createRawDataAggregationOperator(
+      RawDataAggregationNode node,
+      LocalExecutionPlanContext context,
+      Map<String, List<InputLocation>> layout) {
     checkArgument(
         !node.getAggregationDescriptorList().isEmpty(),
         "Aggregation descriptorList cannot be empty");
     Operator child = node.getChild().accept(this, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
-    Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
     for (AggregationDescriptor descriptor : node.getAggregationDescriptorList()) {
       List<InputLocation[]> inputLocationList = calcInputLocationList(descriptor, layout);
@@ -1930,7 +2022,7 @@ public Operator visitAggregation(AggregationNode node, LocalExecutionPlanContext
         !node.getAggregationDescriptorList().isEmpty(),
         "Aggregation descriptorList cannot be empty");
     List<Operator> children = dealWithConsumeAllChildrenPipelineBreaker(node, context);
-    boolean ascending = node.getScanOrder() == Ordering.ASC;
+    boolean ascending = node.getScanOrder() == ASC;
     List<Aggregator> aggregators = new ArrayList<>();
     Map<String, List<InputLocation>> layout = makeLayout(node);
     List<AggregationDescriptor> aggregationDescriptors = node.getAggregationDescriptorList();
@@ -2213,7 +2305,7 @@ public Operator visitFullOuterTimeJoin(
                 node.getPlanNodeId(),
                 FullOuterTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<OutputColumn> outputColumns = generateOutputColumnsFromChildren(node);
     List<ColumnMerger> mergers = createColumnMergers(outputColumns, timeComparator);
     List<TSDataType> outputColumnTypes =
@@ -2243,7 +2335,7 @@ public Operator visitInnerTimeJoin(InnerTimeJoinNode node, LocalExecutionPlanCon
                 node.getPlanNodeId(),
                 InnerTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<TSDataType> outputColumnTypes =
         context.getTypeProvider().getTemplatedInfo() != null
             ? getOutputColumnTypesOfTimeJoinNode(node)
@@ -2297,7 +2389,7 @@ public Operator visitLeftOuterTimeJoin(
                 node.getPlanNodeId(),
                 LeftOuterTimeJoinOperator.class.getSimpleName());
     TimeComparator timeComparator =
-        node.getMergeOrder() == Ordering.ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
+        node.getMergeOrder() == ASC ? ASC_TIME_COMPARATOR : DESC_TIME_COMPARATOR;
     List<TSDataType> outputColumnTypes =
         context.getTypeProvider().getTemplatedInfo() != null
             ? getOutputColumnTypesOfTimeJoinNode(node)
@@ -2804,9 +2896,7 @@ public Operator visitLastQuery(LastQueryNode node, LocalExecutionPlanContext con
     } else {
       // order by timeseries
       Comparator<Binary> comparator =
-          node.getTimeseriesOrdering() == Ordering.ASC
-              ? ASC_BINARY_COMPARATOR
-              : DESC_BINARY_COMPARATOR;
+          node.getTimeseriesOrdering() == ASC ? ASC_BINARY_COMPARATOR : DESC_BINARY_COMPARATOR;
       // sort values from last cache
       if (initSize > 0) {
         cachedLastValueAndPathList.sort(Comparator.comparing(Pair::getRight, comparator));
@@ -2850,7 +2940,7 @@ public Operator visitLastQueryMerge(LastQueryMergeNode node, LocalExecutionPlanC
 
     Ordering timeseriesOrdering = node.getTimeseriesOrdering();
     Comparator<Binary> comparator =
-        (timeseriesOrdering == null || timeseriesOrdering == Ordering.ASC)
+        (timeseriesOrdering == null || timeseriesOrdering == ASC)
             ? ASC_BINARY_COMPARATOR
             : DESC_BINARY_COMPARATOR;
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
index b8efa1e3b3d2..34d48ea8a72b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/SubPlanTypeExtractor.java
@@ -85,6 +85,13 @@ public Void visitSeriesAggregationScan(SeriesAggregationScanNode node, Void cont
     @Override
     public Void visitAlignedSeriesAggregationScan(
         AlignedSeriesAggregationScanNode node, Void context) {
+      // if TemplateInfo is not empty, all type infos used by AlignedSeriesAggregationScanNode have
+      // been stored
+      // in TemplateInfo
+      if (typeProvider.getTemplatedInfo() != null) {
+        return null;
+      }
+
       AlignedPath alignedPath = node.getAlignedPath();
       for (int i = 0; i < alignedPath.getColumnNum(); i++) {
         String sourcePath = alignedPath.getPathWithMeasurement(i).getFullPath();
@@ -168,6 +175,7 @@ public Void visitSingleDeviceView(SingleDeviceViewNode node, Void context) {
       if (typeProvider.getTemplatedInfo() != null) {
         return null;
       }
+
       return visitPlan(node, context);
     }
 
@@ -178,6 +186,7 @@ public Void visitFilter(FilterNode node, Void context) {
       if (typeProvider.getTemplatedInfo() != null) {
         return null;
       }
+
       return visitPlan(node, context);
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
index 75222efb6fc9..fbb10954e2f5 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlan.java
@@ -25,13 +25,20 @@
 import org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.queryengine.plan.expression.multi.FunctionExpression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.InputLocation;
 import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
+import org.apache.iotdb.db.utils.SchemaUtils;
 
+import org.apache.commons.lang3.Validate;
+import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -39,9 +46,14 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.DEVICE;
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.ENDTIME;
+import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.END_TIME_EXPRESSION;
 import static org.apache.iotdb.db.queryengine.plan.analyze.ExpressionAnalyzer.searchSourceExpressions;
 import static org.apache.iotdb.db.queryengine.plan.analyze.TemplatedInfo.makeLayout;
+import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanBuilder.updateTypeProviderByPartialAggregation;
 import static org.apache.iotdb.db.queryengine.plan.planner.LogicalPlanVisitor.pushDownLimitToScanNode;
+import static org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.AggregationNode.getDeduplicatedDescriptors;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -70,6 +82,8 @@ public class TemplatedLogicalPlan {
 
   private Map<String, List<InputLocation>> filterLayoutMap;
 
+  List<AggregationDescriptor> aggregationDescriptorList;
+
   public TemplatedLogicalPlan(
       Analysis analysis, QueryStatement queryStatement, MPPQueryContext context) {
     this.analysis = analysis;
@@ -85,11 +99,84 @@ public TemplatedLogicalPlan(
 
     this.whereExpression = analysis.getWhereExpression();
 
-    // for align by device query with template, most used variables are same
-    initCommonVariables();
+    // for align by device query with template, store common variables for once
+    if (queryStatement.isAggregationQuery()) {
+      initAggQueryCommonVariables();
+    } else {
+      initNonAggQueryCommonVariables();
+    }
+  }
+
+  private void initAggQueryCommonVariables() {
+    if (whereExpression != null) {
+      newMeasurementList = new ArrayList<>(measurementList);
+      newSchemaList = new ArrayList<>(schemaList);
+      Set<String> selectMeasurements = new HashSet<>(measurementList);
+      List<Expression> whereSourceExpressions = searchSourceExpressions(whereExpression);
+      for (Expression expression : whereSourceExpressions) {
+        if (expression instanceof TimeSeriesOperand) {
+          String measurement = ((TimeSeriesOperand) expression).getPath().getMeasurement();
+          if (!analysis.getDeviceTemplate().getSchemaMap().containsKey(measurement)) {
+            continue;
+          }
+          if (!selectMeasurements.contains(measurement)) {
+            newMeasurementList.add(measurement);
+            newSchemaList.add(analysis.getDeviceTemplate().getSchema(measurement));
+          }
+        }
+      }
+
+      filterLayoutMap = makeLayout(newMeasurementList);
+
+      analysis
+          .getExpressionTypes()
+          .forEach(
+              (key, value) ->
+                  context.getTypeProvider().setType(key.getNode().getOutputSymbol(), value));
+    }
+
+    if (queryStatement.isOutputEndTime()) {
+      context.getTypeProvider().setType(END_TIME_EXPRESSION.getOutputSymbol(), TSDataType.INT64);
+    }
+    if (queryStatement.isCountTimeAggregation()) {
+      context.getTypeProvider().setType("count_time(*)", TSDataType.INT64);
+      context.getTypeProvider().setType("count_time(Time)", TSDataType.INT64);
+    }
+
+    List<Integer> deviceToMeasurementIndexes =
+        new ArrayList<>(analysis.getAggregationExpressions().size());
+    for (int i = 1; i <= analysis.getAggregationExpressions().size(); i++) {
+      deviceToMeasurementIndexes.add(i);
+    }
+
+    context
+        .getTypeProvider()
+        .setTemplatedInfo(
+            new TemplatedInfo(
+                newMeasurementList,
+                newSchemaList,
+                newSchemaList.stream()
+                    .map(IMeasurementSchema::getType)
+                    .collect(Collectors.toList()),
+                queryStatement.getResultTimeOrder(),
+                analysis.isLastLevelUseWildcard(),
+                analysis.getDeviceViewOutputExpressions().stream()
+                    .map(Expression::getExpressionString)
+                    .collect(Collectors.toList()),
+                deviceToMeasurementIndexes,
+                OFFSET_VALUE,
+                limitValue,
+                whereExpression,
+                queryStatement.isGroupByTime(),
+                analysis.getDeviceTemplate().getSchemaMap(),
+                filterLayoutMap,
+                null,
+                true,
+                analysis.getGroupByTimeParameter(),
+                queryStatement.isOutputEndTime()));
   }
 
-  private void initCommonVariables() {
+  private void initNonAggQueryCommonVariables() {
     if (whereExpression != null) {
       if (!analysis.isTemplateWildCardQuery()) {
         newMeasurementList = new ArrayList<>(measurementList);
@@ -120,6 +207,12 @@ private void initCommonVariables() {
                   context.getTypeProvider().setType(key.getNode().getOutputSymbol(), value));
     }
 
+    List<Integer> deviceToMeasurementIndexes =
+        new ArrayList<>(analysis.getSelectExpressions().size() - 1);
+    for (int i = 1; i < analysis.getSelectExpressions().size(); i++) {
+      deviceToMeasurementIndexes.add(i);
+    }
+
     context
         .getTypeProvider()
         .setTemplatedInfo(
@@ -134,17 +227,24 @@ private void initCommonVariables() {
                 analysis.getDeviceViewOutputExpressions().stream()
                     .map(Expression::getExpressionString)
                     .collect(Collectors.toList()),
-                analysis.getDeviceViewInputIndexesMap().values().iterator().next(),
+                deviceToMeasurementIndexes,
                 OFFSET_VALUE,
                 limitValue,
                 whereExpression,
                 queryStatement.isGroupByTime(),
                 analysis.getDeviceTemplate().getSchemaMap(),
                 filterLayoutMap,
-                null));
+                null,
+                false,
+                analysis.getGroupByTimeParameter(),
+                queryStatement.isOutputEndTime()));
   }
 
   public PlanNode visitQuery() {
+    if (queryStatement.isAggregationQuery()) {
+      return visitAggregation();
+    }
+
     LogicalPlanBuilder planBuilder =
         new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
 
@@ -213,4 +313,151 @@ public PlanNode visitQueryBody(PartialPath devicePath) {
 
     return planBuilder.getRoot();
   }
+
+  // ============== Methods below are used for templated aggregation ======================
+
+  private PlanNode visitAggregation() {
+    // group by level and group by tag is not allowed in align by device
+    boolean outputPartial =
+        queryStatement.isGroupByTime() && analysis.getGroupByTimeParameter().hasOverlap();
+    AggregationStep curStep = outputPartial ? AggregationStep.PARTIAL : AggregationStep.SINGLE;
+    aggregationDescriptorList =
+        constructAggregationDescriptorList(analysis.getAggregationExpressions(), curStep);
+    updateTypeProvider(analysis.getAggregationExpressions());
+    if (curStep.isOutputPartial()) {
+      aggregationDescriptorList.forEach(
+          aggregationDescriptor ->
+              updateTypeProviderByPartialAggregation(
+                  aggregationDescriptor, context.getTypeProvider()));
+    }
+
+    LogicalPlanBuilder templatedPlanBuilder =
+        new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList);
+    Map<String, PlanNode> deviceToSubPlanMap = new LinkedHashMap<>();
+    aggregationDescriptorList = getDeduplicatedDescriptors(aggregationDescriptorList);
+
+    boolean needCheckAscending = queryStatement.isGroupByTime();
+    List<AggregationDescriptor> ascendingDescriptors = new ArrayList<>();
+    List<AggregationDescriptor> descendingDescriptors = new ArrayList<>();
+    for (AggregationDescriptor aggregationDescriptor : aggregationDescriptorList) {
+      if (needCheckAscending
+          || SchemaUtils.isConsistentWithScanOrder(
+              aggregationDescriptor.getAggregationType(), queryStatement.getResultTimeOrder())) {
+        ascendingDescriptors.add(aggregationDescriptor);
+      } else {
+        descendingDescriptors.add(aggregationDescriptor);
+      }
+    }
+    context.getTypeProvider().getTemplatedInfo().setAscendingDescriptorList(ascendingDescriptors);
+    context.getTypeProvider().getTemplatedInfo().setDescendingDescriptorList(descendingDescriptors);
+
+    for (PartialPath devicePath : analysis.getDeviceList()) {
+      String deviceName = devicePath.getFullPath();
+      PlanNode rootNode = visitDeviceAggregationBody(devicePath);
+
+      LogicalPlanBuilder subPlanBuilder =
+          new TemplatedLogicalPlanBuilder(analysis, context, measurementList, schemaList)
+              .withNewRoot(rootNode);
+
+      deviceToSubPlanMap.put(deviceName, subPlanBuilder.getRoot());
+    }
+
+    templatedPlanBuilder =
+        templatedPlanBuilder
+            .planDeviceView(
+                deviceToSubPlanMap,
+                analysis.getDeviceViewOutputExpressions(),
+                null,
+                analysis.getSelectExpressions(),
+                queryStatement,
+                analysis)
+            .planHavingAndTransform(
+                analysis.getHavingExpression(),
+                analysis.getSelectExpressions(),
+                analysis.getOrderByExpressions(),
+                queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder());
+
+    if (!queryStatement.needPushDownSort()) {
+      templatedPlanBuilder = templatedPlanBuilder.planOrderBy(queryStatement, analysis);
+    }
+
+    templatedPlanBuilder =
+        templatedPlanBuilder
+            .planFill(analysis.getFillDescriptor(), queryStatement.getResultTimeOrder())
+            .planOffset(queryStatement.getRowOffset());
+
+    if (!analysis.isUseTopKNode() || queryStatement.hasOffset()) {
+      templatedPlanBuilder = templatedPlanBuilder.planLimit(queryStatement.getRowLimit());
+    }
+
+    return templatedPlanBuilder.getRoot();
+  }
+
+  private PlanNode visitDeviceAggregationBody(PartialPath devicePath) {
+    TemplatedLogicalPlanBuilder templatedPlanBuilder =
+        new TemplatedLogicalPlanBuilder(analysis, context, newMeasurementList, newSchemaList);
+
+    templatedPlanBuilder =
+        templatedPlanBuilder
+            .planRawDataSource(
+                devicePath,
+                queryStatement.getResultTimeOrder(),
+                OFFSET_VALUE,
+                limitValue,
+                analysis.isLastLevelUseWildcard())
+            .planFilter(
+                whereExpression,
+                queryStatement.isGroupByTime(),
+                queryStatement.getResultTimeOrder())
+            .planRawDataAggregation(
+                analysis.getAggregationExpressions(),
+                null,
+                analysis.getGroupByTimeParameter(),
+                analysis.getGroupByParameter(),
+                queryStatement.isOutputEndTime(),
+                queryStatement.getResultTimeOrder(),
+                aggregationDescriptorList)
+            .planSlidingWindowAggregation(
+                queryStatement,
+                analysis.getAggregationExpressions(),
+                analysis.getGroupByTimeParameter(),
+                queryStatement.getResultTimeOrder());
+
+    return templatedPlanBuilder.getRoot();
+  }
+
+  private List<AggregationDescriptor> constructAggregationDescriptorList(
+      Set<Expression> aggregationExpressions, AggregationStep curStep) {
+    return aggregationExpressions.stream()
+        .map(
+            expression -> {
+              Validate.isTrue(expression instanceof FunctionExpression);
+              return new AggregationDescriptor(
+                  ((FunctionExpression) expression).getFunctionName(),
+                  curStep,
+                  expression.getExpressions(),
+                  ((FunctionExpression) expression).getFunctionAttributes());
+            })
+        .collect(Collectors.toList());
+  }
+
+  void updateTypeProvider(Collection<Expression> expressions) {
+    if (expressions == null) {
+      return;
+    }
+    expressions.forEach(
+        expression -> {
+          if (!expression.getExpressionString().equals(DEVICE)
+              && !expression.getExpressionString().equals(ENDTIME)) {
+            context
+                .getTypeProvider()
+                .setType(expression.getExpressionString(), getPreAnalyzedType(expression));
+          }
+        });
+  }
+
+  private TSDataType getPreAnalyzedType(Expression expression) {
+    return analysis.getType(expression);
+  }
 }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
index b1107ae8fab2..e615a7600a9b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TemplatedLogicalPlanBuilder.java
@@ -27,14 +27,24 @@
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.FilterNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.RawDataAggregationNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.SeriesScanNode;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationDescriptor;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByParameter;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.GroupByTimeParameter;
 import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
+import org.apache.iotdb.db.queryengine.plan.statement.crud.QueryStatement;
 
 import org.apache.tsfile.write.schema.IMeasurementSchema;
 
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
+
+import static org.apache.iotdb.db.queryengine.common.header.ColumnHeaderConstant.DEVICE;
 
 /**
  * This class provides accelerated implementation for multiple devices align by device query. This
@@ -42,6 +52,7 @@
  * unnecessary judgements.
  */
 public class TemplatedLogicalPlanBuilder extends LogicalPlanBuilder {
+
   private final MPPQueryContext context;
 
   private final Analysis analysis;
@@ -121,7 +132,8 @@ public TemplatedLogicalPlanBuilder planFilter(
             null,
             filterExpression,
             isGroupByTime,
-            scanOrder);
+            scanOrder,
+            true);
     analysis.setFromWhere(filterNode);
 
     this.root = filterNode;
@@ -129,6 +141,61 @@ public TemplatedLogicalPlanBuilder planFilter(
     return this;
   }
 
+  // ===================== Methods below are used for aggregation =============================
+
+  public TemplatedLogicalPlanBuilder planRawDataAggregation(
+      Set<Expression> aggregationExpressions,
+      Expression groupByExpression,
+      GroupByTimeParameter groupByTimeParameter,
+      GroupByParameter groupByParameter,
+      boolean outputEndTime,
+      Ordering scanOrder,
+      List<AggregationDescriptor> deduplicatedAggregationDescriptorList) {
+    if (aggregationExpressions == null) {
+      return this;
+    }
+
+    this.root =
+        new RawDataAggregationNode(
+            context.getQueryId().genPlanNodeId(),
+            this.getRoot(),
+            deduplicatedAggregationDescriptorList,
+            groupByTimeParameter,
+            groupByParameter,
+            groupByExpression,
+            outputEndTime,
+            scanOrder,
+            true);
+    return this;
+  }
+
+  public TemplatedLogicalPlanBuilder planSlidingWindowAggregation(
+      QueryStatement queryStatement,
+      Set<Expression> aggregationExpressions,
+      GroupByTimeParameter groupByTimeParameter,
+      Ordering scanOrder) {
+    if (!queryStatement.isGroupByTime() || !analysis.getGroupByTimeParameter().hasOverlap()) {
+      return this;
+    }
+
+    LinkedHashSet<Expression> slidingWindowsExpressions = new LinkedHashSet<>();
+    aggregationExpressions.forEach(
+        expression -> {
+          if (!DEVICE.equalsIgnoreCase(expression.getOutputSymbol())) {
+            slidingWindowsExpressions.add(expression);
+          }
+        });
+    this.root =
+        createSlidingWindowAggregationNode(
+            this.getRoot(),
+            slidingWindowsExpressions,
+            groupByTimeParameter,
+            AggregationStep.FINAL,
+            scanOrder);
+
+    return this;
+  }
+
   @Override
   public TemplatedLogicalPlanBuilder withNewRoot(PlanNode newRoot) {
     this.root = newRoot;
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
index 755119b26075..c2ca7011039c 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/DistributionPlanner.java
@@ -210,6 +210,7 @@ public DistributedQueryPlan planFragments() {
     // Mark the root Fragment of root SubPlan as `root`
     subPlan.getPlanFragment().setRoot(true);
     List<FragmentInstance> fragmentInstances = planFragmentInstances(subPlan);
+
     // Only execute this step for READ operation
     if (context.getQueryType() == QueryType.READ) {
       setSinkForRootInstance(subPlan, fragmentInstances);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
index 4276cba4290d..3b32f2932cb6 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/PlanFragment.java
@@ -27,6 +27,7 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.IPartitionRelatedNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
+import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesAggregationScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.AlignedSeriesScanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.VirtualSourceNode;
 
@@ -152,7 +153,7 @@ public void serialize(DataOutputStream stream) throws IOException {
     } else {
       ReadWriteIOUtils.write((byte) 1, stream);
 
-      // templated device, the serialized attribute basically same,
+      // templated align by device query, the serialized attributes are same,
       // so there is no need to serialize all the SeriesScanNode repeated
       if (typeProvider.getTemplatedInfo() != null) {
         typeProvider.serialize(stream);
@@ -183,7 +184,8 @@ public static PlanNode deserializeHelper(ByteBuffer byteBuffer, TypeProvider typ
     PlanNode root;
     if (typeProvider != null && typeProvider.getTemplatedInfo() != null) {
       root = PlanNodeType.deserializeWithTemplate(byteBuffer, typeProvider);
-      if (root instanceof AlignedSeriesScanNode) {
+      if (root instanceof AlignedSeriesScanNode
+          || root instanceof AlignedSeriesAggregationScanNode) {
         return root;
       }
     } else {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
index 09fe6c92960b..730edb747b78 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanGraphPrinter.java
@@ -452,7 +452,7 @@ public List<String> visitProject(ProjectNode node, GraphContext context) {
     List<String> outputColumns = node.getOutputColumnNames();
     if (outputColumns == null) {
       checkArgument(context.getTemplatedInfo() != null);
-      outputColumns = context.getTemplatedInfo().getSelectMeasurements();
+      outputColumns = context.getTemplatedInfo().getDeviceViewOutputNames();
       // skip device column
       outputColumns = outputColumns.subList(1, outputColumns.size());
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
index 0fd420ce1bb2..2b5e665a755b 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/PlanNodeType.java
@@ -470,14 +470,18 @@ public static PlanNode deserialize(ByteBuffer buffer, short nodeType) {
   public static PlanNode deserializeWithTemplate(ByteBuffer buffer, TypeProvider typeProvider) {
     short nodeType = buffer.getShort();
     switch (nodeType) {
+      case 1:
+        return DeviceViewNode.deserializeUseTemplate(buffer, typeProvider);
       case 3:
         return FilterNode.deserializeUseTemplate(buffer, typeProvider);
+      case 32:
+        return ProjectNode.deserializeUseTemplate(buffer, typeProvider);
       case 33:
         return AlignedSeriesScanNode.deserializeUseTemplate(buffer, typeProvider);
+      case 34:
+        return AlignedSeriesAggregationScanNode.deserializeUseTemplate(buffer, typeProvider);
       case 65:
         return SingleDeviceViewNode.deserializeUseTemplate(buffer, typeProvider);
-      case 32:
-        return ProjectNode.deserializeUseTemplate(buffer, typeProvider);
       default:
         return deserialize(buffer, nodeType);
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
index b1f18c555a60..b6114e1f1272 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/DeviceViewNode.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.queryengine.plan.planner.plan.node.process;
 
+import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeType;
@@ -175,18 +176,21 @@ protected void serializeAttributes(DataOutputStream stream) throws IOException {
 
   public static DeviceViewNode deserialize(ByteBuffer byteBuffer) {
     OrderByParameter mergeOrderParameter = OrderByParameter.deserialize(byteBuffer);
+
     int columnSize = ReadWriteIOUtils.readInt(byteBuffer);
     List<String> outputColumnNames = new ArrayList<>();
     while (columnSize > 0) {
       outputColumnNames.add(ReadWriteIOUtils.readString(byteBuffer));
       columnSize--;
     }
+
     int devicesSize = ReadWriteIOUtils.readInt(byteBuffer);
     List<String> devices = new ArrayList<>();
     while (devicesSize > 0) {
       devices.add(ReadWriteIOUtils.readString(byteBuffer));
       devicesSize--;
     }
+
     int mapSize = ReadWriteIOUtils.readInt(byteBuffer);
     Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>(mapSize);
     while (mapSize > 0) {
@@ -205,6 +209,43 @@ public static DeviceViewNode deserialize(ByteBuffer byteBuffer) {
         planNodeId, mergeOrderParameter, outputColumnNames, devices, deviceToMeasurementIndexesMap);
   }
 
+  @Override
+  public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvider)
+      throws IOException {
+    PlanNodeType.DEVICE_VIEW.serialize(stream);
+    id.serialize(stream);
+    mergeOrderParameter.serializeAttributes(stream);
+    ReadWriteIOUtils.write(devices.size(), stream);
+    for (String deviceName : devices) {
+      ReadWriteIOUtils.write(deviceName, stream);
+    }
+
+    ReadWriteIOUtils.write(getChildren().size(), stream);
+    for (PlanNode planNode : getChildren()) {
+      planNode.serializeUseTemplate(stream, typeProvider);
+    }
+  }
+
+  public static DeviceViewNode deserializeUseTemplate(
+      ByteBuffer byteBuffer, TypeProvider typeProvider) {
+    PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
+    OrderByParameter mergeOrderParameter = OrderByParameter.deserialize(byteBuffer);
+
+    int devicesSize = ReadWriteIOUtils.readInt(byteBuffer);
+    List<String> devices = new ArrayList<>(devicesSize);
+    while (devicesSize > 0) {
+      devices.add(ReadWriteIOUtils.readString(byteBuffer));
+      devicesSize--;
+    }
+
+    return new DeviceViewNode(
+        planNodeId,
+        mergeOrderParameter,
+        typeProvider.getTemplatedInfo().getDeviceViewOutputNames(),
+        devices,
+        null);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
index f57466c98a0c..f121eec96f90 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/FilterNode.java
@@ -37,15 +37,21 @@ public class FilterNode extends TransformNode {
 
   private final Expression predicate;
 
+  // whether this node is generated by where clause
+  // fromWhere equals false, means it is generated by having clause
+  private final boolean fromWhere;
+
   public FilterNode(
       PlanNodeId id,
       PlanNode childPlanNode,
       Expression[] outputExpressions,
       Expression predicate,
       boolean keepNull,
-      Ordering scanOrder) {
+      Ordering scanOrder,
+      boolean fromWhere) {
     super(id, childPlanNode, outputExpressions, keepNull, scanOrder);
     this.predicate = predicate;
+    this.fromWhere = fromWhere;
   }
 
   /** This construction method is only used in inner of class `FilterNode`. */
@@ -54,9 +60,11 @@ public FilterNode(
       Expression[] outputExpressions,
       Expression predicate,
       boolean keepNull,
-      Ordering scanOrder) {
+      Ordering scanOrder,
+      boolean fromWhere) {
     super(id, outputExpressions, keepNull, scanOrder);
     this.predicate = predicate;
+    this.fromWhere = fromWhere;
   }
 
   @Override
@@ -71,7 +79,8 @@ public PlanNodeType getType() {
 
   @Override
   public PlanNode clone() {
-    return new FilterNode(getPlanNodeId(), outputExpressions, predicate, keepNull, scanOrder);
+    return new FilterNode(
+        getPlanNodeId(), outputExpressions, predicate, keepNull, scanOrder, fromWhere);
   }
 
   @Override
@@ -108,7 +117,7 @@ public static FilterNode deserialize(ByteBuffer byteBuffer) {
     boolean keepNull = ReadWriteIOUtils.readBool(byteBuffer);
     Ordering scanOrder = Ordering.values()[ReadWriteIOUtils.readInt(byteBuffer)];
     PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
-    return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder);
+    return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder, false);
   }
 
   @Override
@@ -116,6 +125,17 @@ public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvi
       throws IOException {
     PlanNodeType.FILTER.serialize(stream);
     id.serialize(stream);
+    ReadWriteIOUtils.write(fromWhere, stream);
+    // for FilterNode generated by having clause, it must be serialized totally
+    if (!fromWhere) {
+      ReadWriteIOUtils.write(outputExpressions.length, stream);
+      for (Expression expression : outputExpressions) {
+        Expression.serialize(expression, stream);
+      }
+      Expression.serialize(predicate, stream);
+      ReadWriteIOUtils.write(keepNull, stream);
+      ReadWriteIOUtils.write(scanOrder.ordinal(), stream);
+    }
     ReadWriteIOUtils.write(getChildren().size(), stream);
     for (PlanNode planNode : getChildren()) {
       planNode.serializeUseTemplate(stream, typeProvider);
@@ -125,13 +145,26 @@ public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvi
   public static FilterNode deserializeUseTemplate(
       ByteBuffer byteBuffer, TypeProvider typeProvider) {
     PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
-
-    return new FilterNode(
-        planNodeId,
-        null,
-        typeProvider.getTemplatedInfo().getPredicate(),
-        typeProvider.getTemplatedInfo().isKeepNull(),
-        typeProvider.getTemplatedInfo().getScanOrder());
+    boolean fromWhere = ReadWriteIOUtils.readBool(byteBuffer);
+    if (!fromWhere) {
+      int outputExpressionsLength = ReadWriteIOUtils.readInt(byteBuffer);
+      Expression[] outputExpressions = new Expression[outputExpressionsLength];
+      for (int i = 0; i < outputExpressionsLength; ++i) {
+        outputExpressions[i] = Expression.deserialize(byteBuffer);
+      }
+      Expression predicate = Expression.deserialize(byteBuffer);
+      boolean keepNull = ReadWriteIOUtils.readBool(byteBuffer);
+      Ordering scanOrder = Ordering.values()[ReadWriteIOUtils.readInt(byteBuffer)];
+      return new FilterNode(planNodeId, outputExpressions, predicate, keepNull, scanOrder, false);
+    } else {
+      return new FilterNode(
+          planNodeId,
+          null,
+          typeProvider.getTemplatedInfo().getPredicate(),
+          typeProvider.getTemplatedInfo().isKeepNull(),
+          typeProvider.getTemplatedInfo().getScanOrder(),
+          true);
+    }
   }
 
   public Expression getPredicate() {
@@ -142,6 +175,10 @@ public void setOutputExpressions(Expression[] outputExpressions) {
     this.outputExpressions = outputExpressions;
   }
 
+  public boolean isFromWhere() {
+    return fromWhere;
+  }
+
   @Override
   public String toString() {
     return "FilterNode-" + this.getPlanNodeId();
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
index 345d29770885..dafcbdb9409f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/RawDataAggregationNode.java
@@ -124,6 +124,26 @@ public RawDataAggregationNode(
     this.outputEndTime = outputEndTime;
   }
 
+  // to avoid the repeated invoking of getDeduplicatedDescriptors method
+  public RawDataAggregationNode(
+      PlanNodeId id,
+      PlanNode child,
+      List<AggregationDescriptor> deduplicatedAggregationDescriptorList,
+      @Nullable GroupByTimeParameter groupByTimeParameter,
+      @Nullable GroupByParameter groupByParameter,
+      Expression groupByExpression,
+      boolean outputEndTime,
+      Ordering scanOrder,
+      boolean useDeduplicatedDescriptors) {
+    super(id, child);
+    this.aggregationDescriptorList = deduplicatedAggregationDescriptorList;
+    this.scanOrder = scanOrder;
+    this.groupByParameter = groupByParameter;
+    this.groupByTimeParameter = groupByTimeParameter;
+    this.groupByExpression = groupByExpression;
+    this.outputEndTime = outputEndTime;
+  }
+
   public List<AggregationDescriptor> getAggregationDescriptorList() {
     return aggregationDescriptorList;
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
index c1b3898ed286..263223c5d5cd 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/process/SingleDeviceViewNode.java
@@ -190,7 +190,7 @@ public static SingleDeviceViewNode deserializeUseTemplate(
     return new SingleDeviceViewNode(
         planNodeId,
         cacheOutputColumnNames,
-        typeProvider.getTemplatedInfo().getSelectMeasurements(),
+        typeProvider.getTemplatedInfo().getDeviceViewOutputNames(),
         device,
         typeProvider.getTemplatedInfo().getDeviceToMeasurementIndexes());
   }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
index 68a284c018de..6e53f5d95d72 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/node/source/AlignedSeriesAggregationScanNode.java
@@ -24,6 +24,7 @@
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.path.PathDeserializeUtil;
 import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper;
+import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider;
 import org.apache.iotdb.db.queryengine.plan.expression.Expression;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeId;
@@ -58,6 +59,12 @@ public class AlignedSeriesAggregationScanNode extends SeriesAggregationSourceNod
   // The id of DataRegion where the node will run
   private TRegionReplicaSet regionReplicaSet;
 
+  // this variable is only used in aggregation align by device query, with all devices in one
+  // template,
+  // 0 represent ascending descriptors, 1 represent descending descriptors, 2 represent count_time
+  // descriptors
+  private byte descriptorType;
+
   public AlignedSeriesAggregationScanNode(
       PlanNodeId id,
       AlignedPath alignedPath,
@@ -100,7 +107,8 @@ public AlignedSeriesAggregationScanNode(
       boolean outputEndTime,
       @Nullable Expression pushDownPredicate,
       @Nullable GroupByTimeParameter groupByTimeParameter,
-      TRegionReplicaSet dataRegionReplicaSet) {
+      TRegionReplicaSet dataRegionReplicaSet,
+      byte descriptorType) {
     this(
         id,
         alignedPath,
@@ -110,6 +118,7 @@ public AlignedSeriesAggregationScanNode(
         groupByTimeParameter,
         dataRegionReplicaSet);
     setOutputEndTime(outputEndTime);
+    setDescriptorType(descriptorType);
   }
 
   public AlignedPath getAlignedPath() {
@@ -120,9 +129,12 @@ public void setAlignedPath(AlignedPath alignedPath) {
     this.alignedPath = alignedPath;
   }
 
-  @Override
-  public Ordering getScanOrder() {
-    return scanOrder;
+  public byte getDescriptorType() {
+    return this.descriptorType;
+  }
+
+  public void setDescriptorType(byte descriptorType) {
+    this.descriptorType = descriptorType;
   }
 
   @Override
@@ -176,7 +188,8 @@ public PlanNode clone() {
         isOutputEndTime(),
         getPushDownPredicate(),
         getGroupByTimeParameter(),
-        getRegionReplicaSet());
+        getRegionReplicaSet(),
+        getDescriptorType());
   }
 
   @Override
@@ -260,7 +273,52 @@ public static AlignedSeriesAggregationScanNode deserialize(ByteBuffer byteBuffer
         outputEndTime,
         pushDownPredicate,
         groupByTimeParameter,
-        null);
+        null,
+        (byte) 0);
+  }
+
+  @Override
+  public void serializeUseTemplate(DataOutputStream stream, TypeProvider typeProvider)
+      throws IOException {
+    PlanNodeType.ALIGNED_SERIES_AGGREGATE_SCAN.serialize(stream);
+    id.serialize(stream);
+    ReadWriteIOUtils.write(alignedPath.getNodes().length, stream);
+    for (String node : alignedPath.getNodes()) {
+      ReadWriteIOUtils.write(node, stream);
+    }
+    ReadWriteIOUtils.write(descriptorType, stream);
+  }
+
+  public static AlignedSeriesAggregationScanNode deserializeUseTemplate(
+      ByteBuffer byteBuffer, TypeProvider typeProvider) {
+    PlanNodeId planNodeId = PlanNodeId.deserialize(byteBuffer);
+
+    int nodeSize = ReadWriteIOUtils.readInt(byteBuffer);
+    String[] nodes = new String[nodeSize];
+    for (int i = 0; i < nodeSize; i++) {
+      nodes[i] = ReadWriteIOUtils.readString(byteBuffer);
+    }
+    AlignedPath alignedPath = new AlignedPath(new PartialPath(nodes));
+    alignedPath.setMeasurementList(typeProvider.getTemplatedInfo().getMeasurementList());
+    alignedPath.addSchemas(typeProvider.getTemplatedInfo().getSchemaList());
+    byte descriptorType = ReadWriteIOUtils.readByte(byteBuffer);
+    List<AggregationDescriptor> aggregationDescriptorList = null;
+    if (descriptorType == 0 || descriptorType == 2) {
+      aggregationDescriptorList = typeProvider.getTemplatedInfo().getAscendingDescriptorList();
+    } else if (descriptorType == 1) {
+      aggregationDescriptorList = typeProvider.getTemplatedInfo().getDescendingDescriptorList();
+    }
+
+    return new AlignedSeriesAggregationScanNode(
+        planNodeId,
+        alignedPath,
+        aggregationDescriptorList,
+        typeProvider.getTemplatedInfo().getScanOrder(),
+        typeProvider.getTemplatedInfo().isOutputEndTime(),
+        typeProvider.getTemplatedInfo().getPushDownPredicate(),
+        typeProvider.getTemplatedInfo().getGroupByTimeParameter(),
+        null,
+        descriptorType);
   }
 
   @Override
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
index d266de50aaad..c7758007d36e 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/parameter/AggregationDescriptor.java
@@ -265,7 +265,7 @@ public List<String> getInputExpressionsAsStringList() {
 
   protected String getInputString(List<Expression> expressions) {
     StringBuilder builder = new StringBuilder();
-    if (!(expressions.size() == 0)) {
+    if (!(expressions.isEmpty())) {
       builder.append(expressions.get(0).getExpressionString());
       for (int i = 1; i < expressions.size(); ++i) {
         builder.append(", ").append(expressions.get(i).getExpressionString());
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
index 0ca53b7b84c3..372b803d9547 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/optimization/TestPlanBuilder.java
@@ -365,7 +365,8 @@ public TestPlanBuilder filter(
             expressions.toArray(new Expression[0]),
             predicate,
             isGroupByTime,
-            Ordering.ASC);
+            Ordering.ASC,
+            true);
     return this;
   }
 
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
index adb25ea1a009..2a14c0cf3b2b 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/DataQueryLogicalPlannerTest.java
@@ -194,7 +194,8 @@ public void testRawDataQuery() {
             new Expression[] {new TimeSeriesOperand(schemaMap.get("root.sg.d2.s1"))},
             predicate,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     OffsetNode offsetNode = new OffsetNode(queryId.genPlanNodeId(), filterNode, 100);
     LimitNode limitNode = new LimitNode(queryId.genPlanNodeId(), offsetNode, 100);
@@ -249,7 +250,8 @@ public void testRawDataQueryAlignByDevice() {
             },
             predicate1,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     List<PlanNode> sourceNodeList2 = new ArrayList<>();
     sourceNodeList2.add(
@@ -287,7 +289,8 @@ public void testRawDataQueryAlignByDevice() {
             },
             predicate2,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     Map<String, List<Integer>> deviceToMeasurementIndexesMap = new HashMap<>();
     deviceToMeasurementIndexesMap.put("root.sg.d1", Arrays.asList(1, 2, 3));
@@ -742,7 +745,8 @@ public void testAggregationQueryWithValueFilter() {
             },
             predicate,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode =
         new RawDataAggregationNode(
@@ -867,7 +871,8 @@ public void testAggregationQueryWithValueFilterAlignByDevice() {
             },
             predicate1,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode1 =
         new RawDataAggregationNode(
@@ -922,7 +927,8 @@ public void testAggregationQueryWithValueFilterAlignByDevice() {
             },
             predicate2,
             false,
-            Ordering.DESC);
+            Ordering.DESC,
+            true);
 
     RawDataAggregationNode aggregationNode2 =
         new RawDataAggregationNode(
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
index ad5e28f27b38..998df88719b4 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/node/process/FilterNodeSerdeTest.java
@@ -52,7 +52,8 @@ public void testSerializeAndDeserialize() throws IllegalPathException {
                 new TimeSeriesOperand(new PartialPath("root.sg.d1.s1")),
                 new ConstantOperand(TSDataType.INT64, "100")),
             false,
-            Ordering.ASC);
+            Ordering.ASC,
+            true);
 
     ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
     filterNode.serialize(byteBuffer);