it = new MockDataSource("tb" + this.taskId, tableCount);
+ try {
+ while (it.hasNext() && active) {
+ String line = it.next();
+ int queueId = getQueueId(line);
+ taskQueues.get(queueId).put(line);
+ }
+ } catch (Exception e) {
+ logger.error("Read Task Error", e);
+ }
+ }
+
+ public void stop() {
+ logger.info("stop");
+ this.active = false;
+ }
+}
\ No newline at end of file
diff --git a/docs/examples/java/src/main/java/com/taos/example/highvolume/SQLWriter.java b/docs/examples/java/src/main/java/com/taos/example/highvolume/SQLWriter.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2989acdbe3d0f56d7451ac86051a55955ce14de
--- /dev/null
+++ b/docs/examples/java/src/main/java/com/taos/example/highvolume/SQLWriter.java
@@ -0,0 +1,205 @@
+package com.taos.example.highvolume;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.*;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A helper class encapsulate the logic of writing using SQL.
+ *
+ * The main interfaces are two methods:
+ *
+ * - {@link SQLWriter#processLine}, which receive raw lines from WriteTask and group them by table names.
+ * - {@link SQLWriter#flush}, which assemble INSERT statement and execute it.
+ *
+ *
+ * There is a technical skill worth mentioning: we create table as needed when "table does not exist" error occur instead of creating table automatically using syntax "INSET INTO tb USING stb".
+ * This ensure that checking table existence is a one-time-only operation.
+ *
+ *
+ *
+ */
+public class SQLWriter {
+ final static Logger logger = LoggerFactory.getLogger(SQLWriter.class);
+
+ private Connection conn;
+ private Statement stmt;
+
+ /**
+ * current number of buffered records
+ */
+ private int bufferedCount = 0;
+ /**
+ * Maximum number of buffered records.
+ * Flush action will be triggered if bufferedCount reached this value,
+ */
+ private int maxBatchSize;
+
+
+ /**
+ * Maximum SQL length.
+ */
+ private int maxSQLLength;
+
+ /**
+ * Map from table name to column values. For example:
+ * "tb001" -> "(1648432611249,2.1,114,0.09) (1648432611250,2.2,135,0.2)"
+ */
+ private Map tbValues = new HashMap<>();
+
+ /**
+ * Map from table name to tag values in the same order as creating stable.
+ * Used for creating table.
+ */
+ private Map tbTags = new HashMap<>();
+
+ public SQLWriter(int maxBatchSize) {
+ this.maxBatchSize = maxBatchSize;
+ }
+
+
+ /**
+ * Get Database Connection
+ *
+ * @return Connection
+ * @throws SQLException
+ */
+ private static Connection getConnection() throws SQLException {
+ String jdbcURL = System.getenv("TDENGINE_JDBC_URL");
+ return DriverManager.getConnection(jdbcURL);
+ }
+
+ /**
+ * Create Connection and Statement
+ *
+ * @throws SQLException
+ */
+ public void init() throws SQLException {
+ conn = getConnection();
+ stmt = conn.createStatement();
+ stmt.execute("use test");
+ ResultSet rs = stmt.executeQuery("show variables");
+ while (rs.next()) {
+ String configName = rs.getString(1);
+ if ("maxSQLLength".equals(configName)) {
+ maxSQLLength = Integer.parseInt(rs.getString(2));
+ logger.info("maxSQLLength={}", maxSQLLength);
+ }
+ }
+ }
+
+ /**
+ * Convert raw data to SQL fragments, group them by table name and cache them in a HashMap.
+ * Trigger writing when number of buffered records reached maxBachSize.
+ *
+ * @param line raw data get from task queue in format: tbName,ts,current,voltage,phase,location,groupId
+ */
+ public void processLine(String line) throws SQLException {
+ bufferedCount += 1;
+ int firstComma = line.indexOf(',');
+ String tbName = line.substring(0, firstComma);
+ int lastComma = line.lastIndexOf(',');
+ int secondLastComma = line.lastIndexOf(',', lastComma - 1);
+ String value = "(" + line.substring(firstComma + 1, secondLastComma) + ") ";
+ if (tbValues.containsKey(tbName)) {
+ tbValues.put(tbName, tbValues.get(tbName) + value);
+ } else {
+ tbValues.put(tbName, value);
+ }
+ if (!tbTags.containsKey(tbName)) {
+ String location = line.substring(secondLastComma + 1, lastComma);
+ String groupId = line.substring(lastComma + 1);
+ String tagValues = "('" + location + "'," + groupId + ')';
+ tbTags.put(tbName, tagValues);
+ }
+ if (bufferedCount == maxBatchSize) {
+ flush();
+ }
+ }
+
+
+ /**
+ * Assemble INSERT statement using buffered SQL fragments in Map {@link SQLWriter#tbValues} and execute it.
+ * In case of "Table does not exit" exception, create all tables in the sql and retry the sql.
+ */
+ public void flush() throws SQLException {
+ StringBuilder sb = new StringBuilder("INSERT INTO ");
+ for (Map.Entry entry : tbValues.entrySet()) {
+ String tableName = entry.getKey();
+ String values = entry.getValue();
+ String q = tableName + " values " + values + " ";
+ if (sb.length() + q.length() > maxSQLLength) {
+ executeSQL(sb.toString());
+ logger.warn("increase maxSQLLength or decrease maxBatchSize to gain better performance");
+ sb = new StringBuilder("INSERT INTO ");
+ }
+ sb.append(q);
+ }
+ executeSQL(sb.toString());
+ tbValues.clear();
+ bufferedCount = 0;
+ }
+
+ private void executeSQL(String sql) throws SQLException {
+ try {
+ stmt.executeUpdate(sql);
+ } catch (SQLException e) {
+ // convert to error code defined in taoserror.h
+ int errorCode = e.getErrorCode() & 0xffff;
+ if (errorCode == 0x362 || errorCode == 0x218) {
+ // Table does not exist
+ createTables();
+ executeSQL(sql);
+ } else {
+ logger.error("Execute SQL: {}", sql);
+ throw e;
+ }
+ } catch (Throwable throwable) {
+ logger.error("Execute SQL: {}", sql);
+ throw throwable;
+ }
+ }
+
+ /**
+ * Create tables in batch using syntax:
+ *
+ * CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) [IF NOT EXISTS] tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
+ *
+ */
+ private void createTables() throws SQLException {
+ StringBuilder sb = new StringBuilder("CREATE TABLE ");
+ for (String tbName : tbValues.keySet()) {
+ String tagValues = tbTags.get(tbName);
+ sb.append("IF NOT EXISTS ").append(tbName).append(" USING meters TAGS ").append(tagValues).append(" ");
+ }
+ String sql = sb.toString();
+ try {
+ stmt.executeUpdate(sql);
+ } catch (Throwable throwable) {
+ logger.error("Execute SQL: {}", sql);
+ throw throwable;
+ }
+ }
+
+ public boolean hasBufferedValues() {
+ return bufferedCount > 0;
+ }
+
+ public int getBufferedCount() {
+ return bufferedCount;
+ }
+
+ public void close() {
+ try {
+ stmt.close();
+ } catch (SQLException e) {
+ }
+ try {
+ conn.close();
+ } catch (SQLException e) {
+ }
+ }
+}
\ No newline at end of file
diff --git a/docs/examples/java/src/main/java/com/taos/example/highvolume/StmtWriter.java b/docs/examples/java/src/main/java/com/taos/example/highvolume/StmtWriter.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ade06625d708a112c85d5657aa00bcd0e605ff4
--- /dev/null
+++ b/docs/examples/java/src/main/java/com/taos/example/highvolume/StmtWriter.java
@@ -0,0 +1,4 @@
+package com.taos.example.highvolume;
+
+public class StmtWriter {
+}
diff --git a/docs/examples/java/src/main/java/com/taos/example/highvolume/WriteTask.java b/docs/examples/java/src/main/java/com/taos/example/highvolume/WriteTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..de9e5463d7dc59478f991e4783aacaae527b4c4b
--- /dev/null
+++ b/docs/examples/java/src/main/java/com/taos/example/highvolume/WriteTask.java
@@ -0,0 +1,58 @@
+package com.taos.example.highvolume;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.BlockingQueue;
+
+class WriteTask implements Runnable {
+ private final static Logger logger = LoggerFactory.getLogger(WriteTask.class);
+ private final int maxBatchSize;
+
+ // the queue from which this writing task get raw data.
+ private final BlockingQueue queue;
+
+ // A flag indicate whether to continue.
+ private boolean active = true;
+
+ public WriteTask(BlockingQueue taskQueue, int maxBatchSize) {
+ this.queue = taskQueue;
+ this.maxBatchSize = maxBatchSize;
+ }
+
+ @Override
+ public void run() {
+ logger.info("started");
+ String line = null; // data getting from the queue just now.
+ SQLWriter writer = new SQLWriter(maxBatchSize);
+ try {
+ writer.init();
+ while (active) {
+ line = queue.poll();
+ if (line != null) {
+ // parse raw data and buffer the data.
+ writer.processLine(line);
+ } else if (writer.hasBufferedValues()) {
+ // write data immediately if no more data in the queue
+ writer.flush();
+ } else {
+ // sleep a while to avoid high CPU usage if no more data in the queue and no buffered records, .
+ Thread.sleep(100);
+ }
+ }
+ if (writer.hasBufferedValues()) {
+ writer.flush();
+ }
+ } catch (Exception e) {
+ String msg = String.format("line=%s, bufferedCount=%s", line, writer.getBufferedCount());
+ logger.error(msg, e);
+ } finally {
+ writer.close();
+ }
+ }
+
+ public void stop() {
+ logger.info("stop");
+ this.active = false;
+ }
+}
\ No newline at end of file
diff --git a/docs/examples/java/src/test/java/com/taos/test/TestAll.java b/docs/examples/java/src/test/java/com/taos/test/TestAll.java
index 42db24485afec05298159f7b0c3a4e15835d98ed..8d201da0745e1d2d36220c9d78383fc37d4a813a 100644
--- a/docs/examples/java/src/test/java/com/taos/test/TestAll.java
+++ b/docs/examples/java/src/test/java/com/taos/test/TestAll.java
@@ -23,16 +23,16 @@ public class TestAll {
String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
try (Connection conn = DriverManager.getConnection(jdbcUrl)) {
try (Statement stmt = conn.createStatement()) {
- String sql = "INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 14:38:05.000',10.30000,219,0.31000)\n" +
- " power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 15:38:15.000',12.60000,218,0.33000)\n" +
- " power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 15:38:16.800',12.30000,221,0.31000)\n" +
- " power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES('2018-10-03 15:38:16.650',10.30000,218,0.25000)\n" +
- " power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 15:38:05.500',11.80000,221,0.28000)\n" +
- " power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 15:38:16.600',13.40000,223,0.29000)\n" +
- " power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:05.000',10.80000,223,0.29000)\n" +
- " power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:06.000',10.80000,223,0.29000)\n" +
- " power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:07.000',10.80000,223,0.29000)\n" +
- " power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:08.500',11.50000,221,0.35000)";
+ String sql = "INSERT INTO power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES('2018-10-03 14:38:05.000',10.30000,219,0.31000)\n" +
+ " power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES('2018-10-03 15:38:15.000',12.60000,218,0.33000)\n" +
+ " power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES('2018-10-03 15:38:16.800',12.30000,221,0.31000)\n" +
+ " power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES('2018-10-03 15:38:16.650',10.30000,218,0.25000)\n" +
+ " power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES('2018-10-03 15:38:05.500',11.80000,221,0.28000)\n" +
+ " power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES('2018-10-03 15:38:16.600',13.40000,223,0.29000)\n" +
+ " power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 15:38:05.000',10.80000,223,0.29000)\n" +
+ " power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 15:38:06.000',10.80000,223,0.29000)\n" +
+ " power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 15:38:07.000',10.80000,223,0.29000)\n" +
+ " power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 15:38:08.500',11.50000,221,0.35000)";
stmt.execute(sql);
}
diff --git a/docs/examples/python/fast_write_example.py b/docs/examples/python/fast_write_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9d606388fdecd85f1468f24cc497ecc5941f035
--- /dev/null
+++ b/docs/examples/python/fast_write_example.py
@@ -0,0 +1,180 @@
+# install dependencies:
+# recommend python >= 3.8
+# pip3 install faster-fifo
+#
+
+import logging
+import math
+import sys
+import time
+import os
+from multiprocessing import Process
+from faster_fifo import Queue
+from mockdatasource import MockDataSource
+from queue import Empty
+from typing import List
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="%(asctime)s [%(name)s] - %(message)s")
+
+READ_TASK_COUNT = 1
+WRITE_TASK_COUNT = 1
+TABLE_COUNT = 1000
+QUEUE_SIZE = 1000000
+MAX_BATCH_SIZE = 3000
+
+read_processes = []
+write_processes = []
+
+
+def get_connection():
+ """
+ If variable TDENGINE_FIRST_EP is provided then it will be used. If not, firstEP in /etc/taos/taos.cfg will be used.
+ You can also override the default username and password by supply variable TDENGINE_USER and TDENGINE_PASSWORD
+ """
+ import taos
+ firstEP = os.environ.get("TDENGINE_FIRST_EP")
+ if firstEP:
+ host, port = firstEP.split(":")
+ else:
+ host, port = None, 0
+ user = os.environ.get("TDENGINE_USER", "root")
+ password = os.environ.get("TDENGINE_PASSWORD", "taosdata")
+ return taos.connect(host=host, port=int(port), user=user, password=password)
+
+
+# ANCHOR: read
+
+def run_read_task(task_id: int, task_queues: List[Queue]):
+ table_count_per_task = TABLE_COUNT // READ_TASK_COUNT
+ data_source = MockDataSource(f"tb{task_id}", table_count_per_task)
+ try:
+ for batch in data_source:
+ for table_id, rows in batch:
+ # hash data to different queue
+ i = table_id % len(task_queues)
+ # block putting forever when the queue is full
+ task_queues[i].put_many(rows, block=True, timeout=-1)
+ except KeyboardInterrupt:
+ pass
+
+
+# ANCHOR_END: read
+
+# ANCHOR: write
+def run_write_task(task_id: int, queue: Queue):
+ from sql_writer import SQLWriter
+ log = logging.getLogger(f"WriteTask-{task_id}")
+ writer = SQLWriter(get_connection)
+ lines = None
+ try:
+ while True:
+ try:
+ # get as many as possible
+ lines = queue.get_many(block=False, max_messages_to_get=MAX_BATCH_SIZE)
+ writer.process_lines(lines)
+ except Empty:
+ time.sleep(0.01)
+ except KeyboardInterrupt:
+ pass
+ except BaseException as e:
+ log.debug(f"lines={lines}")
+ raise e
+
+
+# ANCHOR_END: write
+
+def set_global_config():
+ argc = len(sys.argv)
+ if argc > 1:
+ global READ_TASK_COUNT
+ READ_TASK_COUNT = int(sys.argv[1])
+ if argc > 2:
+ global WRITE_TASK_COUNT
+ WRITE_TASK_COUNT = int(sys.argv[2])
+ if argc > 3:
+ global TABLE_COUNT
+ TABLE_COUNT = int(sys.argv[3])
+ if argc > 4:
+ global QUEUE_SIZE
+ QUEUE_SIZE = int(sys.argv[4])
+ if argc > 5:
+ global MAX_BATCH_SIZE
+ MAX_BATCH_SIZE = int(sys.argv[5])
+
+
+# ANCHOR: monitor
+def run_monitor_process():
+ log = logging.getLogger("DataBaseMonitor")
+ conn = get_connection()
+ conn.execute("DROP DATABASE IF EXISTS test")
+ conn.execute("CREATE DATABASE test")
+ conn.execute("CREATE STABLE test.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) "
+ "TAGS (location BINARY(64), groupId INT)")
+
+ def get_count():
+ res = conn.query("SELECT count(*) FROM test.meters")
+ rows = res.fetch_all()
+ return rows[0][0] if rows else 0
+
+ last_count = 0
+ while True:
+ time.sleep(10)
+ count = get_count()
+ log.info(f"count={count} speed={(count - last_count) / 10}")
+ last_count = count
+
+
+# ANCHOR_END: monitor
+# ANCHOR: main
+def main():
+ set_global_config()
+ logging.info(f"READ_TASK_COUNT={READ_TASK_COUNT}, WRITE_TASK_COUNT={WRITE_TASK_COUNT}, "
+ f"TABLE_COUNT={TABLE_COUNT}, QUEUE_SIZE={QUEUE_SIZE}, MAX_BATCH_SIZE={MAX_BATCH_SIZE}")
+
+ monitor_process = Process(target=run_monitor_process)
+ monitor_process.start()
+ time.sleep(3) # waiting for database ready.
+
+ task_queues: List[Queue] = []
+ # create task queues
+ for i in range(WRITE_TASK_COUNT):
+ queue = Queue(max_size_bytes=QUEUE_SIZE)
+ task_queues.append(queue)
+
+ # create write processes
+ for i in range(WRITE_TASK_COUNT):
+ p = Process(target=run_write_task, args=(i, task_queues[i]))
+ p.start()
+ logging.debug(f"WriteTask-{i} started with pid {p.pid}")
+ write_processes.append(p)
+
+ # create read processes
+ for i in range(READ_TASK_COUNT):
+ queues = assign_queues(i, task_queues)
+ p = Process(target=run_read_task, args=(i, queues))
+ p.start()
+ logging.debug(f"ReadTask-{i} started with pid {p.pid}")
+ read_processes.append(p)
+
+ try:
+ monitor_process.join()
+ except KeyboardInterrupt:
+ monitor_process.terminate()
+ [p.terminate() for p in read_processes]
+ [p.terminate() for p in write_processes]
+ [q.close() for q in task_queues]
+
+
+def assign_queues(read_task_id, task_queues):
+ """
+ Compute target queues for a specific read task.
+ """
+ ratio = WRITE_TASK_COUNT / READ_TASK_COUNT
+ from_index = math.floor(read_task_id * ratio)
+ end_index = math.ceil((read_task_id + 1) * ratio)
+ return task_queues[from_index:end_index]
+
+
+if __name__ == '__main__':
+ main()
+# ANCHOR_END: main
diff --git a/docs/examples/python/mockdatasource.py b/docs/examples/python/mockdatasource.py
new file mode 100644
index 0000000000000000000000000000000000000000..852860aec0adc8f9b043c9dcd5deb0bf00239201
--- /dev/null
+++ b/docs/examples/python/mockdatasource.py
@@ -0,0 +1,49 @@
+import time
+
+
+class MockDataSource:
+ samples = [
+ "8.8,119,0.32,LosAngeles,0",
+ "10.7,116,0.34,SanDiego,1",
+ "9.9,111,0.33,Hollywood,2",
+ "8.9,113,0.329,Compton,3",
+ "9.4,118,0.141,San Francisco,4"
+ ]
+
+ def __init__(self, tb_name_prefix, table_count):
+ self.table_name_prefix = tb_name_prefix + "_"
+ self.table_count = table_count
+ self.max_rows = 10000000
+ self.current_ts = round(time.time() * 1000) - self.max_rows * 100
+ # [(tableId, tableName, values),]
+ self.data = self._init_data()
+
+ def _init_data(self):
+ lines = self.samples * (self.table_count // 5 + 1)
+ data = []
+ for i in range(self.table_count):
+ table_name = self.table_name_prefix + str(i)
+ data.append((i, table_name, lines[i])) # tableId, row
+ return data
+
+ def __iter__(self):
+ self.row = 0
+ return self
+
+ def __next__(self):
+ """
+ next 1000 rows for each table.
+ return: {tableId:[row,...]}
+ """
+ # generate 1000 timestamps
+ ts = []
+ for _ in range(1000):
+ self.current_ts += 100
+ ts.append(str(self.current_ts))
+ # add timestamp to each row
+ # [(tableId, ["tableName,ts,current,voltage,phase,location,groupId"])]
+ result = []
+ for table_id, table_name, values in self.data:
+ rows = [table_name + ',' + t + ',' + values for t in ts]
+ result.append((table_id, rows))
+ return result
diff --git a/docs/examples/python/sql_writer.py b/docs/examples/python/sql_writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..758167376b009f21afc701be7d89c1bfbabdeb9f
--- /dev/null
+++ b/docs/examples/python/sql_writer.py
@@ -0,0 +1,90 @@
+import logging
+import taos
+
+
+class SQLWriter:
+ log = logging.getLogger("SQLWriter")
+
+ def __init__(self, get_connection_func):
+ self._tb_values = {}
+ self._tb_tags = {}
+ self._conn = get_connection_func()
+ self._max_sql_length = self.get_max_sql_length()
+ self._conn.execute("USE test")
+
+ def get_max_sql_length(self):
+ rows = self._conn.query("SHOW variables").fetch_all()
+ for r in rows:
+ name = r[0]
+ if name == "maxSQLLength":
+ return int(r[1])
+ return 1024 * 1024
+
+ def process_lines(self, lines: str):
+ """
+ :param lines: [[tbName,ts,current,voltage,phase,location,groupId]]
+ """
+ for line in lines:
+ ps = line.split(",")
+ table_name = ps[0]
+ value = '(' + ",".join(ps[1:-2]) + ') '
+ if table_name in self._tb_values:
+ self._tb_values[table_name] += value
+ else:
+ self._tb_values[table_name] = value
+
+ if table_name not in self._tb_tags:
+ location = ps[-2]
+ group_id = ps[-1]
+ tag_value = f"('{location}',{group_id})"
+ self._tb_tags[table_name] = tag_value
+ self.flush()
+
+ def flush(self):
+ """
+ Assemble INSERT statement and execute it.
+ When the sql length grows close to MAX_SQL_LENGTH, the sql will be executed immediately, and a new INSERT statement will be created.
+ In case of "Table does not exit" exception, tables in the sql will be created and the sql will be re-executed.
+ """
+ sql = "INSERT INTO "
+ sql_len = len(sql)
+ buf = []
+ for tb_name, values in self._tb_values.items():
+ q = tb_name + " VALUES " + values
+ if sql_len + len(q) >= self._max_sql_length:
+ sql += " ".join(buf)
+ self.execute_sql(sql)
+ sql = "INSERT INTO "
+ sql_len = len(sql)
+ buf = []
+ buf.append(q)
+ sql_len += len(q)
+ sql += " ".join(buf)
+ self.execute_sql(sql)
+ self._tb_values.clear()
+
+ def execute_sql(self, sql):
+ try:
+ self._conn.execute(sql)
+ except taos.Error as e:
+ error_code = e.errno & 0xffff
+ # Table does not exit
+ if error_code == 9731:
+ self.create_tables()
+ else:
+ self.log.error("Execute SQL: %s", sql)
+ raise e
+ except BaseException as baseException:
+ self.log.error("Execute SQL: %s", sql)
+ raise baseException
+
+ def create_tables(self):
+ sql = "CREATE TABLE "
+ for tb in self._tb_values.keys():
+ tag_values = self._tb_tags[tb]
+ sql += "IF NOT EXISTS " + tb + " USING meters TAGS " + tag_values + " "
+ try:
+ self._conn.execute(sql)
+ except BaseException as e:
+ self.log.error("Execute SQL: %s", sql)
+ raise e
diff --git a/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx b/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx
index 214cbdaa96d02e0cd1251eeda97c6a897887cc7e..2920fa35a447861fd5c34a84c1950b22407b214d 100644
--- a/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx
+++ b/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx
@@ -23,7 +23,7 @@ import PhpStmt from "./_php_stmt.mdx";
## SQL 写入简介
-应用通过连接器执行 INSERT 语句来插入数据，用户还可以通过 TAOS Shell，手动输入 INSERT 语句插入数据。
+应用通过连接器执行 INSERT 语句来插入数据，用户还可以通过 TDengine CLI，手动输入 INSERT 语句插入数据。
### 一次写入一条
下面这条 INSERT 就将一条记录写入到表 d1001 中：
diff --git a/docs/zh/07-develop/03-insert-data/05-high-volume.md b/docs/zh/07-develop/03-insert-data/05-high-volume.md
new file mode 100644
index 0000000000000000000000000000000000000000..32be8cb8903493f6b5290928a36507ae225a37df
--- /dev/null
+++ b/docs/zh/07-develop/03-insert-data/05-high-volume.md
@@ -0,0 +1,440 @@
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# 高效写入
+
+本节介绍如何高效地向 TDengine 写入数据。
+
+## 高效写入原理 {#principle}
+
+### 客户端程序的角度 {#application-view}
+
+从客户端程序的角度来说，高效写入数据要考虑以下几个因素：
+
+1. 单次写入的数据量。一般来讲，每批次写入的数据量越大越高效（但超过一定阈值其优势会消失）。使用 SQL 写入 TDengine 时，尽量在一条 SQL 中拼接更多数据。目前，TDengine 支持的一条 SQL 的最大长度为 1,048,576（1M）个字符。可通过配置客户端参数 maxSQLLength（默认值为 65480）进行修改。
+2. 并发连接数。一般来讲，同时写入数据的并发连接数越多写入越高效（但超过一定阈值反而会下降，取决于服务端处理能力）。
+3. 数据在不同表（或子表）之间的分布，即要写入数据的相邻性。一般来说，每批次只向同一张表（或子表）写入数据比向多张表（或子表）写入数据要更高效；
+4. 写入方式。一般来讲：
+ - 参数绑定写入比 SQL 写入更高效。因参数绑定方式避免了 SQL 解析。（但增加了 C 接口的调用次数，对于连接器也有性能损耗）。
+ - SQL 写入不自动建表比自动建表更高效。因自动建表要频繁检查表是否存在
+ - SQL 写入比无模式写入更高效。因无模式写入会自动建表且支持动态更改表结构
+
+客户端程序要充分且恰当地利用以上几个因素。在单次写入中尽量只向同一张表（或子表）写入数据，每批次写入的数据量经过测试和调优设定为一个最适合当前系统处理能力的数值，并发写入的连接数同样经过测试和调优后设定为一个最适合当前系统处理能力的数值，以实现在当前系统中的最佳写入速度。
+
+### 数据源的角度 {#datasource-view}
+
+客户端程序通常需要从数据源读数据再写入 TDengine。从数据源角度来说，以下几种情况需要在读线程和写线程之间增加队列：
+
+1. 有多个数据源，单个数据源生成数据的速度远小于单线程写入的速度，但数据量整体比较大。此时队列的作用是把多个数据源的数据汇聚到一起，增加单次写入的数据量。
+2. 单个数据源生成数据的速度远大于单线程写入的速度。此时队列的作用是增加写入的并发度。
+3. 单张表的数据分散在多个数据源。此时队列的作用是将同一张表的数据提前汇聚到一起，提高写入时数据的相邻性。
+
+如果写应用的数据源是 Kafka, 写应用本身即 Kafka 的消费者，则可利用 Kafka 的特性实现高效写入。比如：
+
+1. 将同一张表的数据写到同一个 Topic 的同一个 Partition，增加数据的相邻性
+2. 通过订阅多个 Topic 实现数据汇聚
+3. 通过增加 Consumer 线程数增加写入的并发度
+4. 通过增加每次 fetch 的最大数据量来增加单次写入的最大数据量
+
+### 服务器配置的角度 {#setting-view}
+
+从服务器配置的角度来说，也有很多优化写入性能的方法。
+
+如果总表数不多(远小于核数乘以1000), 且无论怎么调节客户端程序，taosd 进程的 CPU 使用率都很低，那么很可能是因为表在各个 vgroup 分布不均。比如：数据库总表数是 1000 且 minTablesPerVnode 设置的也是 1000，那么所有的表都会分布在 1 个 vgroup 上。此时如果将 minTablesPerVnode 和 tablelncStepPerVnode 都设置成 100， 则可将表分布至 10 个 vgroup。（假设 maxVgroupsPerDb 大于等于 10）。
+
+如果总表数比较大（比如大于500万），适当增加 maxVgroupsPerDb 也能显著提高建表的速度。maxVgroupsPerDb 默认值为 0， 自动配置为 CPU 的核数。 如果表的数量巨大，也建议调节 maxTablesPerVnode 参数，以免超过单个 vnode 建表的上限。
+
+更多调优参数，请参考 [配置参考](../../../reference/config)部分。
+
+## 高效写入示例 {#sample-code}
+
+### 场景设计 {#scenario}
+
+下面的示例程序展示了如何高效写入数据，场景设计如下：
+
+- TDengine 客户端程序从其它数据源不断读入数据，在示例程序中采用生成模拟数据的方式来模拟读取数据源
+- 单个连接向 TDengine 写入的速度无法与读数据的速度相匹配，因此客户端程序启动多个线程，每个线程都建立了与 TDengine 的连接，每个线程都有一个独占的固定大小的消息队列
+- 客户端程序将接收到的数据根据所属的表名（或子表名）HASH 到不同的线程，即写入该线程所对应的消息队列，以此确保属于某个表（或子表）的数据一定会被一个固定的线程处理
+- 各个子线程在将所关联的消息队列中的数据读空后或者读取数据量达到一个预定的阈值后将该批数据写入 TDengine，并继续处理后面接收到的数据
+
+
+
+### 示例代码 {#code}
+
+这一部分是针对以上场景的示例代码。对于其它场景高效写入原理相同，不过代码需要适当修改。
+
+本示例代码假设源数据属于同一张超级表(meters)的不同子表。程序在开始写入数据之前已经在 test 库创建了这个超级表。对于子表，将根据收到的数据，由应用程序自动创建。如果实际场景是多个超级表，只需修改写任务自动建表的代码。
+
+
+
+
+**程序清单**
+
+| 类名 | 功能说明 |
+| ---------------- | --------------------------------------------------------------------------- |
+| FastWriteExample | 主程序 |
+| ReadTask | 从模拟源中读取数据，将表名经过 hash 后得到 Queue 的 index，写入对应的 Queue |
+| WriteTask | 从 Queue 中获取数据，组成一个 Batch，写入 TDengine |
+| MockDataSource | 模拟生成一定数量 meters 子表的数据 |
+| SQLWriter | WriteTask 依赖这个类完成 SQL 拼接、自动建表、 SQL 写入、SQL 长度检查 |
+| StmtWriter | 实现参数绑定方式批量写入（暂未完成） |
+| DataBaseMonitor | 统计写入速度，并每隔 10 秒把当前写入速度打印到控制台 |
+
+
+以下是各类的完整代码和更详细的功能说明。
+
+
+FastWriteExample
+主程序负责：
+
+1. 创建消息队列
+2. 启动写线程
+3. 启动读线程
+4. 每隔 10 秒统计一次写入速度
+
+主程序默认暴露了 4 个参数，每次启动程序都可调节，用于测试和调优：
+
+1. 读线程个数。默认为 1。
+2. 写线程个数。默认为 3。
+3. 模拟生成的总表数。默认为 1000。将会平分给各个读线程。如果总表数较大，建表需要花费较长，开始统计的写入速度可能较慢。
+4. 每批最多写入记录数量。默认为 3000。
+
+队列容量(taskQueueCapacity)也是与性能有关的参数，可通过修改程序调节。一般来讲，队列容量越大，入队被阻塞的概率越小，队列的吞吐量越大，但是内存占用也会越大。 示例程序默认值已经设置地足够大。
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/FastWriteExample.java}}
+```
+
+
+
+
+ReadTask
+
+读任务负责从数据源读数据。每个读任务都关联了一个模拟数据源。每个模拟数据源可生成一点数量表的数据。不同的模拟数据源生成不同表的数据。
+
+读任务采用阻塞的方式写消息队列。也就是说，一旦队列满了，写操作就会阻塞。
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/ReadTask.java}}
+```
+
+
+
+
+WriteTask
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/WriteTask.java}}
+```
+
+
+
+
+
+MockDataSource
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/MockDataSource.java}}
+```
+
+
+
+
+
+SQLWriter
+
+SQLWriter 类封装了拼 SQL 和写数据的逻辑。注意，所有的表都没有提前创建，而是在 catch 到表不存在异常的时候，再以超级表为模板批量建表，然后重新执行 INSERT 语句。对于其它异常，这里简单地记录当时执行的 SQL 语句到日志中，你也可以记录更多线索到日志，已便排查错误和故障恢复。
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/SQLWriter.java}}
+```
+
+
+
+
+
+DataBaseMonitor
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/highvolume/DataBaseMonitor.java}}
+```
+
+
+
+**执行步骤**
+
+
+执行 Java 示例程序
+
+执行程序前需配置环境变量 `TDENGINE_JDBC_URL`。如果 TDengine Server 部署在本机，且用户名、密码和端口都是默认值，那么可配置：
+
+```
+TDENGINE_JDBC_URL="jdbc:TAOS://localhost:6030?user=root&password=taosdata"
+```
+
+**本地集成开发环境执行示例程序**
+
+1. clone TDengine 仓库
+ ```
+ git clone git@github.com:taosdata/TDengine.git --depth 1
+ ```
+2. 用集成开发环境打开 `docs/examples/java` 目录。
+3. 在开发环境中配置环境变量 `TDENGINE_JDBC_URL`。如果已配置了全局的环境变量 `TDENGINE_JDBC_URL` 可跳过这一步。
+4. 运行类 `com.taos.example.highvolume.FastWriteExample`。
+
+**远程服务器上执行示例程序**
+
+若要在服务器上执行示例程序，可按照下面的步骤操作：
+
+1. 打包示例代码。在目录 TDengine/docs/examples/java 下执行：
+ ```
+ mvn package
+ ```
+2. 远程服务器上创建 examples 目录：
+ ```
+ mkdir -p examples/java
+ ```
+3. 复制依赖到服务器指定目录：
+ - 复制依赖包，只用复制一次
+ ```
+ scp -r .\target\lib @:~/examples/java
+ ```
+ - 复制本程序的 jar 包，每次更新代码都需要复制
+ ```
+ scp -r .\target\javaexample-1.0.jar @:~/examples/java
+ ```
+4. 配置环境变量。
+ 编辑 `~/.bash_profile` 或 `~/.bashrc` 添加如下内容例如：
+
+ ```
+ export TDENGINE_JDBC_URL="jdbc:TAOS://localhost:6030?user=root&password=taosdata"
+ ```
+
+ 以上使用的是本地部署 TDengine Server 时默认的 JDBC URL。你需要根据自己的实际情况更改。
+
+5. 用 java 命令启动示例程序，命令模板：
+
+ ```
+ java -classpath lib/*:javaexample-1.0.jar com.taos.example.highvolume.FastWriteExample
+ ```
+
+6. 结束测试程序。测试程序不会自动结束，在获取到当前配置下稳定的写入速度后，按 CTRL + C 结束程序。
+ 下面是一次实际运行的日志输出，机器配置 16核 + 64G + 固态硬盘。
+
+ ```
+ root@vm85$ java -classpath lib/*:javaexample-1.0.jar com.taos.example.highvolume.FastWriteExample 2 12
+ 18:56:35.896 [main] INFO c.t.e.highvolume.FastWriteExample - readTaskCount=2, writeTaskCount=12 tableCount=1000 maxBatchSize=3000
+ 18:56:36.011 [WriteThread-0] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.015 [WriteThread-0] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.021 [WriteThread-1] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.022 [WriteThread-1] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.031 [WriteThread-2] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.032 [WriteThread-2] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.041 [WriteThread-3] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.042 [WriteThread-3] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.093 [WriteThread-4] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.094 [WriteThread-4] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.099 [WriteThread-5] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.100 [WriteThread-5] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.100 [WriteThread-6] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.101 [WriteThread-6] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.103 [WriteThread-7] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.104 [WriteThread-7] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.105 [WriteThread-8] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.107 [WriteThread-8] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.108 [WriteThread-9] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.109 [WriteThread-9] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.156 [WriteThread-10] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.157 [WriteThread-11] INFO c.taos.example.highvolume.WriteTask - started
+ 18:56:36.158 [WriteThread-10] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:36.158 [ReadThread-0] INFO com.taos.example.highvolume.ReadTask - started
+ 18:56:36.158 [ReadThread-1] INFO com.taos.example.highvolume.ReadTask - started
+ 18:56:36.158 [WriteThread-11] INFO c.taos.example.highvolume.SQLWriter - maxSQLLength=1048576
+ 18:56:46.369 [main] INFO c.t.e.highvolume.FastWriteExample - count=18554448 speed=1855444
+ 18:56:56.946 [main] INFO c.t.e.highvolume.FastWriteExample - count=39059660 speed=2050521
+ 18:57:07.322 [main] INFO c.t.e.highvolume.FastWriteExample - count=59403604 speed=2034394
+ 18:57:18.032 [main] INFO c.t.e.highvolume.FastWriteExample - count=80262938 speed=2085933
+ 18:57:28.432 [main] INFO c.t.e.highvolume.FastWriteExample - count=101139906 speed=2087696
+ 18:57:38.921 [main] INFO c.t.e.highvolume.FastWriteExample - count=121807202 speed=2066729
+ 18:57:49.375 [main] INFO c.t.e.highvolume.FastWriteExample - count=142952417 speed=2114521
+ 18:58:00.689 [main] INFO c.t.e.highvolume.FastWriteExample - count=163650306 speed=2069788
+ 18:58:11.646 [main] INFO c.t.e.highvolume.FastWriteExample - count=185019808 speed=2136950
+ ```
+
+
+
+
+
+
+**程序清单**
+
+Python 示例程序中采用了多进程的架构，并使用了跨进程的消息队列。
+
+| 函数或类 | 功能说明 |
+| ------------------------ | -------------------------------------------------------------------- |
+| main 函数 | 程序入口， 创建各个子进程和消息队列 |
+| run_monitor_process 函数 | 创建数据库，超级表，统计写入速度并定时打印到控制台 |
+| run_read_task 函数 | 读进程主要逻辑，负责从其它数据系统读数据，并分发数据到为之分配的队列 |
+| MockDataSource 类 | 模拟数据源, 实现迭代器接口，每次批量返回每张表的接下来 1000 条数据 |
+| run_write_task 函数 | 写进程主要逻辑。每次从队列中取出尽量多的数据，并批量写入 |
+| SQLWriter类 | SQL 写入和自动建表 |
+| StmtWriter 类 | 实现参数绑定方式批量写入（暂未完成） |
+
+
+
+main 函数
+
+main 函数负责创建消息队列和启动子进程，子进程有 3 类：
+
+1. 1 个监控进程，负责数据库初始化和统计写入速度
+2. n 个读进程，负责从其它数据系统读数据
+3. m 个写进程，负责写数据库
+
+main 函数可以接收 5 个启动参数，依次是：
+
+1. 读任务（进程）数, 默认为 1
+2. 写任务（进程）数, 默认为 1
+3. 模拟生成的总表数，默认为 1000
+4. 队列大小（单位字节），默认为 1000000
+5. 每批最多写入记录数量， 默认为 3000
+
+```python
+{{#include docs/examples/python/fast_write_example.py:main}}
+```
+
+
+
+
+run_monitor_process
+
+监控进程负责初始化数据库，并监控当前的写入速度。
+
+```python
+{{#include docs/examples/python/fast_write_example.py:monitor}}
+```
+
+
+
+
+
+run_read_task 函数
+
+读进程，负责从其它数据系统读数据，并分发数据到为之分配的队列。
+
+```python
+{{#include docs/examples/python/fast_write_example.py:read}}
+```
+
+
+
+
+
+MockDataSource
+
+以下是模拟数据源的实现，我们假设数据源生成的每一条数据都带有目标表名信息。实际中你可能需要一定的规则确定目标表名。
+
+```python
+{{#include docs/examples/python/mockdatasource.py}}
+```
+
+
+
+
+run_write_task 函数
+
+写进程每次从队列中取出尽量多的数据，并批量写入。
+
+```python
+{{#include docs/examples/python/fast_write_example.py:write}}
+```
+
+
+
+
+
+SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提前创建，而是在发生表不存在错误的时候，再以超级表为模板批量建表，然后重新执行 INSERT 语句。对于其它错误会记录当时执行的 SQL， 以便排查错误和故障恢复。这个类也对 SQL 是否超过最大长度限制做了检查，如果接近 SQL 最大长度限制（maxSQLLength），将会立即执行 SQL。为了减少 SQL 此时，建议将 maxSQLLength 适当调大。
+
+SQLWriter
+
+```python
+{{#include docs/examples/python/sql_writer.py}}
+```
+
+
+
+**执行步骤**
+
+
+
+执行 Python 示例程序
+
+1. 前提条件
+
+ - 已安装 TDengine 客户端驱动
+ - 已安装 Python3， 推荐版本 >= 3.8
+ - 已安装 taospy
+
+2. 安装 faster-fifo 代替 python 内置的 multiprocessing.Queue
+
+ ```
+ pip3 install faster-fifo
+ ```
+
+3. 点击上面的“查看源码”链接复制 `fast_write_example.py` 、 `sql_writer.py` 和 `mockdatasource.py` 三个文件。
+
+4. 执行示例程序
+
+ ```
+ python3 fast_write_example.py
+ ```
+
+ 下面是一次实际运行的输出, 机器配置 16核 + 64G + 固态硬盘。
+
+ ```
+ root@vm85$ python3 fast_write_example.py 8 8
+ 2022-07-14 19:13:45,869 [root] - READ_TASK_COUNT=8, WRITE_TASK_COUNT=8, TABLE_COUNT=1000, QUEUE_SIZE=1000000, MAX_BATCH_SIZE=3000
+ 2022-07-14 19:13:48,882 [root] - WriteTask-0 started with pid 718347
+ 2022-07-14 19:13:48,883 [root] - WriteTask-1 started with pid 718348
+ 2022-07-14 19:13:48,884 [root] - WriteTask-2 started with pid 718349
+ 2022-07-14 19:13:48,884 [root] - WriteTask-3 started with pid 718350
+ 2022-07-14 19:13:48,885 [root] - WriteTask-4 started with pid 718351
+ 2022-07-14 19:13:48,885 [root] - WriteTask-5 started with pid 718352
+ 2022-07-14 19:13:48,886 [root] - WriteTask-6 started with pid 718353
+ 2022-07-14 19:13:48,886 [root] - WriteTask-7 started with pid 718354
+ 2022-07-14 19:13:48,887 [root] - ReadTask-0 started with pid 718355
+ 2022-07-14 19:13:48,888 [root] - ReadTask-1 started with pid 718356
+ 2022-07-14 19:13:48,889 [root] - ReadTask-2 started with pid 718357
+ 2022-07-14 19:13:48,889 [root] - ReadTask-3 started with pid 718358
+ 2022-07-14 19:13:48,890 [root] - ReadTask-4 started with pid 718359
+ 2022-07-14 19:13:48,891 [root] - ReadTask-5 started with pid 718361
+ 2022-07-14 19:13:48,892 [root] - ReadTask-6 started with pid 718364
+ 2022-07-14 19:13:48,893 [root] - ReadTask-7 started with pid 718365
+ 2022-07-14 19:13:56,042 [DataBaseMonitor] - count=6676310 speed=667631.0
+ 2022-07-14 19:14:06,196 [DataBaseMonitor] - count=20004310 speed=1332800.0
+ 2022-07-14 19:14:16,366 [DataBaseMonitor] - count=32290310 speed=1228600.0
+ 2022-07-14 19:14:26,527 [DataBaseMonitor] - count=44438310 speed=1214800.0
+ 2022-07-14 19:14:36,673 [DataBaseMonitor] - count=56608310 speed=1217000.0
+ 2022-07-14 19:14:46,834 [DataBaseMonitor] - count=68757310 speed=1214900.0
+ 2022-07-14 19:14:57,280 [DataBaseMonitor] - count=80992310 speed=1223500.0
+ 2022-07-14 19:15:07,689 [DataBaseMonitor] - count=93805310 speed=1281300.0
+ 2022-07-14 19:15:18,020 [DataBaseMonitor] - count=106111310 speed=1230600.0
+ 2022-07-14 19:15:28,356 [DataBaseMonitor] - count=118394310 speed=1228300.0
+ 2022-07-14 19:15:38,690 [DataBaseMonitor] - count=130742310 speed=1234800.0
+ 2022-07-14 19:15:49,000 [DataBaseMonitor] - count=143051310 speed=1230900.0
+ 2022-07-14 19:15:59,323 [DataBaseMonitor] - count=155276310 speed=1222500.0
+ 2022-07-14 19:16:09,649 [DataBaseMonitor] - count=167603310 speed=1232700.0
+ 2022-07-14 19:16:19,995 [DataBaseMonitor] - count=179976310 speed=1237300.0
+ ```
+
+
+
+:::note
+使用 Python 连接器多进程连接 TDengine 的时候，有一个限制：不能在父进程中建立连接，所有连接只能在子进程中创建。
+如果在父进程中创建连接，子进程再创建连接就会一直阻塞。这是个已知问题。
+
+:::
+
+
+
+
+
diff --git a/docs/zh/07-develop/03-insert-data/highvolume.webp b/docs/zh/07-develop/03-insert-data/highvolume.webp
new file mode 100644
index 0000000000000000000000000000000000000000..46dfc74ae3b0043c591ff930c62251da49cae7ad
Binary files /dev/null and b/docs/zh/07-develop/03-insert-data/highvolume.webp differ
diff --git a/docs/zh/07-develop/04-query-data/index.mdx b/docs/zh/07-develop/04-query-data/index.mdx
index c083c30c2c26f8ecff96a36f3f4151e103ea1052..92cb1906d9530238b156856b0b6b0dcc9719111f 100644
--- a/docs/zh/07-develop/04-query-data/index.mdx
+++ b/docs/zh/07-develop/04-query-data/index.mdx
@@ -52,7 +52,7 @@ Query OK, 2 row(s) in set (0.001100s)
### 示例一
-在 TAOS Shell，查找加利福尼亚州所有智能电表采集的电压平均值，并按照 location 分组。
+在 TDengine CLI，查找加利福尼亚州所有智能电表采集的电压平均值，并按照 location 分组。
```
taos> SELECT AVG(voltage), location FROM meters GROUP BY location;
@@ -65,7 +65,7 @@ Query OK, 2 rows in database (0.005995s)
### 示例二
-在 TAOS shell, 查找 groupId 为 2 的所有智能电表的记录条数，电流的最大值。
+在 TDengine CLI, 查找 groupId 为 2 的所有智能电表的记录条数，电流的最大值。
```
taos> SELECT count(*), max(current) FROM meters where groupId = 2;
diff --git a/docs/zh/07-develop/08-cache.md b/docs/zh/07-develop/08-cache.md
index bd9da6062d3cc1a21be418079f0fee40520f4460..29e28e3dde0816d9e5a08f74abd2382854d336da 100644
--- a/docs/zh/07-develop/08-cache.md
+++ b/docs/zh/07-develop/08-cache.md
@@ -20,11 +20,11 @@ create database db0 vgroups 100 buffer 16MB
## 读缓存
-在创建数据库时可以选择是否缓存该数据库中每个子表的最新数据。由参数 cachelast 设置，分为三种情况：
-- 0: 不缓存
-- 1: 缓存子表最近一行数据，这将显著改善 last_row 函数的性能
-- 2: 缓存子表每一列最近的非 NULL 值，这将显著改善无特殊影响（比如 WHERE, ORDER BY, GROUP BY, INTERVAL）时的 last 函数的性能
-- 3: 同时缓存行和列，即等同于上述 cachelast 值为 1 或 2 时的行为同时生效
+在创建数据库时可以选择是否缓存该数据库中每个子表的最新数据。由参数 cachemodel 设置，分为四种情况：
+- none: 不缓存
+- last_row: 缓存子表最近一行数据，这将显著改善 last_row 函数的性能
+- last_value: 缓存子表每一列最近的非 NULL 值，这将显著改善无特殊影响（比如 WHERE, ORDER BY, GROUP BY, INTERVAL）时的 last 函数的性能
+- both: 同时缓存最近的行和列，即等同于上述 cachemodel 值为 last_row 和 last_value 的行为同时生效
## 元数据缓存
diff --git a/docs/zh/10-deployment/01-deploy.md b/docs/zh/10-deployment/01-deploy.md
index 8d8a2eb6d864b2fb05ae6e0a2833d850b62d68a8..03b4ce30f980cd77e9845076ce9bb35c4474f948 100644
--- a/docs/zh/10-deployment/01-deploy.md
+++ b/docs/zh/10-deployment/01-deploy.md
@@ -71,7 +71,7 @@ serverPort 6030
## 启动集群
-按照《立即开始》里的步骤，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos，启动 taos shell，从 shell 里执行命令“SHOW DNODES”，如下所示：
+按照《立即开始》里的步骤，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos，启动 TDengine CLI，在其中执行命令 “SHOW DNODES”，如下所示：
```
taos> show dnodes;
@@ -115,7 +115,7 @@ SHOW DNODES;
任何已经加入集群在线的数据节点，都可以作为后续待加入节点的 firstEp。
firstEp 这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的 mnode 的 End Point 列表，不再依赖这个参数。
-接下来，配置文件中的 firstEp 参数就主要在客户端连接的时候使用了，例如 taos shell 如果不加参数，会默认连接由 firstEp 指定的节点。
+接下来，配置文件中的 firstEp 参数就主要在客户端连接的时候使用了，例如 TDengine CLI 如果不加参数，会默认连接由 firstEp 指定的节点。
两个没有配置 firstEp 参数的数据节点 dnode 启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。无法将两个独立的集群合并成为新的集群。
:::
diff --git a/docs/zh/10-deployment/03-k8s.md b/docs/zh/10-deployment/03-k8s.md
index 5d512700b6506893dc3af049b655f4021f753463..ff2d670ec23a7bf0d7df20c6161b9ae81e3a9229 100644
--- a/docs/zh/10-deployment/03-k8s.md
+++ b/docs/zh/10-deployment/03-k8s.md
@@ -366,7 +366,7 @@ kubectl scale statefulsets tdengine --replicas=1
```
-在 taos shell 中的所有数据库操作将无法成功。
+在 TDengine CLI 中的所有数据库操作将无法成功。
```
taos> show dnodes;
diff --git a/docs/zh/12-taos-sql/03-table.md b/docs/zh/12-taos-sql/03-table.md
index a93b010c4c1af5349930225803e6714011d47912..9c33c45efcf006344ba5d84a0cbce7bc683f8559 100644
--- a/docs/zh/12-taos-sql/03-table.md
+++ b/docs/zh/12-taos-sql/03-table.md
@@ -10,27 +10,27 @@ description: 对表的各种管理操作
```sql
CREATE TABLE [IF NOT EXISTS] [db_name.]tb_name (create_definition [, create_definitionn] ...) [table_options]
-
+
CREATE TABLE create_subtable_clause
-
+
CREATE TABLE [IF NOT EXISTS] [db_name.]tb_name (create_definition [, create_definitionn] ...)
[TAGS (create_definition [, create_definitionn] ...)]
[table_options]
-
+
create_subtable_clause: {
create_subtable_clause [create_subtable_clause] ...
| [IF NOT EXISTS] [db_name.]tb_name USING [db_name.]stb_name [(tag_name [, tag_name] ...)] TAGS (tag_value [, tag_value] ...)
}
-
+
create_definition:
col_name column_definition
-
+
column_definition:
type_name [comment 'string_value']
-
+
table_options:
table_option ...
-
+
table_option: {
COMMENT 'string_value'
| WATERMARK duration[,duration]
@@ -54,12 +54,13 @@ table_option: {
需要注意的是转义字符中的内容必须是可打印字符。
**参数说明**
+
1. COMMENT：表注释。可用于超级表、子表和普通表。
-2. WATERMARK：指定窗口的关闭时间，默认值为 5 秒，最小单位毫秒，范围为0到15分钟，多个以逗号分隔。只可用于超级表，且只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。
-3. MAX_DELAY：用于控制推送计算结果的最大延迟，默认值为 interval 的值(但不能超过最大值)，最小单位毫秒，范围为1毫秒到15分钟，多个以逗号分隔。注：不建议 MAX_DELAY 设置太小，否则会过于频繁的推送结果，影响存储和查询性能，如无特殊需求，取默认值即可。只可用于超级表，且只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。
-4. ROLLUP：Rollup 指定的聚合函数，提供基于多层级的降采样聚合结果。只可用于超级表。只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。作用于超级表除TS列外的其它所有列，但是只能定义一个聚合函数。 聚合函数支持 avg, sum, min, max, last, first。
-5. SMA：Small Materialized Aggregates，提供基于数据块的自定义预计算功能。预计算类型包括MAX、MIN和SUM。可用于超级表/普通表。
-6. TTL：Time to Live，是用户用来指定表的生命周期的参数。如果在持续的TTL时间内，都没有数据写入该表，则TDengine系统会自动删除该表。这个TTL的时间只是一个大概时间，我们系统不保证到了时间一定会将其删除，而只保证存在这样一个机制。TTL单位是天，默认为0，表示不限制。用户需要注意，TTL优先级高于KEEP，即TTL时间满足删除机制时，即使当前数据的存在时间小于KEEP，此表也会被删除。只可用于子表和普通表。
+2. WATERMARK：指定窗口的关闭时间，默认值为 5 秒，最小单位毫秒，范围为 0 到 15 分钟，多个以逗号分隔。只可用于超级表，且只有当数据库使用了 RETENTIONS 参数时，才可以使用此表参数。
+3. MAX_DELAY：用于控制推送计算结果的最大延迟，默认值为 interval 的值(但不能超过最大值)，最小单位毫秒，范围为 1 毫秒到 15 分钟，多个以逗号分隔。注：不建议 MAX_DELAY 设置太小，否则会过于频繁的推送结果，影响存储和查询性能，如无特殊需求，取默认值即可。只可用于超级表，且只有当数据库使用了 RETENTIONS 参数时，才可以使用此表参数。
+4. ROLLUP：Rollup 指定的聚合函数，提供基于多层级的降采样聚合结果。只可用于超级表。只有当数据库使用了 RETENTIONS 参数时，才可以使用此表参数。作用于超级表除 TS 列外的其它所有列，但是只能定义一个聚合函数。 聚合函数支持 avg, sum, min, max, last, first。
+5. SMA：Small Materialized Aggregates，提供基于数据块的自定义预计算功能。预计算类型包括 MAX、MIN 和 SUM。可用于超级表/普通表。
+6. TTL：Time to Live，是用户用来指定表的生命周期的参数。如果创建表时指定了这个参数，当该表的存在时间超过 TTL 指定的时间后，TDengine 自动删除该表。这个 TTL 的时间只是一个大概时间，系统不保证到了时间一定会将其删除，而只保证存在这样一个机制且最终一定会删除。TTL 单位是天，默认为 0，表示不限制，到期时间为表创建时间加上 TTL 时间。
## 创建子表
@@ -89,7 +90,7 @@ CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) [IF
```sql
ALTER TABLE [db_name.]tb_name alter_table_clause
-
+
alter_table_clause: {
alter_table_options
| ADD COLUMN col_name column_type
@@ -97,10 +98,10 @@ alter_table_clause: {
| MODIFY COLUMN col_name column_type
| RENAME COLUMN old_col_name new_col_name
}
-
+
alter_table_options:
alter_table_option ...
-
+
alter_table_option: {
TTL value
| COMMENT 'string_value'
@@ -110,6 +111,7 @@ alter_table_option: {
**使用说明**
对普通表可以进行如下修改操作
+
1. ADD COLUMN：添加列。
2. DROP COLUMN：删除列。
3. MODIFY COLUMN：修改列定义，如果数据列的类型是可变长类型，那么可以使用此指令修改其宽度，只能改大，不能改小。
@@ -143,15 +145,15 @@ ALTER TABLE tb_name RENAME COLUMN old_col_name new_col_name
```sql
ALTER TABLE [db_name.]tb_name alter_table_clause
-
+
alter_table_clause: {
alter_table_options
| SET TAG tag_name = new_tag_value
}
-
+
alter_table_options:
alter_table_option ...
-
+
alter_table_option: {
TTL value
| COMMENT 'string_value'
@@ -159,6 +161,7 @@ alter_table_option: {
```
**使用说明**
+
1. 对子表的列和标签的修改，除了更改标签值以外，都要通过超级表才能进行。
### 修改子表标签值
@@ -169,7 +172,7 @@ ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
## 删除表
-可以在一条SQL语句中删除一个或多个普通表或子表。
+可以在一条 SQL 语句中删除一个或多个普通表或子表。
```sql
DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
@@ -179,7 +182,7 @@ DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
### 显示所有表
-如下SQL语句可以列出当前数据库中的所有表名。
+如下 SQL 语句可以列出当前数据库中的所有表名。
```sql
SHOW TABLES [LIKE tb_name_wildchar];
diff --git a/docs/zh/12-taos-sql/24-show.md b/docs/zh/12-taos-sql/24-show.md
index 14b51fb4c1414a93032c33384750f0334cb12eab..b4aafdaa0af644e05e47106b76e0c7ab074a61b8 100644
--- a/docs/zh/12-taos-sql/24-show.md
+++ b/docs/zh/12-taos-sql/24-show.md
@@ -195,7 +195,7 @@ SHOW STREAMS;
SHOW SUBSCRIPTIONS;
```
-显示当前数据库下的所有的订阅关系
+显示当前系统内所有的订阅关系
## SHOW TABLES
diff --git a/docs/zh/14-reference/11-docker/index.md b/docs/zh/14-reference/11-docker/index.md
index 743fc2d32f82778fb97e7879972cd23db1159c8e..d712e9aba8bf5d79c98abbe65222722497c66dee 100644
--- a/docs/zh/14-reference/11-docker/index.md
+++ b/docs/zh/14-reference/11-docker/index.md
@@ -32,7 +32,7 @@ taos> show databases;
Query OK, 2 rows in database (0.033802s)
```
-因为运行在容器中的 TDengine 服务端使用容器的 hostname 建立连接，使用 taos shell 或者各种连接器（例如 JDBC-JNI）从容器外访问容器内的 TDengine 比较复杂，所以上述方式是访问容器中 TDengine 服务的最简单的方法，适用于一些简单场景。如果在一些复杂场景下想要从容器化使用 taos shell 或者各种连接器访问容器中的 TDengine 服务，请参考下一节。
+因为运行在容器中的 TDengine 服务端使用容器的 hostname 建立连接，使用 TDengine CLI 或者各种连接器（例如 JDBC-JNI）从容器外访问容器内的 TDengine 比较复杂，所以上述方式是访问容器中 TDengine 服务的最简单的方法，适用于一些简单场景。如果在一些复杂场景下想要从容器化使用 TDengine CLI 或者各种连接器访问容器中的 TDengine 服务，请参考下一节。
## 在 host 网络上启动 TDengine
@@ -75,7 +75,7 @@ docker run -d \
echo 127.0.0.1 tdengine |sudo tee -a /etc/hosts
```
-最后，可以从 taos shell 或者任意连接器以 "tdengine" 为服务端地址访问 TDengine 服务。
+最后，可以从 TDengine CLI 或者任意连接器以 "tdengine" 为服务端地址访问 TDengine 服务。
```shell
taos -h tdengine -P 6030
@@ -354,7 +354,7 @@ test-docker_td-2_1 /tini -- /usr/bin/entrypoi ... Up
test-docker_td-3_1 /tini -- /usr/bin/entrypoi ... Up
```
-4. 用 taos shell 查看 dnodes
+4. 用 TDengine CLI 查看 dnodes
```shell
diff --git a/docs/zh/17-operation/01-pkg-install.md b/docs/zh/17-operation/01-pkg-install.md
index 671dc00cee070b4743453727d661f8b086cd0261..6d93c1697b1e0936b3f6539d3b1fb95db0baa956 100644
--- a/docs/zh/17-operation/01-pkg-install.md
+++ b/docs/zh/17-operation/01-pkg-install.md
@@ -47,7 +47,7 @@ lrwxrwxrwx 1 root root 13 Feb 22 09:34 log -> /var/log/taos/
-卸载命令如下:
+TDengine 卸载命令如下:
```
$ sudo apt-get remove tdengine
@@ -65,10 +65,26 @@ TDengine is removed successfully!
```
+taosTools 卸载命令如下:
+
+```
+$ sudo apt remove taostools
+Reading package lists... Done
+Building dependency tree
+Reading state information... Done
+The following packages will be REMOVED:
+ taostools
+0 upgraded, 0 newly installed, 1 to remove and 0 not upgraded.
+After this operation, 68.3 MB disk space will be freed.
+Do you want to continue? [Y/n]
+(Reading database ... 147973 files and directories currently installed.)
+Removing taostools (2.1.2) ...
+```
+
-卸载命令如下:
+TDengine 卸载命令如下:
```
$ sudo dpkg -r tdengine
@@ -78,28 +94,52 @@ TDengine is removed successfully!
```
+taosTools 卸载命令如下:
+
+```
+$ sudo dpkg -r taostools
+(Reading database ... 147973 files and directories currently installed.)
+Removing taostools (2.1.2) ...
+```
+
-卸载命令如下:
+卸载 TDengine 命令如下:
```
$ sudo rpm -e tdengine
TDengine is removed successfully!
```
+卸载 taosTools 命令如下:
+
+```
+sudo rpm -e taostools
+taosToole is removed successfully!
+```
+
-卸载命令如下:
+卸载 TDengine 命令如下:
```
$ rmtaos
TDengine is removed successfully!
```
+卸载 taosTools 命令如下：
+
+```
+$ rmtaostools
+Start to uninstall taos tools ...
+
+taos tools is uninstalled successfully!
+```
+
在 C:\TDengine 目录下，通过运行 unins000.exe 卸载程序来卸载 TDengine。
diff --git a/docs/zh/17-operation/08-export.md b/docs/zh/17-operation/08-export.md
index ecc3b2f1105b6ce37c19e747e2afc4cfc145f0d4..44247e28bdf5ec48ccd05ab6f7e4d3558cf23103 100644
--- a/docs/zh/17-operation/08-export.md
+++ b/docs/zh/17-operation/08-export.md
@@ -7,7 +7,7 @@ description: 如何导出 TDengine 中的数据
## 按表导出 CSV 文件
-如果用户需要导出一个表或一个 STable 中的数据，可在 taos shell 中运行：
+如果用户需要导出一个表或一个 STable 中的数据，可在 TDengine CLI 中运行：
```sql
select * from >> data.csv;
diff --git a/docs/zh/27-train-faq/01-faq.md b/docs/zh/27-train-faq/01-faq.md
index 2fd9dff80b2e1f580b7d66cf94b34a6781698b24..0a46db4a28862e07dd86e427e320e8b2d1276034 100644
--- a/docs/zh/27-train-faq/01-faq.md
+++ b/docs/zh/27-train-faq/01-faq.md
@@ -116,7 +116,7 @@ charset UTF-8
### 9. 表名显示不全
-由于 taos shell 在终端中显示宽度有限，有可能比较长的表名显示不全，如果按照显示的不全的表名进行相关操作会发生 Table does not exist 错误。解决方法可以是通过修改 taos.cfg 文件中的设置项 maxBinaryDisplayWidth， 或者直接输入命令 set max_binary_display_width 100。或者在命令结尾使用 \G 参数来调整结果的显示方式。
+由于 TDengine CLI 在终端中显示宽度有限，有可能比较长的表名显示不全，如果按照显示的不全的表名进行相关操作会发生 Table does not exist 错误。解决方法可以是通过修改 taos.cfg 文件中的设置项 maxBinaryDisplayWidth， 或者直接输入命令 set max_binary_display_width 100。或者在命令结尾使用 \G 参数来调整结果的显示方式。
### 10. 如何进行数据迁移？
diff --git a/examples/JDBC/JDBCDemo/README-jdbc-windows.md b/examples/JDBC/JDBCDemo/README-jdbc-windows.md
index 17c5c8df00ab8727d1adfe493d3fbbd32891a676..5a781f40f730218286edb9f6a7f184ee79e7a5fc 100644
--- a/examples/JDBC/JDBCDemo/README-jdbc-windows.md
+++ b/examples/JDBC/JDBCDemo/README-jdbc-windows.md
@@ -129,7 +129,7 @@ https://www.taosdata.com/cn/all-downloads/
192.168.236.136 td01
```
-配置完成后，在命令行内使用taos shell连接server端
+配置完成后，在命令行内使用TDengine CLI连接server端
```shell
C:\TDengine>taos -h td01
diff --git a/examples/nodejs/README-win.md b/examples/nodejs/README-win.md
index 75fec69413af2bb49498118ec7235c9947e2f89e..e496be2f87e3ff0fcc01359f23888734669b0c22 100644
--- a/examples/nodejs/README-win.md
+++ b/examples/nodejs/README-win.md
@@ -35,7 +35,7 @@ Python 2.7.18
下载地址：https://www.taosdata.com/cn/all-downloads/，选择一个合适的windows-client下载（client应该尽量与server端的版本保持一致）
-使用client的taos shell连接server
+使用client的TDengine CLI连接server
```shell
>taos -h node5
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index d09b5eecfa353c42ee483ec43db9a14be766caa6..681094471a7aae3b824c6c28667389c3f08f47d2 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -2677,15 +2677,6 @@ typedef struct {
int32_t tSerializeSMDropSmaReq(void* buf, int32_t bufLen, SMDropSmaReq* pReq);
int32_t tDeserializeSMDropSmaReq(void* buf, int32_t bufLen, SMDropSmaReq* pReq);
-typedef struct {
- int32_t vgId;
- SEpSet epSet;
-} SVgEpSet;
-
-typedef struct {
- int32_t padding;
-} SRSmaExecMsg;
-
typedef struct {
int8_t version; // for compatibility(default 0)
int8_t intervalUnit; // MACRO: TIME_UNIT_XXX
diff --git a/include/os/os.h b/include/os/os.h
index b036002f8adb5d246db8346112f2189f779f73cd..71966061a19a175d816010ff6425b4004b1f2223 100644
--- a/include/os/os.h
+++ b/include/os/os.h
@@ -79,6 +79,7 @@ extern "C" {
#include
#include
+#include "taoserror.h"
#include "osAtomic.h"
#include "osDef.h"
#include "osDir.h"
diff --git a/include/os/osSemaphore.h b/include/os/osSemaphore.h
index 7fca20d75e2eaece441656bc4ae2c707e0b15cd3..2a3a2e64b623282cf187eed322c880457b83ca74 100644
--- a/include/os/osSemaphore.h
+++ b/include/os/osSemaphore.h
@@ -1,75 +1,74 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see .
- */
-
-#ifndef _TD_OS_SEMPHONE_H_
-#define _TD_OS_SEMPHONE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include
-
-#if defined(_TD_DARWIN_64)
-
-// typedef struct tsem_s *tsem_t;
-typedef struct bosal_sem_t *tsem_t;
-
-
-int tsem_init(tsem_t *sem, int pshared, unsigned int value);
-int tsem_wait(tsem_t *sem);
-int tsem_timewait(tsem_t *sim, int64_t nanosecs);
-int tsem_post(tsem_t *sem);
-int tsem_destroy(tsem_t *sem);
-
-#else
-
-#define tsem_t sem_t
-#define tsem_init sem_init
-int tsem_wait(tsem_t *sem);
-int tsem_timewait(tsem_t *sim, int64_t nanosecs);
-#define tsem_post sem_post
-#define tsem_destroy sem_destroy
-
-#endif
-
-#if defined(_TD_DARWIN_64)
-// #define TdThreadRwlock TdThreadMutex
-// #define taosThreadRwlockInit(lock, NULL) taosThreadMutexInit(lock, NULL)
-// #define taosThreadRwlockDestroy(lock) taosThreadMutexDestroy(lock)
-// #define taosThreadRwlockWrlock(lock) taosThreadMutexLock(lock)
-// #define taosThreadRwlockRdlock(lock) taosThreadMutexLock(lock)
-// #define taosThreadRwlockUnlock(lock) taosThreadMutexUnlock(lock)
-
-// #define TdThreadSpinlock TdThreadMutex
-// #define taosThreadSpinInit(lock, NULL) taosThreadMutexInit(lock, NULL)
-// #define taosThreadSpinDestroy(lock) taosThreadMutexDestroy(lock)
-// #define taosThreadSpinLock(lock) taosThreadMutexLock(lock)
-// #define taosThreadSpinUnlock(lock) taosThreadMutexUnlock(lock)
-#endif
-
-bool taosCheckPthreadValid(TdThread thread);
-int64_t taosGetSelfPthreadId();
-int64_t taosGetPthreadId(TdThread thread);
-void taosResetPthread(TdThread *thread);
-bool taosComparePthread(TdThread first, TdThread second);
-int32_t taosGetPId();
-int32_t taosGetAppName(char *name, int32_t *len);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_OS_SEMPHONE_H_*/
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ */
+
+#ifndef _TD_OS_SEMPHONE_H_
+#define _TD_OS_SEMPHONE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include
+
+#if defined(_TD_DARWIN_64)
+#include
+// typedef struct tsem_s *tsem_t;
+typedef dispatch_semaphore_t tsem_t;
+
+int tsem_init(tsem_t *sem, int pshared, unsigned int value);
+int tsem_wait(tsem_t *sem);
+int tsem_timewait(tsem_t *sim, int64_t nanosecs);
+int tsem_post(tsem_t *sem);
+int tsem_destroy(tsem_t *sem);
+
+#else
+
+#define tsem_t sem_t
+#define tsem_init sem_init
+int tsem_wait(tsem_t *sem);
+int tsem_timewait(tsem_t *sim, int64_t nanosecs);
+#define tsem_post sem_post
+#define tsem_destroy sem_destroy
+
+#endif
+
+#if defined(_TD_DARWIN_64)
+// #define TdThreadRwlock TdThreadMutex
+// #define taosThreadRwlockInit(lock, NULL) taosThreadMutexInit(lock, NULL)
+// #define taosThreadRwlockDestroy(lock) taosThreadMutexDestroy(lock)
+// #define taosThreadRwlockWrlock(lock) taosThreadMutexLock(lock)
+// #define taosThreadRwlockRdlock(lock) taosThreadMutexLock(lock)
+// #define taosThreadRwlockUnlock(lock) taosThreadMutexUnlock(lock)
+
+// #define TdThreadSpinlock TdThreadMutex
+// #define taosThreadSpinInit(lock, NULL) taosThreadMutexInit(lock, NULL)
+// #define taosThreadSpinDestroy(lock) taosThreadMutexDestroy(lock)
+// #define taosThreadSpinLock(lock) taosThreadMutexLock(lock)
+// #define taosThreadSpinUnlock(lock) taosThreadMutexUnlock(lock)
+#endif
+
+bool taosCheckPthreadValid(TdThread thread);
+int64_t taosGetSelfPthreadId();
+int64_t taosGetPthreadId(TdThread thread);
+void taosResetPthread(TdThread *thread);
+bool taosComparePthread(TdThread first, TdThread second);
+int32_t taosGetPId();
+int32_t taosGetAppName(char *name, int32_t *len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_OS_SEMPHONE_H_*/
diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg
index aae2e7c856ac7ce4747d798acf5852d6cdf21535..87f465fdb93ddbff8973430b11ecadc13878069d 100644
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -38,7 +38,7 @@
# The interval of dnode reporting status to mnode
# statusInterval 1
-# The interval for taos shell to send heartbeat to mnode
+# The interval for TDengine CLI to send heartbeat to mnode
# shellActivityTimer 3
# The minimum sliding window time, milli-second
diff --git a/packaging/deb/DEBIAN/prerm b/packaging/deb/DEBIAN/prerm
index 49531028423142ccc9808b90b772bd97b0b3fc58..65f261db2c6c1ac70b761312af68a5188acea541 100644
--- a/packaging/deb/DEBIAN/prerm
+++ b/packaging/deb/DEBIAN/prerm
@@ -1,6 +1,6 @@
#!/bin/bash
-if [ $1 -eq "abort-upgrade" ]; then
+if [ "$1"x = "abort-upgrade"x ]; then
exit 0
fi
diff --git a/packaging/docker/README.md b/packaging/docker/README.md
index e41182f471050af6b4d47b696eb237e319b2dd80..cb27d3bca69ff3b9f6919cb7a47ac076008b29c1 100644
--- a/packaging/docker/README.md
+++ b/packaging/docker/README.md
@@ -47,7 +47,7 @@ taos> show databases;
Query OK, 1 row(s) in set (0.002843s)
```
-Since TDengine use container hostname to establish connections, it's a bit more complex to use taos shell and native connectors(such as JDBC-JNI) with TDengine container instance. This is the recommended way to expose ports and use TDengine with docker in simple cases. If you want to use taos shell or taosc/connectors smoothly outside the `tdengine` container, see next use cases that match you need.
+Since TDengine use container hostname to establish connections, it's a bit more complex to use TDengine CLI and native connectors(such as JDBC-JNI) with TDengine container instance. This is the recommended way to expose ports and use TDengine with docker in simple cases. If you want to use TDengine CLI or taosc/connectors smoothly outside the `tdengine` container, see next use cases that match you need.
### Start with host network
@@ -87,7 +87,7 @@ docker run -d \
This command starts a docker container with TDengine server running and maps the container's TCP ports from 6030 to 6049 to the host's ports from 6030 to 6049 with TCP protocol and UDP ports range 6030-6039 to the host's UDP ports 6030-6039. If the host is already running TDengine server and occupying the same port(s), you need to map the container's port to a different unused port segment. (Please see TDengine 2.0 Port Description for details). In order to support TDengine clients accessing TDengine server services, both TCP and UDP ports need to be exposed by default(unless `rpcForceTcp` is set to `1`).
-If you want to use taos shell or native connectors([JDBC-JNI](https://www.taosdata.com/cn/documentation/connector/java), or [driver-go](https://github.com/taosdata/driver-go)), you need to make sure the `TAOS_FQDN` is resolvable at `/etc/hosts` or with custom DNS service.
+If you want to use TDengine CLI or native connectors([JDBC-JNI](https://www.taosdata.com/cn/documentation/connector/java), or [driver-go](https://github.com/taosdata/driver-go)), you need to make sure the `TAOS_FQDN` is resolvable at `/etc/hosts` or with custom DNS service.
If you set the `TAOS_FQDN` to host's hostname, it will works as using `hosts` network like previous use case. Otherwise, like in `-e TAOS_FQDN=tdengine`, you can add the hostname record `tdengine` into `/etc/hosts` (use `127.0.0.1` here in host path, if use TDengine client/application in other hosts, you should set the right ip to the host eg. `192.168.10.1`(check the real ip in host with `hostname -i` or `ip route list default`) to make the TDengine endpoint resolvable):
@@ -391,7 +391,7 @@ test_td-1_1 /usr/bin/entrypoint.sh taosd Up 6030/tcp, 6031/tcp,
test_td-2_1 /usr/bin/entrypoint.sh taosd Up 6030/tcp, 6031/tcp, 6032/tcp, 6033/tcp, 6034/tcp, 6035/tcp, 6036/tcp, 6037/tcp, 6038/tcp, 6039/tcp, 6040/tcp, 6041/tcp, 6042/tcp
```
-Check dnodes with taos shell:
+Check dnodes with TDengine CLI:
```bash
$ docker-compose exec td-1 taos -s "show dnodes"
diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh
index 6a95ace99ee521b9e1baca39d72bf7fa1cabb7d5..f554942ce330767b45ef5ec2ee0df422c273c5ed 100755
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -381,8 +381,7 @@ function install_header() {
${install_main_dir}/include ||
${csudo}cp -f ${source_dir}/include/client/taos.h ${source_dir}/include/common/taosdef.h ${source_dir}/include/util/taoserror.h ${source_dir}/include/libs/function/taosudf.h \
${install_main_2_dir}/include &&
- ${csudo}chmod 644 ${install_main_dir}/include/* ||:
- ${csudo}chmod 644 ${install_main_2_dir}/include/*
+ ${csudo}chmod 644 ${install_main_dir}/include/* || ${csudo}chmod 644 ${install_main_2_dir}/include/*
fi
}
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 0480c49ca189bc9e00e665657ba4302f2fda8690..2baca1288fe086388cc3e5a424ab289586a864f5 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -1975,7 +1975,7 @@ _OVER:
int32_t appendTbToReq(SHashObj* pHash, int32_t pos1, int32_t len1, int32_t pos2, int32_t len2, const char* str,
int32_t acctId, char* db) {
- SName name;
+ SName name = {0};
if (len1 <= 0) {
return -1;
diff --git a/source/common/src/systable.c b/source/common/src/systable.c
index 0465f1f3f42e3aee46fc738556ed94d653a652ae..9ca896c9ee624740b0602f35544219425db74779 100644
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@@ -350,7 +350,7 @@ static const SSysTableMeta perfsMeta[] = {
{TSDB_PERFS_TABLE_SUBSCRIPTIONS, subscriptionSchema, tListLen(subscriptionSchema), false},
// {TSDB_PERFS_TABLE_OFFSETS, offsetSchema, tListLen(offsetSchema)},
{TSDB_PERFS_TABLE_TRANS, transSchema, tListLen(transSchema), false},
- {TSDB_PERFS_TABLE_SMAS, smaSchema, tListLen(smaSchema), false},
+ // {TSDB_PERFS_TABLE_SMAS, smaSchema, tListLen(smaSchema), false},
{TSDB_PERFS_TABLE_STREAMS, streamSchema, tListLen(streamSchema), false},
{TSDB_PERFS_TABLE_APPS, appSchema, tListLen(appSchema), false}};
// clang-format on
diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c
index 2fb934aaad735240e1a249447b5d041853819d82..8638cc511890066f45367253313aec8f626ceb8e 100644
--- a/source/dnode/mnode/impl/src/mndSma.c
+++ b/source/dnode/mnode/impl/src/mndSma.c
@@ -38,7 +38,6 @@ static SSdbRow *mndSmaActionDecode(SSdbRaw *pRaw);
static int32_t mndSmaActionInsert(SSdb *pSdb, SSmaObj *pSma);
static int32_t mndSmaActionDelete(SSdb *pSdb, SSmaObj *pSpSmatb);
static int32_t mndSmaActionUpdate(SSdb *pSdb, SSmaObj *pOld, SSmaObj *pNew);
-static int32_t mndSmaGetVgEpSet(SMnode *pMnode, SDbObj *pDb, SVgEpSet **ppVgEpSet, int32_t *numOfVgroups);
static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq);
static int32_t mndProcessDropSmaReq(SRpcMsg *pReq);
static int32_t mndProcessGetSmaReq(SRpcMsg *pReq);
@@ -841,6 +840,7 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
_OVER:
mndTransDrop(pTrans);
+ mndReleaseStream(pMnode, pStream);
mndReleaseVgroup(pMnode, pVgroup);
mndReleaseStb(pMnode, pStb);
return code;
@@ -961,6 +961,7 @@ _OVER:
mError("sma:%s, failed to drop since %s", dropReq.name, terrstr());
}
+ mndReleaseSma(pMnode, pSma);
mndReleaseDb(pMnode, pDb);
return code;
}
diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c
index 6dc8e2072b71df78aa88aecdd924a98db658ab05..dd7a9e71eaa634a5bda506b318c6c4472a48726b 100644
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@@ -631,6 +631,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
SStreamObj *pStream = NULL;
SDbObj *pDb = NULL;
SCMCreateStreamReq createStreamReq = {0};
+ SStreamObj streamObj = {0};
if (tDeserializeSCMCreateStreamReq(pReq->pCont, pReq->contLen, &createStreamReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
@@ -659,7 +660,6 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
}
// build stream obj from request
- SStreamObj streamObj = {0};
if (mndBuildStreamObjFromCreateReq(pMnode, &streamObj, &createStreamReq) < 0) {
/*ASSERT(0);*/
mError("stream:%s, failed to create since %s", createStreamReq.name, terrstr());
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 627dbf0ac5ebecbbd8abe3ea7dc135933142a6e1..f69123840c8cbc7650d254edcbc01bbc62360842 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -63,7 +63,7 @@ void vnodeGetInfo(SVnode *pVnode, const char **dbname, int32_t *vgId);
int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen);
int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list);
int32_t vnodeGetCtbIdList(SVnode *pVnode, int64_t suid, SArray *list);
-int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray* list);
+int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray *list);
void *vnodeGetIdx(SVnode *pVnode);
void *vnodeGetIvtIdx(SVnode *pVnode);
@@ -96,7 +96,7 @@ int32_t metaGetTableTags(SMeta *pMeta, uint64_t suid, SArray *uidList, SHash
int32_t metaReadNext(SMetaReader *pReader);
const void *metaGetTableTagVal(void *tag, int16_t type, STagVal *tagVal);
int metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName);
-bool metaIsTableExist(SMeta *pMeta, tb_uid_t uid);
+bool metaIsTableExist(SMeta *pMeta, tb_uid_t uid);
typedef struct SMetaFltParam {
tb_uid_t suid;
@@ -255,6 +255,7 @@ typedef struct {
int64_t numOfSTables;
int64_t numOfCTables;
int64_t numOfNTables;
+ int64_t numOfNTimeSeries;
int64_t numOfTimeSeries;
int64_t pointsWritten;
int64_t totalStorage;
diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c
index 35450bbc88386a57182fb2d4a6b243b7d4545eab..9d3b4d82ebd6041d2c310e622d9ae19c57f2bfad 100644
--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
@@ -619,7 +619,7 @@ int64_t metaGetTimeSeriesNum(SMeta *pMeta) {
vnodeGetTimeSeriesNum(pMeta->pVnode, &num);
pMeta->pVnode->config.vndStats.numOfTimeSeries = num;
- return pMeta->pVnode->config.vndStats.numOfTimeSeries;
+ return pMeta->pVnode->config.vndStats.numOfTimeSeries + pMeta->pVnode->config.vndStats.numOfNTimeSeries;
}
typedef struct {
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 21a5d9a000f68be6c551094b3141da91bd317482..583a2e098f8a54ac61f21d696c6e65c62cd5c4ab 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -444,6 +444,7 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMe
me.ntbEntry.ncid = me.ntbEntry.schemaRow.pSchema[me.ntbEntry.schemaRow.nCols - 1].colId + 1;
++pMeta->pVnode->config.vndStats.numOfNTables;
+ pMeta->pVnode->config.vndStats.numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1;
}
if (metaHandleEntry(pMeta, &me) < 0) goto _err;
@@ -552,6 +553,9 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
SDecoder dc = {0};
rc = tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &pData, &nData);
+ if (rc < 0) {
+ return -1;
+ }
int64_t version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData);
@@ -598,6 +602,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
// drop schema.db (todo)
--pMeta->pVnode->config.vndStats.numOfNTables;
+ pMeta->pVnode->config.vndStats.numOfNTimeSeries -= e.ntbEntry.schemaRow.nCols - 1;
} else if (e.type == TSDB_SUPER_TABLE) {
tdbTbDelete(pMeta->pSuidIdx, &e.uid, sizeof(tb_uid_t), &pMeta->txn);
// drop schema.db (todo)
@@ -700,6 +705,8 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].flags = pAlterTbReq->flags;
pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].colId = entry.ntbEntry.ncid++;
strcpy(pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].name, pAlterTbReq->colName);
+
+ ++pMeta->pVnode->config.vndStats.numOfNTimeSeries;
break;
case TSDB_ALTER_TABLE_DROP_COLUMN:
if (pColumn == NULL) {
@@ -720,6 +727,8 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
memmove(pColumn, pColumn + 1, tlen);
}
pSchema->nCols--;
+
+ --pMeta->pVnode->config.vndStats.numOfNTimeSeries;
break;
case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
if (pColumn == NULL) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c
index b9f38976747f7e73f6bc6b40fe9dd968a3b8cabe..61c68775559ebcbaca1853fdadecaaa1456c170c 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@@ -476,7 +476,7 @@ static int32_t getNextRowFromFSLast(void *iter, TSDBROW **ppRow) {
if (code) goto _err;
if (!state->aBlockL) {
- state->aBlockL = taosArrayInit(0, sizeof(SBlockIdx));
+ state->aBlockL = taosArrayInit(0, sizeof(SBlockL));
} else {
taosArrayClear(state->aBlockL);
}
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 4265f1b9b6ef7d3a407e71ebe5370bf0379f5a19..dae0800c71e911e1e379ff329716400b0ffdda94 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -129,13 +129,19 @@ typedef struct SFileBlockDumpInfo {
bool allDumped;
} SFileBlockDumpInfo;
+typedef struct SUidOrderCheckInfo {
+ uint64_t* tableUidList; // access table uid list in uid ascending order list
+ int32_t currentIndex; // index in table uid list
+} SUidOrderCheckInfo;
+
typedef struct SReaderStatus {
- bool loadFromFile; // check file stage
+ bool loadFromFile; // check file stage
bool composedDataBlock; // the returned data block is a composed block or not
- SHashObj* pTableMap; // SHash
- STableBlockScanInfo* pTableIter; // table iterator used in building in-memory buffer data blocks.
+ SHashObj* pTableMap; // SHash
+ STableBlockScanInfo* pTableIter; // table iterator used in building in-memory buffer data blocks.
+ SUidOrderCheckInfo uidCheckInfo; // check all table in uid order
SFileBlockDumpInfo fBlockDumpInfo;
- SDFileSet* pCurrentFileset; // current opened file set
+ SDFileSet* pCurrentFileset; // current opened file set
SBlockData fileBlockData;
SFilesetIter fileIter;
SDataBlockIter blockIter;
@@ -573,7 +579,7 @@ static void cleanupTableScanInfo(SHashObj* pTableMap) {
}
// reset the index in last block when handing a new file
- px->indexInBlockL = -1;
+ px->indexInBlockL = DEFAULT_ROW_INDEX_VAL;
tMapDataClear(&px->mapData);
taosArrayClear(px->pBlockList);
}
@@ -651,9 +657,11 @@ static int32_t doLoadFileBlock(STsdbReader* pReader, SArray* pIndexList, SArray*
int32_t total = pBlockNum->numOfLastBlocks + pBlockNum->numOfBlocks;
double el = (taosGetTimestampUs() - st) / 1000.0;
- tsdbDebug("load block of %d tables completed, blocks:%d in %d tables, lastBlock:%d, size:%.2f Kb, elapsed time:%.2f ms %s",
- numOfTables, pBlockNum->numOfBlocks, numOfQTable, pBlockNum->numOfLastBlocks, sizeInDisk
- / 1000.0, el, pReader->idStr);
+ tsdbDebug(
+ "load block of %d tables completed, blocks:%d in %d tables, lastBlock:%d, block-info-size:%.2f Kb, elapsed "
+ "time:%.2f ms %s",
+ numOfTables, pBlockNum->numOfBlocks, numOfQTable, pBlockNum->numOfLastBlocks, sizeInDisk / 1000.0, el,
+ pReader->idStr);
pReader->cost.numOfBlocks += total;
pReader->cost.headFileLoadTime += el;
@@ -1810,7 +1818,8 @@ static void setAllRowsChecked(SLastBlockReader *pLastBlockReader) {
}
static bool nextRowInLastBlock(SLastBlockReader *pLastBlockReader, STableBlockScanInfo* pBlockScanInfo) {
- int32_t step = (pLastBlockReader->order == TSDB_ORDER_ASC) ? 1 : -1;
+ bool asc = ASCENDING_TRAVERSE(pLastBlockReader->order);
+ int32_t step = (asc) ? 1 : -1;
if (*pLastBlockReader->rowIndex == ALL_ROWS_CHECKED_INDEX) {
return false;
}
@@ -1819,8 +1828,20 @@ static bool nextRowInLastBlock(SLastBlockReader *pLastBlockReader, STableBlockSc
SBlockData* pBlockData = &pLastBlockReader->lastBlockData;
for(int32_t i = *(pLastBlockReader->rowIndex); i < pBlockData->nRow && i >= 0; i += step) {
- if (pBlockData->aUid != NULL && pBlockData->aUid[i] != pLastBlockReader->uid) {
- continue;
+ if (pBlockData->aUid != NULL) {
+ if (asc) {
+ if (pBlockData->aUid[i] < pLastBlockReader->uid) {
+ continue;
+ } else if (pBlockData->aUid[i] > pLastBlockReader->uid) {
+ break;
+ }
+ } else {
+ if (pBlockData->aUid[i] > pLastBlockReader->uid) {
+ continue;
+ } else if (pBlockData->aUid[i] < pLastBlockReader->uid) {
+ break;
+ }
+ }
}
int64_t ts = pBlockData->aTSKEY[i];
@@ -1866,7 +1887,7 @@ static bool hasDataInLastBlock(SLastBlockReader* pLastBlockReader) {
if (*pLastBlockReader->rowIndex == ALL_ROWS_CHECKED_INDEX) {
return false;
}
-
+
ASSERT(pLastBlockReader->lastBlockData.nRow > 0);
return true;
}
@@ -1891,7 +1912,7 @@ int32_t mergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pBloc
tRowMergerClear(&merge);
return TSDB_CODE_SUCCESS;
}
-
+
return TSDB_CODE_SUCCESS;
}
@@ -1959,7 +1980,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
}
}
}
-
+
bool hasBlockLData = hasDataInLastBlock(pLastBlockReader);
// no data in last block and block, no need to proceed.
@@ -1987,9 +2008,12 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
setComposedBlockFlag(pReader, true);
int64_t et = taosGetTimestampUs();
- tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%d, elapsed time:%.2f ms %s",
- pReader, pBlockScanInfo->uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,
- pResBlock->info.rows, (et - st) / 1000.0, pReader->idStr);
+ if (pResBlock->info.rows > 0) {
+ tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64
+ " rows:%d, elapsed time:%.2f ms %s",
+ pReader, pBlockScanInfo->uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,
+ pResBlock->info.rows, (et - st) / 1000.0, pReader->idStr);
+ }
return TSDB_CODE_SUCCESS;
}
@@ -2279,22 +2303,98 @@ static int32_t doLoadRelatedLastBlock(SLastBlockReader* pLastBlockReader, STable
return TSDB_CODE_SUCCESS;
}
-static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
- SReaderStatus* pStatus = &pReader->status;
- SLastBlockReader* pLastBlockReader = pStatus->fileIter.pLastBlockReader;
+static int32_t uidComparFunc(const void* p1, const void* p2) {
+ uint64_t pu1 = *(uint64_t*) p1;
+ uint64_t pu2 = *(uint64_t*) p2;
+ if (pu1 == pu2) {
+ return 0;
+ } else {
+ return (pu1 < pu2)? -1:1;
+ }
+}
- while(1) {
- if (pStatus->pTableIter == NULL) {
- pStatus->pTableIter = taosHashIterate(pStatus->pTableMap, NULL);
+static void extractOrderedTableUidList(SUidOrderCheckInfo *pOrderCheckInfo, SReaderStatus* pStatus) {
+ int32_t index = 0;
+ int32_t total = taosHashGetSize(pStatus->pTableMap);
+
+ void* p = taosHashIterate(pStatus->pTableMap, NULL);
+ while(p != NULL) {
+ STableBlockScanInfo* pScanInfo = p;
+ pOrderCheckInfo->tableUidList[index++] = pScanInfo->uid;
+ p = taosHashIterate(pStatus->pTableMap, p);
+ }
+
+ taosSort(pOrderCheckInfo->tableUidList, total, sizeof(uint64_t), uidComparFunc);
+}
+
+static int32_t initOrderCheckInfo(SUidOrderCheckInfo* pOrderCheckInfo, SReaderStatus* pStatus) {
+ if (pOrderCheckInfo->tableUidList == NULL) {
+ int32_t total = taosHashGetSize(pStatus->pTableMap);
+
+ pOrderCheckInfo->currentIndex = 0;
+ pOrderCheckInfo->tableUidList = taosMemoryMalloc(total * sizeof(uint64_t));
+ if (pOrderCheckInfo->tableUidList == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
+ extractOrderedTableUidList(pOrderCheckInfo, pStatus);
+
+ uint64_t uid = pOrderCheckInfo->tableUidList[0];
+ pStatus->pTableIter = taosHashGet(pStatus->pTableMap, &uid, sizeof(uid));
+ } else {
+ if (pStatus->pTableIter == NULL) { // it is the last block of a new file
+// ASSERT(pOrderCheckInfo->currentIndex == taosHashGetSize(pStatus->pTableMap));
+
+ pOrderCheckInfo->currentIndex = 0;
+ uint64_t uid = pOrderCheckInfo->tableUidList[pOrderCheckInfo->currentIndex];
+ pStatus->pTableIter = taosHashGet(pStatus->pTableMap, &uid, sizeof(uid));
+
+ // the tableMap has already updated
if (pStatus->pTableIter == NULL) {
- return TSDB_CODE_SUCCESS;
+ void* p = taosMemoryRealloc(pOrderCheckInfo->tableUidList, taosHashGetSize(pStatus->pTableMap)*sizeof(uint64_t));
+ if (p == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
+ pOrderCheckInfo->tableUidList = p;
+ extractOrderedTableUidList(pOrderCheckInfo, pStatus);
+
+ uid = pOrderCheckInfo->tableUidList[0];
+ pStatus->pTableIter = taosHashGet(pStatus->pTableMap, &uid, sizeof(uid));
}
}
+ }
+
+ return TSDB_CODE_SUCCESS;
+}
+
+static bool moveToNextTable(SUidOrderCheckInfo *pOrderedCheckInfo, SReaderStatus* pStatus) {
+ pOrderedCheckInfo->currentIndex += 1;
+ if (pOrderedCheckInfo->currentIndex >= taosHashGetSize(pStatus->pTableMap)) {
+ pStatus->pTableIter = NULL;
+ return false;
+ }
+
+ uint64_t uid = pOrderedCheckInfo->tableUidList[pOrderedCheckInfo->currentIndex];
+ pStatus->pTableIter = taosHashGet(pStatus->pTableMap, &uid, sizeof(uid));
+ ASSERT(pStatus->pTableIter != NULL);
+ return true;
+}
+
+static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
+ SReaderStatus* pStatus = &pReader->status;
+ SLastBlockReader* pLastBlockReader = pStatus->fileIter.pLastBlockReader;
+
+ SUidOrderCheckInfo *pOrderedCheckInfo = &pStatus->uidCheckInfo;
+ int32_t code = initOrderCheckInfo(pOrderedCheckInfo, pStatus);
+ if (code != TSDB_CODE_SUCCESS || (taosHashGetSize(pStatus->pTableMap) == 0)) {
+ return code;
+ }
+ while(1) {
// load the last data block of current table
- // todo opt perf by avoiding load last block repeatly
STableBlockScanInfo* pScanInfo = pStatus->pTableIter;
- int32_t code = doLoadRelatedLastBlock(pLastBlockReader, pScanInfo, pReader);
+ code = doLoadRelatedLastBlock(pLastBlockReader, pScanInfo, pReader);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
@@ -2302,19 +2402,20 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
if (pLastBlockReader->currentBlockIndex != -1) {
initLastBlockReader(pLastBlockReader, pScanInfo->uid, &pScanInfo->indexInBlockL);
int32_t index = pScanInfo->indexInBlockL;
+
if (index == DEFAULT_ROW_INDEX_VAL || index == pLastBlockReader->lastBlockData.nRow) {
bool hasData = nextRowInLastBlock(pLastBlockReader, pScanInfo);
if (!hasData) { // current table does not have rows in last block, try next table
- pStatus->pTableIter = taosHashIterate(pStatus->pTableMap, pStatus->pTableIter);
- if (pStatus->pTableIter == NULL) {
+ bool hasNexTable = moveToNextTable(pOrderedCheckInfo, pStatus);
+ if (!hasNexTable) {
return TSDB_CODE_SUCCESS;
}
continue;
}
}
} else { // no data in last block, try next table
- pStatus->pTableIter = taosHashIterate(pStatus->pTableMap, pStatus->pTableIter);
- if (pStatus->pTableIter == NULL) {
+ bool hasNexTable = moveToNextTable(pOrderedCheckInfo, pStatus);
+ if (!hasNexTable) {
return TSDB_CODE_SUCCESS;
}
continue;
@@ -2330,8 +2431,8 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
}
// current table is exhausted, let's try next table
- pStatus->pTableIter = taosHashIterate(pStatus->pTableMap, pStatus->pTableIter);
- if (pStatus->pTableIter == NULL) {
+ bool hasNexTable = moveToNextTable(pOrderedCheckInfo, pStatus);
+ if (!hasNexTable) {
return TSDB_CODE_SUCCESS;
}
}
@@ -3343,6 +3444,8 @@ void tsdbReaderClose(STsdbReader* pReader) {
tsdbDataFReaderClose(&pReader->pFileReader);
}
+ taosMemoryFree(pReader->status.uidCheckInfo.tableUidList);
+
SFilesetIter* pFilesetIter = &pReader->status.fileIter;
if (pFilesetIter->pLastBlockReader != NULL) {
tBlockDataDestroy(&pFilesetIter->pLastBlockReader->lastBlockData, true);
diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c
index 4418ce20e88b8c461e55fbe0d7b4a8348e032379..580ab8bc93cac3a5057821f238cf85fc1011fa38 100644
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
@@ -117,6 +117,7 @@ int vnodeEncodeConfig(const void *pObj, SJson *pJson) {
if (tjsonAddIntegerToObject(pJson, "vndStats.ctables", pCfg->vndStats.numOfCTables) < 0) return -1;
if (tjsonAddIntegerToObject(pJson, "vndStats.ntables", pCfg->vndStats.numOfNTables) < 0) return -1;
if (tjsonAddIntegerToObject(pJson, "vndStats.timeseries", pCfg->vndStats.numOfTimeSeries) < 0) return -1;
+ if (tjsonAddIntegerToObject(pJson, "vndStats.ntimeseries", pCfg->vndStats.numOfNTimeSeries) < 0) return -1;
SJson *pNodeInfoArr = tjsonCreateArray();
tjsonAddItemToObject(pJson, "syncCfg.nodeInfo", pNodeInfoArr);
@@ -224,6 +225,8 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
if (code < 0) return -1;
tjsonGetNumberValue(pJson, "vndStats.timeseries", pCfg->vndStats.numOfTimeSeries, code);
if (code < 0) return -1;
+ tjsonGetNumberValue(pJson, "vndStats.ntimeseries", pCfg->vndStats.numOfNTimeSeries, code);
+ if (code < 0) return -1;
SJson *pNodeInfoArr = tjsonGetObjectItem(pJson, "syncCfg.nodeInfo");
int arraySize = tjsonGetArraySize(pNodeInfoArr);
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 777dcd0592ae69de003d5df0d1d9d2592302d195..9b62581051daac9c232409c0cb30d379e3a4d596 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -188,7 +188,7 @@ typedef struct SCtgTbCache {
typedef struct SCtgVgCache {
SRWLatch vgLock;
- SDBVgInfo *vgInfo;
+ SDBVgInfo *vgInfo;
} SCtgVgCache;
typedef struct SCtgDBCache {
@@ -224,7 +224,7 @@ typedef struct SCtgUserAuth {
} SCtgUserAuth;
typedef struct SCatalog {
- uint64_t clusterId;
+ uint64_t clusterId;
SHashObj *userCache; //key:user, value:SCtgUserAuth
SHashObj *dbCache; //key:dbname, value:SCtgDBCache
SCtgRentMgmt dbRent;
@@ -253,9 +253,9 @@ typedef struct SCtgJob {
int32_t jobResCode;
int32_t taskIdx;
SRWLatch taskLock;
-
+
uint64_t queryId;
- SCatalog* pCtg;
+ SCatalog* pCtg;
SRequestConnInfo conn;
void* userParam;
catalogCallback userFp;
@@ -279,7 +279,7 @@ typedef struct SCtgMsgCtx {
void* lastOut;
void* out;
char* target;
- SHashObj* pBatchs;
+ SHashObj* pBatchs;
} SCtgMsgCtx;
@@ -364,7 +364,7 @@ typedef struct SCtgCacheStat {
uint64_t numOfMetaHit;
uint64_t numOfMetaMiss;
uint64_t numOfIndexHit;
- uint64_t numOfIndexMiss;
+ uint64_t numOfIndexMiss;
uint64_t numOfUserHit;
uint64_t numOfUserMiss;
uint64_t numOfClear;
@@ -451,7 +451,7 @@ typedef struct SCtgCacheOperation {
int32_t opId;
void *data;
bool syncOp;
- tsem_t rspSem;
+ tsem_t rspSem;
bool stopQueue;
bool unLocked;
} SCtgCacheOperation;
@@ -466,7 +466,7 @@ typedef struct SCtgQueue {
bool stopQueue;
SCtgQNode *head;
SCtgQNode *tail;
- tsem_t reqSem;
+ tsem_t reqSem;
uint64_t qRemainNum;
} SCtgQueue;
@@ -475,7 +475,7 @@ typedef struct SCatalogMgmt {
int32_t jobPool;
SRWLatch lock;
SCtgQueue queue;
- TdThread updateThread;
+ TdThread updateThread;
SHashObj *pCluster; //key: clusterId, value: SCatalog*
SCatalogStat stat;
SCatalogCfg cfg;
@@ -528,8 +528,8 @@ typedef struct SCtgOperation {
#define CTG_META_SIZE(pMeta) (sizeof(STableMeta) + ((pMeta)->tableInfo.numOfTags + (pMeta)->tableInfo.numOfColumns) * sizeof(SSchema))
-#define CTG_TABLE_NOT_EXIST(code) (code == CTG_ERR_CODE_TABLE_NOT_EXIST)
-#define CTG_DB_NOT_EXIST(code) (code == TSDB_CODE_MND_DB_NOT_EXIST)
+#define CTG_TABLE_NOT_EXIST(code) (code == CTG_ERR_CODE_TABLE_NOT_EXIST)
+#define CTG_DB_NOT_EXIST(code) (code == TSDB_CODE_MND_DB_NOT_EXIST)
#define ctgFatal(param, ...) qFatal("CTG:%p " param, pCtg, __VA_ARGS__)
#define ctgError(param, ...) qError("CTG:%p " param, pCtg, __VA_ARGS__)
@@ -576,7 +576,7 @@ typedef struct SCtgOperation {
} \
} while (0)
-
+
#define CTG_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
#define CTG_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
#define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c
index 64ca85edf45ac515bd7728883c171b04c399d148..585b33930c2cae0332ee77a3933d5a86288c77bc 100644
--- a/source/libs/catalog/src/ctgAsync.c
+++ b/source/libs/catalog/src/ctgAsync.c
@@ -39,7 +39,7 @@ int32_t ctgInitGetTbMetaTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosMemoryFree(task.taskCtx);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
-
+
memcpy(ctx->pName, name, sizeof(*name));
ctx->flag = CTG_FLAG_UNKNOWN_STB;
@@ -69,7 +69,7 @@ int32_t ctgInitGetTbMetasTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosArrayPush(pJob->pTasks, &task);
- qDebug("QID:0x%" PRIx64 " the %dth task type %s initialized, dbNum:%d, tbNum:%d",
+ qDebug("QID:0x%" PRIx64 " the %dth task type %s initialized, dbNum:%d, tbNum:%d",
pJob->queryId, taskIdx, ctgTaskTypeStr(task.type), taosArrayGetSize(ctx->pNames), pJob->tbMetaNum);
return TSDB_CODE_SUCCESS;
@@ -89,7 +89,7 @@ int32_t ctgInitGetDbVgTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgDbVgCtx* ctx = task.taskCtx;
-
+
memcpy(ctx->dbFName, dbFName, sizeof(ctx->dbFName));
taosArrayPush(pJob->pTasks, &task);
@@ -113,7 +113,7 @@ int32_t ctgInitGetDbCfgTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgDbCfgCtx* ctx = task.taskCtx;
-
+
memcpy(ctx->dbFName, dbFName, sizeof(ctx->dbFName));
taosArrayPush(pJob->pTasks, &task);
@@ -137,7 +137,7 @@ int32_t ctgInitGetDbInfoTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgDbInfoCtx* ctx = task.taskCtx;
-
+
memcpy(ctx->dbFName, dbFName, sizeof(ctx->dbFName));
taosArrayPush(pJob->pTasks, &task);
@@ -167,7 +167,7 @@ int32_t ctgInitGetTbHashTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosMemoryFree(task.taskCtx);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
-
+
memcpy(ctx->pName, name, sizeof(*name));
tNameGetFullDbName(ctx->pName, ctx->dbFName);
@@ -197,7 +197,7 @@ int32_t ctgInitGetTbHashsTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosArrayPush(pJob->pTasks, &task);
- qDebug("QID:0x%" PRIx64 " the %dth task type %s initialized, dbNum:%d, tbNum:%d",
+ qDebug("QID:0x%" PRIx64 " the %dth task type %s initialized, dbNum:%d, tbNum:%d",
pJob->queryId, taskIdx, ctgTaskTypeStr(task.type), taosArrayGetSize(ctx->pNames), pJob->tbHashNum);
return TSDB_CODE_SUCCESS;
@@ -248,7 +248,7 @@ int32_t ctgInitGetIndexTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgIndexCtx* ctx = task.taskCtx;
-
+
strcpy(ctx->indexFName, name);
taosArrayPush(pJob->pTasks, &task);
@@ -272,7 +272,7 @@ int32_t ctgInitGetUdfTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgUdfCtx* ctx = task.taskCtx;
-
+
strcpy(ctx->udfName, name);
taosArrayPush(pJob->pTasks, &task);
@@ -296,7 +296,7 @@ int32_t ctgInitGetUserTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
}
SCtgUserCtx* ctx = task.taskCtx;
-
+
memcpy(&ctx->user, user, sizeof(*user));
taosArrayPush(pJob->pTasks, &task);
@@ -339,7 +339,7 @@ int32_t ctgInitGetTbIndexTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosMemoryFree(task.taskCtx);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
-
+
memcpy(ctx->pName, name, sizeof(*name));
taosArrayPush(pJob->pTasks, &task);
@@ -368,7 +368,7 @@ int32_t ctgInitGetTbCfgTask(SCtgJob *pJob, int32_t taskIdx, void* param) {
taosMemoryFree(task.taskCtx);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
-
+
memcpy(ctx->pName, name, sizeof(*name));
taosArrayPush(pJob->pTasks, &task);
@@ -387,7 +387,7 @@ int32_t ctgHandleForceUpdate(SCatalog* pCtg, int32_t taskNum, SCtgJob *pJob, con
taosHashCleanup(pTb);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
-
+
for (int32_t i = 0; i < pJob->dbVgNum; ++i) {
char* dbFName = taosArrayGet(pReq->pDbVgroup, i);
taosHashPut(pDb, dbFName, strlen(dbFName), dbFName, TSDB_DB_FNAME_LEN);
@@ -474,7 +474,7 @@ int32_t ctgInitTask(SCtgJob *pJob, CTG_TASK_TYPE type, void* param, int32_t *tas
if (taskId) {
*taskId = tid;
}
-
+
return TSDB_CODE_SUCCESS;
}
@@ -510,7 +510,7 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgJob** job, const
pJob->pCtg = pCtg;
pJob->conn = *pConn;
pJob->userParam = param;
-
+
pJob->tbMetaNum = tbMetaNum;
pJob->tbHashNum = tbHashNum;
pJob->qnodeNum = qnodeNum;
@@ -844,20 +844,20 @@ int32_t ctgDumpSvrVer(SCtgTask* pTask) {
pJob->jobRes.pSvrVer->code = pTask->code;
pJob->jobRes.pSvrVer->pRes = pTask->res;
-
+
return TSDB_CODE_SUCCESS;
}
int32_t ctgCallSubCb(SCtgTask *pTask) {
int32_t code = 0;
-
+
CTG_LOCK(CTG_WRITE, &pTask->lock);
-
+
int32_t parentNum = taosArrayGetSize(pTask->pParents);
for (int32_t i = 0; i < parentNum; ++i) {
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
SCtgTask* pParent = taosArrayGetP(pTask->pParents, i);
-
+
pParent->subRes.code = pTask->code;
if (TSDB_CODE_SUCCESS == pTask->code) {
code = (*gCtgAsyncFps[pTask->type].cloneFp)(pTask, &pParent->subRes.res);
@@ -868,22 +868,22 @@ int32_t ctgCallSubCb(SCtgTask *pTask) {
SCtgMsgCtx *pParMsgCtx = CTG_GET_TASK_MSGCTX(pParent, -1);
- pParMsgCtx->pBatchs = pMsgCtx->pBatchs;
+ pParMsgCtx->pBatchs = pMsgCtx->pBatchs;
CTG_ERR_JRET(pParent->subRes.fp(pParent));
}
-
+
_return:
CTG_UNLOCK(CTG_WRITE, &pTask->lock);
- CTG_RET(code);
+ CTG_RET(code);
}
int32_t ctgCallUserCb(void* param) {
SCtgJob* pJob = (SCtgJob*)param;
qDebug("QID:0x%" PRIx64 " ctg start to call user cb with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
-
+
(*pJob->userFp)(&pJob->jobRes, pJob->userParam, pJob->jobResCode);
qDebug("QID:0x%" PRIx64 " ctg end to call user cb", pJob->queryId);
@@ -922,9 +922,9 @@ _return:
//taosSsleep(2);
//qDebug("QID:0x%" PRIx64 " ctg after sleep", pJob->queryId);
-
+
taosAsyncExec(ctgCallUserCb, pJob, NULL);
-
+
CTG_RET(code);
}
@@ -932,7 +932,7 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
int32_t code = 0;
SCtgDBCache *dbCache = NULL;
SCtgTask* pTask = tReq->pTask;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgMsgCtx* pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, tReq->msgIdx);
SCtgTbMetaCtx* ctx = (SCtgTbMetaCtx*)pTask->taskCtx;
@@ -958,38 +958,38 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
}
case TDMT_MND_TABLE_META: {
STableMetaOutput* pOut = (STableMetaOutput*)pMsgCtx->out;
-
+
if (CTG_IS_META_NULL(pOut->metaType)) {
if (CTG_FLAG_IS_STB(flag)) {
char dbFName[TSDB_DB_FNAME_LEN] = {0};
tNameGetFullDbName(pName, dbFName);
-
+
CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, dbFName, &dbCache));
if (NULL != dbCache) {
SVgroupInfo vgInfo = {0};
CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pCtg, dbCache->vgCache.vgInfo, pName, &vgInfo));
-
+
ctgDebug("will refresh tbmeta, supposed to be stb, tbName:%s, flag:%d", tNameGetTableName(pName), flag);
- *vgId = vgInfo.vgId;
+ *vgId = vgInfo.vgId;
CTG_ERR_JRET(ctgGetTbMetaFromVnode(pCtg, pConn, pName, &vgInfo, NULL, tReq));
ctgReleaseVgInfoToCache(pCtg, dbCache);
} else {
SBuildUseDBInput input = {0};
-
+
tstrncpy(input.db, dbFName, tListLen(input.db));
input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
-
+
CTG_ERR_JRET(ctgGetDBVgInfoFromMnode(pCtg, pConn, &input, NULL, tReq));
}
return TSDB_CODE_SUCCESS;
}
-
+
ctgError("no tbmeta got, tbName:%s", tNameGetTableName(pName));
ctgRemoveTbMetaFromCache(pCtg, pName, false);
-
+
CTG_ERR_JRET(CTG_ERR_CODE_TABLE_NOT_EXIST);
}
@@ -998,12 +998,12 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
STableMetaOutput* pLastOut = (STableMetaOutput*)pMsgCtx->out;
TSWAP(pLastOut->tbMeta, pOut->tbMeta);
}
-
+
break;
}
case TDMT_VND_TABLE_META: {
STableMetaOutput* pOut = (STableMetaOutput*)pMsgCtx->out;
-
+
if (CTG_IS_META_NULL(pOut->metaType)) {
ctgError("no tbmeta got, tbNmae:%s", tNameGetTableName(pName));
ctgRemoveTbMetaFromCache(pCtg, pName, false);
@@ -1013,12 +1013,12 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
if (CTG_FLAG_IS_STB(flag)) {
break;
}
-
+
if (CTG_IS_META_TABLE(pOut->metaType) && TSDB_SUPER_TABLE == pOut->tbMeta->tableType) {
ctgDebug("will continue to refresh tbmeta since got stb, tbName:%s", tNameGetTableName(pName));
-
+
taosMemoryFreeClear(pOut->tbMeta);
-
+
CTG_RET(ctgGetTbMetaFromMnode(pCtg, pConn, pName, NULL, tReq));
} else if (CTG_IS_META_BOTH(pOut->metaType)) {
int32_t exist = 0;
@@ -1029,13 +1029,13 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
stbCtx.flag = flag;
stbCtx.pName = &stbName;
- taosMemoryFreeClear(pOut->tbMeta);
+ taosMemoryFreeClear(pOut->tbMeta);
CTG_ERR_JRET(ctgReadTbMetaFromCache(pCtg, &stbCtx, &pOut->tbMeta));
if (pOut->tbMeta) {
exist = 1;
}
}
-
+
if (0 == exist) {
TSWAP(pMsgCtx->lastOut, pMsgCtx->out);
CTG_RET(ctgGetTbMetaFromMnodeImpl(pCtg, pConn, pOut->dbFName, pOut->tbName, NULL, tReq));
@@ -1056,7 +1056,7 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
if (CTG_IS_META_BOTH(pOut->metaType)) {
memcpy(pOut->tbMeta, &pOut->ctbMeta, sizeof(pOut->ctbMeta));
}
-
+
/*
else if (CTG_IS_META_CTABLE(pOut->metaType)) {
SName stbName = *pName;
@@ -1064,7 +1064,7 @@ int32_t ctgHandleGetTbMetaRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
SCtgTbMetaCtx stbCtx = {0};
stbCtx.flag = flag;
stbCtx.pName = &stbName;
-
+
CTG_ERR_JRET(ctgReadTbMetaFromCache(pCtg, &stbCtx, &pOut->tbMeta));
if (NULL == pOut->tbMeta) {
ctgDebug("stb no longer exist, stbName:%s", stbName.tname);
@@ -1088,7 +1088,7 @@ _return:
if (pTask->res || code) {
ctgHandleTaskEnd(pTask, code);
}
-
+
CTG_RET(code);
}
@@ -1097,7 +1097,7 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
int32_t code = 0;
SCtgDBCache *dbCache = NULL;
SCtgTask* pTask = tReq->pTask;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgMsgCtx* pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, tReq->msgIdx);
SCtgTbMetasCtx* ctx = (SCtgTbMetasCtx*)pTask->taskCtx;
@@ -1125,38 +1125,38 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
}
case TDMT_MND_TABLE_META: {
STableMetaOutput* pOut = (STableMetaOutput*)pMsgCtx->out;
-
+
if (CTG_IS_META_NULL(pOut->metaType)) {
if (CTG_FLAG_IS_STB(flag)) {
char dbFName[TSDB_DB_FNAME_LEN] = {0};
tNameGetFullDbName(pName, dbFName);
-
+
CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, dbFName, &dbCache));
if (NULL != dbCache) {
SVgroupInfo vgInfo = {0};
CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pCtg, dbCache->vgCache.vgInfo, pName, &vgInfo));
-
+
ctgDebug("will refresh tbmeta, supposed to be stb, tbName:%s, flag:%d", tNameGetTableName(pName), flag);
- *vgId = vgInfo.vgId;
+ *vgId = vgInfo.vgId;
CTG_ERR_JRET(ctgGetTbMetaFromVnode(pCtg, pConn, pName, &vgInfo, NULL, tReq));
ctgReleaseVgInfoToCache(pCtg, dbCache);
} else {
SBuildUseDBInput input = {0};
-
+
tstrncpy(input.db, dbFName, tListLen(input.db));
input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
-
+
CTG_ERR_JRET(ctgGetDBVgInfoFromMnode(pCtg, pConn, &input, NULL, tReq));
}
return TSDB_CODE_SUCCESS;
}
-
+
ctgError("no tbmeta got, tbName:%s", tNameGetTableName(pName));
ctgRemoveTbMetaFromCache(pCtg, pName, false);
-
+
CTG_ERR_JRET(CTG_ERR_CODE_TABLE_NOT_EXIST);
}
@@ -1165,12 +1165,12 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
STableMetaOutput* pLastOut = (STableMetaOutput*)pMsgCtx->out;
TSWAP(pLastOut->tbMeta, pOut->tbMeta);
}
-
+
break;
}
case TDMT_VND_TABLE_META: {
STableMetaOutput* pOut = (STableMetaOutput*)pMsgCtx->out;
-
+
if (CTG_IS_META_NULL(pOut->metaType)) {
ctgError("no tbmeta got, tbNmae:%s", tNameGetTableName(pName));
ctgRemoveTbMetaFromCache(pCtg, pName, false);
@@ -1180,12 +1180,12 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
if (CTG_FLAG_IS_STB(flag)) {
break;
}
-
+
if (CTG_IS_META_TABLE(pOut->metaType) && TSDB_SUPER_TABLE == pOut->tbMeta->tableType) {
ctgDebug("will continue to refresh tbmeta since got stb, tbName:%s", tNameGetTableName(pName));
-
+
taosMemoryFreeClear(pOut->tbMeta);
-
+
CTG_RET(ctgGetTbMetaFromMnode(pCtg, pConn, pName, NULL, tReq));
} else if (CTG_IS_META_BOTH(pOut->metaType)) {
int32_t exist = 0;
@@ -1196,14 +1196,14 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
stbCtx.flag = flag;
stbCtx.pName = &stbName;
- taosMemoryFreeClear(pOut->tbMeta);
+ taosMemoryFreeClear(pOut->tbMeta);
CTG_ERR_JRET(ctgReadTbMetaFromCache(pCtg, &stbCtx, &pOut->tbMeta));
if (pOut->tbMeta) {
ctgDebug("use cached stb meta, tbName:%s", tNameGetTableName(pName));
exist = 1;
}
}
-
+
if (0 == exist) {
TSWAP(pMsgCtx->lastOut, pMsgCtx->out);
CTG_RET(ctgGetTbMetaFromMnodeImpl(pCtg, pConn, pOut->dbFName, pOut->tbName, NULL, tReq));
@@ -1224,7 +1224,7 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
if (CTG_IS_META_BOTH(pOut->metaType)) {
memcpy(pOut->tbMeta, &pOut->ctbMeta, sizeof(pOut->ctbMeta));
}
-
+
/*
else if (CTG_IS_META_CTABLE(pOut->metaType)) {
SName stbName = *pName;
@@ -1232,7 +1232,7 @@ int32_t ctgHandleGetTbMetasRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
SCtgTbMetaCtx stbCtx = {0};
stbCtx.flag = flag;
stbCtx.pName = &stbName;
-
+
CTG_ERR_JRET(ctgReadTbMetaFromCache(pCtg, &stbCtx, &pOut->tbMeta));
if (NULL == pOut->tbMeta) {
ctgDebug("stb no longer exist, stbName:%s", stbName.tname);
@@ -1273,7 +1273,7 @@ _return:
if (pTask->res && taskDone) {
ctgHandleTaskEnd(pTask, code);
}
-
+
CTG_RET(code);
}
@@ -1282,7 +1282,7 @@ int32_t ctgHandleGetDbVgRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf *
int32_t code = 0;
SCtgTask* pTask = tReq->pTask;
SCtgDbVgCtx* ctx = (SCtgDbVgCtx*)pTask->taskCtx;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
@@ -1290,7 +1290,7 @@ int32_t ctgHandleGetDbVgRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf *
case TDMT_MND_USE_DB: {
SUseDbOutput* pOut = (SUseDbOutput*)pTask->msgCtx.out;
SDBVgInfo* pDb = NULL;
-
+
CTG_ERR_JRET(ctgGenerateVgList(pCtg, pOut->dbVgroup->vgHash, (SArray**)&pTask->res));
CTG_ERR_JRET(cloneDbVgInfo(pOut->dbVgroup, &pDb));
@@ -1316,7 +1316,7 @@ int32_t ctgHandleGetTbHashRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
int32_t code = 0;
SCtgTask* pTask = tReq->pTask;
SCtgTbHashCtx* ctx = (SCtgTbHashCtx*)pTask->taskCtx;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
@@ -1330,7 +1330,7 @@ int32_t ctgHandleGetTbHashRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
}
CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pCtg, pOut->dbVgroup, ctx->pName, (SVgroupInfo*)pTask->res));
-
+
CTG_ERR_JRET(ctgUpdateVgroupEnqueue(pCtg, ctx->dbFName, pOut->dbId, pOut->dbVgroup, false));
pOut->dbVgroup = NULL;
@@ -1354,7 +1354,7 @@ int32_t ctgHandleGetTbHashsRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
int32_t code = 0;
SCtgTask* pTask = tReq->pTask;
SCtgTbHashsCtx* ctx = (SCtgTbHashsCtx*)pTask->taskCtx;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SCtgMsgCtx* pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, tReq->msgIdx);
SCtgFetch* pFetch = taosArrayGet(ctx->pFetchs, tReq->msgIdx);
bool taskDone = false;
@@ -1367,7 +1367,7 @@ int32_t ctgHandleGetTbHashsRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
STablesReq* pReq = taosArrayGet(ctx->pNames, pFetch->dbIdx);
CTG_ERR_JRET(ctgGetVgInfosFromHashValue(pCtg, tReq, pOut->dbVgroup, ctx, pMsgCtx->target, pReq->pTables, true));
-
+
CTG_ERR_JRET(ctgUpdateVgroupEnqueue(pCtg, pMsgCtx->target, pOut->dbId, pOut->dbVgroup, false));
pOut->dbVgroup = NULL;
@@ -1394,7 +1394,7 @@ _return:
pRes->code = code;
pRes->pRes = NULL;
}
-
+
if (0 == atomic_sub_fetch_32(&ctx->fetchNum, 1)) {
TSWAP(pTask->res, ctx->pResList);
taskDone = true;
@@ -1419,9 +1419,9 @@ int32_t ctgHandleGetTbIndexRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
CTG_ERR_JRET(ctgCloneTableIndex(pOut->pIndex, &pInfo));
pTask->res = pInfo;
- SCtgTbIndexCtx* ctx = pTask->taskCtx;
+ SCtgTbIndexCtx* ctx = pTask->taskCtx;
CTG_ERR_JRET(ctgUpdateTbIndexEnqueue(pTask->pJob->pCtg, (STableIndex**)&pTask->msgCtx.out, false));
-
+
_return:
if (TSDB_CODE_MND_DB_INDEX_NOT_EXIST == code) {
@@ -1438,7 +1438,7 @@ int32_t ctgHandleGetTbCfgRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(&pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1452,7 +1452,7 @@ int32_t ctgHandleGetDbCfgRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1471,7 +1471,7 @@ int32_t ctgHandleGetQnodeRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1485,7 +1485,7 @@ int32_t ctgHandleGetDnodeRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(&pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1499,7 +1499,7 @@ int32_t ctgHandleGetIndexRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1513,7 +1513,7 @@ int32_t ctgHandleGetUdfRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf *p
CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1525,7 +1525,7 @@ int32_t ctgHandleGetUserRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf *
int32_t code = 0;
SCtgTask* pTask = tReq->pTask;
SCtgUserCtx* ctx = (SCtgUserCtx*)pTask->taskCtx;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
bool pass = false;
SGetUserAuthRsp* pOut = (SGetUserAuthRsp*)pTask->msgCtx.out;
@@ -1573,7 +1573,7 @@ int32_t ctgHandleGetSvrVerRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf
CTG_ERR_JRET(ctgProcessRspMsg(&pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
TSWAP(pTask->res, pTask->msgCtx.out);
-
+
_return:
ctgHandleTaskEnd(pTask, code);
@@ -1583,7 +1583,7 @@ _return:
int32_t ctgAsyncRefreshTbMeta(SCtgTaskReq *tReq, int32_t flag, SName* pName, int32_t* vgId) {
SCtgTask* pTask = tReq->pTask;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
int32_t code = 0;
@@ -1603,7 +1603,7 @@ int32_t ctgAsyncRefreshTbMeta(SCtgTaskReq *tReq, int32_t flag, SName* pName, int
SCtgDBCache *dbCache = NULL;
char dbFName[TSDB_DB_FNAME_LEN] = {0};
tNameGetFullDbName(pName, dbFName);
-
+
CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, dbFName, &dbCache));
if (dbCache) {
SVgroupInfo vgInfo = {0};
@@ -1632,7 +1632,7 @@ _return:
}
int32_t ctgLaunchGetTbMetaTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgJob* pJob = pTask->pJob;
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
@@ -1649,14 +1649,14 @@ int32_t ctgLaunchGetTbMetaTask(SCtgTask *pTask) {
SCtgTbMetaCtx* pCtx = (SCtgTbMetaCtx*)pTask->taskCtx;
SCtgTaskReq tReq;
tReq.pTask = pTask;
- tReq.msgIdx = -1;
+ tReq.msgIdx = -1;
CTG_ERR_RET(ctgAsyncRefreshTbMeta(&tReq, pCtx->flag, pCtx->pName, &pCtx->vgId));
return TSDB_CODE_SUCCESS;
}
int32_t ctgLaunchGetTbMetasTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgTbMetasCtx* pCtx = (SCtgTbMetasCtx*)pTask->taskCtx;
SCtgJob* pJob = pTask->pJob;
@@ -1670,18 +1670,18 @@ int32_t ctgLaunchGetTbMetasTask(SCtgTask *pTask) {
CTG_ERR_RET(ctgGetTbMetasFromCache(pCtg, pConn, pCtx, i, &fetchIdx, baseResIdx, pReq->pTables));
baseResIdx += taosArrayGetSize(pReq->pTables);
}
-
+
pCtx->fetchNum = taosArrayGetSize(pCtx->pFetchs);
if (pCtx->fetchNum <= 0) {
TSWAP(pTask->res, pCtx->pResList);
-
+
CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
return TSDB_CODE_SUCCESS;
}
-
+
pTask->msgCtxs = taosArrayInit(pCtx->fetchNum, sizeof(SCtgMsgCtx));
taosArraySetSize(pTask->msgCtxs, pCtx->fetchNum);
-
+
for (int32_t i = 0; i < pCtx->fetchNum; ++i) {
SCtgFetch* pFetch = taosArrayGet(pCtx->pFetchs, i);
SName* pName = ctgGetFetchName(pCtx->pNames, pFetch);
@@ -1689,19 +1689,19 @@ int32_t ctgLaunchGetTbMetasTask(SCtgTask *pTask) {
if (NULL == pMsgCtx->pBatchs) {
pMsgCtx->pBatchs = pJob->pBatchs;
}
-
+
SCtgTaskReq tReq;
tReq.pTask = pTask;
- tReq.msgIdx = pFetch->fetchIdx;
+ tReq.msgIdx = pFetch->fetchIdx;
CTG_ERR_RET(ctgAsyncRefreshTbMeta(&tReq, pFetch->flag, pName, &pFetch->vgId));
}
-
+
return TSDB_CODE_SUCCESS;
}
int32_t ctgLaunchGetDbVgTask(SCtgTask *pTask) {
int32_t code = 0;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgDBCache *dbCache = NULL;
SCtgDbVgCtx* pCtx = (SCtgDbVgCtx*)pTask->taskCtx;
@@ -1710,18 +1710,18 @@ int32_t ctgLaunchGetDbVgTask(SCtgTask *pTask) {
if (NULL == pMsgCtx->pBatchs) {
pMsgCtx->pBatchs = pJob->pBatchs;
}
-
+
CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, pCtx->dbFName, &dbCache));
if (NULL != dbCache) {
CTG_ERR_JRET(ctgGenerateVgList(pCtg, dbCache->vgCache.vgInfo->vgHash, (SArray**)&pTask->res));
ctgReleaseVgInfoToCache(pCtg, dbCache);
dbCache = NULL;
-
+
CTG_ERR_JRET(ctgHandleTaskEnd(pTask, 0));
} else {
SBuildUseDBInput input = {0};
-
+
tstrncpy(input.db, pCtx->dbFName, tListLen(input.db));
input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
@@ -1742,7 +1742,7 @@ _return:
int32_t ctgLaunchGetTbHashTask(SCtgTask *pTask) {
int32_t code = 0;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgDBCache *dbCache = NULL;
SCtgTbHashCtx* pCtx = (SCtgTbHashCtx*)pTask->taskCtx;
@@ -1751,7 +1751,7 @@ int32_t ctgLaunchGetTbHashTask(SCtgTask *pTask) {
if (NULL == pMsgCtx->pBatchs) {
pMsgCtx->pBatchs = pJob->pBatchs;
}
-
+
CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, pCtx->dbFName, &dbCache));
if (NULL != dbCache) {
pTask->res = taosMemoryMalloc(sizeof(SVgroupInfo));
@@ -1762,17 +1762,17 @@ int32_t ctgLaunchGetTbHashTask(SCtgTask *pTask) {
ctgReleaseVgInfoToCache(pCtg, dbCache);
dbCache = NULL;
-
+
CTG_ERR_JRET(ctgHandleTaskEnd(pTask, 0));
} else {
SBuildUseDBInput input = {0};
-
+
tstrncpy(input.db, pCtx->dbFName, tListLen(input.db));
input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
SCtgTaskReq tReq;
tReq.pTask = pTask;
- tReq.msgIdx = -1;
+ tReq.msgIdx = -1;
CTG_ERR_RET(ctgGetDBVgInfoFromMnode(pCtg, pConn, &input, NULL, &tReq));
}
@@ -1786,16 +1786,16 @@ _return:
}
int32_t ctgLaunchGetTbHashsTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgTbHashsCtx* pCtx = (SCtgTbHashsCtx*)pTask->taskCtx;
SCtgDBCache *dbCache = NULL;
- SCtgJob* pJob = pTask->pJob;
+ SCtgJob* pJob = pTask->pJob;
int32_t dbNum = taosArrayGetSize(pCtx->pNames);
int32_t fetchIdx = 0;
int32_t baseResIdx = 0;
int32_t code = 0;
-
+
for (int32_t i = 0; i < dbNum; ++i) {
STablesReq* pReq = taosArrayGet(pCtx->pNames, i);
@@ -1804,7 +1804,7 @@ int32_t ctgLaunchGetTbHashsTask(SCtgTask *pTask) {
if (NULL != dbCache) {
SCtgTaskReq tReq;
tReq.pTask = pTask;
- tReq.msgIdx = -1;
+ tReq.msgIdx = -1;
CTG_ERR_JRET(ctgGetVgInfosFromHashValue(pCtg, &tReq, dbCache->vgCache.vgInfo, pCtx, pReq->dbFName, pReq->pTables, false));
ctgReleaseVgInfoToCache(pCtg, dbCache);
@@ -1815,21 +1815,21 @@ int32_t ctgLaunchGetTbHashsTask(SCtgTask *pTask) {
ctgAddFetch(&pCtx->pFetchs, i, -1, &fetchIdx, baseResIdx, 0);
baseResIdx += taosArrayGetSize(pReq->pTables);
- taosArraySetSize(pCtx->pResList, baseResIdx);
+ taosArraySetSize(pCtx->pResList, baseResIdx);
}
}
pCtx->fetchNum = taosArrayGetSize(pCtx->pFetchs);
if (pCtx->fetchNum <= 0) {
TSWAP(pTask->res, pCtx->pResList);
-
+
CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
return TSDB_CODE_SUCCESS;
}
-
+
pTask->msgCtxs = taosArrayInit(pCtx->fetchNum, sizeof(SCtgMsgCtx));
taosArraySetSize(pTask->msgCtxs, pCtx->fetchNum);
-
+
for (int32_t i = 0; i < pCtx->fetchNum; ++i) {
SCtgFetch* pFetch = taosArrayGet(pCtx->pFetchs, i);
STablesReq* pReq = taosArrayGet(pCtx->pNames, pFetch->dbIdx);
@@ -1837,10 +1837,10 @@ int32_t ctgLaunchGetTbHashsTask(SCtgTask *pTask) {
if (NULL == pMsgCtx->pBatchs) {
pMsgCtx->pBatchs = pJob->pBatchs;
}
-
+
SBuildUseDBInput input = {0};
strcpy(input.db, pReq->dbFName);
-
+
input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
SCtgTaskReq tReq;
@@ -1854,14 +1854,14 @@ _return:
if (dbCache) {
ctgReleaseVgInfoToCache(pCtg, dbCache);
}
-
+
return code;
}
int32_t ctgLaunchGetTbIndexTask(SCtgTask *pTask) {
int32_t code = 0;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgTbIndexCtx* pCtx = (SCtgTbIndexCtx*)pTask->taskCtx;
SArray* pRes = NULL;
@@ -1874,18 +1874,18 @@ int32_t ctgLaunchGetTbIndexTask(SCtgTask *pTask) {
CTG_ERR_RET(ctgReadTbIndexFromCache(pCtg, pCtx->pName, &pRes));
if (pRes) {
pTask->res = pRes;
-
+
CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
return TSDB_CODE_SUCCESS;
}
-
+
CTG_ERR_RET(ctgGetTbIndexFromMnode(pCtg, pConn, pCtx->pName, NULL, pTask));
return TSDB_CODE_SUCCESS;
}
int32_t ctgLaunchGetTbCfgTask(SCtgTask *pTask) {
int32_t code = 0;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgTbCfgCtx* pCtx = (SCtgTbCfgCtx*)pTask->taskCtx;
SArray* pRes = NULL;
@@ -1915,7 +1915,7 @@ int32_t ctgLaunchGetTbCfgTask(SCtgTask *pTask) {
return TSDB_CODE_SUCCESS;
}
}
-
+
CTG_ERR_JRET(ctgGetTableCfgFromVnode(pCtg, pConn, pCtx->pName, pCtx->pVgInfo, NULL, pTask));
}
@@ -1926,13 +1926,13 @@ _return:
if (CTG_TASK_LAUNCHED == pTask->status) {
ctgHandleTaskEnd(pTask, code);
}
-
+
CTG_RET(code);
}
int32_t ctgLaunchGetQnodeTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgJob* pJob = pTask->pJob;
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
@@ -1945,7 +1945,7 @@ int32_t ctgLaunchGetQnodeTask(SCtgTask *pTask) {
}
int32_t ctgLaunchGetDnodeTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgJob* pJob = pTask->pJob;
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
@@ -1959,7 +1959,7 @@ int32_t ctgLaunchGetDnodeTask(SCtgTask *pTask) {
int32_t ctgLaunchGetDbCfgTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgDbCfgCtx* pCtx = (SCtgDbCfgCtx*)pTask->taskCtx;
SCtgJob* pJob = pTask->pJob;
@@ -1975,7 +1975,7 @@ int32_t ctgLaunchGetDbCfgTask(SCtgTask *pTask) {
int32_t ctgLaunchGetDbInfoTask(SCtgTask *pTask) {
int32_t code = 0;
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SCtgDBCache *dbCache = NULL;
SCtgDbInfoCtx* pCtx = (SCtgDbInfoCtx*)pTask->taskCtx;
SCtgJob* pJob = pTask->pJob;
@@ -2014,7 +2014,7 @@ _return:
}
int32_t ctgLaunchGetIndexTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgIndexCtx* pCtx = (SCtgIndexCtx*)pTask->taskCtx;
SCtgJob* pJob = pTask->pJob;
@@ -2029,7 +2029,7 @@ int32_t ctgLaunchGetIndexTask(SCtgTask *pTask) {
}
int32_t ctgLaunchGetUdfTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgUdfCtx* pCtx = (SCtgUdfCtx*)pTask->taskCtx;
SCtgJob* pJob = pTask->pJob;
@@ -2044,7 +2044,7 @@ int32_t ctgLaunchGetUdfTask(SCtgTask *pTask) {
}
int32_t ctgLaunchGetUserTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgUserCtx* pCtx = (SCtgUserCtx*)pTask->taskCtx;
bool inCache = false;
@@ -2054,7 +2054,7 @@ int32_t ctgLaunchGetUserTask(SCtgTask *pTask) {
if (NULL == pMsgCtx->pBatchs) {
pMsgCtx->pBatchs = pJob->pBatchs;
}
-
+
CTG_ERR_RET(ctgChkAuthFromCache(pCtg, pCtx->user.user, pCtx->user.dbFName, pCtx->user.type, &inCache, &pass));
if (inCache) {
pTask->res = taosMemoryCalloc(1, sizeof(bool));
@@ -2062,7 +2062,7 @@ int32_t ctgLaunchGetUserTask(SCtgTask *pTask) {
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
*(bool*)pTask->res = pass;
-
+
CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
return TSDB_CODE_SUCCESS;
}
@@ -2073,7 +2073,7 @@ int32_t ctgLaunchGetUserTask(SCtgTask *pTask) {
}
int32_t ctgLaunchGetSvrVerTask(SCtgTask *pTask) {
- SCatalog* pCtg = pTask->pJob->pCtg;
+ SCatalog* pCtg = pTask->pJob->pCtg;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SCtgJob* pJob = pTask->pJob;
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
@@ -2096,7 +2096,7 @@ int32_t ctgRelaunchGetTbMetaTask(SCtgTask *pTask) {
int32_t ctgGetTbCfgCb(SCtgTask *pTask) {
int32_t code = 0;
-
+
CTG_ERR_JRET(pTask->subRes.code);
SCtgTbCfgCtx* pCtx = (SCtgTbCfgCtx*)pTask->taskCtx;
@@ -2104,7 +2104,7 @@ int32_t ctgGetTbCfgCb(SCtgTask *pTask) {
pCtx->tbType = ((STableMeta*)pTask->subRes.res)->tableType;
} else if (CTG_TASK_GET_DB_VGROUP == pTask->subRes.type) {
SDBVgInfo* pDb = (SDBVgInfo*)pTask->subRes.res;
-
+
pCtx->pVgInfo = taosMemoryCalloc(1, sizeof(SVgroupInfo));
CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pTask->pJob->pCtg, pDb, pCtx->pName, pCtx->pVgInfo));
}
@@ -2167,7 +2167,7 @@ SCtgAsyncFps gCtgAsyncFps[] = {
int32_t ctgMakeAsyncRes(SCtgJob *pJob) {
int32_t code = 0;
int32_t taskNum = taosArrayGetSize(pJob->pTasks);
-
+
for (int32_t i = 0; i < taskNum; ++i) {
SCtgTask *pTask = taosArrayGet(pJob->pTasks, i);
CTG_ERR_RET((*gCtgAsyncFps[pTask->type].dumpResFp)(pTask));
@@ -2180,16 +2180,16 @@ int32_t ctgSearchExistingTask(SCtgJob *pJob, CTG_TASK_TYPE type, void* param, in
bool equal = false;
SCtgTask* pTask = NULL;
int32_t code = 0;
-
+
CTG_LOCK(CTG_READ, &pJob->taskLock);
-
+
int32_t taskNum = taosArrayGetSize(pJob->pTasks);
for (int32_t i = 0; i < taskNum; ++i) {
pTask = taosArrayGet(pJob->pTasks, i);
if (type != pTask->type) {
continue;
}
-
+
CTG_ERR_JRET((*gCtgAsyncFps[type].compFp)(pTask, param, &equal));
if (equal) {
break;
@@ -2208,7 +2208,7 @@ _return:
int32_t ctgSetSubTaskCb(SCtgTask *pSub, SCtgTask *pTask) {
int32_t code = 0;
-
+
CTG_LOCK(CTG_WRITE, &pSub->lock);
if (CTG_TASK_DONE == pSub->status) {
pTask->subRes.code = pSub->code;
@@ -2216,7 +2216,7 @@ int32_t ctgSetSubTaskCb(SCtgTask *pSub, SCtgTask *pTask) {
SCtgMsgCtx *pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
SCtgMsgCtx *pSubMsgCtx = CTG_GET_TASK_MSGCTX(pSub, -1);
pMsgCtx->pBatchs = pSubMsgCtx->pBatchs;
-
+
CTG_ERR_JRET(pTask->subRes.fp(pTask));
} else {
if (NULL == pSub->pParents) {
@@ -2230,7 +2230,7 @@ _return:
CTG_UNLOCK(CTG_WRITE, &pSub->lock);
- CTG_RET(code);
+ CTG_RET(code);
}
@@ -2242,13 +2242,13 @@ int32_t ctgLaunchSubTask(SCtgTask *pTask, CTG_TASK_TYPE type, ctgSubTaskCbFp fp,
ctgClearSubTaskRes(&pTask->subRes);
pTask->subRes.type = type;
pTask->subRes.fp = fp;
-
+
CTG_ERR_RET(ctgSearchExistingTask(pJob, type, param, &subTaskId));
if (subTaskId < 0) {
CTG_ERR_RET(ctgInitTask(pJob, type, param, &subTaskId));
newTask = true;
}
-
+
SCtgTask* pSub = taosArrayGet(pJob->pTasks, subTaskId);
CTG_ERR_RET(ctgSetSubTaskCb(pSub, pTask));
@@ -2267,21 +2267,21 @@ int32_t ctgLaunchSubTask(SCtgTask *pTask, CTG_TASK_TYPE type, ctgSubTaskCbFp fp,
int32_t ctgLaunchJob(SCtgJob *pJob) {
int32_t taskNum = taosArrayGetSize(pJob->pTasks);
-
+
for (int32_t i = 0; i < taskNum; ++i) {
SCtgTask *pTask = taosArrayGet(pJob->pTasks, i);
qDebug("QID:0x%" PRIx64 " ctg launch [%dth] task", pJob->queryId, pTask->taskId);
CTG_ERR_RET((*gCtgAsyncFps[pTask->type].launchFp)(pTask));
-
+
pTask->status = CTG_TASK_LAUNCHED;
}
if (taskNum <= 0) {
qDebug("QID:0x%" PRIx64 " ctg call user callback with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
-
+
taosAsyncExec(ctgCallUserCb, pJob, NULL);
-#if CTG_BATCH_FETCH
+#if CTG_BATCH_FETCH
} else {
ctgLaunchBatchs(pJob->pCtg, pJob, pJob->pBatchs);
#endif
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index dbe35361bddee351d3f1db67d5ffe0b3e737b0eb..7ae7330b09933f7f33c29b7446445e376710ce5e 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -209,6 +209,7 @@ typedef struct SExprSupp {
typedef struct SOperatorInfo {
uint16_t operatorType;
+ int16_t resultDataBlockId;
bool blocking; // block operator or not
uint8_t status; // denote if current operator is completed
char* name; // name, for debug purpose
@@ -220,7 +221,6 @@ typedef struct SOperatorInfo {
struct SOperatorInfo** pDownstream; // downstram pointer list
int32_t numOfDownstream; // number of downstream. The value is always ONE expect for join operator
SOperatorFpSet fpSet;
- int16_t resultDataBlockId;
} SOperatorInfo;
typedef enum {
@@ -924,21 +924,15 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy
SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** dowStreams, size_t numStreams, SMergePhysiNode* pMergePhysiNode, SExecTaskInfo* pTaskInfo);
-SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t numOfDownstream, SExprInfo* pExprInfo, int32_t num, SArray* pSortInfo, SArray* pGroupInfo, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pTableScanNode, SReadHandle* readHandle, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
STimeWindowAggSupp* pTwAggSupp, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, bool isStream);
-
-SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
- SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
- bool mergeResultBlock, SExecTaskInfo* pTaskInfo);
-
-SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
- SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
- SNode* pCondition, bool mergeResultBlocks, SExecTaskInfo* pTaskInfo);
-
+SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode,
+ SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode,
+ SExecTaskInfo* pTaskInfo);
SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
SExecTaskInfo* pTaskInfo, int32_t numOfChild);
SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode,
@@ -946,8 +940,8 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW
SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
SSDataBlock* pResultBlock, SArray* pGroupColList, SNode* pCondition,
SExprInfo* pScalarExprInfo, int32_t numOfScalarExpr, SExecTaskInfo* pTaskInfo);
-SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SReadHandle* readHandle, uint64_t uid, SBlockDistScanPhysiNode* pBlockScanNode,
- SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SReadHandle* readHandle, uint64_t uid,
+ SBlockDistScanPhysiNode* pBlockScanNode, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,
SExecTaskInfo* pTaskInfo);
@@ -955,15 +949,9 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo);
-
-SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols,
- SSDataBlock* pResBlock, STimeWindowAggSupp *pTwAggSupp, int32_t tsSlotId,
- SColumn* pStateKeyCol, SNode* pCondition, SExecTaskInfo* pTaskInfo);
-
+SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo);
SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo);
-
SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo);
-
SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode,
SExecTaskInfo* pTaskInfo);
@@ -974,10 +962,6 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream
SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo);
-#if 0
-SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv);
-#endif
-
int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx,
int32_t numOfOutput, SArray* pPseudoList);
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 4ef6a5df26b74295efbc9f8d7c0ca316c17a9d12..a37bad1d497891aeeb59024120fa041bb9abd3af 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -600,7 +600,7 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc
if (pExpr[k].pExpr->nodeType == QUERY_NODE_COLUMN) { // it is a project query
SColumnInfoData* pColInfoData = taosArrayGet(pResult->pDataBlock, outputSlotId);
if (pResult->info.rows > 0 && !createNewColModel) {
- colDataMergeCol(pColInfoData, pResult->info.rows, &pResult->info.capacity, pInputData->pData[0],
+ colDataMergeCol(pColInfoData, pResult->info.rows, (int32_t*)&pResult->info.capacity, pInputData->pData[0],
pInputData->numOfRows);
} else {
colDataAssign(pColInfoData, pInputData->pData[0], pInputData->numOfRows, &pResult->info);
@@ -638,7 +638,7 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc
int32_t startOffset = createNewColModel ? 0 : pResult->info.rows;
ASSERT(pResult->info.capacity > 0);
- colDataMergeCol(pResColData, startOffset, &pResult->info.capacity, &idata, dest.numOfRows);
+ colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows);
colDataDestroy(&idata);
numOfRows = dest.numOfRows;
@@ -703,7 +703,7 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc
int32_t startOffset = createNewColModel ? 0 : pResult->info.rows;
ASSERT(pResult->info.capacity > 0);
- colDataMergeCol(pResColData, startOffset, &pResult->info.capacity, &idata, dest.numOfRows);
+ colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows);
colDataDestroy(&idata);
numOfRows = dest.numOfRows;
@@ -4025,7 +4025,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
if (code) {
pTaskInfo->code = code;
- qError("failed to createScanTableListInfo, code: %s", tstrerror(code));
+ qError("failed to createScanTableListInfo, code:%s, %s", tstrerror(code), GET_TASKID(pTaskInfo));
return NULL;
}
@@ -4163,9 +4163,9 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
if (ops[i] == NULL) {
taosMemoryFree(ops);
return NULL;
- } else {
- ops[i]->resultDataBlockId = pChildNode->pOutputDataBlockDesc->dataBlockId;
}
+
+ ops[i]->resultDataBlockId = pChildNode->pOutputDataBlockDesc->dataBlockId;
}
SOperatorInfo* pOptr = NULL;
@@ -4217,37 +4217,10 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL == type) {
SMergeAlignedIntervalPhysiNode* pIntervalPhyNode = (SMergeAlignedIntervalPhysiNode*)pPhyNode;
-
- SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &num);
- SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
-
- SInterval interval = {.interval = pIntervalPhyNode->interval,
- .sliding = pIntervalPhyNode->sliding,
- .intervalUnit = pIntervalPhyNode->intervalUnit,
- .slidingUnit = pIntervalPhyNode->slidingUnit,
- .offset = pIntervalPhyNode->offset,
- .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
-
- int32_t tsSlotId = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
- pOptr = createMergeAlignedIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, tsSlotId,
- pPhyNode->pConditions, pIntervalPhyNode->window.mergeDataBlock,
- pTaskInfo);
+ pOptr = createMergeAlignedIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL == type) {
SMergeIntervalPhysiNode* pIntervalPhyNode = (SMergeIntervalPhysiNode*)pPhyNode;
-
- SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &num);
- SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
-
- SInterval interval = {.interval = pIntervalPhyNode->interval,
- .sliding = pIntervalPhyNode->sliding,
- .intervalUnit = pIntervalPhyNode->intervalUnit,
- .slidingUnit = pIntervalPhyNode->slidingUnit,
- .offset = pIntervalPhyNode->offset,
- .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
-
- int32_t tsSlotId = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
- pOptr = createMergeIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, tsSlotId,
- pIntervalPhyNode->window.mergeDataBlock, pTaskInfo);
+ pOptr = createMergeIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL == type) {
int32_t children = 0;
pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children);
@@ -4276,17 +4249,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
pOptr = createPartitionOperatorInfo(ops[0], (SPartitionPhysiNode*)pPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE == type) {
SStateWinodwPhysiNode* pStateNode = (SStateWinodwPhysiNode*)pPhyNode;
-
- STimeWindowAggSupp as = {.waterMark = pStateNode->window.watermark, .calTrigger = pStateNode->window.triggerType};
-
- SExprInfo* pExprInfo = createExprInfo(pStateNode->window.pFuncs, NULL, &num);
- SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
- int32_t tsSlotId = ((SColumnNode*)pStateNode->window.pTspk)->slotId;
-
- SColumnNode* pColNode = (SColumnNode*)((STargetNode*)pStateNode->pStateKey)->pExpr;
- SColumn col = extractColumnFromColumnNode(pColNode);
- pOptr = createStatewindowOperatorInfo(ops[0], pExprInfo, num, pResBlock, &as, tsSlotId, &col, pPhyNode->pConditions,
- pTaskInfo);
+ pOptr = createStatewindowOperatorInfo(ops[0], pStateNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE == type) {
pOptr = createStreamStateAggOperatorInfo(ops[0], pPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN == type) {
@@ -4300,8 +4263,12 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
} else {
ASSERT(0);
}
+
taosMemoryFree(ops);
- if (pOptr) pOptr->resultDataBlockId = pPhyNode->pOutputDataBlockDesc->dataBlockId;
+ if (pOptr) {
+ pOptr->resultDataBlockId = pPhyNode->pOutputDataBlockDesc->dataBlockId;
+ }
+
return pOptr;
}
diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c
index 53709c7dcc78b380b54afd2a25947a67f5381ecd..9d7e833b19c05ebdf3bb72d9a28cdb28a28104cd 100644
--- a/source/libs/executor/src/groupoperator.c
+++ b/source/libs/executor/src/groupoperator.c
@@ -702,8 +702,8 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) {
}
SArray* groupArray = taosArrayInit(taosHashGetSize(pInfo->pGroupSet), sizeof(SDataGroupInfo));
- void* pGroupIter = NULL;
- pGroupIter = taosHashIterate(pInfo->pGroupSet, NULL);
+
+ void* pGroupIter = taosHashIterate(pInfo->pGroupSet, NULL);
while (pGroupIter != NULL) {
SDataGroupInfo* pGroupInfo = pGroupIter;
taosArrayPush(groupArray, pGroupInfo);
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index cadaf4a9d522971a81e16b0215d4c5967f30f676..ebafa910462b2ab6f3b9f3af2466a925c2b6a2e5 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -1900,8 +1900,6 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo*
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
pOperator->info = pInfo;
pOperator->fpSet = createOperatorFpSet(doOpenIntervalAgg, doBuildIntervalResult, doStreamIntervalAgg, NULL,
@@ -2700,20 +2698,26 @@ _error:
return NULL;
}
-SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols,
- SSDataBlock* pResBlock, STimeWindowAggSupp* pTwAggSup, int32_t tsSlotId,
- SColumn* pStateKeyCol, SNode* pCondition, SExecTaskInfo* pTaskInfo) {
+SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode,
+ SExecTaskInfo* pTaskInfo) {
SStateWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStateWindowOperatorInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
if (pInfo == NULL || pOperator == NULL) {
goto _error;
}
- pInfo->stateCol = *pStateKeyCol;
+ int32_t num = 0;
+ SExprInfo* pExprInfo = createExprInfo(pStateNode->window.pFuncs, NULL, &num);
+ SSDataBlock* pResBlock = createResDataBlock(pStateNode->window.node.pOutputDataBlockDesc);
+ int32_t tsSlotId = ((SColumnNode*)pStateNode->window.pTspk)->slotId;
+
+ SColumnNode* pColNode = (SColumnNode*)((STargetNode*)pStateNode->pStateKey)->pExpr;
+
+ pInfo->stateCol = extractColumnFromColumnNode(pColNode);
pInfo->stateKey.type = pInfo->stateCol.type;
pInfo->stateKey.bytes = pInfo->stateCol.bytes;
pInfo->stateKey.pData = taosMemoryCalloc(1, pInfo->stateCol.bytes);
- pInfo->pCondition = pCondition;
+ pInfo->pCondition = pStateNode->window.node.pConditions;
if (pInfo->stateKey.pData == NULL) {
goto _error;
}
@@ -2721,16 +2725,15 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SExprInf
size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
initResultSizeInfo(&pOperator->resultInfo, 4096);
- int32_t code = initAggInfo(&pOperator->exprSupp, &pInfo->aggSup, pExpr, numOfCols, keyBufSize, pTaskInfo->id.str);
+ int32_t code = initAggInfo(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
if (code != TSDB_CODE_SUCCESS) {
goto _error;
}
initBasicInfo(&pInfo->binfo, pResBlock);
-
initResultRowInfo(&pInfo->binfo.resultRowInfo);
- pInfo->twAggSup = *pTwAggSup;
+ pInfo->twAggSup = (STimeWindowAggSupp){.waterMark = pStateNode->window.watermark, .calTrigger = pStateNode->window.triggerType};;
initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
pInfo->tsSlotId = tsSlotId;
@@ -2738,8 +2741,6 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SExprInf
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExpr;
- pOperator->exprSupp.numOfExprs = numOfCols;
pOperator->pTaskInfo = pTaskInfo;
pOperator->info = pInfo;
@@ -2813,8 +2814,6 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
pOperator->info = pInfo;
pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doSessionWindowAgg, NULL, NULL,
@@ -3449,8 +3448,6 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
pOperator->operatorType = pPhyNode->type;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
pOperator->info = pInfo;
pOperator->fpSet =
@@ -3636,8 +3633,6 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
pOperator->info = pInfo;
pOperator->fpSet =
createOperatorFpSet(operatorDummyOpenFn, doStreamSessionAgg, NULL, NULL, destroyStreamSessionAggOperatorInfo,
@@ -4898,8 +4893,6 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE;
pOperator->blocking = true;
pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.numOfExprs = numOfCols;
- pOperator->exprSupp.pExprInfo = pExprInfo;
pOperator->pTaskInfo = pTaskInfo;
pOperator->info = pInfo;
pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doStreamStateAgg, NULL, NULL,
@@ -5115,9 +5108,7 @@ static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
return (rows == 0) ? NULL : pRes;
}
-SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo,
- int32_t numOfCols, SSDataBlock* pResBlock, SInterval* pInterval,
- int32_t primaryTsSlotId, SNode* pCondition, bool mergeResultBlock,
+SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode,
SExecTaskInfo* pTaskInfo) {
SMergeAlignedIntervalAggOperatorInfo* miaInfo = taosMemoryCalloc(1, sizeof(SMergeAlignedIntervalAggOperatorInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
@@ -5130,24 +5121,33 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
goto _error;
}
+ int32_t num = 0;
+ SExprInfo* pExprInfo = createExprInfo(pNode->window.pFuncs, NULL, &num);
+ SSDataBlock* pResBlock = createResDataBlock(pNode->window.node.pOutputDataBlockDesc);
+
+ SInterval interval = {.interval = pNode->interval,
+ .sliding = pNode->sliding,
+ .intervalUnit = pNode->intervalUnit,
+ .slidingUnit = pNode->slidingUnit,
+ .offset = pNode->offset,
+ .precision = ((SColumnNode*)pNode->window.pTspk)->node.resType.precision};
+
SIntervalAggOperatorInfo* iaInfo = miaInfo->intervalAggOperatorInfo;
SExprSupp* pSup = &pOperator->exprSupp;
- miaInfo->pCondition = pCondition;
- miaInfo->curTs = INT64_MIN;
-
- iaInfo->win = pTaskInfo->window;
- iaInfo->inputOrder = TSDB_ORDER_ASC;
- iaInfo->interval = *pInterval;
- iaInfo->execModel = pTaskInfo->execModel;
- iaInfo->primaryTsIndex = primaryTsSlotId;
- iaInfo->binfo.mergeResultBlock = mergeResultBlock;
+ miaInfo->pCondition = pNode->window.node.pConditions;
+ miaInfo->curTs = INT64_MIN;
+ iaInfo->win = pTaskInfo->window;
+ iaInfo->inputOrder = TSDB_ORDER_ASC;
+ iaInfo->interval = interval;
+ iaInfo->execModel = pTaskInfo->execModel;
+ iaInfo->primaryTsIndex = ((SColumnNode*)pNode->window.pTspk)->slotId;
+ iaInfo->binfo.mergeResultBlock = pNode->window.mergeDataBlock;
size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
initResultSizeInfo(&pOperator->resultInfo, 4096);
- int32_t code =
- initAggInfo(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str);
+ int32_t code = initAggInfo(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
if (code != TSDB_CODE_SUCCESS) {
goto _error;
}
@@ -5155,7 +5155,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
initBasicInfo(&iaInfo->binfo, pResBlock);
initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win);
- iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, numOfCols, iaInfo);
+ iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo);
if (iaInfo->timeWindowInterpo) {
iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SResultRowPosition));
}
@@ -5163,14 +5163,12 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
initResultRowInfo(&iaInfo->binfo.resultRowInfo);
blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity);
- pOperator->name = "TimeMergeAlignedIntervalAggOperator";
+ pOperator->name = "TimeMergeAlignedIntervalAggOperator";
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL;
- pOperator->blocking = false;
- pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->pTaskInfo = pTaskInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
- pOperator->info = miaInfo;
+ pOperator->blocking = false;
+ pOperator->status = OP_NOT_OPENED;
+ pOperator->pTaskInfo = pTaskInfo;
+ pOperator->info = miaInfo;
pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, mergeAlignedIntervalAgg, NULL, NULL,
destroyMergeAlignedIntervalOperatorInfo, NULL, NULL, NULL);
@@ -5427,57 +5425,64 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
return (rows == 0) ? NULL : pRes;
}
-SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
- SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
- bool mergeBlock, SExecTaskInfo* pTaskInfo) {
- SMergeIntervalAggOperatorInfo* miaInfo = taosMemoryCalloc(1, sizeof(SMergeIntervalAggOperatorInfo));
+SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode,
+ SExecTaskInfo* pTaskInfo) {
+ SMergeIntervalAggOperatorInfo* pMergeIntervalInfo = taosMemoryCalloc(1, sizeof(SMergeIntervalAggOperatorInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
- if (miaInfo == NULL || pOperator == NULL) {
+ if (pMergeIntervalInfo == NULL || pOperator == NULL) {
goto _error;
}
- miaInfo->groupIntervals = tdListNew(sizeof(SGroupTimeWindow));
+ int32_t num = 0;
+ SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &num);
+ SSDataBlock* pResBlock = createResDataBlock(pIntervalPhyNode->window.node.pOutputDataBlockDesc);
+
+ SInterval interval = {.interval = pIntervalPhyNode->interval,
+ .sliding = pIntervalPhyNode->sliding,
+ .intervalUnit = pIntervalPhyNode->intervalUnit,
+ .slidingUnit = pIntervalPhyNode->slidingUnit,
+ .offset = pIntervalPhyNode->offset,
+ .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
- SIntervalAggOperatorInfo* iaInfo = &miaInfo->intervalAggOperatorInfo;
- iaInfo->win = pTaskInfo->window;
- iaInfo->inputOrder = TSDB_ORDER_ASC;
- iaInfo->interval = *pInterval;
- iaInfo->execModel = pTaskInfo->execModel;
- iaInfo->binfo.mergeResultBlock = mergeBlock;
+ pMergeIntervalInfo->groupIntervals = tdListNew(sizeof(SGroupTimeWindow));
- iaInfo->primaryTsIndex = primaryTsSlotId;
+ SIntervalAggOperatorInfo* pIntervalInfo = &pMergeIntervalInfo->intervalAggOperatorInfo;
+ pIntervalInfo->win = pTaskInfo->window;
+ pIntervalInfo->inputOrder = TSDB_ORDER_ASC;
+ pIntervalInfo->interval = interval;
+ pIntervalInfo->execModel = pTaskInfo->execModel;
+ pIntervalInfo->binfo.mergeResultBlock = pIntervalPhyNode->window.mergeDataBlock;
+ pIntervalInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
SExprSupp* pExprSupp = &pOperator->exprSupp;
size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
initResultSizeInfo(&pOperator->resultInfo, 4096);
- int32_t code = initAggInfo(pExprSupp, &iaInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str);
+ int32_t code = initAggInfo(pExprSupp, &pIntervalInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
if (code != TSDB_CODE_SUCCESS) {
goto _error;
}
- initBasicInfo(&iaInfo->binfo, pResBlock);
- initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win);
+ initBasicInfo(&pIntervalInfo->binfo, pResBlock);
+ initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win);
- iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, numOfCols, iaInfo);
- if (iaInfo->timeWindowInterpo) {
- iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SResultRowPosition));
- if (iaInfo->binfo.resultRowInfo.openWindow == NULL) {
+ pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo);
+ if (pIntervalInfo->timeWindowInterpo) {
+ pIntervalInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SResultRowPosition));
+ if (pIntervalInfo->binfo.resultRowInfo.openWindow == NULL) {
goto _error;
}
}
- initResultRowInfo(&iaInfo->binfo.resultRowInfo);
+ initResultRowInfo(&pIntervalInfo->binfo.resultRowInfo);
- pOperator->name = "TimeMergeIntervalAggOperator";
+ pOperator->name = "TimeMergeIntervalAggOperator";
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL;
- pOperator->blocking = false;
- pOperator->status = OP_NOT_OPENED;
- pOperator->exprSupp.pExprInfo = pExprInfo;
- pOperator->pTaskInfo = pTaskInfo;
- pOperator->exprSupp.numOfExprs = numOfCols;
- pOperator->info = miaInfo;
+ pOperator->blocking = false;
+ pOperator->status = OP_NOT_OPENED;
+ pOperator->pTaskInfo = pTaskInfo;
+ pOperator->info = pMergeIntervalInfo;
pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doMergeIntervalAgg, NULL, NULL,
destroyMergeIntervalOperatorInfo, NULL, NULL, NULL);
@@ -5490,7 +5495,7 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SExprI
return pOperator;
_error:
- destroyMergeIntervalOperatorInfo(miaInfo);
+ destroyMergeIntervalOperatorInfo(pMergeIntervalInfo);
taosMemoryFreeClear(pOperator);
pTaskInfo->code = code;
return NULL;
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index ed82e4cb50cd2ce72ab3e9965b7ef1481fe2ccfa..b7cd02befd326eafd7b0a9354a3f5c50147d834b 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -303,7 +303,7 @@ static int32_t translateInOutStr(SFunctionNode* pFunc, char* pErrBuf, int32_t le
}
SExprNode* pPara1 = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
- if (!IS_VAR_DATA_TYPE(pPara1->resType.type)) {
+ if (!IS_STR_DATA_TYPE(pPara1->resType.type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -317,7 +317,7 @@ static int32_t translateTrimStr(SFunctionNode* pFunc, char* pErrBuf, int32_t len
}
SExprNode* pPara1 = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
- if (!IS_VAR_DATA_TYPE(pPara1->resType.type)) {
+ if (!IS_STR_DATA_TYPE(pPara1->resType.type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -546,7 +546,7 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
// param2
if (3 == numOfParams) {
uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
- if (!IS_VAR_DATA_TYPE(para3Type)) {
+ if (!IS_STR_DATA_TYPE(para3Type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -593,7 +593,7 @@ static int32_t translateApercentileImpl(SFunctionNode* pFunc, char* pErrBuf, int
// param2
if (3 == numOfParams) {
uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
- if (!IS_VAR_DATA_TYPE(para3Type)) {
+ if (!IS_STR_DATA_TYPE(para3Type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1388,7 +1388,7 @@ static int32_t translateSample(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
}
// set result type
- if (IS_VAR_DATA_TYPE(colType)) {
+ if (IS_STR_DATA_TYPE(colType)) {
pFunc->node.resType = (SDataType){.bytes = pCol->resType.bytes, .type = colType};
} else {
pFunc->node.resType = (SDataType){.bytes = tDataTypes[colType].bytes, .type = colType};
@@ -1431,7 +1431,7 @@ static int32_t translateTail(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
}
// set result type
- if (IS_VAR_DATA_TYPE(colType)) {
+ if (IS_STR_DATA_TYPE(colType)) {
pFunc->node.resType = (SDataType){.bytes = pCol->resType.bytes, .type = colType};
} else {
pFunc->node.resType = (SDataType){.bytes = tDataTypes[colType].bytes, .type = colType};
@@ -1514,7 +1514,7 @@ static int32_t translateInterp(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
for (int32_t i = 1; i < 3; ++i) {
nodeType = nodeType(nodesListGetNode(pFunc->pParameterList, i));
paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
- if (!IS_VAR_DATA_TYPE(paraType) || QUERY_NODE_VALUE != nodeType) {
+ if (!IS_STR_DATA_TYPE(paraType) || QUERY_NODE_VALUE != nodeType) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1682,7 +1682,7 @@ static int32_t translateLength(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
}
- if (!IS_VAR_DATA_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type)) {
+ if (!IS_STR_DATA_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1714,7 +1714,7 @@ static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
for (int32_t i = 0; i < numOfParams; ++i) {
SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);
uint8_t paraType = ((SExprNode*)pPara)->resType.type;
- if (!IS_VAR_DATA_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
+ if (!IS_STR_DATA_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
if (TSDB_DATA_TYPE_NCHAR == paraType) {
@@ -1770,7 +1770,7 @@ static int32_t translateSubstr(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
uint8_t para0Type = pPara0->resType.type;
uint8_t para1Type = pPara1->resType.type;
- if (!IS_VAR_DATA_TYPE(para0Type) || !IS_INTEGER_TYPE(para1Type)) {
+ if (!IS_STR_DATA_TYPE(para0Type) || !IS_INTEGER_TYPE(para1Type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1802,7 +1802,7 @@ static int32_t translateCast(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
uint8_t para2Type = pFunc->node.resType.type;
int32_t para2Bytes = pFunc->node.resType.bytes;
- if (IS_VAR_DATA_TYPE(para2Type)) {
+ if (IS_STR_DATA_TYPE(para2Type)) {
para2Bytes -= VARSTR_HEADER_SIZE;
}
if (para2Bytes <= 0 || para2Bytes > 4096) { // cast dst var type length limits to 4096 bytes
@@ -1859,7 +1859,7 @@ static int32_t translateToUnixtimestamp(SFunctionNode* pFunc, char* pErrBuf, int
return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
}
- if (!IS_VAR_DATA_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type)) {
+ if (!IS_STR_DATA_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1878,7 +1878,7 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
- if ((!IS_VAR_DATA_TYPE(para1Type) && !IS_INTEGER_TYPE(para1Type) && TSDB_DATA_TYPE_TIMESTAMP != para1Type) ||
+ if ((!IS_STR_DATA_TYPE(para1Type) && !IS_INTEGER_TYPE(para1Type) && TSDB_DATA_TYPE_TIMESTAMP != para1Type) ||
!IS_INTEGER_TYPE(para2Type)) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
@@ -1911,7 +1911,7 @@ static int32_t translateTimeDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t le
for (int32_t i = 0; i < 2; ++i) {
uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
- if (!IS_VAR_DATA_TYPE(paraType) && !IS_INTEGER_TYPE(paraType) && TSDB_DATA_TYPE_TIMESTAMP != paraType) {
+ if (!IS_STR_DATA_TYPE(paraType) && !IS_INTEGER_TYPE(paraType) && TSDB_DATA_TYPE_TIMESTAMP != paraType) {
return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
}
}
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 56e68d8374518ab7494371151513c099bc37ab80..9bff061d02fbfa8d5795dff82c9ec93b7093f96d 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -495,12 +495,9 @@ bufsize_opt(A) ::= BUFSIZE NK_INTEGER(B).
/************************************************ create/drop stream **************************************************/
cmd ::= CREATE STREAM not_exists_opt(E) stream_name(A)
- stream_options(B) into_opt(C) AS query_expression(D). { pCxt->pRootNode = createCreateStreamStmt(pCxt, E, &A, C, B, D); }
+ stream_options(B) INTO full_table_name(C) AS query_expression(D). { pCxt->pRootNode = createCreateStreamStmt(pCxt, E, &A, C, B, D); }
cmd ::= DROP STREAM exists_opt(A) stream_name(B). { pCxt->pRootNode = createDropStreamStmt(pCxt, A, &B); }
-into_opt(A) ::= . { A = NULL; }
-into_opt(A) ::= INTO full_table_name(B). { A = B; }
-
stream_options(A) ::= . { A = createStreamOptions(pCxt); }
stream_options(A) ::= stream_options(B) TRIGGER AT_ONCE. { ((SStreamOptions*)B)->triggerType = STREAM_TRIGGER_AT_ONCE; A = B; }
stream_options(A) ::= stream_options(B) TRIGGER WINDOW_CLOSE. { ((SStreamOptions*)B)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; A = B; }
diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c
index ffa7729745021be10cfc22aa66dab7f7b3abccb3..82b5842663a824b08553da9ac3b1044a19ad3ef6 100644
--- a/source/libs/parser/src/parAstParser.c
+++ b/source/libs/parser/src/parAstParser.c
@@ -464,6 +464,9 @@ static int32_t collectMetaKeyFromShowCreateTable(SCollectMetaKeyCxt* pCxt, SShow
if (TSDB_CODE_SUCCESS == code) {
code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pCxt->pMetaCache);
}
+ if (TSDB_CODE_SUCCESS == code) {
+ code = reserveUserAuthInCacheExt(pCxt->pParseCxt->pUser, &name, AUTH_TYPE_READ, pCxt->pMetaCache);
+ }
return code;
}
diff --git a/source/libs/parser/src/parAuthenticator.c b/source/libs/parser/src/parAuthenticator.c
index fc76d8ffc6755e3deeba1870cd0bd4198917f49d..d9a5761d99b7f04d5f2d4d9604ceee3faf76a896 100644
--- a/source/libs/parser/src/parAuthenticator.c
+++ b/source/libs/parser/src/parAuthenticator.c
@@ -96,6 +96,10 @@ static int32_t authInsert(SAuthCxt* pCxt, SInsertStmt* pInsert) {
return code;
}
+static int32_t authShowCreateTable(SAuthCxt* pCxt, SShowCreateTableStmt* pStmt) {
+ return checkAuth(pCxt, pStmt->dbName, AUTH_TYPE_READ);
+}
+
static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
switch (nodeType(pStmt)) {
case QUERY_NODE_SET_OPERATOR:
@@ -118,11 +122,14 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
case QUERY_NODE_SHOW_LICENCES_STMT:
case QUERY_NODE_SHOW_VGROUPS_STMT:
case QUERY_NODE_SHOW_VARIABLES_STMT:
- case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
+ case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:
case QUERY_NODE_SHOW_VNODES_STMT:
case QUERY_NODE_SHOW_SCORES_STMT:
return !pCxt->pParseCxt->enableSysInfo ? TSDB_CODE_PAR_PERMISSION_DENIED : TSDB_CODE_SUCCESS;
+ case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+ case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
+ return authShowCreateTable(pCxt, (SShowCreateTableStmt*)pStmt);
default:
break;
}
diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c
index 4e32672697f9faac9d25667a5018acac60b6fbb4..c9115d90e18a73ff6328e877eaddfeb0e2c72b36 100644
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@@ -1715,7 +1715,7 @@ static int32_t skipUsingClause(SInsertParseSyntaxCxt* pCxt) {
}
static int32_t collectTableMetaKey(SInsertParseSyntaxCxt* pCxt, bool isStable, int32_t tableNo, SToken* pTbToken) {
- SName name;
+ SName name = {0};
CHECK_CODE(createSName(&name, pTbToken, pCxt->pComCxt->acctId, pCxt->pComCxt->db, &pCxt->msg));
CHECK_CODE(reserveTableMetaInCacheForInsert(&name, isStable ? CATALOG_REQ_TYPE_META : CATALOG_REQ_TYPE_BOTH, tableNo,
pCxt->pMetaCache));
@@ -1730,7 +1730,7 @@ static int32_t checkTableName(const char* pTableName, SMsgBuf* pMsgBuf) {
}
static int32_t collectAutoCreateTableMetaKey(SInsertParseSyntaxCxt* pCxt, int32_t tableNo, SToken* pTbToken) {
- SName name;
+ SName name = {0};
CHECK_CODE(createSName(&name, pTbToken, pCxt->pComCxt->acctId, pCxt->pComCxt->db, &pCxt->msg));
CHECK_CODE(checkTableName(name.tname, &pCxt->msg));
CHECK_CODE(reserveTableMetaInCacheForInsert(&name, CATALOG_REQ_TYPE_VGROUP, tableNo, pCxt->pMetaCache));
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index c820e955d78dc9439499d21645c2456884edb318..c4bd1aff044a491edede232eff74b8dea1feeadb 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -104,26 +104,26 @@
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
-#define YYNOCODE 427
+#define YYNOCODE 426
#define YYACTIONTYPE unsigned short int
#define ParseTOKENTYPE SToken
typedef union {
int yyinit;
ParseTOKENTYPE yy0;
- SAlterOption yy95;
- EOperatorType yy198;
- EOrder yy204;
- int8_t yy215;
- ENullOrder yy277;
- bool yy313;
- int64_t yy473;
- SNodeList* yy544;
- SToken yy617;
- EJoinType yy708;
- SDataType yy784;
- EFillMode yy816;
- SNode* yy840;
- int32_t yy844;
+ SAlterOption yy5;
+ int8_t yy59;
+ int64_t yy69;
+ EJoinType yy156;
+ SNodeList* yy172;
+ EFillMode yy186;
+ SToken yy209;
+ int32_t yy232;
+ SNode* yy272;
+ bool yy293;
+ EOperatorType yy392;
+ ENullOrder yy493;
+ SDataType yy616;
+ EOrder yy818;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
@@ -140,16 +140,16 @@ typedef union {
#define ParseCTX_STORE
#define YYFALLBACK 1
#define YYNSTATE 667
-#define YYNRULE 491
+#define YYNRULE 489
#define YYNTOKEN 305
#define YY_MAX_SHIFT 666
-#define YY_MIN_SHIFTREDUCE 973
-#define YY_MAX_SHIFTREDUCE 1463
-#define YY_ERROR_ACTION 1464
-#define YY_ACCEPT_ACTION 1465
-#define YY_NO_ACTION 1466
-#define YY_MIN_REDUCE 1467
-#define YY_MAX_REDUCE 1957
+#define YY_MIN_SHIFTREDUCE 972
+#define YY_MAX_SHIFTREDUCE 1460
+#define YY_ERROR_ACTION 1461
+#define YY_ACCEPT_ACTION 1462
+#define YY_NO_ACTION 1463
+#define YY_MIN_REDUCE 1464
+#define YY_MAX_REDUCE 1952
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
@@ -216,694 +216,650 @@ typedef union {
** yy_default[] Default action for each state.
**
*********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (2548)
+#define YY_ACTTAB_COUNT (2259)
static const YYACTIONTYPE yy_action[] = {
- /* 0 */ 526, 30, 261, 526, 549, 433, 526, 434, 1502, 11,
- /* 10 */ 10, 117, 39, 37, 55, 1653, 1654, 117, 471, 378,
- /* 20 */ 339, 1468, 1264, 1006, 476, 1023, 1290, 1022, 1607, 1791,
- /* 30 */ 1598, 1607, 127, 1340, 1607, 1262, 441, 552, 434, 1502,
- /* 40 */ 469, 1775, 107, 1779, 1290, 106, 105, 104, 103, 102,
- /* 50 */ 101, 100, 99, 98, 1775, 1024, 1335, 1809, 150, 64,
- /* 60 */ 1935, 14, 1567, 1010, 1011, 553, 1771, 1777, 1270, 450,
- /* 70 */ 1761, 125, 577, 165, 39, 37, 1403, 1932, 571, 1771,
- /* 80 */ 1777, 328, 339, 1529, 1264, 551, 161, 1877, 1878, 1,
- /* 90 */ 1882, 571, 1659, 479, 478, 1340, 1823, 1262, 1376, 327,
- /* 100 */ 95, 1792, 580, 1794, 1795, 576, 496, 571, 1657, 344,
- /* 110 */ 1869, 663, 1652, 1654, 330, 1865, 160, 513, 1335, 494,
- /* 120 */ 1935, 492, 1289, 14, 325, 1342, 1343, 1705, 164, 543,
- /* 130 */ 1270, 1161, 1162, 1934, 33, 32, 1895, 1932, 40, 38,
- /* 140 */ 36, 35, 34, 148, 63, 1479, 640, 639, 638, 637,
+ /* 0 */ 433, 1930, 434, 1499, 1593, 441, 526, 434, 1499, 513,
+ /* 10 */ 30, 260, 39, 37, 1929, 326, 325, 117, 1927, 1702,
+ /* 20 */ 339, 1465, 1261, 146, 471, 40, 38, 36, 35, 34,
+ /* 30 */ 1786, 552, 1606, 1337, 1604, 1259, 344, 552, 1287, 1649,
+ /* 40 */ 1651, 378, 107, 1774, 526, 106, 105, 104, 103, 102,
+ /* 50 */ 101, 100, 99, 98, 1770, 117, 1332, 432, 1804, 64,
+ /* 60 */ 436, 14, 476, 36, 35, 34, 553, 148, 1267, 1476,
+ /* 70 */ 450, 1756, 1604, 577, 39, 37, 1400, 1595, 1766, 1772,
+ /* 80 */ 328, 1930, 339, 1526, 1261, 1804, 217, 1286, 1770, 1,
+ /* 90 */ 571, 1005, 1656, 542, 164, 1337, 1818, 1259, 1927, 327,
+ /* 100 */ 95, 1787, 580, 1789, 1790, 576, 43, 571, 1654, 158,
+ /* 110 */ 1864, 663, 1766, 1772, 330, 1860, 159, 513, 1332, 63,
+ /* 120 */ 1930, 78, 1643, 14, 571, 1339, 1340, 1703, 163, 541,
+ /* 130 */ 1267, 1009, 1010, 165, 33, 32, 1890, 1927, 40, 38,
+ /* 140 */ 36, 35, 34, 543, 63, 63, 640, 639, 638, 637,
/* 150 */ 349, 2, 636, 635, 128, 630, 629, 628, 627, 626,
/* 160 */ 625, 624, 139, 620, 619, 618, 348, 347, 615, 614,
- /* 170 */ 1265, 107, 1263, 663, 106, 105, 104, 103, 102, 101,
- /* 180 */ 100, 99, 98, 1809, 36, 35, 34, 1342, 1343, 224,
- /* 190 */ 225, 542, 384, 1268, 1269, 613, 1317, 1318, 1320, 1321,
- /* 200 */ 1322, 1323, 1324, 1325, 573, 569, 1333, 1334, 1336, 1337,
- /* 210 */ 1338, 1339, 1341, 1344, 1467, 1288, 1434, 33, 32, 482,
- /* 220 */ 481, 40, 38, 36, 35, 34, 123, 168, 541, 303,
- /* 230 */ 1465, 223, 1265, 84, 1263, 1264, 477, 480, 116, 115,
- /* 240 */ 114, 113, 112, 111, 110, 109, 108, 305, 1262, 1023,
- /* 250 */ 516, 1022, 22, 174, 1600, 1268, 1269, 1490, 1317, 1318,
- /* 260 */ 1320, 1321, 1322, 1323, 1324, 1325, 573, 569, 1333, 1334,
- /* 270 */ 1336, 1337, 1338, 1339, 1341, 1344, 39, 37, 1489, 1024,
- /* 280 */ 538, 1270, 168, 526, 339, 71, 1264, 1488, 70, 354,
- /* 290 */ 1244, 1245, 1708, 1791, 170, 211, 512, 1340, 1761, 1262,
- /* 300 */ 1119, 602, 601, 600, 1123, 599, 1125, 1126, 598, 1128,
- /* 310 */ 595, 1607, 1134, 592, 1136, 1137, 589, 586, 1935, 1761,
- /* 320 */ 1335, 1809, 1584, 1270, 663, 14, 1659, 1935, 1761, 553,
- /* 330 */ 1935, 166, 1270, 343, 1761, 1932, 577, 1935, 39, 37,
- /* 340 */ 1933, 487, 1657, 165, 1932, 552, 339, 1932, 1264, 549,
- /* 350 */ 165, 76, 305, 2, 1932, 516, 497, 544, 539, 1340,
- /* 360 */ 1823, 1262, 1698, 159, 95, 1792, 580, 1794, 1795, 576,
- /* 370 */ 210, 571, 63, 173, 1869, 663, 1646, 127, 330, 1865,
- /* 380 */ 160, 552, 1335, 1265, 490, 1263, 419, 605, 484, 1342,
- /* 390 */ 1343, 33, 32, 209, 1270, 40, 38, 36, 35, 34,
- /* 400 */ 1896, 634, 632, 39, 37, 1345, 1268, 1269, 1487, 91,
- /* 410 */ 622, 339, 1791, 1264, 42, 8, 125, 40, 38, 36,
- /* 420 */ 35, 34, 124, 611, 1340, 58, 1262, 1596, 57, 49,
- /* 430 */ 1599, 162, 1877, 1878, 1265, 1882, 1263, 663, 178, 177,
- /* 440 */ 1809, 352, 137, 136, 608, 607, 606, 1335, 575, 1761,
- /* 450 */ 43, 1342, 1343, 1761, 316, 577, 1486, 1268, 1269, 1270,
- /* 460 */ 1317, 1318, 1320, 1321, 1322, 1323, 1324, 1325, 573, 569,
- /* 470 */ 1333, 1334, 1336, 1337, 1338, 1339, 1341, 1344, 63, 1823,
- /* 480 */ 9, 74, 1935, 294, 1792, 580, 1794, 1795, 576, 574,
- /* 490 */ 571, 568, 1841, 1289, 122, 165, 1265, 1761, 1263, 1932,
- /* 500 */ 33, 32, 663, 1602, 40, 38, 36, 35, 34, 317,
- /* 510 */ 168, 315, 314, 1485, 473, 351, 1342, 1343, 475, 1268,
- /* 520 */ 1269, 1291, 1317, 1318, 1320, 1321, 1322, 1323, 1324, 1325,
- /* 530 */ 573, 569, 1333, 1334, 1336, 1337, 1338, 1339, 1341, 1344,
- /* 540 */ 474, 1010, 1011, 33, 32, 1460, 1364, 40, 38, 36,
- /* 550 */ 35, 34, 168, 168, 1761, 526, 1935, 1592, 377, 146,
- /* 560 */ 376, 1265, 63, 1263, 26, 1532, 382, 168, 1610, 165,
- /* 570 */ 33, 32, 217, 1932, 40, 38, 36, 35, 34, 218,
- /* 580 */ 1484, 1791, 1414, 1607, 1268, 1269, 1594, 1317, 1318, 1320,
- /* 590 */ 1321, 1322, 1323, 1324, 1325, 573, 569, 1333, 1334, 1336,
- /* 600 */ 1337, 1338, 1339, 1341, 1344, 39, 37, 77, 27, 1809,
- /* 610 */ 498, 1884, 63, 339, 78, 1264, 168, 578, 1369, 1483,
- /* 620 */ 505, 1761, 1761, 373, 577, 1302, 1340, 28, 1262, 482,
- /* 630 */ 481, 1482, 1459, 33, 32, 1881, 123, 40, 38, 36,
- /* 640 */ 35, 34, 375, 371, 438, 1590, 477, 480, 1823, 1335,
- /* 650 */ 1287, 1935, 96, 1792, 580, 1794, 1795, 576, 253, 571,
- /* 660 */ 1761, 1270, 1869, 513, 165, 1481, 1868, 1865, 1932, 1081,
- /* 670 */ 33, 32, 1761, 1706, 40, 38, 36, 35, 34, 666,
- /* 680 */ 33, 32, 9, 526, 40, 38, 36, 35, 34, 1478,
- /* 690 */ 1477, 33, 32, 268, 383, 40, 38, 36, 35, 34,
- /* 700 */ 168, 1704, 1083, 300, 663, 432, 1761, 157, 436, 1698,
- /* 710 */ 214, 1607, 656, 652, 648, 644, 266, 1582, 1342, 1343,
- /* 720 */ 176, 33, 32, 307, 572, 40, 38, 36, 35, 34,
- /* 730 */ 1761, 1761, 39, 37, 526, 604, 526, 302, 1476, 1287,
- /* 740 */ 339, 549, 1264, 526, 307, 389, 412, 404, 92, 424,
- /* 750 */ 168, 231, 1302, 1340, 405, 1262, 440, 1585, 74, 436,
- /* 760 */ 1362, 1407, 1607, 1265, 1607, 1263, 397, 1289, 425, 127,
- /* 770 */ 399, 1607, 1475, 1703, 1779, 300, 1335, 1889, 1396, 1761,
- /* 780 */ 1603, 1362, 44, 4, 523, 1775, 1268, 1269, 1270, 1317,
- /* 790 */ 1318, 1320, 1321, 1322, 1323, 1324, 1325, 573, 569, 1333,
- /* 800 */ 1334, 1336, 1337, 1338, 1339, 1341, 1344, 390, 125, 2,
- /* 810 */ 1771, 1777, 334, 1761, 1363, 7, 220, 450, 611, 386,
- /* 820 */ 90, 526, 571, 163, 1877, 1878, 1659, 1882, 1424, 145,
- /* 830 */ 87, 663, 448, 312, 1236, 1363, 213, 137, 136, 608,
- /* 840 */ 607, 606, 1657, 1480, 1884, 1342, 1343, 423, 1474, 1607,
+ /* 170 */ 1262, 107, 1260, 663, 106, 105, 104, 103, 102, 101,
+ /* 180 */ 100, 99, 98, 440, 1775, 1287, 436, 1339, 1340, 223,
+ /* 190 */ 224, 11, 10, 1265, 1266, 1770, 1314, 1315, 1317, 1318,
+ /* 200 */ 1319, 1320, 1321, 1322, 573, 569, 1330, 1331, 1333, 1334,
+ /* 210 */ 1335, 1336, 1338, 1341, 1464, 496, 1431, 33, 32, 1766,
+ /* 220 */ 1772, 40, 38, 36, 35, 34, 526, 167, 494, 150,
+ /* 230 */ 492, 571, 1262, 1564, 1260, 1261, 210, 55, 116, 115,
+ /* 240 */ 114, 113, 112, 111, 110, 109, 108, 305, 1259, 63,
+ /* 250 */ 516, 1701, 22, 300, 1604, 1265, 1266, 167, 1314, 1315,
+ /* 260 */ 1317, 1318, 1319, 1320, 1321, 1322, 573, 569, 1330, 1331,
+ /* 270 */ 1333, 1334, 1335, 1336, 1338, 1341, 39, 37, 1650, 1651,
+ /* 280 */ 1373, 1267, 167, 167, 339, 552, 1261, 613, 1286, 49,
+ /* 290 */ 1160, 1161, 76, 305, 1786, 1487, 516, 1337, 1421, 1259,
+ /* 300 */ 1118, 602, 601, 600, 1122, 599, 1124, 1125, 598, 1127,
+ /* 310 */ 595, 342, 1133, 592, 1135, 1136, 589, 586, 1285, 146,
+ /* 320 */ 1332, 1581, 1804, 173, 663, 14, 479, 478, 1606, 377,
+ /* 330 */ 553, 376, 1267, 1656, 1930, 1756, 1756, 577, 39, 37,
+ /* 340 */ 312, 535, 1419, 1420, 1422, 1423, 339, 1928, 1261, 1654,
+ /* 350 */ 1705, 1927, 84, 2, 42, 71, 1656, 63, 70, 1337,
+ /* 360 */ 1818, 1259, 1267, 343, 95, 1787, 580, 1789, 1790, 576,
+ /* 370 */ 605, 571, 1654, 1597, 1864, 663, 345, 1589, 330, 1860,
+ /* 380 */ 159, 1288, 1332, 1262, 146, 1260, 1022, 167, 1021, 1339,
+ /* 390 */ 1340, 33, 32, 1606, 1267, 40, 38, 36, 35, 34,
+ /* 400 */ 1891, 1930, 384, 39, 37, 1342, 1265, 1266, 1486, 1485,
+ /* 410 */ 611, 339, 1786, 1261, 165, 8, 1023, 438, 1927, 634,
+ /* 420 */ 632, 1080, 611, 1284, 1337, 622, 1259, 167, 549, 137,
+ /* 430 */ 136, 608, 607, 606, 1262, 1695, 1260, 663, 1484, 303,
+ /* 440 */ 1804, 137, 136, 608, 607, 606, 172, 1332, 575, 1756,
+ /* 450 */ 1756, 1339, 1340, 1756, 1082, 577, 127, 1265, 1266, 1267,
+ /* 460 */ 1314, 1315, 1317, 1318, 1319, 1320, 1321, 1322, 573, 569,
+ /* 470 */ 1330, 1331, 1333, 1334, 1335, 1336, 1338, 1341, 1818, 1756,
+ /* 480 */ 9, 1591, 293, 1787, 580, 1789, 1790, 576, 574, 571,
+ /* 490 */ 568, 1836, 167, 74, 125, 167, 1262, 222, 1260, 33,
+ /* 500 */ 32, 1529, 663, 40, 38, 36, 35, 34, 551, 160,
+ /* 510 */ 1872, 1873, 1587, 1877, 1483, 1600, 1339, 1340, 252, 1265,
+ /* 520 */ 1266, 1579, 1314, 1315, 1317, 1318, 1319, 1320, 1321, 1322,
+ /* 530 */ 573, 569, 1330, 1331, 1333, 1334, 1335, 1336, 1338, 1341,
+ /* 540 */ 1700, 526, 300, 33, 32, 1457, 91, 40, 38, 36,
+ /* 550 */ 35, 34, 169, 167, 316, 1756, 1241, 1242, 623, 124,
+ /* 560 */ 1576, 1262, 1879, 1260, 26, 482, 481, 1596, 1462, 1604,
+ /* 570 */ 33, 32, 123, 1582, 40, 38, 36, 35, 34, 213,
+ /* 580 */ 1786, 1411, 477, 480, 1265, 1266, 1876, 1314, 1315, 1317,
+ /* 590 */ 1318, 1319, 1320, 1321, 1322, 573, 569, 1330, 1331, 1333,
+ /* 600 */ 1334, 1335, 1336, 1338, 1341, 39, 37, 475, 1804, 317,
+ /* 610 */ 146, 315, 314, 339, 473, 1261, 578, 1361, 475, 1607,
+ /* 620 */ 549, 1756, 611, 577, 28, 1299, 1337, 354, 1259, 474,
+ /* 630 */ 33, 32, 1456, 450, 40, 38, 36, 35, 34, 538,
+ /* 640 */ 474, 137, 136, 608, 607, 606, 1818, 1695, 127, 1332,
+ /* 650 */ 96, 1787, 580, 1789, 1790, 576, 572, 571, 175, 74,
+ /* 660 */ 1864, 1267, 526, 609, 1863, 1860, 1647, 1930, 554, 512,
+ /* 670 */ 33, 32, 122, 382, 40, 38, 36, 35, 34, 27,
+ /* 680 */ 164, 1599, 9, 1482, 1927, 1022, 125, 1021, 7, 1366,
+ /* 690 */ 1604, 33, 32, 1481, 1565, 40, 38, 36, 35, 34,
+ /* 700 */ 469, 250, 1872, 548, 663, 547, 33, 32, 1930, 1930,
+ /* 710 */ 40, 38, 36, 35, 34, 1023, 544, 539, 1339, 1340,
+ /* 720 */ 526, 166, 164, 307, 1756, 1927, 1927, 135, 487, 1404,
+ /* 730 */ 526, 383, 39, 37, 1756, 1286, 1480, 302, 1879, 1284,
+ /* 740 */ 339, 389, 1261, 497, 307, 526, 412, 604, 1604, 424,
+ /* 750 */ 526, 549, 1299, 1337, 1477, 1259, 404, 209, 1604, 61,
+ /* 760 */ 1359, 405, 1875, 1262, 373, 1260, 397, 1479, 425, 1478,
+ /* 770 */ 399, 490, 255, 1604, 54, 484, 1332, 1756, 1604, 127,
+ /* 780 */ 208, 1359, 1475, 375, 371, 419, 1265, 1266, 1267, 1314,
+ /* 790 */ 1315, 1317, 1318, 1319, 1320, 1321, 1322, 573, 569, 1330,
+ /* 800 */ 1331, 1333, 1334, 1335, 1336, 1338, 1341, 390, 1756, 2,
+ /* 810 */ 1756, 1397, 58, 526, 1360, 57, 1879, 125, 505, 386,
+ /* 820 */ 1289, 33, 32, 1756, 448, 40, 38, 36, 35, 34,
+ /* 830 */ 1474, 663, 161, 1872, 1873, 1360, 1877, 177, 176, 1505,
+ /* 840 */ 1874, 1604, 1347, 1009, 1010, 1339, 1340, 423, 1286, 1580,
/* 850 */ 418, 417, 416, 415, 414, 411, 410, 409, 408, 407,
- /* 860 */ 403, 402, 401, 400, 394, 393, 392, 391, 1880, 388,
- /* 870 */ 387, 535, 1422, 1423, 1425, 1426, 29, 337, 1357, 1358,
- /* 880 */ 1359, 1360, 1361, 1365, 1366, 1367, 1368, 1350, 61, 1761,
- /* 890 */ 1265, 609, 1263, 1289, 1650, 1935, 1400, 29, 337, 1357,
- /* 900 */ 1358, 1359, 1360, 1361, 1365, 1366, 1367, 1368, 166, 1583,
- /* 910 */ 1791, 1473, 1932, 1268, 1269, 1472, 1317, 1318, 1320, 1321,
- /* 920 */ 1322, 1323, 1324, 1325, 573, 569, 1333, 1334, 1336, 1337,
- /* 930 */ 1338, 1339, 1341, 1344, 623, 147, 1579, 1791, 1809, 526,
- /* 940 */ 279, 611, 610, 256, 1319, 1650, 578, 1884, 1471, 1470,
- /* 950 */ 449, 1761, 1761, 577, 277, 60, 1761, 475, 59, 1292,
- /* 960 */ 137, 136, 608, 607, 606, 1809, 554, 1607, 1289, 613,
- /* 970 */ 1568, 1879, 135, 578, 181, 429, 427, 1823, 1761, 474,
- /* 980 */ 577, 94, 1792, 580, 1794, 1795, 576, 536, 571, 1761,
- /* 990 */ 1761, 1869, 1780, 554, 468, 306, 1865, 273, 53, 509,
- /* 1000 */ 1637, 1659, 1396, 1775, 1823, 526, 63, 1935, 94, 1792,
- /* 1010 */ 580, 1794, 1795, 576, 526, 571, 1604, 1658, 1869, 54,
- /* 1020 */ 167, 1748, 306, 1865, 1932, 1736, 1519, 202, 1771, 1777,
- /* 1030 */ 200, 336, 335, 1607, 1935, 1462, 1463, 558, 526, 526,
- /* 1040 */ 571, 1278, 1607, 1273, 93, 526, 526, 165, 483, 506,
- /* 1050 */ 510, 1932, 1340, 561, 1271, 326, 228, 522, 526, 204,
- /* 1060 */ 526, 1791, 203, 146, 499, 526, 1607, 1607, 361, 524,
- /* 1070 */ 1319, 525, 1609, 1607, 1607, 1335, 262, 41, 222, 68,
- /* 1080 */ 67, 381, 342, 526, 172, 1272, 1607, 1270, 1607, 1809,
- /* 1090 */ 146, 131, 245, 1607, 346, 206, 233, 578, 205, 1609,
- /* 1100 */ 301, 567, 1761, 369, 577, 367, 363, 359, 356, 353,
- /* 1110 */ 345, 1607, 1782, 208, 134, 135, 207, 1810, 146, 1514,
- /* 1120 */ 1399, 1512, 51, 1791, 1213, 226, 237, 1609, 1823, 556,
- /* 1130 */ 566, 51, 95, 1792, 580, 1794, 1795, 576, 519, 571,
- /* 1140 */ 41, 485, 1869, 488, 168, 1319, 330, 1865, 1948, 11,
- /* 1150 */ 10, 1809, 616, 41, 617, 1784, 350, 1903, 584, 578,
- /* 1160 */ 134, 230, 1112, 1503, 1761, 1647, 577, 135, 119, 1421,
- /* 1170 */ 134, 1899, 550, 240, 1069, 1791, 1067, 255, 1370, 250,
- /* 1180 */ 1276, 258, 260, 3, 5, 355, 313, 1326, 1050, 1279,
- /* 1190 */ 1823, 1274, 360, 1229, 95, 1792, 580, 1794, 1795, 576,
- /* 1200 */ 272, 571, 269, 1809, 1869, 1140, 1508, 1144, 330, 1865,
- /* 1210 */ 1948, 578, 1282, 1284, 1151, 1149, 1761, 138, 577, 1926,
- /* 1220 */ 175, 1051, 1275, 1287, 569, 1333, 1334, 1336, 1337, 1338,
- /* 1230 */ 1339, 1791, 385, 1354, 406, 1700, 413, 421, 420, 1293,
- /* 1240 */ 559, 1791, 1823, 422, 426, 431, 95, 1792, 580, 1794,
- /* 1250 */ 1795, 576, 428, 571, 658, 439, 1869, 430, 562, 1809,
- /* 1260 */ 330, 1865, 1948, 1295, 442, 443, 184, 578, 1294, 1809,
- /* 1270 */ 186, 1888, 1761, 1296, 577, 444, 445, 578, 189, 447,
- /* 1280 */ 191, 72, 1761, 73, 577, 451, 470, 554, 195, 472,
- /* 1290 */ 1791, 304, 1597, 199, 118, 1593, 1741, 554, 1823, 501,
- /* 1300 */ 201, 140, 286, 1792, 580, 1794, 1795, 576, 1823, 571,
- /* 1310 */ 141, 1595, 286, 1792, 580, 1794, 1795, 576, 1809, 571,
- /* 1320 */ 1591, 142, 143, 212, 270, 500, 578, 215, 1935, 507,
- /* 1330 */ 504, 1761, 511, 577, 322, 219, 534, 514, 1935, 132,
- /* 1340 */ 1740, 167, 1710, 520, 517, 1932, 133, 324, 81, 521,
- /* 1350 */ 1791, 165, 1292, 530, 271, 1932, 83, 1823, 1608, 235,
- /* 1360 */ 1791, 96, 1792, 580, 1794, 1795, 576, 1900, 571, 537,
- /* 1370 */ 239, 1869, 532, 1910, 6, 565, 1865, 533, 1809, 546,
- /* 1380 */ 329, 1909, 540, 531, 529, 244, 578, 1891, 1809, 528,
- /* 1390 */ 1396, 1761, 1291, 577, 154, 126, 578, 249, 563, 560,
- /* 1400 */ 246, 1761, 48, 577, 1885, 247, 331, 248, 85, 1791,
- /* 1410 */ 582, 1651, 1580, 265, 274, 659, 660, 1823, 1931, 662,
- /* 1420 */ 52, 149, 1792, 580, 1794, 1795, 576, 1823, 571, 1951,
- /* 1430 */ 153, 96, 1792, 580, 1794, 1795, 576, 1809, 571, 557,
- /* 1440 */ 1755, 1869, 323, 287, 297, 578, 1866, 1850, 296, 254,
- /* 1450 */ 1761, 276, 577, 564, 1754, 278, 257, 259, 65, 1753,
- /* 1460 */ 1791, 1752, 66, 1749, 357, 555, 1949, 358, 1256, 1257,
- /* 1470 */ 171, 362, 1747, 364, 365, 366, 1823, 1746, 1745, 368,
- /* 1480 */ 295, 1792, 580, 1794, 1795, 576, 370, 571, 1809, 1744,
- /* 1490 */ 372, 1743, 374, 527, 1232, 1231, 578, 1721, 1720, 379,
- /* 1500 */ 380, 1761, 1201, 577, 1719, 1718, 1693, 129, 1692, 1691,
- /* 1510 */ 1690, 69, 1791, 1689, 1688, 1687, 1686, 1685, 395, 396,
- /* 1520 */ 1684, 398, 1791, 130, 1669, 1668, 1667, 1823, 1683, 1682,
- /* 1530 */ 1681, 295, 1792, 580, 1794, 1795, 576, 1680, 571, 1791,
- /* 1540 */ 1809, 1679, 1678, 1677, 1676, 1675, 1674, 1673, 578, 1672,
- /* 1550 */ 1809, 1671, 1670, 1761, 1666, 577, 1665, 1664, 578, 1663,
- /* 1560 */ 1203, 1662, 1661, 1761, 1660, 577, 1534, 1809, 179, 1533,
- /* 1570 */ 1531, 1499, 120, 182, 180, 575, 1498, 158, 435, 1823,
- /* 1580 */ 1761, 1013, 577, 290, 1792, 580, 1794, 1795, 576, 1823,
- /* 1590 */ 571, 190, 1012, 149, 1792, 580, 1794, 1795, 576, 1791,
- /* 1600 */ 571, 437, 1734, 183, 121, 1728, 1823, 1717, 1716, 1702,
- /* 1610 */ 294, 1792, 580, 1794, 1795, 576, 1791, 571, 188, 1842,
- /* 1620 */ 1586, 545, 1043, 1530, 1528, 452, 454, 1809, 1526, 453,
- /* 1630 */ 456, 457, 338, 458, 1524, 578, 460, 462, 1950, 461,
- /* 1640 */ 1761, 1522, 577, 465, 1809, 464, 1511, 1510, 1495, 340,
- /* 1650 */ 466, 1588, 578, 1155, 1154, 1587, 50, 1761, 631, 577,
- /* 1660 */ 1080, 1077, 633, 1520, 198, 1076, 1823, 1075, 1515, 1513,
- /* 1670 */ 295, 1792, 580, 1794, 1795, 576, 318, 571, 319, 320,
- /* 1680 */ 486, 1494, 1493, 1823, 1791, 489, 197, 295, 1792, 580,
- /* 1690 */ 1794, 1795, 576, 491, 571, 1492, 493, 495, 97, 1733,
- /* 1700 */ 152, 1238, 1791, 1727, 216, 467, 463, 459, 455, 196,
- /* 1710 */ 56, 502, 1809, 144, 1715, 1713, 1714, 1712, 1711, 221,
- /* 1720 */ 578, 1248, 15, 1709, 227, 1761, 79, 577, 1701, 503,
- /* 1730 */ 1809, 321, 508, 80, 232, 518, 41, 87, 578, 229,
- /* 1740 */ 47, 75, 16, 1761, 194, 577, 243, 242, 82, 25,
- /* 1750 */ 17, 1823, 1436, 23, 234, 280, 1792, 580, 1794, 1795,
- /* 1760 */ 576, 1791, 571, 236, 1418, 515, 238, 1782, 151, 1823,
- /* 1770 */ 1420, 252, 241, 281, 1792, 580, 1794, 1795, 576, 24,
- /* 1780 */ 571, 1413, 1393, 46, 1781, 86, 18, 155, 1392, 1809,
- /* 1790 */ 1448, 1453, 1442, 1447, 332, 1452, 1451, 578, 333, 10,
- /* 1800 */ 45, 1280, 1761, 1330, 577, 1355, 193, 187, 13, 192,
- /* 1810 */ 1791, 19, 1328, 446, 1327, 156, 1826, 169, 570, 31,
- /* 1820 */ 12, 20, 1310, 21, 583, 1141, 341, 1138, 1823, 185,
- /* 1830 */ 587, 1791, 282, 1792, 580, 1794, 1795, 576, 1809, 571,
- /* 1840 */ 585, 588, 581, 1135, 579, 590, 578, 1129, 593, 596,
- /* 1850 */ 1118, 1761, 1127, 577, 591, 594, 597, 1133, 1132, 1809,
- /* 1860 */ 1131, 1130, 88, 89, 263, 603, 1150, 578, 1146, 62,
- /* 1870 */ 1041, 1072, 1761, 612, 577, 1071, 1070, 1823, 1068, 1066,
- /* 1880 */ 1065, 289, 1792, 580, 1794, 1795, 576, 1064, 571, 1791,
- /* 1890 */ 1087, 621, 264, 1062, 1061, 1060, 1059, 1058, 1823, 1791,
- /* 1900 */ 1057, 1056, 291, 1792, 580, 1794, 1795, 576, 1047, 571,
- /* 1910 */ 1084, 1082, 1053, 1052, 1049, 1048, 1046, 1809, 1527, 641,
- /* 1920 */ 1525, 642, 643, 645, 647, 578, 1523, 1809, 649, 646,
- /* 1930 */ 1761, 651, 577, 1521, 650, 578, 653, 655, 654, 1509,
- /* 1940 */ 1761, 657, 577, 1491, 1003, 267, 661, 1466, 1466, 1266,
- /* 1950 */ 275, 1791, 664, 1466, 665, 1466, 1823, 1466, 1466, 1466,
- /* 1960 */ 283, 1792, 580, 1794, 1795, 576, 1823, 571, 1791, 1466,
- /* 1970 */ 292, 1792, 580, 1794, 1795, 576, 1466, 571, 1466, 1809,
- /* 1980 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 578, 1466, 1466,
- /* 1990 */ 1466, 1466, 1761, 1466, 577, 1466, 1809, 1466, 1466, 1466,
- /* 2000 */ 1466, 1466, 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761,
- /* 2010 */ 1466, 577, 1466, 1466, 1466, 1466, 1466, 1791, 1823, 1466,
- /* 2020 */ 1466, 1466, 284, 1792, 580, 1794, 1795, 576, 1466, 571,
- /* 2030 */ 1466, 1466, 1466, 1466, 1791, 1823, 1466, 1466, 1466, 293,
- /* 2040 */ 1792, 580, 1794, 1795, 576, 1809, 571, 1466, 1466, 1466,
- /* 2050 */ 1466, 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761, 1466,
- /* 2060 */ 577, 1466, 1809, 1466, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2070 */ 578, 1466, 1466, 1466, 1466, 1761, 1466, 577, 1466, 1466,
- /* 2080 */ 1466, 1466, 1466, 1791, 1823, 1466, 1466, 1466, 285, 1792,
- /* 2090 */ 580, 1794, 1795, 576, 1466, 571, 1466, 1466, 1466, 1466,
- /* 2100 */ 1466, 1823, 1466, 1466, 1466, 298, 1792, 580, 1794, 1795,
- /* 2110 */ 576, 1809, 571, 1466, 1466, 1466, 1466, 1466, 1466, 578,
- /* 2120 */ 1466, 1466, 1466, 1466, 1761, 1466, 577, 1466, 1466, 1466,
- /* 2130 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1791, 1466, 1466,
- /* 2140 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1791, 1466, 1466,
- /* 2150 */ 1823, 1466, 1466, 1466, 299, 1792, 580, 1794, 1795, 576,
- /* 2160 */ 1466, 571, 1466, 1466, 1466, 1809, 1466, 1466, 1466, 1466,
- /* 2170 */ 1466, 1466, 1466, 578, 1466, 1809, 1466, 1466, 1761, 1466,
- /* 2180 */ 577, 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761, 1466,
- /* 2190 */ 577, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1791, 1466,
- /* 2200 */ 1466, 1466, 1466, 1466, 1823, 1466, 1466, 1466, 1803, 1792,
- /* 2210 */ 580, 1794, 1795, 576, 1823, 571, 1791, 1466, 1802, 1792,
- /* 2220 */ 580, 1794, 1795, 576, 1466, 571, 1809, 1466, 1466, 1466,
- /* 2230 */ 1466, 1466, 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761,
- /* 2240 */ 1466, 577, 1466, 1466, 1809, 1466, 1466, 1466, 1466, 1466,
- /* 2250 */ 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761, 1466, 577,
- /* 2260 */ 1466, 1466, 1466, 1466, 1466, 1823, 1466, 1466, 1466, 1801,
- /* 2270 */ 1792, 580, 1794, 1795, 576, 1791, 571, 1466, 1466, 1466,
- /* 2280 */ 1466, 1466, 1466, 1823, 1466, 1466, 1466, 310, 1792, 580,
- /* 2290 */ 1794, 1795, 576, 1466, 571, 1466, 1791, 1466, 1466, 1466,
- /* 2300 */ 1466, 1466, 1466, 1809, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2310 */ 1466, 578, 1466, 1466, 1466, 1466, 1761, 1466, 577, 1466,
- /* 2320 */ 1466, 1466, 1466, 1466, 1809, 1466, 1466, 1466, 1466, 1466,
- /* 2330 */ 1466, 1466, 578, 1466, 1466, 1466, 1466, 1761, 1466, 577,
- /* 2340 */ 1466, 1466, 1823, 1466, 1466, 1466, 309, 1792, 580, 1794,
- /* 2350 */ 1795, 576, 1791, 571, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2360 */ 1466, 1466, 1791, 1823, 1466, 1466, 1466, 311, 1792, 580,
- /* 2370 */ 1794, 1795, 576, 1466, 571, 1466, 1466, 1466, 1466, 1466,
- /* 2380 */ 1809, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 578, 1466,
- /* 2390 */ 1809, 1466, 1466, 1761, 549, 577, 1466, 1466, 578, 1466,
- /* 2400 */ 1466, 1466, 1466, 1761, 1466, 577, 1466, 1466, 1466, 1466,
- /* 2410 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1823,
- /* 2420 */ 1466, 1466, 127, 308, 1792, 580, 1794, 1795, 576, 1823,
- /* 2430 */ 571, 1466, 1466, 288, 1792, 580, 1794, 1795, 576, 1466,
- /* 2440 */ 571, 549, 554, 1466, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2450 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2460 */ 1466, 125, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 127,
- /* 2470 */ 1466, 1466, 1466, 1466, 1466, 1466, 251, 1877, 548, 1466,
- /* 2480 */ 547, 1466, 1466, 1935, 1466, 1466, 1466, 1466, 1466, 554,
- /* 2490 */ 1466, 1466, 1466, 1466, 1466, 1466, 167, 1466, 1466, 1466,
- /* 2500 */ 1932, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 125, 1466,
- /* 2510 */ 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2520 */ 1466, 1466, 1466, 251, 1877, 548, 1466, 547, 1466, 1466,
- /* 2530 */ 1935, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466,
- /* 2540 */ 1466, 1466, 1466, 165, 1466, 1466, 1466, 1932,
+ /* 860 */ 403, 402, 401, 400, 394, 393, 392, 391, 549, 388,
+ /* 870 */ 387, 1756, 1656, 616, 1473, 1393, 29, 337, 1354, 1355,
+ /* 880 */ 1356, 1357, 1358, 1362, 1363, 1364, 1365, 658, 1655, 468,
+ /* 890 */ 1262, 610, 1260, 1286, 1647, 1068, 127, 29, 337, 1354,
+ /* 900 */ 1355, 1356, 1357, 1358, 1362, 1363, 1364, 1365, 272, 613,
+ /* 910 */ 536, 1634, 1316, 1265, 1266, 1756, 1314, 1315, 1317, 1318,
+ /* 920 */ 1319, 1320, 1321, 1322, 573, 569, 1330, 1331, 1333, 1334,
+ /* 930 */ 1335, 1336, 1338, 1341, 125, 147, 1472, 1786, 561, 352,
+ /* 940 */ 278, 351, 1884, 1393, 1743, 482, 481, 1516, 1774, 162,
+ /* 950 */ 1872, 1873, 123, 1877, 276, 60, 1805, 232, 59, 1770,
+ /* 960 */ 526, 526, 477, 480, 1471, 1804, 44, 4, 244, 483,
+ /* 970 */ 145, 449, 1601, 578, 180, 429, 427, 1756, 1756, 1930,
+ /* 980 */ 577, 1930, 1500, 1766, 1772, 334, 1470, 1786, 1604, 1604,
+ /* 990 */ 526, 361, 164, 554, 164, 571, 1927, 216, 1927, 498,
+ /* 1000 */ 556, 499, 1469, 1818, 1468, 1756, 63, 94, 1787, 580,
+ /* 1010 */ 1789, 1790, 576, 526, 571, 1804, 558, 1864, 1604, 336,
+ /* 1020 */ 335, 306, 1860, 578, 506, 1316, 526, 1756, 1756, 1275,
+ /* 1030 */ 577, 201, 77, 1930, 199, 1396, 1644, 510, 526, 1930,
+ /* 1040 */ 1337, 1604, 1268, 1756, 93, 1756, 166, 1511, 1467, 227,
+ /* 1050 */ 1927, 350, 164, 1818, 1604, 1786, 1927, 95, 1787, 580,
+ /* 1060 */ 1789, 1790, 576, 1332, 571, 526, 1604, 1864, 41, 485,
+ /* 1070 */ 1316, 330, 1860, 1943, 526, 1267, 522, 53, 509, 68,
+ /* 1080 */ 67, 381, 1898, 1804, 171, 524, 221, 203, 526, 1756,
+ /* 1090 */ 202, 578, 205, 1604, 207, 204, 1756, 206, 577, 525,
+ /* 1100 */ 301, 1509, 1604, 369, 1894, 367, 363, 359, 356, 353,
+ /* 1110 */ 1270, 554, 131, 526, 1786, 1212, 1604, 1269, 566, 567,
+ /* 1120 */ 526, 1818, 134, 488, 261, 94, 1787, 580, 1789, 1790,
+ /* 1130 */ 576, 346, 571, 225, 135, 1864, 51, 550, 666, 306,
+ /* 1140 */ 1860, 1604, 1804, 562, 167, 236, 51, 323, 1604, 41,
+ /* 1150 */ 578, 1930, 267, 90, 1786, 1756, 617, 577, 41, 519,
+ /* 1160 */ 1777, 11, 10, 87, 164, 249, 156, 3, 1927, 229,
+ /* 1170 */ 254, 656, 652, 648, 644, 265, 584, 1276, 1066, 1271,
+ /* 1180 */ 1818, 1111, 1804, 1418, 294, 1787, 580, 1789, 1790, 576,
+ /* 1190 */ 578, 571, 239, 1367, 1786, 1756, 1323, 577, 1459, 1460,
+ /* 1200 */ 1279, 1281, 257, 1779, 259, 271, 134, 92, 135, 5,
+ /* 1210 */ 230, 1049, 569, 1330, 1331, 1333, 1334, 1335, 1336, 559,
+ /* 1220 */ 1818, 360, 1804, 1139, 95, 1787, 580, 1789, 1790, 576,
+ /* 1230 */ 578, 571, 268, 355, 1864, 1756, 119, 577, 330, 1860,
+ /* 1240 */ 1943, 134, 549, 523, 1050, 313, 1228, 1273, 174, 1921,
+ /* 1250 */ 385, 1351, 1284, 1143, 1272, 1150, 406, 413, 1697, 421,
+ /* 1260 */ 1818, 420, 422, 1786, 95, 1787, 580, 1789, 1790, 576,
+ /* 1270 */ 127, 571, 426, 428, 1864, 219, 430, 1290, 330, 1860,
+ /* 1280 */ 1943, 431, 439, 1148, 1292, 442, 183, 443, 138, 1883,
+ /* 1290 */ 554, 1804, 1291, 1235, 185, 212, 444, 1293, 188, 578,
+ /* 1300 */ 445, 190, 447, 72, 1756, 73, 577, 451, 125, 194,
+ /* 1310 */ 470, 472, 1594, 198, 118, 1590, 304, 1786, 200, 554,
+ /* 1320 */ 140, 269, 141, 250, 1872, 548, 1592, 547, 1588, 1818,
+ /* 1330 */ 1930, 142, 143, 285, 1787, 580, 1789, 1790, 576, 211,
+ /* 1340 */ 571, 500, 1736, 164, 214, 1804, 507, 1927, 504, 511,
+ /* 1350 */ 218, 322, 534, 578, 514, 520, 501, 1735, 1756, 1930,
+ /* 1360 */ 577, 132, 1707, 517, 324, 1289, 81, 1786, 521, 133,
+ /* 1370 */ 270, 83, 166, 554, 537, 1605, 1927, 530, 1905, 234,
+ /* 1380 */ 1895, 238, 6, 1818, 1786, 532, 533, 285, 1787, 580,
+ /* 1390 */ 1789, 1790, 576, 329, 571, 1804, 546, 531, 540, 529,
+ /* 1400 */ 528, 248, 1288, 578, 1393, 126, 563, 560, 1756, 48,
+ /* 1410 */ 577, 1880, 1804, 1930, 1904, 85, 1648, 331, 1577, 659,
+ /* 1420 */ 578, 582, 264, 660, 243, 1756, 164, 577, 153, 1886,
+ /* 1430 */ 1927, 247, 245, 1818, 1786, 246, 253, 96, 1787, 580,
+ /* 1440 */ 1789, 1790, 576, 1845, 571, 273, 662, 1864, 299, 275,
+ /* 1450 */ 1818, 565, 1860, 256, 149, 1787, 580, 1789, 1790, 576,
+ /* 1460 */ 1786, 571, 1804, 52, 1946, 1926, 557, 286, 296, 258,
+ /* 1470 */ 578, 564, 295, 1750, 277, 1756, 1749, 577, 65, 1748,
+ /* 1480 */ 1747, 66, 1744, 357, 358, 1253, 1254, 170, 1804, 362,
+ /* 1490 */ 1742, 364, 365, 527, 366, 1741, 578, 368, 555, 1944,
+ /* 1500 */ 1818, 1756, 1740, 577, 96, 1787, 580, 1789, 1790, 576,
+ /* 1510 */ 1786, 571, 370, 1739, 1864, 372, 1738, 1230, 374, 1861,
+ /* 1520 */ 1231, 1718, 1786, 379, 380, 1716, 1818, 1717, 1715, 1690,
+ /* 1530 */ 294, 1787, 580, 1789, 1790, 576, 1786, 571, 1804, 1689,
+ /* 1540 */ 1200, 129, 1688, 1687, 69, 1686, 578, 395, 1681, 396,
+ /* 1550 */ 1804, 1756, 1685, 577, 1684, 1683, 1682, 398, 578, 1680,
+ /* 1560 */ 1679, 1678, 1677, 1756, 1804, 577, 1676, 1675, 1674, 1673,
+ /* 1570 */ 1672, 1671, 575, 1670, 1669, 1668, 1818, 1756, 1667, 577,
+ /* 1580 */ 289, 1787, 580, 1789, 1790, 576, 130, 571, 1818, 1786,
+ /* 1590 */ 1666, 1665, 149, 1787, 580, 1789, 1790, 576, 1664, 571,
+ /* 1600 */ 1663, 1662, 1818, 1202, 1660, 1659, 293, 1787, 580, 1789,
+ /* 1610 */ 1790, 576, 1661, 571, 1658, 1837, 1657, 1804, 545, 1531,
+ /* 1620 */ 178, 1530, 338, 120, 181, 578, 196, 1528, 179, 1496,
+ /* 1630 */ 1756, 157, 577, 435, 1012, 437, 1011, 1945, 1495, 182,
+ /* 1640 */ 152, 121, 1786, 452, 453, 467, 463, 459, 455, 195,
+ /* 1650 */ 1731, 1725, 1714, 189, 1786, 1818, 187, 1713, 1699, 294,
+ /* 1660 */ 1787, 580, 1789, 1790, 576, 1583, 571, 1527, 1786, 1042,
+ /* 1670 */ 1804, 1525, 454, 1523, 456, 340, 458, 457, 578, 1521,
+ /* 1680 */ 460, 75, 1804, 1756, 193, 577, 462, 461, 1519, 464,
+ /* 1690 */ 578, 465, 466, 1508, 1507, 1756, 1804, 577, 1492, 1585,
+ /* 1700 */ 1153, 1154, 197, 1584, 578, 1079, 1074, 50, 1818, 1756,
+ /* 1710 */ 1517, 577, 294, 1787, 580, 1789, 1790, 576, 631, 571,
+ /* 1720 */ 1818, 1076, 1786, 633, 279, 1787, 580, 1789, 1790, 576,
+ /* 1730 */ 1075, 571, 1512, 318, 1818, 319, 1786, 1510, 280, 1787,
+ /* 1740 */ 580, 1789, 1790, 576, 320, 571, 192, 186, 1786, 191,
+ /* 1750 */ 1804, 486, 489, 446, 1491, 491, 1490, 1489, 578, 493,
+ /* 1760 */ 495, 97, 1730, 1756, 1804, 577, 1237, 56, 1724, 184,
+ /* 1770 */ 502, 1712, 578, 1710, 508, 503, 1804, 1756, 215, 577,
+ /* 1780 */ 1711, 1709, 321, 1708, 578, 15, 144, 220, 1818, 1756,
+ /* 1790 */ 1245, 577, 281, 1787, 580, 1789, 1790, 576, 1706, 571,
+ /* 1800 */ 1698, 226, 1818, 518, 79, 1786, 288, 1787, 580, 1789,
+ /* 1810 */ 1790, 576, 228, 571, 1818, 1786, 515, 80, 290, 1787,
+ /* 1820 */ 580, 1789, 1790, 576, 82, 571, 87, 41, 231, 23,
+ /* 1830 */ 47, 1786, 1433, 1804, 233, 241, 235, 1415, 237, 242,
+ /* 1840 */ 1417, 578, 16, 1804, 25, 1777, 1756, 151, 577, 240,
+ /* 1850 */ 24, 578, 46, 1410, 86, 1786, 1756, 17, 577, 1804,
+ /* 1860 */ 1390, 251, 1389, 1776, 154, 1450, 45, 578, 18, 1439,
+ /* 1870 */ 1445, 1818, 1756, 13, 577, 282, 1787, 580, 1789, 1790,
+ /* 1880 */ 576, 1818, 571, 1804, 1444, 291, 1787, 580, 1789, 1790,
+ /* 1890 */ 576, 578, 571, 332, 1449, 1448, 1756, 1818, 577, 333,
+ /* 1900 */ 10, 283, 1787, 580, 1789, 1790, 576, 1277, 571, 1352,
+ /* 1910 */ 19, 1786, 1821, 1307, 1327, 570, 155, 1325, 31, 581,
+ /* 1920 */ 1324, 1818, 12, 20, 168, 292, 1787, 580, 1789, 1790,
+ /* 1930 */ 576, 1786, 571, 21, 583, 1140, 341, 585, 579, 1804,
+ /* 1940 */ 1137, 587, 588, 590, 1134, 591, 593, 578, 596, 1132,
+ /* 1950 */ 594, 1786, 1756, 1128, 577, 1126, 1131, 597, 1117, 1804,
+ /* 1960 */ 1130, 88, 1149, 603, 1129, 89, 62, 578, 262, 1145,
+ /* 1970 */ 612, 1786, 1756, 1071, 577, 1070, 1040, 1818, 1069, 1804,
+ /* 1980 */ 1067, 284, 1787, 580, 1789, 1790, 576, 578, 571, 1065,
+ /* 1990 */ 1064, 1786, 1756, 1063, 577, 263, 1086, 1818, 1061, 1804,
+ /* 2000 */ 1060, 297, 1787, 580, 1789, 1790, 576, 578, 571, 621,
+ /* 2010 */ 1059, 1058, 1756, 1057, 577, 1056, 1055, 1818, 1083, 1804,
+ /* 2020 */ 1081, 298, 1787, 580, 1789, 1790, 576, 578, 571, 1052,
+ /* 2030 */ 1051, 1786, 1756, 1048, 577, 1047, 1046, 1818, 1045, 1524,
+ /* 2040 */ 641, 1798, 1787, 580, 1789, 1790, 576, 1786, 571, 642,
+ /* 2050 */ 643, 1522, 645, 646, 647, 1520, 649, 1818, 651, 1804,
+ /* 2060 */ 650, 1797, 1787, 580, 1789, 1790, 576, 578, 571, 1518,
+ /* 2070 */ 653, 654, 1756, 655, 577, 1804, 1506, 657, 1002, 1488,
+ /* 2080 */ 266, 661, 664, 578, 1263, 274, 665, 1463, 1756, 1463,
+ /* 2090 */ 577, 1463, 1463, 1463, 1463, 1463, 1463, 1818, 1786, 1463,
+ /* 2100 */ 1463, 1796, 1787, 580, 1789, 1790, 576, 1463, 571, 1463,
+ /* 2110 */ 1463, 1463, 1463, 1818, 1786, 1463, 1463, 310, 1787, 580,
+ /* 2120 */ 1789, 1790, 576, 1463, 571, 1463, 1804, 1463, 1463, 1463,
+ /* 2130 */ 1463, 1463, 1463, 1463, 578, 1463, 1463, 1463, 1463, 1756,
+ /* 2140 */ 1463, 577, 1804, 1463, 1463, 1463, 1463, 1463, 1463, 1463,
+ /* 2150 */ 578, 1463, 1463, 1463, 1463, 1756, 1463, 577, 1463, 1463,
+ /* 2160 */ 1463, 1463, 1463, 1463, 1818, 1786, 1463, 1463, 309, 1787,
+ /* 2170 */ 580, 1789, 1790, 576, 1463, 571, 1463, 1463, 1463, 1463,
+ /* 2180 */ 1818, 1786, 1463, 1463, 311, 1787, 580, 1789, 1790, 576,
+ /* 2190 */ 1463, 571, 1463, 1804, 1463, 1463, 1463, 1463, 1463, 1463,
+ /* 2200 */ 1463, 578, 1463, 1463, 1463, 1463, 1756, 1463, 577, 1804,
+ /* 2210 */ 1463, 1463, 1463, 1463, 1463, 1463, 1463, 578, 1463, 1463,
+ /* 2220 */ 1463, 1463, 1756, 1463, 577, 1463, 1463, 1463, 1463, 1463,
+ /* 2230 */ 1463, 1818, 1463, 1463, 1463, 308, 1787, 580, 1789, 1790,
+ /* 2240 */ 576, 1463, 571, 1463, 1463, 1463, 1463, 1818, 1463, 1463,
+ /* 2250 */ 1463, 287, 1787, 580, 1789, 1790, 576, 1463, 571,
};
static const YYCODETYPE yy_lookahead[] = {
- /* 0 */ 316, 390, 391, 316, 316, 312, 316, 314, 315, 1,
- /* 10 */ 2, 327, 12, 13, 327, 350, 351, 327, 334, 364,
- /* 20 */ 20, 0, 22, 4, 334, 20, 20, 22, 344, 308,
- /* 30 */ 338, 344, 344, 33, 344, 35, 312, 20, 314, 315,
- /* 40 */ 35, 349, 21, 338, 20, 24, 25, 26, 27, 28,
- /* 50 */ 29, 30, 31, 32, 349, 50, 56, 336, 321, 4,
- /* 60 */ 405, 61, 325, 44, 45, 344, 374, 375, 68, 60,
- /* 70 */ 349, 383, 351, 418, 12, 13, 14, 422, 386, 374,
- /* 80 */ 375, 376, 20, 0, 22, 397, 398, 399, 400, 89,
- /* 90 */ 402, 386, 336, 322, 323, 33, 375, 35, 90, 343,
- /* 100 */ 379, 380, 381, 382, 383, 384, 21, 386, 352, 347,
- /* 110 */ 389, 111, 350, 351, 393, 394, 395, 351, 56, 34,
- /* 120 */ 405, 36, 20, 61, 358, 125, 126, 361, 407, 20,
- /* 130 */ 68, 125, 126, 418, 8, 9, 415, 422, 12, 13,
- /* 140 */ 14, 15, 16, 307, 89, 309, 63, 64, 65, 66,
+ /* 0 */ 312, 404, 314, 315, 337, 312, 316, 314, 315, 351,
+ /* 10 */ 389, 390, 12, 13, 417, 328, 358, 327, 421, 361,
+ /* 20 */ 20, 0, 22, 336, 334, 12, 13, 14, 15, 16,
+ /* 30 */ 308, 20, 345, 33, 344, 35, 347, 20, 20, 350,
+ /* 40 */ 351, 364, 21, 338, 316, 24, 25, 26, 27, 28,
+ /* 50 */ 29, 30, 31, 32, 349, 327, 56, 313, 336, 4,
+ /* 60 */ 316, 61, 334, 14, 15, 16, 344, 307, 68, 309,
+ /* 70 */ 60, 349, 344, 351, 12, 13, 14, 338, 373, 374,
+ /* 80 */ 375, 404, 20, 0, 22, 336, 56, 20, 349, 89,
+ /* 90 */ 385, 4, 336, 344, 417, 33, 374, 35, 421, 343,
+ /* 100 */ 378, 379, 380, 381, 382, 383, 89, 385, 352, 335,
+ /* 110 */ 388, 111, 373, 374, 392, 393, 394, 351, 56, 89,
+ /* 120 */ 404, 91, 348, 61, 385, 125, 126, 361, 406, 380,
+ /* 130 */ 68, 44, 45, 417, 8, 9, 414, 421, 12, 13,
+ /* 140 */ 14, 15, 16, 20, 89, 89, 63, 64, 65, 66,
/* 150 */ 67, 89, 69, 70, 71, 72, 73, 74, 75, 76,
/* 160 */ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
/* 170 */ 170, 21, 172, 111, 24, 25, 26, 27, 28, 29,
- /* 180 */ 30, 31, 32, 336, 14, 15, 16, 125, 126, 120,
- /* 190 */ 121, 344, 316, 193, 194, 60, 196, 197, 198, 199,
+ /* 180 */ 30, 31, 32, 313, 338, 20, 316, 125, 126, 120,
+ /* 190 */ 121, 1, 2, 193, 194, 349, 196, 197, 198, 199,
/* 200 */ 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
- /* 210 */ 210, 211, 212, 213, 0, 20, 90, 8, 9, 64,
- /* 220 */ 65, 12, 13, 14, 15, 16, 71, 227, 381, 353,
- /* 230 */ 305, 120, 170, 318, 172, 22, 81, 82, 24, 25,
- /* 240 */ 26, 27, 28, 29, 30, 31, 32, 178, 35, 20,
- /* 250 */ 181, 22, 43, 56, 339, 193, 194, 308, 196, 197,
+ /* 210 */ 210, 211, 212, 213, 0, 21, 90, 8, 9, 373,
+ /* 220 */ 374, 12, 13, 14, 15, 16, 316, 227, 34, 321,
+ /* 230 */ 36, 385, 170, 325, 172, 22, 121, 327, 24, 25,
+ /* 240 */ 26, 27, 28, 29, 30, 31, 32, 178, 35, 89,
+ /* 250 */ 181, 360, 43, 362, 344, 193, 194, 227, 196, 197,
/* 260 */ 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
- /* 270 */ 208, 209, 210, 211, 212, 213, 12, 13, 308, 50,
- /* 280 */ 155, 68, 227, 316, 20, 88, 22, 308, 91, 364,
- /* 290 */ 179, 180, 0, 308, 327, 121, 364, 33, 349, 35,
+ /* 270 */ 208, 209, 210, 211, 212, 213, 12, 13, 350, 351,
+ /* 280 */ 90, 68, 227, 227, 20, 20, 22, 60, 20, 89,
+ /* 290 */ 125, 126, 177, 178, 308, 308, 181, 33, 193, 35,
/* 300 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
- /* 310 */ 112, 344, 114, 115, 116, 117, 118, 119, 405, 349,
- /* 320 */ 56, 336, 0, 68, 111, 61, 336, 405, 349, 344,
- /* 330 */ 405, 418, 68, 343, 349, 422, 351, 405, 12, 13,
- /* 340 */ 418, 4, 352, 418, 422, 20, 20, 422, 22, 316,
- /* 350 */ 418, 177, 178, 89, 422, 181, 19, 232, 233, 33,
- /* 360 */ 375, 35, 344, 335, 379, 380, 381, 382, 383, 384,
- /* 370 */ 33, 386, 89, 355, 389, 111, 348, 344, 393, 394,
- /* 380 */ 395, 20, 56, 170, 47, 172, 77, 100, 51, 125,
- /* 390 */ 126, 8, 9, 56, 68, 12, 13, 14, 15, 16,
- /* 400 */ 415, 322, 323, 12, 13, 14, 193, 194, 308, 318,
- /* 410 */ 68, 20, 308, 22, 89, 89, 383, 12, 13, 14,
- /* 420 */ 15, 16, 331, 101, 33, 88, 35, 337, 91, 89,
- /* 430 */ 339, 398, 399, 400, 170, 402, 172, 111, 129, 130,
- /* 440 */ 336, 364, 120, 121, 122, 123, 124, 56, 344, 349,
- /* 450 */ 89, 125, 126, 349, 37, 351, 308, 193, 194, 68,
+ /* 310 */ 112, 328, 114, 115, 116, 117, 118, 119, 20, 336,
+ /* 320 */ 56, 0, 336, 56, 111, 61, 322, 323, 345, 169,
+ /* 330 */ 344, 171, 68, 336, 404, 349, 349, 351, 12, 13,
+ /* 340 */ 343, 236, 237, 238, 239, 240, 20, 417, 22, 352,
+ /* 350 */ 0, 421, 318, 89, 89, 88, 336, 89, 91, 33,
+ /* 360 */ 374, 35, 68, 343, 378, 379, 380, 381, 382, 383,
+ /* 370 */ 100, 385, 352, 339, 388, 111, 328, 337, 392, 393,
+ /* 380 */ 394, 20, 56, 170, 336, 172, 20, 227, 22, 125,
+ /* 390 */ 126, 8, 9, 345, 68, 12, 13, 14, 15, 16,
+ /* 400 */ 414, 404, 316, 12, 13, 14, 193, 194, 308, 308,
+ /* 410 */ 101, 20, 308, 22, 417, 89, 50, 14, 421, 322,
+ /* 420 */ 323, 35, 101, 20, 33, 68, 35, 227, 316, 120,
+ /* 430 */ 121, 122, 123, 124, 170, 344, 172, 111, 308, 353,
+ /* 440 */ 336, 120, 121, 122, 123, 124, 355, 56, 344, 349,
+ /* 450 */ 349, 125, 126, 349, 68, 351, 344, 193, 194, 68,
/* 460 */ 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
- /* 470 */ 206, 207, 208, 209, 210, 211, 212, 213, 89, 375,
- /* 480 */ 89, 320, 405, 379, 380, 381, 382, 383, 384, 385,
- /* 490 */ 386, 387, 388, 20, 333, 418, 170, 349, 172, 422,
- /* 500 */ 8, 9, 111, 342, 12, 13, 14, 15, 16, 92,
- /* 510 */ 227, 94, 95, 308, 97, 364, 125, 126, 101, 193,
- /* 520 */ 194, 20, 196, 197, 198, 199, 200, 201, 202, 203,
+ /* 470 */ 206, 207, 208, 209, 210, 211, 212, 213, 374, 349,
+ /* 480 */ 89, 337, 378, 379, 380, 381, 382, 383, 384, 385,
+ /* 490 */ 386, 387, 227, 320, 382, 227, 170, 120, 172, 8,
+ /* 500 */ 9, 0, 111, 12, 13, 14, 15, 16, 396, 397,
+ /* 510 */ 398, 399, 337, 401, 308, 342, 125, 126, 157, 193,
+ /* 520 */ 194, 0, 196, 197, 198, 199, 200, 201, 202, 203,
/* 530 */ 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
- /* 540 */ 123, 44, 45, 8, 9, 162, 152, 12, 13, 14,
- /* 550 */ 15, 16, 227, 227, 349, 316, 405, 337, 169, 336,
- /* 560 */ 171, 170, 89, 172, 2, 0, 327, 227, 345, 418,
- /* 570 */ 8, 9, 56, 422, 12, 13, 14, 15, 16, 56,
- /* 580 */ 308, 308, 90, 344, 193, 194, 337, 196, 197, 198,
+ /* 540 */ 360, 316, 362, 8, 9, 162, 318, 12, 13, 14,
+ /* 550 */ 15, 16, 327, 227, 37, 349, 179, 180, 324, 331,
+ /* 560 */ 326, 170, 376, 172, 2, 64, 65, 339, 305, 344,
+ /* 570 */ 8, 9, 71, 0, 12, 13, 14, 15, 16, 337,
+ /* 580 */ 308, 90, 81, 82, 193, 194, 400, 196, 197, 198,
/* 590 */ 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
- /* 600 */ 209, 210, 211, 212, 213, 12, 13, 91, 214, 336,
- /* 610 */ 364, 377, 89, 20, 91, 22, 227, 344, 224, 308,
- /* 620 */ 368, 349, 349, 165, 351, 90, 33, 2, 35, 64,
- /* 630 */ 65, 308, 249, 8, 9, 401, 71, 12, 13, 14,
- /* 640 */ 15, 16, 184, 185, 14, 337, 81, 82, 375, 56,
- /* 650 */ 20, 405, 379, 380, 381, 382, 383, 384, 157, 386,
- /* 660 */ 349, 68, 389, 351, 418, 308, 393, 394, 422, 35,
- /* 670 */ 8, 9, 349, 361, 12, 13, 14, 15, 16, 19,
- /* 680 */ 8, 9, 89, 316, 12, 13, 14, 15, 16, 308,
- /* 690 */ 308, 8, 9, 33, 327, 12, 13, 14, 15, 16,
- /* 700 */ 227, 360, 68, 362, 111, 313, 349, 47, 316, 344,
- /* 710 */ 337, 344, 52, 53, 54, 55, 56, 0, 125, 126,
- /* 720 */ 355, 8, 9, 61, 337, 12, 13, 14, 15, 16,
- /* 730 */ 349, 349, 12, 13, 316, 337, 316, 18, 308, 20,
- /* 740 */ 20, 316, 22, 316, 61, 327, 27, 327, 88, 30,
- /* 750 */ 227, 91, 90, 33, 327, 35, 313, 0, 320, 316,
- /* 760 */ 98, 14, 344, 170, 344, 172, 47, 20, 49, 344,
- /* 770 */ 51, 344, 308, 360, 338, 362, 56, 225, 226, 349,
- /* 780 */ 342, 98, 42, 43, 124, 349, 193, 194, 68, 196,
+ /* 600 */ 209, 210, 211, 212, 213, 12, 13, 101, 336, 92,
+ /* 610 */ 336, 94, 95, 20, 97, 22, 344, 152, 101, 345,
+ /* 620 */ 316, 349, 101, 351, 2, 90, 33, 364, 35, 123,
+ /* 630 */ 8, 9, 249, 60, 12, 13, 14, 15, 16, 155,
+ /* 640 */ 123, 120, 121, 122, 123, 124, 374, 344, 344, 56,
+ /* 650 */ 378, 379, 380, 381, 382, 383, 337, 385, 355, 320,
+ /* 660 */ 388, 68, 316, 346, 392, 393, 349, 404, 364, 364,
+ /* 670 */ 8, 9, 333, 327, 12, 13, 14, 15, 16, 214,
+ /* 680 */ 417, 342, 89, 308, 421, 20, 382, 22, 39, 224,
+ /* 690 */ 344, 8, 9, 308, 325, 12, 13, 14, 15, 16,
+ /* 700 */ 35, 397, 398, 399, 111, 401, 8, 9, 404, 404,
+ /* 710 */ 12, 13, 14, 15, 16, 50, 232, 233, 125, 126,
+ /* 720 */ 316, 417, 417, 61, 349, 421, 421, 43, 4, 14,
+ /* 730 */ 316, 327, 12, 13, 349, 20, 308, 18, 376, 20,
+ /* 740 */ 20, 327, 22, 19, 61, 316, 27, 337, 344, 30,
+ /* 750 */ 316, 316, 90, 33, 309, 35, 327, 33, 344, 3,
+ /* 760 */ 98, 327, 400, 170, 165, 172, 47, 308, 49, 308,
+ /* 770 */ 51, 47, 424, 344, 90, 51, 56, 349, 344, 344,
+ /* 780 */ 56, 98, 308, 184, 185, 77, 193, 194, 68, 196,
/* 790 */ 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
- /* 800 */ 207, 208, 209, 210, 211, 212, 213, 88, 383, 89,
- /* 810 */ 374, 375, 376, 349, 152, 39, 156, 60, 101, 100,
- /* 820 */ 89, 316, 386, 398, 399, 400, 336, 402, 193, 157,
- /* 830 */ 99, 111, 327, 343, 174, 152, 176, 120, 121, 122,
- /* 840 */ 123, 124, 352, 309, 377, 125, 126, 128, 308, 344,
+ /* 800 */ 207, 208, 209, 210, 211, 212, 213, 88, 349, 89,
+ /* 810 */ 349, 4, 88, 316, 152, 91, 376, 382, 368, 100,
+ /* 820 */ 20, 8, 9, 349, 327, 12, 13, 14, 15, 16,
+ /* 830 */ 308, 111, 397, 398, 399, 152, 401, 129, 130, 0,
+ /* 840 */ 400, 344, 14, 44, 45, 125, 126, 128, 20, 0,
/* 850 */ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
- /* 860 */ 141, 142, 143, 144, 145, 146, 147, 148, 401, 150,
- /* 870 */ 151, 236, 237, 238, 239, 240, 214, 215, 216, 217,
- /* 880 */ 218, 219, 220, 221, 222, 223, 224, 14, 3, 349,
- /* 890 */ 170, 346, 172, 20, 349, 405, 4, 214, 215, 216,
- /* 900 */ 217, 218, 219, 220, 221, 222, 223, 224, 418, 0,
- /* 910 */ 308, 308, 422, 193, 194, 308, 196, 197, 198, 199,
+ /* 860 */ 141, 142, 143, 144, 145, 146, 147, 148, 316, 150,
+ /* 870 */ 151, 349, 336, 13, 308, 226, 214, 215, 216, 217,
+ /* 880 */ 218, 219, 220, 221, 222, 223, 224, 48, 352, 317,
+ /* 890 */ 170, 346, 172, 20, 349, 35, 344, 214, 215, 216,
+ /* 900 */ 217, 218, 219, 220, 221, 222, 223, 224, 329, 60,
+ /* 910 */ 415, 332, 197, 193, 194, 349, 196, 197, 198, 199,
/* 920 */ 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
- /* 930 */ 210, 211, 212, 213, 324, 18, 326, 308, 336, 316,
- /* 940 */ 23, 101, 346, 425, 197, 349, 344, 377, 308, 308,
- /* 950 */ 327, 349, 349, 351, 37, 38, 349, 101, 41, 20,
- /* 960 */ 120, 121, 122, 123, 124, 336, 364, 344, 20, 60,
- /* 970 */ 325, 401, 43, 344, 57, 58, 59, 375, 349, 123,
- /* 980 */ 351, 379, 380, 381, 382, 383, 384, 416, 386, 349,
- /* 990 */ 349, 389, 338, 364, 317, 393, 394, 329, 157, 158,
- /* 1000 */ 332, 336, 226, 349, 375, 316, 89, 405, 379, 380,
- /* 1010 */ 381, 382, 383, 384, 316, 386, 327, 352, 389, 90,
- /* 1020 */ 418, 0, 393, 394, 422, 327, 0, 93, 374, 375,
- /* 1030 */ 96, 12, 13, 344, 405, 125, 126, 43, 316, 316,
- /* 1040 */ 386, 22, 344, 35, 127, 316, 316, 418, 22, 327,
- /* 1050 */ 327, 422, 33, 43, 35, 328, 327, 327, 316, 93,
- /* 1060 */ 316, 308, 96, 336, 371, 316, 344, 344, 47, 327,
- /* 1070 */ 197, 327, 345, 344, 344, 56, 327, 43, 43, 162,
- /* 1080 */ 163, 164, 328, 316, 167, 35, 344, 68, 344, 336,
- /* 1090 */ 336, 43, 412, 344, 327, 93, 157, 344, 96, 345,
- /* 1100 */ 183, 61, 349, 186, 351, 188, 189, 190, 191, 192,
- /* 1110 */ 328, 344, 46, 93, 43, 43, 96, 336, 336, 0,
- /* 1120 */ 228, 0, 43, 308, 90, 90, 43, 345, 375, 244,
- /* 1130 */ 111, 43, 379, 380, 381, 382, 383, 384, 90, 386,
- /* 1140 */ 43, 22, 389, 22, 227, 197, 393, 394, 395, 1,
- /* 1150 */ 2, 336, 13, 43, 13, 89, 317, 404, 43, 344,
- /* 1160 */ 43, 90, 90, 315, 349, 348, 351, 43, 43, 90,
- /* 1170 */ 43, 378, 403, 90, 35, 308, 35, 419, 90, 396,
- /* 1180 */ 172, 419, 419, 406, 229, 373, 372, 90, 35, 170,
- /* 1190 */ 375, 172, 47, 168, 379, 380, 381, 382, 383, 384,
- /* 1200 */ 90, 386, 366, 336, 389, 90, 0, 90, 393, 394,
- /* 1210 */ 395, 344, 193, 194, 90, 90, 349, 90, 351, 404,
- /* 1220 */ 42, 68, 172, 20, 205, 206, 207, 208, 209, 210,
- /* 1230 */ 211, 308, 356, 193, 316, 316, 356, 152, 354, 20,
- /* 1240 */ 246, 308, 375, 354, 316, 310, 379, 380, 381, 382,
- /* 1250 */ 383, 384, 316, 386, 48, 310, 389, 316, 248, 336,
- /* 1260 */ 393, 394, 395, 20, 370, 351, 320, 344, 20, 336,
- /* 1270 */ 320, 404, 349, 20, 351, 363, 365, 344, 320, 363,
- /* 1280 */ 320, 320, 349, 320, 351, 316, 310, 364, 320, 336,
- /* 1290 */ 308, 310, 336, 336, 316, 336, 349, 364, 375, 369,
- /* 1300 */ 336, 336, 379, 380, 381, 382, 383, 384, 375, 386,
- /* 1310 */ 336, 336, 379, 380, 381, 382, 383, 384, 336, 386,
- /* 1320 */ 336, 336, 336, 318, 370, 175, 344, 318, 405, 316,
- /* 1330 */ 351, 349, 316, 351, 363, 318, 234, 349, 405, 359,
- /* 1340 */ 349, 418, 349, 154, 349, 422, 359, 349, 318, 357,
- /* 1350 */ 308, 418, 20, 349, 332, 422, 318, 375, 344, 359,
- /* 1360 */ 308, 379, 380, 381, 382, 383, 384, 378, 386, 235,
- /* 1370 */ 359, 389, 349, 411, 241, 393, 394, 349, 336, 161,
- /* 1380 */ 349, 411, 349, 243, 242, 413, 344, 414, 336, 230,
- /* 1390 */ 226, 349, 20, 351, 411, 344, 344, 373, 247, 245,
- /* 1400 */ 410, 349, 89, 351, 377, 409, 250, 408, 89, 308,
- /* 1410 */ 340, 349, 326, 318, 316, 36, 311, 375, 421, 310,
- /* 1420 */ 367, 379, 380, 381, 382, 383, 384, 375, 386, 426,
- /* 1430 */ 362, 379, 380, 381, 382, 383, 384, 336, 386, 421,
- /* 1440 */ 0, 389, 341, 330, 330, 344, 394, 392, 330, 420,
- /* 1450 */ 349, 319, 351, 421, 0, 306, 420, 420, 177, 0,
- /* 1460 */ 308, 0, 42, 0, 35, 423, 424, 187, 35, 35,
- /* 1470 */ 35, 187, 0, 35, 35, 187, 375, 0, 0, 187,
- /* 1480 */ 379, 380, 381, 382, 383, 384, 35, 386, 336, 0,
- /* 1490 */ 22, 0, 35, 341, 172, 170, 344, 0, 0, 166,
- /* 1500 */ 165, 349, 46, 351, 0, 0, 0, 42, 0, 0,
- /* 1510 */ 0, 149, 308, 0, 0, 0, 0, 0, 144, 35,
- /* 1520 */ 0, 144, 308, 42, 0, 0, 0, 375, 0, 0,
- /* 1530 */ 0, 379, 380, 381, 382, 383, 384, 0, 386, 308,
- /* 1540 */ 336, 0, 0, 0, 0, 0, 0, 0, 344, 0,
- /* 1550 */ 336, 0, 0, 349, 0, 351, 0, 0, 344, 0,
- /* 1560 */ 22, 0, 0, 349, 0, 351, 0, 336, 56, 0,
- /* 1570 */ 0, 0, 39, 42, 56, 344, 0, 43, 46, 375,
- /* 1580 */ 349, 14, 351, 379, 380, 381, 382, 383, 384, 375,
- /* 1590 */ 386, 161, 14, 379, 380, 381, 382, 383, 384, 308,
- /* 1600 */ 386, 46, 0, 40, 39, 0, 375, 0, 0, 0,
- /* 1610 */ 379, 380, 381, 382, 383, 384, 308, 386, 39, 388,
- /* 1620 */ 0, 417, 62, 0, 0, 35, 39, 336, 0, 47,
- /* 1630 */ 35, 47, 341, 39, 0, 344, 35, 39, 424, 47,
- /* 1640 */ 349, 0, 351, 47, 336, 35, 0, 0, 0, 341,
- /* 1650 */ 39, 0, 344, 35, 22, 0, 98, 349, 43, 351,
- /* 1660 */ 35, 35, 43, 0, 96, 35, 375, 22, 0, 0,
- /* 1670 */ 379, 380, 381, 382, 383, 384, 22, 386, 22, 22,
- /* 1680 */ 49, 0, 0, 375, 308, 35, 33, 379, 380, 381,
- /* 1690 */ 382, 383, 384, 35, 386, 0, 35, 22, 20, 0,
- /* 1700 */ 47, 35, 308, 0, 154, 52, 53, 54, 55, 56,
- /* 1710 */ 157, 22, 336, 173, 0, 0, 0, 0, 0, 90,
- /* 1720 */ 344, 35, 89, 0, 89, 349, 89, 351, 0, 157,
- /* 1730 */ 336, 157, 159, 39, 46, 155, 43, 99, 344, 153,
- /* 1740 */ 43, 88, 231, 349, 91, 351, 46, 43, 89, 43,
- /* 1750 */ 231, 375, 90, 89, 89, 379, 380, 381, 382, 383,
- /* 1760 */ 384, 308, 386, 90, 90, 182, 89, 46, 89, 375,
- /* 1770 */ 90, 46, 89, 379, 380, 381, 382, 383, 384, 89,
- /* 1780 */ 386, 90, 90, 43, 46, 89, 43, 46, 90, 336,
- /* 1790 */ 35, 90, 90, 35, 35, 35, 35, 344, 35, 2,
- /* 1800 */ 225, 22, 349, 90, 351, 193, 153, 154, 231, 156,
- /* 1810 */ 308, 43, 90, 160, 90, 46, 89, 46, 89, 89,
- /* 1820 */ 89, 89, 22, 89, 35, 90, 35, 90, 375, 176,
- /* 1830 */ 35, 308, 379, 380, 381, 382, 383, 384, 336, 386,
- /* 1840 */ 89, 89, 100, 90, 195, 35, 344, 90, 35, 35,
- /* 1850 */ 22, 349, 90, 351, 89, 89, 89, 113, 113, 336,
- /* 1860 */ 113, 113, 89, 89, 43, 101, 35, 344, 22, 89,
- /* 1870 */ 62, 35, 349, 61, 351, 35, 35, 375, 35, 35,
- /* 1880 */ 35, 379, 380, 381, 382, 383, 384, 35, 386, 308,
- /* 1890 */ 68, 87, 43, 35, 35, 22, 35, 22, 375, 308,
- /* 1900 */ 35, 35, 379, 380, 381, 382, 383, 384, 22, 386,
- /* 1910 */ 68, 35, 35, 35, 35, 35, 35, 336, 0, 35,
- /* 1920 */ 0, 47, 39, 35, 39, 344, 0, 336, 35, 47,
- /* 1930 */ 349, 39, 351, 0, 47, 344, 35, 39, 47, 0,
- /* 1940 */ 349, 35, 351, 0, 35, 22, 21, 427, 427, 22,
- /* 1950 */ 22, 308, 21, 427, 20, 427, 375, 427, 427, 427,
- /* 1960 */ 379, 380, 381, 382, 383, 384, 375, 386, 308, 427,
- /* 1970 */ 379, 380, 381, 382, 383, 384, 427, 386, 427, 336,
- /* 1980 */ 427, 427, 427, 427, 427, 427, 427, 344, 427, 427,
- /* 1990 */ 427, 427, 349, 427, 351, 427, 336, 427, 427, 427,
- /* 2000 */ 427, 427, 427, 427, 344, 427, 427, 427, 427, 349,
- /* 2010 */ 427, 351, 427, 427, 427, 427, 427, 308, 375, 427,
- /* 2020 */ 427, 427, 379, 380, 381, 382, 383, 384, 427, 386,
- /* 2030 */ 427, 427, 427, 427, 308, 375, 427, 427, 427, 379,
- /* 2040 */ 380, 381, 382, 383, 384, 336, 386, 427, 427, 427,
- /* 2050 */ 427, 427, 427, 344, 427, 427, 427, 427, 349, 427,
- /* 2060 */ 351, 427, 336, 427, 427, 427, 427, 427, 427, 427,
- /* 2070 */ 344, 427, 427, 427, 427, 349, 427, 351, 427, 427,
- /* 2080 */ 427, 427, 427, 308, 375, 427, 427, 427, 379, 380,
- /* 2090 */ 381, 382, 383, 384, 427, 386, 427, 427, 427, 427,
- /* 2100 */ 427, 375, 427, 427, 427, 379, 380, 381, 382, 383,
- /* 2110 */ 384, 336, 386, 427, 427, 427, 427, 427, 427, 344,
- /* 2120 */ 427, 427, 427, 427, 349, 427, 351, 427, 427, 427,
- /* 2130 */ 427, 427, 427, 427, 427, 427, 427, 308, 427, 427,
- /* 2140 */ 427, 427, 427, 427, 427, 427, 427, 308, 427, 427,
- /* 2150 */ 375, 427, 427, 427, 379, 380, 381, 382, 383, 384,
- /* 2160 */ 427, 386, 427, 427, 427, 336, 427, 427, 427, 427,
- /* 2170 */ 427, 427, 427, 344, 427, 336, 427, 427, 349, 427,
- /* 2180 */ 351, 427, 427, 344, 427, 427, 427, 427, 349, 427,
- /* 2190 */ 351, 427, 427, 427, 427, 427, 427, 427, 308, 427,
- /* 2200 */ 427, 427, 427, 427, 375, 427, 427, 427, 379, 380,
- /* 2210 */ 381, 382, 383, 384, 375, 386, 308, 427, 379, 380,
- /* 2220 */ 381, 382, 383, 384, 427, 386, 336, 427, 427, 427,
- /* 2230 */ 427, 427, 427, 427, 344, 427, 427, 427, 427, 349,
- /* 2240 */ 427, 351, 427, 427, 336, 427, 427, 427, 427, 427,
- /* 2250 */ 427, 427, 344, 427, 427, 427, 427, 349, 427, 351,
- /* 2260 */ 427, 427, 427, 427, 427, 375, 427, 427, 427, 379,
- /* 2270 */ 380, 381, 382, 383, 384, 308, 386, 427, 427, 427,
- /* 2280 */ 427, 427, 427, 375, 427, 427, 427, 379, 380, 381,
- /* 2290 */ 382, 383, 384, 427, 386, 427, 308, 427, 427, 427,
- /* 2300 */ 427, 427, 427, 336, 427, 427, 427, 427, 427, 427,
- /* 2310 */ 427, 344, 427, 427, 427, 427, 349, 427, 351, 427,
- /* 2320 */ 427, 427, 427, 427, 336, 427, 427, 427, 427, 427,
- /* 2330 */ 427, 427, 344, 427, 427, 427, 427, 349, 427, 351,
- /* 2340 */ 427, 427, 375, 427, 427, 427, 379, 380, 381, 382,
- /* 2350 */ 383, 384, 308, 386, 427, 427, 427, 427, 427, 427,
- /* 2360 */ 427, 427, 308, 375, 427, 427, 427, 379, 380, 381,
- /* 2370 */ 382, 383, 384, 427, 386, 427, 427, 427, 427, 427,
- /* 2380 */ 336, 427, 427, 427, 427, 427, 427, 427, 344, 427,
- /* 2390 */ 336, 427, 427, 349, 316, 351, 427, 427, 344, 427,
- /* 2400 */ 427, 427, 427, 349, 427, 351, 427, 427, 427, 427,
- /* 2410 */ 427, 427, 427, 427, 427, 427, 427, 427, 427, 375,
- /* 2420 */ 427, 427, 344, 379, 380, 381, 382, 383, 384, 375,
- /* 2430 */ 386, 427, 427, 379, 380, 381, 382, 383, 384, 427,
- /* 2440 */ 386, 316, 364, 427, 427, 427, 427, 427, 427, 427,
- /* 2450 */ 427, 427, 427, 427, 427, 427, 427, 427, 427, 427,
- /* 2460 */ 427, 383, 427, 427, 427, 427, 427, 427, 427, 344,
- /* 2470 */ 427, 427, 427, 427, 427, 427, 398, 399, 400, 427,
- /* 2480 */ 402, 427, 427, 405, 427, 427, 427, 427, 427, 364,
- /* 2490 */ 427, 427, 427, 427, 427, 427, 418, 427, 427, 427,
- /* 2500 */ 422, 427, 427, 427, 427, 427, 427, 427, 383, 427,
- /* 2510 */ 427, 427, 427, 427, 427, 427, 427, 427, 427, 427,
- /* 2520 */ 427, 427, 427, 398, 399, 400, 427, 402, 427, 427,
- /* 2530 */ 405, 427, 427, 427, 427, 427, 427, 427, 427, 427,
- /* 2540 */ 427, 427, 427, 418, 427, 427, 427, 422,
+ /* 930 */ 210, 211, 212, 213, 382, 18, 308, 308, 43, 364,
+ /* 940 */ 23, 364, 225, 226, 0, 64, 65, 0, 338, 397,
+ /* 950 */ 398, 399, 71, 401, 37, 38, 336, 157, 41, 349,
+ /* 960 */ 316, 316, 81, 82, 308, 336, 42, 43, 411, 22,
+ /* 970 */ 157, 327, 327, 344, 57, 58, 59, 349, 349, 404,
+ /* 980 */ 351, 404, 315, 373, 374, 375, 308, 308, 344, 344,
+ /* 990 */ 316, 47, 417, 364, 417, 385, 421, 56, 421, 364,
+ /* 1000 */ 244, 327, 308, 374, 308, 349, 89, 378, 379, 380,
+ /* 1010 */ 381, 382, 383, 316, 385, 336, 43, 388, 344, 12,
+ /* 1020 */ 13, 392, 393, 344, 327, 197, 316, 349, 349, 22,
+ /* 1030 */ 351, 93, 91, 404, 96, 228, 348, 327, 316, 404,
+ /* 1040 */ 33, 344, 35, 349, 127, 349, 417, 0, 308, 327,
+ /* 1050 */ 421, 317, 417, 374, 344, 308, 421, 378, 379, 380,
+ /* 1060 */ 381, 382, 383, 56, 385, 316, 344, 388, 43, 22,
+ /* 1070 */ 197, 392, 393, 394, 316, 68, 327, 157, 158, 162,
+ /* 1080 */ 163, 164, 403, 336, 167, 327, 43, 93, 316, 349,
+ /* 1090 */ 96, 344, 93, 344, 93, 96, 349, 96, 351, 327,
+ /* 1100 */ 183, 0, 344, 186, 377, 188, 189, 190, 191, 192,
+ /* 1110 */ 35, 364, 43, 316, 308, 90, 344, 35, 111, 61,
+ /* 1120 */ 316, 374, 43, 22, 327, 378, 379, 380, 381, 382,
+ /* 1130 */ 383, 327, 385, 90, 43, 388, 43, 402, 19, 392,
+ /* 1140 */ 393, 344, 336, 248, 227, 43, 43, 341, 344, 43,
+ /* 1150 */ 344, 404, 33, 89, 308, 349, 13, 351, 43, 90,
+ /* 1160 */ 46, 1, 2, 99, 417, 395, 47, 405, 421, 90,
+ /* 1170 */ 418, 52, 53, 54, 55, 56, 43, 170, 35, 172,
+ /* 1180 */ 374, 90, 336, 90, 378, 379, 380, 381, 382, 383,
+ /* 1190 */ 344, 385, 90, 90, 308, 349, 90, 351, 125, 126,
+ /* 1200 */ 193, 194, 418, 89, 418, 90, 43, 88, 43, 229,
+ /* 1210 */ 91, 35, 205, 206, 207, 208, 209, 210, 211, 246,
+ /* 1220 */ 374, 47, 336, 90, 378, 379, 380, 381, 382, 383,
+ /* 1230 */ 344, 385, 366, 372, 388, 349, 43, 351, 392, 393,
+ /* 1240 */ 394, 43, 316, 124, 68, 371, 168, 172, 42, 403,
+ /* 1250 */ 356, 193, 20, 90, 172, 90, 316, 356, 316, 152,
+ /* 1260 */ 374, 354, 354, 308, 378, 379, 380, 381, 382, 383,
+ /* 1270 */ 344, 385, 316, 316, 388, 156, 316, 20, 392, 393,
+ /* 1280 */ 394, 310, 310, 90, 20, 370, 320, 351, 90, 403,
+ /* 1290 */ 364, 336, 20, 174, 320, 176, 363, 20, 320, 344,
+ /* 1300 */ 365, 320, 363, 320, 349, 320, 351, 316, 382, 320,
+ /* 1310 */ 310, 336, 336, 336, 316, 336, 310, 308, 336, 364,
+ /* 1320 */ 336, 370, 336, 397, 398, 399, 336, 401, 336, 374,
+ /* 1330 */ 404, 336, 336, 378, 379, 380, 381, 382, 383, 318,
+ /* 1340 */ 385, 175, 349, 417, 318, 336, 316, 421, 351, 316,
+ /* 1350 */ 318, 363, 234, 344, 349, 154, 369, 349, 349, 404,
+ /* 1360 */ 351, 359, 349, 349, 349, 20, 318, 308, 357, 359,
+ /* 1370 */ 332, 318, 417, 364, 235, 344, 421, 349, 410, 359,
+ /* 1380 */ 377, 359, 241, 374, 308, 349, 349, 378, 379, 380,
+ /* 1390 */ 381, 382, 383, 349, 385, 336, 161, 243, 349, 242,
+ /* 1400 */ 230, 372, 20, 344, 226, 344, 247, 245, 349, 89,
+ /* 1410 */ 351, 376, 336, 404, 410, 89, 349, 250, 326, 36,
+ /* 1420 */ 344, 340, 318, 311, 412, 349, 417, 351, 410, 413,
+ /* 1430 */ 421, 407, 409, 374, 308, 408, 419, 378, 379, 380,
+ /* 1440 */ 381, 382, 383, 391, 385, 316, 310, 388, 362, 319,
+ /* 1450 */ 374, 392, 393, 419, 378, 379, 380, 381, 382, 383,
+ /* 1460 */ 308, 385, 336, 367, 425, 420, 420, 330, 330, 419,
+ /* 1470 */ 344, 420, 330, 0, 306, 349, 0, 351, 177, 0,
+ /* 1480 */ 0, 42, 0, 35, 187, 35, 35, 35, 336, 187,
+ /* 1490 */ 0, 35, 35, 341, 187, 0, 344, 187, 422, 423,
+ /* 1500 */ 374, 349, 0, 351, 378, 379, 380, 381, 382, 383,
+ /* 1510 */ 308, 385, 35, 0, 388, 22, 0, 170, 35, 393,
+ /* 1520 */ 172, 0, 308, 166, 165, 0, 374, 0, 0, 0,
+ /* 1530 */ 378, 379, 380, 381, 382, 383, 308, 385, 336, 0,
+ /* 1540 */ 46, 42, 0, 0, 149, 0, 344, 144, 0, 35,
+ /* 1550 */ 336, 349, 0, 351, 0, 0, 0, 144, 344, 0,
+ /* 1560 */ 0, 0, 0, 349, 336, 351, 0, 0, 0, 0,
+ /* 1570 */ 0, 0, 344, 0, 0, 0, 374, 349, 0, 351,
+ /* 1580 */ 378, 379, 380, 381, 382, 383, 42, 385, 374, 308,
+ /* 1590 */ 0, 0, 378, 379, 380, 381, 382, 383, 0, 385,
+ /* 1600 */ 0, 0, 374, 22, 0, 0, 378, 379, 380, 381,
+ /* 1610 */ 382, 383, 0, 385, 0, 387, 0, 336, 416, 0,
+ /* 1620 */ 56, 0, 341, 39, 42, 344, 33, 0, 56, 0,
+ /* 1630 */ 349, 43, 351, 46, 14, 46, 14, 423, 0, 40,
+ /* 1640 */ 47, 39, 308, 35, 47, 52, 53, 54, 55, 56,
+ /* 1650 */ 0, 0, 0, 161, 308, 374, 39, 0, 0, 378,
+ /* 1660 */ 379, 380, 381, 382, 383, 0, 385, 0, 308, 62,
+ /* 1670 */ 336, 0, 39, 0, 35, 341, 39, 47, 344, 0,
+ /* 1680 */ 35, 88, 336, 349, 91, 351, 39, 47, 0, 35,
+ /* 1690 */ 344, 47, 39, 0, 0, 349, 336, 351, 0, 0,
+ /* 1700 */ 22, 35, 96, 0, 344, 35, 22, 98, 374, 349,
+ /* 1710 */ 0, 351, 378, 379, 380, 381, 382, 383, 43, 385,
+ /* 1720 */ 374, 35, 308, 43, 378, 379, 380, 381, 382, 383,
+ /* 1730 */ 35, 385, 0, 22, 374, 22, 308, 0, 378, 379,
+ /* 1740 */ 380, 381, 382, 383, 22, 385, 153, 154, 308, 156,
+ /* 1750 */ 336, 49, 35, 160, 0, 35, 0, 0, 344, 35,
+ /* 1760 */ 22, 20, 0, 349, 336, 351, 35, 157, 0, 176,
+ /* 1770 */ 22, 0, 344, 0, 159, 157, 336, 349, 154, 351,
+ /* 1780 */ 0, 0, 157, 0, 344, 89, 173, 90, 374, 349,
+ /* 1790 */ 35, 351, 378, 379, 380, 381, 382, 383, 0, 385,
+ /* 1800 */ 0, 89, 374, 155, 89, 308, 378, 379, 380, 381,
+ /* 1810 */ 382, 383, 153, 385, 374, 308, 182, 39, 378, 379,
+ /* 1820 */ 380, 381, 382, 383, 89, 385, 99, 43, 46, 89,
+ /* 1830 */ 43, 308, 90, 336, 89, 43, 90, 90, 89, 46,
+ /* 1840 */ 90, 344, 231, 336, 43, 46, 349, 89, 351, 89,
+ /* 1850 */ 89, 344, 43, 90, 89, 308, 349, 231, 351, 336,
+ /* 1860 */ 90, 46, 90, 46, 46, 90, 225, 344, 43, 90,
+ /* 1870 */ 35, 374, 349, 231, 351, 378, 379, 380, 381, 382,
+ /* 1880 */ 383, 374, 385, 336, 35, 378, 379, 380, 381, 382,
+ /* 1890 */ 383, 344, 385, 35, 35, 35, 349, 374, 351, 35,
+ /* 1900 */ 2, 378, 379, 380, 381, 382, 383, 22, 385, 193,
+ /* 1910 */ 43, 308, 89, 22, 90, 89, 46, 90, 89, 100,
+ /* 1920 */ 90, 374, 89, 89, 46, 378, 379, 380, 381, 382,
+ /* 1930 */ 383, 308, 385, 89, 35, 90, 35, 89, 195, 336,
+ /* 1940 */ 90, 35, 89, 35, 90, 89, 35, 344, 35, 113,
+ /* 1950 */ 89, 308, 349, 90, 351, 90, 113, 89, 22, 336,
+ /* 1960 */ 113, 89, 35, 101, 113, 89, 89, 344, 43, 22,
+ /* 1970 */ 61, 308, 349, 35, 351, 35, 62, 374, 35, 336,
+ /* 1980 */ 35, 378, 379, 380, 381, 382, 383, 344, 385, 35,
+ /* 1990 */ 35, 308, 349, 35, 351, 43, 68, 374, 35, 336,
+ /* 2000 */ 35, 378, 379, 380, 381, 382, 383, 344, 385, 87,
+ /* 2010 */ 22, 35, 349, 22, 351, 35, 35, 374, 68, 336,
+ /* 2020 */ 35, 378, 379, 380, 381, 382, 383, 344, 385, 35,
+ /* 2030 */ 35, 308, 349, 35, 351, 35, 22, 374, 35, 0,
+ /* 2040 */ 35, 378, 379, 380, 381, 382, 383, 308, 385, 47,
+ /* 2050 */ 39, 0, 35, 47, 39, 0, 35, 374, 39, 336,
+ /* 2060 */ 47, 378, 379, 380, 381, 382, 383, 344, 385, 0,
+ /* 2070 */ 35, 47, 349, 39, 351, 336, 0, 35, 35, 0,
+ /* 2080 */ 22, 21, 21, 344, 22, 22, 20, 426, 349, 426,
+ /* 2090 */ 351, 426, 426, 426, 426, 426, 426, 374, 308, 426,
+ /* 2100 */ 426, 378, 379, 380, 381, 382, 383, 426, 385, 426,
+ /* 2110 */ 426, 426, 426, 374, 308, 426, 426, 378, 379, 380,
+ /* 2120 */ 381, 382, 383, 426, 385, 426, 336, 426, 426, 426,
+ /* 2130 */ 426, 426, 426, 426, 344, 426, 426, 426, 426, 349,
+ /* 2140 */ 426, 351, 336, 426, 426, 426, 426, 426, 426, 426,
+ /* 2150 */ 344, 426, 426, 426, 426, 349, 426, 351, 426, 426,
+ /* 2160 */ 426, 426, 426, 426, 374, 308, 426, 426, 378, 379,
+ /* 2170 */ 380, 381, 382, 383, 426, 385, 426, 426, 426, 426,
+ /* 2180 */ 374, 308, 426, 426, 378, 379, 380, 381, 382, 383,
+ /* 2190 */ 426, 385, 426, 336, 426, 426, 426, 426, 426, 426,
+ /* 2200 */ 426, 344, 426, 426, 426, 426, 349, 426, 351, 336,
+ /* 2210 */ 426, 426, 426, 426, 426, 426, 426, 344, 426, 426,
+ /* 2220 */ 426, 426, 349, 426, 351, 426, 426, 426, 426, 426,
+ /* 2230 */ 426, 374, 426, 426, 426, 378, 379, 380, 381, 382,
+ /* 2240 */ 383, 426, 385, 426, 426, 426, 426, 374, 426, 426,
+ /* 2250 */ 426, 378, 379, 380, 381, 382, 383, 426, 385, 426,
+ /* 2260 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2270 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2280 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2290 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2300 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2310 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2320 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2330 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2340 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2350 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2360 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2370 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2380 */ 426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
+ /* 2390 */ 426, 426,
};
#define YY_SHIFT_COUNT (666)
#define YY_SHIFT_MIN (0)
-#define YY_SHIFT_MAX (1943)
+#define YY_SHIFT_MAX (2079)
static const unsigned short int yy_shift_ofst[] = {
/* 0 */ 917, 0, 0, 62, 62, 264, 264, 264, 326, 326,
/* 10 */ 264, 264, 391, 593, 720, 593, 593, 593, 593, 593,
/* 20 */ 593, 593, 593, 593, 593, 593, 593, 593, 593, 593,
/* 30 */ 593, 593, 593, 593, 593, 593, 593, 593, 593, 593,
- /* 40 */ 593, 593, 325, 325, 361, 361, 361, 1019, 1019, 473,
- /* 50 */ 1019, 1019, 389, 523, 283, 340, 283, 17, 17, 19,
- /* 60 */ 19, 55, 6, 283, 283, 17, 17, 17, 17, 17,
- /* 70 */ 17, 17, 17, 17, 17, 9, 17, 17, 17, 24,
- /* 80 */ 17, 17, 102, 17, 17, 102, 109, 17, 102, 102,
- /* 90 */ 102, 17, 135, 719, 662, 683, 683, 150, 213, 213,
+ /* 40 */ 593, 593, 265, 265, 17, 17, 17, 1007, 1007, 268,
+ /* 50 */ 1007, 1007, 160, 30, 56, 200, 56, 11, 11, 87,
+ /* 60 */ 87, 55, 165, 56, 56, 11, 11, 11, 11, 11,
+ /* 70 */ 11, 11, 11, 11, 11, 10, 11, 11, 11, 18,
+ /* 80 */ 11, 11, 67, 11, 11, 67, 123, 11, 67, 67,
+ /* 90 */ 67, 11, 227, 719, 662, 683, 683, 150, 213, 213,
/* 100 */ 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
- /* 110 */ 213, 213, 213, 213, 213, 213, 213, 417, 155, 6,
- /* 120 */ 630, 630, 757, 634, 909, 501, 501, 501, 634, 195,
- /* 130 */ 195, 24, 292, 292, 102, 102, 255, 255, 287, 342,
- /* 140 */ 198, 198, 198, 198, 198, 198, 198, 660, 21, 383,
- /* 150 */ 565, 635, 5, 174, 125, 747, 873, 229, 497, 856,
- /* 160 */ 939, 552, 776, 552, 740, 885, 885, 885, 892, 948,
- /* 170 */ 955, 1145, 1025, 1178, 1203, 1203, 1178, 1085, 1085, 1203,
- /* 180 */ 1203, 1203, 1219, 1219, 1243, 9, 24, 9, 1248, 1253,
- /* 190 */ 9, 1248, 9, 9, 9, 1203, 9, 1219, 102, 102,
- /* 200 */ 102, 102, 102, 102, 102, 102, 102, 102, 102, 1203,
- /* 210 */ 1219, 255, 1243, 135, 1150, 24, 135, 1203, 1203, 1248,
- /* 220 */ 135, 1102, 255, 255, 255, 255, 1102, 255, 1189, 135,
- /* 230 */ 287, 135, 195, 1332, 255, 1134, 1102, 255, 255, 1134,
- /* 240 */ 1102, 255, 255, 102, 1133, 1218, 1134, 1140, 1142, 1159,
- /* 250 */ 955, 1164, 195, 1372, 1151, 1154, 1156, 1151, 1154, 1151,
- /* 260 */ 1154, 1313, 1319, 255, 342, 1203, 135, 1379, 1219, 2548,
- /* 270 */ 2548, 2548, 2548, 2548, 2548, 2548, 83, 1653, 214, 337,
- /* 280 */ 126, 209, 492, 562, 625, 672, 535, 322, 713, 713,
- /* 290 */ 713, 713, 713, 713, 713, 713, 717, 840, 405, 405,
- /* 300 */ 69, 458, 197, 309, 85, 111, 8, 394, 170, 170,
- /* 310 */ 170, 170, 929, 1021, 934, 966, 1002, 1020, 1026, 1119,
- /* 320 */ 1121, 516, 841, 1034, 1035, 1048, 1071, 1072, 1079, 1083,
- /* 330 */ 1148, 910, 994, 1010, 1088, 1008, 1050, 1040, 1097, 1066,
- /* 340 */ 1110, 1115, 1117, 1124, 1125, 1127, 731, 1139, 1141, 1153,
- /* 350 */ 1206, 1440, 1454, 1281, 1459, 1461, 1420, 1463, 1429, 1280,
- /* 360 */ 1433, 1434, 1435, 1284, 1472, 1438, 1439, 1288, 1477, 1292,
- /* 370 */ 1478, 1451, 1489, 1468, 1491, 1457, 1322, 1325, 1497, 1498,
- /* 380 */ 1333, 1335, 1504, 1505, 1456, 1506, 1465, 1508, 1509, 1510,
- /* 390 */ 1362, 1513, 1514, 1515, 1516, 1517, 1374, 1484, 1520, 1377,
- /* 400 */ 1528, 1529, 1530, 1537, 1541, 1542, 1543, 1544, 1545, 1546,
- /* 410 */ 1547, 1549, 1551, 1552, 1481, 1524, 1525, 1526, 1554, 1556,
- /* 420 */ 1557, 1538, 1559, 1561, 1562, 1564, 1566, 1512, 1569, 1518,
- /* 430 */ 1570, 1571, 1531, 1533, 1534, 1567, 1532, 1578, 1555, 1576,
- /* 440 */ 1563, 1565, 1602, 1605, 1607, 1579, 1430, 1608, 1609, 1620,
- /* 450 */ 1560, 1623, 1624, 1590, 1582, 1587, 1628, 1595, 1584, 1594,
- /* 460 */ 1634, 1601, 1592, 1598, 1641, 1610, 1596, 1611, 1646, 1647,
- /* 470 */ 1648, 1651, 1558, 1568, 1618, 1632, 1655, 1625, 1615, 1619,
- /* 480 */ 1626, 1630, 1645, 1663, 1654, 1668, 1656, 1631, 1669, 1657,
- /* 490 */ 1650, 1681, 1658, 1682, 1661, 1695, 1675, 1678, 1699, 1553,
- /* 500 */ 1666, 1703, 1540, 1689, 1572, 1550, 1714, 1715, 1574, 1573,
- /* 510 */ 1716, 1717, 1718, 1633, 1629, 1686, 1583, 1723, 1635, 1580,
- /* 520 */ 1637, 1728, 1694, 1586, 1659, 1638, 1688, 1693, 1511, 1664,
- /* 530 */ 1662, 1665, 1673, 1674, 1677, 1697, 1680, 1679, 1683, 1690,
- /* 540 */ 1691, 1704, 1700, 1721, 1696, 1706, 1519, 1692, 1698, 1725,
- /* 550 */ 1575, 1740, 1738, 1741, 1701, 1743, 1577, 1702, 1755, 1758,
- /* 560 */ 1759, 1760, 1761, 1763, 1702, 1797, 1779, 1612, 1768, 1727,
- /* 570 */ 1713, 1729, 1722, 1730, 1724, 1769, 1731, 1732, 1771, 1800,
- /* 580 */ 1649, 1734, 1742, 1735, 1789, 1791, 1751, 1737, 1795, 1752,
- /* 590 */ 1753, 1810, 1765, 1757, 1813, 1766, 1762, 1814, 1767, 1744,
- /* 600 */ 1745, 1747, 1748, 1828, 1764, 1773, 1774, 1831, 1780, 1821,
- /* 610 */ 1821, 1846, 1808, 1812, 1836, 1840, 1841, 1843, 1844, 1845,
- /* 620 */ 1852, 1822, 1804, 1849, 1858, 1859, 1873, 1861, 1875, 1865,
- /* 630 */ 1866, 1842, 1615, 1876, 1619, 1877, 1878, 1879, 1880, 1886,
- /* 640 */ 1881, 1918, 1884, 1874, 1883, 1920, 1888, 1882, 1885, 1926,
- /* 650 */ 1893, 1887, 1892, 1933, 1901, 1891, 1898, 1939, 1906, 1909,
- /* 660 */ 1943, 1923, 1925, 1927, 1928, 1931, 1934,
+ /* 110 */ 213, 213, 213, 213, 213, 213, 213, 517, 881, 165,
+ /* 120 */ 403, 403, 573, 386, 849, 361, 361, 361, 386, 298,
+ /* 130 */ 298, 18, 350, 350, 67, 67, 294, 294, 270, 357,
+ /* 140 */ 198, 198, 198, 198, 198, 198, 198, 1119, 21, 383,
+ /* 150 */ 501, 105, 665, 484, 715, 828, 366, 799, 506, 800,
+ /* 160 */ 717, 649, 717, 924, 756, 756, 756, 807, 873, 980,
+ /* 170 */ 1174, 1078, 1206, 1232, 1232, 1206, 1107, 1107, 1232, 1232,
+ /* 180 */ 1232, 1257, 1257, 1264, 10, 18, 10, 1272, 1277, 10,
+ /* 190 */ 1272, 10, 10, 10, 1232, 10, 1257, 67, 67, 67,
+ /* 200 */ 67, 67, 67, 67, 67, 67, 67, 67, 1232, 1257,
+ /* 210 */ 294, 1264, 227, 1166, 18, 227, 1232, 1232, 1272, 227,
+ /* 220 */ 1118, 294, 294, 294, 294, 1118, 294, 1201, 227, 270,
+ /* 230 */ 227, 298, 1345, 294, 1139, 1118, 294, 294, 1139, 1118,
+ /* 240 */ 294, 294, 67, 1141, 1235, 1139, 1154, 1157, 1170, 980,
+ /* 250 */ 1178, 298, 1382, 1159, 1162, 1167, 1159, 1162, 1159, 1162,
+ /* 260 */ 1320, 1326, 294, 357, 1232, 227, 1383, 1257, 2259, 2259,
+ /* 270 */ 2259, 2259, 2259, 2259, 2259, 83, 1593, 214, 724, 126,
+ /* 280 */ 209, 491, 562, 622, 813, 535, 321, 698, 698, 698,
+ /* 290 */ 698, 698, 698, 698, 698, 521, 309, 13, 13, 115,
+ /* 300 */ 69, 599, 267, 708, 194, 377, 190, 465, 49, 49,
+ /* 310 */ 49, 49, 684, 944, 938, 994, 999, 1001, 947, 1047,
+ /* 320 */ 1101, 941, 920, 1025, 1043, 1069, 1079, 1091, 1093, 1102,
+ /* 330 */ 1160, 1073, 973, 895, 1103, 1075, 1082, 1058, 1106, 1114,
+ /* 340 */ 1115, 1133, 1163, 1165, 1193, 1198, 1064, 860, 1143, 1176,
+ /* 350 */ 839, 1473, 1476, 1301, 1479, 1480, 1439, 1482, 1448, 1297,
+ /* 360 */ 1450, 1451, 1452, 1302, 1490, 1456, 1457, 1307, 1495, 1310,
+ /* 370 */ 1502, 1477, 1513, 1493, 1516, 1483, 1348, 1347, 1521, 1527,
+ /* 380 */ 1357, 1359, 1525, 1528, 1494, 1529, 1499, 1539, 1542, 1543,
+ /* 390 */ 1395, 1545, 1552, 1554, 1555, 1556, 1403, 1514, 1548, 1413,
+ /* 400 */ 1559, 1560, 1561, 1562, 1566, 1567, 1568, 1569, 1570, 1571,
+ /* 410 */ 1573, 1574, 1575, 1578, 1544, 1590, 1591, 1598, 1600, 1601,
+ /* 420 */ 1612, 1581, 1604, 1605, 1614, 1616, 1619, 1564, 1621, 1572,
+ /* 430 */ 1627, 1629, 1582, 1584, 1588, 1620, 1587, 1622, 1589, 1638,
+ /* 440 */ 1599, 1602, 1650, 1651, 1652, 1617, 1492, 1657, 1658, 1665,
+ /* 450 */ 1607, 1667, 1671, 1608, 1597, 1633, 1673, 1639, 1630, 1637,
+ /* 460 */ 1679, 1645, 1640, 1647, 1688, 1654, 1644, 1653, 1693, 1694,
+ /* 470 */ 1698, 1699, 1609, 1606, 1666, 1678, 1703, 1670, 1675, 1680,
+ /* 480 */ 1686, 1695, 1684, 1710, 1711, 1732, 1713, 1702, 1737, 1722,
+ /* 490 */ 1717, 1754, 1720, 1756, 1724, 1757, 1738, 1741, 1762, 1610,
+ /* 500 */ 1731, 1768, 1613, 1748, 1618, 1624, 1771, 1773, 1625, 1615,
+ /* 510 */ 1780, 1781, 1783, 1696, 1697, 1755, 1634, 1798, 1712, 1648,
+ /* 520 */ 1715, 1800, 1778, 1659, 1735, 1727, 1782, 1784, 1611, 1740,
+ /* 530 */ 1742, 1745, 1746, 1747, 1749, 1787, 1750, 1758, 1760, 1761,
+ /* 540 */ 1763, 1792, 1793, 1799, 1765, 1801, 1626, 1770, 1772, 1815,
+ /* 550 */ 1641, 1809, 1817, 1818, 1775, 1825, 1642, 1779, 1835, 1849,
+ /* 560 */ 1858, 1859, 1860, 1864, 1779, 1898, 1885, 1716, 1867, 1823,
+ /* 570 */ 1824, 1826, 1827, 1829, 1830, 1870, 1833, 1834, 1878, 1891,
+ /* 580 */ 1743, 1844, 1819, 1845, 1899, 1901, 1848, 1850, 1906, 1853,
+ /* 590 */ 1854, 1908, 1856, 1863, 1911, 1861, 1865, 1913, 1868, 1836,
+ /* 600 */ 1843, 1847, 1851, 1936, 1862, 1872, 1876, 1927, 1877, 1925,
+ /* 610 */ 1925, 1947, 1914, 1909, 1938, 1940, 1943, 1945, 1954, 1955,
+ /* 620 */ 1958, 1928, 1922, 1952, 1963, 1965, 1988, 1976, 1991, 1980,
+ /* 630 */ 1981, 1950, 1675, 1985, 1680, 1994, 1995, 1998, 2000, 2014,
+ /* 640 */ 2003, 2039, 2005, 2002, 2011, 2051, 2017, 2006, 2015, 2055,
+ /* 650 */ 2021, 2013, 2019, 2069, 2035, 2024, 2034, 2076, 2042, 2043,
+ /* 660 */ 2079, 2058, 2060, 2062, 2063, 2061, 2066,
};
-#define YY_REDUCE_COUNT (275)
-#define YY_REDUCE_MIN (-389)
-#define YY_REDUCE_MAX (2125)
+#define YY_REDUCE_COUNT (274)
+#define YY_REDUCE_MIN (-403)
+#define YY_REDUCE_MAX (1873)
static const short yy_reduce_ofst[] = {
- /* 0 */ -75, 602, 629, -279, -15, 753, 815, 867, 923, 933,
- /* 10 */ 273, 982, 104, 1042, 1052, 1101, 1152, 1204, 1214, 1231,
- /* 20 */ 1291, 1308, 1376, 1394, 1453, 1502, 1523, 1581, 1591, 1643,
- /* 30 */ 1660, 1709, 1726, 1775, 1829, 1839, 1890, 1908, 1967, 1988,
- /* 40 */ 2044, 2054, 2078, 2125, -312, 33, 425, -295, 436, 490,
- /* 50 */ -308, 654, -345, -68, 77, 151, 246, -316, -310, -307,
- /* 60 */ -276, -285, -238, -87, -78, -313, -33, 239, 367, 418,
- /* 70 */ 420, 427, 505, 623, 689, 161, 698, 722, 723, -234,
- /* 80 */ 729, 730, 727, 742, 744, -244, -153, 749, 754, -10,
- /* 90 */ 782, 767, 91, -124, -389, -389, -389, -164, -51, -30,
- /* 100 */ -21, 100, 148, 205, 272, 311, 323, 357, 381, 382,
- /* 110 */ 430, 464, 540, 603, 607, 640, 641, 28, -263, -335,
- /* 120 */ 392, 443, 438, -229, -85, 234, 467, 570, 79, 18,
- /* 130 */ 365, 312, 341, 413, 223, 665, 545, 596, 668, 610,
- /* 140 */ 90, 220, 249, 308, 373, 387, 398, 252, 534, 518,
- /* 150 */ 645, 571, 677, 693, 680, 781, 781, 839, 848, 817,
- /* 160 */ 793, 769, 769, 769, 783, 758, 762, 763, 777, 781,
- /* 170 */ 812, 814, 836, 876, 918, 919, 880, 884, 889, 928,
- /* 180 */ 936, 941, 935, 945, 894, 946, 914, 950, 912, 911,
- /* 190 */ 958, 916, 960, 961, 963, 969, 968, 976, 953, 956,
- /* 200 */ 957, 959, 964, 965, 974, 975, 984, 985, 986, 978,
- /* 210 */ 981, 947, 954, 1005, 930, 979, 1009, 1013, 1016, 971,
- /* 220 */ 1017, 980, 988, 991, 993, 995, 987, 998, 992, 1030,
- /* 230 */ 1022, 1038, 1014, 989, 1004, 962, 1000, 1023, 1028, 970,
- /* 240 */ 1011, 1031, 1033, 781, 973, 972, 983, 990, 996, 999,
- /* 250 */ 1024, 769, 1051, 1027, 997, 1029, 1003, 1018, 1036, 1032,
- /* 260 */ 1037, 1055, 1070, 1062, 1086, 1098, 1095, 1105, 1109, 1053,
- /* 270 */ 1068, 1113, 1114, 1118, 1132, 1149,
+ /* 0 */ 263, 629, 747, -278, -14, 679, 846, 886, 955, 1009,
+ /* 10 */ 272, 1059, 104, 1076, 1126, 806, 1152, 1202, 1214, 1228,
+ /* 20 */ 1281, 1334, 1346, 1360, 1414, 1428, 1440, 1497, 1507, 1523,
+ /* 30 */ 1547, 1603, 1623, 1643, 1663, 1683, 1723, 1739, 1790, 1806,
+ /* 40 */ 1857, 1873, 304, 926, 112, 435, 552, -295, 610, -3,
+ /* 50 */ -261, -154, -323, 305, 575, 577, 635, -310, -272, -312,
+ /* 60 */ -307, -403, -311, -284, -70, -90, 225, 346, 404, 414,
+ /* 70 */ 429, 434, 497, 644, 645, 339, 674, 697, 710, -342,
+ /* 80 */ 722, 749, -313, 758, 772, -244, -251, 797, -17, 20,
+ /* 90 */ 48, 804, 228, 86, -379, -379, -379, -240, -13, 100,
+ /* 100 */ 101, 130, 206, 375, 385, 428, 459, 461, 474, 522,
+ /* 110 */ 566, 628, 656, 678, 694, 696, 740, -226, -92, -72,
+ /* 120 */ -256, -130, 173, 4, 34, 186, 362, 440, 97, 91,
+ /* 130 */ 303, -234, -109, 180, 274, 536, 317, 545, 579, 234,
+ /* 140 */ -333, 40, 144, 175, 242, 319, 410, 450, 445, 348,
+ /* 150 */ 369, 495, 572, 557, 620, 620, 734, 667, 688, 727,
+ /* 160 */ 735, 735, 735, 770, 752, 784, 786, 762, 620, 861,
+ /* 170 */ 874, 866, 894, 940, 942, 901, 907, 908, 956, 957,
+ /* 180 */ 960, 971, 972, 915, 966, 936, 974, 933, 935, 978,
+ /* 190 */ 939, 981, 983, 985, 991, 989, 1000, 975, 976, 977,
+ /* 200 */ 979, 982, 984, 986, 990, 992, 995, 996, 998, 1006,
+ /* 210 */ 993, 951, 1021, 987, 997, 1026, 1030, 1033, 988, 1032,
+ /* 220 */ 1002, 1005, 1008, 1013, 1014, 1010, 1015, 1011, 1048, 1038,
+ /* 230 */ 1053, 1031, 1003, 1028, 968, 1020, 1036, 1037, 1004, 1022,
+ /* 240 */ 1044, 1049, 620, 1016, 1012, 1018, 1023, 1027, 1024, 1029,
+ /* 250 */ 735, 1061, 1035, 1045, 1017, 1039, 1046, 1034, 1051, 1050,
+ /* 260 */ 1052, 1081, 1067, 1092, 1129, 1104, 1112, 1136, 1096, 1086,
+ /* 270 */ 1137, 1138, 1142, 1130, 1168,
};
static const YYACTIONTYPE yy_default[] = {
- /* 0 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 10 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 20 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 30 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 40 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 50 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 60 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 70 */ 1464, 1464, 1464, 1464, 1464, 1538, 1464, 1464, 1464, 1464,
- /* 80 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 90 */ 1464, 1464, 1536, 1694, 1464, 1871, 1464, 1464, 1464, 1464,
- /* 100 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 110 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 120 */ 1464, 1464, 1538, 1464, 1536, 1883, 1883, 1883, 1464, 1464,
- /* 130 */ 1464, 1464, 1737, 1737, 1464, 1464, 1464, 1464, 1636, 1464,
- /* 140 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1729, 1464, 1952,
- /* 150 */ 1464, 1464, 1464, 1735, 1906, 1464, 1464, 1464, 1464, 1589,
- /* 160 */ 1898, 1875, 1889, 1876, 1873, 1937, 1937, 1937, 1892, 1464,
- /* 170 */ 1902, 1464, 1722, 1699, 1464, 1464, 1699, 1696, 1696, 1464,
- /* 180 */ 1464, 1464, 1464, 1464, 1464, 1538, 1464, 1538, 1464, 1464,
- /* 190 */ 1538, 1464, 1538, 1538, 1538, 1464, 1538, 1464, 1464, 1464,
- /* 200 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 210 */ 1464, 1464, 1464, 1536, 1731, 1464, 1536, 1464, 1464, 1464,
- /* 220 */ 1536, 1911, 1464, 1464, 1464, 1464, 1911, 1464, 1464, 1536,
- /* 230 */ 1464, 1536, 1464, 1464, 1464, 1913, 1911, 1464, 1464, 1913,
- /* 240 */ 1911, 1464, 1464, 1464, 1925, 1921, 1913, 1929, 1927, 1904,
- /* 250 */ 1902, 1889, 1464, 1464, 1943, 1939, 1955, 1943, 1939, 1943,
- /* 260 */ 1939, 1464, 1605, 1464, 1464, 1464, 1536, 1496, 1464, 1724,
- /* 270 */ 1737, 1639, 1639, 1639, 1539, 1469, 1464, 1464, 1464, 1464,
- /* 280 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1808, 1924,
- /* 290 */ 1923, 1847, 1846, 1845, 1843, 1807, 1464, 1601, 1806, 1805,
- /* 300 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1799, 1800,
- /* 310 */ 1798, 1797, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 320 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 330 */ 1872, 1464, 1940, 1944, 1464, 1464, 1464, 1464, 1464, 1783,
- /* 340 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 350 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 360 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 370 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 380 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 390 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 400 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 410 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 420 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 430 */ 1464, 1464, 1464, 1464, 1501, 1464, 1464, 1464, 1464, 1464,
- /* 440 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 450 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 460 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 470 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1573, 1572,
- /* 480 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 490 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 500 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 510 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1741, 1464, 1464,
- /* 520 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1905, 1464, 1464,
- /* 530 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 540 */ 1464, 1464, 1464, 1783, 1464, 1922, 1464, 1882, 1878, 1464,
- /* 550 */ 1464, 1874, 1782, 1464, 1464, 1938, 1464, 1464, 1464, 1464,
- /* 560 */ 1464, 1464, 1464, 1464, 1464, 1867, 1464, 1464, 1840, 1825,
- /* 570 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 580 */ 1793, 1464, 1464, 1464, 1464, 1464, 1633, 1464, 1464, 1464,
- /* 590 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1618,
- /* 600 */ 1616, 1615, 1614, 1464, 1611, 1464, 1464, 1464, 1464, 1642,
- /* 610 */ 1641, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 620 */ 1464, 1464, 1464, 1557, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 630 */ 1464, 1464, 1549, 1464, 1548, 1464, 1464, 1464, 1464, 1464,
- /* 640 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 650 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
- /* 660 */ 1464, 1464, 1464, 1464, 1464, 1464, 1464,
+ /* 0 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 10 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 20 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 30 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 40 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 50 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 60 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 70 */ 1461, 1461, 1461, 1461, 1461, 1535, 1461, 1461, 1461, 1461,
+ /* 80 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 90 */ 1461, 1461, 1533, 1691, 1461, 1866, 1461, 1461, 1461, 1461,
+ /* 100 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 110 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 120 */ 1461, 1461, 1535, 1461, 1533, 1878, 1878, 1878, 1461, 1461,
+ /* 130 */ 1461, 1461, 1732, 1732, 1461, 1461, 1461, 1461, 1633, 1461,
+ /* 140 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1726, 1461, 1947,
+ /* 150 */ 1461, 1461, 1461, 1901, 1461, 1461, 1461, 1461, 1586, 1893,
+ /* 160 */ 1870, 1884, 1871, 1868, 1932, 1932, 1932, 1887, 1461, 1897,
+ /* 170 */ 1461, 1719, 1696, 1461, 1461, 1696, 1693, 1693, 1461, 1461,
+ /* 180 */ 1461, 1461, 1461, 1461, 1535, 1461, 1535, 1461, 1461, 1535,
+ /* 190 */ 1461, 1535, 1535, 1535, 1461, 1535, 1461, 1461, 1461, 1461,
+ /* 200 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 210 */ 1461, 1461, 1533, 1728, 1461, 1533, 1461, 1461, 1461, 1533,
+ /* 220 */ 1906, 1461, 1461, 1461, 1461, 1906, 1461, 1461, 1533, 1461,
+ /* 230 */ 1533, 1461, 1461, 1461, 1908, 1906, 1461, 1461, 1908, 1906,
+ /* 240 */ 1461, 1461, 1461, 1920, 1916, 1908, 1924, 1922, 1899, 1897,
+ /* 250 */ 1884, 1461, 1461, 1938, 1934, 1950, 1938, 1934, 1938, 1934,
+ /* 260 */ 1461, 1602, 1461, 1461, 1461, 1533, 1493, 1461, 1721, 1732,
+ /* 270 */ 1636, 1636, 1636, 1536, 1466, 1461, 1461, 1461, 1461, 1461,
+ /* 280 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1803, 1919, 1918,
+ /* 290 */ 1842, 1841, 1840, 1838, 1802, 1461, 1598, 1801, 1800, 1461,
+ /* 300 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1794, 1795,
+ /* 310 */ 1793, 1792, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 320 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 330 */ 1867, 1461, 1935, 1939, 1461, 1461, 1461, 1461, 1461, 1778,
+ /* 340 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 350 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 360 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 370 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 380 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 390 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 400 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 410 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 420 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 430 */ 1461, 1461, 1461, 1461, 1498, 1461, 1461, 1461, 1461, 1461,
+ /* 440 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 450 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 460 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 470 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1570, 1569,
+ /* 480 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 490 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 500 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 510 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1736, 1461, 1461,
+ /* 520 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1900, 1461, 1461,
+ /* 530 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 540 */ 1461, 1461, 1461, 1778, 1461, 1917, 1461, 1877, 1873, 1461,
+ /* 550 */ 1461, 1869, 1777, 1461, 1461, 1933, 1461, 1461, 1461, 1461,
+ /* 560 */ 1461, 1461, 1461, 1461, 1461, 1862, 1461, 1461, 1835, 1820,
+ /* 570 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 580 */ 1788, 1461, 1461, 1461, 1461, 1461, 1630, 1461, 1461, 1461,
+ /* 590 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1615,
+ /* 600 */ 1613, 1612, 1611, 1461, 1608, 1461, 1461, 1461, 1461, 1639,
+ /* 610 */ 1638, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 620 */ 1461, 1461, 1461, 1554, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 630 */ 1461, 1461, 1546, 1461, 1545, 1461, 1461, 1461, 1461, 1461,
+ /* 640 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 650 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /* 660 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461,
};
/********** End of lemon-generated parsing tables *****************************/
@@ -1686,62 +1642,61 @@ static const char *const yyTokenName[] = {
/* 368 */ "agg_func_opt",
/* 369 */ "bufsize_opt",
/* 370 */ "stream_name",
- /* 371 */ "into_opt",
- /* 372 */ "dnode_list",
- /* 373 */ "where_clause_opt",
- /* 374 */ "signed",
- /* 375 */ "literal_func",
- /* 376 */ "literal_list",
- /* 377 */ "table_alias",
- /* 378 */ "column_alias",
- /* 379 */ "expression",
- /* 380 */ "pseudo_column",
- /* 381 */ "column_reference",
- /* 382 */ "function_expression",
- /* 383 */ "subquery",
- /* 384 */ "star_func",
- /* 385 */ "star_func_para_list",
- /* 386 */ "noarg_func",
- /* 387 */ "other_para_list",
- /* 388 */ "star_func_para",
- /* 389 */ "predicate",
- /* 390 */ "compare_op",
- /* 391 */ "in_op",
- /* 392 */ "in_predicate_value",
- /* 393 */ "boolean_value_expression",
- /* 394 */ "boolean_primary",
- /* 395 */ "common_expression",
- /* 396 */ "from_clause_opt",
- /* 397 */ "table_reference_list",
- /* 398 */ "table_reference",
- /* 399 */ "table_primary",
- /* 400 */ "joined_table",
- /* 401 */ "alias_opt",
- /* 402 */ "parenthesized_joined_table",
- /* 403 */ "join_type",
- /* 404 */ "search_condition",
- /* 405 */ "query_specification",
- /* 406 */ "set_quantifier_opt",
- /* 407 */ "select_list",
- /* 408 */ "partition_by_clause_opt",
- /* 409 */ "range_opt",
- /* 410 */ "every_opt",
- /* 411 */ "fill_opt",
- /* 412 */ "twindow_clause_opt",
- /* 413 */ "group_by_clause_opt",
- /* 414 */ "having_clause_opt",
- /* 415 */ "select_item",
- /* 416 */ "fill_mode",
- /* 417 */ "group_by_list",
- /* 418 */ "query_expression_body",
- /* 419 */ "order_by_clause_opt",
- /* 420 */ "slimit_clause_opt",
- /* 421 */ "limit_clause_opt",
- /* 422 */ "query_primary",
- /* 423 */ "sort_specification_list",
- /* 424 */ "sort_specification",
- /* 425 */ "ordering_specification_opt",
- /* 426 */ "null_ordering_opt",
+ /* 371 */ "dnode_list",
+ /* 372 */ "where_clause_opt",
+ /* 373 */ "signed",
+ /* 374 */ "literal_func",
+ /* 375 */ "literal_list",
+ /* 376 */ "table_alias",
+ /* 377 */ "column_alias",
+ /* 378 */ "expression",
+ /* 379 */ "pseudo_column",
+ /* 380 */ "column_reference",
+ /* 381 */ "function_expression",
+ /* 382 */ "subquery",
+ /* 383 */ "star_func",
+ /* 384 */ "star_func_para_list",
+ /* 385 */ "noarg_func",
+ /* 386 */ "other_para_list",
+ /* 387 */ "star_func_para",
+ /* 388 */ "predicate",
+ /* 389 */ "compare_op",
+ /* 390 */ "in_op",
+ /* 391 */ "in_predicate_value",
+ /* 392 */ "boolean_value_expression",
+ /* 393 */ "boolean_primary",
+ /* 394 */ "common_expression",
+ /* 395 */ "from_clause_opt",
+ /* 396 */ "table_reference_list",
+ /* 397 */ "table_reference",
+ /* 398 */ "table_primary",
+ /* 399 */ "joined_table",
+ /* 400 */ "alias_opt",
+ /* 401 */ "parenthesized_joined_table",
+ /* 402 */ "join_type",
+ /* 403 */ "search_condition",
+ /* 404 */ "query_specification",
+ /* 405 */ "set_quantifier_opt",
+ /* 406 */ "select_list",
+ /* 407 */ "partition_by_clause_opt",
+ /* 408 */ "range_opt",
+ /* 409 */ "every_opt",
+ /* 410 */ "fill_opt",
+ /* 411 */ "twindow_clause_opt",
+ /* 412 */ "group_by_clause_opt",
+ /* 413 */ "having_clause_opt",
+ /* 414 */ "select_item",
+ /* 415 */ "fill_mode",
+ /* 416 */ "group_by_list",
+ /* 417 */ "query_expression_body",
+ /* 418 */ "order_by_clause_opt",
+ /* 419 */ "slimit_clause_opt",
+ /* 420 */ "limit_clause_opt",
+ /* 421 */ "query_primary",
+ /* 422 */ "sort_specification_list",
+ /* 423 */ "sort_specification",
+ /* 424 */ "ordering_specification_opt",
+ /* 425 */ "null_ordering_opt",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
@@ -2015,231 +1970,229 @@ static const char *const yyRuleName[] = {
/* 263 */ "agg_func_opt ::= AGGREGATE",
/* 264 */ "bufsize_opt ::=",
/* 265 */ "bufsize_opt ::= BUFSIZE NK_INTEGER",
- /* 266 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression",
+ /* 266 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression",
/* 267 */ "cmd ::= DROP STREAM exists_opt stream_name",
- /* 268 */ "into_opt ::=",
- /* 269 */ "into_opt ::= INTO full_table_name",
- /* 270 */ "stream_options ::=",
- /* 271 */ "stream_options ::= stream_options TRIGGER AT_ONCE",
- /* 272 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE",
- /* 273 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal",
- /* 274 */ "stream_options ::= stream_options WATERMARK duration_literal",
- /* 275 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER",
- /* 276 */ "cmd ::= KILL CONNECTION NK_INTEGER",
- /* 277 */ "cmd ::= KILL QUERY NK_STRING",
- /* 278 */ "cmd ::= KILL TRANSACTION NK_INTEGER",
- /* 279 */ "cmd ::= BALANCE VGROUP",
- /* 280 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
- /* 281 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
- /* 282 */ "cmd ::= SPLIT VGROUP NK_INTEGER",
- /* 283 */ "dnode_list ::= DNODE NK_INTEGER",
- /* 284 */ "dnode_list ::= dnode_list DNODE NK_INTEGER",
- /* 285 */ "cmd ::= DELETE FROM full_table_name where_clause_opt",
- /* 286 */ "cmd ::= query_expression",
- /* 287 */ "cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression",
- /* 288 */ "cmd ::= INSERT INTO full_table_name query_expression",
- /* 289 */ "literal ::= NK_INTEGER",
- /* 290 */ "literal ::= NK_FLOAT",
- /* 291 */ "literal ::= NK_STRING",
- /* 292 */ "literal ::= NK_BOOL",
- /* 293 */ "literal ::= TIMESTAMP NK_STRING",
- /* 294 */ "literal ::= duration_literal",
- /* 295 */ "literal ::= NULL",
- /* 296 */ "literal ::= NK_QUESTION",
- /* 297 */ "duration_literal ::= NK_VARIABLE",
- /* 298 */ "signed ::= NK_INTEGER",
- /* 299 */ "signed ::= NK_PLUS NK_INTEGER",
- /* 300 */ "signed ::= NK_MINUS NK_INTEGER",
- /* 301 */ "signed ::= NK_FLOAT",
- /* 302 */ "signed ::= NK_PLUS NK_FLOAT",
- /* 303 */ "signed ::= NK_MINUS NK_FLOAT",
- /* 304 */ "signed_literal ::= signed",
- /* 305 */ "signed_literal ::= NK_STRING",
- /* 306 */ "signed_literal ::= NK_BOOL",
- /* 307 */ "signed_literal ::= TIMESTAMP NK_STRING",
- /* 308 */ "signed_literal ::= duration_literal",
- /* 309 */ "signed_literal ::= NULL",
- /* 310 */ "signed_literal ::= literal_func",
- /* 311 */ "signed_literal ::= NK_QUESTION",
- /* 312 */ "literal_list ::= signed_literal",
- /* 313 */ "literal_list ::= literal_list NK_COMMA signed_literal",
- /* 314 */ "db_name ::= NK_ID",
- /* 315 */ "table_name ::= NK_ID",
- /* 316 */ "column_name ::= NK_ID",
- /* 317 */ "function_name ::= NK_ID",
- /* 318 */ "table_alias ::= NK_ID",
- /* 319 */ "column_alias ::= NK_ID",
- /* 320 */ "user_name ::= NK_ID",
- /* 321 */ "topic_name ::= NK_ID",
- /* 322 */ "stream_name ::= NK_ID",
- /* 323 */ "cgroup_name ::= NK_ID",
- /* 324 */ "expression ::= literal",
- /* 325 */ "expression ::= pseudo_column",
- /* 326 */ "expression ::= column_reference",
- /* 327 */ "expression ::= function_expression",
- /* 328 */ "expression ::= subquery",
- /* 329 */ "expression ::= NK_LP expression NK_RP",
- /* 330 */ "expression ::= NK_PLUS expression",
- /* 331 */ "expression ::= NK_MINUS expression",
- /* 332 */ "expression ::= expression NK_PLUS expression",
- /* 333 */ "expression ::= expression NK_MINUS expression",
- /* 334 */ "expression ::= expression NK_STAR expression",
- /* 335 */ "expression ::= expression NK_SLASH expression",
- /* 336 */ "expression ::= expression NK_REM expression",
- /* 337 */ "expression ::= column_reference NK_ARROW NK_STRING",
- /* 338 */ "expression ::= expression NK_BITAND expression",
- /* 339 */ "expression ::= expression NK_BITOR expression",
- /* 340 */ "expression_list ::= expression",
- /* 341 */ "expression_list ::= expression_list NK_COMMA expression",
- /* 342 */ "column_reference ::= column_name",
- /* 343 */ "column_reference ::= table_name NK_DOT column_name",
- /* 344 */ "pseudo_column ::= ROWTS",
- /* 345 */ "pseudo_column ::= TBNAME",
- /* 346 */ "pseudo_column ::= table_name NK_DOT TBNAME",
- /* 347 */ "pseudo_column ::= QSTART",
- /* 348 */ "pseudo_column ::= QEND",
- /* 349 */ "pseudo_column ::= QDURATION",
- /* 350 */ "pseudo_column ::= WSTART",
- /* 351 */ "pseudo_column ::= WEND",
- /* 352 */ "pseudo_column ::= WDURATION",
- /* 353 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
- /* 354 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
- /* 355 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
- /* 356 */ "function_expression ::= literal_func",
- /* 357 */ "literal_func ::= noarg_func NK_LP NK_RP",
- /* 358 */ "literal_func ::= NOW",
- /* 359 */ "noarg_func ::= NOW",
- /* 360 */ "noarg_func ::= TODAY",
- /* 361 */ "noarg_func ::= TIMEZONE",
- /* 362 */ "noarg_func ::= DATABASE",
- /* 363 */ "noarg_func ::= CLIENT_VERSION",
- /* 364 */ "noarg_func ::= SERVER_VERSION",
- /* 365 */ "noarg_func ::= SERVER_STATUS",
- /* 366 */ "noarg_func ::= CURRENT_USER",
- /* 367 */ "noarg_func ::= USER",
- /* 368 */ "star_func ::= COUNT",
- /* 369 */ "star_func ::= FIRST",
- /* 370 */ "star_func ::= LAST",
- /* 371 */ "star_func ::= LAST_ROW",
- /* 372 */ "star_func_para_list ::= NK_STAR",
- /* 373 */ "star_func_para_list ::= other_para_list",
- /* 374 */ "other_para_list ::= star_func_para",
- /* 375 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
- /* 376 */ "star_func_para ::= expression",
- /* 377 */ "star_func_para ::= table_name NK_DOT NK_STAR",
- /* 378 */ "predicate ::= expression compare_op expression",
- /* 379 */ "predicate ::= expression BETWEEN expression AND expression",
- /* 380 */ "predicate ::= expression NOT BETWEEN expression AND expression",
- /* 381 */ "predicate ::= expression IS NULL",
- /* 382 */ "predicate ::= expression IS NOT NULL",
- /* 383 */ "predicate ::= expression in_op in_predicate_value",
- /* 384 */ "compare_op ::= NK_LT",
- /* 385 */ "compare_op ::= NK_GT",
- /* 386 */ "compare_op ::= NK_LE",
- /* 387 */ "compare_op ::= NK_GE",
- /* 388 */ "compare_op ::= NK_NE",
- /* 389 */ "compare_op ::= NK_EQ",
- /* 390 */ "compare_op ::= LIKE",
- /* 391 */ "compare_op ::= NOT LIKE",
- /* 392 */ "compare_op ::= MATCH",
- /* 393 */ "compare_op ::= NMATCH",
- /* 394 */ "compare_op ::= CONTAINS",
- /* 395 */ "in_op ::= IN",
- /* 396 */ "in_op ::= NOT IN",
- /* 397 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
- /* 398 */ "boolean_value_expression ::= boolean_primary",
- /* 399 */ "boolean_value_expression ::= NOT boolean_primary",
- /* 400 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
- /* 401 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
- /* 402 */ "boolean_primary ::= predicate",
- /* 403 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
- /* 404 */ "common_expression ::= expression",
- /* 405 */ "common_expression ::= boolean_value_expression",
- /* 406 */ "from_clause_opt ::=",
- /* 407 */ "from_clause_opt ::= FROM table_reference_list",
- /* 408 */ "table_reference_list ::= table_reference",
- /* 409 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
- /* 410 */ "table_reference ::= table_primary",
- /* 411 */ "table_reference ::= joined_table",
- /* 412 */ "table_primary ::= table_name alias_opt",
- /* 413 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
- /* 414 */ "table_primary ::= subquery alias_opt",
- /* 415 */ "table_primary ::= parenthesized_joined_table",
- /* 416 */ "alias_opt ::=",
- /* 417 */ "alias_opt ::= table_alias",
- /* 418 */ "alias_opt ::= AS table_alias",
- /* 419 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
- /* 420 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
- /* 421 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
- /* 422 */ "join_type ::=",
- /* 423 */ "join_type ::= INNER",
- /* 424 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
- /* 425 */ "set_quantifier_opt ::=",
- /* 426 */ "set_quantifier_opt ::= DISTINCT",
- /* 427 */ "set_quantifier_opt ::= ALL",
- /* 428 */ "select_list ::= select_item",
- /* 429 */ "select_list ::= select_list NK_COMMA select_item",
- /* 430 */ "select_item ::= NK_STAR",
- /* 431 */ "select_item ::= common_expression",
- /* 432 */ "select_item ::= common_expression column_alias",
- /* 433 */ "select_item ::= common_expression AS column_alias",
- /* 434 */ "select_item ::= table_name NK_DOT NK_STAR",
- /* 435 */ "where_clause_opt ::=",
- /* 436 */ "where_clause_opt ::= WHERE search_condition",
- /* 437 */ "partition_by_clause_opt ::=",
- /* 438 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
- /* 439 */ "twindow_clause_opt ::=",
- /* 440 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
- /* 441 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
- /* 442 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
- /* 443 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
- /* 444 */ "sliding_opt ::=",
- /* 445 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
- /* 446 */ "fill_opt ::=",
- /* 447 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
- /* 448 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
- /* 449 */ "fill_mode ::= NONE",
- /* 450 */ "fill_mode ::= PREV",
- /* 451 */ "fill_mode ::= NULL",
- /* 452 */ "fill_mode ::= LINEAR",
- /* 453 */ "fill_mode ::= NEXT",
- /* 454 */ "group_by_clause_opt ::=",
- /* 455 */ "group_by_clause_opt ::= GROUP BY group_by_list",
- /* 456 */ "group_by_list ::= expression",
- /* 457 */ "group_by_list ::= group_by_list NK_COMMA expression",
- /* 458 */ "having_clause_opt ::=",
- /* 459 */ "having_clause_opt ::= HAVING search_condition",
- /* 460 */ "range_opt ::=",
- /* 461 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
- /* 462 */ "every_opt ::=",
- /* 463 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
- /* 464 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
- /* 465 */ "query_expression_body ::= query_primary",
- /* 466 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
- /* 467 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
- /* 468 */ "query_primary ::= query_specification",
- /* 469 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
- /* 470 */ "order_by_clause_opt ::=",
- /* 471 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 472 */ "slimit_clause_opt ::=",
- /* 473 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 474 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 475 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 476 */ "limit_clause_opt ::=",
- /* 477 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 478 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 479 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 480 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 481 */ "search_condition ::= common_expression",
- /* 482 */ "sort_specification_list ::= sort_specification",
- /* 483 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 484 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
- /* 485 */ "ordering_specification_opt ::=",
- /* 486 */ "ordering_specification_opt ::= ASC",
- /* 487 */ "ordering_specification_opt ::= DESC",
- /* 488 */ "null_ordering_opt ::=",
- /* 489 */ "null_ordering_opt ::= NULLS FIRST",
- /* 490 */ "null_ordering_opt ::= NULLS LAST",
+ /* 268 */ "stream_options ::=",
+ /* 269 */ "stream_options ::= stream_options TRIGGER AT_ONCE",
+ /* 270 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE",
+ /* 271 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal",
+ /* 272 */ "stream_options ::= stream_options WATERMARK duration_literal",
+ /* 273 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER",
+ /* 274 */ "cmd ::= KILL CONNECTION NK_INTEGER",
+ /* 275 */ "cmd ::= KILL QUERY NK_STRING",
+ /* 276 */ "cmd ::= KILL TRANSACTION NK_INTEGER",
+ /* 277 */ "cmd ::= BALANCE VGROUP",
+ /* 278 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
+ /* 279 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
+ /* 280 */ "cmd ::= SPLIT VGROUP NK_INTEGER",
+ /* 281 */ "dnode_list ::= DNODE NK_INTEGER",
+ /* 282 */ "dnode_list ::= dnode_list DNODE NK_INTEGER",
+ /* 283 */ "cmd ::= DELETE FROM full_table_name where_clause_opt",
+ /* 284 */ "cmd ::= query_expression",
+ /* 285 */ "cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression",
+ /* 286 */ "cmd ::= INSERT INTO full_table_name query_expression",
+ /* 287 */ "literal ::= NK_INTEGER",
+ /* 288 */ "literal ::= NK_FLOAT",
+ /* 289 */ "literal ::= NK_STRING",
+ /* 290 */ "literal ::= NK_BOOL",
+ /* 291 */ "literal ::= TIMESTAMP NK_STRING",
+ /* 292 */ "literal ::= duration_literal",
+ /* 293 */ "literal ::= NULL",
+ /* 294 */ "literal ::= NK_QUESTION",
+ /* 295 */ "duration_literal ::= NK_VARIABLE",
+ /* 296 */ "signed ::= NK_INTEGER",
+ /* 297 */ "signed ::= NK_PLUS NK_INTEGER",
+ /* 298 */ "signed ::= NK_MINUS NK_INTEGER",
+ /* 299 */ "signed ::= NK_FLOAT",
+ /* 300 */ "signed ::= NK_PLUS NK_FLOAT",
+ /* 301 */ "signed ::= NK_MINUS NK_FLOAT",
+ /* 302 */ "signed_literal ::= signed",
+ /* 303 */ "signed_literal ::= NK_STRING",
+ /* 304 */ "signed_literal ::= NK_BOOL",
+ /* 305 */ "signed_literal ::= TIMESTAMP NK_STRING",
+ /* 306 */ "signed_literal ::= duration_literal",
+ /* 307 */ "signed_literal ::= NULL",
+ /* 308 */ "signed_literal ::= literal_func",
+ /* 309 */ "signed_literal ::= NK_QUESTION",
+ /* 310 */ "literal_list ::= signed_literal",
+ /* 311 */ "literal_list ::= literal_list NK_COMMA signed_literal",
+ /* 312 */ "db_name ::= NK_ID",
+ /* 313 */ "table_name ::= NK_ID",
+ /* 314 */ "column_name ::= NK_ID",
+ /* 315 */ "function_name ::= NK_ID",
+ /* 316 */ "table_alias ::= NK_ID",
+ /* 317 */ "column_alias ::= NK_ID",
+ /* 318 */ "user_name ::= NK_ID",
+ /* 319 */ "topic_name ::= NK_ID",
+ /* 320 */ "stream_name ::= NK_ID",
+ /* 321 */ "cgroup_name ::= NK_ID",
+ /* 322 */ "expression ::= literal",
+ /* 323 */ "expression ::= pseudo_column",
+ /* 324 */ "expression ::= column_reference",
+ /* 325 */ "expression ::= function_expression",
+ /* 326 */ "expression ::= subquery",
+ /* 327 */ "expression ::= NK_LP expression NK_RP",
+ /* 328 */ "expression ::= NK_PLUS expression",
+ /* 329 */ "expression ::= NK_MINUS expression",
+ /* 330 */ "expression ::= expression NK_PLUS expression",
+ /* 331 */ "expression ::= expression NK_MINUS expression",
+ /* 332 */ "expression ::= expression NK_STAR expression",
+ /* 333 */ "expression ::= expression NK_SLASH expression",
+ /* 334 */ "expression ::= expression NK_REM expression",
+ /* 335 */ "expression ::= column_reference NK_ARROW NK_STRING",
+ /* 336 */ "expression ::= expression NK_BITAND expression",
+ /* 337 */ "expression ::= expression NK_BITOR expression",
+ /* 338 */ "expression_list ::= expression",
+ /* 339 */ "expression_list ::= expression_list NK_COMMA expression",
+ /* 340 */ "column_reference ::= column_name",
+ /* 341 */ "column_reference ::= table_name NK_DOT column_name",
+ /* 342 */ "pseudo_column ::= ROWTS",
+ /* 343 */ "pseudo_column ::= TBNAME",
+ /* 344 */ "pseudo_column ::= table_name NK_DOT TBNAME",
+ /* 345 */ "pseudo_column ::= QSTART",
+ /* 346 */ "pseudo_column ::= QEND",
+ /* 347 */ "pseudo_column ::= QDURATION",
+ /* 348 */ "pseudo_column ::= WSTART",
+ /* 349 */ "pseudo_column ::= WEND",
+ /* 350 */ "pseudo_column ::= WDURATION",
+ /* 351 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
+ /* 352 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
+ /* 353 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
+ /* 354 */ "function_expression ::= literal_func",
+ /* 355 */ "literal_func ::= noarg_func NK_LP NK_RP",
+ /* 356 */ "literal_func ::= NOW",
+ /* 357 */ "noarg_func ::= NOW",
+ /* 358 */ "noarg_func ::= TODAY",
+ /* 359 */ "noarg_func ::= TIMEZONE",
+ /* 360 */ "noarg_func ::= DATABASE",
+ /* 361 */ "noarg_func ::= CLIENT_VERSION",
+ /* 362 */ "noarg_func ::= SERVER_VERSION",
+ /* 363 */ "noarg_func ::= SERVER_STATUS",
+ /* 364 */ "noarg_func ::= CURRENT_USER",
+ /* 365 */ "noarg_func ::= USER",
+ /* 366 */ "star_func ::= COUNT",
+ /* 367 */ "star_func ::= FIRST",
+ /* 368 */ "star_func ::= LAST",
+ /* 369 */ "star_func ::= LAST_ROW",
+ /* 370 */ "star_func_para_list ::= NK_STAR",
+ /* 371 */ "star_func_para_list ::= other_para_list",
+ /* 372 */ "other_para_list ::= star_func_para",
+ /* 373 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
+ /* 374 */ "star_func_para ::= expression",
+ /* 375 */ "star_func_para ::= table_name NK_DOT NK_STAR",
+ /* 376 */ "predicate ::= expression compare_op expression",
+ /* 377 */ "predicate ::= expression BETWEEN expression AND expression",
+ /* 378 */ "predicate ::= expression NOT BETWEEN expression AND expression",
+ /* 379 */ "predicate ::= expression IS NULL",
+ /* 380 */ "predicate ::= expression IS NOT NULL",
+ /* 381 */ "predicate ::= expression in_op in_predicate_value",
+ /* 382 */ "compare_op ::= NK_LT",
+ /* 383 */ "compare_op ::= NK_GT",
+ /* 384 */ "compare_op ::= NK_LE",
+ /* 385 */ "compare_op ::= NK_GE",
+ /* 386 */ "compare_op ::= NK_NE",
+ /* 387 */ "compare_op ::= NK_EQ",
+ /* 388 */ "compare_op ::= LIKE",
+ /* 389 */ "compare_op ::= NOT LIKE",
+ /* 390 */ "compare_op ::= MATCH",
+ /* 391 */ "compare_op ::= NMATCH",
+ /* 392 */ "compare_op ::= CONTAINS",
+ /* 393 */ "in_op ::= IN",
+ /* 394 */ "in_op ::= NOT IN",
+ /* 395 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
+ /* 396 */ "boolean_value_expression ::= boolean_primary",
+ /* 397 */ "boolean_value_expression ::= NOT boolean_primary",
+ /* 398 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
+ /* 399 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
+ /* 400 */ "boolean_primary ::= predicate",
+ /* 401 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
+ /* 402 */ "common_expression ::= expression",
+ /* 403 */ "common_expression ::= boolean_value_expression",
+ /* 404 */ "from_clause_opt ::=",
+ /* 405 */ "from_clause_opt ::= FROM table_reference_list",
+ /* 406 */ "table_reference_list ::= table_reference",
+ /* 407 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
+ /* 408 */ "table_reference ::= table_primary",
+ /* 409 */ "table_reference ::= joined_table",
+ /* 410 */ "table_primary ::= table_name alias_opt",
+ /* 411 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
+ /* 412 */ "table_primary ::= subquery alias_opt",
+ /* 413 */ "table_primary ::= parenthesized_joined_table",
+ /* 414 */ "alias_opt ::=",
+ /* 415 */ "alias_opt ::= table_alias",
+ /* 416 */ "alias_opt ::= AS table_alias",
+ /* 417 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
+ /* 418 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
+ /* 419 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
+ /* 420 */ "join_type ::=",
+ /* 421 */ "join_type ::= INNER",
+ /* 422 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
+ /* 423 */ "set_quantifier_opt ::=",
+ /* 424 */ "set_quantifier_opt ::= DISTINCT",
+ /* 425 */ "set_quantifier_opt ::= ALL",
+ /* 426 */ "select_list ::= select_item",
+ /* 427 */ "select_list ::= select_list NK_COMMA select_item",
+ /* 428 */ "select_item ::= NK_STAR",
+ /* 429 */ "select_item ::= common_expression",
+ /* 430 */ "select_item ::= common_expression column_alias",
+ /* 431 */ "select_item ::= common_expression AS column_alias",
+ /* 432 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /* 433 */ "where_clause_opt ::=",
+ /* 434 */ "where_clause_opt ::= WHERE search_condition",
+ /* 435 */ "partition_by_clause_opt ::=",
+ /* 436 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
+ /* 437 */ "twindow_clause_opt ::=",
+ /* 438 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
+ /* 439 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
+ /* 440 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
+ /* 441 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
+ /* 442 */ "sliding_opt ::=",
+ /* 443 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
+ /* 444 */ "fill_opt ::=",
+ /* 445 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
+ /* 446 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
+ /* 447 */ "fill_mode ::= NONE",
+ /* 448 */ "fill_mode ::= PREV",
+ /* 449 */ "fill_mode ::= NULL",
+ /* 450 */ "fill_mode ::= LINEAR",
+ /* 451 */ "fill_mode ::= NEXT",
+ /* 452 */ "group_by_clause_opt ::=",
+ /* 453 */ "group_by_clause_opt ::= GROUP BY group_by_list",
+ /* 454 */ "group_by_list ::= expression",
+ /* 455 */ "group_by_list ::= group_by_list NK_COMMA expression",
+ /* 456 */ "having_clause_opt ::=",
+ /* 457 */ "having_clause_opt ::= HAVING search_condition",
+ /* 458 */ "range_opt ::=",
+ /* 459 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
+ /* 460 */ "every_opt ::=",
+ /* 461 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
+ /* 462 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /* 463 */ "query_expression_body ::= query_primary",
+ /* 464 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
+ /* 465 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
+ /* 466 */ "query_primary ::= query_specification",
+ /* 467 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
+ /* 468 */ "order_by_clause_opt ::=",
+ /* 469 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 470 */ "slimit_clause_opt ::=",
+ /* 471 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 472 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 473 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 474 */ "limit_clause_opt ::=",
+ /* 475 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 476 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 477 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 478 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 479 */ "search_condition ::= common_expression",
+ /* 480 */ "sort_specification_list ::= sort_specification",
+ /* 481 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 482 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
+ /* 483 */ "ordering_specification_opt ::=",
+ /* 484 */ "ordering_specification_opt ::= ASC",
+ /* 485 */ "ordering_specification_opt ::= DESC",
+ /* 486 */ "null_ordering_opt ::=",
+ /* 487 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 488 */ "null_ordering_opt ::= NULLS LAST",
};
#endif /* NDEBUG */
@@ -2393,42 +2346,41 @@ static void yy_destructor(
case 362: /* stream_options */
case 364: /* query_expression */
case 367: /* explain_options */
- case 371: /* into_opt */
- case 373: /* where_clause_opt */
- case 374: /* signed */
- case 375: /* literal_func */
- case 379: /* expression */
- case 380: /* pseudo_column */
- case 381: /* column_reference */
- case 382: /* function_expression */
- case 383: /* subquery */
- case 388: /* star_func_para */
- case 389: /* predicate */
- case 392: /* in_predicate_value */
- case 393: /* boolean_value_expression */
- case 394: /* boolean_primary */
- case 395: /* common_expression */
- case 396: /* from_clause_opt */
- case 397: /* table_reference_list */
- case 398: /* table_reference */
- case 399: /* table_primary */
- case 400: /* joined_table */
- case 402: /* parenthesized_joined_table */
- case 404: /* search_condition */
- case 405: /* query_specification */
- case 409: /* range_opt */
- case 410: /* every_opt */
- case 411: /* fill_opt */
- case 412: /* twindow_clause_opt */
- case 414: /* having_clause_opt */
- case 415: /* select_item */
- case 418: /* query_expression_body */
- case 420: /* slimit_clause_opt */
- case 421: /* limit_clause_opt */
- case 422: /* query_primary */
- case 424: /* sort_specification */
+ case 372: /* where_clause_opt */
+ case 373: /* signed */
+ case 374: /* literal_func */
+ case 378: /* expression */
+ case 379: /* pseudo_column */
+ case 380: /* column_reference */
+ case 381: /* function_expression */
+ case 382: /* subquery */
+ case 387: /* star_func_para */
+ case 388: /* predicate */
+ case 391: /* in_predicate_value */
+ case 392: /* boolean_value_expression */
+ case 393: /* boolean_primary */
+ case 394: /* common_expression */
+ case 395: /* from_clause_opt */
+ case 396: /* table_reference_list */
+ case 397: /* table_reference */
+ case 398: /* table_primary */
+ case 399: /* joined_table */
+ case 401: /* parenthesized_joined_table */
+ case 403: /* search_condition */
+ case 404: /* query_specification */
+ case 408: /* range_opt */
+ case 409: /* every_opt */
+ case 410: /* fill_opt */
+ case 411: /* twindow_clause_opt */
+ case 413: /* having_clause_opt */
+ case 414: /* select_item */
+ case 417: /* query_expression_body */
+ case 419: /* slimit_clause_opt */
+ case 420: /* limit_clause_opt */
+ case 421: /* query_primary */
+ case 423: /* sort_specification */
{
- nodesDestroyNode((yypminor->yy840));
+ nodesDestroyNode((yypminor->yy272));
}
break;
case 306: /* account_options */
@@ -2449,11 +2401,11 @@ static void yy_destructor(
case 363: /* topic_name */
case 365: /* cgroup_name */
case 370: /* stream_name */
- case 377: /* table_alias */
- case 378: /* column_alias */
- case 384: /* star_func */
- case 386: /* noarg_func */
- case 401: /* alias_opt */
+ case 376: /* table_alias */
+ case 377: /* column_alias */
+ case 383: /* star_func */
+ case 385: /* noarg_func */
+ case 400: /* alias_opt */
{
}
@@ -2474,7 +2426,7 @@ static void yy_destructor(
case 320: /* exists_opt */
case 366: /* analyze_opt */
case 368: /* agg_func_opt */
- case 406: /* set_quantifier_opt */
+ case 405: /* set_quantifier_opt */
{
}
@@ -2493,18 +2445,18 @@ static void yy_destructor(
case 346: /* duration_list */
case 347: /* rollup_func_list */
case 358: /* func_list */
- case 372: /* dnode_list */
- case 376: /* literal_list */
- case 385: /* star_func_para_list */
- case 387: /* other_para_list */
- case 407: /* select_list */
- case 408: /* partition_by_clause_opt */
- case 413: /* group_by_clause_opt */
- case 417: /* group_by_list */
- case 419: /* order_by_clause_opt */
- case 423: /* sort_specification_list */
+ case 371: /* dnode_list */
+ case 375: /* literal_list */
+ case 384: /* star_func_para_list */
+ case 386: /* other_para_list */
+ case 406: /* select_list */
+ case 407: /* partition_by_clause_opt */
+ case 412: /* group_by_clause_opt */
+ case 416: /* group_by_list */
+ case 418: /* order_by_clause_opt */
+ case 422: /* sort_specification_list */
{
- nodesDestroyList((yypminor->yy544));
+ nodesDestroyList((yypminor->yy172));
}
break;
case 325: /* alter_db_option */
@@ -2518,28 +2470,28 @@ static void yy_destructor(
}
break;
- case 390: /* compare_op */
- case 391: /* in_op */
+ case 389: /* compare_op */
+ case 390: /* in_op */
{
}
break;
- case 403: /* join_type */
+ case 402: /* join_type */
{
}
break;
- case 416: /* fill_mode */
+ case 415: /* fill_mode */
{
}
break;
- case 425: /* ordering_specification_opt */
+ case 424: /* ordering_specification_opt */
{
}
break;
- case 426: /* null_ordering_opt */
+ case 425: /* null_ordering_opt */
{
}
@@ -3104,231 +3056,229 @@ static const struct {
{ 368, -1 }, /* (263) agg_func_opt ::= AGGREGATE */
{ 369, 0 }, /* (264) bufsize_opt ::= */
{ 369, -2 }, /* (265) bufsize_opt ::= BUFSIZE NK_INTEGER */
- { 305, -8 }, /* (266) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
+ { 305, -9 }, /* (266) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */
{ 305, -4 }, /* (267) cmd ::= DROP STREAM exists_opt stream_name */
- { 371, 0 }, /* (268) into_opt ::= */
- { 371, -2 }, /* (269) into_opt ::= INTO full_table_name */
- { 362, 0 }, /* (270) stream_options ::= */
- { 362, -3 }, /* (271) stream_options ::= stream_options TRIGGER AT_ONCE */
- { 362, -3 }, /* (272) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
- { 362, -4 }, /* (273) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
- { 362, -3 }, /* (274) stream_options ::= stream_options WATERMARK duration_literal */
- { 362, -4 }, /* (275) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
- { 305, -3 }, /* (276) cmd ::= KILL CONNECTION NK_INTEGER */
- { 305, -3 }, /* (277) cmd ::= KILL QUERY NK_STRING */
- { 305, -3 }, /* (278) cmd ::= KILL TRANSACTION NK_INTEGER */
- { 305, -2 }, /* (279) cmd ::= BALANCE VGROUP */
- { 305, -4 }, /* (280) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
- { 305, -4 }, /* (281) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
- { 305, -3 }, /* (282) cmd ::= SPLIT VGROUP NK_INTEGER */
- { 372, -2 }, /* (283) dnode_list ::= DNODE NK_INTEGER */
- { 372, -3 }, /* (284) dnode_list ::= dnode_list DNODE NK_INTEGER */
- { 305, -4 }, /* (285) cmd ::= DELETE FROM full_table_name where_clause_opt */
- { 305, -1 }, /* (286) cmd ::= query_expression */
- { 305, -7 }, /* (287) cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */
- { 305, -4 }, /* (288) cmd ::= INSERT INTO full_table_name query_expression */
- { 308, -1 }, /* (289) literal ::= NK_INTEGER */
- { 308, -1 }, /* (290) literal ::= NK_FLOAT */
- { 308, -1 }, /* (291) literal ::= NK_STRING */
- { 308, -1 }, /* (292) literal ::= NK_BOOL */
- { 308, -2 }, /* (293) literal ::= TIMESTAMP NK_STRING */
- { 308, -1 }, /* (294) literal ::= duration_literal */
- { 308, -1 }, /* (295) literal ::= NULL */
- { 308, -1 }, /* (296) literal ::= NK_QUESTION */
- { 349, -1 }, /* (297) duration_literal ::= NK_VARIABLE */
- { 374, -1 }, /* (298) signed ::= NK_INTEGER */
- { 374, -2 }, /* (299) signed ::= NK_PLUS NK_INTEGER */
- { 374, -2 }, /* (300) signed ::= NK_MINUS NK_INTEGER */
- { 374, -1 }, /* (301) signed ::= NK_FLOAT */
- { 374, -2 }, /* (302) signed ::= NK_PLUS NK_FLOAT */
- { 374, -2 }, /* (303) signed ::= NK_MINUS NK_FLOAT */
- { 338, -1 }, /* (304) signed_literal ::= signed */
- { 338, -1 }, /* (305) signed_literal ::= NK_STRING */
- { 338, -1 }, /* (306) signed_literal ::= NK_BOOL */
- { 338, -2 }, /* (307) signed_literal ::= TIMESTAMP NK_STRING */
- { 338, -1 }, /* (308) signed_literal ::= duration_literal */
- { 338, -1 }, /* (309) signed_literal ::= NULL */
- { 338, -1 }, /* (310) signed_literal ::= literal_func */
- { 338, -1 }, /* (311) signed_literal ::= NK_QUESTION */
- { 376, -1 }, /* (312) literal_list ::= signed_literal */
- { 376, -3 }, /* (313) literal_list ::= literal_list NK_COMMA signed_literal */
- { 316, -1 }, /* (314) db_name ::= NK_ID */
- { 344, -1 }, /* (315) table_name ::= NK_ID */
- { 336, -1 }, /* (316) column_name ::= NK_ID */
- { 351, -1 }, /* (317) function_name ::= NK_ID */
- { 377, -1 }, /* (318) table_alias ::= NK_ID */
- { 378, -1 }, /* (319) column_alias ::= NK_ID */
- { 310, -1 }, /* (320) user_name ::= NK_ID */
- { 363, -1 }, /* (321) topic_name ::= NK_ID */
- { 370, -1 }, /* (322) stream_name ::= NK_ID */
- { 365, -1 }, /* (323) cgroup_name ::= NK_ID */
- { 379, -1 }, /* (324) expression ::= literal */
- { 379, -1 }, /* (325) expression ::= pseudo_column */
- { 379, -1 }, /* (326) expression ::= column_reference */
- { 379, -1 }, /* (327) expression ::= function_expression */
- { 379, -1 }, /* (328) expression ::= subquery */
- { 379, -3 }, /* (329) expression ::= NK_LP expression NK_RP */
- { 379, -2 }, /* (330) expression ::= NK_PLUS expression */
- { 379, -2 }, /* (331) expression ::= NK_MINUS expression */
- { 379, -3 }, /* (332) expression ::= expression NK_PLUS expression */
- { 379, -3 }, /* (333) expression ::= expression NK_MINUS expression */
- { 379, -3 }, /* (334) expression ::= expression NK_STAR expression */
- { 379, -3 }, /* (335) expression ::= expression NK_SLASH expression */
- { 379, -3 }, /* (336) expression ::= expression NK_REM expression */
- { 379, -3 }, /* (337) expression ::= column_reference NK_ARROW NK_STRING */
- { 379, -3 }, /* (338) expression ::= expression NK_BITAND expression */
- { 379, -3 }, /* (339) expression ::= expression NK_BITOR expression */
- { 341, -1 }, /* (340) expression_list ::= expression */
- { 341, -3 }, /* (341) expression_list ::= expression_list NK_COMMA expression */
- { 381, -1 }, /* (342) column_reference ::= column_name */
- { 381, -3 }, /* (343) column_reference ::= table_name NK_DOT column_name */
- { 380, -1 }, /* (344) pseudo_column ::= ROWTS */
- { 380, -1 }, /* (345) pseudo_column ::= TBNAME */
- { 380, -3 }, /* (346) pseudo_column ::= table_name NK_DOT TBNAME */
- { 380, -1 }, /* (347) pseudo_column ::= QSTART */
- { 380, -1 }, /* (348) pseudo_column ::= QEND */
- { 380, -1 }, /* (349) pseudo_column ::= QDURATION */
- { 380, -1 }, /* (350) pseudo_column ::= WSTART */
- { 380, -1 }, /* (351) pseudo_column ::= WEND */
- { 380, -1 }, /* (352) pseudo_column ::= WDURATION */
- { 382, -4 }, /* (353) function_expression ::= function_name NK_LP expression_list NK_RP */
- { 382, -4 }, /* (354) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
- { 382, -6 }, /* (355) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
- { 382, -1 }, /* (356) function_expression ::= literal_func */
- { 375, -3 }, /* (357) literal_func ::= noarg_func NK_LP NK_RP */
- { 375, -1 }, /* (358) literal_func ::= NOW */
- { 386, -1 }, /* (359) noarg_func ::= NOW */
- { 386, -1 }, /* (360) noarg_func ::= TODAY */
- { 386, -1 }, /* (361) noarg_func ::= TIMEZONE */
- { 386, -1 }, /* (362) noarg_func ::= DATABASE */
- { 386, -1 }, /* (363) noarg_func ::= CLIENT_VERSION */
- { 386, -1 }, /* (364) noarg_func ::= SERVER_VERSION */
- { 386, -1 }, /* (365) noarg_func ::= SERVER_STATUS */
- { 386, -1 }, /* (366) noarg_func ::= CURRENT_USER */
- { 386, -1 }, /* (367) noarg_func ::= USER */
- { 384, -1 }, /* (368) star_func ::= COUNT */
- { 384, -1 }, /* (369) star_func ::= FIRST */
- { 384, -1 }, /* (370) star_func ::= LAST */
- { 384, -1 }, /* (371) star_func ::= LAST_ROW */
- { 385, -1 }, /* (372) star_func_para_list ::= NK_STAR */
- { 385, -1 }, /* (373) star_func_para_list ::= other_para_list */
- { 387, -1 }, /* (374) other_para_list ::= star_func_para */
- { 387, -3 }, /* (375) other_para_list ::= other_para_list NK_COMMA star_func_para */
- { 388, -1 }, /* (376) star_func_para ::= expression */
- { 388, -3 }, /* (377) star_func_para ::= table_name NK_DOT NK_STAR */
- { 389, -3 }, /* (378) predicate ::= expression compare_op expression */
- { 389, -5 }, /* (379) predicate ::= expression BETWEEN expression AND expression */
- { 389, -6 }, /* (380) predicate ::= expression NOT BETWEEN expression AND expression */
- { 389, -3 }, /* (381) predicate ::= expression IS NULL */
- { 389, -4 }, /* (382) predicate ::= expression IS NOT NULL */
- { 389, -3 }, /* (383) predicate ::= expression in_op in_predicate_value */
- { 390, -1 }, /* (384) compare_op ::= NK_LT */
- { 390, -1 }, /* (385) compare_op ::= NK_GT */
- { 390, -1 }, /* (386) compare_op ::= NK_LE */
- { 390, -1 }, /* (387) compare_op ::= NK_GE */
- { 390, -1 }, /* (388) compare_op ::= NK_NE */
- { 390, -1 }, /* (389) compare_op ::= NK_EQ */
- { 390, -1 }, /* (390) compare_op ::= LIKE */
- { 390, -2 }, /* (391) compare_op ::= NOT LIKE */
- { 390, -1 }, /* (392) compare_op ::= MATCH */
- { 390, -1 }, /* (393) compare_op ::= NMATCH */
- { 390, -1 }, /* (394) compare_op ::= CONTAINS */
- { 391, -1 }, /* (395) in_op ::= IN */
- { 391, -2 }, /* (396) in_op ::= NOT IN */
- { 392, -3 }, /* (397) in_predicate_value ::= NK_LP literal_list NK_RP */
- { 393, -1 }, /* (398) boolean_value_expression ::= boolean_primary */
- { 393, -2 }, /* (399) boolean_value_expression ::= NOT boolean_primary */
- { 393, -3 }, /* (400) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
- { 393, -3 }, /* (401) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
- { 394, -1 }, /* (402) boolean_primary ::= predicate */
- { 394, -3 }, /* (403) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
- { 395, -1 }, /* (404) common_expression ::= expression */
- { 395, -1 }, /* (405) common_expression ::= boolean_value_expression */
- { 396, 0 }, /* (406) from_clause_opt ::= */
- { 396, -2 }, /* (407) from_clause_opt ::= FROM table_reference_list */
- { 397, -1 }, /* (408) table_reference_list ::= table_reference */
- { 397, -3 }, /* (409) table_reference_list ::= table_reference_list NK_COMMA table_reference */
- { 398, -1 }, /* (410) table_reference ::= table_primary */
- { 398, -1 }, /* (411) table_reference ::= joined_table */
- { 399, -2 }, /* (412) table_primary ::= table_name alias_opt */
- { 399, -4 }, /* (413) table_primary ::= db_name NK_DOT table_name alias_opt */
- { 399, -2 }, /* (414) table_primary ::= subquery alias_opt */
- { 399, -1 }, /* (415) table_primary ::= parenthesized_joined_table */
- { 401, 0 }, /* (416) alias_opt ::= */
- { 401, -1 }, /* (417) alias_opt ::= table_alias */
- { 401, -2 }, /* (418) alias_opt ::= AS table_alias */
- { 402, -3 }, /* (419) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
- { 402, -3 }, /* (420) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
- { 400, -6 }, /* (421) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
- { 403, 0 }, /* (422) join_type ::= */
- { 403, -1 }, /* (423) join_type ::= INNER */
- { 405, -12 }, /* (424) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
- { 406, 0 }, /* (425) set_quantifier_opt ::= */
- { 406, -1 }, /* (426) set_quantifier_opt ::= DISTINCT */
- { 406, -1 }, /* (427) set_quantifier_opt ::= ALL */
- { 407, -1 }, /* (428) select_list ::= select_item */
- { 407, -3 }, /* (429) select_list ::= select_list NK_COMMA select_item */
- { 415, -1 }, /* (430) select_item ::= NK_STAR */
- { 415, -1 }, /* (431) select_item ::= common_expression */
- { 415, -2 }, /* (432) select_item ::= common_expression column_alias */
- { 415, -3 }, /* (433) select_item ::= common_expression AS column_alias */
- { 415, -3 }, /* (434) select_item ::= table_name NK_DOT NK_STAR */
- { 373, 0 }, /* (435) where_clause_opt ::= */
- { 373, -2 }, /* (436) where_clause_opt ::= WHERE search_condition */
- { 408, 0 }, /* (437) partition_by_clause_opt ::= */
- { 408, -3 }, /* (438) partition_by_clause_opt ::= PARTITION BY expression_list */
- { 412, 0 }, /* (439) twindow_clause_opt ::= */
- { 412, -6 }, /* (440) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
- { 412, -4 }, /* (441) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
- { 412, -6 }, /* (442) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
- { 412, -8 }, /* (443) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
- { 359, 0 }, /* (444) sliding_opt ::= */
- { 359, -4 }, /* (445) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
- { 411, 0 }, /* (446) fill_opt ::= */
- { 411, -4 }, /* (447) fill_opt ::= FILL NK_LP fill_mode NK_RP */
- { 411, -6 }, /* (448) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
- { 416, -1 }, /* (449) fill_mode ::= NONE */
- { 416, -1 }, /* (450) fill_mode ::= PREV */
- { 416, -1 }, /* (451) fill_mode ::= NULL */
- { 416, -1 }, /* (452) fill_mode ::= LINEAR */
- { 416, -1 }, /* (453) fill_mode ::= NEXT */
- { 413, 0 }, /* (454) group_by_clause_opt ::= */
- { 413, -3 }, /* (455) group_by_clause_opt ::= GROUP BY group_by_list */
- { 417, -1 }, /* (456) group_by_list ::= expression */
- { 417, -3 }, /* (457) group_by_list ::= group_by_list NK_COMMA expression */
- { 414, 0 }, /* (458) having_clause_opt ::= */
- { 414, -2 }, /* (459) having_clause_opt ::= HAVING search_condition */
- { 409, 0 }, /* (460) range_opt ::= */
- { 409, -6 }, /* (461) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
- { 410, 0 }, /* (462) every_opt ::= */
- { 410, -4 }, /* (463) every_opt ::= EVERY NK_LP duration_literal NK_RP */
- { 364, -4 }, /* (464) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
- { 418, -1 }, /* (465) query_expression_body ::= query_primary */
- { 418, -4 }, /* (466) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
- { 418, -3 }, /* (467) query_expression_body ::= query_expression_body UNION query_expression_body */
- { 422, -1 }, /* (468) query_primary ::= query_specification */
- { 422, -6 }, /* (469) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
- { 419, 0 }, /* (470) order_by_clause_opt ::= */
- { 419, -3 }, /* (471) order_by_clause_opt ::= ORDER BY sort_specification_list */
- { 420, 0 }, /* (472) slimit_clause_opt ::= */
- { 420, -2 }, /* (473) slimit_clause_opt ::= SLIMIT NK_INTEGER */
- { 420, -4 }, /* (474) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
- { 420, -4 }, /* (475) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
- { 421, 0 }, /* (476) limit_clause_opt ::= */
- { 421, -2 }, /* (477) limit_clause_opt ::= LIMIT NK_INTEGER */
- { 421, -4 }, /* (478) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
- { 421, -4 }, /* (479) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
- { 383, -3 }, /* (480) subquery ::= NK_LP query_expression NK_RP */
- { 404, -1 }, /* (481) search_condition ::= common_expression */
- { 423, -1 }, /* (482) sort_specification_list ::= sort_specification */
- { 423, -3 }, /* (483) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
- { 424, -3 }, /* (484) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
- { 425, 0 }, /* (485) ordering_specification_opt ::= */
- { 425, -1 }, /* (486) ordering_specification_opt ::= ASC */
- { 425, -1 }, /* (487) ordering_specification_opt ::= DESC */
- { 426, 0 }, /* (488) null_ordering_opt ::= */
- { 426, -2 }, /* (489) null_ordering_opt ::= NULLS FIRST */
- { 426, -2 }, /* (490) null_ordering_opt ::= NULLS LAST */
+ { 362, 0 }, /* (268) stream_options ::= */
+ { 362, -3 }, /* (269) stream_options ::= stream_options TRIGGER AT_ONCE */
+ { 362, -3 }, /* (270) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+ { 362, -4 }, /* (271) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
+ { 362, -3 }, /* (272) stream_options ::= stream_options WATERMARK duration_literal */
+ { 362, -4 }, /* (273) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
+ { 305, -3 }, /* (274) cmd ::= KILL CONNECTION NK_INTEGER */
+ { 305, -3 }, /* (275) cmd ::= KILL QUERY NK_STRING */
+ { 305, -3 }, /* (276) cmd ::= KILL TRANSACTION NK_INTEGER */
+ { 305, -2 }, /* (277) cmd ::= BALANCE VGROUP */
+ { 305, -4 }, /* (278) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+ { 305, -4 }, /* (279) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+ { 305, -3 }, /* (280) cmd ::= SPLIT VGROUP NK_INTEGER */
+ { 371, -2 }, /* (281) dnode_list ::= DNODE NK_INTEGER */
+ { 371, -3 }, /* (282) dnode_list ::= dnode_list DNODE NK_INTEGER */
+ { 305, -4 }, /* (283) cmd ::= DELETE FROM full_table_name where_clause_opt */
+ { 305, -1 }, /* (284) cmd ::= query_expression */
+ { 305, -7 }, /* (285) cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */
+ { 305, -4 }, /* (286) cmd ::= INSERT INTO full_table_name query_expression */
+ { 308, -1 }, /* (287) literal ::= NK_INTEGER */
+ { 308, -1 }, /* (288) literal ::= NK_FLOAT */
+ { 308, -1 }, /* (289) literal ::= NK_STRING */
+ { 308, -1 }, /* (290) literal ::= NK_BOOL */
+ { 308, -2 }, /* (291) literal ::= TIMESTAMP NK_STRING */
+ { 308, -1 }, /* (292) literal ::= duration_literal */
+ { 308, -1 }, /* (293) literal ::= NULL */
+ { 308, -1 }, /* (294) literal ::= NK_QUESTION */
+ { 349, -1 }, /* (295) duration_literal ::= NK_VARIABLE */
+ { 373, -1 }, /* (296) signed ::= NK_INTEGER */
+ { 373, -2 }, /* (297) signed ::= NK_PLUS NK_INTEGER */
+ { 373, -2 }, /* (298) signed ::= NK_MINUS NK_INTEGER */
+ { 373, -1 }, /* (299) signed ::= NK_FLOAT */
+ { 373, -2 }, /* (300) signed ::= NK_PLUS NK_FLOAT */
+ { 373, -2 }, /* (301) signed ::= NK_MINUS NK_FLOAT */
+ { 338, -1 }, /* (302) signed_literal ::= signed */
+ { 338, -1 }, /* (303) signed_literal ::= NK_STRING */
+ { 338, -1 }, /* (304) signed_literal ::= NK_BOOL */
+ { 338, -2 }, /* (305) signed_literal ::= TIMESTAMP NK_STRING */
+ { 338, -1 }, /* (306) signed_literal ::= duration_literal */
+ { 338, -1 }, /* (307) signed_literal ::= NULL */
+ { 338, -1 }, /* (308) signed_literal ::= literal_func */
+ { 338, -1 }, /* (309) signed_literal ::= NK_QUESTION */
+ { 375, -1 }, /* (310) literal_list ::= signed_literal */
+ { 375, -3 }, /* (311) literal_list ::= literal_list NK_COMMA signed_literal */
+ { 316, -1 }, /* (312) db_name ::= NK_ID */
+ { 344, -1 }, /* (313) table_name ::= NK_ID */
+ { 336, -1 }, /* (314) column_name ::= NK_ID */
+ { 351, -1 }, /* (315) function_name ::= NK_ID */
+ { 376, -1 }, /* (316) table_alias ::= NK_ID */
+ { 377, -1 }, /* (317) column_alias ::= NK_ID */
+ { 310, -1 }, /* (318) user_name ::= NK_ID */
+ { 363, -1 }, /* (319) topic_name ::= NK_ID */
+ { 370, -1 }, /* (320) stream_name ::= NK_ID */
+ { 365, -1 }, /* (321) cgroup_name ::= NK_ID */
+ { 378, -1 }, /* (322) expression ::= literal */
+ { 378, -1 }, /* (323) expression ::= pseudo_column */
+ { 378, -1 }, /* (324) expression ::= column_reference */
+ { 378, -1 }, /* (325) expression ::= function_expression */
+ { 378, -1 }, /* (326) expression ::= subquery */
+ { 378, -3 }, /* (327) expression ::= NK_LP expression NK_RP */
+ { 378, -2 }, /* (328) expression ::= NK_PLUS expression */
+ { 378, -2 }, /* (329) expression ::= NK_MINUS expression */
+ { 378, -3 }, /* (330) expression ::= expression NK_PLUS expression */
+ { 378, -3 }, /* (331) expression ::= expression NK_MINUS expression */
+ { 378, -3 }, /* (332) expression ::= expression NK_STAR expression */
+ { 378, -3 }, /* (333) expression ::= expression NK_SLASH expression */
+ { 378, -3 }, /* (334) expression ::= expression NK_REM expression */
+ { 378, -3 }, /* (335) expression ::= column_reference NK_ARROW NK_STRING */
+ { 378, -3 }, /* (336) expression ::= expression NK_BITAND expression */
+ { 378, -3 }, /* (337) expression ::= expression NK_BITOR expression */
+ { 341, -1 }, /* (338) expression_list ::= expression */
+ { 341, -3 }, /* (339) expression_list ::= expression_list NK_COMMA expression */
+ { 380, -1 }, /* (340) column_reference ::= column_name */
+ { 380, -3 }, /* (341) column_reference ::= table_name NK_DOT column_name */
+ { 379, -1 }, /* (342) pseudo_column ::= ROWTS */
+ { 379, -1 }, /* (343) pseudo_column ::= TBNAME */
+ { 379, -3 }, /* (344) pseudo_column ::= table_name NK_DOT TBNAME */
+ { 379, -1 }, /* (345) pseudo_column ::= QSTART */
+ { 379, -1 }, /* (346) pseudo_column ::= QEND */
+ { 379, -1 }, /* (347) pseudo_column ::= QDURATION */
+ { 379, -1 }, /* (348) pseudo_column ::= WSTART */
+ { 379, -1 }, /* (349) pseudo_column ::= WEND */
+ { 379, -1 }, /* (350) pseudo_column ::= WDURATION */
+ { 381, -4 }, /* (351) function_expression ::= function_name NK_LP expression_list NK_RP */
+ { 381, -4 }, /* (352) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+ { 381, -6 }, /* (353) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+ { 381, -1 }, /* (354) function_expression ::= literal_func */
+ { 374, -3 }, /* (355) literal_func ::= noarg_func NK_LP NK_RP */
+ { 374, -1 }, /* (356) literal_func ::= NOW */
+ { 385, -1 }, /* (357) noarg_func ::= NOW */
+ { 385, -1 }, /* (358) noarg_func ::= TODAY */
+ { 385, -1 }, /* (359) noarg_func ::= TIMEZONE */
+ { 385, -1 }, /* (360) noarg_func ::= DATABASE */
+ { 385, -1 }, /* (361) noarg_func ::= CLIENT_VERSION */
+ { 385, -1 }, /* (362) noarg_func ::= SERVER_VERSION */
+ { 385, -1 }, /* (363) noarg_func ::= SERVER_STATUS */
+ { 385, -1 }, /* (364) noarg_func ::= CURRENT_USER */
+ { 385, -1 }, /* (365) noarg_func ::= USER */
+ { 383, -1 }, /* (366) star_func ::= COUNT */
+ { 383, -1 }, /* (367) star_func ::= FIRST */
+ { 383, -1 }, /* (368) star_func ::= LAST */
+ { 383, -1 }, /* (369) star_func ::= LAST_ROW */
+ { 384, -1 }, /* (370) star_func_para_list ::= NK_STAR */
+ { 384, -1 }, /* (371) star_func_para_list ::= other_para_list */
+ { 386, -1 }, /* (372) other_para_list ::= star_func_para */
+ { 386, -3 }, /* (373) other_para_list ::= other_para_list NK_COMMA star_func_para */
+ { 387, -1 }, /* (374) star_func_para ::= expression */
+ { 387, -3 }, /* (375) star_func_para ::= table_name NK_DOT NK_STAR */
+ { 388, -3 }, /* (376) predicate ::= expression compare_op expression */
+ { 388, -5 }, /* (377) predicate ::= expression BETWEEN expression AND expression */
+ { 388, -6 }, /* (378) predicate ::= expression NOT BETWEEN expression AND expression */
+ { 388, -3 }, /* (379) predicate ::= expression IS NULL */
+ { 388, -4 }, /* (380) predicate ::= expression IS NOT NULL */
+ { 388, -3 }, /* (381) predicate ::= expression in_op in_predicate_value */
+ { 389, -1 }, /* (382) compare_op ::= NK_LT */
+ { 389, -1 }, /* (383) compare_op ::= NK_GT */
+ { 389, -1 }, /* (384) compare_op ::= NK_LE */
+ { 389, -1 }, /* (385) compare_op ::= NK_GE */
+ { 389, -1 }, /* (386) compare_op ::= NK_NE */
+ { 389, -1 }, /* (387) compare_op ::= NK_EQ */
+ { 389, -1 }, /* (388) compare_op ::= LIKE */
+ { 389, -2 }, /* (389) compare_op ::= NOT LIKE */
+ { 389, -1 }, /* (390) compare_op ::= MATCH */
+ { 389, -1 }, /* (391) compare_op ::= NMATCH */
+ { 389, -1 }, /* (392) compare_op ::= CONTAINS */
+ { 390, -1 }, /* (393) in_op ::= IN */
+ { 390, -2 }, /* (394) in_op ::= NOT IN */
+ { 391, -3 }, /* (395) in_predicate_value ::= NK_LP literal_list NK_RP */
+ { 392, -1 }, /* (396) boolean_value_expression ::= boolean_primary */
+ { 392, -2 }, /* (397) boolean_value_expression ::= NOT boolean_primary */
+ { 392, -3 }, /* (398) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+ { 392, -3 }, /* (399) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+ { 393, -1 }, /* (400) boolean_primary ::= predicate */
+ { 393, -3 }, /* (401) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+ { 394, -1 }, /* (402) common_expression ::= expression */
+ { 394, -1 }, /* (403) common_expression ::= boolean_value_expression */
+ { 395, 0 }, /* (404) from_clause_opt ::= */
+ { 395, -2 }, /* (405) from_clause_opt ::= FROM table_reference_list */
+ { 396, -1 }, /* (406) table_reference_list ::= table_reference */
+ { 396, -3 }, /* (407) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+ { 397, -1 }, /* (408) table_reference ::= table_primary */
+ { 397, -1 }, /* (409) table_reference ::= joined_table */
+ { 398, -2 }, /* (410) table_primary ::= table_name alias_opt */
+ { 398, -4 }, /* (411) table_primary ::= db_name NK_DOT table_name alias_opt */
+ { 398, -2 }, /* (412) table_primary ::= subquery alias_opt */
+ { 398, -1 }, /* (413) table_primary ::= parenthesized_joined_table */
+ { 400, 0 }, /* (414) alias_opt ::= */
+ { 400, -1 }, /* (415) alias_opt ::= table_alias */
+ { 400, -2 }, /* (416) alias_opt ::= AS table_alias */
+ { 401, -3 }, /* (417) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+ { 401, -3 }, /* (418) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+ { 399, -6 }, /* (419) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+ { 402, 0 }, /* (420) join_type ::= */
+ { 402, -1 }, /* (421) join_type ::= INNER */
+ { 404, -12 }, /* (422) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+ { 405, 0 }, /* (423) set_quantifier_opt ::= */
+ { 405, -1 }, /* (424) set_quantifier_opt ::= DISTINCT */
+ { 405, -1 }, /* (425) set_quantifier_opt ::= ALL */
+ { 406, -1 }, /* (426) select_list ::= select_item */
+ { 406, -3 }, /* (427) select_list ::= select_list NK_COMMA select_item */
+ { 414, -1 }, /* (428) select_item ::= NK_STAR */
+ { 414, -1 }, /* (429) select_item ::= common_expression */
+ { 414, -2 }, /* (430) select_item ::= common_expression column_alias */
+ { 414, -3 }, /* (431) select_item ::= common_expression AS column_alias */
+ { 414, -3 }, /* (432) select_item ::= table_name NK_DOT NK_STAR */
+ { 372, 0 }, /* (433) where_clause_opt ::= */
+ { 372, -2 }, /* (434) where_clause_opt ::= WHERE search_condition */
+ { 407, 0 }, /* (435) partition_by_clause_opt ::= */
+ { 407, -3 }, /* (436) partition_by_clause_opt ::= PARTITION BY expression_list */
+ { 411, 0 }, /* (437) twindow_clause_opt ::= */
+ { 411, -6 }, /* (438) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+ { 411, -4 }, /* (439) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+ { 411, -6 }, /* (440) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+ { 411, -8 }, /* (441) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+ { 359, 0 }, /* (442) sliding_opt ::= */
+ { 359, -4 }, /* (443) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+ { 410, 0 }, /* (444) fill_opt ::= */
+ { 410, -4 }, /* (445) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+ { 410, -6 }, /* (446) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+ { 415, -1 }, /* (447) fill_mode ::= NONE */
+ { 415, -1 }, /* (448) fill_mode ::= PREV */
+ { 415, -1 }, /* (449) fill_mode ::= NULL */
+ { 415, -1 }, /* (450) fill_mode ::= LINEAR */
+ { 415, -1 }, /* (451) fill_mode ::= NEXT */
+ { 412, 0 }, /* (452) group_by_clause_opt ::= */
+ { 412, -3 }, /* (453) group_by_clause_opt ::= GROUP BY group_by_list */
+ { 416, -1 }, /* (454) group_by_list ::= expression */
+ { 416, -3 }, /* (455) group_by_list ::= group_by_list NK_COMMA expression */
+ { 413, 0 }, /* (456) having_clause_opt ::= */
+ { 413, -2 }, /* (457) having_clause_opt ::= HAVING search_condition */
+ { 408, 0 }, /* (458) range_opt ::= */
+ { 408, -6 }, /* (459) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+ { 409, 0 }, /* (460) every_opt ::= */
+ { 409, -4 }, /* (461) every_opt ::= EVERY NK_LP duration_literal NK_RP */
+ { 364, -4 }, /* (462) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+ { 417, -1 }, /* (463) query_expression_body ::= query_primary */
+ { 417, -4 }, /* (464) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+ { 417, -3 }, /* (465) query_expression_body ::= query_expression_body UNION query_expression_body */
+ { 421, -1 }, /* (466) query_primary ::= query_specification */
+ { 421, -6 }, /* (467) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+ { 418, 0 }, /* (468) order_by_clause_opt ::= */
+ { 418, -3 }, /* (469) order_by_clause_opt ::= ORDER BY sort_specification_list */
+ { 419, 0 }, /* (470) slimit_clause_opt ::= */
+ { 419, -2 }, /* (471) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+ { 419, -4 }, /* (472) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+ { 419, -4 }, /* (473) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+ { 420, 0 }, /* (474) limit_clause_opt ::= */
+ { 420, -2 }, /* (475) limit_clause_opt ::= LIMIT NK_INTEGER */
+ { 420, -4 }, /* (476) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+ { 420, -4 }, /* (477) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+ { 382, -3 }, /* (478) subquery ::= NK_LP query_expression NK_RP */
+ { 403, -1 }, /* (479) search_condition ::= common_expression */
+ { 422, -1 }, /* (480) sort_specification_list ::= sort_specification */
+ { 422, -3 }, /* (481) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+ { 423, -3 }, /* (482) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+ { 424, 0 }, /* (483) ordering_specification_opt ::= */
+ { 424, -1 }, /* (484) ordering_specification_opt ::= ASC */
+ { 424, -1 }, /* (485) ordering_specification_opt ::= DESC */
+ { 425, 0 }, /* (486) null_ordering_opt ::= */
+ { 425, -2 }, /* (487) null_ordering_opt ::= NULLS FIRST */
+ { 425, -2 }, /* (488) null_ordering_opt ::= NULLS LAST */
};
static void yy_accept(yyParser*); /* Forward Declaration */
@@ -3465,69 +3415,69 @@ static YYACTIONTYPE yy_reduce(
yy_destructor(yypParser,308,&yymsp[0].minor);
break;
case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */
-{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy617, &yymsp[-1].minor.yy0, yymsp[0].minor.yy215); }
+{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy209, &yymsp[-1].minor.yy0, yymsp[0].minor.yy59); }
break;
case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */
-{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy617, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy209, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); }
break;
case 26: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */
-{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy617, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy209, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); }
break;
case 27: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */
-{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy617, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy209, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); }
break;
case 28: /* cmd ::= DROP USER user_name */
-{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 29: /* sysinfo_opt ::= */
-{ yymsp[1].minor.yy215 = 1; }
+{ yymsp[1].minor.yy59 = 1; }
break;
case 30: /* sysinfo_opt ::= SYSINFO NK_INTEGER */
-{ yymsp[-1].minor.yy215 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy59 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); }
break;
case 31: /* cmd ::= GRANT privileges ON priv_level TO user_name */
-{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy473, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-4].minor.yy69, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); }
break;
case 32: /* cmd ::= REVOKE privileges ON priv_level FROM user_name */
-{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy473, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-4].minor.yy69, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); }
break;
case 33: /* privileges ::= ALL */
-{ yymsp[0].minor.yy473 = PRIVILEGE_TYPE_ALL; }
+{ yymsp[0].minor.yy69 = PRIVILEGE_TYPE_ALL; }
break;
case 34: /* privileges ::= priv_type_list */
case 35: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==35);
-{ yylhsminor.yy473 = yymsp[0].minor.yy473; }
- yymsp[0].minor.yy473 = yylhsminor.yy473;
+{ yylhsminor.yy69 = yymsp[0].minor.yy69; }
+ yymsp[0].minor.yy69 = yylhsminor.yy69;
break;
case 36: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */
-{ yylhsminor.yy473 = yymsp[-2].minor.yy473 | yymsp[0].minor.yy473; }
- yymsp[-2].minor.yy473 = yylhsminor.yy473;
+{ yylhsminor.yy69 = yymsp[-2].minor.yy69 | yymsp[0].minor.yy69; }
+ yymsp[-2].minor.yy69 = yylhsminor.yy69;
break;
case 37: /* priv_type ::= READ */
-{ yymsp[0].minor.yy473 = PRIVILEGE_TYPE_READ; }
+{ yymsp[0].minor.yy69 = PRIVILEGE_TYPE_READ; }
break;
case 38: /* priv_type ::= WRITE */
-{ yymsp[0].minor.yy473 = PRIVILEGE_TYPE_WRITE; }
+{ yymsp[0].minor.yy69 = PRIVILEGE_TYPE_WRITE; }
break;
case 39: /* priv_level ::= NK_STAR NK_DOT NK_STAR */
-{ yylhsminor.yy617 = yymsp[-2].minor.yy0; }
- yymsp[-2].minor.yy617 = yylhsminor.yy617;
+{ yylhsminor.yy209 = yymsp[-2].minor.yy0; }
+ yymsp[-2].minor.yy209 = yylhsminor.yy209;
break;
case 40: /* priv_level ::= db_name NK_DOT NK_STAR */
-{ yylhsminor.yy617 = yymsp[-2].minor.yy617; }
- yymsp[-2].minor.yy617 = yylhsminor.yy617;
+{ yylhsminor.yy209 = yymsp[-2].minor.yy209; }
+ yymsp[-2].minor.yy209 = yylhsminor.yy209;
break;
case 41: /* cmd ::= CREATE DNODE dnode_endpoint */
-{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy617, NULL); }
+{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy209, NULL); }
break;
case 42: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */
-{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); }
break;
case 43: /* cmd ::= DROP DNODE NK_INTEGER */
{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy0); }
break;
case 44: /* cmd ::= DROP DNODE dnode_endpoint */
-{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 45: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
{ pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); }
@@ -3544,31 +3494,31 @@ static YYACTIONTYPE yy_reduce(
case 49: /* dnode_endpoint ::= NK_STRING */
case 50: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==50);
case 51: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==51);
- case 314: /* db_name ::= NK_ID */ yytestcase(yyruleno==314);
- case 315: /* table_name ::= NK_ID */ yytestcase(yyruleno==315);
- case 316: /* column_name ::= NK_ID */ yytestcase(yyruleno==316);
- case 317: /* function_name ::= NK_ID */ yytestcase(yyruleno==317);
- case 318: /* table_alias ::= NK_ID */ yytestcase(yyruleno==318);
- case 319: /* column_alias ::= NK_ID */ yytestcase(yyruleno==319);
- case 320: /* user_name ::= NK_ID */ yytestcase(yyruleno==320);
- case 321: /* topic_name ::= NK_ID */ yytestcase(yyruleno==321);
- case 322: /* stream_name ::= NK_ID */ yytestcase(yyruleno==322);
- case 323: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==323);
- case 359: /* noarg_func ::= NOW */ yytestcase(yyruleno==359);
- case 360: /* noarg_func ::= TODAY */ yytestcase(yyruleno==360);
- case 361: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==361);
- case 362: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==362);
- case 363: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==363);
- case 364: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==364);
- case 365: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==365);
- case 366: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==366);
- case 367: /* noarg_func ::= USER */ yytestcase(yyruleno==367);
- case 368: /* star_func ::= COUNT */ yytestcase(yyruleno==368);
- case 369: /* star_func ::= FIRST */ yytestcase(yyruleno==369);
- case 370: /* star_func ::= LAST */ yytestcase(yyruleno==370);
- case 371: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==371);
-{ yylhsminor.yy617 = yymsp[0].minor.yy0; }
- yymsp[0].minor.yy617 = yylhsminor.yy617;
+ case 312: /* db_name ::= NK_ID */ yytestcase(yyruleno==312);
+ case 313: /* table_name ::= NK_ID */ yytestcase(yyruleno==313);
+ case 314: /* column_name ::= NK_ID */ yytestcase(yyruleno==314);
+ case 315: /* function_name ::= NK_ID */ yytestcase(yyruleno==315);
+ case 316: /* table_alias ::= NK_ID */ yytestcase(yyruleno==316);
+ case 317: /* column_alias ::= NK_ID */ yytestcase(yyruleno==317);
+ case 318: /* user_name ::= NK_ID */ yytestcase(yyruleno==318);
+ case 319: /* topic_name ::= NK_ID */ yytestcase(yyruleno==319);
+ case 320: /* stream_name ::= NK_ID */ yytestcase(yyruleno==320);
+ case 321: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==321);
+ case 357: /* noarg_func ::= NOW */ yytestcase(yyruleno==357);
+ case 358: /* noarg_func ::= TODAY */ yytestcase(yyruleno==358);
+ case 359: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==359);
+ case 360: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==360);
+ case 361: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==361);
+ case 362: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==362);
+ case 363: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==363);
+ case 364: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==364);
+ case 365: /* noarg_func ::= USER */ yytestcase(yyruleno==365);
+ case 366: /* star_func ::= COUNT */ yytestcase(yyruleno==366);
+ case 367: /* star_func ::= FIRST */ yytestcase(yyruleno==367);
+ case 368: /* star_func ::= LAST */ yytestcase(yyruleno==368);
+ case 369: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==369);
+{ yylhsminor.yy209 = yymsp[0].minor.yy0; }
+ yymsp[0].minor.yy209 = yylhsminor.yy209;
break;
case 52: /* cmd ::= ALTER LOCAL NK_STRING */
{ pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); }
@@ -3601,189 +3551,189 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); }
break;
case 62: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
-{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy313, &yymsp[-1].minor.yy617, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy293, &yymsp[-1].minor.yy209, yymsp[0].minor.yy272); }
break;
case 63: /* cmd ::= DROP DATABASE exists_opt db_name */
-{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy293, &yymsp[0].minor.yy209); }
break;
case 64: /* cmd ::= USE db_name */
-{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 65: /* cmd ::= ALTER DATABASE db_name alter_db_options */
-{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy617, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy209, yymsp[0].minor.yy272); }
break;
case 66: /* cmd ::= FLUSH DATABASE db_name */
-{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 67: /* cmd ::= TRIM DATABASE db_name */
-{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 68: /* not_exists_opt ::= IF NOT EXISTS */
-{ yymsp[-2].minor.yy313 = true; }
+{ yymsp[-2].minor.yy293 = true; }
break;
case 69: /* not_exists_opt ::= */
case 71: /* exists_opt ::= */ yytestcase(yyruleno==71);
case 255: /* analyze_opt ::= */ yytestcase(yyruleno==255);
case 262: /* agg_func_opt ::= */ yytestcase(yyruleno==262);
- case 425: /* set_quantifier_opt ::= */ yytestcase(yyruleno==425);
-{ yymsp[1].minor.yy313 = false; }
+ case 423: /* set_quantifier_opt ::= */ yytestcase(yyruleno==423);
+{ yymsp[1].minor.yy293 = false; }
break;
case 70: /* exists_opt ::= IF EXISTS */
-{ yymsp[-1].minor.yy313 = true; }
+{ yymsp[-1].minor.yy293 = true; }
break;
case 72: /* db_options ::= */
-{ yymsp[1].minor.yy840 = createDefaultDatabaseOptions(pCxt); }
+{ yymsp[1].minor.yy272 = createDefaultDatabaseOptions(pCxt); }
break;
case 73: /* db_options ::= db_options BUFFER NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 74: /* db_options ::= db_options CACHEMODEL NK_STRING */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 75: /* db_options ::= db_options CACHESIZE NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 76: /* db_options ::= db_options COMP NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_COMP, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_COMP, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 77: /* db_options ::= db_options DURATION NK_INTEGER */
case 78: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==78);
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_DAYS, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_DAYS, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 79: /* db_options ::= db_options MAXROWS NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 80: /* db_options ::= db_options MINROWS NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 81: /* db_options ::= db_options KEEP integer_list */
case 82: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==82);
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_KEEP, yymsp[0].minor.yy544); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_KEEP, yymsp[0].minor.yy172); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 83: /* db_options ::= db_options PAGES NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGES, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_PAGES, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 84: /* db_options ::= db_options PAGESIZE NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 85: /* db_options ::= db_options PRECISION NK_STRING */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 86: /* db_options ::= db_options REPLICA NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 87: /* db_options ::= db_options STRICT NK_STRING */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_STRICT, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_STRICT, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 88: /* db_options ::= db_options VGROUPS NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 89: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 90: /* db_options ::= db_options RETENTIONS retention_list */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_RETENTIONS, yymsp[0].minor.yy544); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_RETENTIONS, yymsp[0].minor.yy172); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 91: /* db_options ::= db_options SCHEMALESS NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 92: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_WAL, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 93: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 94: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 95: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */
{
SToken t = yymsp[-1].minor.yy0;
t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
- yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &t);
+ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-3].minor.yy272, DB_OPTION_WAL_RETENTION_PERIOD, &t);
}
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 96: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 97: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */
{
SToken t = yymsp[-1].minor.yy0;
t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
- yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &t);
+ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-3].minor.yy272, DB_OPTION_WAL_RETENTION_SIZE, &t);
}
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 98: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 99: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */
-{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setDatabaseOption(pCxt, yymsp[-2].minor.yy272, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 100: /* alter_db_options ::= alter_db_option */
-{ yylhsminor.yy840 = createAlterDatabaseOptions(pCxt); yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yylhsminor.yy840, &yymsp[0].minor.yy95); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterDatabaseOptions(pCxt); yylhsminor.yy272 = setAlterDatabaseOption(pCxt, yylhsminor.yy272, &yymsp[0].minor.yy5); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 101: /* alter_db_options ::= alter_db_options alter_db_option */
-{ yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy840, &yymsp[0].minor.yy95); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy272, &yymsp[0].minor.yy5); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 102: /* alter_db_option ::= CACHEMODEL NK_STRING */
-{ yymsp[-1].minor.yy95.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 103: /* alter_db_option ::= CACHESIZE NK_INTEGER */
-{ yymsp[-1].minor.yy95.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 104: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */
-{ yymsp[-1].minor.yy95.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 105: /* alter_db_option ::= KEEP integer_list */
case 106: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==106);
-{ yymsp[-1].minor.yy95.type = DB_OPTION_KEEP; yymsp[-1].minor.yy95.pList = yymsp[0].minor.yy544; }
+{ yymsp[-1].minor.yy5.type = DB_OPTION_KEEP; yymsp[-1].minor.yy5.pList = yymsp[0].minor.yy172; }
break;
case 107: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */
-{ yymsp[-1].minor.yy95.type = DB_OPTION_WAL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = DB_OPTION_WAL; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 108: /* integer_list ::= NK_INTEGER */
-{ yylhsminor.yy544 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+{ yylhsminor.yy172 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
case 109: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */
- case 284: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==284);
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-2].minor.yy544, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
- yymsp[-2].minor.yy544 = yylhsminor.yy544;
+ case 282: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==282);
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-2].minor.yy172, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+ yymsp[-2].minor.yy172 = yylhsminor.yy172;
break;
case 110: /* variable_list ::= NK_VARIABLE */
-{ yylhsminor.yy544 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+{ yylhsminor.yy172 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
case 111: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-2].minor.yy544, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
- yymsp[-2].minor.yy544 = yylhsminor.yy544;
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-2].minor.yy172, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+ yymsp[-2].minor.yy172 = yylhsminor.yy172;
break;
case 112: /* retention_list ::= retention */
case 132: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==132);
@@ -3792,266 +3742,266 @@ static YYACTIONTYPE yy_reduce(
case 185: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==185);
case 190: /* col_name_list ::= col_name */ yytestcase(yyruleno==190);
case 238: /* func_list ::= func */ yytestcase(yyruleno==238);
- case 312: /* literal_list ::= signed_literal */ yytestcase(yyruleno==312);
- case 374: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==374);
- case 428: /* select_list ::= select_item */ yytestcase(yyruleno==428);
- case 482: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==482);
-{ yylhsminor.yy544 = createNodeList(pCxt, yymsp[0].minor.yy840); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+ case 310: /* literal_list ::= signed_literal */ yytestcase(yyruleno==310);
+ case 372: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==372);
+ case 426: /* select_list ::= select_item */ yytestcase(yyruleno==426);
+ case 480: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==480);
+{ yylhsminor.yy172 = createNodeList(pCxt, yymsp[0].minor.yy272); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
case 113: /* retention_list ::= retention_list NK_COMMA retention */
case 143: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==143);
case 186: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==186);
case 191: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==191);
case 239: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==239);
- case 313: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==313);
- case 375: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==375);
- case 429: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==429);
- case 483: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==483);
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-2].minor.yy544, yymsp[0].minor.yy840); }
- yymsp[-2].minor.yy544 = yylhsminor.yy544;
+ case 311: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==311);
+ case 373: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==373);
+ case 427: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==427);
+ case 481: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==481);
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-2].minor.yy172, yymsp[0].minor.yy272); }
+ yymsp[-2].minor.yy172 = yylhsminor.yy172;
break;
case 114: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
-{ yylhsminor.yy840 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 115: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
case 117: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==117);
-{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy313, yymsp[-5].minor.yy840, yymsp[-3].minor.yy544, yymsp[-1].minor.yy544, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy293, yymsp[-5].minor.yy272, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, yymsp[0].minor.yy272); }
break;
case 116: /* cmd ::= CREATE TABLE multi_create_clause */
-{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy544); }
+{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy172); }
break;
case 118: /* cmd ::= DROP TABLE multi_drop_clause */
-{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy544); }
+{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy172); }
break;
case 119: /* cmd ::= DROP STABLE exists_opt full_table_name */
-{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy293, yymsp[0].minor.yy272); }
break;
case 120: /* cmd ::= ALTER TABLE alter_table_clause */
- case 286: /* cmd ::= query_expression */ yytestcase(yyruleno==286);
-{ pCxt->pRootNode = yymsp[0].minor.yy840; }
+ case 284: /* cmd ::= query_expression */ yytestcase(yyruleno==284);
+{ pCxt->pRootNode = yymsp[0].minor.yy272; }
break;
case 121: /* cmd ::= ALTER STABLE alter_table_clause */
-{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy272); }
break;
case 122: /* alter_table_clause ::= full_table_name alter_table_options */
-{ yylhsminor.yy840 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 123: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy617, yymsp[0].minor.yy784); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy209, yymsp[0].minor.yy616); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 124: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */
-{ yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy617); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy272, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy209); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 125: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy617, yymsp[0].minor.yy784); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy209, yymsp[0].minor.yy616); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 126: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-{ yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy617, &yymsp[0].minor.yy617); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 127: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy617, yymsp[0].minor.yy784); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy209, yymsp[0].minor.yy616); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 128: /* alter_table_clause ::= full_table_name DROP TAG column_name */
-{ yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy617); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy272, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy209); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 129: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy617, yymsp[0].minor.yy784); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy209, yymsp[0].minor.yy616); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 130: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
-{ yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy617, &yymsp[0].minor.yy617); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy272, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 131: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
-{ yylhsminor.yy840 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy840, &yymsp[-2].minor.yy617, yymsp[0].minor.yy840); }
- yymsp[-5].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy272, &yymsp[-2].minor.yy209, yymsp[0].minor.yy272); }
+ yymsp[-5].minor.yy272 = yylhsminor.yy272;
break;
case 133: /* multi_create_clause ::= multi_create_clause create_subtable_clause */
case 136: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==136);
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-1].minor.yy544, yymsp[0].minor.yy840); }
- yymsp[-1].minor.yy544 = yylhsminor.yy544;
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-1].minor.yy172, yymsp[0].minor.yy272); }
+ yymsp[-1].minor.yy172 = yylhsminor.yy172;
break;
case 134: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */
-{ yylhsminor.yy840 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy313, yymsp[-8].minor.yy840, yymsp[-6].minor.yy840, yymsp[-5].minor.yy544, yymsp[-2].minor.yy544, yymsp[0].minor.yy840); }
- yymsp[-9].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy293, yymsp[-8].minor.yy272, yymsp[-6].minor.yy272, yymsp[-5].minor.yy172, yymsp[-2].minor.yy172, yymsp[0].minor.yy272); }
+ yymsp[-9].minor.yy272 = yylhsminor.yy272;
break;
case 137: /* drop_table_clause ::= exists_opt full_table_name */
-{ yylhsminor.yy840 = createDropTableClause(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createDropTableClause(pCxt, yymsp[-1].minor.yy293, yymsp[0].minor.yy272); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 138: /* specific_cols_opt ::= */
case 169: /* tags_def_opt ::= */ yytestcase(yyruleno==169);
- case 437: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==437);
- case 454: /* group_by_clause_opt ::= */ yytestcase(yyruleno==454);
- case 470: /* order_by_clause_opt ::= */ yytestcase(yyruleno==470);
-{ yymsp[1].minor.yy544 = NULL; }
+ case 435: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==435);
+ case 452: /* group_by_clause_opt ::= */ yytestcase(yyruleno==452);
+ case 468: /* order_by_clause_opt ::= */ yytestcase(yyruleno==468);
+{ yymsp[1].minor.yy172 = NULL; }
break;
case 139: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */
-{ yymsp[-2].minor.yy544 = yymsp[-1].minor.yy544; }
+{ yymsp[-2].minor.yy172 = yymsp[-1].minor.yy172; }
break;
case 140: /* full_table_name ::= table_name */
-{ yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy617, NULL); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy209, NULL); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 141: /* full_table_name ::= db_name NK_DOT table_name */
-{ yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617, NULL); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createRealTableNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209, NULL); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 144: /* column_def ::= column_name type_name */
-{ yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy617, yymsp[0].minor.yy784, NULL); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy209, yymsp[0].minor.yy616, NULL); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 145: /* column_def ::= column_name type_name COMMENT NK_STRING */
-{ yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy617, yymsp[-2].minor.yy784, &yymsp[0].minor.yy0); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-2].minor.yy616, &yymsp[0].minor.yy0); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 146: /* type_name ::= BOOL */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BOOL); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_BOOL); }
break;
case 147: /* type_name ::= TINYINT */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TINYINT); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_TINYINT); }
break;
case 148: /* type_name ::= SMALLINT */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_SMALLINT); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_SMALLINT); }
break;
case 149: /* type_name ::= INT */
case 150: /* type_name ::= INTEGER */ yytestcase(yyruleno==150);
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_INT); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_INT); }
break;
case 151: /* type_name ::= BIGINT */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BIGINT); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_BIGINT); }
break;
case 152: /* type_name ::= FLOAT */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_FLOAT); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_FLOAT); }
break;
case 153: /* type_name ::= DOUBLE */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DOUBLE); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_DOUBLE); }
break;
case 154: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy616 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); }
break;
case 155: /* type_name ::= TIMESTAMP */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); }
break;
case 156: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy616 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); }
break;
case 157: /* type_name ::= TINYINT UNSIGNED */
-{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UTINYINT); }
+{ yymsp[-1].minor.yy616 = createDataType(TSDB_DATA_TYPE_UTINYINT); }
break;
case 158: /* type_name ::= SMALLINT UNSIGNED */
-{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_USMALLINT); }
+{ yymsp[-1].minor.yy616 = createDataType(TSDB_DATA_TYPE_USMALLINT); }
break;
case 159: /* type_name ::= INT UNSIGNED */
-{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UINT); }
+{ yymsp[-1].minor.yy616 = createDataType(TSDB_DATA_TYPE_UINT); }
break;
case 160: /* type_name ::= BIGINT UNSIGNED */
-{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UBIGINT); }
+{ yymsp[-1].minor.yy616 = createDataType(TSDB_DATA_TYPE_UBIGINT); }
break;
case 161: /* type_name ::= JSON */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_JSON); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_JSON); }
break;
case 162: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy616 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); }
break;
case 163: /* type_name ::= MEDIUMBLOB */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); }
break;
case 164: /* type_name ::= BLOB */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BLOB); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_BLOB); }
break;
case 165: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy616 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); }
break;
case 166: /* type_name ::= DECIMAL */
-{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[0].minor.yy616 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
break;
case 167: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[-3].minor.yy616 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
break;
case 168: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-{ yymsp[-5].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[-5].minor.yy616 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
break;
case 170: /* tags_def_opt ::= tags_def */
- case 373: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==373);
-{ yylhsminor.yy544 = yymsp[0].minor.yy544; }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+ case 371: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==371);
+{ yylhsminor.yy172 = yymsp[0].minor.yy172; }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
case 171: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */
-{ yymsp[-3].minor.yy544 = yymsp[-1].minor.yy544; }
+{ yymsp[-3].minor.yy172 = yymsp[-1].minor.yy172; }
break;
case 172: /* table_options ::= */
-{ yymsp[1].minor.yy840 = createDefaultTableOptions(pCxt); }
+{ yymsp[1].minor.yy272 = createDefaultTableOptions(pCxt); }
break;
case 173: /* table_options ::= table_options COMMENT NK_STRING */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-2].minor.yy272, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 174: /* table_options ::= table_options MAX_DELAY duration_list */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy544); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-2].minor.yy272, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy172); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 175: /* table_options ::= table_options WATERMARK duration_list */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy544); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-2].minor.yy272, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy172); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 176: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy544); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-4].minor.yy272, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy172); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 177: /* table_options ::= table_options TTL NK_INTEGER */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-2].minor.yy272, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 178: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_SMA, yymsp[-1].minor.yy544); }
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-4].minor.yy272, TABLE_OPTION_SMA, yymsp[-1].minor.yy172); }
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
case 179: /* alter_table_options ::= alter_table_option */
-{ yylhsminor.yy840 = createAlterTableOptions(pCxt); yylhsminor.yy840 = setTableOption(pCxt, yylhsminor.yy840, yymsp[0].minor.yy95.type, &yymsp[0].minor.yy95.val); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createAlterTableOptions(pCxt); yylhsminor.yy272 = setTableOption(pCxt, yylhsminor.yy272, yymsp[0].minor.yy5.type, &yymsp[0].minor.yy5.val); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 180: /* alter_table_options ::= alter_table_options alter_table_option */
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy95.type, &yymsp[0].minor.yy95.val); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setTableOption(pCxt, yymsp[-1].minor.yy272, yymsp[0].minor.yy5.type, &yymsp[0].minor.yy5.val); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 181: /* alter_table_option ::= COMMENT NK_STRING */
-{ yymsp[-1].minor.yy95.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 182: /* alter_table_option ::= TTL NK_INTEGER */
-{ yymsp[-1].minor.yy95.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; }
+{ yymsp[-1].minor.yy5.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy5.val = yymsp[0].minor.yy0; }
break;
case 183: /* duration_list ::= duration_literal */
- case 340: /* expression_list ::= expression */ yytestcase(yyruleno==340);
-{ yylhsminor.yy544 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+ case 338: /* expression_list ::= expression */ yytestcase(yyruleno==338);
+{ yylhsminor.yy172 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy272)); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
case 184: /* duration_list ::= duration_list NK_COMMA duration_literal */
- case 341: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==341);
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-2].minor.yy544, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
- yymsp[-2].minor.yy544 = yylhsminor.yy544;
+ case 339: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==339);
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-2].minor.yy172, releaseRawExprNode(pCxt, yymsp[0].minor.yy272)); }
+ yymsp[-2].minor.yy172 = yylhsminor.yy172;
break;
case 187: /* rollup_func_name ::= function_name */
-{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy617, NULL); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createFunctionNode(pCxt, &yymsp[0].minor.yy209, NULL); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 188: /* rollup_func_name ::= FIRST */
case 189: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==189);
-{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 192: /* col_name ::= column_name */
-{ yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy617); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy209); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 193: /* cmd ::= SHOW DNODES */
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); }
@@ -4063,13 +4013,13 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); }
break;
case 196: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); }
+{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy272, yymsp[0].minor.yy272, OP_TYPE_LIKE); }
break;
case 197: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); }
+{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy272, yymsp[0].minor.yy272, OP_TYPE_LIKE); }
break;
case 198: /* cmd ::= SHOW db_name_cond_opt VGROUPS */
-{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy840, NULL, OP_TYPE_LIKE); }
+{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy272, NULL, OP_TYPE_LIKE); }
break;
case 199: /* cmd ::= SHOW MNODES */
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); }
@@ -4084,7 +4034,7 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); }
break;
case 203: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); }
+{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy272, yymsp[-1].minor.yy272, OP_TYPE_EQUAL); }
break;
case 204: /* cmd ::= SHOW STREAMS */
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); }
@@ -4103,13 +4053,13 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); }
break;
case 210: /* cmd ::= SHOW CREATE DATABASE db_name */
-{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy209); }
break;
case 211: /* cmd ::= SHOW CREATE TABLE full_table_name */
-{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy272); }
break;
case 212: /* cmd ::= SHOW CREATE STABLE full_table_name */
-{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy272); }
break;
case 213: /* cmd ::= SHOW QUERIES */
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); }
@@ -4142,7 +4092,7 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); }
break;
case 223: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
-{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy272); }
break;
case 224: /* cmd ::= SHOW CONSUMERS */
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); }
@@ -4151,713 +4101,711 @@ static YYACTIONTYPE yy_reduce(
{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); }
break;
case 226: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
-{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); }
+{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy272, yymsp[-1].minor.yy272, OP_TYPE_EQUAL); }
break;
case 227: /* db_name_cond_opt ::= */
case 232: /* from_db_opt ::= */ yytestcase(yyruleno==232);
-{ yymsp[1].minor.yy840 = createDefaultDatabaseCondValue(pCxt); }
+{ yymsp[1].minor.yy272 = createDefaultDatabaseCondValue(pCxt); }
break;
case 228: /* db_name_cond_opt ::= db_name NK_DOT */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy617); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy209); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
case 229: /* like_pattern_opt ::= */
- case 268: /* into_opt ::= */ yytestcase(yyruleno==268);
- case 406: /* from_clause_opt ::= */ yytestcase(yyruleno==406);
- case 435: /* where_clause_opt ::= */ yytestcase(yyruleno==435);
- case 439: /* twindow_clause_opt ::= */ yytestcase(yyruleno==439);
- case 444: /* sliding_opt ::= */ yytestcase(yyruleno==444);
- case 446: /* fill_opt ::= */ yytestcase(yyruleno==446);
- case 458: /* having_clause_opt ::= */ yytestcase(yyruleno==458);
- case 460: /* range_opt ::= */ yytestcase(yyruleno==460);
- case 462: /* every_opt ::= */ yytestcase(yyruleno==462);
- case 472: /* slimit_clause_opt ::= */ yytestcase(yyruleno==472);
- case 476: /* limit_clause_opt ::= */ yytestcase(yyruleno==476);
-{ yymsp[1].minor.yy840 = NULL; }
+ case 404: /* from_clause_opt ::= */ yytestcase(yyruleno==404);
+ case 433: /* where_clause_opt ::= */ yytestcase(yyruleno==433);
+ case 437: /* twindow_clause_opt ::= */ yytestcase(yyruleno==437);
+ case 442: /* sliding_opt ::= */ yytestcase(yyruleno==442);
+ case 444: /* fill_opt ::= */ yytestcase(yyruleno==444);
+ case 456: /* having_clause_opt ::= */ yytestcase(yyruleno==456);
+ case 458: /* range_opt ::= */ yytestcase(yyruleno==458);
+ case 460: /* every_opt ::= */ yytestcase(yyruleno==460);
+ case 470: /* slimit_clause_opt ::= */ yytestcase(yyruleno==470);
+ case 474: /* limit_clause_opt ::= */ yytestcase(yyruleno==474);
+{ yymsp[1].minor.yy272 = NULL; }
break;
case 230: /* like_pattern_opt ::= LIKE NK_STRING */
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
break;
case 231: /* table_name_cond ::= table_name */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy617); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy209); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
case 233: /* from_db_opt ::= FROM db_name */
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy617); }
+{ yymsp[-1].minor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy209); }
break;
case 234: /* cmd ::= CREATE SMA INDEX not_exists_opt full_table_name ON full_table_name index_options */
-{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy313, yymsp[-3].minor.yy840, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy293, yymsp[-3].minor.yy272, yymsp[-1].minor.yy272, NULL, yymsp[0].minor.yy272); }
break;
case 235: /* cmd ::= DROP INDEX exists_opt full_table_name */
-{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy293, yymsp[0].minor.yy272); }
break;
case 236: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
-{ yymsp[-9].minor.yy840 = createIndexOption(pCxt, yymsp[-7].minor.yy544, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
+{ yymsp[-9].minor.yy272 = createIndexOption(pCxt, yymsp[-7].minor.yy172, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), NULL, yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
break;
case 237: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
-{ yymsp[-11].minor.yy840 = createIndexOption(pCxt, yymsp[-9].minor.yy544, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
+{ yymsp[-11].minor.yy272 = createIndexOption(pCxt, yymsp[-9].minor.yy172, releaseRawExprNode(pCxt, yymsp[-5].minor.yy272), releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
break;
case 240: /* func ::= function_name NK_LP expression_list NK_RP */
-{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[-3].minor.yy617, yymsp[-1].minor.yy544); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = createFunctionNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-1].minor.yy172); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
case 241: /* sma_stream_opt ::= */
- case 270: /* stream_options ::= */ yytestcase(yyruleno==270);
-{ yymsp[1].minor.yy840 = createStreamOptions(pCxt); }
+ case 268: /* stream_options ::= */ yytestcase(yyruleno==268);
+{ yymsp[1].minor.yy272 = createStreamOptions(pCxt); }
break;
case 242: /* sma_stream_opt ::= stream_options WATERMARK duration_literal */
- case 274: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==274);
-{ ((SStreamOptions*)yymsp[-2].minor.yy840)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 272: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==272);
+{ ((SStreamOptions*)yymsp[-2].minor.yy272)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy272); yylhsminor.yy272 = yymsp[-2].minor.yy272; }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 243: /* sma_stream_opt ::= stream_options MAX_DELAY duration_literal */
-{ ((SStreamOptions*)yymsp[-2].minor.yy840)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ ((SStreamOptions*)yymsp[-2].minor.yy272)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy272); yylhsminor.yy272 = yymsp[-2].minor.yy272; }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 244: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
-{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy617, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy293, &yymsp[-2].minor.yy209, yymsp[0].minor.yy272); }
break;
case 245: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
-{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy313, &yymsp[-3].minor.yy617, &yymsp[0].minor.yy617, false); }
+{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy293, &yymsp[-3].minor.yy209, &yymsp[0].minor.yy209, false); }
break;
case 246: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */
-{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-6].minor.yy313, &yymsp[-5].minor.yy617, &yymsp[0].minor.yy617, true); }
+{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-6].minor.yy293, &yymsp[-5].minor.yy209, &yymsp[0].minor.yy209, true); }
break;
case 247: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
-{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-4].minor.yy313, &yymsp[-3].minor.yy617, yymsp[0].minor.yy840, false); }
+{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-4].minor.yy293, &yymsp[-3].minor.yy209, yymsp[0].minor.yy272, false); }
break;
case 248: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */
-{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-6].minor.yy313, &yymsp[-5].minor.yy617, yymsp[0].minor.yy840, true); }
+{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-6].minor.yy293, &yymsp[-5].minor.yy209, yymsp[0].minor.yy272, true); }
break;
case 249: /* cmd ::= DROP TOPIC exists_opt topic_name */
-{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy293, &yymsp[0].minor.yy209); }
break;
case 250: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
-{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy293, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209); }
break;
case 251: /* cmd ::= DESC full_table_name */
case 252: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==252);
-{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy272); }
break;
case 253: /* cmd ::= RESET QUERY CACHE */
{ pCxt->pRootNode = createResetQueryCacheStmt(pCxt); }
break;
case 254: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */
-{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy313, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
+{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy293, yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
break;
case 256: /* analyze_opt ::= ANALYZE */
case 263: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==263);
- case 426: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==426);
-{ yymsp[0].minor.yy313 = true; }
+ case 424: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==424);
+{ yymsp[0].minor.yy293 = true; }
break;
case 257: /* explain_options ::= */
-{ yymsp[1].minor.yy840 = createDefaultExplainOptions(pCxt); }
+{ yymsp[1].minor.yy272 = createDefaultExplainOptions(pCxt); }
break;
case 258: /* explain_options ::= explain_options VERBOSE NK_BOOL */
-{ yylhsminor.yy840 = setExplainVerbose(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setExplainVerbose(pCxt, yymsp[-2].minor.yy272, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 259: /* explain_options ::= explain_options RATIO NK_FLOAT */
-{ yylhsminor.yy840 = setExplainRatio(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy272 = setExplainRatio(pCxt, yymsp[-2].minor.yy272, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
case 260: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
-{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy313, yymsp[-8].minor.yy313, &yymsp[-5].minor.yy617, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy784, yymsp[0].minor.yy844); }
+{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy293, yymsp[-8].minor.yy293, &yymsp[-5].minor.yy209, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy616, yymsp[0].minor.yy232); }
break;
case 261: /* cmd ::= DROP FUNCTION exists_opt function_name */
-{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy293, &yymsp[0].minor.yy209); }
break;
case 264: /* bufsize_opt ::= */
-{ yymsp[1].minor.yy844 = 0; }
+{ yymsp[1].minor.yy232 = 0; }
break;
case 265: /* bufsize_opt ::= BUFSIZE NK_INTEGER */
-{ yymsp[-1].minor.yy844 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy232 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); }
break;
- case 266: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
-{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-5].minor.yy313, &yymsp[-4].minor.yy617, yymsp[-2].minor.yy840, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); }
+ case 266: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name AS query_expression */
+{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-6].minor.yy293, &yymsp[-5].minor.yy209, yymsp[-2].minor.yy272, yymsp[-4].minor.yy272, yymsp[0].minor.yy272); }
break;
case 267: /* cmd ::= DROP STREAM exists_opt stream_name */
-{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy617); }
+{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy293, &yymsp[0].minor.yy209); }
break;
- case 269: /* into_opt ::= INTO full_table_name */
- case 407: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==407);
- case 436: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==436);
- case 459: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==459);
-{ yymsp[-1].minor.yy840 = yymsp[0].minor.yy840; }
+ case 269: /* stream_options ::= stream_options TRIGGER AT_ONCE */
+{ ((SStreamOptions*)yymsp[-2].minor.yy272)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy272 = yymsp[-2].minor.yy272; }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 271: /* stream_options ::= stream_options TRIGGER AT_ONCE */
-{ ((SStreamOptions*)yymsp[-2].minor.yy840)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy840 = yymsp[-2].minor.yy840; }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 270: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+{ ((SStreamOptions*)yymsp[-2].minor.yy272)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy272 = yymsp[-2].minor.yy272; }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 272: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
-{ ((SStreamOptions*)yymsp[-2].minor.yy840)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy840 = yymsp[-2].minor.yy840; }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 271: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
+{ ((SStreamOptions*)yymsp[-3].minor.yy272)->triggerType = STREAM_TRIGGER_MAX_DELAY; ((SStreamOptions*)yymsp[-3].minor.yy272)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy272); yylhsminor.yy272 = yymsp[-3].minor.yy272; }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 273: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
-{ ((SStreamOptions*)yymsp[-3].minor.yy840)->triggerType = STREAM_TRIGGER_MAX_DELAY; ((SStreamOptions*)yymsp[-3].minor.yy840)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-3].minor.yy840; }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ case 273: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
+{ ((SStreamOptions*)yymsp[-3].minor.yy272)->ignoreExpired = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy272 = yymsp[-3].minor.yy272; }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 275: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
-{ ((SStreamOptions*)yymsp[-3].minor.yy840)->ignoreExpired = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy840 = yymsp[-3].minor.yy840; }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
- break;
- case 276: /* cmd ::= KILL CONNECTION NK_INTEGER */
+ case 274: /* cmd ::= KILL CONNECTION NK_INTEGER */
{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); }
break;
- case 277: /* cmd ::= KILL QUERY NK_STRING */
+ case 275: /* cmd ::= KILL QUERY NK_STRING */
{ pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); }
break;
- case 278: /* cmd ::= KILL TRANSACTION NK_INTEGER */
+ case 276: /* cmd ::= KILL TRANSACTION NK_INTEGER */
{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); }
break;
- case 279: /* cmd ::= BALANCE VGROUP */
+ case 277: /* cmd ::= BALANCE VGROUP */
{ pCxt->pRootNode = createBalanceVgroupStmt(pCxt); }
break;
- case 280: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+ case 278: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
{ pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 281: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy544); }
+ case 279: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy172); }
break;
- case 282: /* cmd ::= SPLIT VGROUP NK_INTEGER */
+ case 280: /* cmd ::= SPLIT VGROUP NK_INTEGER */
{ pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); }
break;
- case 283: /* dnode_list ::= DNODE NK_INTEGER */
-{ yymsp[-1].minor.yy544 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
- break;
- case 285: /* cmd ::= DELETE FROM full_table_name where_clause_opt */
-{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
- break;
- case 287: /* cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */
-{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-4].minor.yy840, yymsp[-2].minor.yy544, yymsp[0].minor.yy840); }
- break;
- case 288: /* cmd ::= INSERT INTO full_table_name query_expression */
-{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); }
- break;
- case 289: /* literal ::= NK_INTEGER */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 290: /* literal ::= NK_FLOAT */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 291: /* literal ::= NK_STRING */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 292: /* literal ::= NK_BOOL */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 293: /* literal ::= TIMESTAMP NK_STRING */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
- break;
- case 294: /* literal ::= duration_literal */
- case 304: /* signed_literal ::= signed */ yytestcase(yyruleno==304);
- case 324: /* expression ::= literal */ yytestcase(yyruleno==324);
- case 325: /* expression ::= pseudo_column */ yytestcase(yyruleno==325);
- case 326: /* expression ::= column_reference */ yytestcase(yyruleno==326);
- case 327: /* expression ::= function_expression */ yytestcase(yyruleno==327);
- case 328: /* expression ::= subquery */ yytestcase(yyruleno==328);
- case 356: /* function_expression ::= literal_func */ yytestcase(yyruleno==356);
- case 398: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==398);
- case 402: /* boolean_primary ::= predicate */ yytestcase(yyruleno==402);
- case 404: /* common_expression ::= expression */ yytestcase(yyruleno==404);
- case 405: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==405);
- case 408: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==408);
- case 410: /* table_reference ::= table_primary */ yytestcase(yyruleno==410);
- case 411: /* table_reference ::= joined_table */ yytestcase(yyruleno==411);
- case 415: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==415);
- case 465: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==465);
- case 468: /* query_primary ::= query_specification */ yytestcase(yyruleno==468);
-{ yylhsminor.yy840 = yymsp[0].minor.yy840; }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 295: /* literal ::= NULL */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 296: /* literal ::= NK_QUESTION */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 297: /* duration_literal ::= NK_VARIABLE */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 298: /* signed ::= NK_INTEGER */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 299: /* signed ::= NK_PLUS NK_INTEGER */
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
- break;
- case 300: /* signed ::= NK_MINUS NK_INTEGER */
+ case 281: /* dnode_list ::= DNODE NK_INTEGER */
+{ yymsp[-1].minor.yy172 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+ break;
+ case 283: /* cmd ::= DELETE FROM full_table_name where_clause_opt */
+{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
+ break;
+ case 285: /* cmd ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_expression */
+{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-4].minor.yy272, yymsp[-2].minor.yy172, yymsp[0].minor.yy272); }
+ break;
+ case 286: /* cmd ::= INSERT INTO full_table_name query_expression */
+{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-1].minor.yy272, NULL, yymsp[0].minor.yy272); }
+ break;
+ case 287: /* literal ::= NK_INTEGER */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 288: /* literal ::= NK_FLOAT */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 289: /* literal ::= NK_STRING */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 290: /* literal ::= NK_BOOL */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 291: /* literal ::= TIMESTAMP NK_STRING */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 292: /* literal ::= duration_literal */
+ case 302: /* signed_literal ::= signed */ yytestcase(yyruleno==302);
+ case 322: /* expression ::= literal */ yytestcase(yyruleno==322);
+ case 323: /* expression ::= pseudo_column */ yytestcase(yyruleno==323);
+ case 324: /* expression ::= column_reference */ yytestcase(yyruleno==324);
+ case 325: /* expression ::= function_expression */ yytestcase(yyruleno==325);
+ case 326: /* expression ::= subquery */ yytestcase(yyruleno==326);
+ case 354: /* function_expression ::= literal_func */ yytestcase(yyruleno==354);
+ case 396: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==396);
+ case 400: /* boolean_primary ::= predicate */ yytestcase(yyruleno==400);
+ case 402: /* common_expression ::= expression */ yytestcase(yyruleno==402);
+ case 403: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==403);
+ case 406: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==406);
+ case 408: /* table_reference ::= table_primary */ yytestcase(yyruleno==408);
+ case 409: /* table_reference ::= joined_table */ yytestcase(yyruleno==409);
+ case 413: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==413);
+ case 463: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==463);
+ case 466: /* query_primary ::= query_specification */ yytestcase(yyruleno==466);
+{ yylhsminor.yy272 = yymsp[0].minor.yy272; }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 293: /* literal ::= NULL */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 294: /* literal ::= NK_QUESTION */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 295: /* duration_literal ::= NK_VARIABLE */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 296: /* signed ::= NK_INTEGER */
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 297: /* signed ::= NK_PLUS NK_INTEGER */
+{ yymsp[-1].minor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
+ break;
+ case 298: /* signed ::= NK_MINUS NK_INTEGER */
{
SToken t = yymsp[-1].minor.yy0;
t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
- yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t);
+ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t);
}
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 301: /* signed ::= NK_FLOAT */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 299: /* signed ::= NK_FLOAT */
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 302: /* signed ::= NK_PLUS NK_FLOAT */
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
+ case 300: /* signed ::= NK_PLUS NK_FLOAT */
+{ yymsp[-1].minor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
break;
- case 303: /* signed ::= NK_MINUS NK_FLOAT */
+ case 301: /* signed ::= NK_MINUS NK_FLOAT */
{
SToken t = yymsp[-1].minor.yy0;
t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
- yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t);
+ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t);
}
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 305: /* signed_literal ::= NK_STRING */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 303: /* signed_literal ::= NK_STRING */
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 306: /* signed_literal ::= NK_BOOL */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 304: /* signed_literal ::= NK_BOOL */
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 307: /* signed_literal ::= TIMESTAMP NK_STRING */
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
+ case 305: /* signed_literal ::= TIMESTAMP NK_STRING */
+{ yymsp[-1].minor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
break;
- case 308: /* signed_literal ::= duration_literal */
- case 310: /* signed_literal ::= literal_func */ yytestcase(yyruleno==310);
- case 376: /* star_func_para ::= expression */ yytestcase(yyruleno==376);
- case 431: /* select_item ::= common_expression */ yytestcase(yyruleno==431);
- case 481: /* search_condition ::= common_expression */ yytestcase(yyruleno==481);
-{ yylhsminor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 306: /* signed_literal ::= duration_literal */
+ case 308: /* signed_literal ::= literal_func */ yytestcase(yyruleno==308);
+ case 374: /* star_func_para ::= expression */ yytestcase(yyruleno==374);
+ case 429: /* select_item ::= common_expression */ yytestcase(yyruleno==429);
+ case 479: /* search_condition ::= common_expression */ yytestcase(yyruleno==479);
+{ yylhsminor.yy272 = releaseRawExprNode(pCxt, yymsp[0].minor.yy272); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 309: /* signed_literal ::= NULL */
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 307: /* signed_literal ::= NULL */
+{ yylhsminor.yy272 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 311: /* signed_literal ::= NK_QUESTION */
-{ yylhsminor.yy840 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 309: /* signed_literal ::= NK_QUESTION */
+{ yylhsminor.yy272 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 329: /* expression ::= NK_LP expression NK_RP */
- case 403: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==403);
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 327: /* expression ::= NK_LP expression NK_RP */
+ case 401: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==401);
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy272)); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 330: /* expression ::= NK_PLUS expression */
+ case 328: /* expression ::= NK_PLUS expression */
{
- SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy840));
+ SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy272));
}
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 331: /* expression ::= NK_MINUS expression */
+ case 329: /* expression ::= NK_MINUS expression */
{
- SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL));
+ SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy272), NULL));
}
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 332: /* expression ::= expression NK_PLUS expression */
+ case 330: /* expression ::= expression NK_PLUS expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 333: /* expression ::= expression NK_MINUS expression */
+ case 331: /* expression ::= expression NK_MINUS expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 334: /* expression ::= expression NK_STAR expression */
+ case 332: /* expression ::= expression NK_STAR expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 335: /* expression ::= expression NK_SLASH expression */
+ case 333: /* expression ::= expression NK_SLASH expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 336: /* expression ::= expression NK_REM expression */
+ case 334: /* expression ::= expression NK_REM expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 337: /* expression ::= column_reference NK_ARROW NK_STRING */
+ case 335: /* expression ::= column_reference NK_ARROW NK_STRING */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 338: /* expression ::= expression NK_BITAND expression */
+ case 336: /* expression ::= expression NK_BITAND expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 339: /* expression ::= expression NK_BITOR expression */
+ case 337: /* expression ::= expression NK_BITOR expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
- break;
- case 342: /* column_reference ::= column_name */
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy617, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy617)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 343: /* column_reference ::= table_name NK_DOT column_name */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617, createColumnNode(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy617)); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
- break;
- case 344: /* pseudo_column ::= ROWTS */
- case 345: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==345);
- case 347: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==347);
- case 348: /* pseudo_column ::= QEND */ yytestcase(yyruleno==348);
- case 349: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==349);
- case 350: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==350);
- case 351: /* pseudo_column ::= WEND */ yytestcase(yyruleno==351);
- case 352: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==352);
- case 358: /* literal_func ::= NOW */ yytestcase(yyruleno==358);
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
- break;
- case 346: /* pseudo_column ::= table_name NK_DOT TBNAME */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy617)))); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
- break;
- case 353: /* function_expression ::= function_name NK_LP expression_list NK_RP */
- case 354: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==354);
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy617, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy617, yymsp[-1].minor.yy544)); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
- break;
- case 355: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy784)); }
- yymsp[-5].minor.yy840 = yylhsminor.yy840;
- break;
- case 357: /* literal_func ::= noarg_func NK_LP NK_RP */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy617, NULL)); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
- break;
- case 372: /* star_func_para_list ::= NK_STAR */
-{ yylhsminor.yy544 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
- break;
- case 377: /* star_func_para ::= table_name NK_DOT NK_STAR */
- case 434: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==434);
-{ yylhsminor.yy840 = createColumnNode(pCxt, &yymsp[-2].minor.yy617, &yymsp[0].minor.yy0); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
- break;
- case 378: /* predicate ::= expression compare_op expression */
- case 383: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==383);
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 340: /* column_reference ::= column_name */
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy209, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy209)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 341: /* column_reference ::= table_name NK_DOT column_name */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209, createColumnNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy209)); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 342: /* pseudo_column ::= ROWTS */
+ case 343: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==343);
+ case 345: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==345);
+ case 346: /* pseudo_column ::= QEND */ yytestcase(yyruleno==346);
+ case 347: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==347);
+ case 348: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==348);
+ case 349: /* pseudo_column ::= WEND */ yytestcase(yyruleno==349);
+ case 350: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==350);
+ case 356: /* literal_func ::= NOW */ yytestcase(yyruleno==356);
+{ yylhsminor.yy272 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 344: /* pseudo_column ::= table_name NK_DOT TBNAME */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy209)))); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 351: /* function_expression ::= function_name NK_LP expression_list NK_RP */
+ case 352: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==352);
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy209, yymsp[-1].minor.yy172)); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 353: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), yymsp[-1].minor.yy616)); }
+ yymsp[-5].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 355: /* literal_func ::= noarg_func NK_LP NK_RP */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy209, NULL)); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 370: /* star_func_para_list ::= NK_STAR */
+{ yylhsminor.yy172 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
+ break;
+ case 375: /* star_func_para ::= table_name NK_DOT NK_STAR */
+ case 432: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==432);
+{ yylhsminor.yy272 = createColumnNode(pCxt, &yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 376: /* predicate ::= expression compare_op expression */
+ case 381: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==381);
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy198, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy392, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 379: /* predicate ::= expression BETWEEN expression AND expression */
+ case 377: /* predicate ::= expression BETWEEN expression AND expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy272), releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-4].minor.yy840 = yylhsminor.yy840;
+ yymsp[-4].minor.yy272 = yylhsminor.yy272;
break;
- case 380: /* predicate ::= expression NOT BETWEEN expression AND expression */
+ case 378: /* predicate ::= expression NOT BETWEEN expression AND expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy272), releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-5].minor.yy840 = yylhsminor.yy840;
+ yymsp[-5].minor.yy272 = yylhsminor.yy272;
break;
- case 381: /* predicate ::= expression IS NULL */
+ case 379: /* predicate ::= expression IS NULL */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), NULL));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), NULL));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 382: /* predicate ::= expression IS NOT NULL */
+ case 380: /* predicate ::= expression IS NOT NULL */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), NULL));
}
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 384: /* compare_op ::= NK_LT */
-{ yymsp[0].minor.yy198 = OP_TYPE_LOWER_THAN; }
+ case 382: /* compare_op ::= NK_LT */
+{ yymsp[0].minor.yy392 = OP_TYPE_LOWER_THAN; }
break;
- case 385: /* compare_op ::= NK_GT */
-{ yymsp[0].minor.yy198 = OP_TYPE_GREATER_THAN; }
+ case 383: /* compare_op ::= NK_GT */
+{ yymsp[0].minor.yy392 = OP_TYPE_GREATER_THAN; }
break;
- case 386: /* compare_op ::= NK_LE */
-{ yymsp[0].minor.yy198 = OP_TYPE_LOWER_EQUAL; }
+ case 384: /* compare_op ::= NK_LE */
+{ yymsp[0].minor.yy392 = OP_TYPE_LOWER_EQUAL; }
break;
- case 387: /* compare_op ::= NK_GE */
-{ yymsp[0].minor.yy198 = OP_TYPE_GREATER_EQUAL; }
+ case 385: /* compare_op ::= NK_GE */
+{ yymsp[0].minor.yy392 = OP_TYPE_GREATER_EQUAL; }
break;
- case 388: /* compare_op ::= NK_NE */
-{ yymsp[0].minor.yy198 = OP_TYPE_NOT_EQUAL; }
+ case 386: /* compare_op ::= NK_NE */
+{ yymsp[0].minor.yy392 = OP_TYPE_NOT_EQUAL; }
break;
- case 389: /* compare_op ::= NK_EQ */
-{ yymsp[0].minor.yy198 = OP_TYPE_EQUAL; }
+ case 387: /* compare_op ::= NK_EQ */
+{ yymsp[0].minor.yy392 = OP_TYPE_EQUAL; }
break;
- case 390: /* compare_op ::= LIKE */
-{ yymsp[0].minor.yy198 = OP_TYPE_LIKE; }
+ case 388: /* compare_op ::= LIKE */
+{ yymsp[0].minor.yy392 = OP_TYPE_LIKE; }
break;
- case 391: /* compare_op ::= NOT LIKE */
-{ yymsp[-1].minor.yy198 = OP_TYPE_NOT_LIKE; }
+ case 389: /* compare_op ::= NOT LIKE */
+{ yymsp[-1].minor.yy392 = OP_TYPE_NOT_LIKE; }
break;
- case 392: /* compare_op ::= MATCH */
-{ yymsp[0].minor.yy198 = OP_TYPE_MATCH; }
+ case 390: /* compare_op ::= MATCH */
+{ yymsp[0].minor.yy392 = OP_TYPE_MATCH; }
break;
- case 393: /* compare_op ::= NMATCH */
-{ yymsp[0].minor.yy198 = OP_TYPE_NMATCH; }
+ case 391: /* compare_op ::= NMATCH */
+{ yymsp[0].minor.yy392 = OP_TYPE_NMATCH; }
break;
- case 394: /* compare_op ::= CONTAINS */
-{ yymsp[0].minor.yy198 = OP_TYPE_JSON_CONTAINS; }
+ case 392: /* compare_op ::= CONTAINS */
+{ yymsp[0].minor.yy392 = OP_TYPE_JSON_CONTAINS; }
break;
- case 395: /* in_op ::= IN */
-{ yymsp[0].minor.yy198 = OP_TYPE_IN; }
+ case 393: /* in_op ::= IN */
+{ yymsp[0].minor.yy392 = OP_TYPE_IN; }
break;
- case 396: /* in_op ::= NOT IN */
-{ yymsp[-1].minor.yy198 = OP_TYPE_NOT_IN; }
+ case 394: /* in_op ::= NOT IN */
+{ yymsp[-1].minor.yy392 = OP_TYPE_NOT_IN; }
break;
- case 397: /* in_predicate_value ::= NK_LP literal_list NK_RP */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy544)); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 395: /* in_predicate_value ::= NK_LP literal_list NK_RP */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy172)); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 399: /* boolean_value_expression ::= NOT boolean_primary */
+ case 397: /* boolean_value_expression ::= NOT boolean_primary */
{
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL));
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy272), NULL));
}
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 400: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+ case 398: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 401: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+ case 399: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
{
- SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
- SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
- yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
+ SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy272);
+ SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy272);
+ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), releaseRawExprNode(pCxt, yymsp[0].minor.yy272)));
}
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
+ break;
+ case 405: /* from_clause_opt ::= FROM table_reference_list */
+ case 434: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==434);
+ case 457: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==457);
+{ yymsp[-1].minor.yy272 = yymsp[0].minor.yy272; }
break;
- case 409: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
-{ yylhsminor.yy840 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, NULL); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 407: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
+{ yylhsminor.yy272 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy272, yymsp[0].minor.yy272, NULL); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 412: /* table_primary ::= table_name alias_opt */
-{ yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy617, &yymsp[0].minor.yy617); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ case 410: /* table_primary ::= table_name alias_opt */
+{ yylhsminor.yy272 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 413: /* table_primary ::= db_name NK_DOT table_name alias_opt */
-{ yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-3].minor.yy617, &yymsp[-1].minor.yy617, &yymsp[0].minor.yy617); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ case 411: /* table_primary ::= db_name NK_DOT table_name alias_opt */
+{ yylhsminor.yy272 = createRealTableNode(pCxt, &yymsp[-3].minor.yy209, &yymsp[-1].minor.yy209, &yymsp[0].minor.yy209); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 414: /* table_primary ::= subquery alias_opt */
-{ yylhsminor.yy840 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy617); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ case 412: /* table_primary ::= subquery alias_opt */
+{ yylhsminor.yy272 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy272), &yymsp[0].minor.yy209); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 416: /* alias_opt ::= */
-{ yymsp[1].minor.yy617 = nil_token; }
+ case 414: /* alias_opt ::= */
+{ yymsp[1].minor.yy209 = nil_token; }
break;
- case 417: /* alias_opt ::= table_alias */
-{ yylhsminor.yy617 = yymsp[0].minor.yy617; }
- yymsp[0].minor.yy617 = yylhsminor.yy617;
+ case 415: /* alias_opt ::= table_alias */
+{ yylhsminor.yy209 = yymsp[0].minor.yy209; }
+ yymsp[0].minor.yy209 = yylhsminor.yy209;
break;
- case 418: /* alias_opt ::= AS table_alias */
-{ yymsp[-1].minor.yy617 = yymsp[0].minor.yy617; }
+ case 416: /* alias_opt ::= AS table_alias */
+{ yymsp[-1].minor.yy209 = yymsp[0].minor.yy209; }
break;
- case 419: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
- case 420: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==420);
-{ yymsp[-2].minor.yy840 = yymsp[-1].minor.yy840; }
+ case 417: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+ case 418: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==418);
+{ yymsp[-2].minor.yy272 = yymsp[-1].minor.yy272; }
break;
- case 421: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-{ yylhsminor.yy840 = createJoinTableNode(pCxt, yymsp[-4].minor.yy708, yymsp[-5].minor.yy840, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); }
- yymsp[-5].minor.yy840 = yylhsminor.yy840;
+ case 419: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+{ yylhsminor.yy272 = createJoinTableNode(pCxt, yymsp[-4].minor.yy156, yymsp[-5].minor.yy272, yymsp[-2].minor.yy272, yymsp[0].minor.yy272); }
+ yymsp[-5].minor.yy272 = yylhsminor.yy272;
break;
- case 422: /* join_type ::= */
-{ yymsp[1].minor.yy708 = JOIN_TYPE_INNER; }
+ case 420: /* join_type ::= */
+{ yymsp[1].minor.yy156 = JOIN_TYPE_INNER; }
break;
- case 423: /* join_type ::= INNER */
-{ yymsp[0].minor.yy708 = JOIN_TYPE_INNER; }
+ case 421: /* join_type ::= INNER */
+{ yymsp[0].minor.yy156 = JOIN_TYPE_INNER; }
break;
- case 424: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+ case 422: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
{
- yymsp[-11].minor.yy840 = createSelectStmt(pCxt, yymsp[-10].minor.yy313, yymsp[-9].minor.yy544, yymsp[-8].minor.yy840);
- yymsp[-11].minor.yy840 = addWhereClause(pCxt, yymsp[-11].minor.yy840, yymsp[-7].minor.yy840);
- yymsp[-11].minor.yy840 = addPartitionByClause(pCxt, yymsp[-11].minor.yy840, yymsp[-6].minor.yy544);
- yymsp[-11].minor.yy840 = addWindowClauseClause(pCxt, yymsp[-11].minor.yy840, yymsp[-2].minor.yy840);
- yymsp[-11].minor.yy840 = addGroupByClause(pCxt, yymsp[-11].minor.yy840, yymsp[-1].minor.yy544);
- yymsp[-11].minor.yy840 = addHavingClause(pCxt, yymsp[-11].minor.yy840, yymsp[0].minor.yy840);
- yymsp[-11].minor.yy840 = addRangeClause(pCxt, yymsp[-11].minor.yy840, yymsp[-5].minor.yy840);
- yymsp[-11].minor.yy840 = addEveryClause(pCxt, yymsp[-11].minor.yy840, yymsp[-4].minor.yy840);
- yymsp[-11].minor.yy840 = addFillClause(pCxt, yymsp[-11].minor.yy840, yymsp[-3].minor.yy840);
+ yymsp[-11].minor.yy272 = createSelectStmt(pCxt, yymsp[-10].minor.yy293, yymsp[-9].minor.yy172, yymsp[-8].minor.yy272);
+ yymsp[-11].minor.yy272 = addWhereClause(pCxt, yymsp[-11].minor.yy272, yymsp[-7].minor.yy272);
+ yymsp[-11].minor.yy272 = addPartitionByClause(pCxt, yymsp[-11].minor.yy272, yymsp[-6].minor.yy172);
+ yymsp[-11].minor.yy272 = addWindowClauseClause(pCxt, yymsp[-11].minor.yy272, yymsp[-2].minor.yy272);
+ yymsp[-11].minor.yy272 = addGroupByClause(pCxt, yymsp[-11].minor.yy272, yymsp[-1].minor.yy172);
+ yymsp[-11].minor.yy272 = addHavingClause(pCxt, yymsp[-11].minor.yy272, yymsp[0].minor.yy272);
+ yymsp[-11].minor.yy272 = addRangeClause(pCxt, yymsp[-11].minor.yy272, yymsp[-5].minor.yy272);
+ yymsp[-11].minor.yy272 = addEveryClause(pCxt, yymsp[-11].minor.yy272, yymsp[-4].minor.yy272);
+ yymsp[-11].minor.yy272 = addFillClause(pCxt, yymsp[-11].minor.yy272, yymsp[-3].minor.yy272);
}
break;
- case 427: /* set_quantifier_opt ::= ALL */
-{ yymsp[0].minor.yy313 = false; }
+ case 425: /* set_quantifier_opt ::= ALL */
+{ yymsp[0].minor.yy293 = false; }
break;
- case 430: /* select_item ::= NK_STAR */
-{ yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy840 = yylhsminor.yy840;
+ case 428: /* select_item ::= NK_STAR */
+{ yylhsminor.yy272 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy272 = yylhsminor.yy272;
break;
- case 432: /* select_item ::= common_expression column_alias */
-{ yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy617); }
- yymsp[-1].minor.yy840 = yylhsminor.yy840;
+ case 430: /* select_item ::= common_expression column_alias */
+{ yylhsminor.yy272 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy272), &yymsp[0].minor.yy209); }
+ yymsp[-1].minor.yy272 = yylhsminor.yy272;
break;
- case 433: /* select_item ::= common_expression AS column_alias */
-{ yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), &yymsp[0].minor.yy617); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 431: /* select_item ::= common_expression AS column_alias */
+{ yylhsminor.yy272 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), &yymsp[0].minor.yy209); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 438: /* partition_by_clause_opt ::= PARTITION BY expression_list */
- case 455: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==455);
- case 471: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==471);
-{ yymsp[-2].minor.yy544 = yymsp[0].minor.yy544; }
+ case 436: /* partition_by_clause_opt ::= PARTITION BY expression_list */
+ case 453: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==453);
+ case 469: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==469);
+{ yymsp[-2].minor.yy172 = yymsp[0].minor.yy172; }
break;
- case 440: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-{ yymsp[-5].minor.yy840 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
+ case 438: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+{ yymsp[-5].minor.yy272 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), releaseRawExprNode(pCxt, yymsp[-1].minor.yy272)); }
break;
- case 441: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-{ yymsp[-3].minor.yy840 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
+ case 439: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+{ yymsp[-3].minor.yy272 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy272)); }
break;
- case 442: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-{ yymsp[-5].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
+ case 440: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+{ yymsp[-5].minor.yy272 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), NULL, yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
break;
- case 443: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-{ yymsp[-7].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
+ case 441: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+{ yymsp[-7].minor.yy272 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy272), releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), yymsp[-1].minor.yy272, yymsp[0].minor.yy272); }
break;
- case 445: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
- case 463: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==463);
-{ yymsp[-3].minor.yy840 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy840); }
+ case 443: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+ case 461: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==461);
+{ yymsp[-3].minor.yy272 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy272); }
break;
- case 447: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
-{ yymsp[-3].minor.yy840 = createFillNode(pCxt, yymsp[-1].minor.yy816, NULL); }
+ case 445: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
+{ yymsp[-3].minor.yy272 = createFillNode(pCxt, yymsp[-1].minor.yy186, NULL); }
break;
- case 448: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-{ yymsp[-5].minor.yy840 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy544)); }
+ case 446: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+{ yymsp[-5].minor.yy272 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy172)); }
break;
- case 449: /* fill_mode ::= NONE */
-{ yymsp[0].minor.yy816 = FILL_MODE_NONE; }
+ case 447: /* fill_mode ::= NONE */
+{ yymsp[0].minor.yy186 = FILL_MODE_NONE; }
break;
- case 450: /* fill_mode ::= PREV */
-{ yymsp[0].minor.yy816 = FILL_MODE_PREV; }
+ case 448: /* fill_mode ::= PREV */
+{ yymsp[0].minor.yy186 = FILL_MODE_PREV; }
break;
- case 451: /* fill_mode ::= NULL */
-{ yymsp[0].minor.yy816 = FILL_MODE_NULL; }
+ case 449: /* fill_mode ::= NULL */
+{ yymsp[0].minor.yy186 = FILL_MODE_NULL; }
break;
- case 452: /* fill_mode ::= LINEAR */
-{ yymsp[0].minor.yy816 = FILL_MODE_LINEAR; }
+ case 450: /* fill_mode ::= LINEAR */
+{ yymsp[0].minor.yy186 = FILL_MODE_LINEAR; }
break;
- case 453: /* fill_mode ::= NEXT */
-{ yymsp[0].minor.yy816 = FILL_MODE_NEXT; }
+ case 451: /* fill_mode ::= NEXT */
+{ yymsp[0].minor.yy186 = FILL_MODE_NEXT; }
break;
- case 456: /* group_by_list ::= expression */
-{ yylhsminor.yy544 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); }
- yymsp[0].minor.yy544 = yylhsminor.yy544;
+ case 454: /* group_by_list ::= expression */
+{ yylhsminor.yy172 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy272))); }
+ yymsp[0].minor.yy172 = yylhsminor.yy172;
break;
- case 457: /* group_by_list ::= group_by_list NK_COMMA expression */
-{ yylhsminor.yy544 = addNodeToList(pCxt, yymsp[-2].minor.yy544, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); }
- yymsp[-2].minor.yy544 = yylhsminor.yy544;
+ case 455: /* group_by_list ::= group_by_list NK_COMMA expression */
+{ yylhsminor.yy172 = addNodeToList(pCxt, yymsp[-2].minor.yy172, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy272))); }
+ yymsp[-2].minor.yy172 = yylhsminor.yy172;
break;
- case 461: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
-{ yymsp[-5].minor.yy840 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
+ case 459: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+{ yymsp[-5].minor.yy272 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy272), releaseRawExprNode(pCxt, yymsp[-1].minor.yy272)); }
break;
- case 464: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+ case 462: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
{
- yylhsminor.yy840 = addOrderByClause(pCxt, yymsp[-3].minor.yy840, yymsp[-2].minor.yy544);
- yylhsminor.yy840 = addSlimitClause(pCxt, yylhsminor.yy840, yymsp[-1].minor.yy840);
- yylhsminor.yy840 = addLimitClause(pCxt, yylhsminor.yy840, yymsp[0].minor.yy840);
+ yylhsminor.yy272 = addOrderByClause(pCxt, yymsp[-3].minor.yy272, yymsp[-2].minor.yy172);
+ yylhsminor.yy272 = addSlimitClause(pCxt, yylhsminor.yy272, yymsp[-1].minor.yy272);
+ yylhsminor.yy272 = addLimitClause(pCxt, yylhsminor.yy272, yymsp[0].minor.yy272);
}
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 466: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-{ yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); }
- yymsp[-3].minor.yy840 = yylhsminor.yy840;
+ case 464: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+{ yylhsminor.yy272 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy272, yymsp[0].minor.yy272); }
+ yymsp[-3].minor.yy272 = yylhsminor.yy272;
break;
- case 467: /* query_expression_body ::= query_expression_body UNION query_expression_body */
-{ yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 465: /* query_expression_body ::= query_expression_body UNION query_expression_body */
+{ yylhsminor.yy272 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy272, yymsp[0].minor.yy272); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 469: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+ case 467: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
{
- yymsp[-5].minor.yy840 = addOrderByClause(pCxt, yymsp[-4].minor.yy840, yymsp[-3].minor.yy544);
- yymsp[-5].minor.yy840 = addSlimitClause(pCxt, yymsp[-5].minor.yy840, yymsp[-2].minor.yy840);
- yymsp[-5].minor.yy840 = addLimitClause(pCxt, yymsp[-5].minor.yy840, yymsp[-1].minor.yy840);
+ yymsp[-5].minor.yy272 = addOrderByClause(pCxt, yymsp[-4].minor.yy272, yymsp[-3].minor.yy172);
+ yymsp[-5].minor.yy272 = addSlimitClause(pCxt, yymsp[-5].minor.yy272, yymsp[-2].minor.yy272);
+ yymsp[-5].minor.yy272 = addLimitClause(pCxt, yymsp[-5].minor.yy272, yymsp[-1].minor.yy272);
}
break;
- case 473: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
- case 477: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==477);
-{ yymsp[-1].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
+ case 471: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+ case 475: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==475);
+{ yymsp[-1].minor.yy272 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
break;
- case 474: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
- case 478: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==478);
-{ yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
+ case 472: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+ case 476: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==476);
+{ yymsp[-3].minor.yy272 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 475: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
- case 479: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==479);
-{ yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
+ case 473: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+ case 477: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==477);
+{ yymsp[-3].minor.yy272 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
break;
- case 480: /* subquery ::= NK_LP query_expression NK_RP */
-{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy840); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 478: /* subquery ::= NK_LP query_expression NK_RP */
+{ yylhsminor.yy272 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy272); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 484: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-{ yylhsminor.yy840 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), yymsp[-1].minor.yy204, yymsp[0].minor.yy277); }
- yymsp[-2].minor.yy840 = yylhsminor.yy840;
+ case 482: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+{ yylhsminor.yy272 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy272), yymsp[-1].minor.yy818, yymsp[0].minor.yy493); }
+ yymsp[-2].minor.yy272 = yylhsminor.yy272;
break;
- case 485: /* ordering_specification_opt ::= */
-{ yymsp[1].minor.yy204 = ORDER_ASC; }
+ case 483: /* ordering_specification_opt ::= */
+{ yymsp[1].minor.yy818 = ORDER_ASC; }
break;
- case 486: /* ordering_specification_opt ::= ASC */
-{ yymsp[0].minor.yy204 = ORDER_ASC; }
+ case 484: /* ordering_specification_opt ::= ASC */
+{ yymsp[0].minor.yy818 = ORDER_ASC; }
break;
- case 487: /* ordering_specification_opt ::= DESC */
-{ yymsp[0].minor.yy204 = ORDER_DESC; }
+ case 485: /* ordering_specification_opt ::= DESC */
+{ yymsp[0].minor.yy818 = ORDER_DESC; }
break;
- case 488: /* null_ordering_opt ::= */
-{ yymsp[1].minor.yy277 = NULL_ORDER_DEFAULT; }
+ case 486: /* null_ordering_opt ::= */
+{ yymsp[1].minor.yy493 = NULL_ORDER_DEFAULT; }
break;
- case 489: /* null_ordering_opt ::= NULLS FIRST */
-{ yymsp[-1].minor.yy277 = NULL_ORDER_FIRST; }
+ case 487: /* null_ordering_opt ::= NULLS FIRST */
+{ yymsp[-1].minor.yy493 = NULL_ORDER_FIRST; }
break;
- case 490: /* null_ordering_opt ::= NULLS LAST */
-{ yymsp[-1].minor.yy277 = NULL_ORDER_LAST; }
+ case 488: /* null_ordering_opt ::= NULLS LAST */
+{ yymsp[-1].minor.yy493 = NULL_ORDER_LAST; }
break;
default:
break;
diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp
index 9bca6cae0a41a145237b1035c5dd1edb4fdf0cd9..68c4ac3706e2a42fd370a96a85d1adf6df162774 100644
--- a/source/libs/parser/test/parInitialCTest.cpp
+++ b/source/libs/parser/test/parInitialCTest.cpp
@@ -568,15 +568,13 @@ TEST_F(ParserInitialCTest, createStream) {
memset(&expect, 0, sizeof(SCMCreateStreamReq));
};
- auto setCreateStreamReqFunc = [&](const char* pStream, const char* pSrcDb, const char* pSql,
- const char* pDstStb = nullptr, int8_t igExists = 0,
- int8_t triggerType = STREAM_TRIGGER_AT_ONCE, int64_t maxDelay = 0,
- int64_t watermark = 0, int8_t igExpired = STREAM_DEFAULT_IGNORE_EXPIRED) {
+ auto setCreateStreamReqFunc = [&](const char* pStream, const char* pSrcDb, const char* pSql, const char* pDstStb,
+ int8_t igExists = 0, int8_t triggerType = STREAM_TRIGGER_AT_ONCE,
+ int64_t maxDelay = 0, int64_t watermark = 0,
+ int8_t igExpired = STREAM_DEFAULT_IGNORE_EXPIRED) {
snprintf(expect.name, sizeof(expect.name), "0.%s", pStream);
snprintf(expect.sourceDB, sizeof(expect.sourceDB), "0.%s", pSrcDb);
- if (NULL != pDstStb) {
- snprintf(expect.targetStbFullName, sizeof(expect.targetStbFullName), "0.test.%s", pDstStb);
- }
+ snprintf(expect.targetStbFullName, sizeof(expect.targetStbFullName), "0.test.%s", pDstStb);
expect.igExists = igExists;
expect.sql = strdup(pSql);
expect.triggerType = triggerType;
@@ -603,15 +601,6 @@ TEST_F(ParserInitialCTest, createStream) {
tFreeSCMCreateStreamReq(&req);
});
- setCreateStreamReqFunc("s1", "test", "create stream s1 as select count(*) from t1 interval(10s)");
- run("CREATE STREAM s1 AS SELECT COUNT(*) FROM t1 INTERVAL(10S)");
- clearCreateStreamReq();
-
- setCreateStreamReqFunc("s1", "test", "create stream if not exists s1 as select count(*) from t1 interval(10s)",
- nullptr, 1);
- run("CREATE STREAM IF NOT EXISTS s1 AS SELECT COUNT(*) FROM t1 INTERVAL(10S)");
- clearCreateStreamReq();
-
setCreateStreamReqFunc("s1", "test", "create stream s1 into st1 as select count(*) from t1 interval(10s)", "st1");
run("CREATE STREAM s1 INTO st1 AS SELECT COUNT(*) FROM t1 INTERVAL(10S)");
clearCreateStreamReq();
@@ -629,7 +618,8 @@ TEST_F(ParserInitialCTest, createStream) {
TEST_F(ParserInitialCTest, createStreamSemanticCheck) {
useDb("root", "test");
- run("CREATE STREAM s1 AS SELECT PERCENTILE(c1, 30) FROM t1 INTERVAL(10S)", TSDB_CODE_PAR_STREAM_NOT_ALLOWED_FUNC);
+ run("CREATE STREAM s1 INTO st1 AS SELECT PERCENTILE(c1, 30) FROM t1 INTERVAL(10S)",
+ TSDB_CODE_PAR_STREAM_NOT_ALLOWED_FUNC);
}
TEST_F(ParserInitialCTest, createTable) {
diff --git a/source/libs/planner/test/planOtherTest.cpp b/source/libs/planner/test/planOtherTest.cpp
index 7107f8b3c94c616ae9db90132a59f2804b542aca..350ccd0d927c9773059cfb2c027a0ca2292e4d13 100644
--- a/source/libs/planner/test/planOtherTest.cpp
+++ b/source/libs/planner/test/planOtherTest.cpp
@@ -37,9 +37,9 @@ TEST_F(PlanOtherTest, createStream) {
TEST_F(PlanOtherTest, createStreamUseSTable) {
useDb("root", "test");
- run("CREATE STREAM IF NOT EXISTS s1 as SELECT COUNT(*) FROM st1 INTERVAL(10s)");
+ run("CREATE STREAM IF NOT EXISTS s1 into st1 as SELECT COUNT(*) FROM st1 INTERVAL(10s)");
- run("CREATE STREAM IF NOT EXISTS s1 as SELECT COUNT(*) FROM st1 PARTITION BY TBNAME INTERVAL(10s)");
+ run("CREATE STREAM IF NOT EXISTS s1 into st1 as SELECT COUNT(*) FROM st1 PARTITION BY TBNAME INTERVAL(10s)");
}
TEST_F(PlanOtherTest, createSmaIndex) {
diff --git a/source/libs/scalar/inc/sclInt.h b/source/libs/scalar/inc/sclInt.h
index d423b92da7e83589aacc6d384c0e2cafa0949038..36d2c5a49cb8a00db1ed4f731c3d02fe80a83ea3 100644
--- a/source/libs/scalar/inc/sclInt.h
+++ b/source/libs/scalar/inc/sclInt.h
@@ -45,6 +45,8 @@ typedef struct SScalarCtx {
#define SCL_IS_CONST_CALC(_ctx) (NULL == (_ctx)->pBlockList)
//#define SCL_IS_NULL_VALUE_NODE(_node) ((QUERY_NODE_VALUE == nodeType(_node)) && (TSDB_DATA_TYPE_NULL == ((SValueNode *)_node)->node.resType.type) && (((SValueNode *)_node)->placeholderNo <= 0))
#define SCL_IS_NULL_VALUE_NODE(_node) ((QUERY_NODE_VALUE == nodeType(_node)) && (TSDB_DATA_TYPE_NULL == ((SValueNode *)_node)->node.resType.type))
+#define SCL_IS_COMPARISON_OPERATOR(_opType) ((_opType) >= OP_TYPE_GREATER_THAN && (_opType) < OP_TYPE_IS_NOT_UNKNOWN)
+#define SCL_DOWNGRADE_DATETYPE(_type) ((_type) == TSDB_DATA_TYPE_BIGINT || TSDB_DATA_TYPE_DOUBLE == (_type) || (_type) == TSDB_DATA_TYPE_UBIGINT)
#define sclFatal(...) qFatal(__VA_ARGS__)
#define sclError(...) qError(__VA_ARGS__)
diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index 6634a29f4091773c89988940c9ab6ed5de2487da..cd1f6624bdf83e4fe143c1a648e5e30947bcdd65 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -9,6 +9,7 @@
#include "scalar.h"
#include "tudf.h"
#include "ttime.h"
+#include "tcompare.h"
int32_t scalarGetOperatorParamNum(EOperatorType type) {
if (OP_TYPE_IS_NULL == type || OP_TYPE_IS_NOT_NULL == type || OP_TYPE_IS_TRUE == type || OP_TYPE_IS_NOT_TRUE == type
@@ -219,6 +220,82 @@ void sclFreeParamList(SScalarParam *param, int32_t paramNum) {
taosMemoryFree(param);
}
+void sclDowngradeValueType(SValueNode *valueNode) {
+ switch (valueNode->node.resType.type) {
+ case TSDB_DATA_TYPE_BIGINT: {
+ int8_t i8 = valueNode->datum.i;
+ if (i8 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_TINYINT;
+ *(int8_t*)&valueNode->typeData = i8;
+ break;
+ }
+ int16_t i16 = valueNode->datum.i;
+ if (i16 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_SMALLINT;
+ *(int16_t*)&valueNode->typeData = i16;
+ break;
+ }
+ int32_t i32 = valueNode->datum.i;
+ if (i32 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_INT;
+ *(int32_t*)&valueNode->typeData = i32;
+ break;
+ }
+ break;
+ }
+ case TSDB_DATA_TYPE_UBIGINT:{
+ uint8_t u8 = valueNode->datum.i;
+ if (u8 == valueNode->datum.i) {
+ int8_t i8 = valueNode->datum.i;
+ if (i8 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_TINYINT;
+ *(int8_t*)&valueNode->typeData = i8;
+ } else {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_UTINYINT;
+ *(uint8_t*)&valueNode->typeData = u8;
+ }
+ break;
+ }
+ uint16_t u16 = valueNode->datum.i;
+ if (u16 == valueNode->datum.i) {
+ int16_t i16 = valueNode->datum.i;
+ if (i16 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_SMALLINT;
+ *(int16_t*)&valueNode->typeData = i16;
+ } else {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_USMALLINT;
+ *(uint16_t*)&valueNode->typeData = u16;
+ }
+ break;
+ }
+ uint32_t u32 = valueNode->datum.i;
+ if (u32 == valueNode->datum.i) {
+ int32_t i32 = valueNode->datum.i;
+ if (i32 == valueNode->datum.i) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_INT;
+ *(int32_t*)&valueNode->typeData = i32;
+ } else {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_UINT;
+ *(uint32_t*)&valueNode->typeData = u32;
+ }
+ break;
+ }
+ break;
+ }
+ case TSDB_DATA_TYPE_DOUBLE: {
+ float f = valueNode->datum.d;
+ if (FLT_EQUAL(f, valueNode->datum.d)) {
+ valueNode->node.resType.type = TSDB_DATA_TYPE_FLOAT;
+ *(float*)&valueNode->typeData = f;
+ break;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
int32_t sclInitParam(SNode* node, SScalarParam *param, SScalarCtx *ctx, int32_t *rowNum) {
switch (nodeType(node)) {
case QUERY_NODE_LEFT_VALUE: {
@@ -675,6 +752,10 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR;
}
}
+
+ if (SCL_IS_COMPARISON_OPERATOR(node->opType) && SCL_DOWNGRADE_DATETYPE(valueNode->node.resType.type)) {
+ sclDowngradeValueType(valueNode);
+ }
}
if (node->pRight && (QUERY_NODE_VALUE == nodeType(node->pRight))) {
@@ -692,6 +773,10 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR;
}
}
+
+ if (SCL_IS_COMPARISON_OPERATOR(node->opType) && SCL_DOWNGRADE_DATETYPE(valueNode->node.resType.type)) {
+ sclDowngradeValueType(valueNode);
+ }
}
if (node->pRight && (QUERY_NODE_NODE_LIST == nodeType(node->pRight))) {
diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c
index 20a2f7d332ce97511ec7bcd752539ff626ce0f54..1442ed2e0509e37d8b21806dc05343adcaa0f32c 100644
--- a/source/libs/stream/src/streamMeta.c
+++ b/source/libs/stream/src/streamMeta.c
@@ -265,6 +265,8 @@ int32_t streamLoadTasks(SStreamMeta* pMeta) {
}
}
+ tdbFree(pKey);
+ tdbFree(pVal);
if (tdbTbcClose(pCur) < 0) {
return -1;
}
diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c
index 2ab5fd2e9c2f1156ab9bba3c0ed384807f25e8cd..4701318779bba3928223c137c13c0bca6e2df417 100644
--- a/source/libs/tdb/src/db/tdbBtree.c
+++ b/source/libs/tdb/src/db/tdbBtree.c
@@ -782,6 +782,11 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx
pBt);
tdbPageInsertCell(pParent, sIdx++, pNewCell, szNewCell, 0);
tdbOsFree(pNewCell);
+
+ if (TDB_CELLDECODER_FREE_VAL(&cd)) {
+ tdbFree(cd.pVal);
+ cd.pVal = NULL;
+ }
}
// move to next new page
diff --git a/source/libs/transport/src/thttp.c b/source/libs/transport/src/thttp.c
index 98e0b8f9c93b61703787e7b7d4e91f86f1084358..386ea95dd795b93bcaa2826d471a6e4c97f81b7b 100644
--- a/source/libs/transport/src/thttp.c
+++ b/source/libs/transport/src/thttp.c
@@ -175,7 +175,7 @@ static int32_t taosBuildDstAddr(const char* server, uint16_t port, struct sockad
uint32_t ip = taosGetIpv4FromFqdn(server);
if (ip == 0xffffffff) {
terrno = TAOS_SYSTEM_ERROR(errno);
- uError("http-report failed to get http server:%s ip since %s", server, terrstr());
+ uError("http-report failed to get http server:%s since %s", server, errno == 0 ? "invalid http server" : terrstr());
return -1;
}
char buf[128] = {0};
@@ -224,6 +224,7 @@ int32_t taosSendHttpReport(const char* server, uint16_t port, char* pCont, int32
if (ret != 0) {
uError("http-report failed to connect to server, reason:%s, dst:%s:%d", uv_strerror(ret), cli->addr, cli->port);
destroyHttpClient(cli);
+ uv_stop(loop);
}
uv_run(loop, UV_RUN_DEFAULT);
diff --git a/source/os/src/osDir.c b/source/os/src/osDir.c
index b755a35815fb64d6fa11ff3e0c35efc647318b83..30aaa01dae0bf26bb930271f056d77226e808a4d 100644
--- a/source/os/src/osDir.c
+++ b/source/os/src/osDir.c
@@ -133,6 +133,7 @@ int32_t taosMulMkDir(const char *dirname) {
code = mkdir(temp, 0755);
#endif
if (code < 0 && errno != EEXIST) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
return code;
}
*pos = TD_DIRSEP[0];
@@ -146,6 +147,7 @@ int32_t taosMulMkDir(const char *dirname) {
code = mkdir(temp, 0755);
#endif
if (code < 0 && errno != EEXIST) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
return code;
}
}
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index f9797f631969d8a692d84078211e7e27174517e6..fab933755a73ba23be962cb76b34da002b8a3702 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -313,6 +313,7 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
assert(!(tdFileOptions & TD_FILE_EXCL));
fp = fopen(path, mode);
if (fp == NULL) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
return NULL;
}
} else {
@@ -335,6 +336,7 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
fd = open(path, access, S_IRWXU | S_IRWXG | S_IRWXO);
#endif
if (fd == -1) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
return NULL;
}
}
diff --git a/source/os/src/osSemaphore.c b/source/os/src/osSemaphore.c
index a7d2ba85311b8f2a9ababbde0f1f5857cb354484..a95503b5e58228064f67f892d45b9668c2dd861c 100644
--- a/source/os/src/osSemaphore.c
+++ b/source/os/src/osSemaphore.c
@@ -1,678 +1,531 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see .
- */
-
-#define ALLOW_FORBID_FUNC
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "pthread.h"
-#include "tdef.h"
-
-#ifdef WINDOWS
-
-/*
- * windows implementation
- */
-
-#include
-
-bool taosCheckPthreadValid(TdThread thread) { return thread.p != NULL; }
-
-void taosResetPthread(TdThread* thread) { thread->p = 0; }
-
-int64_t taosGetPthreadId(TdThread thread) {
-#ifdef PTW32_VERSION
- return pthread_getw32threadid_np(thread);
-#else
- return (int64_t)thread;
-#endif
-}
-
-int64_t taosGetSelfPthreadId() { return GetCurrentThreadId(); }
-
-bool taosComparePthread(TdThread first, TdThread second) { return first.p == second.p; }
-
-int32_t taosGetPId() { return GetCurrentProcessId(); }
-
-int32_t taosGetAppName(char* name, int32_t* len) {
- char filepath[1024] = {0};
-
- GetModuleFileName(NULL, filepath, MAX_PATH);
- char* sub = strrchr(filepath, '.');
- if (sub != NULL) {
- *sub = '\0';
- }
- char* end = strrchr(filepath, TD_DIRSEP[0]);
- if (end == NULL) {
- end = filepath;
- }
-
- tstrncpy(name, end, TSDB_APP_NAME_LEN);
-
- if (len != NULL) {
- *len = (int32_t)strlen(end);
- }
-
- return 0;
-}
-
-int32_t tsem_wait(tsem_t* sem) {
- int ret = 0;
- do {
- ret = sem_wait(sem);
- } while (ret != 0 && errno == EINTR);
- return ret;
-}
-
-int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
- struct timespec ts, rel;
- FILETIME ft_before, ft_after;
- int rc;
-
- rel.tv_sec = 0;
- rel.tv_nsec = nanosecs;
-
- GetSystemTimeAsFileTime(&ft_before);
- // errno = 0;
- rc = sem_timedwait(sem, pthread_win32_getabstime_np(&ts, &rel));
-
- /* This should have timed out */
- // assert(errno == ETIMEDOUT);
- // assert(rc != 0);
- // GetSystemTimeAsFileTime(&ft_after);
- // // We specified a non-zero wait. Time must advance.
- // if (ft_before.dwLowDateTime == ft_after.dwLowDateTime && ft_before.dwHighDateTime == ft_after.dwHighDateTime)
- // {
- // printf("nanoseconds: %d, rc: %d, code:0x%x. before filetime: %d, %d; after filetime: %d, %d\n",
- // nanosecs, rc, errno,
- // (int)ft_before.dwLowDateTime, (int)ft_before.dwHighDateTime,
- // (int)ft_after.dwLowDateTime, (int)ft_after.dwHighDateTime);
- // printf("time must advance during sem_timedwait.");
- // return 1;
- // }
- return rc;
-}
-
-#elif defined(_TD_DARWIN_64)
-
-/*
- * darwin implementation
- */
-
-#include
-
-// #define SEM_USE_PTHREAD
-// #define SEM_USE_POSIX
-// #define SEM_USE_SEM
-
-// #ifdef SEM_USE_SEM
-// #include
-// #include
-// #include
-// #include
-
-// static TdThread sem_thread;
-// static TdThreadOnce sem_once;
-// static task_t sem_port;
-// static volatile int sem_inited = 0;
-// static semaphore_t sem_exit;
-
-// static void *sem_thread_routine(void *arg) {
-// (void)arg;
-// setThreadName("sem_thrd");
-
-// sem_port = mach_task_self();
-// kern_return_t ret = semaphore_create(sem_port, &sem_exit, SYNC_POLICY_FIFO, 0);
-// if (ret != KERN_SUCCESS) {
-// fprintf(stderr, "==%s[%d]%s()==failed to create sem_exit\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__);
-// sem_inited = -1;
-// return NULL;
-// }
-// sem_inited = 1;
-// semaphore_wait(sem_exit);
-// return NULL;
-// }
-
-// static void once_init(void) {
-// int r = 0;
-// r = taosThreadCreate(&sem_thread, NULL, sem_thread_routine, NULL);
-// if (r) {
-// fprintf(stderr, "==%s[%d]%s()==failed to create thread\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__);
-// return;
-// }
-// while (sem_inited == 0) {
-// ;
-// }
-// }
-// #endif
-
-// struct tsem_s {
-// #ifdef SEM_USE_PTHREAD
-// TdThreadMutex lock;
-// TdThreadCond cond;
-// volatile int64_t val;
-// #elif defined(SEM_USE_POSIX)
-// size_t id;
-// sem_t *sem;
-// #elif defined(SEM_USE_SEM)
-// semaphore_t sem;
-// #else // SEM_USE_PTHREAD
-// dispatch_semaphore_t sem;
-// #endif // SEM_USE_PTHREAD
-
-// volatile unsigned int valid : 1;
-// };
-
-// int tsem_init(tsem_t *sem, int pshared, unsigned int value) {
-// // fprintf(stderr, "==%s[%d]%s():[%p]==creating\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// if (*sem) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==already initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// struct tsem_s *p = (struct tsem_s *)taosMemoryCalloc(1, sizeof(*p));
-// if (!p) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==out of memory\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// abort();
-// }
-
-// #ifdef SEM_USE_PTHREAD
-// int r = taosThreadMutexInit(&p->lock, NULL);
-// do {
-// if (r) break;
-// r = taosThreadCondInit(&p->cond, NULL);
-// if (r) {
-// taosThreadMutexDestroy(&p->lock);
-// break;
-// }
-// p->val = value;
-// } while (0);
-// if (r) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==not created\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// abort();
-// }
-// #elif defined(SEM_USE_POSIX)
-// static size_t tick = 0;
-// do {
-// size_t id = atomic_add_fetch_64(&tick, 1);
-// if (id == SEM_VALUE_MAX) {
-// atomic_store_64(&tick, 0);
-// id = 0;
-// }
-// char name[NAME_MAX - 4];
-// snprintf(name, sizeof(name), "/t" PRId64, id);
-// p->sem = sem_open(name, O_CREAT | O_EXCL, pshared, value);
-// p->id = id;
-// if (p->sem != SEM_FAILED) break;
-// int e = errno;
-// if (e == EEXIST) continue;
-// if (e == EINTR) continue;
-// fprintf(stderr, "==%s[%d]%s():[%p]==not created[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem,
-// e, strerror(e));
-// abort();
-// } while (p->sem == SEM_FAILED);
-// #elif defined(SEM_USE_SEM)
-// taosThreadOnce(&sem_once, once_init);
-// if (sem_inited != 1) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal resource init failed\n", taosDirEntryBaseName(__FILE__), __LINE__,
-// __func__, sem);
-// errno = ENOMEM;
-// return -1;
-// }
-// kern_return_t ret = semaphore_create(sem_port, &p->sem, SYNC_POLICY_FIFO, value);
-// if (ret != KERN_SUCCESS) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==semophore_create failed\n", taosDirEntryBaseName(__FILE__), __LINE__,
-// __func__,
-// sem);
-// // we fail-fast here, because we have less-doc about semaphore_create for the moment
-// abort();
-// }
-// #else // SEM_USE_PTHREAD
-// p->sem = dispatch_semaphore_create(value);
-// if (p->sem == NULL) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==not created\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// abort();
-// }
-// #endif // SEM_USE_PTHREAD
-
-// p->valid = 1;
-
-// *sem = p;
-
-// return 0;
-// }
-
-// int tsem_wait(tsem_t *sem) {
-// if (!*sem) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// abort();
-// }
-// struct tsem_s *p = *sem;
-// if (!p->valid) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem); abort();
-// }
-// #ifdef SEM_USE_PTHREAD
-// if (taosThreadMutexLock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// p->val -= 1;
-// if (p->val < 0) {
-// if (taosThreadCondWait(&p->cond, &p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
-// __func__,
-// sem);
-// abort();
-// }
-// }
-// if (taosThreadMutexUnlock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// return 0;
-// #elif defined(SEM_USE_POSIX)
-// return sem_wait(p->sem);
-// #elif defined(SEM_USE_SEM)
-// return semaphore_wait(p->sem);
-// #else // SEM_USE_PTHREAD
-// return dispatch_semaphore_wait(p->sem, DISPATCH_TIME_FOREVER);
-// #endif // SEM_USE_PTHREAD
-// }
-
-// int tsem_post(tsem_t *sem) {
-// if (!*sem) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// abort();
-// }
-// struct tsem_s *p = *sem;
-// if (!p->valid) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem); abort();
-// }
-// #ifdef SEM_USE_PTHREAD
-// if (taosThreadMutexLock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// p->val += 1;
-// if (p->val <= 0) {
-// if (taosThreadCondSignal(&p->cond)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
-// __func__,
-// sem);
-// abort();
-// }
-// }
-// if (taosThreadMutexUnlock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// return 0;
-// #elif defined(SEM_USE_POSIX)
-// return sem_post(p->sem);
-// #elif defined(SEM_USE_SEM)
-// return semaphore_signal(p->sem);
-// #else // SEM_USE_PTHREAD
-// return dispatch_semaphore_signal(p->sem);
-// #endif // SEM_USE_PTHREAD
-// }
-
-// int tsem_destroy(tsem_t *sem) {
-// // fprintf(stderr, "==%s[%d]%s():[%p]==destroying\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
-// if (!*sem) {
-// // fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// // abort();
-// return 0;
-// }
-// struct tsem_s *p = *sem;
-// if (!p->valid) {
-// // fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// // sem); abort();
-// return 0;
-// }
-// #ifdef SEM_USE_PTHREAD
-// if (taosThreadMutexLock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// p->valid = 0;
-// if (taosThreadCondDestroy(&p->cond)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// if (taosThreadMutexUnlock(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// if (taosThreadMutexDestroy(&p->lock)) {
-// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem);
-// abort();
-// }
-// #elif defined(SEM_USE_POSIX)
-// char name[NAME_MAX - 4];
-// snprintf(name, sizeof(name), "/t" PRId64, p->id);
-// int r = sem_unlink(name);
-// if (r) {
-// int e = errno;
-// fprintf(stderr, "==%s[%d]%s():[%p]==unlink failed[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-// sem,
-// e, strerror(e));
-// abort();
-// }
-// #elif defined(SEM_USE_SEM)
-// semaphore_destroy(sem_port, p->sem);
-// #else // SEM_USE_PTHREAD
-// #endif // SEM_USE_PTHREAD
-
-// p->valid = 0;
-// taosMemoryFree(p);
-
-// *sem = NULL;
-// return 0;
-// }
-typedef struct {
- pthread_mutex_t count_lock;
- pthread_cond_t count_bump;
- unsigned int count;
-} bosal_sem_t;
-
-int tsem_init(tsem_t *psem, int flags, unsigned int count) {
- bosal_sem_t *pnewsem;
- int result;
-
- pnewsem = (bosal_sem_t *)malloc(sizeof(bosal_sem_t));
- if (!pnewsem) {
- return -1;
- }
- result = pthread_mutex_init(&pnewsem->count_lock, NULL);
- if (result) {
- free(pnewsem);
- return result;
- }
- result = pthread_cond_init(&pnewsem->count_bump, NULL);
- if (result) {
- pthread_mutex_destroy(&pnewsem->count_lock);
- free(pnewsem);
- return result;
- }
- pnewsem->count = count;
- *psem = (tsem_t)pnewsem;
- return 0;
-}
-
-int tsem_destroy(tsem_t *psem) {
- bosal_sem_t *poldsem;
-
- if (!psem) {
- return EINVAL;
- }
- poldsem = (bosal_sem_t *)*psem;
-
- pthread_mutex_destroy(&poldsem->count_lock);
- pthread_cond_destroy(&poldsem->count_bump);
- free(poldsem);
- return 0;
-}
-
-int tsem_post(tsem_t *psem) {
- bosal_sem_t *pxsem;
- int result, xresult;
-
- if (!psem) {
- return EINVAL;
- }
- pxsem = (bosal_sem_t *)*psem;
-
- result = pthread_mutex_lock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- pxsem->count = pxsem->count + 1;
-
- xresult = pthread_cond_signal(&pxsem->count_bump);
-
- result = pthread_mutex_unlock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- if (xresult) {
- errno = xresult;
- return -1;
- }
- return 0;
-}
-
-int tsem_trywait(tsem_t *psem) {
- bosal_sem_t *pxsem;
- int result, xresult;
-
- if (!psem) {
- return EINVAL;
- }
- pxsem = (bosal_sem_t *)*psem;
-
- result = pthread_mutex_lock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- xresult = 0;
-
- if (pxsem->count > 0) {
- pxsem->count--;
- } else {
- xresult = EAGAIN;
- }
- result = pthread_mutex_unlock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- if (xresult) {
- errno = xresult;
- return -1;
- }
- return 0;
-}
-
-int tsem_wait(tsem_t *psem) {
- bosal_sem_t *pxsem;
- int result, xresult;
-
- if (!psem) {
- return EINVAL;
- }
- pxsem = (bosal_sem_t *)*psem;
-
- result = pthread_mutex_lock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- xresult = 0;
-
- if (pxsem->count == 0) {
- xresult = pthread_cond_wait(&pxsem->count_bump, &pxsem->count_lock);
- }
- if (!xresult) {
- if (pxsem->count > 0) {
- pxsem->count--;
- }
- }
- result = pthread_mutex_unlock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- if (xresult) {
- errno = xresult;
- return -1;
- }
- return 0;
-}
-
-int tsem_timewait(tsem_t *psem, int64_t nanosecs) {
- struct timespec abstim = {
- .tv_sec = 0,
- .tv_nsec = nanosecs,
- };
-
- bosal_sem_t *pxsem;
- int result, xresult;
-
- if (!psem) {
- return EINVAL;
- }
- pxsem = (bosal_sem_t *)*psem;
-
- result = pthread_mutex_lock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- xresult = 0;
-
- if (pxsem->count == 0) {
- xresult = pthread_cond_timedwait(&pxsem->count_bump, &pxsem->count_lock, &abstim);
- }
- if (!xresult) {
- if (pxsem->count > 0) {
- pxsem->count--;
- }
- }
- result = pthread_mutex_unlock(&pxsem->count_lock);
- if (result) {
- return result;
- }
- if (xresult) {
- errno = xresult;
- return -1;
- }
- return 0;
-}
-
-bool taosCheckPthreadValid(TdThread thread) {
- int32_t ret = taosThreadKill(thread, 0);
- if (ret == ESRCH) return false;
- if (ret == EINVAL) return false;
- // alive
- return true;
-}
-
-int64_t taosGetSelfPthreadId() {
- TdThread thread = taosThreadSelf();
- return (int64_t)thread;
-}
-
-int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
-
-void taosResetPthread(TdThread *thread) { *thread = NULL; }
-
-bool taosComparePthread(TdThread first, TdThread second) { return taosThreadEqual(first, second) ? true : false; }
-
-int32_t taosGetPId() { return (int32_t)getpid(); }
-
-int32_t taosGetAppName(char *name, int32_t *len) {
- char buf[PATH_MAX + 1];
- buf[0] = '\0';
- proc_name(getpid(), buf, sizeof(buf) - 1);
- buf[PATH_MAX] = '\0';
- size_t n = strlen(buf);
- if (len) *len = n;
- if (name) tstrncpy(name, buf, TSDB_APP_NAME_LEN);
- return 0;
-}
-
-#else
-
-/*
- * linux implementation
- */
-
-#include
-#include
-
-bool taosCheckPthreadValid(TdThread thread) { return thread != 0; }
-
-int64_t taosGetSelfPthreadId() {
- static __thread int id = 0;
- if (id != 0) return id;
- id = syscall(SYS_gettid);
- return id;
-}
-
-int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
-void taosResetPthread(TdThread* thread) { *thread = 0; }
-bool taosComparePthread(TdThread first, TdThread second) { return first == second; }
-
-int32_t taosGetPId() {
- static int32_t pid;
- if (pid != 0) return pid;
- pid = getpid();
- return pid;
-}
-
-int32_t taosGetAppName(char* name, int32_t* len) {
- const char* self = "/proc/self/exe";
- char path[PATH_MAX] = {0};
-
- if (readlink(self, path, PATH_MAX) <= 0) {
- return -1;
- }
-
- path[PATH_MAX - 1] = 0;
- char* end = strrchr(path, '/');
- if (end == NULL) {
- return -1;
- }
-
- ++end;
-
- tstrncpy(name, end, TSDB_APP_NAME_LEN);
-
- if (len != NULL) {
- *len = strlen(name);
- }
-
- return 0;
-}
-
-int32_t tsem_wait(tsem_t* sem) {
- int ret = 0;
- do {
- ret = sem_wait(sem);
- } while (ret != 0 && errno == EINTR);
- return ret;
-}
-
-int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
- int ret = 0;
-
- struct timespec tv = {
- .tv_sec = 0,
- .tv_nsec = nanosecs,
- };
-
- while ((ret = sem_timedwait(sem, &tv)) == -1 && errno == EINTR) continue;
-
- return ret;
-}
-
-#endif
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ */
+
+#define ALLOW_FORBID_FUNC
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "pthread.h"
+#include "tdef.h"
+
+#ifdef WINDOWS
+
+/*
+ * windows implementation
+ */
+
+#include
+
+bool taosCheckPthreadValid(TdThread thread) { return thread.p != NULL; }
+
+void taosResetPthread(TdThread* thread) { thread->p = 0; }
+
+int64_t taosGetPthreadId(TdThread thread) {
+#ifdef PTW32_VERSION
+ return pthread_getw32threadid_np(thread);
+#else
+ return (int64_t)thread;
+#endif
+}
+
+int64_t taosGetSelfPthreadId() { return GetCurrentThreadId(); }
+
+bool taosComparePthread(TdThread first, TdThread second) { return first.p == second.p; }
+
+int32_t taosGetPId() { return GetCurrentProcessId(); }
+
+int32_t taosGetAppName(char* name, int32_t* len) {
+ char filepath[1024] = {0};
+
+ GetModuleFileName(NULL, filepath, MAX_PATH);
+ char* sub = strrchr(filepath, '.');
+ if (sub != NULL) {
+ *sub = '\0';
+ }
+ char* end = strrchr(filepath, TD_DIRSEP[0]);
+ if (end == NULL) {
+ end = filepath;
+ }
+
+ tstrncpy(name, end, TSDB_APP_NAME_LEN);
+
+ if (len != NULL) {
+ *len = (int32_t)strlen(end);
+ }
+
+ return 0;
+}
+
+int32_t tsem_wait(tsem_t* sem) {
+ int ret = 0;
+ do {
+ ret = sem_wait(sem);
+ } while (ret != 0 && errno == EINTR);
+ return ret;
+}
+
+int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
+ struct timespec ts, rel;
+ FILETIME ft_before, ft_after;
+ int rc;
+
+ rel.tv_sec = 0;
+ rel.tv_nsec = nanosecs;
+
+ GetSystemTimeAsFileTime(&ft_before);
+ // errno = 0;
+ rc = sem_timedwait(sem, pthread_win32_getabstime_np(&ts, &rel));
+
+ /* This should have timed out */
+ // assert(errno == ETIMEDOUT);
+ // assert(rc != 0);
+ // GetSystemTimeAsFileTime(&ft_after);
+ // // We specified a non-zero wait. Time must advance.
+ // if (ft_before.dwLowDateTime == ft_after.dwLowDateTime && ft_before.dwHighDateTime == ft_after.dwHighDateTime)
+ // {
+ // printf("nanoseconds: %d, rc: %d, code:0x%x. before filetime: %d, %d; after filetime: %d, %d\n",
+ // nanosecs, rc, errno,
+ // (int)ft_before.dwLowDateTime, (int)ft_before.dwHighDateTime,
+ // (int)ft_after.dwLowDateTime, (int)ft_after.dwHighDateTime);
+ // printf("time must advance during sem_timedwait.");
+ // return 1;
+ // }
+ return rc;
+}
+
+#elif defined(_TD_DARWIN_64)
+
+/*
+ * darwin implementation
+ */
+
+#include
+
+// #define SEM_USE_PTHREAD
+// #define SEM_USE_POSIX
+// #define SEM_USE_SEM
+
+// #ifdef SEM_USE_SEM
+// #include
+// #include
+// #include
+// #include
+
+// static TdThread sem_thread;
+// static TdThreadOnce sem_once;
+// static task_t sem_port;
+// static volatile int sem_inited = 0;
+// static semaphore_t sem_exit;
+
+// static void *sem_thread_routine(void *arg) {
+// (void)arg;
+// setThreadName("sem_thrd");
+
+// sem_port = mach_task_self();
+// kern_return_t ret = semaphore_create(sem_port, &sem_exit, SYNC_POLICY_FIFO, 0);
+// if (ret != KERN_SUCCESS) {
+// fprintf(stderr, "==%s[%d]%s()==failed to create sem_exit\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__);
+// sem_inited = -1;
+// return NULL;
+// }
+// sem_inited = 1;
+// semaphore_wait(sem_exit);
+// return NULL;
+// }
+
+// static void once_init(void) {
+// int r = 0;
+// r = taosThreadCreate(&sem_thread, NULL, sem_thread_routine, NULL);
+// if (r) {
+// fprintf(stderr, "==%s[%d]%s()==failed to create thread\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__);
+// return;
+// }
+// while (sem_inited == 0) {
+// ;
+// }
+// }
+// #endif
+
+// struct tsem_s {
+// #ifdef SEM_USE_PTHREAD
+// TdThreadMutex lock;
+// TdThreadCond cond;
+// volatile int64_t val;
+// #elif defined(SEM_USE_POSIX)
+// size_t id;
+// sem_t *sem;
+// #elif defined(SEM_USE_SEM)
+// semaphore_t sem;
+// #else // SEM_USE_PTHREAD
+// dispatch_semaphore_t sem;
+// #endif // SEM_USE_PTHREAD
+
+// volatile unsigned int valid : 1;
+// };
+
+// int tsem_init(tsem_t *sem, int pshared, unsigned int value) {
+// // fprintf(stderr, "==%s[%d]%s():[%p]==creating\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// if (*sem) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==already initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// struct tsem_s *p = (struct tsem_s *)taosMemoryCalloc(1, sizeof(*p));
+// if (!p) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==out of memory\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// abort();
+// }
+
+// #ifdef SEM_USE_PTHREAD
+// int r = taosThreadMutexInit(&p->lock, NULL);
+// do {
+// if (r) break;
+// r = taosThreadCondInit(&p->cond, NULL);
+// if (r) {
+// taosThreadMutexDestroy(&p->lock);
+// break;
+// }
+// p->val = value;
+// } while (0);
+// if (r) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==not created\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// abort();
+// }
+// #elif defined(SEM_USE_POSIX)
+// static size_t tick = 0;
+// do {
+// size_t id = atomic_add_fetch_64(&tick, 1);
+// if (id == SEM_VALUE_MAX) {
+// atomic_store_64(&tick, 0);
+// id = 0;
+// }
+// char name[NAME_MAX - 4];
+// snprintf(name, sizeof(name), "/t" PRId64, id);
+// p->sem = sem_open(name, O_CREAT | O_EXCL, pshared, value);
+// p->id = id;
+// if (p->sem != SEM_FAILED) break;
+// int e = errno;
+// if (e == EEXIST) continue;
+// if (e == EINTR) continue;
+// fprintf(stderr, "==%s[%d]%s():[%p]==not created[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem,
+// e, strerror(e));
+// abort();
+// } while (p->sem == SEM_FAILED);
+// #elif defined(SEM_USE_SEM)
+// taosThreadOnce(&sem_once, once_init);
+// if (sem_inited != 1) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal resource init failed\n", taosDirEntryBaseName(__FILE__), __LINE__,
+// __func__, sem);
+// errno = ENOMEM;
+// return -1;
+// }
+// kern_return_t ret = semaphore_create(sem_port, &p->sem, SYNC_POLICY_FIFO, value);
+// if (ret != KERN_SUCCESS) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==semophore_create failed\n", taosDirEntryBaseName(__FILE__), __LINE__,
+// __func__,
+// sem);
+// // we fail-fast here, because we have less-doc about semaphore_create for the moment
+// abort();
+// }
+// #else // SEM_USE_PTHREAD
+// p->sem = dispatch_semaphore_create(value);
+// if (p->sem == NULL) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==not created\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// abort();
+// }
+// #endif // SEM_USE_PTHREAD
+
+// p->valid = 1;
+
+// *sem = p;
+
+// return 0;
+// }
+
+// int tsem_wait(tsem_t *sem) {
+// if (!*sem) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// abort();
+// }
+// struct tsem_s *p = *sem;
+// if (!p->valid) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem); abort();
+// }
+// #ifdef SEM_USE_PTHREAD
+// if (taosThreadMutexLock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// p->val -= 1;
+// if (p->val < 0) {
+// if (taosThreadCondWait(&p->cond, &p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
+// __func__,
+// sem);
+// abort();
+// }
+// }
+// if (taosThreadMutexUnlock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// return 0;
+// #elif defined(SEM_USE_POSIX)
+// return sem_wait(p->sem);
+// #elif defined(SEM_USE_SEM)
+// return semaphore_wait(p->sem);
+// #else // SEM_USE_PTHREAD
+// return dispatch_semaphore_wait(p->sem, DISPATCH_TIME_FOREVER);
+// #endif // SEM_USE_PTHREAD
+// }
+
+// int tsem_post(tsem_t *sem) {
+// if (!*sem) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// abort();
+// }
+// struct tsem_s *p = *sem;
+// if (!p->valid) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem); abort();
+// }
+// #ifdef SEM_USE_PTHREAD
+// if (taosThreadMutexLock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// p->val += 1;
+// if (p->val <= 0) {
+// if (taosThreadCondSignal(&p->cond)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
+// __func__,
+// sem);
+// abort();
+// }
+// }
+// if (taosThreadMutexUnlock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// return 0;
+// #elif defined(SEM_USE_POSIX)
+// return sem_post(p->sem);
+// #elif defined(SEM_USE_SEM)
+// return semaphore_signal(p->sem);
+// #else // SEM_USE_PTHREAD
+// return dispatch_semaphore_signal(p->sem);
+// #endif // SEM_USE_PTHREAD
+// }
+
+// int tsem_destroy(tsem_t *sem) {
+// // fprintf(stderr, "==%s[%d]%s():[%p]==destroying\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+// if (!*sem) {
+// // fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// // abort();
+// return 0;
+// }
+// struct tsem_s *p = *sem;
+// if (!p->valid) {
+// // fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// // sem); abort();
+// return 0;
+// }
+// #ifdef SEM_USE_PTHREAD
+// if (taosThreadMutexLock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// p->valid = 0;
+// if (taosThreadCondDestroy(&p->cond)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// if (taosThreadMutexUnlock(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// if (taosThreadMutexDestroy(&p->lock)) {
+// fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem);
+// abort();
+// }
+// #elif defined(SEM_USE_POSIX)
+// char name[NAME_MAX - 4];
+// snprintf(name, sizeof(name), "/t" PRId64, p->id);
+// int r = sem_unlink(name);
+// if (r) {
+// int e = errno;
+// fprintf(stderr, "==%s[%d]%s():[%p]==unlink failed[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+// sem,
+// e, strerror(e));
+// abort();
+// }
+// #elif defined(SEM_USE_SEM)
+// semaphore_destroy(sem_port, p->sem);
+// #else // SEM_USE_PTHREAD
+// #endif // SEM_USE_PTHREAD
+
+// p->valid = 0;
+// taosMemoryFree(p);
+
+// *sem = NULL;
+// return 0;
+// }
+
+int tsem_init(tsem_t *psem, int flags, unsigned int count) {
+ *psem = dispatch_semaphore_create(count);
+ if (*psem == NULL) return -1;
+ return 0;
+}
+
+int tsem_destroy(tsem_t *psem) {
+ return 0;
+}
+
+int tsem_post(tsem_t *psem) {
+ if (psem == NULL || *psem == NULL) return -1;
+ dispatch_semaphore_signal(*psem);
+ return 0;
+}
+
+int tsem_wait(tsem_t *psem) {
+ if (psem == NULL || *psem == NULL) return -1;
+ dispatch_semaphore_wait(*psem, DISPATCH_TIME_FOREVER);
+ return 0;
+}
+
+int tsem_timewait(tsem_t *psem, int64_t nanosecs) {
+ if (psem == NULL || *psem == NULL) return -1;
+ dispatch_semaphore_wait(*psem, nanosecs);
+ return 0;
+}
+
+bool taosCheckPthreadValid(TdThread thread) {
+ int32_t ret = taosThreadKill(thread, 0);
+ if (ret == ESRCH) return false;
+ if (ret == EINVAL) return false;
+ // alive
+ return true;
+}
+
+int64_t taosGetSelfPthreadId() {
+ TdThread thread = taosThreadSelf();
+ return (int64_t)thread;
+}
+
+int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
+
+void taosResetPthread(TdThread *thread) { *thread = NULL; }
+
+bool taosComparePthread(TdThread first, TdThread second) { return taosThreadEqual(first, second) ? true : false; }
+
+int32_t taosGetPId() { return (int32_t)getpid(); }
+
+int32_t taosGetAppName(char *name, int32_t *len) {
+ char buf[PATH_MAX + 1];
+ buf[0] = '\0';
+ proc_name(getpid(), buf, sizeof(buf) - 1);
+ buf[PATH_MAX] = '\0';
+ size_t n = strlen(buf);
+ if (len) *len = n;
+ if (name) tstrncpy(name, buf, TSDB_APP_NAME_LEN);
+ return 0;
+}
+
+#else
+
+/*
+ * linux implementation
+ */
+
+#include
+#include
+
+bool taosCheckPthreadValid(TdThread thread) { return thread != 0; }
+
+int64_t taosGetSelfPthreadId() {
+ static __thread int id = 0;
+ if (id != 0) return id;
+ id = syscall(SYS_gettid);
+ return id;
+}
+
+int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
+void taosResetPthread(TdThread* thread) { *thread = 0; }
+bool taosComparePthread(TdThread first, TdThread second) { return first == second; }
+
+int32_t taosGetPId() {
+ static int32_t pid;
+ if (pid != 0) return pid;
+ pid = getpid();
+ return pid;
+}
+
+int32_t taosGetAppName(char* name, int32_t* len) {
+ const char* self = "/proc/self/exe";
+ char path[PATH_MAX] = {0};
+
+ if (readlink(self, path, PATH_MAX) <= 0) {
+ return -1;
+ }
+
+ path[PATH_MAX - 1] = 0;
+ char* end = strrchr(path, '/');
+ if (end == NULL) {
+ return -1;
+ }
+
+ ++end;
+
+ tstrncpy(name, end, TSDB_APP_NAME_LEN);
+
+ if (len != NULL) {
+ *len = strlen(name);
+ }
+
+ return 0;
+}
+
+int32_t tsem_wait(tsem_t* sem) {
+ int ret = 0;
+ do {
+ ret = sem_wait(sem);
+ } while (ret != 0 && errno == EINTR);
+ return ret;
+}
+
+int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
+ int ret = 0;
+
+ struct timespec tv = {
+ .tv_sec = 0,
+ .tv_nsec = nanosecs,
+ };
+
+ while ((ret = sem_timedwait(sem, &tv)) == -1 && errno == EINTR) continue;
+
+ return ret;
+}
+
+#endif
diff --git a/source/os/src/osSysinfo.c b/source/os/src/osSysinfo.c
index 3aa3f4f29ea402b08fb3733451f3c9a1b8df153a..19e9568bbebf20a74e5f316bb50056efa4786c1a 100644
--- a/source/os/src/osSysinfo.c
+++ b/source/os/src/osSysinfo.c
@@ -595,6 +595,7 @@ int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize) {
#else
struct statvfs info;
if (statvfs(dataDir, &info)) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
return -1;
} else {
diskSize->total = info.f_blocks * info.f_frsize;
diff --git a/source/util/src/tcompare.c b/source/util/src/tcompare.c
index fe3065b2b78a46a85d6dc04b90fcff4e0fe80f03..7d7a14483a8bddb2e5a8770d62d34e3b6ae93bb8 100644
--- a/source/util/src/tcompare.c
+++ b/source/util/src/tcompare.c
@@ -186,15 +186,16 @@ int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
int32_t len1 = varDataLen(pLeft);
int32_t len2 = varDataLen(pRight);
- if (len1 != len2) {
- return len1 > len2 ? 1 : -1;
- } else {
- int32_t ret = strncmp(varDataVal(pLeft), varDataVal(pRight), len1);
- if (ret == 0) {
+ int32_t minLen = TMIN(len1, len2);
+ int32_t ret = strncmp(varDataVal(pLeft), varDataVal(pRight), minLen);
+ if (ret == 0) {
+ if (len1 == len2) {
return 0;
} else {
- return ret > 0 ? 1 : -1;
+ return len1 > len2 ? 1 : -1;
}
+ } else {
+ return ret > 0 ? 1 : -1;
}
}
diff --git a/source/util/src/thash.c b/source/util/src/thash.c
index 0029f1ab1ec83278de5336cdedf1666bec839df0..b69d8ea52866055668ce4937836c5eb46842f1c2 100644
--- a/source/util/src/thash.c
+++ b/source/util/src/thash.c
@@ -252,11 +252,15 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
// the max slots is not defined by user
pHashObj->capacity = taosHashCapacity((int32_t)capacity);
+ pHashObj->size = 0;
pHashObj->equalFp = memcmp;
pHashObj->hashFp = fn;
pHashObj->type = type;
+ pHashObj->lock = 0;
pHashObj->enableUpdate = update;
+ pHashObj->freeFp = NULL;
+ pHashObj->callbackFp = NULL;
ASSERT((pHashObj->capacity & (pHashObj->capacity - 1)) == 0);
@@ -329,7 +333,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo
// disable resize
taosHashRLock(pHashObj);
- int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity);
+ uint32_t slot = HASH_INDEX(hashVal, pHashObj->capacity);
SHashEntry *pe = pHashObj->hashList[slot];
taosHashEntryWLock(pHashObj, pe);
diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c
index 2e8239c68f0861486d2d6175d698dc76ed92b128..a2d65d6a542f72eae239f15c79be7c64c8df3bd1 100644
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
@@ -429,7 +429,7 @@ static inline int32_t taosBuildLogHead(char *buffer, const char *flags) {
}
static inline void taosPrintLogImp(ELogLevel level, int32_t dflag, const char *buffer, int32_t len) {
- if ((dflag & DEBUG_FILE) && tsLogObj.logHandle && tsLogObj.logHandle->pFile != NULL) {
+ if ((dflag & DEBUG_FILE) && tsLogObj.logHandle && tsLogObj.logHandle->pFile != NULL && osLogSpaceAvailable()) {
taosUpdateLogNums(level);
if (tsAsyncLog) {
taosPushLogBuffer(tsLogObj.logHandle, buffer, len);
@@ -451,7 +451,6 @@ static inline void taosPrintLogImp(ELogLevel level, int32_t dflag, const char *b
}
void taosPrintLog(const char *flags, ELogLevel level, int32_t dflag, const char *format, ...) {
- if (!osLogSpaceAvailable()) return;
if (!(dflag & DEBUG_FILE) && !(dflag & DEBUG_SCREEN)) return;
char buffer[LOG_MAX_LINE_BUFFER_SIZE];
diff --git a/tests/docs-examples-test/jdbc.sh b/tests/docs-examples-test/jdbc.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d71085a40306956ea8d25e9b575c97ae9945df76
--- /dev/null
+++ b/tests/docs-examples-test/jdbc.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+pgrep taosd || taosd >> /dev/null 2>&1 &
+pgrep taosadapter || taosadapter >> /dev/null 2>&1 &
+cd ../../docs/examples/java
+
+mvn clean test > jdbc-out.log 2>&1
+tail -n 20 jdbc-out.log
+
+cases=`grep 'Tests run' jdbc-out.log | awk 'END{print $3}'`
+totalJDBCCases=`echo ${cases/%,}`
+failed=`grep 'Tests run' jdbc-out.log | awk 'END{print $5}'`
+JDBCFailed=`echo ${failed/%,}`
+error=`grep 'Tests run' jdbc-out.log | awk 'END{print $7}'`
+JDBCError=`echo ${error/%,}`
+
+totalJDBCFailed=`expr $JDBCFailed + $JDBCError`
+totalJDBCSuccess=`expr $totalJDBCCases - $totalJDBCFailed`
+
+if [ "$totalJDBCSuccess" -gt "0" ]; then
+ echo -e "\n${GREEN} ### Total $totalJDBCSuccess JDBC case(s) succeed! ### ${NC}"
+fi
+
+if [ "$totalJDBCFailed" -ne "0" ]; then
+ echo -e "\n${RED} ### Total $totalJDBCFailed JDBC case(s) failed! ### ${NC}"
+ exit 8
+fi
\ No newline at end of file
diff --git a/tests/script/tsim/parser/groupby.sim b/tests/script/tsim/parser/groupby.sim
index 12a698b1ccb2273d10c1831948103ab88f494d54..4ee9c530a79c72ccac12a99922af1eeefc7485ed 100644
--- a/tests/script/tsim/parser/groupby.sim
+++ b/tests/script/tsim/parser/groupby.sim
@@ -557,7 +557,7 @@ if $data10 != @{slop:0.000000, intercept:1.000000}@ then
return -1
endi
-if $data90 != @{slop:0.000000, intercept:9.000000}@ then
+if $data90 != @{slop:0.000000, intercept:17.000000}@ then
return -1
endi
diff --git a/tests/script/tsim/query/crash_sql.sim b/tests/script/tsim/query/crash_sql.sim
index 169f2e7272bfb5e2beb413e8a210e2ddf54d744d..79a9165e6602b1e8b1931e0f3ad9bf7d0168450f 100644
--- a/tests/script/tsim/query/crash_sql.sim
+++ b/tests/script/tsim/query/crash_sql.sim
@@ -76,7 +76,7 @@ sql insert into ct4 values ( '2022-05-21 01:01:01.000', NULL, NULL, NULL, NULL,
print ================ start query ======================
-print ================ SQL used to cause taosd or taos shell crash
+print ================ SQL used to cause taosd or TDengine CLI crash
sql_error select sum(c1) ,count(c1) from ct4 group by c1 having sum(c10) between 0 and 1 ;
#system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/tsim/user/privilege_sysinfo.sim b/tests/script/tsim/user/privilege_sysinfo.sim
index 3008599427b37b07d69fa07de2e66dad26fcd3ca..e8348d92d43ede9c594ffa8487e22f27a95de503 100644
--- a/tests/script/tsim/user/privilege_sysinfo.sim
+++ b/tests/script/tsim/user/privilege_sysinfo.sim
@@ -133,8 +133,8 @@ sql_error show grants
sql show queries
sql show connections
sql show apps
-sql_error show transactions
-#sql_error show create database d2
+sql show transactions
+sql_error show create database d2
sql show create table d2.stb2;
sql show create table d2.ctb2;
sql show create table d2.ntb2;
@@ -175,9 +175,8 @@ sql select * from performance_schema.perf_queries
sql select * from performance_schema.perf_topics
sql select * from performance_schema.perf_consumers
sql select * from performance_schema.perf_subscriptions
-#sql_error select * from performance_schema.perf_trans
-#sql_error select * from performance_schema.perf_smas
-#sql_error select * from information_schema.perf_streams
-#sql_error select * from information_schema.perf_apps
+sql select * from performance_schema.perf_trans
+sql select * from performance_schema.perf_streams
+sql select * from performance_schema.perf_apps
#system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/system-test/2-query/json_tag.py b/tests/system-test/2-query/json_tag.py
index 856d7647477f8693e0f20f6950e1ab810c47b4d4..d9715579aed4878c1cf17642824718d412a77511 100644
--- a/tests/system-test/2-query/json_tag.py
+++ b/tests/system-test/2-query/json_tag.py
@@ -338,7 +338,7 @@ class TDTestCase:
tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 1 and 30")
tdSql.checkRows(3)
tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 'femail' and 'beijing'")
- tdSql.checkRows(2)
+ tdSql.checkRows(0)
# test with tbname/normal column
tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1'")