diff --git a/.github/workflows/taoskeeper-ci.yml b/.github/workflows/taoskeeper-ci.yml index ba43937029d6..fbc662ffb21f 100644 --- a/.github/workflows/taoskeeper-ci.yml +++ b/.github/workflows/taoskeeper-ci.yml @@ -48,7 +48,7 @@ jobs: working-directory: tools/keeper run: | go mod tidy - go test -v -coverpkg=./... -coverprofile=coverage.out ./... + sudo go test -v -ldflags="-X 'github.com/taosdata/taoskeeper/version.IsEnterprise=true'" -coverpkg=./... -coverprofile=coverage.out ./... go tool cover -func=coverage.out - name: Clean up diff --git a/cmake/cmake.define b/cmake/cmake.define index 3fa99a7c9322..ff582261b30f 100644 --- a/cmake/cmake.define +++ b/cmake/cmake.define @@ -191,48 +191,11 @@ ELSE() SET(COMPILER_SUPPORT_AVX512VL false) ELSE() CHECK_C_COMPILER_FLAG("-mfma" COMPILER_SUPPORT_FMA) + CHECK_C_COMPILER_FLAG("-mavx" COMPILER_SUPPORT_AVX) + CHECK_C_COMPILER_FLAG("-mavx2" COMPILER_SUPPORT_AVX2) CHECK_C_COMPILER_FLAG("-mavx512f" COMPILER_SUPPORT_AVX512F) CHECK_C_COMPILER_FLAG("-mavx512vbmi" COMPILER_SUPPORT_AVX512BMI) CHECK_C_COMPILER_FLAG("-mavx512vl" COMPILER_SUPPORT_AVX512VL) - - INCLUDE(CheckCSourceRuns) - SET(CMAKE_REQUIRED_FLAGS "-mavx") - check_c_source_runs(" - #include - int main() { - __m256d a, b, c; - double buf[4] = {0}; - a = _mm256_loadu_pd(buf); - b = _mm256_loadu_pd(buf); - c = _mm256_add_pd(a, b); - _mm256_storeu_pd(buf, c); - for (int i = 0; i < sizeof(buf) / sizeof(buf[0]); ++i) { - IF (buf[i] != 0) { - return 1; - } - } - return 0; - } - " COMPILER_SUPPORT_AVX) - - SET(CMAKE_REQUIRED_FLAGS "-mavx2") - check_c_source_runs(" - #include - int main() { - __m256i a, b, c; - int buf[8] = {0}; - a = _mm256_loadu_si256((__m256i *)buf); - b = _mm256_loadu_si256((__m256i *)buf); - c = _mm256_and_si256(a, b); - _mm256_storeu_si256((__m256i *)buf, c); - for (int i = 0; i < sizeof(buf) / sizeof(buf[0]); ++i) { - IF (buf[i] != 0) { - return 1; - } - } - return 0; - } - " COMPILER_SUPPORT_AVX2) ENDIF() IF(COMPILER_SUPPORT_SSE42) diff --git a/docs/examples/node/package.json b/docs/examples/node/package.json index 3f5f54e9d7c4..14303c8f3748 100644 --- a/docs/examples/node/package.json +++ b/docs/examples/node/package.json @@ -4,6 +4,6 @@ "main": "index.js", "license": "MIT", "dependencies": { - "@tdengine/websocket": "^3.1.0" + "@tdengine/websocket": "^3.1.1" } } diff --git a/docs/examples/node/websocketexample/sql_example.js b/docs/examples/node/websocketexample/sql_example.js index 0a09228d970f..c120b84d99fe 100644 --- a/docs/examples/node/websocketexample/sql_example.js +++ b/docs/examples/node/websocketexample/sql_example.js @@ -3,7 +3,6 @@ const taos = require("@tdengine/websocket"); let dsn = 'ws://localhost:6041'; async function createConnect() { - try { let conf = new taos.WSConfig(dsn); conf.setUser('root'); diff --git a/docs/examples/node/websocketexample/tmq_seek_example.js b/docs/examples/node/websocketexample/tmq_seek_example.js index f676efe36f6d..be4d8ddfa4a5 100644 --- a/docs/examples/node/websocketexample/tmq_seek_example.js +++ b/docs/examples/node/websocketexample/tmq_seek_example.js @@ -10,7 +10,6 @@ const groupId = "group1"; const clientId = "client1"; async function createConsumer() { - let groupId = "group1"; let clientId = "client1"; let configMap = new Map([ diff --git a/docs/zh/05-basic/03-query.md b/docs/zh/05-basic/03-query.md index 4a1771d5fd72..b6f172829ae3 100644 --- a/docs/zh/05-basic/03-query.md +++ b/docs/zh/05-basic/03-query.md @@ -8,7 +8,7 @@ toc_max_heading_level: 4 ## 基本查询 -为了更好的介绍 TDengine 数据查询，使用 如下 taosBenchmark 命令，生成本章内容需要的时序数据。 +为了更好的介绍 TDengine 数据查询，使用如下 taosBenchmark 命令，生成本章内容需要的时序数据。 ```shell taosBenchmark --start-timestamp=1600000000000 --tables=100 --records=10000000 --time-step=10000 @@ -25,7 +25,7 @@ ORDER BY ts DESC LIMIT 5; ``` -上面的 SQL，从超级表 `meters` 中查询出电压 `voltage` 大于 230 的记录，按时间降序排列，且仅输出前 5 行。查询结果如下： +上面的 SQL，从超级表 `meters` 中查询出电压 `voltage` 大于 230V 的记录，按时间降序排列，且仅输出前 5 行。查询结果如下： ```text ts | current | voltage | phase | groupid | location | diff --git a/docs/zh/06-advanced/06-data-analysis/01-arima.md b/docs/zh/06-advanced/06-data-analysis/01-arima.md index 1668da453c17..6799d488871c 100644 --- a/docs/zh/06-advanced/06-data-analysis/01-arima.md +++ b/docs/zh/06-advanced/06-data-analysis/01-arima.md @@ -3,8 +3,52 @@ title: "ARIMA" sidebar_label: "ARIMA" --- -本节讲述如何 ARIMA 算法的使用方法。 +本节讲述 ARIMA 算法模型的使用方法。 ## 功能概述 -…… \ No newline at end of file +ARIMA 即自回归移动平均模型(Autoregressive Integrated Moving Average, ARIMA)，也记作 ARIMA(p,d,q)，是统计模型中最常见的一种用来进行时间序列预测的模型。 +ARIMA模型是一种自回归模型，只需要自变量即可预测后续的值。ARIMA模型要求时序数据是**平稳**，或经过差分处理后平稳，如果是不平稳的数据，**无法**获得正确的结果。 + +>平稳的时间序列：其性质不随观测时间的变化而变化。具有趋势或季节性的时间序列不是平稳时间序列——趋势和季节性使得时间序列在不同时段呈现不同性质。 + +以下参数可以动态输入控制预测过程中生成 合适的 ARIMA 的模型。 + +- p= 自回归模型阶数 +- d= 差分阶数 +- q= 移动平均模型阶数 + + +### 参数 +分析平台中使用自动化的 ARIMA 模型进行计算，因此每次计算的时候会根据输入的数据自动拟合最合适的模型，然后根据该模型进行预测输出结果。 +|参数名称|说明|必填项| +|---|---|---| +|period|输入时间序列数据每个周期包含的数据点个数。如果不设置该参数或则该参数设置为 0， 将使用非季节性/周期性的 ARIMA 模型预测。|选填| +|start_p| 自回归模型阶数的 起始值，0 开始的整数，不推荐大于 10 |选填| +|max_p| 自回归模型阶数的 结束值，0 开始的整数，不推荐大于 10 |选填| +|start_q| 移动平均模型阶数的起始值， 0 开始的整数，不推荐大于 10 |选填| +|max_q| 移动平均模型阶数的结束值， 0 开始的整数，不推荐大于 10 |选填| +|d| 差分阶数|选填| + +`start_p`、`max_p` `start_q` `max_q` 四个参数约束了模型在多大的范围内去搜寻合适的最优解。相同输入数据的条件下，参数范围越大，消耗的资源越多，系统响应的时间越长。 + +### 示例及结果 +针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期，start_p 起始是 1， 最大拟合是 5，start_q是1，最大值是5，预测结果中返回 95% 置信区间范围边界。 +``` +FORECAST(i32, "algo=arima,alpha=95,period=10, start_p=1, max_p=5, start_q=1, max_q=5") +``` + +```json5 +{ +"rows": fc_rows, // 预测结果的行数 +"period": period, // 返回结果的周期性，同输入 +"alpha": alpha, // 返回结果的置信区间，同输入 +"algo": "arima", // 返回结果使用的算法 +"mse":mse, // 拟合输入时序数据时候生成模型的最小均方误差(MSE) +"res": res // 列模式的结果 +} +``` + +### 参考文献 +- https://en.wikipedia.org/wiki/Autoregressive_moving-average_model +- https://baike.baidu.com/item/%E8%87%AA%E5%9B%9E%E5%BD%92%E6%BB%91%E5%8A%A8%E5%B9%B3%E5%9D%87%E6%A8%A1%E5%9E%8B/5023931?fromtitle=ARMA%E6%A8%A1%E5%9E%8B&fromid=8048415 diff --git a/docs/zh/06-advanced/06-data-analysis/02-holtwinters.md b/docs/zh/06-advanced/06-data-analysis/02-holtwinters.md new file mode 100644 index 000000000000..470ef462539f --- /dev/null +++ b/docs/zh/06-advanced/06-data-analysis/02-holtwinters.md @@ -0,0 +1,43 @@ +--- +title: "HoltWinters" +sidebar_label: "HoltWinters" +--- + +本节讲述 HoltWinters 算法模型的使用方法。 + +## 功能概述 +HoltWinters模型又称为多次指数平滑模型（EMA）。对含有线性趋势和周期波动的非平稳序列适用，利用指数平滑法让模型参数不断适应非平稳序列的变化，并对未来趋势进行**短期**预测。 +HoltWinters有两种不同的季节性组成部分，当季节变化在该时间序列中大致保持不变时，通常选择**加法模型**；而当季节变化与时间序列的水平成比例变化时，通常选择**乘法模型**。 +该模型对于返回数据也不提供计算的置信区间范围结果。在 95% 置信区间的上下界结果与预测结果相同。 + + +### 参数 + +分析平台中使用自动化的 ARIMA 模型进行计算，因此每次计算的时候会根据输入的数据自动拟合最合适的模型，然后根据该模型进行预测输出结果。 +|参数名称|说明|必填项| +|---|---|---| +|period| 输入时间序列数据每个周期包含的数据点个数。如果不设置该参数或则该参数设置为 0， 将使用一次（简单）指数平滑方式进行数据拟合，并据此进行未来数据的预测|选填| +|trend| 趋势模型使用加法模型还是乘法模型|选填| +|seasonal| 季节性采用加法模型还是乘法模型|选填| + +参数 `trend` 和 `seasonal`的均可以选择 `add` （加法模型）或 `mul`（乘法模型）。 + +### 示例及结果 +针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期，趋势采用乘法模型，季节采用乘法模型 +``` +FORECAST(i32, "algo=holtwinters,period=10,trend=mul,seasonal=mul") +``` + +```json5 +{ +"rows": rows, // 结果的行数 +"period": period, // 返回结果的周期性， 该结果与输入的周期性相同，如果没有周期性，该值为 0 +"algo": 'holtwinters' // 返回结果使用的计算模型 +"mse":mse, // 最小均方误差（minmum square error） +"res": res // 具体的结果，按照列形式返回的结果。一般意义上包含了 两列[timestamp][fc_results]。 +} +``` + +### 参考文献 +- https://en.wikipedia.org/wiki/Exponential_smoothing +- https://orangematter.solarwinds.com/2019/12/15/holt-winters-forecasting-simplified/ diff --git a/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md b/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md new file mode 100644 index 000000000000..8f1e1f064a79 --- /dev/null +++ b/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md @@ -0,0 +1,46 @@ +--- +title: "Anomaly-detection" +sidebar_label: "Anomaly-detection" +--- + +本节讲述 异常检测 算法模型的使用方法。 + +## 概述 +分析平台提供了 6 种异常检查模型，6 种异常检查模型分为 3 个类别，分别属于基于统计的异常检测模型、基于数据密度的检测模型、基于深度学习的异常检测模型。在不指定异常检测使用的方法的情况下，默认调用 iqr 的方法进行计算。 + + +### 统计学异常检测方法 + +- k-sigma[1]: 即 ***68–95–99.7 rule*** 。***k***值默认为3， 即序列均值的 3 倍标准差范围为边界，超过边界的是异常值。KSigma 要求数据整体上服从正态分布，如果一个点偏离均值K倍标准差，则该点被视为异常点. + +|参数名称|说明|是否必选|默认值| +|---|---|---|---| +|k|标准差倍数|选填|3| + + +- IQR[2]：四分位距 (Interquartile range, IQR) 是一种衡量变异性的方法. 四分位数将一个按等级排序的数据集划分为四个相等的部分。即 Q1（第 1 个四分位数）、Q2（第 2 个四分位数）和 Q3（第 3 个四分位数）。IQR 定义为 Q3–Q1，位于 Q3+1.5 。无输入参数。 + +- Grubbs[3]: 又称为 Grubbs' test，即最大标准残差测试。Grubbs 通常用作检验最大值、最小值偏离均值的程度是否为异常，该单变量数据集遵循近似标准正态分布。非正态分布数据集不能使用该方法。无输入参数。 + +- SHESD[4]： 带有季节性的 ESD 检测算法。ESD 可以检测时间序列数据的多异常点。需要指定异常点比例的上界***k***，最差的情况是至多49.9%。数据集的异常比例一般不超过5% + +|参数名称|说明|是否必选|默认值| +|---|---|---|---| +|k|异常点在输入数据集中占比，范围是$`1\le K \le 49.9`$ |选填|5| + + +### 基于数据密度的检测方法 +LOF[5]: 局部离群因子(LOF，又叫局部异常因子)算法是Breunig于2000年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的top(n)个点。 + + +### 基于深度学习的检测方法 +使用自动编码器的异常检测模型。可以对具有周期性的数据具有较好的检测结果。但是使用该模型需要针对输入的时序数据进行训练，同时将训练完成的模型部署到服务目录中，才能够运行与使用。 + + +### 参考文献 +1. https://en.wikipedia.org/wiki/68%E2%80%9395%E2%80%9399.7_rule +2. https://en.wikipedia.org/wiki/Interquartile_range +3. Adikaram, K. K. L. B.; Hussein, M. A.; Effenberger, M.; Becker, T. (2015-01-14). "Data Transformation Technique to Improve the Outlier Detection Power of Grubbs's Test for Data Expected to Follow Linear Relation". Journal of Applied Mathematics. 2015: 1–9. doi:10.1155/2015/708948. +4. Hochenbaum, O. S. Vallis, and A. Kejariwal. 2017. Automatic Anomaly Detection in the Cloud Via Statistical Learning. arXiv preprint arXiv:1704.07706 (2017). +5. Breunig, M. M.; Kriegel, H.-P.; Ng, R. T.; Sander, J. (2000). LOF: Identifying Density-based Local Outliers (PDF). Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data. SIGMOD. pp. 93–104. doi:10.1145/335191.335388. ISBN 1-58113-217-4. + diff --git a/docs/zh/06-advanced/06-data-analysis/addins.md b/docs/zh/06-advanced/06-data-analysis/addins.md new file mode 100644 index 000000000000..867bd9ff235a --- /dev/null +++ b/docs/zh/06-advanced/06-data-analysis/addins.md @@ -0,0 +1,167 @@ +--- +title: "addins" +sidebar_label: "addins" +--- + +本节说明如何将自己开发的新预测算法和异常检测算法整合到 TDengine 分析平台， 并能够通过 SQL 语句进行调用。 + +## 目录结构 + +![数据分析功能架构图](./pic/dir.png) + +|目录|说明| +|---|---| +|taos|Python 源代码目录，其下包含了算法具体保存目录 algo，放置杂项目录 misc， 单元测试和集成测试目录 test。 algo目录下 ad 放置异常检测算法代码， fc 放置预测算法代码| +|script|是安装脚本和发布脚本放置目录| +|model|放置针对数据集完成的训练模型| +|cfg| 配置文件目录| + +## 约定与限制 + +定义异常检测算法的 Python 代码文件 需放在 /taos/algo/ad 目录中，预测算法 Python 代码文件需要放在 /taos/algo/fc 目录中，以确保系统启动的时候能够正常加载对应目录下的 Python 文件。 + + +### 类命名规范 + +算法类的名称需要 以下划线开始，以 Service 结尾。例如：_KsigmaService 是 KSigma 异常检测算法的实现类。 + +### 类继承约定 + +异常检测算法需要从 `AbstractAnomalyDetectionService` 继承，并实现其核心抽象方法 `execute`. +预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`。 + +### 类属性初始化 +每个算法实现的类需要静态初始化两个类属性，分别是 + +`name`: 的触发调用关键词，全小写英文字母。 +`desc`：该算法的描述信息。 + +### 核心方法输入与输出约定 + +`execute` 是算法处理的核心方法。调用该方法的时候， `self.list` 已经设置好输入数组。 +异常检测输出结果 + +`execute` 的返回值是长度与 `self.list` 相同的数组，数组位置为 -1 的即为异常值点。例如：输入数组是 [2, 2, 2, 2, 100]， 如果 100 是异常点，那么返回值是 [1, 1, 1, 1, -1]。 +预测输出结果 + +对于预测算法， `AbstractForecastService` 的对象属性说明如下： + +|属性名称|说明|默认值| +|---|---|---| +|period|输入时序数据的周期性，多少个数据点表示一个完整的周期。如果没有周期性，那么设置为 0 即可。| 0| +|start_ts|预测数据的开始时间| 0| +|time_step|预测结果的两个数据点之间时间间隔|0 | +|fc_rows|预测结果数量| 0 | +|return_conf|返回结果中是否包含执行区间范围，如果算法计算结果不包含置信区间，那么上界和下界与自身相同| 1| +|conf|执行区间分位数 0.05| + + +预测返回结果如下： +```python +return { + "rows": self.fc_rows, # 预测数据行数 + "period": self.period, # 数据周期性，同输入 + "algo": "holtwinters", # 预测使用的算法 + "mse": mse, # 预测算法的 mse + "res": res # 结果数组 [时间戳数组, 预测结果数组, 预测结果执行区间下界数组，预测结果执行区间上界数组] +} +``` + + +## 示例代码 + +```python +import numpy as np +from service import AbstractAnomalyDetectionService + +# 算法实现类名称 需要以下划线 "_" 开始，并以 Service 结束，如下 _IqrService 是 IQR 异常检测算法的实现类。 +class _IqrService(AbstractAnomalyDetectionService): + """ IQR algorithm 定义类，从 AbstractAnomalyDetectionService 继承，并实现 AbstractAnomalyDetectionService类的抽象函数 """ + + # 定义算法调用关键词，全小写ASCII码(必须添加) + name = 'iqr' + + # 该算法的描述信息(建议添加) + desc = """found the anomaly data according to the inter-quartile range""" + + def __init__(self): + super().__init__() + + def execute(self): + """ execute 是算法实现逻辑的核心实现，直接修改该实现即可 """ + + # self.list 是输入数值列，list 类型，例如：[1,2,3,4,5]。设置 self.list 的方法在父类中已经进行了定义。实现自己的算法，修改该文件即可，以下代码使用自己的实现替换即可。 + #lower = np.quantile(self.list, 0.25) + #upper = np.quantile(self.list, 0.75) + + #min_val = lower - 1.5 * (upper - lower) + #max_val = upper + 1.5 * (upper - lower) + #threshold = [min_val, max_val] + + # 返回值是与输入数值列长度相同的数据列，异常值对应位置是 -1。例如上述输入数据列，返回数值列是 [1, 1, 1, 1, -1],表示 [5] 是异常值。 + return [-1 if k < threshold[0] or k > threshold[1] else 1 for k in self.list] + + + def set_params(self, params): + """该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑""" + pass +``` + + +## 单元测试 + +在测试文件目录中的 anomaly_test.py 中增加单元测试用例。 +```python +def test_iqr(self): + """ 测试 _IqrService 类 """ + s = loader.get_service("iqr") + + # 设置需要进行检测的输入数据 + s.set_input_list(AnomalyDetectionTest.input_list) + + # 测试 set_params 的处理逻辑 + try: + s.set_params({"k": 2}) + except ValueError as e: + self.assertEqual(1, 0) + + r = s.execute() + + # 绘制异常检测结果 + draw_ad_results(AnomalyDetectionTest.input_list, r, "iqr") + + # 检查结果 + self.assertEqual(r[-1], -1) + self.assertEqual(len(r), len(AnomalyDetectionTest.input_list)) +``` + +## 需要模型的算法 + +针对特定数据集，进行模型训练的算法，在训练完成后。需要将训练得到的模型保存在 model 目录中。需要注意的是，针对每个算法，需要建立独立的文件夹。例如 auto_encoder 的训练算法在 model 目录下建立了， autoencoder的目录，使用该算法针对不同数据集训练得到的模型，均需要放置在该目录下。 + +训练完成后的模型，使用 joblib 进行保存。 + +并在 model 目录下建立对应的文件夹存放该模型。 + +保存模型的调用，可参考 encoder.py 的方式，用户通过调用 set_params 方法，并指定参数 {"model": "ad_encoder_keras"} 的方式，可以调用该模型进行计算。 + +具体的调用方式如下： + +```python +def test_autoencoder_ad(self): + # 获取特定的算法服务 + s = loader.get_service("ac") + data = self.__load_remote_data_for_ad() + + # 设置异常检查的输入数据 + s.set_input_list(data) + + # 指定调用的模型，该模型是之前针对该数据集进行训练获得 + s.set_params({"model": "ad_encoder_keras"}) + # 执行检查动作，并返回结果 + r = s.execute() + + num_of_error = -(sum(filter(lambda x: x == -1, r))) + self.assertEqual(num_of_error, 109) +``` + diff --git a/docs/zh/06-advanced/06-data-analysis/index.md b/docs/zh/06-advanced/06-data-analysis/index.md index a1ca53d7d0c7..e3bf2f4158f4 100644 --- a/docs/zh/06-advanced/06-data-analysis/index.md +++ b/docs/zh/06-advanced/06-data-analysis/index.md @@ -5,9 +5,314 @@ title: 数据分析功能 ## 概述 -TDengine 提供数据分析功能的扩展组件，通过引入 ANode，TDengine 能够支持时间序列的机器学习分析 - -下图展示了数据分析的技术架构。 +TDengine 通过 ANode(AnalysisNode) 是提供数据分析功能的扩展组件，通过 Restful 接口提供分析服务，从而拓展 TDengine 的功能，支持时间序列高级分析功能。 +ANode 是无状态的数据分析节点，集群中可以存在多个 ANode节点，相互之间没有关联。将 ANode 注册到 TDengine 集群以后，通过 SQL 语句即可调用并完成时序分析任务。 +下图是数据分析的技术架构示意图。 ![数据分析功能架构图](./pic/data-analysis.png) +## 安装部署 +### 环境准备 +ANode 的要求节点上准备有 Python 3.10 及以上版本以及相应的Python包自动安装组件 Pip ，同时请确保能够正常连接互联网。 + +### 安装及卸载 +使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengien 的安装流程一致。 + +```bash +tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz +cd TDengine-enterprise-anode-1.0.0 +sudo ./install.sh +``` + +卸载 ANode，执行命令 `rmtaosanode` 即可。 + +### 其他 +为了避免 ANode 安装后影响目标节点现有的 Python 库。 ANode 使用 Python 虚拟环境运行，安装后的默认 Python 目录处于 `/var/lib/taos/taosanode/venv/`。为了避免反复安装虚拟环境带来的开销，卸载 ANode 并不会自动删除该虚拟环境，如果您确认不需要 Python 的虚拟环境，可以手动删除。 + +## 启动及停止服务 +安装 ANode 以后，可以使用`systemctl`来管理 ANode 的服务。使用如下命令可以启动/停止/检查状态。 + +```bash +systemctl start taosanoded +systemctl stop taosanoded +systemctl status taosanoded +``` + +## 目录及配置说明 +|目录/文件|说明| +|---------------|------| +|/usr/local/taos/taosanode/bin|可执行文件目录| +|/usr/local/taos/taosanode/resource|资源文件目录，链接到文件夹 /var/lib/taos/taosanode/resource/| +|/usr/local/taos/taosanode/lib|库文件目录| +|/var/lib/taos/taosanode/model/|模型文件目录，链接到文件夹 /var/lib/taos/taosanode/model| +|/var/log/taos/taosanode/|日志文件目录| +|/etc/taos/taosanode.ini|配置文件| + +### 配置说明 + +Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 的配置和 uWSGI 的配置在同一个配置文件中，具体如下： + +```ini +[uwsgi] +# charset +env=LC_ALL=en_US.UTF-8 + +# ip:port +http = 127.0.0.1:6050 + +# the local unix socket file than communicate to Nginx +#socket = 127.0.0.1:8001 +#socket-timeout=10 + +# base directory +chdir = /usr/local/taos/taosanode/lib + +# initialize python file +wsgi-file = /usr/local/taos/taosanode/lib/app.py + +# invoke app model +callable = app + +# auto remove unix Socket and pid file when stopping +vacuum = true + +# socket exec model +#chmod-socket = 664 + +# uWSGI pid +uid=root + +# uWSGI gid +gid=root + +# main process +master = true + +# the number of worker processes +processes = 2 + +# pid file +pidfile = /usr/local/taos/taosanode/uwsgi.pid + +# enable threads +enable-threads=true + +# the number of threads for each process +threads=2 + +# memory useage report +memory-report = true +reload-mercy = 10 + +# conflict with systemctl, so do NOT uncomment this +# daemonize = /var/log/taos/taosanode/taosanode.log + +# set log +logto = /var/log/taos/taosanode/taosanode.log + +# monitor server +stats = 127.0.0.1:8387 + +# python virtual environment directory +virtualenv = /usr/local/taos/taosanode/venv/ + +[taosanode] +# default app log file +app-log = /var/log/taos/taosanode/taosanode.app.log + +# model storage directory +model-dir=/usr/local/taos/taosanode/model/ + +# default log level +log-level = DEBUG +``` + +**提示** +请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而无法正常启动。 + + +## ANode 基本操作 +### 管理 ANode +#### 创建 ANode +```sql +CREATE ANODE {node_url} +``` +node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。 + +#### 查看 ANode +列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。 +```sql +SHOW ANODES; +``` + +#### 查看提供的时序数据分析服务 + +```SQL +SHOW ANODES FULL; +``` + +#### 强制刷新 TDengine 集群中分析算法缓存 +```SQL +UPDATE ANODE {node_id} +UPDATE ALL ANODES +``` + +#### 删除 ANode +```sql +DROP ANODE {anode_id} +``` +删除 ANode 只是将 ANode 从 TDengine 集群中删除，管理 ANode 的启停仍然需要使用`systemctl`命令。 + +### 时序数据分析功能 + +#### 白噪声检查 + +平台提供 Restful的服务检测输入时间序列是否是白噪声时间序列（White Noise Data, WND），白噪声时间序列及随机数序列。 +此外，分析平台要求输入的数据不能是 , 因此针对的所有数据均默认进行 白噪声检查。当前白噪声检查采用通行的 `Ljung-Box`检验，`Ljung-Box` 统计量检查过程需要遍历整个输入序列并进行计算。 +如果用户能够明确输入序列一定不是白噪声序列，那么可以通过输入参数，指定预测之前忽略该检查，从而节省分析过程的 CPU 计算资源。 +同时支持独立地针对输入序列进行白噪声检测（该检测功能暂不独立对外开放）。 + + +#### 数据重采样和时间戳对齐 + +数据分析平台支持将输入的数据进行重采样的预处理，从而确保输出结果按照用户指定的等间隔进行处理。处理过程分为两种类别： + +- 数据时间戳对齐。由于真实数据时间可能并非严格按照查询指定的时间戳输入。此时数据平台将自动将数据的时间间隔按照指定的时间间隔进行对齐。例如有输入时间序列：[11, 22, 29, 41]，用户指定时间间隔为 10，那么该序列将被对齐重整为以下序列 [10, 20, 30, 40]。 +- 数据时间重采样。用户输入的时间序列其采样频率超过了指定的查询需要获得结果的时间间隔，例如输入原始数据是 5， 但是输出结果的频率是 10. [0， 5， 10， 15， 20， 25， 30]，那么该输入数据列将重采用为间隔 为 10 的输入序列，其结果如下 [0, 10, 20，30]。[5, 15, 25] 处的数据将被丢弃。 + +需要注意的是，数据输入平台不支持缺失数据补齐后进行的预测分析，如果输入时间序列数据[11, 22, 29, 49]，并且用户要求的时间间隔为 10， 重整对齐后的序列是 [10, 20, 30, 50] 那么该序列进行预测分析将返回错误。 + + +#### 时序数据异常检测 +异常检测是针对输入的时序数据，使用预设或用户指定的算法确定时间序列中**可能**出现异常时间序列点，对于时间序列中若干个连续的异常点，将自动合并成为一个连续的（闭区间）异常窗口。对于只有单个点的场景，异常窗口窗口退化成为一个起始时间和结束时间相同的点。 +异常检测生成的异常窗口受检测算法和算法参数的共同影响，对于异常窗口范围内的数据，可以应用 TDengine 提供的聚合和标量函数进行查询或变换处理。 +对于输入时间序列 (1, 20), (2, 22), (3, 91), (4, 120), (5, 18), (6, 19)。系统检测到 (3, 91), (4, 120) 为异常点，那么返回的异常窗口是闭区间 [3, 4]。 + + +##### 语法 + +```SQL +ANOMALY_WINDOW(column_name, option_expr) + +option_expr: {" +algo=expr1 +[,wncheck=1|0] +[,expr2] +"} +``` + +1. `column`：进行时序数据异常检测的输入数据列，当前只支持单列输入，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。 +2. `options`：字符串。其中使用 K/V 调用异常检测的算法，及与算法相关的参数。采用 逗号分隔的K/V字符串表示，其中的字符串不需要使用单引号、双引号、或转意号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma, k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。 +3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。 +4. 输入数据默认进行白噪声检查，如果检查结果是输入数据是白噪声，将不会有任何（异常）窗口信息返回。 + +**参数说明** +|参数|含义|默认值| +|---|---|---| +|algo|异常检测调用的算法|iqr| +|wncheck|对输入数据列是否进行白噪声检查|取值为0或者1，默认值为 1，表示进行白噪声检查| + +异常检测的返回结果以窗口的形式呈现，因此窗口查询相关的伪列在这种场景下仍然可用。可以使用的伪列如下： +1. `_WSTART`： 异常窗口开始时间戳 +2. `_WEND`：异常窗口结束时间戳 +3. `_WDURATION`：异常窗口持续时间 + +**示例** +```SQL +--- 使用 iqr 算法进行异常检测，检测列 i32 列。 +SELECT _wstart, _wend, SUM(i32) +FROM ai.atb +ANOMALY_WINDOW(i32, "algo=iqr"); + +--- 使用 ksigma 算法进行异常检测，输入参数 k 值为 2，检测列 i32 列 +SELECT _wstart, _wend, SUM(i32) +FROM ai.atb +ANOMALY_WINDOW(i32, "algo=ksigma,k=2"); +``` + +``` +taos> SELECT _wstart, _wend, count(*) FROM ai.atb ANOMAYL_WINDOW(i32); + _wstart | _wend | count(*) | +============================================================================ + 2020-01-01 00:00:16.000 | 2020-01-01 00:00:16.001 | 1 | +Query OK, 1 row(s) in set (0.028946s) +``` + + +**可用异常检测算法** +- iqr +- ksigma +- grubbs +- lof +- shesd +- tac + + +#### 时序数据预测 +数据预测以一段训练数据作为输入，预测接下来一个连续时间区间内，时序数据的趋势。 + +##### 语法 +```SQL +FORECAST(column_expr, option_expr) + +option_expr: {" +algo=expr1 +[,wncheck=1|0] +[,conf=conf_val] +[,every=every_val] +[,rows=rows_val] +[,start=start_ts_val] +[,expr2] +"} + +``` +1. `column_expr`：预测的时序数据列。与异常检测相同，只支持数值类型输入。 +2. `options`：异常检测函数的参数，使用规则与 anomaly_window 相同。预测还支持`conf`, `every`, `rows`, `start`, `rows` 几个参数，其含义如下： + +**参数说明** + +|参数|含义|默认值| +|---|---|---| +|algo|预测分析使用的算法|holtwinters| +|wncheck|白噪声（white noise data）检查|默认值为 1，0 表示不进行检查| +|conf|预测数据的置信区间范围 ，取值范围[0, 100]|95| +|every|预测数据的采样间隔|输入数据的采样间隔| +|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样时间段| +|rows|预测结果的记录数|10| + +1. 预测查询结果新增了三个伪列，具体如下： `_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果 +2. 更改参数 `START`：返回预测结果的起始时间，改变这个起始时间不会影响返回的预测数值，只影响起始时间。 +3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。 +4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。 + +**示例** + +```SQL +--- 使用 arima 算法进行预测，预测结果是 10 条记录（默认值），数据进行白噪声检查，默认置信区间 95%. +SELECT _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima") +FROM ai.ftb; + +--- 使用 arima 算法进行预测，输入数据的是周期数据，每10个采样点是一个周期。返回置信区间是 95%. +SELECT _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10") +FROM ai.ftb; +``` +``` +taos> select _flow, _fhigh, _frowts, forecast(i32) from ai.ftb; + _flow | _fhigh | _frowts | forecast(i32) | +======================================================================================== + 10.5286684 | 41.8038254 | 2020-01-01 00:01:35.001 | 26 | + -21.9861946 | 83.3938904 | 2020-01-01 00:01:36.001 | 30 | + -78.5686035 | 144.6729126 | 2020-01-01 00:01:37.001 | 33 | + -154.9797363 | 230.3057709 | 2020-01-01 00:01:38.001 | 37 | + -253.9852905 | 337.6083984 | 2020-01-01 00:01:39.001 | 41 | + -375.7857971 | 466.4594727 | 2020-01-01 00:01:40.001 | 45 | + -514.8043823 | 622.4426270 | 2020-01-01 00:01:41.001 | 53 | + -680.6343994 | 796.2861328 | 2020-01-01 00:01:42.001 | 57 | + -868.4956665 | 992.8603516 | 2020-01-01 00:01:43.001 | 62 | + -1076.1566162 | 1214.4498291 | 2020-01-01 00:01:44.001 | 69 | +``` + + +**可用预测算法** +- arima +- holtwinters diff --git a/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png b/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png index 1598238f2cc7..44fd82832f3e 100644 Binary files a/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png and b/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png differ diff --git a/docs/zh/06-advanced/06-data-analysis/pic/dir.png b/docs/zh/06-advanced/06-data-analysis/pic/dir.png new file mode 100644 index 000000000000..d5aafb44274b Binary files /dev/null and b/docs/zh/06-advanced/06-data-analysis/pic/dir.png differ diff --git a/docs/zh/14-reference/03-taos-sql/02-database.md b/docs/zh/14-reference/03-taos-sql/02-database.md index 7d040a2c44f7..24eca979522e 100644 --- a/docs/zh/14-reference/03-taos-sql/02-database.md +++ b/docs/zh/14-reference/03-taos-sql/02-database.md @@ -30,6 +30,7 @@ database_option: { | SINGLE_STABLE {0 | 1} | TABLE_PREFIX value | TABLE_SUFFIX value + | DNODES value | TSDB_PAGESIZE value | WAL_LEVEL {1 | 2} | WAL_FSYNC_PERIOD value @@ -63,19 +64,20 @@ database_option: { - MAXROWS：文件块中记录的最大条数，默认为 4096 条。 - MINROWS：文件块中记录的最小条数，默认为 100 条。 - KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于3倍的 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。企业版支持[多级存储](https://docs.taosdata.com/tdinternal/arch/#%E5%A4%9A%E7%BA%A7%E5%AD%98%E5%82%A8)功能, 因此, 可以设置多个保存时间（多个以英文逗号分隔，最多 3 个，满足 keep 0 \<= keep 1 \<= keep 2，如 KEEP 100h,100d,3650d）; 社区版不支持多级存储功能（即使配置了多个保存时间, 也不会生效, KEEP 会取最大的保存时间）。 -- STT_TRIGGER：表示落盘文件触发文件合并的个数。默认为 1，范围 1 到 16。对于少表高频场景，此参数建议使用默认配置，或较小的值；而对于多表低频场景，此参数建议配置较大的值。 +- STT_TRIGGER：表示落盘文件触发文件合并的个数。开源版本固定为 1，企业版本可设置范围为 1 到 16。对于少表高频写入场景，此参数建议使用默认配置；而对于多表低频写入场景，此参数建议配置较大的值。 - SINGLE_STABLE：表示此数据库中是否只可以创建一个超级表，用于超级表列非常多的情况。 - 0：表示可以创建多张超级表。 - 1：表示只可以创建一张超级表。 - TABLE_PREFIX：当其为正值时，在决定把一个表分配到哪个 vgroup 时要忽略表名中指定长度的前缀；当其为负值时，在决定把一个表分配到哪个 vgroup 时只使用表名中指定长度的前缀；例如，假定表名为 "v30001"，当 TSDB_PREFIX = 2 时 使用 "0001" 来决定分配到哪个 vgroup ，当 TSDB_PREFIX = -2 时使用 "v3" 来决定分配到哪个 vgroup - TABLE_SUFFIX：当其为正值时，在决定把一个表分配到哪个 vgroup 时要忽略表名中指定长度的后缀；当其为负值时，在决定把一个表分配到哪个 vgroup 时只使用表名中指定长度的后缀；例如，假定表名为 "v30001"，当 TSDB_SUFFIX = 2 时 使用 "v300" 来决定分配到哪个 vgroup ，当 TSDB_SUFFIX = -2 时使用 "01" 来决定分配到哪个 vgroup。 - TSDB_PAGESIZE：一个 VNODE 中时序数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB到 16 MB。 +- DNODES：指定 VNODE 所在的 DNODE 列表，如 '1,2,3'，以逗号区分且字符间不能有空格，仅企业版支持。 - WAL_LEVEL：WAL 级别，默认为 1。 - 1：写 WAL，但不执行 fsync。 - 2：写 WAL，而且执行 fsync。 - WAL_FSYNC_PERIOD：当 WAL_LEVEL 参数设置为 2 时，用于设置落盘的周期。默认为 3000，单位毫秒。最小为 0，表示每次写入立即落盘；最大为 180000，即三分钟。 -- WAL_RETENTION_PERIOD: 为了数据订阅消费，需要WAL日志文件额外保留的最大时长策略。WAL日志清理，不受订阅客户端消费状态影响。单位为 s。默认为 3600，表示在 WAL 保留最近 3600 秒的数据，请根据数据订阅的需要修改这个参数为适当值。 -- WAL_RETENTION_SIZE：为了数据订阅消费，需要WAL日志文件额外保留的最大累计大小策略。单位为 KB。默认为 0，表示累计大小无上限。 +- WAL_RETENTION_PERIOD: 为了数据订阅消费，需要 WAL 日志文件额外保留的最大时长策略。WAL 日志清理，不受订阅客户端消费状态影响。单位为 s。默认为 3600，表示在 WAL 保留最近 3600 秒的数据，请根据数据订阅的需要修改这个参数为适当值。 +- WAL_RETENTION_SIZE：为了数据订阅消费，需要 WAL 日志文件额外保留的最大累计大小策略。单位为 KB。默认为 0，表示累计大小无上限。 ### 创建数据库示例 ```sql diff --git a/docs/zh/14-reference/03-taos-sql/07-tag-index.md b/docs/zh/14-reference/03-taos-sql/07-tag-index.md index 383c5b2a1f0a..364d465ba394 100644 --- a/docs/zh/14-reference/03-taos-sql/07-tag-index.md +++ b/docs/zh/14-reference/03-taos-sql/07-tag-index.md @@ -11,7 +11,7 @@ description: 使用标签索引提升查询性能 创建索引的语法如下 ```sql -CREATE INDEX index_name ON tbl_name (tagColName） +CREATE INDEX index_name ON tbl_name (tagColName) ``` 其中 `index_name` 为索引名称， `tbl_name` 为超级表名称，`tagColName` 为要在其上建立索引的 tag 列的名称。`tagColName` 的类型不受限制，即任何类型的 tag 列都可以建立索引。 diff --git a/docs/zh/14-reference/05-connector/35-node.mdx b/docs/zh/14-reference/05-connector/35-node.mdx index 6ac34d247175..d9512eae78d7 100644 --- a/docs/zh/14-reference/05-connector/35-node.mdx +++ b/docs/zh/14-reference/05-connector/35-node.mdx @@ -26,6 +26,7 @@ Node.js 连接器目前仅支持 WebSocket 连接器， 其通过 taosAdapter | Node.js 连接器 版本 | 主要变化 | TDengine 版本 | | :------------------: | :----------------------: | :----------------: | +| 3.1.1 | 优化了数据传输性能 | 3.3.2.0 及更高版本 | | 3.1.0 | 新版本发布，支持 WebSocket 连接 | 3.2.0.0 及更高版本 | ## 处理异常 diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 268c99682b9b..19b18c204c91 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1339,6 +1339,7 @@ typedef struct { char* sql; int8_t withArbitrator; int8_t encryptAlgorithm; + char dnodeListStr[TSDB_DNODE_LIST_LEN]; } SCreateDbReq; int32_t tSerializeSCreateDbReq(void* buf, int32_t bufLen, SCreateDbReq* pReq); diff --git a/include/common/ttypes.h b/include/common/ttypes.h index 3934553b1c06..0ef47cdd12e8 100644 --- a/include/common/ttypes.h +++ b/include/common/ttypes.h @@ -238,12 +238,26 @@ typedef struct { case TSDB_DATA_TYPE_UBIGINT: \ snprintf(_output, (int32_t)(_outputBytes), "%" PRIu64, *(uint64_t *)(_input)); \ break; \ - case TSDB_DATA_TYPE_FLOAT: \ - snprintf(_output, (int32_t)(_outputBytes), "%f", *(float *)(_input)); \ + case TSDB_DATA_TYPE_FLOAT: { \ + int32_t n = snprintf(_output, (int32_t)(_outputBytes), "%f", *(float *)(_input)); \ + if (n >= (_outputBytes)) { \ + n = snprintf(_output, (int32_t)(_outputBytes), "%.7e", *(float *)(_input)); \ + if (n >= (_outputBytes)) { \ + snprintf(_output, (int32_t)(_outputBytes), "%f", *(float *)(_input)); \ + } \ + } \ break; \ - case TSDB_DATA_TYPE_DOUBLE: \ - snprintf(_output, (int32_t)(_outputBytes), "%f", *(double *)(_input)); \ + } \ + case TSDB_DATA_TYPE_DOUBLE: { \ + int32_t n = snprintf(_output, (int32_t)(_outputBytes), "%f", *(double *)(_input)); \ + if (n >= (_outputBytes)) { \ + snprintf(_output, (int32_t)(_outputBytes), "%.15e", *(double *)(_input)); \ + if (n >= (_outputBytes)) { \ + snprintf(_output, (int32_t)(_outputBytes), "%f", *(double *)(_input)); \ + } \ + } \ break; \ + } \ case TSDB_DATA_TYPE_UINT: \ snprintf(_output, (int32_t)(_outputBytes), "%u", *(uint32_t *)(_input)); \ break; \ diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index bbf288928984..514eddbc249a 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -72,6 +72,7 @@ typedef struct SDatabaseOptions { int8_t compressionLevel; int8_t encryptAlgorithm; int32_t daysPerFile; + char dnodeListStr[TSDB_DNODE_LIST_LEN]; char encryptAlgorithmStr[TSDB_ENCRYPT_ALGO_STR_LEN]; SValueNode* pDaysPerFile; int32_t fsyncPeriod; diff --git a/include/util/taoserror.h b/include/util/taoserror.h index 2a67a3cae16a..9a8b39b84c99 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -352,6 +352,8 @@ int32_t taosGetErrSize(); #define TSDB_CODE_MND_INVALID_SYS_TABLENAME TAOS_DEF_ERROR_CODE(0, 0x039A) #define TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE TAOS_DEF_ERROR_CODE(0, 0x039B) #define TSDB_CODE_MND_INVALID_WAL_LEVEL TAOS_DEF_ERROR_CODE(0, 0x039C) +#define TSDB_CODE_MND_INVALID_DNODE_LIST_FMT TAOS_DEF_ERROR_CODE(0, 0x039D) +#define TSDB_CODE_MND_DNODE_LIST_REPEAT TAOS_DEF_ERROR_CODE(0, 0x039E) // mnode-node #define TSDB_CODE_MND_MNODE_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x03A0) diff --git a/include/util/tcompression.h b/include/util/tcompression.h index 1f09b750cbea..140b7fe392a3 100644 --- a/include/util/tcompression.h +++ b/include/util/tcompression.h @@ -152,15 +152,12 @@ int32_t tsDecompressBigint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int // for internal usage int32_t getWordLength(char type); -#ifdef __AVX2__ int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, char *const output, const char type); int32_t tsDecompressFloatImpAvx2(const char *input, int32_t nelements, char *output); int32_t tsDecompressDoubleImpAvx2(const char *input, int32_t nelements, char *output); -#endif -#ifdef __AVX512VL__ -void tsDecompressTimestampAvx2(const char *input, int32_t nelements, char *output, bool bigEndian); -void tsDecompressTimestampAvx512(const char *const input, const int32_t nelements, char *const output, bool bigEndian); -#endif +int32_t tsDecompressTimestampAvx2(const char *input, int32_t nelements, char *output, bool bigEndian); +int32_t tsDecompressTimestampAvx512(const char *const input, const int32_t nelements, char *const output, + bool bigEndian); /************************************************************************* * REGULAR COMPRESSION 2 diff --git a/include/util/tdef.h b/include/util/tdef.h index 4aad89a142b3..7ef01f9752fd 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -41,6 +41,7 @@ extern const int32_t TYPE_BYTES[21]; #define FLOAT_BYTES sizeof(float) #define DOUBLE_BYTES sizeof(double) #define POINTER_BYTES sizeof(void *) +#define M256_BYTES 32 #define TSDB_KEYSIZE sizeof(TSKEY) #define TSDB_NCHAR_SIZE sizeof(TdUcs4) @@ -452,6 +453,7 @@ typedef enum ELogicConditionType { #define TSDB_CACHE_MODEL_LAST_ROW 1 #define TSDB_CACHE_MODEL_LAST_VALUE 2 #define TSDB_CACHE_MODEL_BOTH 3 +#define TSDB_DNODE_LIST_LEN 256 #define TSDB_ENCRYPT_ALGO_STR_LEN 16 #define TSDB_ENCRYPT_ALGO_NONE_STR "none" #define TSDB_ENCRYPT_ALGO_SM4_STR "sm4" diff --git a/source/common/src/tcol.c b/source/common/src/tcol.c index 84027c25b6b3..923aab12ca0e 100644 --- a/source/common/src/tcol.c +++ b/source/common/src/tcol.c @@ -363,6 +363,9 @@ int8_t validColEncode(uint8_t type, uint8_t l1) { if (l1 == TSDB_COLVAL_ENCODE_NOCHANGE) { return 1; } + if (l1 == TSDB_COLVAL_ENCODE_DISABLED) { + return 1; + } if (type == TSDB_DATA_TYPE_BOOL) { return TSDB_COLVAL_ENCODE_RLE == l1 ? 1 : 0; } else if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_INT) { diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 9c8544fcd46e..9b54da2c3087 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -3874,6 +3874,7 @@ int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->s3ChunkSize)); TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->s3KeepLocal)); TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->s3Compact)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->dnodeListStr)); tEndEncode(&encoder); @@ -3962,6 +3963,10 @@ int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->s3Compact)); } + if (!tDecodeIsEnd(&decoder)) { + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->dnodeListStr)); + } + tEndDecode(&decoder); _exit: diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index 8a8dcc74a5bd..006f44b349cb 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -741,7 +741,7 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { int32_t vgId = alterReq.vgId; dInfo( - "vgId:%d,vnode management handle msgType:%s, start to alter vnode replica:%d selfIndex:%d leanerReplica:%d " + "vgId:%d, vnode management handle msgType:%s, start to alter vnode replica:%d selfIndex:%d leanerReplica:%d " "learnerSelfIndex:%d strict:%d changeVersion:%d", vgId, TMSG_INFO(pMsg->msgType), alterReq.replica, alterReq.selfIndex, alterReq.learnerReplica, alterReq.learnerSelfIndex, alterReq.strict, alterReq.changeVersion); diff --git a/source/dnode/mnode/impl/inc/mndDb.h b/source/dnode/mnode/impl/inc/mndDb.h index b72d1386c1bb..fdb6b5a80b97 100644 --- a/source/dnode/mnode/impl/inc/mndDb.h +++ b/source/dnode/mnode/impl/inc/mndDb.h @@ -37,6 +37,7 @@ const char *mndGetDbStr(const char *src); const char *mndGetStableStr(const char *src); int32_t mndProcessCompactDbReq(SRpcMsg *pReq); +int32_t mndCheckDbDnodeList(SMnode *pMnode, char *db, char *dnodeListStr, SArray *dnodeList); #ifdef __cplusplus } diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 742db8f450a9..d2d9b2e8eb2f 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -70,7 +70,7 @@ typedef enum { MND_OPER_WRITE_DB, MND_OPER_READ_DB, MND_OPER_READ_OR_WRITE_DB, - MND_OPER_SHOW_VARIBALES, + MND_OPER_SHOW_VARIABLES, MND_OPER_SUBSCRIBE, MND_OPER_CREATE_TOPIC, MND_OPER_DROP_TOPIC, diff --git a/source/dnode/mnode/impl/inc/mndVgroup.h b/source/dnode/mnode/impl/inc/mndVgroup.h index 682a51a68781..a8a806e497b2 100644 --- a/source/dnode/mnode/impl/inc/mndVgroup.h +++ b/source/dnode/mnode/impl/inc/mndVgroup.h @@ -35,9 +35,9 @@ void mndSortVnodeGid(SVgObj *pVgroup); int64_t mndGetVnodesMemory(SMnode *pMnode, int32_t dnodeId); int64_t mndGetVgroupMemory(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup); -SArray *mndBuildDnodesArray(SMnode *, int32_t exceptDnodeId); +SArray *mndBuildDnodesArray(SMnode *, int32_t exceptDnodeId, SArray *dnodeList); int32_t mndAllocSmaVgroup(SMnode *, SDbObj *pDb, SVgObj *pVgroup); -int32_t mndAllocVgroup(SMnode *, SDbObj *pDb, SVgObj **ppVgroups); +int32_t mndAllocVgroup(SMnode *, SDbObj *pDb, SVgObj **ppVgroups, SArray *dnodeList); int32_t mndAddNewVgPrepareAction(SMnode *, STrans *pTrans, SVgObj *pVg); int32_t mndAddCreateVnodeAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid); int32_t mndAddAlterVnodeConfirmAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup); diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index aed00af3c189..0d17ccd0b087 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -462,8 +462,8 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) { if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code; if (pCfg->hashMethod != 1) return code; if (pCfg->replications > mndGetDnodeSize(pMnode)) { - terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES; - return code; + code = TSDB_CODE_MND_NO_ENOUGH_DNODES; + TAOS_RETURN(code); } if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code; if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code; @@ -746,7 +746,7 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj TAOS_RETURN(code); } -static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) { +static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser, SArray *dnodeList) { int32_t code = 0; SUserObj newUserObj = {0}; SDbObj dbObj = {0}; @@ -823,7 +823,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, } SVgObj *pVgroups = NULL; - if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups)) != 0) { + if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups, dnodeList)) != 0) { mError("db:%s, failed to create, alloc vgroup failed, since %s", pCreate->db, terrstr()); TAOS_RETURN(code); } @@ -925,6 +925,17 @@ static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) { TAOS_RETURN(code); } +#ifndef TD_ENTERPRISE +int32_t mndCheckDbDnodeList(SMnode *pMnode, char *db, char *dnodeListStr, SArray *dnodeList) { + if (dnodeListStr[0] != 0) { + terrno = TSDB_CODE_OPS_NOT_SUPPORT; + return terrno; + } else { + return 0; + } +} +#endif + static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; int32_t code = -1; @@ -932,6 +943,10 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) { SDbObj *pDb = NULL; SUserObj *pUser = NULL; SCreateDbReq createReq = {0}; + SArray *dnodeList = NULL; + + dnodeList = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(int32_t)); + TSDB_CHECK_NULL(dnodeList, code, lino, _OVER, TSDB_CODE_OUT_OF_MEMORY); TAOS_CHECK_GOTO(tDeserializeSCreateDbReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER); #ifdef WINDOWS @@ -975,9 +990,11 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) { TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER); + TAOS_CHECK_GOTO(mndCheckDbDnodeList(pMnode, createReq.db, createReq.dnodeListStr, dnodeList), &lino, _OVER); + TAOS_CHECK_GOTO(mndAcquireUser(pMnode, pReq->info.conn.user, &pUser), &lino, _OVER); - TAOS_CHECK_GOTO(mndCreateDb(pMnode, pReq, &createReq, pUser), &lino, _OVER); + TAOS_CHECK_GOTO(mndCreateDb(pMnode, pReq, &createReq, pUser, dnodeList), &lino, _OVER); if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; @@ -994,6 +1011,7 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) { mndReleaseDb(pMnode, pDb); mndReleaseUser(pMnode, pUser); tFreeSCreateDbReq(&createReq); + taosArrayDestroy(dnodeList); TAOS_RETURN(code); } @@ -1168,7 +1186,9 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj * SSdb *pSdb = pMnode->pSdb; void *pIter = NULL; SVgObj *pVgroup = NULL; - SArray *pArray = mndBuildDnodesArray(pMnode, 0); + SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL); + + TSDB_CHECK_NULL(pArray, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY); while (1) { pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup); diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index 5e10583a0a6e..2a1689854b88 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -1068,7 +1068,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) { SShowVariablesRsp rsp = {0}; int32_t code = -1; - if (mndCheckOperPrivilege(pReq->info.node, pReq->info.conn.user, MND_OPER_SHOW_VARIBALES) != 0) { + if (mndCheckOperPrivilege(pReq->info.node, pReq->info.conn.user, MND_OPER_SHOW_VARIABLES) != 0) { goto _OVER; } diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 5a79ac6bc8d0..913e6e329585 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -717,11 +717,28 @@ static bool mndBuildDnodesArrayFp(SMnode *pMnode, void *pObj, void *p1, void *p2 SDnodeObj *pDnode = pObj; SArray *pArray = p1; int32_t exceptDnodeId = *(int32_t *)p2; + SArray *dnodeList = p3; if (exceptDnodeId == pDnode->id) { return true; } + if (dnodeList != NULL) { + int32_t dnodeListSize = taosArrayGetSize(dnodeList); + if (dnodeListSize > 0) { + bool inDnodeList = false; + for (int32_t index = 0; index < dnodeListSize; ++index) { + int32_t dnodeId = *(int32_t *)taosArrayGet(dnodeList, index); + if (pDnode->id == dnodeId) { + inDnodeList = true; + } + } + if (!inDnodeList) { + return true; + } + } + } + int64_t curMs = taosGetTimestampMs(); bool online = mndIsDnodeOnline(pDnode, curMs); bool isMnode = mndIsMnode(pMnode, pDnode->id); @@ -741,7 +758,7 @@ static bool mndBuildDnodesArrayFp(SMnode *pMnode, void *pObj, void *p1, void *p2 return true; } -SArray *mndBuildDnodesArray(SMnode *pMnode, int32_t exceptDnodeId) { +SArray *mndBuildDnodesArray(SMnode *pMnode, int32_t exceptDnodeId, SArray *dnodeList) { SSdb *pSdb = pMnode->pSdb; int32_t numOfDnodes = mndGetDnodeSize(pMnode); @@ -752,7 +769,7 @@ SArray *mndBuildDnodesArray(SMnode *pMnode, int32_t exceptDnodeId) { } sdbTraverse(pSdb, SDB_DNODE, mndResetDnodesArrayFp, NULL, NULL, NULL); - sdbTraverse(pSdb, SDB_DNODE, mndBuildDnodesArrayFp, pArray, &exceptDnodeId, NULL); + sdbTraverse(pSdb, SDB_DNODE, mndBuildDnodesArrayFp, pArray, &exceptDnodeId, dnodeList); mDebug("build %d dnodes array", (int32_t)taosArrayGetSize(pArray)); for (int32_t i = 0; i < (int32_t)taosArrayGetSize(pArray); ++i) { @@ -845,7 +862,7 @@ static int32_t mndGetAvailableDnode(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup int32_t mndAllocSmaVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup) { int32_t code = 0; - SArray *pArray = mndBuildDnodesArray(pMnode, 0); + SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL); if (pArray == NULL) { code = TSDB_CODE_MND_RETURN_VALUE_NULL; if (terrno != 0) code = terrno; @@ -868,7 +885,7 @@ int32_t mndAllocSmaVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup) { return 0; } -int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) { +int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups, SArray *dnodeList) { int32_t code = -1; SArray *pArray = NULL; SVgObj *pVgroups = NULL; @@ -879,7 +896,7 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) { goto _OVER; } - pArray = mndBuildDnodesArray(pMnode, 0); + pArray = mndBuildDnodesArray(pMnode, 0, dnodeList); if (pArray == NULL) { code = TSDB_CODE_MND_RETURN_VALUE_NULL; if (terrno != 0) code = terrno; @@ -2062,7 +2079,7 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int32_t mndSetMoveVgroupsInfoToTrans(SMnode *pMnode, STrans *pTrans, int32_t delDnodeId, bool force, bool unsafe) { int32_t code = 0; - SArray *pArray = mndBuildDnodesArray(pMnode, delDnodeId); + SArray *pArray = mndBuildDnodesArray(pMnode, delDnodeId, NULL); if (pArray == NULL) { code = TSDB_CODE_MND_RETURN_VALUE_NULL; if (terrno != 0) code = terrno; @@ -3140,7 +3157,7 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro int32_t code = -1; STrans *pTrans = NULL; SDbObj dbObj = {0}; - SArray *pArray = mndBuildDnodesArray(pMnode, 0); + SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL); int32_t numOfStreams = 0; if ((code = mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams)) != 0) { @@ -3506,7 +3523,7 @@ static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) { sdbRelease(pMnode->pSdb, pDnode); } - pArray = mndBuildDnodesArray(pMnode, 0); + pArray = mndBuildDnodesArray(pMnode, 0, NULL); if (pArray == NULL) { code = TSDB_CODE_MND_RETURN_VALUE_NULL; if (terrno != 0) code = terrno; diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 4a4d341b51aa..15f7e1559663 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -1263,7 +1263,10 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { QUERY_CHECK_CONDITION((hasRemainPartion(pInfo)), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR); SPartitionDataInfo* pParInfo = (SPartitionDataInfo*)pInfo->parIte; blockDataCleanup(pDest); - int32_t rows = taosArrayGetSize(pParInfo->rowIds); + int32_t rows = taosArrayGetSize(pParInfo->rowIds); + code = blockDataEnsureCapacity(pDest, rows); + QUERY_CHECK_CODE(code, lino, _end); + SSDataBlock* pSrc = pInfo->pInputDataBlock; for (int32_t i = 0; i < rows; i++) { int32_t rowIndex = *(int32_t*)taosArrayGet(pParInfo->rowIds, i); diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index 53fe76d85137..f77aa8f34a54 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -675,11 +675,13 @@ static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExp .pData = taosMemoryCalloc(1, pExprInfo->base.resSchema.bytes)}; if (!key.pData) { taosArrayDestroyEx(pInfo->pPrevGroupKeys, destroyGroupKey); + pInfo->pPrevGroupKeys = NULL; return terrno; } if (NULL == taosArrayPush(pInfo->pPrevGroupKeys, &key)) { taosMemoryFree(key.pData); taosArrayDestroyEx(pInfo->pPrevGroupKeys, destroyGroupKey); + pInfo->pPrevGroupKeys = NULL; return terrno; } } diff --git a/source/libs/function/CMakeLists.txt b/source/libs/function/CMakeLists.txt index 4164852111cc..d5c9cccc0eaa 100644 --- a/source/libs/function/CMakeLists.txt +++ b/source/libs/function/CMakeLists.txt @@ -1,6 +1,10 @@ aux_source_directory(src FUNCTION_SRC) aux_source_directory(src/detail FUNCTION_SRC_DETAIL) list(REMOVE_ITEM FUNCTION_SRC src/udfd.c) +IF(COMPILER_SUPPORT_AVX2) + MESSAGE(STATUS "AVX2 instructions is ACTIVATED") + set_source_files_properties(src/detail/tminmaxavx.c PROPERTIES COMPILE_FLAGS -mavx2) +ENDIF() add_library(function STATIC ${FUNCTION_SRC} ${FUNCTION_SRC_DETAIL}) target_include_directories( function diff --git a/source/libs/function/inc/builtinsimpl.h b/source/libs/function/inc/builtinsimpl.h index 36e53d0a80ee..a1c82dc58b79 100644 --- a/source/libs/function/inc/builtinsimpl.h +++ b/source/libs/function/inc/builtinsimpl.h @@ -25,6 +25,11 @@ extern "C" { #include "functionResInfoInt.h" int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc, int32_t* nElems); +int32_t i8VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res); +int32_t i16VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res); +int32_t i32VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res); +int32_t floatVectorCmpAVX2(const float* pData, int32_t numOfRows, bool isMinFunc, float* res); +int32_t doubleVectorCmpAVX2(const double* pData, int32_t numOfRows, bool isMinFunc, double* res); int32_t saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos); int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos); diff --git a/source/libs/function/src/detail/tminmax.c b/source/libs/function/src/detail/tminmax.c index 69c1a8a6ddc7..87120960331b 100644 --- a/source/libs/function/src/detail/tminmax.c +++ b/source/libs/function/src/detail/tminmax.c @@ -72,173 +72,6 @@ #define GET_INVOKE_INTRINSIC_THRESHOLD(_bits, _bytes) ((_bits) / ((_bytes) << 3u)) -#ifdef __AVX2__ -static void calculateRounds(int32_t numOfRows, int32_t bytes, int32_t* remainder, int32_t* rounds, int32_t* width) { - const int32_t bitWidth = 256; - - *width = (bitWidth >> 3u) / bytes; - *remainder = numOfRows % (*width); - *rounds = numOfRows / (*width); -} - -#define EXTRACT_MAX_VAL(_first, _sec, _width, _remain, _v) \ - __COMPARE_EXTRACT_MAX(0, (_width), (_v), (_first)) \ - __COMPARE_EXTRACT_MAX(0, (_remain), (_v), (_sec)) - -#define EXTRACT_MIN_VAL(_first, _sec, _width, _remain, _v) \ - __COMPARE_EXTRACT_MIN(0, (_width), (_v), (_first)) \ - __COMPARE_EXTRACT_MIN(0, (_remain), (_v), (_sec)) - -#define CMP_TYPE_MIN_MAX(type, cmp) \ - const type* p = pData; \ - __m256i initVal = _mm256_lddqu_si256((__m256i*)p); \ - p += width; \ - for (int32_t i = 1; i < (rounds); ++i) { \ - __m256i next = _mm256_lddqu_si256((__m256i*)p); \ - initVal = CMP_FUNC_##cmp##_##type(initVal, next); \ - p += width; \ - } \ - const type* q = (const type*)&initVal; \ - type* v = (type*)res; \ - EXTRACT_##cmp##_VAL(q, p, width, remain, *v) - -static void i8VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { - const int8_t* p = pData; - - int32_t width, remain, rounds; - calculateRounds(numOfRows, sizeof(int8_t), &remain, &rounds, &width); - -#define CMP_FUNC_MIN_int8_t _mm256_min_epi8 -#define CMP_FUNC_MAX_int8_t _mm256_max_epi8 -#define CMP_FUNC_MIN_uint8_t _mm256_min_epu8 -#define CMP_FUNC_MAX_uint8_t _mm256_max_epu8 - - if (!isMinFunc) { // max function - if (signVal) { - CMP_TYPE_MIN_MAX(int8_t, MAX); - } else { - CMP_TYPE_MIN_MAX(uint8_t, MAX); - } - } else { // min function - if (signVal) { - CMP_TYPE_MIN_MAX(int8_t, MIN); - } else { - CMP_TYPE_MIN_MAX(uint8_t, MIN); - } - } -} - -static void i16VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { - int32_t width, remain, rounds; - calculateRounds(numOfRows, sizeof(int16_t), &remain, &rounds, &width); - -#define CMP_FUNC_MIN_int16_t _mm256_min_epi16 -#define CMP_FUNC_MAX_int16_t _mm256_max_epi16 -#define CMP_FUNC_MIN_uint16_t _mm256_min_epu16 -#define CMP_FUNC_MAX_uint16_t _mm256_max_epu16 - if (!isMinFunc) { // max function - if (signVal) { - CMP_TYPE_MIN_MAX(int16_t, MAX); - } else { - CMP_TYPE_MIN_MAX(uint16_t, MAX); - } - } else { // min function - if (signVal) { - CMP_TYPE_MIN_MAX(int16_t, MIN); - } else { - CMP_TYPE_MIN_MAX(uint16_t, MIN); - } - } -} - -static void i32VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { - int32_t width, remain, rounds; - calculateRounds(numOfRows, sizeof(int32_t), &remain, &rounds, &width); - -#define CMP_FUNC_MIN_int32_t _mm256_min_epi32 -#define CMP_FUNC_MAX_int32_t _mm256_max_epi32 -#define CMP_FUNC_MIN_uint32_t _mm256_min_epu32 -#define CMP_FUNC_MAX_uint32_t _mm256_max_epu32 - if (!isMinFunc) { // max function - if (signVal) { - CMP_TYPE_MIN_MAX(int32_t, MAX); - } else { - CMP_TYPE_MIN_MAX(uint32_t, MAX); - } - } else { // min function - if (signVal) { - CMP_TYPE_MIN_MAX(int32_t, MIN); - } else { - CMP_TYPE_MIN_MAX(uint32_t, MIN); - } - } -} - -static void floatVectorCmpAVX2(const float* pData, int32_t numOfRows, bool isMinFunc, float* res) { - const float* p = pData; - - int32_t width, remain, rounds; - calculateRounds(numOfRows, sizeof(float), &remain, &rounds, &width); - - __m256 next; - __m256 initVal = _mm256_loadu_ps(p); - p += width; - - if (!isMinFunc) { // max function - for (int32_t i = 1; i < rounds; ++i) { - next = _mm256_loadu_ps(p); - initVal = _mm256_max_ps(initVal, next); - p += width; - } - - const float* q = (const float*)&initVal; - EXTRACT_MAX_VAL(q, p, width, remain, *res) - } else { // min function - for (int32_t i = 1; i < rounds; ++i) { - next = _mm256_loadu_ps(p); - initVal = _mm256_min_ps(initVal, next); - p += width; - } - - const float* q = (const float*)&initVal; - EXTRACT_MIN_VAL(q, p, width, remain, *res) - } -} - -static void doubleVectorCmpAVX2(const double* pData, int32_t numOfRows, bool isMinFunc, double* res) { - const double* p = pData; - - int32_t width, remain, rounds; - calculateRounds(numOfRows, sizeof(double), &remain, &rounds, &width); - - __m256d next; - __m256d initVal = _mm256_loadu_pd(p); - p += width; - - if (!isMinFunc) { // max function - for (int32_t i = 1; i < rounds; ++i) { - next = _mm256_loadu_pd(p); - initVal = _mm256_max_pd(initVal, next); - p += width; - } - - // let sum up the final results - const double* q = (const double*)&initVal; - EXTRACT_MAX_VAL(q, p, width, remain, *res) - } else { // min function - for (int32_t i = 1; i < rounds; ++i) { - next = _mm256_loadu_pd(p); - initVal = _mm256_min_pd(initVal, next); - p += width; - } - - // let sum up the final results - const double* q = (const double*)&initVal; - EXTRACT_MIN_VAL(q, p, width, remain, *res) - } -} -#endif - static int32_t findFirstValPosition(const SColumnInfoData* pCol, int32_t start, int32_t numOfRows, bool isStr) { int32_t i = start; @@ -255,31 +88,31 @@ static void handleInt8Col(const void* data, int32_t start, int32_t numOfRows, SM pBuf->v = ((const int8_t*)data)[start]; } -#ifdef __AVX2__ - if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int8_t) >= sizeof(__m256i)) { - i8VectorCmpAVX2(data + start * sizeof(int8_t), numOfRows, isMinFunc, signVal, &pBuf->v); - } else { -#else - if (true) { -#endif - if (signVal) { - const int8_t* p = (const int8_t*)data; - int8_t* v = (int8_t*)&pBuf->v; - - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int8_t) >= M256_BYTES) { + int32_t code = i8VectorCmpAVX2(((char*)data) + start * sizeof(int8_t), numOfRows, isMinFunc, signVal, &pBuf->v); + if (code == TSDB_CODE_SUCCESS) { + pBuf->assign = true; + return; + } + } + + if (signVal) { + const int8_t* p = (const int8_t*)data; + int8_t* v = (int8_t*)&pBuf->v; + + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); } else { - const uint8_t* p = (const uint8_t*)data; - uint8_t* v = (uint8_t*)&pBuf->v; + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); + } + } else { + const uint8_t* p = (const uint8_t*)data; + uint8_t* v = (uint8_t*)&pBuf->v; - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); + } else { + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); } } @@ -292,31 +125,31 @@ static void handleInt16Col(const void* data, int32_t start, int32_t numOfRows, S pBuf->v = ((const int16_t*)data)[start]; } -#ifdef __AVX2__ - if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int16_t) >= sizeof(__m256i)) { - i16VectorCmpAVX2(data + start * sizeof(int16_t), numOfRows, isMinFunc, signVal, &pBuf->v); - } else { -#else - if (true) { -#endif - if (signVal) { - const int16_t* p = (const int16_t*)data; - int16_t* v = (int16_t*)&pBuf->v; - - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int16_t) >= M256_BYTES) { + int32_t code = i16VectorCmpAVX2(((char*)data) + start * sizeof(int16_t), numOfRows, isMinFunc, signVal, &pBuf->v); + if (code == TSDB_CODE_SUCCESS) { + pBuf->assign = true; + return; + } + } + + if (signVal) { + const int16_t* p = (const int16_t*)data; + int16_t* v = (int16_t*)&pBuf->v; + + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); } else { - const uint16_t* p = (const uint16_t*)data; - uint16_t* v = (uint16_t*)&pBuf->v; + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); + } + } else { + const uint16_t* p = (const uint16_t*)data; + uint16_t* v = (uint16_t*)&pBuf->v; - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); + } else { + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); } } @@ -329,31 +162,31 @@ static void handleInt32Col(const void* data, int32_t start, int32_t numOfRows, S pBuf->v = ((const int32_t*)data)[start]; } -#ifdef __AVX2__ - if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int32_t) >= sizeof(__m256i)) { - i32VectorCmpAVX2(data + start * sizeof(int32_t), numOfRows, isMinFunc, signVal, &pBuf->v); - } else { -#else - if (true) { -#endif - if (signVal) { - const int32_t* p = (const int32_t*)data; - int32_t* v = (int32_t*)&pBuf->v; - - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(int32_t) >= M256_BYTES) { + int32_t code = i32VectorCmpAVX2(((char*)data) + start * sizeof(int32_t), numOfRows, isMinFunc, signVal, &pBuf->v); + if (code == TSDB_CODE_SUCCESS) { + pBuf->assign = true; + return; + } + } + + if (signVal) { + const int32_t* p = (const int32_t*)data; + int32_t* v = (int32_t*)&pBuf->v; + + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); } else { - const uint32_t* p = (const uint32_t*)data; - uint32_t* v = (uint32_t*)&pBuf->v; + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); + } + } else { + const uint32_t* p = (const uint32_t*)data; + uint32_t* v = (uint32_t*)&pBuf->v; - if (isMinFunc) { - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); - } else { - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); - } + if (isMinFunc) { + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *v, p); + } else { + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *v, p); } } @@ -397,20 +230,20 @@ static void handleFloatCol(SColumnInfoData* pCol, int32_t start, int32_t numOfRo *val = pData[start]; } -#ifdef __AVX2__ - if (tsAVXSupported && tsSIMDEnable && numOfRows * sizeof(float) >= sizeof(__m256i)) { - floatVectorCmpAVX2(pData + start, numOfRows, isMinFunc, val); - } else { -#else - if (true) { -#endif - if (isMinFunc) { // min - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *val, pData); - } else { // max - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *val, pData); + if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(float) >= M256_BYTES) { + int32_t code = floatVectorCmpAVX2(pData + start, numOfRows, isMinFunc, val); + if (code == TSDB_CODE_SUCCESS) { + pBuf->assign = true; + return; } } + if (isMinFunc) { // min + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *val, pData); + } else { // max + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *val, pData); + } + pBuf->assign = true; } @@ -422,20 +255,20 @@ static void handleDoubleCol(SColumnInfoData* pCol, int32_t start, int32_t numOfR *val = pData[start]; } -#ifdef __AVX2__ - if (tsAVXSupported && tsSIMDEnable && numOfRows * sizeof(double) >= sizeof(__m256i)) { - doubleVectorCmpAVX2(pData + start, numOfRows, isMinFunc, val); - } else { -#else - if (true) { -#endif - if (isMinFunc) { // min - __COMPARE_EXTRACT_MIN(start, start + numOfRows, *val, pData); - } else { // max - __COMPARE_EXTRACT_MAX(start, start + numOfRows, *val, pData); + if (tsAVX2Supported && tsSIMDEnable && numOfRows * sizeof(double) >= M256_BYTES) { + int32_t code = doubleVectorCmpAVX2(pData + start, numOfRows, isMinFunc, val); + if (code == TSDB_CODE_SUCCESS) { + pBuf->assign = true; + return; } } + if (isMinFunc) { // min + __COMPARE_EXTRACT_MIN(start, start + numOfRows, *val, pData); + } else { // max + __COMPARE_EXTRACT_MAX(start, start + numOfRows, *val, pData); + } + pBuf->assign = true; } diff --git a/source/libs/function/src/detail/tminmaxavx.c b/source/libs/function/src/detail/tminmaxavx.c new file mode 100644 index 000000000000..8fe6cc5448f8 --- /dev/null +++ b/source/libs/function/src/detail/tminmaxavx.c @@ -0,0 +1,227 @@ +/* + * 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 . + */ + +#include "builtinsimpl.h" + +#ifdef __AVX2__ +static void calculateRounds(int32_t numOfRows, int32_t bytes, int32_t* remainder, int32_t* rounds, int32_t* width) { + const int32_t bitWidth = 256; + + *width = (bitWidth >> 3u) / bytes; + *remainder = numOfRows % (*width); + *rounds = numOfRows / (*width); +} + +#define __COMPARE_EXTRACT_MIN(start, end, val, _data) \ + for (int32_t i = (start); i < (end); ++i) { \ + if ((val) > (_data)[i]) { \ + (val) = (_data)[i]; \ + } \ + } + +#define __COMPARE_EXTRACT_MAX(start, end, val, _data) \ + for (int32_t i = (start); i < (end); ++i) { \ + if ((val) < (_data)[i]) { \ + (val) = (_data)[i]; \ + } \ + } + +#define EXTRACT_MAX_VAL(_first, _sec, _width, _remain, _v) \ + __COMPARE_EXTRACT_MAX(0, (_width), (_v), (_first)) \ + __COMPARE_EXTRACT_MAX(0, (_remain), (_v), (_sec)) + +#define EXTRACT_MIN_VAL(_first, _sec, _width, _remain, _v) \ + __COMPARE_EXTRACT_MIN(0, (_width), (_v), (_first)) \ + __COMPARE_EXTRACT_MIN(0, (_remain), (_v), (_sec)) + +#define CMP_TYPE_MIN_MAX(type, cmp) \ + const type* p = pData; \ + __m256i initVal = _mm256_lddqu_si256((__m256i*)p); \ + p += width; \ + for (int32_t i = 1; i < (rounds); ++i) { \ + __m256i next = _mm256_lddqu_si256((__m256i*)p); \ + initVal = CMP_FUNC_##cmp##_##type(initVal, next); \ + p += width; \ + } \ + const type* q = (const type*)&initVal; \ + type* v = (type*)res; \ + EXTRACT_##cmp##_VAL(q, p, width, remain, *v) +#endif + +int32_t i8VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { +#ifdef __AVX2__ + const int8_t* p = pData; + + int32_t width, remain, rounds; + calculateRounds(numOfRows, sizeof(int8_t), &remain, &rounds, &width); + +#define CMP_FUNC_MIN_int8_t _mm256_min_epi8 +#define CMP_FUNC_MAX_int8_t _mm256_max_epi8 +#define CMP_FUNC_MIN_uint8_t _mm256_min_epu8 +#define CMP_FUNC_MAX_uint8_t _mm256_max_epu8 + + if (!isMinFunc) { // max function + if (signVal) { + CMP_TYPE_MIN_MAX(int8_t, MAX); + } else { + CMP_TYPE_MIN_MAX(uint8_t, MAX); + } + } else { // min function + if (signVal) { + CMP_TYPE_MIN_MAX(int8_t, MIN); + } else { + CMP_TYPE_MIN_MAX(uint8_t, MIN); + } + } + return TSDB_CODE_SUCCESS; +#else + uError("unable run %s without avx2 instructions", __func__); + return TSDB_CODE_OPS_NOT_SUPPORT; +#endif +} + +int32_t i16VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { +#ifdef __AVX2__ + int32_t width, remain, rounds; + calculateRounds(numOfRows, sizeof(int16_t), &remain, &rounds, &width); + +#define CMP_FUNC_MIN_int16_t _mm256_min_epi16 +#define CMP_FUNC_MAX_int16_t _mm256_max_epi16 +#define CMP_FUNC_MIN_uint16_t _mm256_min_epu16 +#define CMP_FUNC_MAX_uint16_t _mm256_max_epu16 + if (!isMinFunc) { // max function + if (signVal) { + CMP_TYPE_MIN_MAX(int16_t, MAX); + } else { + CMP_TYPE_MIN_MAX(uint16_t, MAX); + } + } else { // min function + if (signVal) { + CMP_TYPE_MIN_MAX(int16_t, MIN); + } else { + CMP_TYPE_MIN_MAX(uint16_t, MIN); + } + } + return TSDB_CODE_SUCCESS; +#else + uError("unable run %s without avx2 instructions", __func__); + return TSDB_CODE_OPS_NOT_SUPPORT; +#endif +} + +int32_t i32VectorCmpAVX2(const void* pData, int32_t numOfRows, bool isMinFunc, bool signVal, int64_t* res) { +#ifdef __AVX2__ + int32_t width, remain, rounds; + calculateRounds(numOfRows, sizeof(int32_t), &remain, &rounds, &width); + +#define CMP_FUNC_MIN_int32_t _mm256_min_epi32 +#define CMP_FUNC_MAX_int32_t _mm256_max_epi32 +#define CMP_FUNC_MIN_uint32_t _mm256_min_epu32 +#define CMP_FUNC_MAX_uint32_t _mm256_max_epu32 + if (!isMinFunc) { // max function + if (signVal) { + CMP_TYPE_MIN_MAX(int32_t, MAX); + } else { + CMP_TYPE_MIN_MAX(uint32_t, MAX); + } + } else { // min function + if (signVal) { + CMP_TYPE_MIN_MAX(int32_t, MIN); + } else { + CMP_TYPE_MIN_MAX(uint32_t, MIN); + } + } + return TSDB_CODE_SUCCESS; +#else + uError("unable run %s without avx2 instructions", __func__); + return TSDB_CODE_OPS_NOT_SUPPORT; +#endif +} + +int32_t floatVectorCmpAVX2(const float* pData, int32_t numOfRows, bool isMinFunc, float* res) { +#ifdef __AVX2__ + const float* p = pData; + + int32_t width, remain, rounds; + calculateRounds(numOfRows, sizeof(float), &remain, &rounds, &width); + + __m256 next; + __m256 initVal = _mm256_loadu_ps(p); + p += width; + + if (!isMinFunc) { // max function + for (int32_t i = 1; i < rounds; ++i) { + next = _mm256_loadu_ps(p); + initVal = _mm256_max_ps(initVal, next); + p += width; + } + + const float* q = (const float*)&initVal; + EXTRACT_MAX_VAL(q, p, width, remain, *res) + } else { // min function + for (int32_t i = 1; i < rounds; ++i) { + next = _mm256_loadu_ps(p); + initVal = _mm256_min_ps(initVal, next); + p += width; + } + + const float* q = (const float*)&initVal; + EXTRACT_MIN_VAL(q, p, width, remain, *res) + } + return TSDB_CODE_SUCCESS; +#else + uError("unable run %s without avx2 instructions", __func__); + return TSDB_CODE_OPS_NOT_SUPPORT; +#endif +} + +int32_t doubleVectorCmpAVX2(const double* pData, int32_t numOfRows, bool isMinFunc, double* res) { +#ifdef __AVX2__ + const double* p = pData; + + int32_t width, remain, rounds; + calculateRounds(numOfRows, sizeof(double), &remain, &rounds, &width); + + __m256d next; + __m256d initVal = _mm256_loadu_pd(p); + p += width; + + if (!isMinFunc) { // max function + for (int32_t i = 1; i < rounds; ++i) { + next = _mm256_loadu_pd(p); + initVal = _mm256_max_pd(initVal, next); + p += width; + } + + // let sum up the final results + const double* q = (const double*)&initVal; + EXTRACT_MAX_VAL(q, p, width, remain, *res) + } else { // min function + for (int32_t i = 1; i < rounds; ++i) { + next = _mm256_loadu_pd(p); + initVal = _mm256_min_pd(initVal, next); + p += width; + } + + // let sum up the final results + const double* q = (const double*)&initVal; + EXTRACT_MIN_VAL(q, p, width, remain, *res) + } + return TSDB_CODE_SUCCESS; +#else + uError("unable run %s without avx2 instructions", __func__); + return TSDB_CODE_OPS_NOT_SUPPORT; +#endif +} diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index b2c4a3ad2a2e..1a5785190be8 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -175,8 +175,8 @@ static int32_t valueNodeCopy(const SValueNode* pSrc, SValueNode* pDst) { case TSDB_DATA_TYPE_VARCHAR: case TSDB_DATA_TYPE_VARBINARY: case TSDB_DATA_TYPE_GEOMETRY: { - int32_t len = pSrc->node.resType.bytes + 1; - pDst->datum.p = taosMemoryCalloc(1, len); + int32_t len = varDataTLen(pSrc->datum.p); + pDst->datum.p = taosMemoryCalloc(1, len + 1); if (NULL == pDst->datum.p) { return terrno; } diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index 597ee5f5d2cf..3caa8da80fd4 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -69,6 +69,7 @@ typedef enum EDatabaseOptionType { DB_OPTION_S3_COMPACT, DB_OPTION_KEEP_TIME_OFFSET, DB_OPTION_ENCRYPT_ALGORITHM, + DB_OPTION_DNODES, } EDatabaseOptionType; typedef enum ETableOptionType { diff --git a/source/libs/parser/inc/parInt.h b/source/libs/parser/inc/parInt.h index c231de653c9f..5999ada70f16 100644 --- a/source/libs/parser/inc/parInt.h +++ b/source/libs/parser/inc/parInt.h @@ -28,6 +28,8 @@ extern "C" { #define QUERY_SMA_OPTIMIZE_DISABLE 0 #define QUERY_SMA_OPTIMIZE_ENABLE 1 +#define QUERY_NUMBER_MAX_DISPLAY_LEN 65 + int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatalogReq, const SMetaData* pMetaData); int32_t continueCreateTbFromFile(SParseContext* pCxt, SQuery** pQuery); int32_t parse(SParseContext* pParseCxt, SQuery** pQuery); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index d905cd87e536..e1c3456e3f24 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -286,6 +286,7 @@ db_options(A) ::= db_options(B) S3_KEEPLOCAL NK_VARIABLE(C). db_options(A) ::= db_options(B) S3_COMPACT NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_S3_COMPACT, &C); } db_options(A) ::= db_options(B) KEEP_TIME_OFFSET NK_INTEGER(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_KEEP_TIME_OFFSET, &C); } db_options(A) ::= db_options(B) ENCRYPT_ALGORITHM NK_STRING(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_ENCRYPT_ALGORITHM, &C); } +db_options(A) ::= db_options(B) DNODES NK_STRING(C). { A = setDatabaseOption(pCxt, B, DB_OPTION_DNODES, &C); } alter_db_options(A) ::= alter_db_option(B). { A = createAlterDatabaseOptions(pCxt); A = setAlterDatabaseOption(pCxt, A, &B); } alter_db_options(A) ::= alter_db_options(B) alter_db_option(C). { A = setAlterDatabaseOption(pCxt, B, &C); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 84c3a2fa1a0d..245346273f95 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1799,6 +1799,7 @@ SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt) { pOptions->s3Compact = TSDB_DEFAULT_S3_COMPACT; pOptions->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR; pOptions->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO; + pOptions->dnodeListStr[0] = 0; return (SNode*)pOptions; _err: return NULL; @@ -1842,6 +1843,7 @@ SNode* createAlterDatabaseOptions(SAstCreateContext* pCxt) { pOptions->s3Compact = -1; pOptions->withArbitrator = -1; pOptions->encryptAlgorithm = -1; + pOptions->dnodeListStr[0] = 0; return (SNode*)pOptions; _err: return NULL; @@ -1981,6 +1983,14 @@ static SNode* setDatabaseOptionImpl(SAstCreateContext* pCxt, SNode* pOptions, ED COPY_STRING_FORM_STR_TOKEN(pDbOptions->encryptAlgorithmStr, (SToken*)pVal); pDbOptions->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO; break; + case DB_OPTION_DNODES: + if (((SToken*)pVal)->n >= TSDB_DNODE_LIST_LEN) { + snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "the dnode list is too long (should less than %d)", + TSDB_DNODE_LIST_LEN); + pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR; + } else { + COPY_STRING_FORM_STR_TOKEN(pDbOptions->dnodeListStr, (SToken*)pVal); + } default: break; } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index c711f628c052..84abdcfe4730 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3311,25 +3311,26 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType) } else { resultType = gDisplyTypes[type2][type1]; } + if (resultType == -1) { return TSDB_CODE_SCALAR_CONVERT_ERROR; } + if (commonType->type == newType->type) { commonType->bytes = TMAX(commonType->bytes, newType->bytes); return TSDB_CODE_SUCCESS; } - if (resultType == commonType->type) { - return TSDB_CODE_SUCCESS; - } - if (resultType == newType->type) { - *commonType = *newType; - return TSDB_CODE_SUCCESS; - } - commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]); - if (resultType == TSDB_DATA_TYPE_VARCHAR && (IS_FLOAT_TYPE(commonType->type) || IS_FLOAT_TYPE(newType->type))) { - commonType->bytes += TYPE_BYTES[TSDB_DATA_TYPE_DOUBLE]; + + if ((resultType == TSDB_DATA_TYPE_VARCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) { + commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN); + } else if ((resultType == TSDB_DATA_TYPE_NCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) { + commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN * TSDB_NCHAR_SIZE); + } else { + commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]); } + commonType->type = resultType; + return TSDB_CODE_SUCCESS; } @@ -7556,6 +7557,8 @@ static int32_t buildCreateDbReq(STranslateContext* pCxt, SCreateDatabaseStmt* pS pReq->ignoreExist = pStmt->ignoreExists; pReq->withArbitrator = pStmt->pOptions->withArbitrator; pReq->encryptAlgorithm = pStmt->pOptions->encryptAlgorithm; + tstrncpy(pReq->dnodeListStr, pStmt->pOptions->dnodeListStr, TSDB_DNODE_LIST_LEN); + return buildCreateDbRetentions(pStmt->pOptions->pRetentions, pReq); } diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 75fecadb4bc7..06b5350ed84d 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -532,18 +532,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 1025 -#define YYNRULE 785 -#define YYNRULE_WITH_ACTION 785 +#define YYNSTATE 1026 +#define YYNRULE 786 +#define YYNRULE_WITH_ACTION 786 #define YYNTOKEN 390 -#define YY_MAX_SHIFT 1024 -#define YY_MIN_SHIFTREDUCE 1517 -#define YY_MAX_SHIFTREDUCE 2301 -#define YY_ERROR_ACTION 2302 -#define YY_ACCEPT_ACTION 2303 -#define YY_NO_ACTION 2304 -#define YY_MIN_REDUCE 2305 -#define YY_MAX_REDUCE 3089 +#define YY_MAX_SHIFT 1025 +#define YY_MIN_SHIFTREDUCE 1519 +#define YY_MAX_SHIFTREDUCE 2304 +#define YY_ERROR_ACTION 2305 +#define YY_ACCEPT_ACTION 2306 +#define YY_NO_ACTION 2307 +#define YY_MIN_REDUCE 2308 +#define YY_MAX_REDUCE 3093 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -612,773 +612,773 @@ typedef union { *********** Begin parsing tables **********************************************/ #define YY_ACTTAB_COUNT (4719) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 839, 683, 3062, 2676, 684, 2353, 113, 2508, 3057, 205, - /* 10 */ 3057, 332, 60, 58, 220, 59, 57, 56, 55, 54, - /* 20 */ 506, 2306, 2018, 2674, 901, 471, 838, 231, 224, 3061, - /* 30 */ 2819, 3058, 840, 3058, 3060, 2512, 2016, 2305, 2126, 2401, - /* 40 */ 2043, 2650, 151, 2844, 2566, 150, 149, 148, 147, 146, - /* 50 */ 145, 144, 143, 142, 914, 851, 170, 198, 854, 2317, - /* 60 */ 2823, 160, 159, 158, 157, 156, 155, 154, 153, 152, - /* 70 */ 512, 2121, 151, 829, 884, 150, 149, 148, 147, 146, - /* 80 */ 145, 144, 143, 142, 919, 2024, 53, 52, 2862, 2044, - /* 90 */ 59, 57, 56, 55, 54, 53, 52, 196, 2047, 59, - /* 100 */ 57, 56, 55, 54, 2809, 691, 896, 2522, 684, 2353, - /* 110 */ 2825, 2827, 501, 2762, 703, 1021, 638, 185, 61, 990, - /* 120 */ 989, 988, 987, 536, 919, 986, 985, 175, 980, 979, - /* 130 */ 978, 977, 976, 975, 974, 174, 968, 967, 966, 535, - /* 140 */ 534, 963, 962, 961, 211, 210, 960, 531, 959, 958, - /* 150 */ 957, 2843, 63, 914, 2894, 2129, 2130, 2523, 134, 2845, - /* 160 */ 900, 2847, 2848, 895, 45, 355, 883, 2895, 919, 197, - /* 170 */ 802, 772, 706, 213, 2663, 2957, 704, 2450, 3057, 500, - /* 180 */ 2953, 207, 2965, 850, 256, 162, 849, 766, 79, 770, - /* 190 */ 768, 303, 302, 3057, 2079, 2089, 3063, 231, 875, 232, - /* 200 */ 2929, 3058, 840, 67, 2128, 2131, 2103, 3004, 2043, 637, - /* 210 */ 255, 838, 231, 914, 1863, 1864, 3058, 840, 782, 2019, - /* 220 */ 1748, 2017, 824, 635, 1787, 1788, 882, 954, 187, 186, - /* 230 */ 951, 950, 949, 184, 887, 1739, 946, 945, 944, 1743, - /* 240 */ 943, 1745, 1746, 942, 939, 886, 1754, 936, 1756, 1757, - /* 250 */ 933, 930, 927, 127, 581, 2022, 2023, 2076, 2844, 2078, - /* 260 */ 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2090, 2091, - /* 270 */ 2092, 892, 885, 894, 227, 917, 916, 881, 2113, 2114, - /* 280 */ 2115, 2116, 2117, 2120, 2122, 2123, 2124, 2125, 2127, 2, - /* 290 */ 60, 58, 2218, 2579, 2844, 445, 973, 2041, 506, 2476, - /* 300 */ 2018, 496, 75, 2862, 625, 644, 642, 469, 441, 897, - /* 310 */ 2076, 245, 2577, 676, 2016, 646, 2126, 590, 2645, 2809, - /* 320 */ 75, 896, 674, 53, 52, 670, 666, 59, 57, 56, - /* 330 */ 55, 54, 574, 468, 604, 2048, 648, 573, 2047, 2862, - /* 340 */ 2193, 446, 606, 830, 825, 818, 814, 810, 339, 2121, - /* 350 */ 851, 170, 884, 584, 267, 2809, 19, 896, 686, 3062, - /* 360 */ 2361, 46, 466, 2024, 2193, 688, 2843, 3057, 220, 2894, - /* 370 */ 2819, 685, 247, 436, 2845, 900, 2847, 2848, 895, 893, - /* 380 */ 2579, 883, 2895, 919, 874, 2922, 3061, 2676, 511, 802, - /* 390 */ 3058, 3059, 785, 1021, 467, 2649, 15, 3057, 2043, 2577, - /* 400 */ 2823, 498, 2843, 915, 2519, 2894, 592, 2673, 901, 134, - /* 410 */ 2845, 900, 2847, 2848, 895, 3063, 231, 883, 2895, 919, - /* 420 */ 3058, 840, 172, 161, 181, 2928, 2957, 914, 699, 801, - /* 430 */ 500, 2953, 731, 2129, 2130, 1684, 2044, 2656, 2635, 2328, + /* 0 */ 839, 683, 3066, 691, 684, 2356, 684, 2356, 3061, 205, + /* 10 */ 3061, 332, 60, 58, 887, 59, 57, 56, 55, 54, + /* 20 */ 506, 2309, 2021, 225, 466, 886, 838, 231, 2046, 3065, + /* 30 */ 220, 3062, 840, 3062, 3064, 126, 2019, 528, 2129, 2404, + /* 40 */ 2576, 2578, 151, 2848, 389, 150, 149, 148, 147, 146, + /* 50 */ 145, 144, 143, 142, 914, 851, 170, 2653, 854, 14, + /* 60 */ 13, 53, 52, 2514, 510, 59, 57, 56, 55, 54, + /* 70 */ 220, 2124, 151, 2050, 884, 150, 149, 148, 147, 146, + /* 80 */ 145, 144, 143, 142, 2823, 2027, 53, 52, 2866, 772, + /* 90 */ 59, 57, 56, 55, 54, 53, 52, 2653, 957, 59, + /* 100 */ 57, 56, 55, 54, 2813, 766, 896, 770, 768, 303, + /* 110 */ 302, 34, 703, 914, 2827, 1022, 638, 914, 61, 991, + /* 120 */ 990, 989, 988, 536, 75, 987, 986, 175, 981, 980, + /* 130 */ 979, 978, 977, 976, 975, 174, 969, 968, 967, 535, + /* 140 */ 534, 964, 963, 962, 211, 210, 961, 531, 960, 959, + /* 150 */ 958, 2847, 63, 2046, 2898, 2132, 2133, 2248, 134, 2849, + /* 160 */ 900, 2851, 2852, 895, 2829, 2832, 883, 2899, 919, 915, + /* 170 */ 2523, 2249, 2667, 213, 704, 2961, 2046, 2173, 919, 500, + /* 180 */ 2957, 207, 2969, 850, 256, 162, 849, 346, 347, 161, + /* 190 */ 914, 137, 345, 3061, 2082, 2092, 581, 2268, 731, 232, + /* 200 */ 526, 2525, 1866, 1867, 2131, 2134, 2106, 3008, 196, 637, + /* 210 */ 255, 838, 231, 127, 1751, 63, 3062, 840, 2526, 2022, + /* 220 */ 2247, 2020, 824, 635, 2196, 198, 882, 2320, 786, 1742, + /* 230 */ 946, 945, 944, 1746, 943, 1748, 1749, 942, 939, 64, + /* 240 */ 1757, 936, 1759, 1760, 933, 930, 927, 644, 642, 227, + /* 250 */ 441, 487, 2727, 245, 785, 2025, 2026, 2079, 2848, 2081, + /* 260 */ 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2093, 2094, + /* 270 */ 2095, 892, 885, 894, 75, 917, 916, 881, 2116, 2117, + /* 280 */ 2118, 2119, 2120, 2123, 2125, 2126, 2127, 2128, 2130, 2, + /* 290 */ 60, 58, 2221, 676, 2848, 445, 706, 2044, 506, 2308, + /* 300 */ 2021, 117, 674, 2866, 625, 670, 666, 469, 196, 897, + /* 310 */ 2051, 693, 2719, 307, 2019, 646, 2129, 526, 2525, 2813, + /* 320 */ 339, 896, 2050, 160, 159, 158, 157, 156, 155, 154, + /* 330 */ 153, 152, 574, 468, 604, 1921, 648, 573, 2046, 2866, + /* 340 */ 2196, 446, 606, 830, 825, 818, 814, 810, 339, 2124, + /* 350 */ 851, 170, 884, 584, 267, 2813, 19, 896, 686, 3066, + /* 360 */ 2364, 46, 688, 2027, 75, 220, 2847, 3061, 685, 2898, + /* 370 */ 2193, 2194, 2195, 436, 2849, 900, 2851, 2852, 895, 893, + /* 380 */ 2047, 883, 2899, 919, 874, 2926, 3065, 2680, 2495, 802, + /* 390 */ 3062, 3063, 2654, 1022, 467, 699, 15, 3061, 1947, 1948, + /* 400 */ 1949, 498, 2847, 915, 2523, 2898, 592, 2677, 901, 134, + /* 410 */ 2849, 900, 2851, 2852, 895, 3067, 231, 883, 2899, 919, + /* 420 */ 3062, 840, 172, 161, 181, 2932, 2961, 533, 532, 509, + /* 430 */ 500, 2957, 736, 2132, 2133, 339, 2047, 2660, 2639, 195, /* 440 */ 634, 633, 631, 630, 629, 624, 623, 622, 621, 451, - /* 450 */ 2825, 2828, 611, 610, 609, 608, 607, 601, 600, 599, - /* 460 */ 970, 594, 593, 465, 919, 2501, 473, 585, 1851, 1852, - /* 470 */ 533, 532, 2079, 2089, 1870, 853, 200, 2965, 2966, 9, - /* 480 */ 168, 2970, 2128, 2131, 1686, 2977, 2190, 2191, 2192, 2977, - /* 490 */ 2977, 2977, 2977, 2977, 2025, 41, 75, 2019, 339, 2017, - /* 500 */ 2809, 53, 52, 2579, 882, 59, 57, 56, 55, 54, - /* 510 */ 2190, 2191, 2192, 53, 52, 2046, 339, 59, 57, 56, - /* 520 */ 55, 54, 858, 53, 52, 63, 2295, 59, 57, 56, - /* 530 */ 55, 54, 972, 2022, 2023, 2076, 2844, 2078, 2081, 2082, - /* 540 */ 2083, 2084, 2085, 2086, 2087, 2088, 2090, 2091, 2092, 892, - /* 550 */ 885, 854, 786, 917, 916, 881, 2113, 2114, 289, 2573, - /* 560 */ 2574, 2120, 2122, 2123, 2124, 2125, 2127, 2, 60, 58, - /* 570 */ 2369, 1890, 1891, 73, 729, 2048, 506, 206, 2018, 477, - /* 580 */ 475, 2862, 2327, 458, 799, 1748, 723, 719, 715, 711, - /* 590 */ 956, 288, 2016, 2193, 2126, 2404, 3, 2809, 558, 896, - /* 600 */ 1739, 946, 945, 944, 1743, 943, 1745, 1746, 891, 890, - /* 610 */ 66, 1754, 889, 1756, 1757, 888, 930, 927, 53, 52, - /* 620 */ 1889, 1892, 59, 57, 56, 55, 54, 2121, 1008, 1593, - /* 630 */ 884, 1592, 2763, 2156, 19, 693, 2715, 286, 2972, 307, - /* 640 */ 2491, 2024, 285, 2809, 2843, 166, 12, 2894, 10, 915, - /* 650 */ 2519, 134, 2845, 900, 2847, 2848, 895, 2294, 64, 883, - /* 660 */ 2895, 919, 474, 472, 678, 733, 213, 2969, 2957, 161, - /* 670 */ 1594, 1021, 500, 2953, 15, 752, 751, 750, 736, 2028, - /* 680 */ 2601, 306, 742, 167, 746, 305, 735, 2676, 745, 802, - /* 690 */ 734, 337, 339, 744, 749, 480, 479, 3057, 2157, 743, - /* 700 */ 3005, 508, 702, 478, 739, 738, 737, 2673, 901, 272, - /* 710 */ 2618, 2129, 2130, 2222, 680, 3063, 231, 956, 283, 2043, - /* 720 */ 3058, 840, 274, 281, 1944, 1945, 1946, 12, 279, 697, - /* 730 */ 190, 2802, 2803, 2972, 523, 409, 562, 783, 2977, 2190, - /* 740 */ 2191, 2192, 2977, 2977, 2977, 2977, 2977, 271, 851, 170, - /* 750 */ 2079, 2089, 3062, 2326, 407, 89, 75, 510, 88, 116, - /* 760 */ 2128, 2131, 2968, 220, 448, 564, 560, 470, 485, 2046, - /* 770 */ 774, 700, 447, 2579, 2579, 2019, 528, 2017, 2162, 2572, - /* 780 */ 2574, 464, 882, 163, 265, 661, 659, 656, 654, 2253, - /* 790 */ 2649, 396, 2577, 866, 512, 512, 2303, 103, 44, 502, - /* 800 */ 2151, 2152, 2153, 2154, 2155, 2159, 2160, 2161, 919, 919, - /* 810 */ 2024, 2022, 2023, 2076, 2809, 2078, 2081, 2082, 2083, 2084, - /* 820 */ 2085, 2086, 2087, 2088, 2090, 2091, 2092, 892, 885, 2493, - /* 830 */ 75, 917, 916, 881, 2113, 2114, 701, 2669, 620, 2120, - /* 840 */ 2122, 2123, 2124, 2125, 2127, 2, 12, 60, 58, 251, - /* 850 */ 137, 486, 2723, 619, 339, 506, 572, 2018, 571, 526, - /* 860 */ 2521, 821, 820, 2251, 2252, 2254, 2255, 2256, 2288, 76, - /* 870 */ 2490, 2016, 839, 2126, 140, 2965, 2966, 2844, 168, 2970, - /* 880 */ 3057, 269, 828, 49, 618, 686, 539, 2361, 786, 617, - /* 890 */ 570, 538, 897, 2080, 2363, 107, 2215, 616, 838, 231, - /* 900 */ 106, 915, 2519, 3058, 840, 117, 2121, 915, 2519, 884, - /* 910 */ 487, 2723, 2862, 19, 2195, 2196, 2197, 2198, 2199, 947, - /* 920 */ 2024, 530, 2862, 101, 100, 577, 2749, 236, 244, 53, - /* 930 */ 52, 596, 2645, 59, 57, 56, 55, 54, 2809, 1918, - /* 940 */ 896, 569, 567, 802, 389, 337, 915, 2519, 627, 2645, - /* 950 */ 1021, 3057, 339, 15, 444, 509, 2077, 556, 1596, 1597, - /* 960 */ 552, 548, 544, 541, 570, 195, 68, 105, 40, 3063, - /* 970 */ 231, 788, 2715, 2018, 3058, 840, 2524, 954, 187, 186, - /* 980 */ 951, 950, 949, 184, 827, 2843, 249, 2016, 2894, 196, - /* 990 */ 2129, 2130, 134, 2845, 900, 2847, 2848, 895, 526, 2521, - /* 1000 */ 883, 2895, 919, 254, 518, 915, 2519, 3077, 877, 2957, - /* 1010 */ 2929, 915, 2519, 500, 2953, 521, 784, 2506, 954, 187, - /* 1020 */ 186, 951, 950, 949, 184, 578, 339, 2579, 2325, 2079, - /* 1030 */ 2089, 579, 915, 2519, 1024, 527, 2024, 915, 2519, 2128, - /* 1040 */ 2131, 2047, 740, 53, 52, 97, 2577, 59, 57, 56, - /* 1050 */ 55, 54, 598, 393, 2019, 843, 2017, 612, 2043, 915, - /* 1060 */ 2519, 882, 173, 225, 43, 1677, 1021, 2043, 1012, 1010, - /* 1070 */ 53, 52, 221, 2509, 59, 57, 56, 55, 54, 613, - /* 1080 */ 2504, 1006, 1002, 998, 994, 171, 388, 2137, 2928, 2809, - /* 1090 */ 2022, 2023, 2076, 2043, 2078, 2081, 2082, 2083, 2084, 2085, - /* 1100 */ 2086, 2087, 2088, 2090, 2091, 2092, 892, 885, 851, 170, - /* 1110 */ 917, 916, 881, 2113, 2114, 56, 55, 54, 2120, 2122, - /* 1120 */ 2123, 2124, 2125, 2127, 2, 60, 58, 2132, 395, 2844, - /* 1130 */ 915, 2519, 133, 506, 1562, 2018, 779, 361, 915, 2519, - /* 1140 */ 2451, 1593, 759, 1592, 897, 91, 3012, 915, 2519, 2016, - /* 1150 */ 614, 2126, 314, 1569, 2264, 53, 52, 773, 705, 59, - /* 1160 */ 57, 56, 55, 54, 553, 529, 2844, 2514, 867, 2324, - /* 1170 */ 2019, 1696, 2017, 222, 2862, 195, 304, 195, 1564, 1567, - /* 1180 */ 1568, 897, 1594, 3025, 2121, 1695, 2524, 884, 2525, 1987, - /* 1190 */ 2809, 238, 896, 802, 47, 762, 915, 2519, 2024, 104, - /* 1200 */ 1986, 3057, 756, 754, 725, 724, 2022, 2023, 2214, 301, - /* 1210 */ 2323, 2862, 2245, 359, 2972, 873, 309, 226, 342, 3063, - /* 1220 */ 231, 517, 516, 341, 3058, 840, 2246, 2809, 1021, 896, - /* 1230 */ 2809, 61, 520, 519, 201, 2965, 2966, 2843, 168, 2970, - /* 1240 */ 2894, 2080, 311, 2967, 134, 2845, 900, 2847, 2848, 895, - /* 1250 */ 915, 2519, 883, 2895, 919, 85, 915, 2519, 3061, 3077, - /* 1260 */ 84, 2957, 787, 2047, 649, 500, 2953, 2080, 2129, 2130, - /* 1270 */ 317, 2809, 2322, 402, 2843, 2244, 857, 2894, 2048, 727, - /* 1280 */ 726, 134, 2845, 900, 2847, 2848, 895, 748, 747, 883, - /* 1290 */ 2895, 919, 752, 751, 750, 2077, 3077, 113, 2957, 742, - /* 1300 */ 167, 746, 500, 2953, 2077, 745, 2321, 2079, 2089, 1569, - /* 1310 */ 744, 749, 480, 479, 984, 982, 743, 2128, 2131, 802, - /* 1320 */ 478, 739, 738, 737, 915, 2519, 2513, 3057, 1700, 2523, - /* 1330 */ 2077, 2729, 2019, 2809, 2017, 1567, 1568, 915, 2519, 882, - /* 1340 */ 915, 2519, 1699, 2158, 350, 3063, 231, 2318, 53, 52, - /* 1350 */ 3058, 840, 59, 57, 56, 55, 54, 871, 53, 52, - /* 1360 */ 357, 844, 59, 57, 56, 55, 54, 2809, 2022, 2023, - /* 1370 */ 2076, 2590, 2078, 2081, 2082, 2083, 2084, 2085, 2086, 2087, - /* 1380 */ 2088, 2090, 2091, 2092, 892, 885, 2320, 48, 917, 916, - /* 1390 */ 881, 2113, 2114, 308, 915, 2519, 2120, 2122, 2123, 2124, - /* 1400 */ 2125, 2127, 2, 60, 58, 915, 2519, 2844, 915, 2519, - /* 1410 */ 2319, 506, 2316, 2018, 908, 855, 948, 915, 2519, 2570, - /* 1420 */ 126, 651, 897, 2163, 816, 909, 2579, 2016, 913, 2126, - /* 1430 */ 922, 346, 347, 2581, 2844, 2315, 345, 385, 403, 234, - /* 1440 */ 396, 833, 2556, 42, 2314, 2578, 2313, 2809, 2510, 897, - /* 1450 */ 775, 3050, 2862, 2312, 14, 13, 2311, 735, 2310, 2098, - /* 1460 */ 2309, 734, 2121, 952, 2628, 884, 2570, 2308, 2809, 2234, - /* 1470 */ 896, 2809, 802, 2809, 2333, 1014, 2024, 53, 52, 2862, - /* 1480 */ 3057, 59, 57, 56, 55, 54, 53, 52, 2297, 2298, - /* 1490 */ 59, 57, 56, 55, 54, 2809, 2809, 896, 3063, 231, - /* 1500 */ 2048, 2724, 34, 3058, 840, 2809, 1021, 2809, 588, 61, - /* 1510 */ 2111, 809, 2753, 2204, 2809, 2843, 177, 2809, 2894, 2809, - /* 1520 */ 2844, 2809, 134, 2845, 900, 2847, 2848, 895, 2809, 632, - /* 1530 */ 883, 2895, 919, 953, 1571, 897, 2570, 3077, 1679, 2957, - /* 1540 */ 2042, 2494, 2843, 500, 2953, 2894, 2129, 2130, 177, 134, - /* 1550 */ 2845, 900, 2847, 2848, 895, 880, 741, 883, 2895, 919, - /* 1560 */ 294, 846, 318, 292, 3077, 2862, 2957, 2388, 2386, 546, - /* 1570 */ 500, 2953, 2170, 296, 176, 298, 295, 300, 297, 1675, - /* 1580 */ 299, 2809, 2377, 896, 2375, 2079, 2089, 1680, 2265, 753, - /* 1590 */ 755, 647, 842, 14, 13, 2128, 2131, 2240, 812, 364, - /* 1600 */ 363, 3018, 1934, 132, 757, 129, 760, 62, 62, 214, - /* 1610 */ 2019, 185, 2017, 118, 205, 1657, 344, 882, 90, 53, - /* 1620 */ 52, 2830, 62, 59, 57, 56, 55, 54, 2843, 366, - /* 1630 */ 365, 2894, 822, 776, 1942, 199, 2845, 900, 2847, 2848, - /* 1640 */ 895, 923, 2027, 883, 2895, 919, 2022, 2023, 2076, 2026, - /* 1650 */ 2078, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2090, - /* 1660 */ 2091, 2092, 892, 885, 1658, 77, 917, 916, 881, 2113, - /* 1670 */ 2114, 62, 62, 325, 2120, 2122, 2123, 2124, 2125, 2127, - /* 1680 */ 2, 60, 58, 2844, 2238, 803, 3015, 333, 2832, 506, - /* 1690 */ 62, 2018, 852, 2250, 2249, 323, 62, 856, 897, 90, - /* 1700 */ 2989, 2863, 348, 182, 863, 2016, 163, 2126, 2102, 165, - /* 1710 */ 185, 368, 367, 2443, 53, 52, 39, 2442, 59, 57, - /* 1720 */ 56, 55, 54, 370, 369, 372, 371, 2354, 2862, 819, - /* 1730 */ 2099, 87, 2148, 374, 373, 376, 375, 378, 377, 3008, - /* 1740 */ 2121, 380, 379, 884, 2809, 925, 896, 382, 381, 384, - /* 1750 */ 383, 2164, 183, 185, 2024, 53, 52, 2112, 2105, 59, - /* 1760 */ 57, 56, 55, 54, 53, 52, 164, 182, 59, 57, - /* 1770 */ 56, 55, 54, 53, 52, 492, 2093, 59, 57, 56, - /* 1780 */ 55, 54, 1887, 826, 1021, 1877, 964, 61, 965, 360, - /* 1790 */ 488, 2843, 912, 1630, 2894, 2844, 1730, 860, 134, 2845, - /* 1800 */ 900, 2847, 2848, 895, 2654, 537, 883, 2895, 919, 1649, - /* 1810 */ 897, 1647, 555, 3077, 2360, 2957, 2567, 401, 795, 500, - /* 1820 */ 2953, 3009, 3019, 834, 2129, 2130, 335, 2030, 835, 2477, - /* 1830 */ 330, 1761, 338, 2655, 2029, 5, 545, 462, 1769, 1776, - /* 1840 */ 2862, 540, 1631, 2041, 2051, 554, 566, 565, 239, 568, - /* 1850 */ 240, 242, 1774, 188, 1911, 394, 2809, 2042, 896, 589, - /* 1860 */ 253, 591, 582, 2079, 2089, 595, 2101, 597, 640, 847, - /* 1870 */ 615, 602, 2647, 2128, 2131, 2104, 626, 628, 636, 639, - /* 1880 */ 641, 653, 652, 650, 2100, 258, 259, 655, 2019, 657, - /* 1890 */ 2017, 658, 2049, 53, 52, 882, 262, 59, 57, 56, - /* 1900 */ 55, 54, 138, 2843, 660, 662, 2894, 681, 4, 682, - /* 1910 */ 202, 2845, 900, 2847, 2848, 895, 689, 690, 883, 2895, - /* 1920 */ 919, 692, 270, 2044, 2022, 2023, 2076, 109, 2078, 2081, - /* 1930 */ 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2090, 2091, 2092, - /* 1940 */ 892, 885, 694, 273, 917, 916, 881, 2113, 2114, 2050, - /* 1950 */ 2052, 695, 2120, 2122, 2123, 2124, 2125, 2127, 2, 60, - /* 1960 */ 58, 276, 698, 696, 2844, 278, 2053, 506, 2670, 2018, - /* 1970 */ 110, 2054, 841, 3078, 111, 2664, 112, 1728, 284, 897, - /* 1980 */ 114, 730, 287, 2016, 707, 2126, 732, 139, 2507, 291, - /* 1990 */ 2503, 763, 764, 293, 191, 136, 780, 2505, 439, 2500, - /* 2000 */ 192, 193, 778, 178, 2097, 115, 397, 310, 2045, 2862, - /* 2010 */ 2716, 790, 791, 789, 313, 315, 796, 823, 2121, 797, - /* 2020 */ 794, 884, 861, 2739, 3024, 2809, 2736, 896, 3023, 8, - /* 2030 */ 2996, 832, 2024, 804, 836, 327, 807, 324, 805, 326, - /* 2040 */ 2735, 204, 806, 328, 837, 533, 532, 320, 493, 3080, - /* 2050 */ 848, 169, 845, 2976, 2046, 2032, 2212, 3056, 334, 331, - /* 2060 */ 2210, 2844, 1021, 217, 322, 61, 340, 233, 398, 2025, - /* 2070 */ 1, 2126, 2843, 179, 859, 2894, 897, 2684, 329, 134, - /* 2080 */ 2845, 900, 2847, 2848, 895, 2683, 864, 883, 2895, 919, - /* 2090 */ 2682, 872, 399, 865, 2932, 497, 2957, 180, 2973, 869, - /* 2100 */ 500, 2953, 2129, 2130, 2121, 74, 2862, 353, 902, 904, - /* 2110 */ 906, 907, 400, 128, 2801, 358, 125, 2520, 2024, 2800, - /* 2120 */ 1541, 2796, 2809, 1016, 896, 2795, 2787, 2938, 2786, 1017, - /* 2130 */ 2778, 921, 2777, 404, 2793, 2792, 2784, 1018, 2783, 2772, - /* 2140 */ 2771, 2079, 2089, 2790, 2789, 390, 2781, 189, 879, 1013, - /* 2150 */ 2780, 2128, 2131, 387, 391, 1020, 782, 440, 2769, 408, - /* 2160 */ 2761, 2768, 2766, 406, 476, 2760, 2019, 524, 2017, 2843, - /* 2170 */ 2765, 2571, 2894, 882, 427, 2759, 134, 2845, 900, 2847, - /* 2180 */ 2848, 895, 98, 2754, 883, 2895, 919, 542, 438, 428, - /* 2190 */ 543, 2930, 1969, 2957, 1970, 237, 547, 500, 2953, 2752, - /* 2200 */ 549, 551, 2022, 2023, 2076, 454, 2078, 2081, 2082, 2083, - /* 2210 */ 2084, 2085, 2086, 2087, 2088, 2090, 2091, 2092, 892, 885, - /* 2220 */ 65, 550, 917, 916, 881, 2113, 2114, 455, 2751, 1968, - /* 2230 */ 2120, 2122, 2123, 2124, 2125, 2127, 2, 60, 58, 2750, - /* 2240 */ 463, 2748, 557, 2747, 559, 506, 2746, 2018, 561, 2745, - /* 2250 */ 563, 1956, 2033, 2720, 2028, 241, 2719, 243, 1914, 99, - /* 2260 */ 1913, 2016, 2697, 2126, 2696, 2695, 575, 2844, 576, 2694, - /* 2270 */ 2693, 2637, 580, 1850, 2634, 2633, 583, 2627, 586, 2624, - /* 2280 */ 587, 246, 897, 2623, 102, 2622, 2621, 2626, 2036, 2038, - /* 2290 */ 2625, 2620, 2619, 2617, 2616, 248, 2121, 2615, 250, 884, - /* 2300 */ 2614, 605, 603, 2612, 2611, 2610, 2609, 2608, 917, 916, - /* 2310 */ 2024, 2632, 2862, 2607, 2606, 2605, 2120, 2122, 2123, 2124, - /* 2320 */ 2125, 2127, 2630, 2613, 2604, 2603, 2602, 2600, 2809, 2599, - /* 2330 */ 896, 2598, 2597, 2596, 2595, 252, 2594, 2593, 2592, 2591, - /* 2340 */ 1021, 2589, 108, 15, 2588, 2662, 2631, 2629, 2587, 2586, - /* 2350 */ 1856, 2585, 257, 2584, 643, 2583, 645, 2582, 2580, 2408, - /* 2360 */ 452, 453, 1697, 2407, 1701, 2406, 1693, 260, 2405, 261, - /* 2370 */ 263, 2403, 264, 2400, 664, 2843, 668, 2392, 2894, 663, - /* 2380 */ 2129, 2130, 134, 2845, 900, 2847, 2848, 895, 2399, 2379, - /* 2390 */ 883, 2895, 919, 2367, 665, 2366, 667, 876, 669, 2957, - /* 2400 */ 671, 2349, 675, 500, 2953, 673, 679, 212, 1570, 672, - /* 2410 */ 2348, 2718, 2844, 94, 266, 2714, 2704, 2692, 677, 2079, - /* 2420 */ 2089, 277, 95, 2829, 268, 275, 223, 897, 2691, 2128, - /* 2430 */ 2131, 687, 2668, 280, 282, 2661, 2495, 2402, 2398, 708, - /* 2440 */ 710, 2396, 709, 712, 2019, 2394, 2017, 713, 716, 714, - /* 2450 */ 718, 882, 2391, 722, 717, 720, 721, 2862, 2374, 2372, - /* 2460 */ 2373, 2371, 2368, 1623, 2345, 728, 2497, 1781, 1780, 2496, - /* 2470 */ 1683, 1665, 981, 2809, 2389, 896, 1682, 983, 1681, 1678, - /* 2480 */ 2022, 2023, 2076, 1676, 2078, 2081, 2082, 2083, 2084, 2085, - /* 2490 */ 2086, 2087, 2088, 2090, 2091, 2092, 892, 885, 481, 1674, - /* 2500 */ 917, 916, 881, 2113, 2114, 2387, 1673, 1672, 2120, 2122, - /* 2510 */ 2123, 2124, 2125, 2127, 2, 450, 449, 1671, 2844, 86, - /* 2520 */ 2843, 1670, 1667, 2894, 290, 513, 1666, 135, 2845, 900, - /* 2530 */ 2847, 2848, 895, 897, 1664, 883, 2895, 919, 2378, 522, - /* 2540 */ 482, 2126, 483, 758, 2957, 2844, 2376, 484, 2956, 2953, - /* 2550 */ 761, 2344, 2343, 2342, 2341, 765, 2340, 767, 769, 2339, - /* 2560 */ 897, 771, 141, 2862, 1950, 1952, 1949, 2717, 312, 1954, - /* 2570 */ 2713, 33, 80, 2703, 2121, 2690, 1920, 1922, 2689, 2809, - /* 2580 */ 792, 896, 69, 3062, 2267, 2844, 17, 2241, 1939, 817, - /* 2590 */ 2862, 35, 228, 22, 808, 319, 70, 36, 811, 2239, - /* 2600 */ 897, 489, 6, 78, 793, 813, 2809, 815, 896, 7, - /* 2610 */ 1899, 321, 2844, 2248, 194, 316, 1898, 23, 781, 24, - /* 2620 */ 203, 216, 215, 38, 798, 37, 2843, 897, 1924, 2894, - /* 2630 */ 2862, 800, 2233, 135, 2845, 900, 2847, 2848, 895, 25, - /* 2640 */ 2830, 883, 2895, 919, 96, 229, 2809, 2207, 896, 2205, - /* 2650 */ 2957, 2203, 230, 898, 878, 2953, 2894, 2862, 26, 2282, - /* 2660 */ 135, 2845, 900, 2847, 2848, 895, 2287, 2288, 883, 2895, - /* 2670 */ 919, 2281, 494, 2809, 2286, 896, 2285, 2957, 495, 72, - /* 2680 */ 2187, 457, 2953, 336, 208, 2186, 2688, 2667, 120, 119, - /* 2690 */ 2666, 121, 218, 2843, 862, 343, 2894, 2660, 2243, 349, - /* 2700 */ 413, 2845, 900, 2847, 2848, 895, 868, 32, 883, 2895, - /* 2710 */ 919, 82, 351, 352, 870, 122, 27, 2139, 11, 2138, - /* 2720 */ 2843, 354, 2009, 2894, 1985, 71, 13, 135, 2845, 900, - /* 2730 */ 2847, 2848, 895, 2034, 21, 883, 2895, 919, 2149, 28, - /* 2740 */ 18, 2096, 29, 209, 2957, 20, 219, 50, 932, 2954, - /* 2750 */ 2095, 2069, 935, 2659, 899, 938, 515, 514, 2010, 941, - /* 2760 */ 123, 51, 905, 2492, 2094, 910, 16, 2301, 30, 2844, - /* 2770 */ 2061, 31, 83, 911, 903, 356, 124, 92, 917, 916, - /* 2780 */ 129, 362, 2907, 2906, 897, 2108, 2120, 2122, 2123, 2124, - /* 2790 */ 2125, 2127, 918, 81, 924, 1762, 920, 2844, 525, 926, - /* 2800 */ 2300, 1759, 928, 929, 931, 934, 937, 1758, 1755, 940, - /* 2810 */ 1749, 130, 897, 1747, 2862, 386, 131, 1753, 1752, 1751, - /* 2820 */ 1750, 1775, 93, 1771, 1661, 1621, 955, 1660, 1659, 1656, - /* 2830 */ 2809, 1653, 896, 1652, 1651, 1650, 1648, 1691, 969, 1646, - /* 2840 */ 1645, 1644, 2862, 971, 1690, 235, 1642, 1641, 1639, 1640, - /* 2850 */ 1638, 1627, 1637, 1636, 503, 1685, 1687, 1633, 2809, 1632, - /* 2860 */ 896, 1629, 2397, 1628, 1626, 992, 991, 2395, 993, 995, - /* 2870 */ 2393, 999, 2390, 1003, 2370, 996, 997, 2843, 1001, 1000, - /* 2880 */ 2894, 2844, 1007, 1005, 437, 2845, 900, 2847, 2848, 895, - /* 2890 */ 2365, 1009, 883, 2895, 919, 1004, 897, 2364, 1011, 1559, - /* 2900 */ 2338, 1542, 1547, 392, 1015, 2843, 1019, 1022, 2894, 2844, - /* 2910 */ 2020, 1549, 199, 2845, 900, 2847, 2848, 895, 405, 1023, - /* 2920 */ 883, 2895, 919, 2304, 897, 2304, 2862, 2304, 2304, 2304, - /* 2930 */ 2844, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 2940 */ 2304, 2304, 2809, 2304, 896, 897, 2304, 2304, 2304, 2304, - /* 2950 */ 2304, 2304, 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, - /* 2960 */ 2304, 2304, 2304, 3016, 2304, 2304, 490, 2304, 2304, 2304, - /* 2970 */ 2809, 2304, 896, 2304, 2304, 2862, 2304, 2304, 2304, 2304, - /* 2980 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2843, - /* 2990 */ 2304, 2809, 2894, 896, 491, 2304, 437, 2845, 900, 2847, - /* 3000 */ 2848, 895, 2304, 2304, 883, 2895, 919, 2304, 2304, 2304, - /* 3010 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2843, 2304, 2304, - /* 3020 */ 2894, 2844, 2304, 2304, 437, 2845, 900, 2847, 2848, 895, - /* 3030 */ 2304, 2304, 883, 2895, 919, 2304, 897, 2304, 2843, 2304, - /* 3040 */ 2304, 2894, 2844, 2304, 2304, 430, 2845, 900, 2847, 2848, - /* 3050 */ 895, 2304, 2304, 883, 2895, 919, 2304, 894, 2304, 2304, - /* 3060 */ 2304, 2304, 2844, 2304, 2304, 2304, 2862, 2304, 2304, 2304, - /* 3070 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 897, 2304, 2304, - /* 3080 */ 2304, 2304, 2809, 2304, 896, 2304, 2304, 2862, 2304, 2304, - /* 3090 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 831, - /* 3100 */ 2304, 2304, 2304, 2809, 2304, 896, 2304, 2862, 2304, 2304, - /* 3110 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3120 */ 2304, 2304, 2304, 2809, 2304, 896, 2304, 2304, 2304, 2843, - /* 3130 */ 2304, 2304, 2894, 2304, 2304, 2304, 202, 2845, 900, 2847, - /* 3140 */ 2848, 895, 2304, 2304, 883, 2895, 919, 504, 2304, 2304, - /* 3150 */ 2843, 2304, 2304, 2894, 2304, 2304, 2304, 436, 2845, 900, - /* 3160 */ 2847, 2848, 895, 2304, 2304, 883, 2895, 919, 2304, 2923, - /* 3170 */ 2843, 2304, 2304, 2894, 2304, 2304, 2304, 437, 2845, 900, - /* 3180 */ 2847, 2848, 895, 2844, 2304, 883, 2895, 919, 2304, 2304, - /* 3190 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 897, 3079, - /* 3200 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2844, 2304, - /* 3210 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3220 */ 2304, 2304, 2304, 897, 2304, 2304, 2304, 2304, 2862, 2304, - /* 3230 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3240 */ 2304, 2304, 2304, 2304, 2809, 2304, 896, 2304, 2304, 2304, - /* 3250 */ 2304, 2304, 2844, 2862, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3260 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 897, 499, 2809, - /* 3270 */ 2304, 896, 2304, 2304, 2304, 2844, 2304, 2304, 2304, 2304, - /* 3280 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3290 */ 897, 2843, 2304, 505, 2894, 2304, 2304, 2862, 422, 2845, - /* 3300 */ 900, 2847, 2848, 895, 2304, 2304, 883, 2895, 919, 2304, - /* 3310 */ 2304, 2304, 2304, 2809, 2304, 896, 2843, 2304, 2304, 2894, - /* 3320 */ 2862, 2304, 2304, 437, 2845, 900, 2847, 2848, 895, 2304, - /* 3330 */ 2304, 883, 2895, 919, 2304, 2304, 2809, 507, 896, 2304, - /* 3340 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3350 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3360 */ 2843, 2304, 2304, 2894, 2844, 2304, 2304, 437, 2845, 900, - /* 3370 */ 2847, 2848, 895, 2304, 2304, 883, 2895, 919, 2304, 897, - /* 3380 */ 2304, 2304, 2304, 2843, 2304, 2304, 2894, 2844, 2304, 2304, - /* 3390 */ 418, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, 2895, - /* 3400 */ 919, 2304, 897, 2304, 2304, 2304, 2304, 2304, 2304, 2862, - /* 3410 */ 2304, 2304, 2304, 2304, 2304, 2844, 2304, 2304, 2304, 2304, - /* 3420 */ 2304, 2304, 2304, 2304, 2304, 2809, 2304, 896, 2304, 2304, - /* 3430 */ 897, 2304, 2862, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3440 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2809, 2304, - /* 3450 */ 896, 2304, 2304, 2304, 2304, 2304, 2844, 2304, 2304, 2304, - /* 3460 */ 2862, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3470 */ 2304, 897, 777, 2304, 2304, 2894, 2809, 2304, 896, 432, - /* 3480 */ 2845, 900, 2847, 2848, 895, 2304, 2304, 883, 2895, 919, - /* 3490 */ 2304, 2304, 2304, 2304, 2304, 2843, 2304, 2304, 2894, 2844, - /* 3500 */ 2304, 2862, 414, 2845, 900, 2847, 2848, 895, 2304, 2304, - /* 3510 */ 883, 2895, 919, 2304, 897, 2304, 2304, 2809, 2304, 896, - /* 3520 */ 2304, 2304, 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, - /* 3530 */ 410, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, 2895, - /* 3540 */ 919, 2844, 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, - /* 3550 */ 2304, 2304, 2304, 2304, 2304, 2304, 897, 2304, 2304, 2304, - /* 3560 */ 2809, 2304, 896, 2304, 2843, 2304, 2304, 2894, 2304, 2304, - /* 3570 */ 2304, 411, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, - /* 3580 */ 2895, 919, 2304, 2304, 2304, 2304, 2862, 2304, 2304, 2304, - /* 3590 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3600 */ 2304, 2304, 2809, 2304, 896, 2304, 2304, 2843, 2304, 2304, - /* 3610 */ 2894, 2304, 2304, 2304, 415, 2845, 900, 2847, 2848, 895, - /* 3620 */ 2304, 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, - /* 3630 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2844, 2304, - /* 3640 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2843, - /* 3650 */ 2304, 2304, 2894, 897, 2304, 2304, 429, 2845, 900, 2847, - /* 3660 */ 2848, 895, 2844, 2304, 883, 2895, 919, 2304, 2304, 2304, - /* 3670 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 897, 2304, 2304, - /* 3680 */ 2304, 2304, 2304, 2862, 2304, 2304, 2304, 2844, 2304, 2304, - /* 3690 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2809, - /* 3700 */ 2304, 896, 897, 2304, 2304, 2304, 2304, 2862, 2304, 2304, - /* 3710 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3720 */ 2304, 2304, 2304, 2809, 2304, 896, 2304, 2844, 2304, 2304, - /* 3730 */ 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3740 */ 2304, 2304, 897, 2304, 2304, 2304, 2843, 2304, 2809, 2894, - /* 3750 */ 896, 2304, 2304, 416, 2845, 900, 2847, 2848, 895, 2304, - /* 3760 */ 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, 2844, - /* 3770 */ 2843, 2304, 2862, 2894, 2304, 2304, 2304, 417, 2845, 900, - /* 3780 */ 2847, 2848, 895, 2304, 897, 883, 2895, 919, 2809, 2304, - /* 3790 */ 896, 2304, 2304, 2304, 2844, 2843, 2304, 2304, 2894, 2304, - /* 3800 */ 2304, 2304, 433, 2845, 900, 2847, 2848, 895, 2304, 897, - /* 3810 */ 883, 2895, 919, 2304, 2862, 2304, 2304, 2304, 2304, 2304, - /* 3820 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3830 */ 2809, 2304, 896, 2304, 2304, 2843, 2304, 2304, 2894, 2862, - /* 3840 */ 2304, 2304, 419, 2845, 900, 2847, 2848, 895, 2304, 2304, - /* 3850 */ 883, 2895, 919, 2304, 2304, 2809, 2304, 896, 2304, 2304, - /* 3860 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3870 */ 2304, 2304, 2304, 2304, 2304, 2844, 2304, 2843, 2304, 2304, - /* 3880 */ 2894, 2304, 2304, 2304, 434, 2845, 900, 2847, 2848, 895, - /* 3890 */ 897, 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, - /* 3900 */ 2844, 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, 420, - /* 3910 */ 2845, 900, 2847, 2848, 895, 897, 2304, 883, 2895, 919, - /* 3920 */ 2862, 2304, 2304, 2304, 2844, 2304, 2304, 2304, 2304, 2304, - /* 3930 */ 2304, 2304, 2304, 2304, 2304, 2304, 2809, 2304, 896, 897, - /* 3940 */ 2304, 2304, 2304, 2304, 2304, 2862, 2304, 2304, 2304, 2304, - /* 3950 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3960 */ 2304, 2809, 2304, 896, 2304, 2844, 2304, 2304, 2304, 2862, - /* 3970 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 3980 */ 897, 2304, 2304, 2843, 2304, 2809, 2894, 896, 2304, 2304, - /* 3990 */ 435, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, 2895, - /* 4000 */ 919, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2843, 2304, - /* 4010 */ 2862, 2894, 2304, 2304, 2304, 421, 2845, 900, 2847, 2848, - /* 4020 */ 895, 2304, 2304, 883, 2895, 919, 2809, 2304, 896, 2304, - /* 4030 */ 2304, 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, 412, - /* 4040 */ 2845, 900, 2847, 2848, 895, 2304, 2844, 883, 2895, 919, - /* 4050 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4060 */ 2304, 897, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4070 */ 2304, 2844, 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, - /* 4080 */ 423, 2845, 900, 2847, 2848, 895, 897, 2304, 883, 2895, - /* 4090 */ 919, 2862, 2304, 2304, 2304, 2844, 2304, 2304, 2304, 2304, - /* 4100 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2809, 2304, 896, - /* 4110 */ 897, 2304, 2304, 2304, 2304, 2304, 2862, 2304, 2304, 2304, - /* 4120 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4130 */ 2304, 2304, 2809, 2304, 896, 2304, 2844, 2304, 2304, 2304, - /* 4140 */ 2862, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4150 */ 2304, 897, 2304, 2304, 2843, 2304, 2809, 2894, 896, 2304, - /* 4160 */ 2304, 424, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, - /* 4170 */ 2895, 919, 2304, 2304, 2304, 2304, 2304, 2304, 2844, 2843, - /* 4180 */ 2304, 2862, 2894, 2304, 2304, 2304, 425, 2845, 900, 2847, - /* 4190 */ 2848, 895, 2304, 897, 883, 2895, 919, 2809, 2304, 896, - /* 4200 */ 2304, 2844, 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, - /* 4210 */ 426, 2845, 900, 2847, 2848, 895, 897, 2304, 883, 2895, - /* 4220 */ 919, 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4230 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2809, - /* 4240 */ 2304, 896, 2304, 2304, 2843, 2304, 2862, 2894, 2304, 2304, - /* 4250 */ 2304, 442, 2845, 900, 2847, 2848, 895, 2304, 2304, 883, - /* 4260 */ 2895, 919, 2809, 2304, 896, 2304, 2304, 2304, 2304, 2844, - /* 4270 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4280 */ 2304, 2304, 2304, 2304, 897, 2304, 2843, 2304, 2304, 2894, - /* 4290 */ 2304, 2304, 2304, 443, 2845, 900, 2847, 2848, 895, 2304, - /* 4300 */ 2304, 883, 2895, 919, 2304, 2304, 2304, 2844, 2304, 2843, - /* 4310 */ 2304, 2304, 2894, 2304, 2862, 2304, 2856, 2845, 900, 2847, - /* 4320 */ 2848, 895, 897, 2304, 883, 2895, 919, 2304, 2304, 2304, - /* 4330 */ 2809, 2304, 896, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4340 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4350 */ 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4360 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2809, 2304, - /* 4370 */ 896, 2304, 2304, 2304, 2304, 2304, 2304, 2843, 2304, 2304, - /* 4380 */ 2894, 2304, 2304, 2304, 2855, 2845, 900, 2847, 2848, 895, - /* 4390 */ 2304, 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, - /* 4400 */ 2304, 2304, 2844, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4410 */ 2304, 2304, 2304, 2304, 2304, 2843, 2304, 897, 2894, 2304, - /* 4420 */ 2304, 2304, 2854, 2845, 900, 2847, 2848, 895, 2304, 2844, - /* 4430 */ 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4440 */ 2304, 2304, 2304, 2304, 897, 2304, 2304, 2862, 2304, 2304, - /* 4450 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4460 */ 2304, 2304, 2304, 2809, 2304, 896, 2304, 2844, 2304, 2304, - /* 4470 */ 2304, 2304, 2304, 2304, 2862, 2304, 2304, 2304, 2304, 2304, - /* 4480 */ 2304, 2304, 897, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4490 */ 2809, 2304, 896, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4500 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4510 */ 2843, 2304, 2862, 2894, 2304, 2304, 2304, 459, 2845, 900, - /* 4520 */ 2847, 2848, 895, 2304, 2304, 883, 2895, 919, 2809, 2304, - /* 4530 */ 896, 2304, 2304, 2304, 2304, 2304, 2304, 2843, 2304, 2304, - /* 4540 */ 2894, 2304, 2304, 2304, 460, 2845, 900, 2847, 2848, 895, - /* 4550 */ 2844, 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, 2304, - /* 4560 */ 2304, 2304, 2304, 2304, 2304, 897, 2304, 2304, 2304, 2304, - /* 4570 */ 2304, 2304, 2304, 2844, 2304, 2843, 2304, 2304, 2894, 2304, - /* 4580 */ 2304, 2304, 456, 2845, 900, 2847, 2848, 895, 897, 2304, - /* 4590 */ 883, 2895, 919, 2844, 2304, 2862, 2304, 2304, 2304, 2304, - /* 4600 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 897, 2304, - /* 4610 */ 2304, 2809, 2304, 896, 2304, 2304, 2304, 2304, 2862, 2304, - /* 4620 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4630 */ 2304, 2304, 2304, 2304, 2809, 2304, 896, 2304, 2862, 2304, - /* 4640 */ 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, 2304, - /* 4650 */ 2304, 2304, 2304, 2304, 2809, 2304, 896, 2304, 2843, 2304, - /* 4660 */ 2304, 2894, 2304, 2304, 2304, 461, 2845, 900, 2847, 2848, - /* 4670 */ 895, 2304, 2304, 883, 2895, 919, 2304, 2304, 2304, 2304, - /* 4680 */ 2304, 898, 2304, 2304, 2894, 2304, 2304, 2304, 432, 2845, - /* 4690 */ 900, 2847, 2848, 895, 2304, 2304, 883, 2895, 919, 2304, - /* 4700 */ 2304, 2843, 2304, 2304, 2894, 2304, 2304, 2304, 431, 2845, - /* 4710 */ 900, 2847, 2848, 895, 2304, 2304, 883, 2895, 919, + /* 450 */ 2528, 2028, 611, 610, 609, 608, 607, 601, 600, 599, + /* 460 */ 702, 594, 593, 465, 572, 956, 571, 585, 1854, 1855, + /* 470 */ 339, 396, 2082, 2092, 1873, 853, 200, 2969, 2970, 9, + /* 480 */ 168, 2974, 2131, 2134, 224, 2981, 2193, 2194, 2195, 2981, + /* 490 */ 2981, 2981, 2981, 2981, 3066, 41, 518, 2022, 570, 2020, + /* 500 */ 2570, 53, 52, 1687, 882, 59, 57, 56, 55, 54, + /* 510 */ 185, 2049, 2083, 53, 52, 1790, 1791, 59, 57, 56, + /* 520 */ 55, 54, 53, 52, 45, 355, 59, 57, 56, 55, + /* 530 */ 54, 486, 2727, 2025, 2026, 2079, 2848, 2081, 2084, 2085, + /* 540 */ 2086, 2087, 2088, 2089, 2090, 2091, 2093, 2094, 2095, 892, + /* 550 */ 885, 854, 1689, 917, 916, 881, 2116, 2117, 289, 2051, + /* 560 */ 339, 2123, 2125, 2126, 2127, 2128, 2130, 2, 60, 58, + /* 570 */ 783, 1893, 1894, 2049, 729, 2080, 506, 206, 2021, 477, + /* 580 */ 475, 2866, 197, 458, 2733, 1751, 723, 719, 715, 711, + /* 590 */ 2454, 288, 2019, 2196, 2129, 2407, 67, 2813, 2823, 896, + /* 600 */ 1742, 946, 945, 944, 1746, 943, 1748, 1749, 891, 890, + /* 610 */ 2291, 1757, 889, 1759, 1760, 888, 930, 927, 53, 52, + /* 620 */ 1892, 1895, 59, 57, 56, 55, 54, 2124, 2827, 1595, + /* 630 */ 884, 1594, 2766, 2159, 19, 2976, 2031, 286, 851, 170, + /* 640 */ 974, 2027, 285, 2480, 2847, 166, 308, 2898, 829, 79, + /* 650 */ 2583, 134, 2849, 900, 2851, 2852, 895, 40, 496, 883, + /* 660 */ 2899, 919, 474, 472, 2973, 733, 213, 2757, 2961, 2581, + /* 670 */ 1596, 1022, 500, 2957, 15, 752, 751, 750, 2829, 2831, + /* 680 */ 501, 1990, 742, 167, 746, 2512, 735, 337, 745, 802, + /* 690 */ 734, 2583, 919, 744, 749, 480, 479, 3061, 2160, 743, + /* 700 */ 3009, 2225, 2140, 478, 739, 738, 737, 2046, 2046, 272, + /* 710 */ 858, 2132, 2133, 517, 516, 3067, 231, 956, 283, 2527, + /* 720 */ 3062, 840, 274, 281, 546, 2298, 2505, 473, 279, 697, + /* 730 */ 190, 2806, 2680, 12, 523, 409, 915, 2523, 2981, 2193, + /* 740 */ 2194, 2195, 2981, 2981, 2981, 2981, 2981, 271, 512, 337, + /* 750 */ 2082, 2092, 2678, 901, 407, 89, 530, 1699, 88, 558, + /* 760 */ 2131, 2134, 919, 75, 140, 2969, 2970, 470, 168, 2974, + /* 770 */ 2632, 1698, 447, 2583, 2807, 2022, 948, 2020, 2165, 2574, + /* 780 */ 782, 464, 882, 2027, 265, 661, 659, 656, 654, 2256, + /* 790 */ 915, 2523, 2581, 700, 512, 2767, 2306, 2622, 44, 502, + /* 800 */ 2154, 2155, 2156, 2157, 2158, 2162, 2163, 2164, 919, 947, + /* 810 */ 236, 2025, 2026, 2079, 588, 2081, 2084, 2085, 2086, 2087, + /* 820 */ 2088, 2089, 2090, 2091, 2093, 2094, 2095, 892, 885, 2497, + /* 830 */ 75, 917, 916, 881, 2116, 2117, 12, 512, 10, 2123, + /* 840 */ 2125, 2126, 2127, 2128, 2130, 2, 12, 60, 58, 251, + /* 850 */ 649, 919, 802, 740, 2680, 506, 2297, 2021, 701, 2673, + /* 860 */ 3061, 821, 820, 2254, 2255, 2257, 2258, 2259, 508, 76, + /* 870 */ 2494, 2019, 839, 2129, 2677, 901, 1680, 2848, 3067, 231, + /* 880 */ 3061, 2083, 2083, 3062, 840, 2079, 539, 171, 915, 2523, + /* 890 */ 2932, 538, 897, 2583, 2366, 107, 880, 562, 838, 231, + /* 900 */ 106, 269, 828, 3062, 840, 686, 2124, 2364, 68, 884, + /* 910 */ 590, 2649, 866, 19, 2198, 2199, 2200, 2201, 2202, 875, + /* 920 */ 2027, 2933, 2866, 101, 100, 577, 564, 560, 244, 53, + /* 930 */ 52, 2372, 2866, 59, 57, 56, 55, 54, 2813, 2498, + /* 940 */ 896, 569, 567, 802, 2080, 2080, 915, 2523, 596, 2649, + /* 950 */ 1022, 3061, 2218, 15, 444, 627, 2649, 556, 786, 339, + /* 960 */ 552, 548, 544, 541, 570, 247, 578, 105, 47, 3067, + /* 970 */ 231, 618, 176, 2021, 3062, 840, 617, 954, 187, 186, + /* 980 */ 951, 950, 949, 184, 616, 2847, 2976, 2019, 2898, 1009, + /* 990 */ 2132, 2133, 134, 2849, 900, 2851, 2852, 895, 113, 2976, + /* 1000 */ 883, 2899, 919, 249, 827, 915, 2523, 3081, 971, 2961, + /* 1010 */ 254, 915, 2523, 500, 2957, 2972, 784, 471, 954, 187, + /* 1020 */ 186, 951, 950, 949, 184, 579, 339, 2516, 2971, 2082, + /* 1030 */ 2092, 598, 915, 2523, 1025, 2510, 2027, 915, 2523, 2131, + /* 1040 */ 2134, 788, 2719, 53, 52, 915, 2523, 59, 57, 56, + /* 1050 */ 55, 54, 612, 393, 2022, 2508, 2020, 613, 521, 915, + /* 1060 */ 2523, 882, 725, 724, 43, 614, 1022, 2331, 1013, 1011, + /* 1070 */ 53, 52, 221, 2151, 59, 57, 56, 55, 54, 705, + /* 1080 */ 973, 1007, 1003, 999, 995, 2161, 388, 2050, 113, 1571, + /* 1090 */ 2025, 2026, 2079, 395, 2081, 2084, 2085, 2086, 2087, 2088, + /* 1100 */ 2089, 2090, 2091, 2093, 2094, 2095, 892, 885, 851, 170, + /* 1110 */ 917, 916, 881, 2116, 2117, 1569, 1570, 2517, 2123, 2125, + /* 1120 */ 2126, 2127, 2128, 2130, 2, 60, 58, 2135, 2813, 2848, + /* 1130 */ 915, 2523, 133, 506, 1564, 2021, 779, 361, 915, 2523, + /* 1140 */ 2577, 2578, 759, 306, 897, 2583, 3016, 305, 403, 2019, + /* 1150 */ 2518, 2129, 2560, 1571, 2267, 53, 52, 773, 309, 59, + /* 1160 */ 57, 56, 55, 54, 2582, 2166, 2848, 2583, 867, 833, + /* 1170 */ 2022, 801, 2020, 553, 2866, 511, 304, 97, 1566, 1569, + /* 1180 */ 1570, 897, 318, 3029, 2124, 42, 2581, 884, 1598, 1599, + /* 1190 */ 2813, 2583, 896, 802, 173, 762, 915, 2523, 2027, 527, + /* 1200 */ 238, 3061, 756, 754, 3065, 2513, 2025, 2026, 3, 301, + /* 1210 */ 2581, 2866, 877, 359, 2933, 873, 317, 2330, 342, 3067, + /* 1220 */ 231, 116, 66, 341, 3062, 840, 448, 2813, 1022, 896, + /* 1230 */ 485, 61, 774, 118, 201, 2969, 2970, 2847, 168, 2974, + /* 1240 */ 2898, 2207, 311, 1989, 134, 2849, 900, 2851, 2852, 895, + /* 1250 */ 915, 2523, 883, 2899, 919, 85, 1595, 2455, 1594, 3081, + /* 1260 */ 84, 2961, 787, 226, 2217, 500, 2957, 2329, 2132, 2133, + /* 1270 */ 857, 56, 55, 54, 2847, 520, 519, 2898, 2813, 727, + /* 1280 */ 726, 134, 2849, 900, 2851, 2852, 895, 748, 747, 883, + /* 1290 */ 2899, 919, 752, 751, 750, 163, 3081, 1596, 2961, 742, + /* 1300 */ 167, 746, 500, 2957, 529, 745, 396, 2082, 2092, 103, + /* 1310 */ 744, 749, 480, 479, 195, 73, 743, 2131, 2134, 802, + /* 1320 */ 478, 739, 738, 737, 2051, 2528, 799, 3061, 2813, 985, + /* 1330 */ 983, 2050, 2022, 2753, 2020, 2046, 53, 52, 2605, 882, + /* 1340 */ 59, 57, 56, 55, 54, 3067, 231, 2321, 53, 52, + /* 1350 */ 3062, 840, 59, 57, 56, 55, 54, 2328, 53, 52, + /* 1360 */ 2327, 314, 59, 57, 56, 55, 54, 2728, 2025, 2026, + /* 1370 */ 2079, 2326, 2081, 2084, 2085, 2086, 2087, 2088, 2089, 2090, + /* 1380 */ 2091, 2093, 2094, 2095, 892, 885, 843, 48, 917, 916, + /* 1390 */ 881, 2116, 2117, 2336, 1015, 922, 2123, 2125, 2126, 2127, + /* 1400 */ 2128, 2130, 2, 60, 58, 915, 2523, 2848, 915, 2523, + /* 1410 */ 2325, 506, 1703, 2021, 952, 855, 953, 2574, 2813, 2574, + /* 1420 */ 49, 2813, 897, 402, 816, 350, 1702, 2019, 871, 2129, + /* 1430 */ 915, 2523, 2813, 2594, 2848, 954, 187, 186, 951, 950, + /* 1440 */ 949, 184, 1573, 2585, 915, 2523, 915, 2523, 2045, 897, + /* 1450 */ 357, 3054, 2866, 915, 2523, 915, 2523, 735, 2324, 2101, + /* 1460 */ 2527, 734, 2124, 195, 908, 884, 909, 846, 2813, 2237, + /* 1470 */ 896, 2813, 802, 913, 2529, 385, 2027, 53, 52, 2866, + /* 1480 */ 3061, 59, 57, 56, 55, 54, 53, 52, 2030, 741, + /* 1490 */ 59, 57, 56, 55, 54, 2813, 620, 896, 3067, 231, + /* 1500 */ 2323, 2322, 809, 3062, 840, 651, 1022, 234, 2319, 61, + /* 1510 */ 2114, 619, 1678, 2318, 2317, 2847, 2316, 2315, 2898, 2813, + /* 1520 */ 2848, 2314, 134, 2849, 900, 2851, 2852, 895, 2313, 2312, + /* 1530 */ 883, 2899, 919, 2311, 678, 897, 177, 3081, 842, 2961, + /* 1540 */ 775, 3022, 2847, 500, 2957, 2898, 2132, 2133, 91, 134, + /* 1550 */ 2849, 900, 2851, 2852, 895, 177, 1682, 883, 2899, 919, + /* 1560 */ 294, 2813, 2813, 292, 3081, 2866, 2961, 205, 2051, 2813, + /* 1570 */ 500, 2957, 2080, 296, 2813, 2813, 295, 2813, 2813, 812, + /* 1580 */ 222, 2813, 2813, 896, 680, 2082, 2092, 2391, 2243, 2813, + /* 1590 */ 2813, 632, 2389, 2380, 2813, 2131, 2134, 2102, 62, 333, + /* 1600 */ 298, 647, 104, 297, 300, 1683, 923, 299, 2378, 753, + /* 1610 */ 2022, 62, 2020, 214, 755, 757, 185, 882, 344, 53, + /* 1620 */ 52, 2834, 1937, 59, 57, 56, 55, 54, 2847, 822, + /* 1630 */ 760, 2898, 325, 14, 13, 199, 2849, 900, 2851, 2852, + /* 1640 */ 895, 1945, 2029, 883, 2899, 919, 2025, 2026, 2079, 90, + /* 1650 */ 2081, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2093, + /* 1660 */ 2094, 2095, 892, 885, 62, 2241, 917, 916, 881, 2116, + /* 1670 */ 2117, 2300, 2301, 2033, 2123, 2125, 2126, 2127, 2128, 2130, + /* 1680 */ 2, 60, 58, 2848, 2253, 803, 3019, 165, 2836, 506, + /* 1690 */ 77, 2021, 844, 364, 363, 852, 62, 2252, 897, 323, + /* 1700 */ 2993, 2867, 856, 62, 348, 2019, 62, 2129, 2446, 2445, + /* 1710 */ 62, 90, 366, 365, 53, 52, 39, 3012, 59, 57, + /* 1720 */ 56, 55, 54, 776, 2357, 182, 163, 132, 2866, 129, + /* 1730 */ 2104, 185, 368, 367, 819, 863, 370, 369, 372, 371, + /* 1740 */ 2124, 374, 373, 884, 2813, 87, 896, 925, 376, 375, + /* 1750 */ 2105, 378, 377, 492, 2027, 53, 52, 380, 379, 59, + /* 1760 */ 57, 56, 55, 54, 53, 52, 183, 185, 59, 57, + /* 1770 */ 56, 55, 54, 53, 52, 847, 2167, 59, 57, 56, + /* 1780 */ 55, 54, 2115, 164, 1022, 382, 381, 61, 1659, 2108, + /* 1790 */ 182, 2847, 2096, 965, 2898, 2848, 1890, 1880, 134, 2849, + /* 1800 */ 900, 2851, 2852, 895, 384, 383, 883, 2899, 919, 966, + /* 1810 */ 897, 360, 912, 3081, 826, 2961, 1651, 1733, 1632, 500, + /* 1820 */ 2957, 488, 2658, 537, 2132, 2133, 860, 2032, 555, 2363, + /* 1830 */ 2571, 401, 1649, 1764, 795, 3013, 3023, 1660, 834, 835, + /* 1840 */ 2866, 330, 335, 338, 2659, 5, 2481, 540, 545, 462, + /* 1850 */ 2044, 554, 1772, 1779, 2054, 566, 2813, 565, 896, 239, + /* 1860 */ 568, 240, 242, 2082, 2092, 1914, 2107, 1633, 394, 1777, + /* 1870 */ 582, 2045, 589, 2131, 2134, 2103, 188, 591, 253, 595, + /* 1880 */ 597, 640, 602, 626, 2100, 636, 615, 2651, 2022, 628, + /* 1890 */ 2020, 639, 641, 652, 653, 882, 259, 650, 655, 657, + /* 1900 */ 262, 258, 138, 2847, 658, 660, 2898, 662, 2052, 681, + /* 1910 */ 202, 2849, 900, 2851, 2852, 895, 4, 682, 883, 2899, + /* 1920 */ 919, 689, 690, 270, 2025, 2026, 2079, 692, 2081, 2084, + /* 1930 */ 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2093, 2094, 2095, + /* 1940 */ 892, 885, 109, 2047, 917, 916, 881, 2116, 2117, 273, + /* 1950 */ 694, 2053, 2123, 2125, 2126, 2127, 2128, 2130, 2, 60, + /* 1960 */ 58, 695, 2055, 276, 2848, 696, 698, 506, 2056, 2021, + /* 1970 */ 278, 110, 841, 3082, 2674, 2057, 111, 2668, 112, 897, + /* 1980 */ 1731, 707, 284, 2019, 114, 2129, 730, 732, 287, 2511, + /* 1990 */ 763, 291, 764, 2743, 2507, 139, 293, 191, 439, 136, + /* 2000 */ 778, 2509, 2504, 115, 192, 193, 178, 780, 2048, 2866, + /* 2010 */ 790, 397, 789, 310, 2720, 315, 791, 313, 2124, 796, + /* 2020 */ 797, 884, 2740, 2739, 861, 2813, 3028, 896, 823, 794, + /* 2030 */ 806, 8, 2027, 832, 804, 837, 805, 3027, 2980, 807, + /* 2040 */ 836, 204, 326, 3000, 848, 533, 532, 324, 327, 320, + /* 2050 */ 331, 322, 328, 493, 169, 2035, 845, 2049, 2215, 2213, + /* 2060 */ 329, 2848, 1022, 3060, 217, 61, 340, 179, 859, 2028, + /* 2070 */ 864, 2129, 2847, 1, 398, 2898, 897, 3084, 233, 134, + /* 2080 */ 2849, 900, 2851, 2852, 895, 180, 399, 883, 2899, 919, + /* 2090 */ 334, 2977, 2688, 2687, 2936, 2686, 2961, 497, 865, 869, + /* 2100 */ 500, 2957, 2132, 2133, 2124, 353, 2866, 872, 74, 2942, + /* 2110 */ 904, 902, 906, 400, 907, 2805, 2524, 128, 2027, 358, + /* 2120 */ 2804, 125, 2813, 1543, 896, 1017, 2800, 1018, 2799, 2791, + /* 2130 */ 2790, 1019, 404, 2782, 65, 189, 2781, 2797, 2796, 2788, + /* 2140 */ 2787, 2082, 2092, 2776, 2775, 387, 1014, 390, 879, 2794, + /* 2150 */ 2793, 2131, 2134, 427, 391, 1021, 406, 440, 921, 476, + /* 2160 */ 782, 408, 454, 2785, 2765, 2784, 2022, 2773, 2020, 2847, + /* 2170 */ 438, 2772, 2898, 882, 2764, 2770, 134, 2849, 900, 2851, + /* 2180 */ 2852, 895, 524, 2763, 883, 2899, 919, 98, 428, 2769, + /* 2190 */ 2758, 2934, 2575, 2961, 542, 543, 1972, 500, 2957, 1973, + /* 2200 */ 547, 237, 2025, 2026, 2079, 2756, 2081, 2084, 2085, 2086, + /* 2210 */ 2087, 2088, 2089, 2090, 2091, 2093, 2094, 2095, 892, 885, + /* 2220 */ 549, 455, 917, 916, 881, 2116, 2117, 550, 551, 1971, + /* 2230 */ 2123, 2125, 2126, 2127, 2128, 2130, 2, 60, 58, 2755, + /* 2240 */ 2754, 463, 2752, 557, 2751, 506, 559, 2021, 2750, 561, + /* 2250 */ 2749, 563, 2036, 1959, 2031, 2724, 241, 2723, 243, 1917, + /* 2260 */ 99, 2019, 1916, 2129, 2701, 2700, 2699, 2848, 575, 576, + /* 2270 */ 2698, 2697, 2641, 580, 1853, 2638, 2637, 583, 2631, 586, + /* 2280 */ 2628, 587, 897, 246, 2627, 102, 2626, 2625, 2039, 2041, + /* 2290 */ 2630, 2629, 2624, 2623, 2621, 2620, 2124, 248, 2619, 884, + /* 2300 */ 250, 2618, 605, 603, 2616, 2615, 2614, 2613, 917, 916, + /* 2310 */ 2027, 2612, 2866, 2636, 2611, 2610, 2123, 2125, 2126, 2127, + /* 2320 */ 2128, 2130, 2609, 2634, 2617, 2608, 2607, 2606, 2813, 2604, + /* 2330 */ 896, 2603, 2602, 2601, 2600, 2599, 252, 2598, 2597, 2596, + /* 2340 */ 1022, 2595, 2593, 15, 108, 2592, 2666, 2635, 2633, 2591, + /* 2350 */ 2590, 2589, 1859, 2588, 2587, 257, 643, 645, 2586, 2584, + /* 2360 */ 452, 453, 1700, 2411, 2410, 1704, 2409, 260, 2408, 2406, + /* 2370 */ 261, 263, 1696, 264, 2403, 2847, 664, 2402, 2898, 2395, + /* 2380 */ 2132, 2133, 134, 2849, 900, 2851, 2852, 895, 663, 2382, + /* 2390 */ 883, 2899, 919, 667, 2370, 2369, 671, 876, 2352, 2961, + /* 2400 */ 665, 668, 1572, 500, 2957, 669, 673, 675, 679, 2351, + /* 2410 */ 2722, 677, 2848, 212, 266, 2718, 2708, 94, 2696, 2082, + /* 2420 */ 2092, 2833, 672, 268, 277, 2695, 223, 897, 95, 2131, + /* 2430 */ 2134, 275, 687, 280, 2672, 2665, 282, 2499, 2405, 2401, + /* 2440 */ 710, 708, 2399, 709, 2022, 714, 2020, 712, 713, 2397, + /* 2450 */ 716, 882, 718, 2394, 717, 720, 721, 2866, 2377, 2375, + /* 2460 */ 2376, 722, 1625, 2374, 2371, 728, 2348, 2501, 1784, 1783, + /* 2470 */ 2500, 758, 1686, 2813, 1668, 896, 1685, 1684, 982, 1681, + /* 2480 */ 2025, 2026, 2079, 481, 2081, 2084, 2085, 2086, 2087, 2088, + /* 2490 */ 2089, 2090, 2091, 2093, 2094, 2095, 892, 885, 1679, 2392, + /* 2500 */ 917, 916, 881, 2116, 2117, 1677, 984, 1676, 2123, 2125, + /* 2510 */ 2126, 2127, 2128, 2130, 2, 450, 449, 1675, 2848, 1674, + /* 2520 */ 2847, 86, 1673, 2898, 2390, 513, 290, 135, 2849, 900, + /* 2530 */ 2851, 2852, 895, 897, 1670, 883, 2899, 919, 1669, 522, + /* 2540 */ 1667, 2129, 482, 2381, 2961, 2848, 2379, 483, 2960, 2957, + /* 2550 */ 484, 761, 2347, 2346, 2345, 765, 2344, 767, 2343, 769, + /* 2560 */ 897, 2342, 771, 2866, 141, 1953, 1955, 1952, 2721, 312, + /* 2570 */ 1957, 2717, 33, 80, 2124, 1923, 2707, 1925, 2694, 2813, + /* 2580 */ 2693, 896, 792, 22, 3066, 2848, 69, 17, 808, 228, + /* 2590 */ 2866, 2270, 35, 319, 6, 2244, 36, 7, 2242, 70, + /* 2600 */ 897, 811, 793, 489, 817, 813, 2813, 815, 896, 316, + /* 2610 */ 23, 321, 2848, 2251, 203, 24, 1902, 1901, 215, 37, + /* 2620 */ 216, 2834, 38, 96, 1942, 2236, 2847, 897, 1927, 2898, + /* 2630 */ 2866, 25, 798, 135, 2849, 900, 2851, 2852, 895, 800, + /* 2640 */ 229, 883, 2899, 919, 781, 194, 2813, 2208, 896, 2210, + /* 2650 */ 2961, 2206, 230, 898, 878, 2957, 2898, 2866, 78, 26, + /* 2660 */ 135, 2849, 900, 2851, 2852, 895, 2290, 2291, 883, 2899, + /* 2670 */ 919, 2285, 2284, 2813, 494, 896, 2289, 2961, 2288, 495, + /* 2680 */ 336, 457, 2957, 2190, 72, 208, 2692, 2671, 2189, 120, + /* 2690 */ 119, 2670, 343, 2847, 2246, 2664, 2898, 218, 121, 27, + /* 2700 */ 413, 2849, 900, 2851, 2852, 895, 349, 32, 883, 2899, + /* 2710 */ 919, 862, 82, 351, 868, 352, 870, 122, 2142, 11, + /* 2720 */ 2847, 2141, 2012, 2898, 1988, 354, 13, 135, 2849, 900, + /* 2730 */ 2851, 2852, 895, 71, 2037, 883, 2899, 919, 21, 2152, + /* 2740 */ 28, 18, 29, 20, 2961, 50, 2663, 209, 932, 2958, + /* 2750 */ 2099, 2098, 2097, 219, 2072, 935, 515, 514, 2013, 938, + /* 2760 */ 123, 2496, 941, 910, 51, 16, 30, 899, 31, 2848, + /* 2770 */ 362, 2064, 903, 905, 83, 356, 124, 92, 917, 916, + /* 2780 */ 129, 2911, 911, 2910, 897, 918, 2123, 2125, 2126, 2127, + /* 2790 */ 2128, 2130, 2304, 2111, 81, 2303, 1765, 2848, 924, 920, + /* 2800 */ 525, 926, 928, 1762, 1761, 931, 929, 934, 1758, 1752, + /* 2810 */ 937, 1750, 897, 940, 2866, 1756, 130, 386, 1755, 1754, + /* 2820 */ 1753, 131, 1778, 93, 1774, 1664, 1623, 955, 1663, 1662, + /* 2830 */ 2813, 1661, 896, 1658, 1655, 1654, 1653, 1652, 1694, 970, + /* 2840 */ 1650, 1648, 2866, 1647, 1646, 1693, 972, 235, 1644, 1643, + /* 2850 */ 1641, 2400, 1642, 1640, 503, 1639, 1638, 1690, 2813, 1688, + /* 2860 */ 896, 1635, 1634, 1631, 1629, 1630, 1628, 992, 993, 2398, + /* 2870 */ 996, 2396, 1000, 2393, 2373, 997, 994, 2847, 1001, 998, + /* 2880 */ 2898, 2848, 1002, 1004, 437, 2849, 900, 2851, 2852, 895, + /* 2890 */ 1005, 1008, 883, 2899, 919, 2368, 897, 1006, 1010, 2367, + /* 2900 */ 1012, 1561, 2341, 1544, 1549, 2847, 1551, 392, 2898, 2848, + /* 2910 */ 1016, 1020, 199, 2849, 900, 2851, 2852, 895, 2023, 405, + /* 2920 */ 883, 2899, 919, 1024, 897, 1023, 2866, 2307, 2307, 2307, + /* 2930 */ 2848, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 2940 */ 2307, 2307, 2813, 2307, 896, 897, 2307, 2307, 2307, 2307, + /* 2950 */ 2307, 2307, 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, + /* 2960 */ 2307, 2307, 2307, 3020, 2307, 2307, 490, 2307, 2307, 2307, + /* 2970 */ 2813, 2307, 896, 2307, 2307, 2866, 2307, 2307, 2307, 2307, + /* 2980 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2847, + /* 2990 */ 2307, 2813, 2898, 896, 491, 2307, 437, 2849, 900, 2851, + /* 3000 */ 2852, 895, 2307, 2307, 883, 2899, 919, 2307, 2307, 2307, + /* 3010 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2847, 2307, 2307, + /* 3020 */ 2898, 2848, 2307, 2307, 437, 2849, 900, 2851, 2852, 895, + /* 3030 */ 2307, 2307, 883, 2899, 919, 2307, 897, 2307, 2847, 2307, + /* 3040 */ 2307, 2898, 2848, 2307, 2307, 430, 2849, 900, 2851, 2852, + /* 3050 */ 895, 2307, 2307, 883, 2899, 919, 2307, 894, 2307, 2307, + /* 3060 */ 2307, 2307, 2848, 2307, 2307, 2307, 2866, 2307, 2307, 2307, + /* 3070 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 897, 2307, 2307, + /* 3080 */ 2307, 2307, 2813, 2307, 896, 2307, 2307, 2866, 2307, 2307, + /* 3090 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 831, + /* 3100 */ 2307, 2307, 2307, 2813, 2307, 896, 2307, 2866, 2307, 2307, + /* 3110 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3120 */ 2307, 2307, 2307, 2813, 2307, 896, 2307, 2307, 2307, 2847, + /* 3130 */ 2307, 2307, 2898, 2307, 2307, 2307, 202, 2849, 900, 2851, + /* 3140 */ 2852, 895, 2307, 2307, 883, 2899, 919, 504, 2307, 2307, + /* 3150 */ 2847, 2307, 2307, 2898, 2307, 2307, 2307, 436, 2849, 900, + /* 3160 */ 2851, 2852, 895, 2307, 2307, 883, 2899, 919, 2307, 2927, + /* 3170 */ 2847, 2307, 2307, 2898, 2307, 2307, 2307, 437, 2849, 900, + /* 3180 */ 2851, 2852, 895, 2848, 2307, 883, 2899, 919, 2307, 2307, + /* 3190 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 897, 3083, + /* 3200 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2848, 2307, + /* 3210 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3220 */ 2307, 2307, 2307, 897, 2307, 2307, 2307, 2307, 2866, 2307, + /* 3230 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3240 */ 2307, 2307, 2307, 2307, 2813, 2307, 896, 2307, 2307, 2307, + /* 3250 */ 2307, 2307, 2848, 2866, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3260 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 897, 499, 2813, + /* 3270 */ 2307, 896, 2307, 2307, 2307, 2848, 2307, 2307, 2307, 2307, + /* 3280 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3290 */ 897, 2847, 2307, 505, 2898, 2307, 2307, 2866, 422, 2849, + /* 3300 */ 900, 2851, 2852, 895, 2307, 2307, 883, 2899, 919, 2307, + /* 3310 */ 2307, 2307, 2307, 2813, 2307, 896, 2847, 2307, 2307, 2898, + /* 3320 */ 2866, 2307, 2307, 437, 2849, 900, 2851, 2852, 895, 2307, + /* 3330 */ 2307, 883, 2899, 919, 2307, 2307, 2813, 507, 896, 2307, + /* 3340 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3350 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3360 */ 2847, 2307, 2307, 2898, 2848, 2307, 2307, 437, 2849, 900, + /* 3370 */ 2851, 2852, 895, 2307, 2307, 883, 2899, 919, 2307, 897, + /* 3380 */ 2307, 2307, 2307, 2847, 2307, 2307, 2898, 2848, 2307, 2307, + /* 3390 */ 418, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, 2899, + /* 3400 */ 919, 2307, 897, 2307, 2307, 2307, 2307, 2307, 2307, 2866, + /* 3410 */ 2307, 2307, 2307, 2307, 2307, 2848, 2307, 2307, 2307, 2307, + /* 3420 */ 2307, 2307, 2307, 2307, 2307, 2813, 2307, 896, 2307, 2307, + /* 3430 */ 897, 2307, 2866, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3440 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2813, 2307, + /* 3450 */ 896, 2307, 2307, 2307, 2307, 2307, 2848, 2307, 2307, 2307, + /* 3460 */ 2866, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3470 */ 2307, 897, 777, 2307, 2307, 2898, 2813, 2307, 896, 432, + /* 3480 */ 2849, 900, 2851, 2852, 895, 2307, 2307, 883, 2899, 919, + /* 3490 */ 2307, 2307, 2307, 2307, 2307, 2847, 2307, 2307, 2898, 2848, + /* 3500 */ 2307, 2866, 414, 2849, 900, 2851, 2852, 895, 2307, 2307, + /* 3510 */ 883, 2899, 919, 2307, 897, 2307, 2307, 2813, 2307, 896, + /* 3520 */ 2307, 2307, 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, + /* 3530 */ 410, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, 2899, + /* 3540 */ 919, 2848, 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, + /* 3550 */ 2307, 2307, 2307, 2307, 2307, 2307, 897, 2307, 2307, 2307, + /* 3560 */ 2813, 2307, 896, 2307, 2847, 2307, 2307, 2898, 2307, 2307, + /* 3570 */ 2307, 411, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, + /* 3580 */ 2899, 919, 2307, 2307, 2307, 2307, 2866, 2307, 2307, 2307, + /* 3590 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3600 */ 2307, 2307, 2813, 2307, 896, 2307, 2307, 2847, 2307, 2307, + /* 3610 */ 2898, 2307, 2307, 2307, 415, 2849, 900, 2851, 2852, 895, + /* 3620 */ 2307, 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, + /* 3630 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2848, 2307, + /* 3640 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2847, + /* 3650 */ 2307, 2307, 2898, 897, 2307, 2307, 429, 2849, 900, 2851, + /* 3660 */ 2852, 895, 2848, 2307, 883, 2899, 919, 2307, 2307, 2307, + /* 3670 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 897, 2307, 2307, + /* 3680 */ 2307, 2307, 2307, 2866, 2307, 2307, 2307, 2848, 2307, 2307, + /* 3690 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2813, + /* 3700 */ 2307, 896, 897, 2307, 2307, 2307, 2307, 2866, 2307, 2307, + /* 3710 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3720 */ 2307, 2307, 2307, 2813, 2307, 896, 2307, 2848, 2307, 2307, + /* 3730 */ 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3740 */ 2307, 2307, 897, 2307, 2307, 2307, 2847, 2307, 2813, 2898, + /* 3750 */ 896, 2307, 2307, 416, 2849, 900, 2851, 2852, 895, 2307, + /* 3760 */ 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, 2848, + /* 3770 */ 2847, 2307, 2866, 2898, 2307, 2307, 2307, 417, 2849, 900, + /* 3780 */ 2851, 2852, 895, 2307, 897, 883, 2899, 919, 2813, 2307, + /* 3790 */ 896, 2307, 2307, 2307, 2848, 2847, 2307, 2307, 2898, 2307, + /* 3800 */ 2307, 2307, 433, 2849, 900, 2851, 2852, 895, 2307, 897, + /* 3810 */ 883, 2899, 919, 2307, 2866, 2307, 2307, 2307, 2307, 2307, + /* 3820 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3830 */ 2813, 2307, 896, 2307, 2307, 2847, 2307, 2307, 2898, 2866, + /* 3840 */ 2307, 2307, 419, 2849, 900, 2851, 2852, 895, 2307, 2307, + /* 3850 */ 883, 2899, 919, 2307, 2307, 2813, 2307, 896, 2307, 2307, + /* 3860 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3870 */ 2307, 2307, 2307, 2307, 2307, 2848, 2307, 2847, 2307, 2307, + /* 3880 */ 2898, 2307, 2307, 2307, 434, 2849, 900, 2851, 2852, 895, + /* 3890 */ 897, 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, + /* 3900 */ 2848, 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, 420, + /* 3910 */ 2849, 900, 2851, 2852, 895, 897, 2307, 883, 2899, 919, + /* 3920 */ 2866, 2307, 2307, 2307, 2848, 2307, 2307, 2307, 2307, 2307, + /* 3930 */ 2307, 2307, 2307, 2307, 2307, 2307, 2813, 2307, 896, 897, + /* 3940 */ 2307, 2307, 2307, 2307, 2307, 2866, 2307, 2307, 2307, 2307, + /* 3950 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3960 */ 2307, 2813, 2307, 896, 2307, 2848, 2307, 2307, 2307, 2866, + /* 3970 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 3980 */ 897, 2307, 2307, 2847, 2307, 2813, 2898, 896, 2307, 2307, + /* 3990 */ 435, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, 2899, + /* 4000 */ 919, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2847, 2307, + /* 4010 */ 2866, 2898, 2307, 2307, 2307, 421, 2849, 900, 2851, 2852, + /* 4020 */ 895, 2307, 2307, 883, 2899, 919, 2813, 2307, 896, 2307, + /* 4030 */ 2307, 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, 412, + /* 4040 */ 2849, 900, 2851, 2852, 895, 2307, 2848, 883, 2899, 919, + /* 4050 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4060 */ 2307, 897, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4070 */ 2307, 2848, 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, + /* 4080 */ 423, 2849, 900, 2851, 2852, 895, 897, 2307, 883, 2899, + /* 4090 */ 919, 2866, 2307, 2307, 2307, 2848, 2307, 2307, 2307, 2307, + /* 4100 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2813, 2307, 896, + /* 4110 */ 897, 2307, 2307, 2307, 2307, 2307, 2866, 2307, 2307, 2307, + /* 4120 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4130 */ 2307, 2307, 2813, 2307, 896, 2307, 2848, 2307, 2307, 2307, + /* 4140 */ 2866, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4150 */ 2307, 897, 2307, 2307, 2847, 2307, 2813, 2898, 896, 2307, + /* 4160 */ 2307, 424, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, + /* 4170 */ 2899, 919, 2307, 2307, 2307, 2307, 2307, 2307, 2848, 2847, + /* 4180 */ 2307, 2866, 2898, 2307, 2307, 2307, 425, 2849, 900, 2851, + /* 4190 */ 2852, 895, 2307, 897, 883, 2899, 919, 2813, 2307, 896, + /* 4200 */ 2307, 2848, 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, + /* 4210 */ 426, 2849, 900, 2851, 2852, 895, 897, 2307, 883, 2899, + /* 4220 */ 919, 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4230 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2813, + /* 4240 */ 2307, 896, 2307, 2307, 2847, 2307, 2866, 2898, 2307, 2307, + /* 4250 */ 2307, 442, 2849, 900, 2851, 2852, 895, 2307, 2307, 883, + /* 4260 */ 2899, 919, 2813, 2307, 896, 2307, 2307, 2307, 2307, 2848, + /* 4270 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4280 */ 2307, 2307, 2307, 2307, 897, 2307, 2847, 2307, 2307, 2898, + /* 4290 */ 2307, 2307, 2307, 443, 2849, 900, 2851, 2852, 895, 2307, + /* 4300 */ 2307, 883, 2899, 919, 2307, 2307, 2307, 2848, 2307, 2847, + /* 4310 */ 2307, 2307, 2898, 2307, 2866, 2307, 2860, 2849, 900, 2851, + /* 4320 */ 2852, 895, 897, 2307, 883, 2899, 919, 2307, 2307, 2307, + /* 4330 */ 2813, 2307, 896, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4340 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4350 */ 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4360 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2813, 2307, + /* 4370 */ 896, 2307, 2307, 2307, 2307, 2307, 2307, 2847, 2307, 2307, + /* 4380 */ 2898, 2307, 2307, 2307, 2859, 2849, 900, 2851, 2852, 895, + /* 4390 */ 2307, 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, + /* 4400 */ 2307, 2307, 2848, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4410 */ 2307, 2307, 2307, 2307, 2307, 2847, 2307, 897, 2898, 2307, + /* 4420 */ 2307, 2307, 2858, 2849, 900, 2851, 2852, 895, 2307, 2848, + /* 4430 */ 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4440 */ 2307, 2307, 2307, 2307, 897, 2307, 2307, 2866, 2307, 2307, + /* 4450 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4460 */ 2307, 2307, 2307, 2813, 2307, 896, 2307, 2848, 2307, 2307, + /* 4470 */ 2307, 2307, 2307, 2307, 2866, 2307, 2307, 2307, 2307, 2307, + /* 4480 */ 2307, 2307, 897, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4490 */ 2813, 2307, 896, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4500 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4510 */ 2847, 2307, 2866, 2898, 2307, 2307, 2307, 459, 2849, 900, + /* 4520 */ 2851, 2852, 895, 2307, 2307, 883, 2899, 919, 2813, 2307, + /* 4530 */ 896, 2307, 2307, 2307, 2307, 2307, 2307, 2847, 2307, 2307, + /* 4540 */ 2898, 2307, 2307, 2307, 460, 2849, 900, 2851, 2852, 895, + /* 4550 */ 2848, 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, 2307, + /* 4560 */ 2307, 2307, 2307, 2307, 2307, 897, 2307, 2307, 2307, 2307, + /* 4570 */ 2307, 2307, 2307, 2848, 2307, 2847, 2307, 2307, 2898, 2307, + /* 4580 */ 2307, 2307, 456, 2849, 900, 2851, 2852, 895, 897, 2307, + /* 4590 */ 883, 2899, 919, 2848, 2307, 2866, 2307, 2307, 2307, 2307, + /* 4600 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 897, 2307, + /* 4610 */ 2307, 2813, 2307, 896, 2307, 2307, 2307, 2307, 2866, 2307, + /* 4620 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4630 */ 2307, 2307, 2307, 2307, 2813, 2307, 896, 2307, 2866, 2307, + /* 4640 */ 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, 2307, + /* 4650 */ 2307, 2307, 2307, 2307, 2813, 2307, 896, 2307, 2847, 2307, + /* 4660 */ 2307, 2898, 2307, 2307, 2307, 461, 2849, 900, 2851, 2852, + /* 4670 */ 895, 2307, 2307, 883, 2899, 919, 2307, 2307, 2307, 2307, + /* 4680 */ 2307, 898, 2307, 2307, 2898, 2307, 2307, 2307, 432, 2849, + /* 4690 */ 900, 2851, 2852, 895, 2307, 2307, 883, 2899, 919, 2307, + /* 4700 */ 2307, 2847, 2307, 2307, 2898, 2307, 2307, 2307, 431, 2849, + /* 4710 */ 900, 2851, 2852, 895, 2307, 2307, 883, 2899, 919, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 537, 402, 537, 456, 405, 406, 416, 441, 545, 539, - /* 10 */ 545, 541, 12, 13, 438, 12, 13, 14, 15, 16, - /* 20 */ 20, 0, 22, 476, 477, 435, 563, 564, 437, 564, - /* 30 */ 424, 568, 569, 568, 569, 445, 36, 0, 38, 0, - /* 40 */ 20, 465, 21, 393, 453, 24, 25, 26, 27, 28, - /* 50 */ 29, 30, 31, 32, 20, 407, 408, 392, 408, 394, - /* 60 */ 454, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 70 */ 504, 71, 21, 20, 74, 24, 25, 26, 27, 28, - /* 80 */ 29, 30, 31, 32, 518, 85, 8, 9, 438, 20, - /* 90 */ 12, 13, 14, 15, 16, 8, 9, 438, 20, 12, - /* 100 */ 13, 14, 15, 16, 454, 402, 456, 448, 405, 406, - /* 110 */ 504, 505, 506, 480, 407, 115, 94, 33, 118, 80, - /* 120 */ 81, 82, 83, 84, 518, 86, 87, 88, 89, 90, + /* 0 */ 537, 402, 537, 402, 405, 406, 405, 406, 545, 539, + /* 10 */ 545, 541, 12, 13, 439, 12, 13, 14, 15, 16, + /* 20 */ 20, 0, 22, 486, 432, 450, 563, 564, 20, 564, + /* 30 */ 438, 568, 569, 568, 569, 414, 36, 452, 38, 0, + /* 40 */ 455, 456, 21, 393, 34, 24, 25, 26, 27, 28, + /* 50 */ 29, 30, 31, 32, 20, 407, 408, 465, 408, 1, + /* 60 */ 2, 8, 9, 442, 432, 12, 13, 14, 15, 16, + /* 70 */ 438, 71, 21, 20, 74, 24, 25, 26, 27, 28, + /* 80 */ 29, 30, 31, 32, 424, 85, 8, 9, 438, 21, + /* 90 */ 12, 13, 14, 15, 16, 8, 9, 465, 59, 12, + /* 100 */ 13, 14, 15, 16, 454, 37, 456, 39, 40, 41, + /* 110 */ 42, 33, 407, 20, 454, 115, 94, 20, 118, 80, + /* 120 */ 81, 82, 83, 84, 118, 86, 87, 88, 89, 90, /* 130 */ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, /* 140 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - /* 150 */ 111, 501, 118, 20, 504, 155, 156, 439, 508, 509, - /* 160 */ 510, 511, 512, 513, 526, 527, 516, 517, 518, 417, - /* 170 */ 537, 21, 77, 523, 467, 525, 469, 425, 545, 529, - /* 180 */ 530, 533, 534, 535, 162, 537, 538, 37, 4, 39, - /* 190 */ 40, 41, 42, 545, 194, 195, 563, 564, 522, 549, - /* 200 */ 524, 568, 569, 119, 204, 205, 119, 557, 20, 187, - /* 210 */ 188, 563, 564, 20, 194, 195, 568, 569, 500, 219, - /* 220 */ 115, 221, 199, 201, 155, 156, 226, 148, 149, 150, - /* 230 */ 151, 152, 153, 154, 439, 130, 131, 132, 133, 134, - /* 240 */ 135, 136, 137, 138, 139, 450, 141, 142, 143, 144, - /* 250 */ 145, 146, 147, 120, 407, 255, 256, 257, 393, 259, + /* 150 */ 111, 501, 118, 20, 504, 155, 156, 22, 508, 509, + /* 160 */ 510, 511, 512, 513, 504, 505, 516, 517, 518, 407, + /* 170 */ 408, 36, 467, 523, 469, 525, 20, 119, 518, 529, + /* 180 */ 530, 533, 534, 535, 162, 537, 538, 149, 150, 427, + /* 190 */ 20, 438, 154, 545, 194, 195, 407, 119, 436, 549, + /* 200 */ 447, 448, 194, 195, 204, 205, 119, 557, 438, 187, + /* 210 */ 188, 563, 564, 120, 115, 118, 568, 569, 448, 219, + /* 220 */ 85, 221, 199, 201, 158, 392, 226, 394, 407, 130, + /* 230 */ 131, 132, 133, 134, 135, 136, 137, 138, 139, 118, + /* 240 */ 141, 142, 143, 144, 145, 146, 147, 458, 459, 196, + /* 250 */ 461, 498, 499, 464, 20, 255, 256, 257, 393, 259, /* 260 */ 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - /* 270 */ 270, 271, 272, 408, 196, 275, 276, 277, 278, 279, + /* 270 */ 270, 271, 272, 408, 118, 275, 276, 277, 278, 279, /* 280 */ 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - /* 290 */ 12, 13, 14, 438, 393, 18, 423, 20, 20, 426, - /* 300 */ 22, 446, 118, 438, 27, 458, 459, 30, 461, 408, - /* 310 */ 257, 464, 457, 57, 36, 38, 38, 407, 408, 454, - /* 320 */ 118, 456, 66, 8, 9, 69, 70, 12, 13, 14, - /* 330 */ 15, 16, 480, 56, 57, 257, 59, 485, 20, 438, + /* 290 */ 12, 13, 14, 57, 393, 18, 77, 20, 20, 0, + /* 300 */ 22, 189, 66, 438, 27, 69, 70, 30, 438, 408, + /* 310 */ 257, 490, 491, 149, 36, 38, 38, 447, 448, 454, + /* 320 */ 314, 456, 20, 24, 25, 26, 27, 28, 29, 30, + /* 330 */ 31, 32, 480, 56, 57, 223, 59, 485, 20, 438, /* 340 */ 158, 64, 65, 320, 321, 322, 323, 324, 314, 71, /* 350 */ 407, 408, 74, 76, 403, 454, 78, 456, 407, 537, - /* 360 */ 409, 274, 432, 85, 158, 14, 501, 545, 438, 504, - /* 370 */ 424, 20, 462, 508, 509, 510, 511, 512, 513, 514, - /* 380 */ 438, 516, 517, 518, 519, 520, 564, 456, 446, 537, - /* 390 */ 568, 569, 20, 115, 117, 465, 118, 545, 20, 457, - /* 400 */ 454, 470, 501, 407, 408, 504, 129, 476, 477, 508, + /* 360 */ 409, 274, 14, 85, 118, 438, 501, 545, 20, 504, + /* 370 */ 304, 305, 306, 508, 509, 510, 511, 512, 513, 514, + /* 380 */ 20, 516, 517, 518, 519, 520, 564, 456, 0, 537, + /* 390 */ 568, 569, 465, 115, 117, 20, 118, 545, 234, 235, + /* 400 */ 236, 470, 501, 407, 408, 504, 129, 476, 477, 508, /* 410 */ 509, 510, 511, 512, 513, 563, 564, 516, 517, 518, - /* 420 */ 568, 569, 521, 427, 523, 524, 525, 20, 20, 52, - /* 430 */ 529, 530, 436, 155, 156, 36, 20, 160, 161, 393, + /* 420 */ 568, 569, 521, 427, 523, 524, 525, 12, 13, 428, + /* 430 */ 529, 530, 436, 155, 156, 314, 20, 160, 161, 438, /* 440 */ 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - /* 450 */ 504, 505, 175, 176, 177, 178, 179, 180, 181, 182, - /* 460 */ 13, 184, 185, 186, 518, 439, 440, 190, 191, 192, - /* 470 */ 12, 13, 194, 195, 197, 532, 533, 534, 535, 44, - /* 480 */ 537, 538, 204, 205, 85, 303, 304, 305, 306, 307, - /* 490 */ 308, 309, 310, 311, 36, 2, 118, 219, 314, 221, - /* 500 */ 454, 8, 9, 438, 226, 12, 13, 14, 15, 16, - /* 510 */ 304, 305, 306, 8, 9, 20, 314, 12, 13, 14, - /* 520 */ 15, 16, 457, 8, 9, 118, 211, 12, 13, 14, - /* 530 */ 15, 16, 85, 255, 256, 257, 393, 259, 260, 261, + /* 450 */ 449, 36, 175, 176, 177, 178, 179, 180, 181, 182, + /* 460 */ 20, 184, 185, 186, 218, 77, 220, 190, 191, 192, + /* 470 */ 314, 438, 194, 195, 197, 532, 533, 534, 535, 44, + /* 480 */ 537, 538, 204, 205, 437, 303, 304, 305, 306, 307, + /* 490 */ 308, 309, 310, 311, 3, 2, 36, 219, 252, 221, + /* 500 */ 453, 8, 9, 36, 226, 12, 13, 14, 15, 16, + /* 510 */ 33, 20, 194, 8, 9, 155, 156, 12, 13, 14, + /* 520 */ 15, 16, 8, 9, 526, 527, 12, 13, 14, 15, + /* 530 */ 16, 498, 499, 255, 256, 257, 393, 259, 260, 261, /* 540 */ 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - /* 550 */ 272, 408, 407, 275, 276, 277, 278, 279, 38, 455, - /* 560 */ 456, 283, 284, 285, 286, 287, 288, 289, 12, 13, - /* 570 */ 0, 155, 156, 196, 54, 257, 20, 57, 22, 41, - /* 580 */ 42, 438, 393, 78, 207, 115, 66, 67, 68, 69, - /* 590 */ 77, 71, 36, 158, 38, 0, 33, 454, 76, 456, + /* 550 */ 272, 408, 85, 275, 276, 277, 278, 279, 38, 257, + /* 560 */ 314, 283, 284, 285, 286, 287, 288, 289, 12, 13, + /* 570 */ 129, 155, 156, 20, 54, 257, 20, 57, 22, 41, + /* 580 */ 42, 438, 417, 78, 433, 115, 66, 67, 68, 69, + /* 590 */ 425, 71, 36, 158, 38, 0, 119, 454, 424, 456, /* 600 */ 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - /* 610 */ 47, 141, 142, 143, 144, 145, 146, 147, 8, 9, - /* 620 */ 204, 205, 12, 13, 14, 15, 16, 71, 58, 20, - /* 630 */ 74, 22, 480, 128, 78, 490, 491, 117, 507, 149, - /* 640 */ 0, 85, 122, 454, 501, 36, 290, 504, 292, 407, - /* 650 */ 408, 508, 509, 510, 511, 512, 513, 342, 118, 516, - /* 660 */ 517, 518, 124, 125, 4, 127, 523, 536, 525, 427, - /* 670 */ 61, 115, 529, 530, 118, 80, 81, 82, 436, 221, - /* 680 */ 0, 150, 87, 88, 89, 154, 148, 456, 93, 537, - /* 690 */ 152, 196, 314, 98, 99, 100, 101, 545, 193, 104, - /* 700 */ 557, 470, 20, 108, 109, 110, 111, 476, 477, 189, - /* 710 */ 0, 155, 156, 14, 54, 563, 564, 77, 198, 20, - /* 720 */ 568, 569, 202, 203, 234, 235, 236, 290, 208, 209, - /* 730 */ 18, 441, 441, 507, 444, 23, 214, 129, 303, 304, - /* 740 */ 305, 306, 307, 308, 309, 310, 311, 227, 407, 408, - /* 750 */ 194, 195, 3, 393, 42, 43, 118, 432, 46, 228, - /* 760 */ 204, 205, 536, 438, 233, 243, 244, 55, 237, 20, - /* 770 */ 239, 407, 60, 438, 438, 219, 452, 221, 273, 455, - /* 780 */ 456, 446, 226, 33, 72, 73, 74, 75, 76, 255, - /* 790 */ 465, 438, 457, 457, 504, 504, 390, 47, 293, 294, - /* 800 */ 295, 296, 297, 298, 299, 300, 301, 302, 518, 518, - /* 810 */ 85, 255, 256, 257, 454, 259, 260, 261, 262, 263, + /* 610 */ 119, 141, 142, 143, 144, 145, 146, 147, 8, 9, + /* 620 */ 204, 205, 12, 13, 14, 15, 16, 71, 454, 20, + /* 630 */ 74, 22, 480, 128, 78, 507, 221, 117, 407, 408, + /* 640 */ 423, 85, 122, 426, 501, 36, 495, 504, 20, 4, + /* 650 */ 438, 508, 509, 510, 511, 512, 513, 47, 446, 516, + /* 660 */ 517, 518, 124, 125, 536, 127, 523, 0, 525, 457, + /* 670 */ 61, 115, 529, 530, 118, 80, 81, 82, 504, 505, + /* 680 */ 506, 221, 87, 88, 89, 441, 148, 196, 93, 537, + /* 690 */ 152, 438, 518, 98, 99, 100, 101, 545, 193, 104, + /* 700 */ 557, 14, 14, 108, 109, 110, 111, 20, 20, 189, + /* 710 */ 457, 155, 156, 253, 254, 563, 564, 77, 198, 439, + /* 720 */ 568, 569, 202, 203, 57, 211, 439, 440, 208, 209, + /* 730 */ 18, 441, 456, 290, 444, 23, 407, 408, 303, 304, + /* 740 */ 305, 306, 307, 308, 309, 310, 311, 227, 504, 196, + /* 750 */ 194, 195, 476, 477, 42, 43, 427, 22, 46, 76, + /* 760 */ 204, 205, 518, 118, 533, 534, 535, 55, 537, 538, + /* 770 */ 0, 36, 60, 438, 441, 219, 451, 221, 273, 454, + /* 780 */ 500, 446, 226, 85, 72, 73, 74, 75, 76, 255, + /* 790 */ 407, 408, 457, 407, 504, 480, 390, 0, 293, 294, + /* 800 */ 295, 296, 297, 298, 299, 300, 301, 302, 518, 129, + /* 810 */ 427, 255, 256, 257, 44, 259, 260, 261, 262, 263, /* 820 */ 264, 265, 266, 267, 268, 269, 270, 271, 272, 0, - /* 830 */ 118, 275, 276, 277, 278, 279, 472, 473, 158, 283, + /* 830 */ 118, 275, 276, 277, 278, 279, 290, 504, 292, 283, /* 840 */ 284, 285, 286, 287, 288, 289, 290, 12, 13, 71, - /* 850 */ 438, 498, 499, 173, 314, 20, 218, 22, 220, 447, - /* 860 */ 448, 327, 328, 329, 330, 331, 332, 333, 119, 157, - /* 870 */ 0, 36, 537, 38, 533, 534, 535, 393, 537, 538, - /* 880 */ 545, 403, 408, 273, 174, 407, 480, 409, 407, 179, - /* 890 */ 252, 485, 408, 194, 410, 117, 4, 187, 563, 564, - /* 900 */ 122, 407, 408, 568, 569, 189, 71, 407, 408, 74, - /* 910 */ 498, 499, 438, 78, 307, 308, 309, 310, 311, 129, - /* 920 */ 85, 427, 438, 211, 212, 213, 0, 427, 216, 8, - /* 930 */ 9, 407, 408, 12, 13, 14, 15, 16, 454, 223, - /* 940 */ 456, 229, 230, 537, 34, 196, 407, 408, 407, 408, - /* 950 */ 115, 545, 314, 118, 242, 428, 257, 245, 62, 63, - /* 960 */ 248, 249, 250, 251, 252, 438, 427, 189, 47, 563, - /* 970 */ 564, 490, 491, 22, 568, 569, 449, 148, 149, 150, - /* 980 */ 151, 152, 153, 154, 510, 501, 462, 36, 504, 438, - /* 990 */ 155, 156, 508, 509, 510, 511, 512, 513, 447, 448, - /* 1000 */ 516, 517, 518, 462, 36, 407, 408, 523, 522, 525, - /* 1010 */ 524, 407, 408, 529, 530, 36, 1, 439, 148, 149, - /* 1020 */ 150, 151, 152, 153, 154, 427, 314, 438, 393, 194, - /* 1030 */ 195, 427, 407, 408, 19, 446, 85, 407, 408, 204, - /* 1040 */ 205, 20, 13, 8, 9, 414, 457, 12, 13, 14, - /* 1050 */ 15, 16, 427, 38, 219, 33, 221, 427, 20, 407, - /* 1060 */ 408, 226, 431, 486, 2, 36, 115, 20, 53, 54, - /* 1070 */ 8, 9, 57, 442, 12, 13, 14, 15, 16, 427, - /* 1080 */ 439, 66, 67, 68, 69, 521, 71, 14, 524, 454, - /* 1090 */ 255, 256, 257, 20, 259, 260, 261, 262, 263, 264, + /* 850 */ 115, 518, 537, 13, 456, 20, 342, 22, 472, 473, + /* 860 */ 545, 327, 328, 329, 330, 331, 332, 333, 470, 157, + /* 870 */ 0, 36, 537, 38, 476, 477, 36, 393, 563, 564, + /* 880 */ 545, 194, 194, 568, 569, 257, 480, 521, 407, 408, + /* 890 */ 524, 485, 408, 438, 410, 117, 78, 214, 563, 564, + /* 900 */ 122, 403, 408, 568, 569, 407, 71, 409, 427, 74, + /* 910 */ 407, 408, 457, 78, 307, 308, 309, 310, 311, 522, + /* 920 */ 85, 524, 438, 211, 212, 213, 243, 244, 216, 8, + /* 930 */ 9, 0, 438, 12, 13, 14, 15, 16, 454, 0, + /* 940 */ 456, 229, 230, 537, 257, 257, 407, 408, 407, 408, + /* 950 */ 115, 545, 4, 118, 242, 407, 408, 245, 407, 314, + /* 960 */ 248, 249, 250, 251, 252, 462, 427, 189, 47, 563, + /* 970 */ 564, 174, 33, 22, 568, 569, 179, 148, 149, 150, + /* 980 */ 151, 152, 153, 154, 187, 501, 507, 36, 504, 58, + /* 990 */ 155, 156, 508, 509, 510, 511, 512, 513, 416, 507, + /* 1000 */ 516, 517, 518, 462, 510, 407, 408, 523, 13, 525, + /* 1010 */ 462, 407, 408, 529, 530, 536, 1, 435, 148, 149, + /* 1020 */ 150, 151, 152, 153, 154, 427, 314, 445, 536, 194, + /* 1030 */ 195, 427, 407, 408, 19, 439, 85, 407, 408, 204, + /* 1040 */ 205, 490, 491, 8, 9, 407, 408, 12, 13, 14, + /* 1050 */ 15, 16, 427, 38, 219, 439, 221, 427, 36, 407, + /* 1060 */ 408, 226, 412, 413, 2, 427, 115, 393, 53, 54, + /* 1070 */ 8, 9, 57, 255, 12, 13, 14, 15, 16, 427, + /* 1080 */ 85, 66, 67, 68, 69, 193, 71, 20, 416, 23, + /* 1090 */ 255, 256, 257, 439, 259, 260, 261, 262, 263, 264, /* 1100 */ 265, 266, 267, 268, 269, 270, 271, 272, 407, 408, - /* 1110 */ 275, 276, 277, 278, 279, 14, 15, 16, 283, 284, - /* 1120 */ 285, 286, 287, 288, 289, 12, 13, 14, 439, 393, + /* 1110 */ 275, 276, 277, 278, 279, 49, 50, 445, 283, 284, + /* 1120 */ 285, 286, 287, 288, 289, 12, 13, 14, 454, 393, /* 1130 */ 407, 408, 117, 20, 4, 22, 480, 122, 407, 408, - /* 1140 */ 425, 20, 4, 22, 408, 129, 410, 407, 408, 36, - /* 1150 */ 427, 38, 439, 23, 119, 8, 9, 19, 427, 12, - /* 1160 */ 13, 14, 15, 16, 44, 428, 393, 427, 153, 393, - /* 1170 */ 219, 22, 221, 247, 438, 438, 38, 438, 48, 49, - /* 1180 */ 50, 408, 61, 410, 71, 36, 449, 74, 449, 221, - /* 1190 */ 454, 71, 456, 537, 47, 57, 407, 408, 85, 183, - /* 1200 */ 221, 545, 64, 65, 412, 413, 255, 256, 316, 71, - /* 1210 */ 393, 438, 22, 198, 507, 200, 427, 196, 203, 563, - /* 1220 */ 564, 253, 254, 208, 568, 569, 36, 454, 115, 456, - /* 1230 */ 454, 118, 253, 254, 533, 534, 535, 501, 537, 538, - /* 1240 */ 504, 194, 227, 536, 508, 509, 510, 511, 512, 513, - /* 1250 */ 407, 408, 516, 517, 518, 117, 407, 408, 3, 523, - /* 1260 */ 122, 525, 480, 20, 115, 529, 530, 194, 155, 156, - /* 1270 */ 427, 454, 393, 439, 501, 85, 427, 504, 257, 412, + /* 1140 */ 455, 456, 4, 150, 408, 438, 410, 154, 429, 36, + /* 1150 */ 427, 38, 433, 23, 119, 8, 9, 19, 427, 12, + /* 1160 */ 13, 14, 15, 16, 457, 273, 393, 438, 153, 13, + /* 1170 */ 219, 52, 221, 44, 438, 446, 38, 414, 48, 49, + /* 1180 */ 50, 408, 71, 410, 71, 293, 457, 74, 62, 63, + /* 1190 */ 454, 438, 456, 537, 431, 57, 407, 408, 85, 446, + /* 1200 */ 71, 545, 64, 65, 3, 442, 255, 256, 33, 71, + /* 1210 */ 457, 438, 522, 198, 524, 200, 427, 393, 203, 563, + /* 1220 */ 564, 228, 47, 208, 568, 569, 233, 454, 115, 456, + /* 1230 */ 237, 118, 239, 122, 533, 534, 535, 501, 537, 538, + /* 1240 */ 504, 85, 227, 221, 508, 509, 510, 511, 512, 513, + /* 1250 */ 407, 408, 516, 517, 518, 117, 20, 425, 22, 523, + /* 1260 */ 122, 525, 480, 196, 316, 529, 530, 393, 155, 156, + /* 1270 */ 427, 14, 15, 16, 501, 253, 254, 504, 454, 412, /* 1280 */ 413, 508, 509, 510, 511, 512, 513, 421, 422, 516, - /* 1290 */ 517, 518, 80, 81, 82, 257, 523, 416, 525, 87, - /* 1300 */ 88, 89, 529, 530, 257, 93, 393, 194, 195, 23, - /* 1310 */ 98, 99, 100, 101, 421, 422, 104, 204, 205, 537, - /* 1320 */ 108, 109, 110, 111, 407, 408, 445, 545, 22, 439, - /* 1330 */ 257, 433, 219, 454, 221, 49, 50, 407, 408, 226, - /* 1340 */ 407, 408, 36, 193, 427, 563, 564, 394, 8, 9, - /* 1350 */ 568, 569, 12, 13, 14, 15, 16, 427, 8, 9, - /* 1360 */ 427, 339, 12, 13, 14, 15, 16, 454, 255, 256, - /* 1370 */ 257, 0, 259, 260, 261, 262, 263, 264, 265, 266, - /* 1380 */ 267, 268, 269, 270, 271, 272, 393, 47, 275, 276, - /* 1390 */ 277, 278, 279, 495, 407, 408, 283, 284, 285, 286, + /* 1290 */ 517, 518, 80, 81, 82, 33, 523, 61, 525, 87, + /* 1300 */ 88, 89, 529, 530, 428, 93, 438, 194, 195, 47, + /* 1310 */ 98, 99, 100, 101, 438, 196, 104, 204, 205, 537, + /* 1320 */ 108, 109, 110, 111, 257, 449, 207, 545, 454, 421, + /* 1330 */ 422, 20, 219, 0, 221, 20, 8, 9, 0, 226, + /* 1340 */ 12, 13, 14, 15, 16, 563, 564, 394, 8, 9, + /* 1350 */ 568, 569, 12, 13, 14, 15, 16, 393, 8, 9, + /* 1360 */ 393, 439, 12, 13, 14, 15, 16, 499, 255, 256, + /* 1370 */ 257, 393, 259, 260, 261, 262, 263, 264, 265, 266, + /* 1380 */ 267, 268, 269, 270, 271, 272, 33, 47, 275, 276, + /* 1390 */ 277, 278, 279, 396, 397, 20, 283, 284, 285, 286, /* 1400 */ 287, 288, 289, 12, 13, 407, 408, 393, 407, 408, - /* 1410 */ 393, 20, 393, 22, 427, 480, 451, 407, 408, 454, - /* 1420 */ 414, 115, 408, 273, 410, 427, 438, 36, 427, 38, - /* 1430 */ 20, 149, 150, 0, 393, 393, 154, 427, 429, 196, - /* 1440 */ 438, 13, 433, 293, 393, 457, 393, 454, 442, 408, - /* 1450 */ 55, 410, 438, 393, 1, 2, 393, 148, 393, 119, - /* 1460 */ 393, 152, 71, 451, 0, 74, 454, 393, 454, 119, - /* 1470 */ 456, 454, 537, 454, 396, 397, 85, 8, 9, 438, - /* 1480 */ 545, 12, 13, 14, 15, 16, 8, 9, 155, 156, - /* 1490 */ 12, 13, 14, 15, 16, 454, 454, 456, 563, 564, - /* 1500 */ 257, 499, 33, 568, 569, 454, 115, 454, 44, 118, - /* 1510 */ 119, 33, 0, 85, 454, 501, 33, 454, 504, 454, - /* 1520 */ 393, 454, 508, 509, 510, 511, 512, 513, 454, 158, - /* 1530 */ 516, 517, 518, 451, 14, 408, 454, 523, 36, 525, - /* 1540 */ 20, 0, 501, 529, 530, 504, 155, 156, 33, 508, - /* 1550 */ 509, 510, 511, 512, 513, 78, 13, 516, 517, 518, - /* 1560 */ 123, 33, 71, 126, 523, 438, 525, 0, 0, 57, - /* 1570 */ 529, 530, 119, 123, 33, 123, 126, 123, 126, 36, - /* 1580 */ 126, 454, 0, 456, 0, 194, 195, 85, 119, 22, - /* 1590 */ 22, 158, 337, 1, 2, 204, 205, 119, 33, 12, - /* 1600 */ 13, 466, 119, 118, 22, 120, 22, 33, 33, 33, - /* 1610 */ 219, 33, 221, 122, 539, 36, 33, 226, 33, 8, - /* 1620 */ 9, 51, 33, 12, 13, 14, 15, 16, 501, 12, - /* 1630 */ 13, 504, 561, 238, 119, 508, 509, 510, 511, 512, - /* 1640 */ 513, 231, 36, 516, 517, 518, 255, 256, 257, 36, + /* 1410 */ 393, 20, 22, 22, 451, 480, 451, 454, 454, 454, + /* 1420 */ 273, 454, 408, 439, 410, 427, 36, 36, 427, 38, + /* 1430 */ 407, 408, 454, 0, 393, 148, 149, 150, 151, 152, + /* 1440 */ 153, 154, 14, 0, 407, 408, 407, 408, 20, 408, + /* 1450 */ 427, 410, 438, 407, 408, 407, 408, 148, 393, 119, + /* 1460 */ 439, 152, 71, 438, 427, 74, 427, 33, 454, 119, + /* 1470 */ 456, 454, 537, 427, 449, 427, 85, 8, 9, 438, + /* 1480 */ 545, 12, 13, 14, 15, 16, 8, 9, 36, 13, + /* 1490 */ 12, 13, 14, 15, 16, 454, 158, 456, 563, 564, + /* 1500 */ 393, 393, 33, 568, 569, 115, 115, 196, 393, 118, + /* 1510 */ 119, 173, 36, 393, 393, 501, 393, 393, 504, 454, + /* 1520 */ 393, 393, 508, 509, 510, 511, 512, 513, 393, 393, + /* 1530 */ 516, 517, 518, 393, 4, 408, 33, 523, 337, 525, + /* 1540 */ 55, 466, 501, 529, 530, 504, 155, 156, 129, 508, + /* 1550 */ 509, 510, 511, 512, 513, 33, 36, 516, 517, 518, + /* 1560 */ 123, 454, 454, 126, 523, 438, 525, 539, 257, 454, + /* 1570 */ 529, 530, 257, 123, 454, 454, 126, 454, 454, 33, + /* 1580 */ 247, 454, 454, 456, 54, 194, 195, 0, 119, 454, + /* 1590 */ 454, 158, 0, 0, 454, 204, 205, 119, 33, 572, + /* 1600 */ 123, 158, 183, 126, 123, 85, 231, 126, 0, 22, + /* 1610 */ 219, 33, 221, 33, 22, 22, 33, 226, 33, 8, + /* 1620 */ 9, 51, 119, 12, 13, 14, 15, 16, 501, 561, + /* 1630 */ 22, 504, 554, 1, 2, 508, 509, 510, 511, 512, + /* 1640 */ 513, 119, 36, 516, 517, 518, 255, 256, 257, 33, /* 1650 */ 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - /* 1660 */ 269, 270, 271, 272, 85, 33, 275, 276, 277, 278, - /* 1670 */ 279, 33, 33, 554, 283, 284, 285, 286, 287, 288, - /* 1680 */ 289, 12, 13, 393, 119, 558, 559, 572, 118, 20, - /* 1690 */ 33, 22, 540, 119, 119, 119, 33, 119, 408, 33, - /* 1700 */ 410, 438, 119, 33, 119, 36, 33, 38, 119, 411, - /* 1710 */ 33, 12, 13, 424, 8, 9, 47, 424, 12, 13, - /* 1720 */ 14, 15, 16, 12, 13, 12, 13, 406, 438, 560, - /* 1730 */ 119, 33, 255, 12, 13, 12, 13, 12, 13, 466, - /* 1740 */ 71, 12, 13, 74, 454, 33, 456, 12, 13, 12, - /* 1750 */ 13, 119, 33, 33, 85, 8, 9, 119, 119, 12, + /* 1660 */ 269, 270, 271, 272, 33, 119, 275, 276, 277, 278, + /* 1670 */ 279, 155, 156, 221, 283, 284, 285, 286, 287, 288, + /* 1680 */ 289, 12, 13, 393, 119, 558, 559, 411, 118, 20, + /* 1690 */ 33, 22, 339, 12, 13, 540, 33, 119, 408, 119, + /* 1700 */ 410, 438, 119, 33, 119, 36, 33, 38, 424, 424, + /* 1710 */ 33, 33, 12, 13, 8, 9, 47, 466, 12, 13, + /* 1720 */ 14, 15, 16, 238, 406, 33, 33, 118, 438, 120, + /* 1730 */ 119, 33, 12, 13, 560, 119, 12, 13, 12, 13, + /* 1740 */ 71, 12, 13, 74, 454, 33, 456, 33, 12, 13, + /* 1750 */ 119, 12, 13, 560, 85, 8, 9, 12, 13, 12, /* 1760 */ 13, 14, 15, 16, 8, 9, 33, 33, 12, 13, - /* 1770 */ 14, 15, 16, 8, 9, 560, 119, 12, 13, 14, - /* 1780 */ 15, 16, 119, 560, 115, 119, 13, 118, 13, 119, - /* 1790 */ 479, 501, 119, 36, 504, 393, 119, 560, 508, 509, - /* 1800 */ 510, 511, 512, 513, 466, 411, 516, 517, 518, 36, - /* 1810 */ 408, 36, 502, 523, 408, 525, 453, 119, 487, 529, - /* 1820 */ 530, 466, 466, 544, 155, 156, 565, 221, 544, 426, - /* 1830 */ 531, 119, 547, 466, 221, 317, 57, 503, 119, 119, - /* 1840 */ 438, 481, 85, 20, 20, 407, 492, 237, 497, 492, - /* 1850 */ 416, 416, 119, 119, 217, 483, 454, 20, 456, 408, - /* 1860 */ 47, 463, 407, 194, 195, 408, 119, 463, 193, 341, - /* 1870 */ 407, 460, 407, 204, 205, 119, 408, 463, 460, 460, - /* 1880 */ 460, 420, 116, 114, 119, 419, 407, 407, 219, 113, - /* 1890 */ 221, 418, 20, 8, 9, 226, 407, 12, 13, 14, - /* 1900 */ 15, 16, 196, 501, 407, 407, 504, 400, 52, 404, - /* 1910 */ 508, 509, 510, 511, 512, 513, 400, 404, 516, 517, - /* 1920 */ 518, 492, 416, 20, 255, 256, 257, 416, 259, 260, + /* 1770 */ 14, 15, 16, 8, 9, 341, 119, 12, 13, 14, + /* 1780 */ 15, 16, 119, 33, 115, 12, 13, 118, 36, 119, + /* 1790 */ 33, 501, 119, 13, 504, 393, 119, 119, 508, 509, + /* 1800 */ 510, 511, 512, 513, 12, 13, 516, 517, 518, 13, + /* 1810 */ 408, 119, 119, 523, 560, 525, 36, 119, 36, 529, + /* 1820 */ 530, 479, 466, 411, 155, 156, 560, 221, 502, 408, + /* 1830 */ 453, 119, 36, 119, 487, 466, 466, 85, 544, 544, + /* 1840 */ 438, 531, 565, 547, 466, 317, 426, 481, 57, 503, + /* 1850 */ 20, 407, 119, 119, 20, 492, 454, 237, 456, 497, + /* 1860 */ 492, 416, 416, 194, 195, 217, 119, 85, 483, 119, + /* 1870 */ 407, 20, 408, 204, 205, 119, 119, 463, 47, 408, + /* 1880 */ 463, 193, 460, 408, 119, 460, 407, 407, 219, 463, + /* 1890 */ 221, 460, 460, 116, 420, 226, 407, 114, 407, 113, + /* 1900 */ 407, 419, 196, 501, 418, 407, 504, 407, 20, 400, + /* 1910 */ 508, 509, 510, 511, 512, 513, 52, 404, 516, 517, + /* 1920 */ 518, 400, 404, 416, 255, 256, 257, 492, 259, 260, /* 1930 */ 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - /* 1940 */ 271, 272, 456, 416, 275, 276, 277, 278, 279, 20, - /* 1950 */ 20, 409, 283, 284, 285, 286, 287, 288, 289, 12, - /* 1960 */ 13, 416, 409, 482, 393, 416, 20, 20, 473, 22, - /* 1970 */ 416, 20, 570, 571, 416, 467, 416, 52, 434, 408, - /* 1980 */ 434, 400, 416, 36, 407, 38, 438, 407, 438, 438, - /* 1990 */ 438, 396, 396, 438, 438, 438, 496, 438, 400, 438, - /* 2000 */ 438, 438, 240, 494, 119, 118, 492, 414, 20, 438, - /* 2010 */ 491, 225, 489, 224, 488, 414, 481, 326, 71, 407, - /* 2020 */ 456, 74, 325, 454, 553, 454, 454, 456, 553, 334, - /* 2030 */ 556, 210, 85, 318, 312, 551, 336, 555, 335, 552, - /* 2040 */ 454, 553, 454, 550, 313, 12, 13, 474, 343, 573, - /* 2050 */ 340, 408, 338, 543, 20, 22, 129, 567, 566, 542, - /* 2060 */ 315, 393, 115, 409, 474, 118, 414, 546, 474, 36, - /* 2070 */ 548, 38, 501, 414, 454, 504, 408, 454, 481, 508, - /* 2080 */ 509, 510, 511, 512, 513, 454, 202, 516, 517, 518, - /* 2090 */ 454, 467, 474, 471, 523, 454, 525, 414, 507, 454, - /* 2100 */ 529, 530, 155, 156, 71, 118, 438, 414, 202, 454, - /* 2110 */ 468, 467, 433, 118, 454, 414, 414, 408, 85, 454, - /* 2120 */ 22, 454, 454, 395, 456, 454, 454, 528, 454, 35, - /* 2130 */ 454, 443, 454, 407, 454, 454, 454, 37, 454, 454, - /* 2140 */ 454, 194, 195, 454, 454, 399, 454, 398, 115, 40, - /* 2150 */ 454, 204, 205, 414, 401, 400, 500, 493, 454, 391, - /* 2160 */ 0, 454, 454, 415, 440, 0, 219, 440, 221, 501, - /* 2170 */ 454, 454, 504, 226, 430, 0, 508, 509, 510, 511, - /* 2180 */ 512, 513, 47, 0, 516, 517, 518, 36, 430, 430, - /* 2190 */ 246, 523, 36, 525, 36, 36, 246, 529, 530, 0, - /* 2200 */ 36, 246, 255, 256, 257, 475, 259, 260, 261, 262, + /* 1940 */ 271, 272, 416, 20, 275, 276, 277, 278, 279, 416, + /* 1950 */ 456, 20, 283, 284, 285, 286, 287, 288, 289, 12, + /* 1960 */ 13, 409, 20, 416, 393, 482, 409, 20, 20, 22, + /* 1970 */ 416, 416, 570, 571, 473, 20, 416, 467, 416, 408, + /* 1980 */ 52, 407, 434, 36, 434, 38, 400, 438, 416, 438, + /* 1990 */ 396, 438, 396, 454, 438, 407, 438, 438, 400, 438, + /* 2000 */ 240, 438, 438, 118, 438, 438, 494, 496, 20, 438, + /* 2010 */ 225, 492, 224, 414, 491, 414, 489, 488, 71, 481, + /* 2020 */ 407, 74, 454, 454, 325, 454, 553, 456, 326, 456, + /* 2030 */ 454, 334, 85, 210, 318, 313, 335, 553, 543, 336, + /* 2040 */ 312, 553, 552, 556, 340, 12, 13, 555, 551, 474, + /* 2050 */ 542, 474, 550, 343, 408, 22, 338, 20, 129, 315, + /* 2060 */ 481, 393, 115, 567, 409, 118, 414, 414, 454, 36, + /* 2070 */ 202, 38, 501, 548, 474, 504, 408, 573, 546, 508, + /* 2080 */ 509, 510, 511, 512, 513, 414, 474, 516, 517, 518, + /* 2090 */ 566, 507, 454, 454, 523, 454, 525, 454, 471, 454, + /* 2100 */ 529, 530, 155, 156, 71, 414, 438, 467, 118, 528, + /* 2110 */ 454, 202, 468, 433, 467, 454, 408, 118, 85, 414, + /* 2120 */ 454, 414, 454, 22, 456, 395, 454, 35, 454, 454, + /* 2130 */ 454, 37, 407, 454, 484, 398, 454, 454, 454, 454, + /* 2140 */ 454, 194, 195, 454, 454, 414, 40, 399, 115, 454, + /* 2150 */ 454, 204, 205, 430, 401, 400, 415, 493, 443, 440, + /* 2160 */ 500, 391, 475, 454, 0, 454, 219, 454, 221, 501, + /* 2170 */ 430, 454, 504, 226, 0, 454, 508, 509, 510, 511, + /* 2180 */ 512, 513, 440, 0, 516, 517, 518, 47, 430, 454, + /* 2190 */ 0, 523, 454, 525, 36, 246, 36, 529, 530, 36, + /* 2200 */ 246, 36, 255, 256, 257, 0, 259, 260, 261, 262, /* 2210 */ 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - /* 2220 */ 484, 36, 275, 276, 277, 278, 279, 475, 0, 36, + /* 2220 */ 36, 475, 275, 276, 277, 278, 279, 36, 246, 36, /* 2230 */ 283, 284, 285, 286, 287, 288, 289, 12, 13, 0, - /* 2240 */ 246, 0, 36, 0, 36, 20, 0, 22, 22, 0, - /* 2250 */ 36, 241, 219, 0, 221, 227, 0, 227, 221, 228, - /* 2260 */ 219, 36, 0, 38, 0, 0, 215, 393, 214, 0, - /* 2270 */ 0, 161, 51, 51, 0, 0, 36, 0, 36, 0, - /* 2280 */ 57, 51, 408, 0, 47, 0, 0, 0, 255, 256, - /* 2290 */ 0, 0, 0, 0, 0, 51, 71, 0, 179, 74, - /* 2300 */ 0, 179, 36, 0, 0, 0, 0, 0, 275, 276, + /* 2240 */ 0, 246, 0, 36, 0, 20, 36, 22, 0, 22, + /* 2250 */ 0, 36, 219, 241, 221, 0, 227, 0, 227, 221, + /* 2260 */ 228, 36, 219, 38, 0, 0, 0, 393, 215, 214, + /* 2270 */ 0, 0, 161, 51, 51, 0, 0, 36, 0, 36, + /* 2280 */ 0, 57, 408, 51, 0, 47, 0, 0, 255, 256, + /* 2290 */ 0, 0, 0, 0, 0, 0, 71, 51, 0, 74, + /* 2300 */ 179, 0, 179, 36, 0, 0, 0, 0, 275, 276, /* 2310 */ 85, 0, 438, 0, 0, 0, 283, 284, 285, 286, /* 2320 */ 287, 288, 0, 0, 0, 0, 0, 0, 454, 0, - /* 2330 */ 456, 0, 0, 0, 0, 51, 0, 0, 0, 0, - /* 2340 */ 115, 0, 47, 118, 0, 0, 0, 0, 0, 0, - /* 2350 */ 22, 0, 161, 0, 160, 0, 159, 0, 0, 0, - /* 2360 */ 52, 52, 22, 0, 22, 0, 36, 71, 0, 71, - /* 2370 */ 71, 0, 71, 0, 57, 501, 57, 0, 504, 36, - /* 2380 */ 155, 156, 508, 509, 510, 511, 512, 513, 0, 0, - /* 2390 */ 516, 517, 518, 0, 44, 0, 36, 523, 44, 525, - /* 2400 */ 36, 0, 36, 529, 530, 44, 36, 33, 14, 57, - /* 2410 */ 0, 0, 393, 44, 47, 0, 0, 0, 56, 194, - /* 2420 */ 195, 210, 44, 51, 45, 44, 51, 408, 0, 204, - /* 2430 */ 205, 51, 0, 51, 51, 0, 0, 0, 0, 36, - /* 2440 */ 44, 0, 57, 36, 219, 0, 221, 57, 36, 44, - /* 2450 */ 44, 226, 0, 44, 57, 36, 57, 438, 0, 0, - /* 2460 */ 0, 0, 0, 79, 0, 36, 0, 36, 22, 0, - /* 2470 */ 22, 22, 33, 454, 0, 456, 36, 33, 36, 36, - /* 2480 */ 255, 256, 257, 36, 259, 260, 261, 262, 263, 264, - /* 2490 */ 265, 266, 267, 268, 269, 270, 271, 272, 22, 36, - /* 2500 */ 275, 276, 277, 278, 279, 0, 36, 36, 283, 284, - /* 2510 */ 285, 286, 287, 288, 289, 12, 13, 36, 393, 128, - /* 2520 */ 501, 36, 36, 504, 126, 22, 36, 508, 509, 510, - /* 2530 */ 511, 512, 513, 408, 36, 516, 517, 518, 0, 36, - /* 2540 */ 22, 38, 22, 59, 525, 393, 0, 22, 529, 530, - /* 2550 */ 36, 0, 0, 0, 0, 36, 0, 36, 36, 0, - /* 2560 */ 408, 22, 20, 438, 36, 36, 36, 0, 51, 119, - /* 2570 */ 0, 118, 118, 0, 71, 0, 36, 22, 0, 454, - /* 2580 */ 22, 456, 196, 3, 119, 393, 319, 119, 232, 114, - /* 2590 */ 438, 118, 51, 33, 22, 118, 196, 118, 36, 119, - /* 2600 */ 408, 36, 52, 3, 196, 118, 454, 116, 456, 52, - /* 2610 */ 196, 119, 393, 119, 222, 202, 196, 33, 231, 33, - /* 2620 */ 118, 33, 118, 33, 206, 118, 501, 408, 226, 504, - /* 2630 */ 438, 206, 119, 508, 509, 510, 511, 512, 513, 319, - /* 2640 */ 51, 516, 517, 518, 118, 33, 454, 36, 456, 85, - /* 2650 */ 525, 119, 118, 501, 529, 530, 504, 438, 33, 36, + /* 2330 */ 456, 0, 0, 0, 0, 0, 51, 0, 0, 0, + /* 2340 */ 115, 0, 0, 118, 47, 0, 0, 0, 0, 0, + /* 2350 */ 0, 0, 22, 0, 0, 161, 160, 159, 0, 0, + /* 2360 */ 52, 52, 22, 0, 0, 22, 0, 71, 0, 0, + /* 2370 */ 71, 71, 36, 71, 0, 501, 57, 0, 504, 0, + /* 2380 */ 155, 156, 508, 509, 510, 511, 512, 513, 36, 0, + /* 2390 */ 516, 517, 518, 36, 0, 0, 36, 523, 0, 525, + /* 2400 */ 44, 57, 14, 529, 530, 44, 44, 36, 36, 0, + /* 2410 */ 0, 56, 393, 33, 47, 0, 0, 44, 0, 194, + /* 2420 */ 195, 51, 57, 45, 210, 0, 51, 408, 44, 204, + /* 2430 */ 205, 44, 51, 51, 0, 0, 51, 0, 0, 0, + /* 2440 */ 44, 36, 0, 57, 219, 44, 221, 36, 57, 0, + /* 2450 */ 36, 226, 44, 0, 57, 36, 57, 438, 0, 0, + /* 2460 */ 0, 44, 79, 0, 0, 36, 0, 0, 36, 22, + /* 2470 */ 0, 59, 22, 454, 22, 456, 36, 36, 33, 36, + /* 2480 */ 255, 256, 257, 22, 259, 260, 261, 262, 263, 264, + /* 2490 */ 265, 266, 267, 268, 269, 270, 271, 272, 36, 0, + /* 2500 */ 275, 276, 277, 278, 279, 36, 33, 36, 283, 284, + /* 2510 */ 285, 286, 287, 288, 289, 12, 13, 36, 393, 36, + /* 2520 */ 501, 128, 36, 504, 0, 22, 126, 508, 509, 510, + /* 2530 */ 511, 512, 513, 408, 36, 516, 517, 518, 36, 36, + /* 2540 */ 36, 38, 22, 0, 525, 393, 0, 22, 529, 530, + /* 2550 */ 22, 36, 0, 0, 0, 36, 0, 36, 0, 36, + /* 2560 */ 408, 0, 22, 438, 20, 36, 36, 36, 0, 51, + /* 2570 */ 119, 0, 118, 118, 71, 36, 0, 22, 0, 454, + /* 2580 */ 0, 456, 22, 33, 3, 393, 196, 319, 22, 51, + /* 2590 */ 438, 119, 118, 118, 52, 119, 118, 52, 119, 196, + /* 2600 */ 408, 36, 196, 36, 114, 118, 454, 116, 456, 202, + /* 2610 */ 33, 119, 393, 119, 118, 33, 196, 196, 118, 118, + /* 2620 */ 33, 51, 33, 118, 232, 119, 501, 408, 226, 504, + /* 2630 */ 438, 319, 206, 508, 509, 510, 511, 512, 513, 206, + /* 2640 */ 33, 516, 517, 518, 231, 222, 454, 85, 456, 36, + /* 2650 */ 525, 119, 118, 501, 529, 530, 504, 438, 3, 33, /* 2660 */ 508, 509, 510, 511, 512, 513, 119, 119, 516, 517, - /* 2670 */ 518, 36, 36, 454, 36, 456, 36, 525, 36, 33, - /* 2680 */ 119, 529, 530, 51, 51, 119, 0, 0, 44, 118, - /* 2690 */ 0, 44, 118, 501, 199, 119, 504, 0, 119, 118, - /* 2700 */ 508, 509, 510, 511, 512, 513, 119, 515, 516, 517, - /* 2710 */ 518, 118, 203, 118, 199, 44, 33, 116, 291, 116, - /* 2720 */ 501, 198, 219, 504, 221, 303, 2, 508, 509, 510, - /* 2730 */ 511, 512, 513, 22, 118, 516, 517, 518, 255, 118, - /* 2740 */ 319, 119, 118, 51, 525, 118, 51, 118, 118, 530, - /* 2750 */ 119, 22, 118, 0, 258, 118, 253, 254, 255, 118, - /* 2760 */ 44, 118, 199, 0, 119, 22, 118, 22, 118, 393, - /* 2770 */ 119, 118, 118, 121, 119, 118, 118, 118, 275, 276, - /* 2780 */ 120, 51, 118, 118, 408, 119, 283, 284, 285, 286, - /* 2790 */ 287, 288, 118, 118, 36, 119, 129, 393, 36, 118, - /* 2800 */ 232, 119, 36, 118, 36, 36, 36, 119, 119, 36, - /* 2810 */ 119, 118, 408, 119, 438, 33, 118, 140, 140, 140, - /* 2820 */ 140, 36, 118, 22, 22, 79, 78, 36, 36, 36, - /* 2830 */ 454, 36, 456, 36, 36, 36, 36, 85, 112, 36, - /* 2840 */ 36, 36, 438, 112, 85, 33, 36, 36, 22, 36, - /* 2850 */ 36, 22, 36, 36, 478, 36, 85, 36, 454, 36, - /* 2860 */ 456, 36, 0, 36, 36, 57, 36, 0, 44, 36, - /* 2870 */ 0, 36, 0, 36, 0, 57, 44, 501, 44, 57, - /* 2880 */ 504, 393, 36, 44, 508, 509, 510, 511, 512, 513, - /* 2890 */ 0, 22, 516, 517, 518, 57, 408, 0, 22, 36, - /* 2900 */ 0, 22, 36, 22, 33, 501, 21, 21, 504, 393, - /* 2910 */ 22, 36, 508, 509, 510, 511, 512, 513, 22, 20, - /* 2920 */ 516, 517, 518, 574, 408, 574, 438, 574, 574, 574, + /* 2670 */ 518, 36, 36, 454, 36, 456, 36, 525, 36, 36, + /* 2680 */ 51, 529, 530, 119, 33, 51, 0, 0, 119, 44, + /* 2690 */ 118, 0, 119, 501, 119, 0, 504, 118, 44, 33, + /* 2700 */ 508, 509, 510, 511, 512, 513, 118, 515, 516, 517, + /* 2710 */ 518, 199, 118, 203, 119, 118, 199, 44, 116, 291, + /* 2720 */ 501, 116, 219, 504, 221, 198, 2, 508, 509, 510, + /* 2730 */ 511, 512, 513, 303, 22, 516, 517, 518, 118, 255, + /* 2740 */ 118, 319, 118, 118, 525, 118, 0, 51, 118, 530, + /* 2750 */ 119, 119, 119, 51, 22, 118, 253, 254, 255, 118, + /* 2760 */ 44, 0, 118, 22, 118, 118, 118, 258, 118, 393, + /* 2770 */ 51, 119, 119, 199, 118, 118, 118, 118, 275, 276, + /* 2780 */ 120, 118, 121, 118, 408, 118, 283, 284, 285, 286, + /* 2790 */ 287, 288, 22, 119, 118, 232, 119, 393, 36, 129, + /* 2800 */ 36, 118, 36, 119, 119, 36, 118, 36, 119, 119, + /* 2810 */ 36, 119, 408, 36, 438, 140, 118, 33, 140, 140, + /* 2820 */ 140, 118, 36, 118, 22, 22, 79, 78, 22, 36, + /* 2830 */ 454, 36, 456, 36, 36, 36, 36, 36, 85, 112, + /* 2840 */ 36, 36, 438, 36, 36, 85, 112, 33, 36, 36, + /* 2850 */ 22, 0, 36, 36, 478, 36, 36, 85, 454, 36, + /* 2860 */ 456, 36, 36, 36, 22, 36, 36, 36, 57, 0, + /* 2870 */ 36, 0, 36, 0, 0, 57, 44, 501, 57, 44, + /* 2880 */ 504, 393, 44, 36, 508, 509, 510, 511, 512, 513, + /* 2890 */ 57, 36, 516, 517, 518, 0, 408, 44, 22, 0, + /* 2900 */ 22, 36, 0, 22, 36, 501, 36, 22, 504, 393, + /* 2910 */ 33, 21, 508, 509, 510, 511, 512, 513, 22, 22, + /* 2920 */ 516, 517, 518, 20, 408, 21, 438, 574, 574, 574, /* 2930 */ 393, 574, 574, 574, 574, 574, 574, 574, 574, 574, /* 2940 */ 574, 574, 454, 574, 456, 408, 574, 574, 574, 574, /* 2950 */ 574, 574, 574, 574, 438, 574, 574, 574, 574, 574, @@ -1598,9 +1598,9 @@ static const YYCODETYPE yy_lookahead[] = { /* 5090 */ 390, 390, 390, 390, 390, 390, 390, 390, 390, 390, /* 5100 */ 390, 390, 390, 390, 390, 390, 390, 390, 390, }; -#define YY_SHIFT_COUNT (1024) +#define YY_SHIFT_COUNT (1025) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2900) +#define YY_SHIFT_MAX (2904) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 712, 278, 556, 278, 835, 835, 835, 835, 835, 835, /* 10 */ 835, 835, 835, 835, 835, 835, 1113, 1947, 1947, 2225, @@ -1608,103 +1608,103 @@ static const unsigned short int yy_shift_ofst[] = { /* 30 */ 1947, 1947, 1669, 1947, 1947, 1947, 1947, 1947, 1947, 1947, /* 40 */ 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, /* 50 */ 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, 1947, - /* 60 */ 1947, 1947, 1947, 34, 378, 638, 407, 202, 540, 202, - /* 70 */ 202, 407, 407, 202, 2033, 202, 277, 2033, 184, 202, - /* 80 */ 188, 2503, 416, 416, 193, 193, 2503, 2503, 1130, 1130, - /* 90 */ 416, 20, 20, 69, 351, 351, 53, 133, 193, 193, - /* 100 */ 193, 193, 193, 193, 193, 193, 193, 193, 193, 372, - /* 110 */ 408, 682, 193, 193, 95, 188, 193, 372, 193, 188, - /* 120 */ 193, 193, 193, 193, 188, 193, 193, 193, 188, 193, - /* 130 */ 188, 188, 188, 513, 505, 505, 105, 105, 470, 1212, + /* 60 */ 1947, 1947, 1947, 34, 156, 246, 97, 6, 121, 6, + /* 70 */ 6, 97, 97, 6, 2033, 6, 277, 2033, 645, 6, + /* 80 */ 133, 2503, 416, 416, 170, 170, 2503, 2503, 1130, 1130, + /* 90 */ 416, 8, 8, 360, 348, 348, 628, 93, 170, 170, + /* 100 */ 170, 170, 170, 170, 170, 170, 170, 170, 170, 234, + /* 110 */ 375, 440, 170, 170, 219, 133, 170, 234, 170, 133, + /* 120 */ 170, 170, 170, 170, 133, 170, 170, 170, 133, 170, + /* 130 */ 133, 133, 133, 640, 505, 505, 99, 99, 470, 1212, /* 140 */ 435, 51, 951, 951, 951, 951, 951, 951, 951, 951, /* 150 */ 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, - /* 160 */ 951, 538, 749, 20, 69, 896, 896, 399, 495, 495, - /* 170 */ 495, 356, 356, 640, 447, 399, 95, 188, 608, 188, - /* 180 */ 188, 437, 188, 188, 725, 188, 725, 725, 790, 910, - /* 190 */ 1015, 105, 105, 105, 105, 105, 105, 595, 21, 78, - /* 200 */ 182, 182, 315, 534, 23, 607, 609, 206, 699, 1073, - /* 210 */ 458, 458, 1286, 1021, 1190, 1190, 1190, 377, 1190, 1047, - /* 220 */ 1243, 1121, 1120, 1520, 1309, 716, 318, 318, 1038, 1428, - /* 230 */ 1428, 1255, 563, 892, 318, 447, 1518, 1779, 1823, 1824, - /* 240 */ 1610, 95, 1824, 95, 1637, 1823, 1837, 1813, 1837, 1813, - /* 250 */ 1675, 1823, 1837, 1823, 1813, 1675, 1675, 1675, 1766, 1769, - /* 260 */ 1823, 1823, 1776, 1823, 1823, 1823, 1872, 1856, 1872, 1856, - /* 270 */ 1824, 95, 95, 1903, 95, 1929, 1930, 95, 1929, 95, - /* 280 */ 1946, 95, 1951, 95, 95, 1925, 1925, 1823, 95, 1872, - /* 290 */ 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, - /* 300 */ 188, 1823, 910, 910, 1872, 725, 725, 725, 1762, 1887, - /* 310 */ 1824, 513, 1988, 1786, 1789, 1903, 513, 1518, 1823, 725, - /* 320 */ 1691, 1697, 1691, 1697, 1695, 1821, 1691, 1700, 1703, 1715, - /* 330 */ 1518, 1731, 1722, 1705, 1710, 1714, 1837, 2034, 1927, 1745, - /* 340 */ 1929, 513, 513, 1697, 725, 725, 725, 725, 1697, 725, - /* 350 */ 1884, 513, 725, 1951, 513, 1987, 725, 1906, 1951, 513, - /* 360 */ 790, 513, 1837, 725, 725, 725, 725, 725, 725, 725, - /* 370 */ 725, 725, 725, 725, 725, 725, 725, 725, 725, 725, - /* 380 */ 725, 725, 725, 725, 725, 1995, 725, 1823, 513, 2098, - /* 390 */ 2094, 2100, 2109, 1872, 4719, 4719, 4719, 4719, 4719, 4719, - /* 400 */ 4719, 4719, 4719, 4719, 4719, 4719, 39, 520, 37, 1138, - /* 410 */ 1469, 1478, 87, 1340, 1035, 1350, 1611, 1747, 921, 493, - /* 420 */ 1062, 1756, 1147, 1765, 1885, 610, 1706, 829, 870, 515, - /* 430 */ 515, 515, 515, 515, 515, 515, 515, 515, 79, 150, - /* 440 */ 531, 22, 3, 3, 522, 778, 710, 256, 490, 968, - /* 450 */ 979, 680, 1149, 1306, 1282, 1282, 1101, 1453, 1150, 1101, - /* 460 */ 1101, 1101, 1512, 926, 84, 1464, 750, 1016, 1371, 1433, - /* 470 */ 660, 1541, 1437, 1410, 1450, 1452, 1410, 1454, 1502, 1029, - /* 480 */ 1543, 1567, 1568, 1582, 1584, 1395, 1483, 1515, 1491, 1565, - /* 490 */ 1574, 1575, 1576, 1333, 1022, 1528, 1578, 1583, 1585, 1589, - /* 500 */ 1592, 1632, 1477, 1638, 1639, 1657, 1570, 1663, 1666, 1670, - /* 510 */ 1673, 1677, 1587, 1617, 1699, 1711, 1713, 1721, 1723, 1725, - /* 520 */ 1729, 1735, 1737, 1698, 1410, 1712, 1719, 1720, 1733, 1734, - /* 530 */ 1485, 1579, 1606, 1613, 1773, 1775, 1757, 570, 2160, 2165, - /* 540 */ 2175, 2135, 2183, 2151, 1944, 2156, 2158, 2159, 1950, 2199, - /* 550 */ 2164, 2185, 1955, 2193, 2228, 2239, 1994, 2241, 2206, 2243, - /* 560 */ 2208, 2246, 2226, 2249, 2214, 2010, 2253, 2028, 2256, 2030, - /* 570 */ 2031, 2037, 2041, 2262, 2264, 2265, 2051, 2054, 2269, 2270, - /* 580 */ 2110, 2221, 2222, 2274, 2240, 2275, 2277, 2242, 2223, 2279, - /* 590 */ 2230, 2283, 2237, 2285, 2286, 2287, 2244, 2290, 2291, 2292, - /* 600 */ 2293, 2294, 2297, 2119, 2266, 2300, 2122, 2303, 2304, 2305, - /* 610 */ 2306, 2307, 2311, 2313, 2314, 2315, 2322, 2323, 2324, 2325, - /* 620 */ 2326, 2327, 2329, 2331, 2332, 2333, 2334, 2284, 2336, 2295, - /* 630 */ 2337, 2338, 2339, 2341, 2344, 2345, 2346, 2347, 2348, 2349, - /* 640 */ 2328, 2351, 2191, 2353, 2194, 2355, 2197, 2357, 2358, 2340, - /* 650 */ 2308, 2342, 2309, 2359, 2296, 2363, 2298, 2330, 2365, 2299, - /* 660 */ 2368, 2301, 2371, 2373, 2343, 2317, 2350, 2388, 2360, 2319, - /* 670 */ 2354, 2377, 2364, 2352, 2361, 2389, 2366, 2393, 2362, 2395, - /* 680 */ 2370, 2401, 2367, 2369, 2374, 2372, 2375, 2394, 2380, 2410, - /* 690 */ 2379, 2378, 2411, 2415, 2416, 2417, 2381, 2211, 2428, 2372, - /* 700 */ 2382, 2432, 2372, 2383, 2435, 2436, 2384, 2437, 2438, 2403, - /* 710 */ 2385, 2396, 2441, 2407, 2390, 2405, 2445, 2412, 2397, 2406, - /* 720 */ 2452, 2419, 2399, 2409, 2458, 2459, 2460, 2461, 2462, 2429, - /* 730 */ 2464, 2466, 2391, 2398, 2431, 2446, 2469, 2448, 2440, 2442, - /* 740 */ 2443, 2447, 2463, 2470, 2471, 2481, 2485, 2439, 2444, 2486, - /* 750 */ 2490, 2449, 2498, 2474, 2476, 2505, 2518, 2538, 2520, 2484, - /* 760 */ 2546, 2525, 2514, 2551, 2552, 2553, 2519, 2554, 2521, 2556, - /* 770 */ 2522, 2559, 2539, 2542, 2528, 2529, 2530, 2450, 2453, 2567, - /* 780 */ 2386, 2356, 2387, 2454, 2402, 2372, 2517, 2570, 2400, 2540, - /* 790 */ 2555, 2573, 2392, 2558, 2408, 2413, 2575, 2578, 2414, 2418, - /* 800 */ 2420, 2425, 2580, 2560, 2267, 2473, 2465, 2477, 2468, 2572, - /* 810 */ 2479, 2480, 2562, 2565, 2487, 2550, 2491, 2557, 2475, 2492, - /* 820 */ 2584, 2586, 2494, 2502, 2504, 2507, 2513, 2588, 2541, 2589, - /* 830 */ 2526, 2590, 2320, 2564, 2532, 2612, 2534, 2611, 2547, 2548, - /* 840 */ 2600, 2625, 2421, 2623, 2635, 2636, 2638, 2640, 2642, 2561, - /* 850 */ 2566, 2632, 2422, 2646, 2633, 2686, 2687, 2571, 2644, 2576, - /* 860 */ 2579, 2574, 2581, 2495, 2593, 2690, 2647, 2509, 2697, 2587, - /* 870 */ 2595, 2515, 2671, 2523, 2683, 2601, 2427, 2603, 2724, 2711, - /* 880 */ 2483, 2616, 2621, 2624, 2627, 2629, 2622, 2631, 2630, 2634, - /* 890 */ 2637, 2641, 2643, 2645, 2692, 2648, 2650, 2695, 2651, 2729, - /* 900 */ 2496, 2653, 2654, 2753, 2655, 2657, 2563, 2716, 2658, 2660, - /* 910 */ 2763, 2743, 2652, 2659, 2372, 2730, 2664, 2665, 2666, 2674, - /* 920 */ 2675, 2667, 2745, 2568, 2676, 2758, 2762, 2681, 2682, 2766, - /* 930 */ 2685, 2688, 2768, 2630, 2689, 2769, 2634, 2691, 2770, 2637, - /* 940 */ 2694, 2773, 2641, 2677, 2678, 2679, 2680, 2693, 2782, 2698, - /* 950 */ 2785, 2704, 2782, 2782, 2801, 2746, 2748, 2802, 2791, 2792, - /* 960 */ 2793, 2795, 2797, 2798, 2799, 2800, 2803, 2804, 2805, 2752, - /* 970 */ 2726, 2759, 2731, 2812, 2810, 2811, 2813, 2826, 2814, 2816, - /* 980 */ 2817, 2771, 2439, 2819, 2444, 2821, 2823, 2825, 2827, 2829, - /* 990 */ 2828, 2862, 2830, 2808, 2824, 2867, 2833, 2818, 2832, 2870, - /* 1000 */ 2835, 2822, 2834, 2872, 2837, 2838, 2839, 2874, 2846, 2890, - /* 1010 */ 2869, 2897, 2876, 2863, 2900, 2879, 2871, 2866, 2875, 2881, - /* 1020 */ 2885, 2888, 2896, 2886, 2899, + /* 160 */ 951, 538, 491, 8, 360, 1126, 1126, 467, 553, 553, + /* 170 */ 553, 546, 546, 388, 995, 467, 219, 133, 441, 133, + /* 180 */ 133, 443, 133, 133, 698, 133, 698, 698, 680, 10, + /* 190 */ 1015, 99, 99, 99, 99, 99, 99, 595, 21, 53, + /* 200 */ 182, 182, 514, 534, 23, 607, 609, 66, 687, 688, + /* 210 */ 415, 415, 1066, 1067, 135, 135, 135, 1119, 135, 318, + /* 220 */ 1311, 1236, 1129, 1428, 1309, 112, 302, 302, 1315, 1156, + /* 230 */ 1156, 1201, 1175, 948, 302, 995, 1528, 1791, 1830, 1834, + /* 240 */ 1620, 219, 1834, 219, 1648, 1830, 1851, 1831, 1851, 1831, + /* 250 */ 1688, 1830, 1851, 1830, 1831, 1688, 1688, 1688, 1777, 1783, + /* 260 */ 1830, 1830, 1786, 1830, 1830, 1830, 1888, 1864, 1888, 1864, + /* 270 */ 1834, 219, 219, 1923, 219, 1931, 1942, 219, 1931, 219, + /* 280 */ 1948, 219, 1955, 219, 219, 1928, 1928, 1830, 219, 1888, + /* 290 */ 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + /* 300 */ 133, 1830, 10, 10, 1888, 698, 698, 698, 1760, 1885, + /* 310 */ 1834, 640, 1988, 1785, 1788, 1923, 640, 1528, 1830, 698, + /* 320 */ 1702, 1699, 1702, 1699, 1697, 1823, 1702, 1703, 1701, 1716, + /* 330 */ 1528, 1722, 1728, 1710, 1704, 1718, 1851, 2037, 1929, 1744, + /* 340 */ 1931, 640, 640, 1699, 698, 698, 698, 698, 1699, 698, + /* 350 */ 1868, 640, 698, 1955, 640, 1990, 698, 1909, 1955, 640, + /* 360 */ 680, 640, 1851, 698, 698, 698, 698, 698, 698, 698, + /* 370 */ 698, 698, 698, 698, 698, 698, 698, 698, 698, 698, + /* 380 */ 698, 698, 698, 698, 698, 1999, 698, 1830, 640, 2101, + /* 390 */ 2092, 2094, 2106, 1888, 4719, 4719, 4719, 4719, 4719, 4719, + /* 400 */ 4719, 4719, 4719, 4719, 4719, 4719, 39, 520, 299, 1138, + /* 410 */ 78, 1469, 87, 1340, 1035, 1350, 1478, 1611, 610, 493, + /* 420 */ 1062, 1747, 921, 1756, 1765, 1147, 1706, 829, 870, 1328, + /* 430 */ 1328, 1328, 1328, 1328, 1328, 1328, 1328, 1328, 1287, 68, + /* 440 */ 993, 22, 3, 3, 683, 778, 797, 236, 164, 460, + /* 450 */ 1022, 1338, 735, 1390, 38, 38, 1257, 58, 892, 1257, + /* 460 */ 1257, 1257, 667, 1333, 477, 770, 1262, 1419, 1433, 1443, + /* 470 */ 1530, 939, 1437, 1375, 1450, 1477, 1375, 1481, 1520, 840, + /* 480 */ 1476, 1587, 1592, 1593, 1608, 1485, 1503, 1522, 1111, 1546, + /* 490 */ 1565, 1578, 1580, 1516, 1353, 1434, 1583, 1585, 1616, 1631, + /* 500 */ 1632, 1657, 818, 1663, 1670, 1673, 1570, 1677, 1678, 1692, + /* 510 */ 1693, 1698, 1681, 1700, 1720, 1724, 1726, 1729, 1736, 1739, + /* 520 */ 1745, 1773, 1792, 1712, 1375, 1714, 1733, 1734, 1750, 1757, + /* 530 */ 1609, 1752, 1452, 1606, 1780, 1796, 1782, 931, 2164, 2174, + /* 540 */ 2183, 2140, 2190, 2158, 1949, 2160, 2163, 2165, 1954, 2205, + /* 550 */ 2184, 2191, 1982, 2193, 2239, 2240, 1995, 2242, 2207, 2244, + /* 560 */ 2210, 2248, 2227, 2250, 2215, 2012, 2255, 2029, 2257, 2031, + /* 570 */ 2032, 2038, 2043, 2264, 2265, 2266, 2053, 2055, 2270, 2271, + /* 580 */ 2111, 2222, 2223, 2275, 2241, 2276, 2278, 2243, 2224, 2280, + /* 590 */ 2232, 2284, 2238, 2286, 2287, 2290, 2246, 2291, 2292, 2293, + /* 600 */ 2294, 2295, 2298, 2121, 2267, 2301, 2123, 2304, 2305, 2306, + /* 610 */ 2307, 2311, 2313, 2314, 2315, 2322, 2323, 2324, 2325, 2326, + /* 620 */ 2327, 2329, 2331, 2332, 2333, 2334, 2335, 2285, 2337, 2297, + /* 630 */ 2338, 2339, 2341, 2342, 2345, 2346, 2347, 2348, 2349, 2350, + /* 640 */ 2330, 2351, 2194, 2353, 2196, 2354, 2198, 2358, 2359, 2340, + /* 650 */ 2308, 2343, 2309, 2363, 2296, 2364, 2299, 2336, 2366, 2300, + /* 660 */ 2368, 2302, 2369, 2374, 2352, 2319, 2356, 2377, 2357, 2344, + /* 670 */ 2361, 2379, 2360, 2365, 2362, 2389, 2371, 2394, 2355, 2395, + /* 680 */ 2372, 2398, 2367, 2373, 2380, 2370, 2375, 2388, 2381, 2409, + /* 690 */ 2378, 2384, 2410, 2415, 2416, 2418, 2387, 2214, 2425, 2370, + /* 700 */ 2382, 2434, 2370, 2385, 2435, 2437, 2383, 2438, 2439, 2405, + /* 710 */ 2386, 2396, 2442, 2411, 2391, 2401, 2449, 2414, 2397, 2408, + /* 720 */ 2453, 2419, 2399, 2417, 2458, 2459, 2460, 2463, 2464, 2429, + /* 730 */ 2466, 2467, 2393, 2400, 2432, 2447, 2470, 2450, 2440, 2441, + /* 740 */ 2443, 2462, 2469, 2471, 2481, 2483, 2486, 2445, 2473, 2498, + /* 750 */ 2502, 2452, 2504, 2499, 2461, 2524, 2520, 2543, 2525, 2412, + /* 760 */ 2546, 2528, 2515, 2552, 2553, 2554, 2519, 2556, 2521, 2558, + /* 770 */ 2523, 2561, 2540, 2544, 2529, 2530, 2531, 2451, 2454, 2568, + /* 780 */ 2390, 2392, 2413, 2455, 2402, 2370, 2518, 2571, 2403, 2539, + /* 790 */ 2555, 2576, 2423, 2560, 2406, 2407, 2578, 2580, 2420, 2426, + /* 800 */ 2421, 2433, 2581, 2550, 2268, 2474, 2472, 2475, 2476, 2566, + /* 810 */ 2478, 2479, 2565, 2567, 2487, 2542, 2491, 2545, 2490, 2492, + /* 820 */ 2577, 2582, 2494, 2496, 2500, 2501, 2506, 2587, 2538, 2570, + /* 830 */ 2505, 2589, 2312, 2562, 2532, 2607, 2534, 2613, 2547, 2548, + /* 840 */ 2655, 2626, 2422, 2635, 2636, 2638, 2640, 2642, 2643, 2564, + /* 850 */ 2569, 2629, 2430, 2651, 2634, 2686, 2687, 2572, 2645, 2573, + /* 860 */ 2575, 2579, 2588, 2512, 2594, 2691, 2654, 2510, 2695, 2595, + /* 870 */ 2597, 2517, 2673, 2527, 2666, 2602, 2428, 2605, 2724, 2712, + /* 880 */ 2484, 2620, 2622, 2624, 2625, 2627, 2631, 2632, 2630, 2637, + /* 890 */ 2641, 2644, 2646, 2633, 2696, 2647, 2648, 2702, 2652, 2732, + /* 900 */ 2509, 2650, 2656, 2746, 2653, 2657, 2574, 2716, 2658, 2660, + /* 910 */ 2761, 2741, 2661, 2659, 2370, 2719, 2663, 2665, 2674, 2667, + /* 920 */ 2676, 2670, 2770, 2563, 2677, 2762, 2764, 2683, 2684, 2766, + /* 930 */ 2688, 2685, 2769, 2630, 2689, 2771, 2637, 2690, 2774, 2641, + /* 940 */ 2692, 2777, 2644, 2675, 2678, 2679, 2680, 2698, 2784, 2703, + /* 950 */ 2786, 2705, 2784, 2784, 2802, 2747, 2749, 2803, 2806, 2793, + /* 960 */ 2795, 2797, 2798, 2799, 2800, 2801, 2804, 2805, 2807, 2808, + /* 970 */ 2753, 2727, 2760, 2734, 2814, 2812, 2813, 2816, 2828, 2817, + /* 980 */ 2819, 2820, 2772, 2445, 2823, 2473, 2825, 2826, 2827, 2829, + /* 990 */ 2842, 2830, 2851, 2831, 2811, 2832, 2869, 2834, 2818, 2835, + /* 1000 */ 2871, 2836, 2821, 2838, 2873, 2847, 2833, 2853, 2874, 2855, + /* 1010 */ 2895, 2876, 2899, 2878, 2865, 2902, 2881, 2877, 2868, 2870, + /* 1020 */ 2885, 2890, 2896, 2897, 2904, 2903, }; #define YY_REDUCE_COUNT (405) #define YY_REDUCE_MIN (-537) @@ -1716,146 +1716,146 @@ static const short yy_reduce_ofst[] = { /* 30 */ 2815, 2859, 2882, 2971, 2994, 3022, 3063, 3106, 3148, 3245, /* 40 */ 3269, 3294, 3334, 3376, 3401, 3482, 3507, 3531, 3572, 3653, /* 50 */ 3678, 3702, 3743, 3785, 3808, 3876, 3914, 4009, 4036, 4074, - /* 60 */ 4157, 4180, 4200, -352, 335, -148, -57, -367, 152, 656, - /* 70 */ 782, 341, 701, 935, -394, -537, -153, -54, -535, -178, - /* 80 */ 412, 290, -69, 231, -4, 242, -434, 291, -401, -297, - /* 90 */ -453, -70, 325, 324, -49, 478, 474, 494, 500, 539, - /* 100 */ 598, 604, -90, 524, 625, 630, 652, 723, 541, 145, - /* 110 */ 364, -293, 731, 740, -410, 353, 789, 481, 843, -145, - /* 120 */ 849, 917, 930, 933, 527, 987, 998, 1001, -58, 1010, - /* 130 */ 551, 589, 737, 631, -362, -362, 26, -282, -205, -248, - /* 140 */ -530, -335, 46, 189, 360, 635, 776, 817, 879, 913, - /* 150 */ 993, 1017, 1019, 1042, 1051, 1053, 1060, 1063, 1065, 1067, - /* 160 */ 1074, -409, 131, -424, 104, 792, 867, 866, 131, 226, - /* 170 */ 707, -324, 486, 1006, -127, 893, 881, 1002, 898, 65, - /* 180 */ 336, 564, 739, -341, 965, 988, 1012, 1082, 1009, 1078, - /* 190 */ 577, 578, 641, 689, 713, 834, 890, 715, 953, 1135, - /* 200 */ 1075, 1075, 1115, 1071, 1119, 1152, 1298, 1075, 1263, 1263, - /* 210 */ 1289, 1293, 1321, 1273, 1169, 1215, 1223, 1311, 1237, 1263, - /* 220 */ 1338, 1394, 1310, 1406, 1363, 1331, 1355, 1356, 1263, 1279, - /* 230 */ 1284, 1261, 1299, 1285, 1367, 1403, 1360, 1334, 1438, 1354, - /* 240 */ 1351, 1434, 1357, 1435, 1372, 1455, 1451, 1398, 1457, 1404, - /* 250 */ 1411, 1463, 1468, 1465, 1414, 1418, 1419, 1420, 1461, 1466, - /* 260 */ 1479, 1480, 1473, 1489, 1497, 1498, 1507, 1505, 1516, 1513, - /* 270 */ 1429, 1506, 1511, 1486, 1527, 1542, 1481, 1545, 1553, 1549, - /* 280 */ 1495, 1554, 1508, 1558, 1560, 1544, 1546, 1577, 1566, 1581, - /* 290 */ 1548, 1550, 1551, 1552, 1555, 1556, 1557, 1559, 1561, 1562, - /* 300 */ 1563, 1580, 1595, 1596, 1598, 1569, 1572, 1586, 1500, 1509, - /* 310 */ 1514, 1593, 1519, 1523, 1526, 1564, 1601, 1535, 1612, 1588, - /* 320 */ 1471, 1573, 1475, 1590, 1474, 1482, 1488, 1487, 1484, 1493, - /* 330 */ 1597, 1510, 1517, 1476, 1490, 1492, 1643, 1591, 1522, 1521, - /* 340 */ 1654, 1652, 1659, 1594, 1620, 1623, 1631, 1636, 1618, 1641, - /* 350 */ 1622, 1683, 1645, 1624, 1693, 1599, 1655, 1642, 1644, 1701, - /* 360 */ 1679, 1702, 1709, 1660, 1665, 1667, 1671, 1672, 1674, 1676, - /* 370 */ 1678, 1680, 1681, 1682, 1684, 1685, 1686, 1689, 1690, 1692, - /* 380 */ 1696, 1704, 1707, 1708, 1716, 1688, 1717, 1726, 1739, 1728, - /* 390 */ 1749, 1746, 1753, 1755, 1736, 1724, 1656, 1664, 1730, 1752, - /* 400 */ 1744, 1758, 1727, 1759, 1748, 1768, + /* 60 */ 4157, 4180, 4200, -352, 335, -148, -57, 152, 315, 656, + /* 70 */ 782, 231, 701, 935, 174, -537, -211, -340, -535, -178, + /* 80 */ -247, 290, -69, 398, -238, -4, 244, 333, -401, -399, + /* 90 */ 276, -408, -368, -415, -49, 498, 494, 329, 383, 481, + /* 100 */ 539, 598, 503, 541, 604, 625, 630, 638, 548, -179, + /* 110 */ 386, -295, 652, 723, 582, 33, 731, 551, 789, 212, + /* 120 */ 843, 998, 1001, 1023, 1, 1037, 1039, 1046, 729, 1048, + /* 130 */ -130, 753, 876, 763, -2, -2, 287, 280, -425, 165, + /* 140 */ -530, -167, 674, 824, 874, 964, 967, 978, 1017, 1065, + /* 150 */ 1107, 1108, 1115, 1120, 1121, 1123, 1124, 1128, 1135, 1136, + /* 160 */ 1140, 47, 128, -73, 685, 650, 867, 866, 128, 479, + /* 170 */ 492, 397, 690, -379, 217, 908, 672, 868, 151, 253, + /* 180 */ 455, 366, 1025, -230, 325, 707, 963, 965, 719, 997, + /* 190 */ -463, 596, 616, 654, 922, 984, 1021, 832, 953, 1075, + /* 200 */ 1028, 1028, 1027, 1068, 1078, 1155, 1276, 1028, 1263, 1263, + /* 210 */ 1284, 1285, 1318, 1251, 1174, 1193, 1254, 1342, 1266, 1263, + /* 220 */ 1356, 1412, 1326, 1421, 1377, 1347, 1369, 1370, 1263, 1294, + /* 230 */ 1295, 1277, 1310, 1296, 1378, 1420, 1366, 1346, 1444, 1363, + /* 240 */ 1362, 1445, 1368, 1446, 1385, 1463, 1464, 1414, 1471, 1417, + /* 250 */ 1422, 1479, 1475, 1480, 1426, 1425, 1431, 1432, 1474, 1482, + /* 260 */ 1489, 1491, 1486, 1493, 1498, 1500, 1509, 1513, 1521, 1518, + /* 270 */ 1435, 1507, 1526, 1494, 1533, 1552, 1483, 1547, 1557, 1554, + /* 280 */ 1501, 1555, 1510, 1560, 1562, 1548, 1550, 1574, 1572, 1586, + /* 290 */ 1549, 1551, 1553, 1556, 1558, 1559, 1561, 1563, 1564, 1566, + /* 300 */ 1567, 1588, 1594, 1596, 1598, 1539, 1568, 1569, 1511, 1512, + /* 310 */ 1519, 1599, 1523, 1527, 1529, 1573, 1601, 1538, 1613, 1576, + /* 320 */ 1473, 1575, 1484, 1577, 1487, 1492, 1488, 1490, 1497, 1502, + /* 330 */ 1579, 1495, 1508, 1504, 1496, 1524, 1646, 1584, 1525, 1532, + /* 340 */ 1655, 1652, 1653, 1600, 1614, 1638, 1639, 1641, 1612, 1643, + /* 350 */ 1627, 1671, 1645, 1640, 1691, 1581, 1656, 1644, 1647, 1705, + /* 360 */ 1680, 1707, 1708, 1661, 1666, 1672, 1674, 1675, 1676, 1679, + /* 370 */ 1682, 1683, 1684, 1685, 1686, 1689, 1690, 1695, 1696, 1709, + /* 380 */ 1711, 1713, 1717, 1721, 1735, 1715, 1738, 1725, 1731, 1730, + /* 390 */ 1737, 1748, 1753, 1755, 1650, 1719, 1660, 1664, 1687, 1746, + /* 400 */ 1723, 1740, 1742, 1758, 1741, 1770, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 10 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 20 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 30 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 40 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 50 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 60 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 70 */ 2302, 2302, 2302, 2685, 2302, 2302, 2641, 2302, 2302, 2302, - /* 80 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 90 */ 2302, 2648, 2648, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 100 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 110 */ 2302, 2302, 2302, 2302, 2412, 2302, 2302, 2302, 2302, 2302, - /* 120 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 130 */ 2302, 2302, 2302, 2410, 2959, 2302, 3087, 2726, 2302, 2302, - /* 140 */ 2988, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 150 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 160 */ 2302, 2302, 2971, 2302, 2302, 2383, 2383, 2302, 2971, 2971, - /* 170 */ 2971, 2931, 2931, 2410, 2302, 2302, 2412, 2302, 2728, 2302, - /* 180 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2555, 2332, - /* 190 */ 2711, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 3017, - /* 200 */ 2963, 2964, 3081, 2302, 3020, 2982, 2302, 2977, 2302, 2302, - /* 210 */ 2302, 2302, 2302, 3007, 2302, 2302, 2302, 2302, 2302, 2302, - /* 220 */ 2653, 2302, 2755, 2302, 2498, 2705, 2302, 2302, 2302, 2302, - /* 230 */ 2302, 3065, 2961, 3001, 2302, 2302, 3011, 2302, 2302, 2302, - /* 240 */ 2743, 2412, 2302, 2412, 2698, 2636, 2302, 2646, 2302, 2646, - /* 250 */ 2643, 2302, 2302, 2302, 2646, 2643, 2643, 2643, 2486, 2482, - /* 260 */ 2302, 2302, 2480, 2302, 2302, 2302, 2302, 2362, 2302, 2362, - /* 270 */ 2302, 2412, 2412, 2302, 2412, 2302, 2302, 2412, 2302, 2412, - /* 280 */ 2302, 2412, 2302, 2412, 2412, 2515, 2515, 2302, 2412, 2302, - /* 290 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 300 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2741, 2721, - /* 310 */ 2302, 2410, 2302, 2709, 2707, 2302, 2410, 3011, 2302, 2302, - /* 320 */ 3035, 3030, 3035, 3030, 3049, 3045, 3035, 3054, 3051, 3013, - /* 330 */ 3011, 2994, 2990, 3084, 3071, 3067, 2302, 2302, 2999, 2997, - /* 340 */ 2302, 2410, 2410, 3030, 2302, 2302, 2302, 2302, 3030, 2302, - /* 350 */ 2302, 2410, 2302, 2302, 2410, 2302, 2302, 2302, 2302, 2410, - /* 360 */ 2302, 2410, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 370 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 380 */ 2302, 2302, 2302, 2302, 2302, 2517, 2302, 2302, 2410, 2302, - /* 390 */ 2334, 2336, 2346, 2302, 2700, 3087, 2726, 2731, 2681, 2681, - /* 400 */ 2558, 2558, 3087, 2558, 2413, 2307, 2302, 2302, 2302, 2302, - /* 410 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 420 */ 2302, 2302, 2860, 2302, 2302, 2302, 2302, 2302, 2302, 3048, - /* 430 */ 3047, 2861, 2302, 2935, 2934, 2933, 2924, 2860, 2511, 2302, - /* 440 */ 2302, 2302, 2859, 2858, 2302, 2302, 2302, 2302, 2302, 2302, - /* 450 */ 2302, 2302, 2302, 2302, 2672, 2671, 2852, 2302, 2302, 2853, - /* 460 */ 2851, 2850, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 470 */ 2302, 2302, 2302, 2502, 2302, 2302, 2499, 2302, 2302, 2302, - /* 480 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 490 */ 2302, 2302, 2302, 2302, 3068, 3072, 2302, 2302, 2302, 2302, - /* 500 */ 2960, 2302, 2302, 2302, 2302, 2302, 2831, 2302, 2302, 2302, - /* 510 */ 2302, 2302, 2799, 2794, 2785, 2776, 2791, 2782, 2770, 2788, - /* 520 */ 2779, 2767, 2764, 2302, 2526, 2302, 2302, 2302, 2302, 2302, - /* 530 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 540 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 550 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 560 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 570 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 580 */ 2642, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 590 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 600 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 610 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 620 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 630 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 640 */ 2302, 2302, 2302, 2302, 2302, 2302, 2657, 2302, 2302, 2302, - /* 650 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 660 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 670 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 680 */ 2302, 2302, 2302, 2302, 2351, 2838, 2302, 2302, 2302, 2302, - /* 690 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2841, - /* 700 */ 2302, 2302, 2842, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 710 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 720 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 730 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 740 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2457, 2456, 2302, - /* 750 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 760 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 770 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2843, 2302, 2302, - /* 780 */ 2302, 2302, 2725, 2302, 2302, 2833, 2302, 2302, 2302, 2302, - /* 790 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 800 */ 2302, 2302, 3064, 3014, 2302, 2302, 2302, 2302, 2302, 2302, - /* 810 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 820 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2831, - /* 830 */ 2302, 3046, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 3062, - /* 840 */ 2302, 3066, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2970, - /* 850 */ 2966, 2302, 2302, 2962, 2302, 2302, 2302, 2302, 2302, 2302, - /* 860 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 870 */ 2302, 2302, 2302, 2302, 2921, 2302, 2302, 2302, 2955, 2302, - /* 880 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2554, 2553, - /* 890 */ 2552, 2551, 2302, 2302, 2302, 2302, 2302, 2302, 2843, 2302, - /* 900 */ 2846, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 910 */ 2302, 2302, 2302, 2302, 2830, 2302, 2898, 2897, 2302, 2302, - /* 920 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2548, 2302, 2302, - /* 930 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 940 */ 2302, 2302, 2302, 2532, 2530, 2529, 2528, 2302, 2565, 2302, - /* 950 */ 2302, 2302, 2561, 2560, 2302, 2302, 2302, 2302, 2302, 2302, - /* 960 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 970 */ 2302, 2302, 2302, 2431, 2302, 2302, 2302, 2302, 2302, 2302, - /* 980 */ 2302, 2302, 2423, 2302, 2422, 2302, 2302, 2302, 2302, 2302, - /* 990 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 1000 */ 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, 2302, - /* 1010 */ 2302, 2302, 2302, 2302, 2302, 2302, 2331, 2302, 2302, 2302, - /* 1020 */ 2302, 2302, 2302, 2302, 2302, + /* 0 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 10 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 20 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 30 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 40 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 50 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 60 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 70 */ 2305, 2305, 2305, 2689, 2305, 2305, 2645, 2305, 2305, 2305, + /* 80 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 90 */ 2305, 2652, 2652, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 100 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 110 */ 2305, 2305, 2305, 2305, 2415, 2305, 2305, 2305, 2305, 2305, + /* 120 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 130 */ 2305, 2305, 2305, 2413, 2963, 2305, 3091, 2730, 2305, 2305, + /* 140 */ 2992, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 150 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 160 */ 2305, 2305, 2975, 2305, 2305, 2386, 2386, 2305, 2975, 2975, + /* 170 */ 2975, 2935, 2935, 2413, 2305, 2305, 2415, 2305, 2732, 2305, + /* 180 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2559, 2335, + /* 190 */ 2715, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 3021, + /* 200 */ 2967, 2968, 3085, 2305, 3024, 2986, 2305, 2981, 2305, 2305, + /* 210 */ 2305, 2305, 2305, 3011, 2305, 2305, 2305, 2305, 2305, 2305, + /* 220 */ 2657, 2305, 2759, 2305, 2502, 2709, 2305, 2305, 2305, 2305, + /* 230 */ 2305, 3069, 2965, 3005, 2305, 2305, 3015, 2305, 2305, 2305, + /* 240 */ 2747, 2415, 2305, 2415, 2702, 2640, 2305, 2650, 2305, 2650, + /* 250 */ 2647, 2305, 2305, 2305, 2650, 2647, 2647, 2647, 2490, 2486, + /* 260 */ 2305, 2305, 2484, 2305, 2305, 2305, 2305, 2365, 2305, 2365, + /* 270 */ 2305, 2415, 2415, 2305, 2415, 2305, 2305, 2415, 2305, 2415, + /* 280 */ 2305, 2415, 2305, 2415, 2415, 2519, 2519, 2305, 2415, 2305, + /* 290 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 300 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2745, 2725, + /* 310 */ 2305, 2413, 2305, 2713, 2711, 2305, 2413, 3015, 2305, 2305, + /* 320 */ 3039, 3034, 3039, 3034, 3053, 3049, 3039, 3058, 3055, 3017, + /* 330 */ 3015, 2998, 2994, 3088, 3075, 3071, 2305, 2305, 3003, 3001, + /* 340 */ 2305, 2413, 2413, 3034, 2305, 2305, 2305, 2305, 3034, 2305, + /* 350 */ 2305, 2413, 2305, 2305, 2413, 2305, 2305, 2305, 2305, 2413, + /* 360 */ 2305, 2413, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 370 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 380 */ 2305, 2305, 2305, 2305, 2305, 2521, 2305, 2305, 2413, 2305, + /* 390 */ 2337, 2339, 2349, 2305, 2704, 3091, 2730, 2735, 2685, 2685, + /* 400 */ 2562, 2562, 3091, 2562, 2416, 2310, 2305, 2305, 2305, 2305, + /* 410 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 420 */ 2305, 2305, 2864, 2305, 2305, 2305, 2305, 2305, 2305, 3052, + /* 430 */ 3051, 2865, 2305, 2939, 2938, 2937, 2928, 2864, 2515, 2305, + /* 440 */ 2305, 2305, 2863, 2862, 2305, 2305, 2305, 2305, 2305, 2305, + /* 450 */ 2305, 2305, 2305, 2305, 2676, 2675, 2856, 2305, 2305, 2857, + /* 460 */ 2855, 2854, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 470 */ 2305, 2305, 2305, 2506, 2305, 2305, 2503, 2305, 2305, 2305, + /* 480 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 490 */ 2305, 2305, 2305, 2305, 3072, 3076, 2305, 2305, 2305, 2305, + /* 500 */ 2964, 2305, 2305, 2305, 2305, 2305, 2835, 2305, 2305, 2305, + /* 510 */ 2305, 2305, 2803, 2798, 2789, 2780, 2795, 2786, 2774, 2792, + /* 520 */ 2783, 2771, 2768, 2305, 2530, 2305, 2305, 2305, 2305, 2305, + /* 530 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 540 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 550 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 560 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 570 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 580 */ 2646, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 590 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 600 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 610 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 620 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 630 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 640 */ 2305, 2305, 2305, 2305, 2305, 2305, 2661, 2305, 2305, 2305, + /* 650 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 660 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 670 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 680 */ 2305, 2305, 2305, 2305, 2354, 2842, 2305, 2305, 2305, 2305, + /* 690 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2845, + /* 700 */ 2305, 2305, 2846, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 710 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 720 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 730 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 740 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2461, 2460, 2305, + /* 750 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 760 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 770 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2847, 2305, 2305, + /* 780 */ 2305, 2305, 2729, 2305, 2305, 2837, 2305, 2305, 2305, 2305, + /* 790 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 800 */ 2305, 2305, 3068, 3018, 2305, 2305, 2305, 2305, 2305, 2305, + /* 810 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 820 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2835, + /* 830 */ 2305, 3050, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 3066, + /* 840 */ 2305, 3070, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2974, + /* 850 */ 2970, 2305, 2305, 2966, 2305, 2305, 2305, 2305, 2305, 2305, + /* 860 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 870 */ 2305, 2305, 2305, 2305, 2925, 2305, 2305, 2305, 2959, 2305, + /* 880 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2558, 2557, + /* 890 */ 2556, 2555, 2305, 2305, 2305, 2305, 2305, 2305, 2847, 2305, + /* 900 */ 2850, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 910 */ 2305, 2305, 2305, 2305, 2834, 2305, 2902, 2901, 2305, 2305, + /* 920 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2552, 2305, 2305, + /* 930 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 940 */ 2305, 2305, 2305, 2536, 2534, 2533, 2532, 2305, 2569, 2305, + /* 950 */ 2305, 2305, 2565, 2564, 2305, 2305, 2305, 2305, 2305, 2305, + /* 960 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 970 */ 2305, 2305, 2305, 2305, 2434, 2305, 2305, 2305, 2305, 2305, + /* 980 */ 2305, 2305, 2305, 2426, 2305, 2425, 2305, 2305, 2305, 2305, + /* 990 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 1000 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2305, + /* 1010 */ 2305, 2305, 2305, 2305, 2305, 2305, 2305, 2334, 2305, 2305, + /* 1020 */ 2305, 2305, 2305, 2305, 2305, 2305, }; /********** End of lemon-generated parsing tables *****************************/ @@ -3079,646 +3079,647 @@ static const char *const yyRuleName[] = { /* 142 */ "db_options ::= db_options S3_COMPACT NK_INTEGER", /* 143 */ "db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER", /* 144 */ "db_options ::= db_options ENCRYPT_ALGORITHM NK_STRING", - /* 145 */ "alter_db_options ::= alter_db_option", - /* 146 */ "alter_db_options ::= alter_db_options alter_db_option", - /* 147 */ "alter_db_option ::= BUFFER NK_INTEGER", - /* 148 */ "alter_db_option ::= CACHEMODEL NK_STRING", - /* 149 */ "alter_db_option ::= CACHESIZE NK_INTEGER", - /* 150 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", - /* 151 */ "alter_db_option ::= KEEP integer_list", - /* 152 */ "alter_db_option ::= KEEP variable_list", - /* 153 */ "alter_db_option ::= PAGES NK_INTEGER", - /* 154 */ "alter_db_option ::= REPLICA NK_INTEGER", - /* 155 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", - /* 156 */ "alter_db_option ::= STT_TRIGGER NK_INTEGER", - /* 157 */ "alter_db_option ::= MINROWS NK_INTEGER", - /* 158 */ "alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER", - /* 159 */ "alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", - /* 160 */ "alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER", - /* 161 */ "alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", - /* 162 */ "alter_db_option ::= S3_KEEPLOCAL NK_INTEGER", - /* 163 */ "alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE", - /* 164 */ "alter_db_option ::= S3_COMPACT NK_INTEGER", - /* 165 */ "alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER", - /* 166 */ "alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING", - /* 167 */ "integer_list ::= NK_INTEGER", - /* 168 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", - /* 169 */ "variable_list ::= NK_VARIABLE", - /* 170 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", - /* 171 */ "retention_list ::= retention", - /* 172 */ "retention_list ::= retention_list NK_COMMA retention", - /* 173 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", - /* 174 */ "retention ::= NK_MINUS NK_COLON NK_VARIABLE", - /* 175 */ "speed_opt ::=", - /* 176 */ "speed_opt ::= BWLIMIT NK_INTEGER", - /* 177 */ "start_opt ::=", - /* 178 */ "start_opt ::= START WITH NK_INTEGER", - /* 179 */ "start_opt ::= START WITH NK_STRING", - /* 180 */ "start_opt ::= START WITH TIMESTAMP NK_STRING", - /* 181 */ "end_opt ::=", - /* 182 */ "end_opt ::= END WITH NK_INTEGER", - /* 183 */ "end_opt ::= END WITH NK_STRING", - /* 184 */ "end_opt ::= END WITH TIMESTAMP NK_STRING", - /* 185 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", - /* 186 */ "cmd ::= CREATE TABLE multi_create_clause", - /* 187 */ "cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING", - /* 188 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", - /* 189 */ "cmd ::= DROP TABLE with_opt multi_drop_clause", - /* 190 */ "cmd ::= DROP STABLE with_opt exists_opt full_table_name", - /* 191 */ "cmd ::= ALTER TABLE alter_table_clause", - /* 192 */ "cmd ::= ALTER STABLE alter_table_clause", - /* 193 */ "alter_table_clause ::= full_table_name alter_table_options", - /* 194 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options", - /* 195 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", - /* 196 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", - /* 197 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options", - /* 198 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", - /* 199 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", - /* 200 */ "alter_table_clause ::= full_table_name DROP TAG column_name", - /* 201 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", - /* 202 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", - /* 203 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal", - /* 204 */ "multi_create_clause ::= create_subtable_clause", - /* 205 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", - /* 206 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options", - /* 207 */ "multi_drop_clause ::= drop_table_clause", - /* 208 */ "multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause", - /* 209 */ "drop_table_clause ::= exists_opt full_table_name", - /* 210 */ "with_opt ::=", - /* 211 */ "with_opt ::= WITH", - /* 212 */ "specific_cols_opt ::=", - /* 213 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", - /* 214 */ "full_table_name ::= table_name", - /* 215 */ "full_table_name ::= db_name NK_DOT table_name", - /* 216 */ "tag_def_list ::= tag_def", - /* 217 */ "tag_def_list ::= tag_def_list NK_COMMA tag_def", - /* 218 */ "tag_def ::= column_name type_name", - /* 219 */ "column_def_list ::= column_def", - /* 220 */ "column_def_list ::= column_def_list NK_COMMA column_def", - /* 221 */ "column_def ::= column_name type_name column_options", - /* 222 */ "type_name ::= BOOL", - /* 223 */ "type_name ::= TINYINT", - /* 224 */ "type_name ::= SMALLINT", - /* 225 */ "type_name ::= INT", - /* 226 */ "type_name ::= INTEGER", - /* 227 */ "type_name ::= BIGINT", - /* 228 */ "type_name ::= FLOAT", - /* 229 */ "type_name ::= DOUBLE", - /* 230 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", - /* 231 */ "type_name ::= TIMESTAMP", - /* 232 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", - /* 233 */ "type_name ::= TINYINT UNSIGNED", - /* 234 */ "type_name ::= SMALLINT UNSIGNED", - /* 235 */ "type_name ::= INT UNSIGNED", - /* 236 */ "type_name ::= BIGINT UNSIGNED", - /* 237 */ "type_name ::= JSON", - /* 238 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", - /* 239 */ "type_name ::= MEDIUMBLOB", - /* 240 */ "type_name ::= BLOB", - /* 241 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", - /* 242 */ "type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP", - /* 243 */ "type_name ::= DECIMAL", - /* 244 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", - /* 245 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 246 */ "type_name_default_len ::= BINARY", - /* 247 */ "type_name_default_len ::= NCHAR", - /* 248 */ "type_name_default_len ::= VARCHAR", - /* 249 */ "type_name_default_len ::= VARBINARY", - /* 250 */ "tags_def_opt ::=", - /* 251 */ "tags_def_opt ::= tags_def", - /* 252 */ "tags_def ::= TAGS NK_LP tag_def_list NK_RP", - /* 253 */ "table_options ::=", - /* 254 */ "table_options ::= table_options COMMENT NK_STRING", - /* 255 */ "table_options ::= table_options MAX_DELAY duration_list", - /* 256 */ "table_options ::= table_options WATERMARK duration_list", - /* 257 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", - /* 258 */ "table_options ::= table_options TTL NK_INTEGER", - /* 259 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", - /* 260 */ "table_options ::= table_options DELETE_MARK duration_list", - /* 261 */ "alter_table_options ::= alter_table_option", - /* 262 */ "alter_table_options ::= alter_table_options alter_table_option", - /* 263 */ "alter_table_option ::= COMMENT NK_STRING", - /* 264 */ "alter_table_option ::= TTL NK_INTEGER", - /* 265 */ "duration_list ::= duration_literal", - /* 266 */ "duration_list ::= duration_list NK_COMMA duration_literal", - /* 267 */ "rollup_func_list ::= rollup_func_name", - /* 268 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", - /* 269 */ "rollup_func_name ::= function_name", - /* 270 */ "rollup_func_name ::= FIRST", - /* 271 */ "rollup_func_name ::= LAST", - /* 272 */ "col_name_list ::= col_name", - /* 273 */ "col_name_list ::= col_name_list NK_COMMA col_name", - /* 274 */ "col_name ::= column_name", - /* 275 */ "cmd ::= SHOW DNODES", - /* 276 */ "cmd ::= SHOW USERS", - /* 277 */ "cmd ::= SHOW USERS FULL", - /* 278 */ "cmd ::= SHOW USER PRIVILEGES", - /* 279 */ "cmd ::= SHOW db_kind_opt DATABASES", - /* 280 */ "cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt", - /* 281 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", - /* 282 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", - /* 283 */ "cmd ::= SHOW MNODES", - /* 284 */ "cmd ::= SHOW QNODES", - /* 285 */ "cmd ::= SHOW ANODES", - /* 286 */ "cmd ::= SHOW ANODES FULL", - /* 287 */ "cmd ::= SHOW ARBGROUPS", - /* 288 */ "cmd ::= SHOW FUNCTIONS", - /* 289 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", - /* 290 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name", - /* 291 */ "cmd ::= SHOW STREAMS", - /* 292 */ "cmd ::= SHOW ACCOUNTS", - /* 293 */ "cmd ::= SHOW APPS", - /* 294 */ "cmd ::= SHOW CONNECTIONS", - /* 295 */ "cmd ::= SHOW LICENCES", - /* 296 */ "cmd ::= SHOW GRANTS", - /* 297 */ "cmd ::= SHOW GRANTS FULL", - /* 298 */ "cmd ::= SHOW GRANTS LOGS", - /* 299 */ "cmd ::= SHOW CLUSTER MACHINES", - /* 300 */ "cmd ::= SHOW CREATE DATABASE db_name", - /* 301 */ "cmd ::= SHOW CREATE TABLE full_table_name", - /* 302 */ "cmd ::= SHOW CREATE STABLE full_table_name", - /* 303 */ "cmd ::= SHOW ENCRYPTIONS", - /* 304 */ "cmd ::= SHOW QUERIES", - /* 305 */ "cmd ::= SHOW SCORES", - /* 306 */ "cmd ::= SHOW TOPICS", - /* 307 */ "cmd ::= SHOW VARIABLES", - /* 308 */ "cmd ::= SHOW CLUSTER VARIABLES", - /* 309 */ "cmd ::= SHOW LOCAL VARIABLES", - /* 310 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", - /* 311 */ "cmd ::= SHOW BNODES", - /* 312 */ "cmd ::= SHOW SNODES", - /* 313 */ "cmd ::= SHOW CLUSTER", - /* 314 */ "cmd ::= SHOW TRANSACTIONS", - /* 315 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", - /* 316 */ "cmd ::= SHOW CONSUMERS", - /* 317 */ "cmd ::= SHOW SUBSCRIPTIONS", - /* 318 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", - /* 319 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name", - /* 320 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", - /* 321 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name", - /* 322 */ "cmd ::= SHOW VNODES ON DNODE NK_INTEGER", - /* 323 */ "cmd ::= SHOW VNODES", - /* 324 */ "cmd ::= SHOW db_name_cond_opt ALIVE", - /* 325 */ "cmd ::= SHOW CLUSTER ALIVE", - /* 326 */ "cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt", - /* 327 */ "cmd ::= SHOW CREATE VIEW full_table_name", - /* 328 */ "cmd ::= SHOW COMPACTS", - /* 329 */ "cmd ::= SHOW COMPACT NK_INTEGER", - /* 330 */ "table_kind_db_name_cond_opt ::=", - /* 331 */ "table_kind_db_name_cond_opt ::= table_kind", - /* 332 */ "table_kind_db_name_cond_opt ::= db_name NK_DOT", - /* 333 */ "table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT", - /* 334 */ "table_kind ::= NORMAL", - /* 335 */ "table_kind ::= CHILD", - /* 336 */ "db_name_cond_opt ::=", - /* 337 */ "db_name_cond_opt ::= db_name NK_DOT", - /* 338 */ "like_pattern_opt ::=", - /* 339 */ "like_pattern_opt ::= LIKE NK_STRING", - /* 340 */ "table_name_cond ::= table_name", - /* 341 */ "from_db_opt ::=", - /* 342 */ "from_db_opt ::= FROM db_name", - /* 343 */ "tag_list_opt ::=", - /* 344 */ "tag_list_opt ::= tag_item", - /* 345 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", - /* 346 */ "tag_item ::= TBNAME", - /* 347 */ "tag_item ::= QTAGS", - /* 348 */ "tag_item ::= column_name", - /* 349 */ "tag_item ::= column_name column_alias", - /* 350 */ "tag_item ::= column_name AS column_alias", - /* 351 */ "db_kind_opt ::=", - /* 352 */ "db_kind_opt ::= USER", - /* 353 */ "db_kind_opt ::= SYSTEM", - /* 354 */ "cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP", - /* 355 */ "cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP", - /* 356 */ "cmd ::= DROP TSMA exists_opt full_tsma_name", - /* 357 */ "cmd ::= SHOW db_name_cond_opt TSMAS", - /* 358 */ "full_tsma_name ::= tsma_name", - /* 359 */ "full_tsma_name ::= db_name NK_DOT tsma_name", - /* 360 */ "tsma_func_list ::= FUNCTION NK_LP func_list NK_RP", - /* 361 */ "cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options", - /* 362 */ "cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP", - /* 363 */ "cmd ::= DROP INDEX exists_opt full_index_name", - /* 364 */ "full_index_name ::= index_name", - /* 365 */ "full_index_name ::= db_name NK_DOT index_name", - /* 366 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", - /* 367 */ "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", - /* 368 */ "func_list ::= func", - /* 369 */ "func_list ::= func_list NK_COMMA func", - /* 370 */ "func ::= sma_func_name NK_LP expression_list NK_RP", - /* 371 */ "sma_func_name ::= function_name", - /* 372 */ "sma_func_name ::= COUNT", - /* 373 */ "sma_func_name ::= FIRST", - /* 374 */ "sma_func_name ::= LAST", - /* 375 */ "sma_func_name ::= LAST_ROW", - /* 376 */ "sma_stream_opt ::=", - /* 377 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", - /* 378 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", - /* 379 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", - /* 380 */ "with_meta ::= AS", - /* 381 */ "with_meta ::= WITH META AS", - /* 382 */ "with_meta ::= ONLY META AS", - /* 383 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", - /* 384 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name", - /* 385 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt", - /* 386 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 387 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", - /* 388 */ "cmd ::= DESC full_table_name", - /* 389 */ "cmd ::= DESCRIBE full_table_name", - /* 390 */ "cmd ::= RESET QUERY CACHE", - /* 391 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", - /* 392 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", - /* 393 */ "analyze_opt ::=", - /* 394 */ "analyze_opt ::= ANALYZE", - /* 395 */ "explain_options ::=", - /* 396 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 397 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 398 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt", - /* 399 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 400 */ "agg_func_opt ::=", - /* 401 */ "agg_func_opt ::= AGGREGATE", - /* 402 */ "bufsize_opt ::=", - /* 403 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 404 */ "language_opt ::=", - /* 405 */ "language_opt ::= LANGUAGE NK_STRING", - /* 406 */ "or_replace_opt ::=", - /* 407 */ "or_replace_opt ::= OR REPLACE", - /* 408 */ "cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery", - /* 409 */ "cmd ::= DROP VIEW exists_opt full_view_name", - /* 410 */ "full_view_name ::= view_name", - /* 411 */ "full_view_name ::= db_name NK_DOT view_name", - /* 412 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery", - /* 413 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 414 */ "cmd ::= PAUSE STREAM exists_opt stream_name", - /* 415 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name", - /* 416 */ "col_list_opt ::=", - /* 417 */ "col_list_opt ::= NK_LP column_stream_def_list NK_RP", - /* 418 */ "column_stream_def_list ::= column_stream_def", - /* 419 */ "column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def", - /* 420 */ "column_stream_def ::= column_name stream_col_options", - /* 421 */ "stream_col_options ::=", - /* 422 */ "stream_col_options ::= stream_col_options PRIMARY KEY", - /* 423 */ "tag_def_or_ref_opt ::=", - /* 424 */ "tag_def_or_ref_opt ::= tags_def", - /* 425 */ "tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP", - /* 426 */ "stream_options ::=", - /* 427 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 428 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 429 */ "stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE", - /* 430 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", - /* 431 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 432 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", - /* 433 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", - /* 434 */ "stream_options ::= stream_options DELETE_MARK duration_literal", - /* 435 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER", - /* 436 */ "subtable_opt ::=", - /* 437 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", - /* 438 */ "ignore_opt ::=", - /* 439 */ "ignore_opt ::= IGNORE UNTREATED", - /* 440 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 441 */ "cmd ::= KILL QUERY NK_STRING", - /* 442 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 443 */ "cmd ::= KILL COMPACT NK_INTEGER", - /* 444 */ "cmd ::= BALANCE VGROUP", - /* 445 */ "cmd ::= BALANCE VGROUP LEADER on_vgroup_id", - /* 446 */ "cmd ::= BALANCE VGROUP LEADER DATABASE db_name", - /* 447 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 448 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 449 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 450 */ "on_vgroup_id ::=", - /* 451 */ "on_vgroup_id ::= ON NK_INTEGER", - /* 452 */ "dnode_list ::= DNODE NK_INTEGER", - /* 453 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 454 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", - /* 455 */ "cmd ::= query_or_subquery", - /* 456 */ "cmd ::= insert_query", - /* 457 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", - /* 458 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", - /* 459 */ "tags_literal ::= NK_INTEGER", - /* 460 */ "tags_literal ::= NK_INTEGER NK_PLUS duration_literal", - /* 461 */ "tags_literal ::= NK_INTEGER NK_MINUS duration_literal", - /* 462 */ "tags_literal ::= NK_PLUS NK_INTEGER", - /* 463 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal", - /* 464 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal", - /* 465 */ "tags_literal ::= NK_MINUS NK_INTEGER", - /* 466 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal", - /* 467 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal", - /* 468 */ "tags_literal ::= NK_FLOAT", - /* 469 */ "tags_literal ::= NK_PLUS NK_FLOAT", - /* 470 */ "tags_literal ::= NK_MINUS NK_FLOAT", - /* 471 */ "tags_literal ::= NK_BIN", - /* 472 */ "tags_literal ::= NK_BIN NK_PLUS duration_literal", - /* 473 */ "tags_literal ::= NK_BIN NK_MINUS duration_literal", - /* 474 */ "tags_literal ::= NK_PLUS NK_BIN", - /* 475 */ "tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal", - /* 476 */ "tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal", - /* 477 */ "tags_literal ::= NK_MINUS NK_BIN", - /* 478 */ "tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal", - /* 479 */ "tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal", - /* 480 */ "tags_literal ::= NK_HEX", - /* 481 */ "tags_literal ::= NK_HEX NK_PLUS duration_literal", - /* 482 */ "tags_literal ::= NK_HEX NK_MINUS duration_literal", - /* 483 */ "tags_literal ::= NK_PLUS NK_HEX", - /* 484 */ "tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal", - /* 485 */ "tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal", - /* 486 */ "tags_literal ::= NK_MINUS NK_HEX", - /* 487 */ "tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal", - /* 488 */ "tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal", - /* 489 */ "tags_literal ::= NK_STRING", - /* 490 */ "tags_literal ::= NK_STRING NK_PLUS duration_literal", - /* 491 */ "tags_literal ::= NK_STRING NK_MINUS duration_literal", - /* 492 */ "tags_literal ::= NK_BOOL", - /* 493 */ "tags_literal ::= NULL", - /* 494 */ "tags_literal ::= literal_func", - /* 495 */ "tags_literal ::= literal_func NK_PLUS duration_literal", - /* 496 */ "tags_literal ::= literal_func NK_MINUS duration_literal", - /* 497 */ "tags_literal_list ::= tags_literal", - /* 498 */ "tags_literal_list ::= tags_literal_list NK_COMMA tags_literal", - /* 499 */ "literal ::= NK_INTEGER", - /* 500 */ "literal ::= NK_FLOAT", - /* 501 */ "literal ::= NK_STRING", - /* 502 */ "literal ::= NK_BOOL", - /* 503 */ "literal ::= TIMESTAMP NK_STRING", - /* 504 */ "literal ::= duration_literal", - /* 505 */ "literal ::= NULL", - /* 506 */ "literal ::= NK_QUESTION", - /* 507 */ "duration_literal ::= NK_VARIABLE", - /* 508 */ "signed ::= NK_INTEGER", - /* 509 */ "signed ::= NK_PLUS NK_INTEGER", - /* 510 */ "signed ::= NK_MINUS NK_INTEGER", - /* 511 */ "signed ::= NK_FLOAT", - /* 512 */ "signed ::= NK_PLUS NK_FLOAT", - /* 513 */ "signed ::= NK_MINUS NK_FLOAT", - /* 514 */ "signed_literal ::= signed", - /* 515 */ "signed_literal ::= NK_STRING", - /* 516 */ "signed_literal ::= NK_BOOL", - /* 517 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 518 */ "signed_literal ::= duration_literal", - /* 519 */ "signed_literal ::= NULL", - /* 520 */ "signed_literal ::= literal_func", - /* 521 */ "signed_literal ::= NK_QUESTION", - /* 522 */ "literal_list ::= signed_literal", - /* 523 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 524 */ "db_name ::= NK_ID", - /* 525 */ "table_name ::= NK_ID", - /* 526 */ "column_name ::= NK_ID", - /* 527 */ "function_name ::= NK_ID", - /* 528 */ "view_name ::= NK_ID", - /* 529 */ "table_alias ::= NK_ID", - /* 530 */ "column_alias ::= NK_ID", - /* 531 */ "column_alias ::= NK_ALIAS", - /* 532 */ "user_name ::= NK_ID", - /* 533 */ "topic_name ::= NK_ID", - /* 534 */ "stream_name ::= NK_ID", - /* 535 */ "cgroup_name ::= NK_ID", - /* 536 */ "index_name ::= NK_ID", - /* 537 */ "tsma_name ::= NK_ID", - /* 538 */ "expr_or_subquery ::= expression", - /* 539 */ "expression ::= literal", - /* 540 */ "expression ::= pseudo_column", - /* 541 */ "expression ::= column_reference", - /* 542 */ "expression ::= function_expression", - /* 543 */ "expression ::= case_when_expression", - /* 544 */ "expression ::= NK_LP expression NK_RP", - /* 545 */ "expression ::= NK_PLUS expr_or_subquery", - /* 546 */ "expression ::= NK_MINUS expr_or_subquery", - /* 547 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", - /* 548 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", - /* 549 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", - /* 550 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", - /* 551 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", - /* 552 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 553 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", - /* 554 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", - /* 555 */ "expression_list ::= expr_or_subquery", - /* 556 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", - /* 557 */ "column_reference ::= column_name", - /* 558 */ "column_reference ::= table_name NK_DOT column_name", - /* 559 */ "column_reference ::= NK_ALIAS", - /* 560 */ "column_reference ::= table_name NK_DOT NK_ALIAS", - /* 561 */ "pseudo_column ::= ROWTS", - /* 562 */ "pseudo_column ::= TBNAME", - /* 563 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 564 */ "pseudo_column ::= QSTART", - /* 565 */ "pseudo_column ::= QEND", - /* 566 */ "pseudo_column ::= QDURATION", - /* 567 */ "pseudo_column ::= WSTART", - /* 568 */ "pseudo_column ::= WEND", - /* 569 */ "pseudo_column ::= WDURATION", - /* 570 */ "pseudo_column ::= IROWTS", - /* 571 */ "pseudo_column ::= ISFILLED", - /* 572 */ "pseudo_column ::= QTAGS", - /* 573 */ "pseudo_column ::= FLOW", - /* 574 */ "pseudo_column ::= FHIGH", - /* 575 */ "pseudo_column ::= FROWTS", - /* 576 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 577 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 578 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", - /* 579 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP", - /* 580 */ "function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP", - /* 581 */ "function_expression ::= TRIM NK_LP expr_or_subquery NK_RP", - /* 582 */ "function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP", - /* 583 */ "function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP", - /* 584 */ "function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP", - /* 585 */ "function_expression ::= substr_func NK_LP expression_list NK_RP", - /* 586 */ "function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP", - /* 587 */ "function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP", - /* 588 */ "function_expression ::= REPLACE NK_LP expression_list NK_RP", - /* 589 */ "function_expression ::= literal_func", - /* 590 */ "function_expression ::= rand_func", - /* 591 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 592 */ "literal_func ::= NOW", - /* 593 */ "literal_func ::= TODAY", - /* 594 */ "rand_func ::= RAND NK_LP NK_RP", - /* 595 */ "rand_func ::= RAND NK_LP expression_list NK_RP", - /* 596 */ "substr_func ::= SUBSTR", - /* 597 */ "substr_func ::= SUBSTRING", - /* 598 */ "trim_specification_type ::= BOTH", - /* 599 */ "trim_specification_type ::= TRAILING", - /* 600 */ "trim_specification_type ::= LEADING", - /* 601 */ "noarg_func ::= NOW", - /* 602 */ "noarg_func ::= TODAY", - /* 603 */ "noarg_func ::= TIMEZONE", - /* 604 */ "noarg_func ::= DATABASE", - /* 605 */ "noarg_func ::= CLIENT_VERSION", - /* 606 */ "noarg_func ::= SERVER_VERSION", - /* 607 */ "noarg_func ::= SERVER_STATUS", - /* 608 */ "noarg_func ::= CURRENT_USER", - /* 609 */ "noarg_func ::= USER", - /* 610 */ "noarg_func ::= PI", - /* 611 */ "star_func ::= COUNT", - /* 612 */ "star_func ::= FIRST", - /* 613 */ "star_func ::= LAST", - /* 614 */ "star_func ::= LAST_ROW", - /* 615 */ "star_func_para_list ::= NK_STAR", - /* 616 */ "star_func_para_list ::= other_para_list", - /* 617 */ "other_para_list ::= star_func_para", - /* 618 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 619 */ "star_func_para ::= expr_or_subquery", - /* 620 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 621 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", - /* 622 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", - /* 623 */ "when_then_list ::= when_then_expr", - /* 624 */ "when_then_list ::= when_then_list when_then_expr", - /* 625 */ "when_then_expr ::= WHEN common_expression THEN common_expression", - /* 626 */ "case_when_else_opt ::=", - /* 627 */ "case_when_else_opt ::= ELSE common_expression", - /* 628 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", - /* 629 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", - /* 630 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", - /* 631 */ "predicate ::= expr_or_subquery IS NULL", - /* 632 */ "predicate ::= expr_or_subquery IS NOT NULL", - /* 633 */ "predicate ::= expr_or_subquery in_op in_predicate_value", - /* 634 */ "compare_op ::= NK_LT", - /* 635 */ "compare_op ::= NK_GT", - /* 636 */ "compare_op ::= NK_LE", - /* 637 */ "compare_op ::= NK_GE", - /* 638 */ "compare_op ::= NK_NE", - /* 639 */ "compare_op ::= NK_EQ", - /* 640 */ "compare_op ::= LIKE", - /* 641 */ "compare_op ::= NOT LIKE", - /* 642 */ "compare_op ::= MATCH", - /* 643 */ "compare_op ::= NMATCH", - /* 644 */ "compare_op ::= CONTAINS", - /* 645 */ "in_op ::= IN", - /* 646 */ "in_op ::= NOT IN", - /* 647 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 648 */ "boolean_value_expression ::= boolean_primary", - /* 649 */ "boolean_value_expression ::= NOT boolean_primary", - /* 650 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 651 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 652 */ "boolean_primary ::= predicate", - /* 653 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 654 */ "common_expression ::= expr_or_subquery", - /* 655 */ "common_expression ::= boolean_value_expression", - /* 656 */ "from_clause_opt ::=", - /* 657 */ "from_clause_opt ::= FROM table_reference_list", - /* 658 */ "table_reference_list ::= table_reference", - /* 659 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 660 */ "table_reference ::= table_primary", - /* 661 */ "table_reference ::= joined_table", - /* 662 */ "table_primary ::= table_name alias_opt", - /* 663 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 664 */ "table_primary ::= subquery alias_opt", - /* 665 */ "table_primary ::= parenthesized_joined_table", - /* 666 */ "alias_opt ::=", - /* 667 */ "alias_opt ::= table_alias", - /* 668 */ "alias_opt ::= AS table_alias", - /* 669 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 670 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 671 */ "joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt", - /* 672 */ "join_type ::=", - /* 673 */ "join_type ::= INNER", - /* 674 */ "join_type ::= LEFT", - /* 675 */ "join_type ::= RIGHT", - /* 676 */ "join_type ::= FULL", - /* 677 */ "join_subtype ::=", - /* 678 */ "join_subtype ::= OUTER", - /* 679 */ "join_subtype ::= SEMI", - /* 680 */ "join_subtype ::= ANTI", - /* 681 */ "join_subtype ::= ASOF", - /* 682 */ "join_subtype ::= WINDOW", - /* 683 */ "join_on_clause_opt ::=", - /* 684 */ "join_on_clause_opt ::= ON search_condition", - /* 685 */ "window_offset_clause_opt ::=", - /* 686 */ "window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP", - /* 687 */ "window_offset_literal ::= NK_VARIABLE", - /* 688 */ "window_offset_literal ::= NK_MINUS NK_VARIABLE", - /* 689 */ "jlimit_clause_opt ::=", - /* 690 */ "jlimit_clause_opt ::= JLIMIT NK_INTEGER", - /* 691 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", - /* 692 */ "hint_list ::=", - /* 693 */ "hint_list ::= NK_HINT", - /* 694 */ "tag_mode_opt ::=", - /* 695 */ "tag_mode_opt ::= TAGS", - /* 696 */ "set_quantifier_opt ::=", - /* 697 */ "set_quantifier_opt ::= DISTINCT", - /* 698 */ "set_quantifier_opt ::= ALL", - /* 699 */ "select_list ::= select_item", - /* 700 */ "select_list ::= select_list NK_COMMA select_item", - /* 701 */ "select_item ::= NK_STAR", - /* 702 */ "select_item ::= common_expression", - /* 703 */ "select_item ::= common_expression column_alias", - /* 704 */ "select_item ::= common_expression AS column_alias", - /* 705 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 706 */ "where_clause_opt ::=", - /* 707 */ "where_clause_opt ::= WHERE search_condition", - /* 708 */ "partition_by_clause_opt ::=", - /* 709 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 710 */ "partition_list ::= partition_item", - /* 711 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 712 */ "partition_item ::= expr_or_subquery", - /* 713 */ "partition_item ::= expr_or_subquery column_alias", - /* 714 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 715 */ "twindow_clause_opt ::=", - /* 716 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", - /* 717 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 718 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 719 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 720 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 721 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", - /* 722 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 723 */ "twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP", - /* 724 */ "twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP", - /* 725 */ "sliding_opt ::=", - /* 726 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", - /* 727 */ "interval_sliding_duration_literal ::= NK_VARIABLE", - /* 728 */ "interval_sliding_duration_literal ::= NK_STRING", - /* 729 */ "interval_sliding_duration_literal ::= NK_INTEGER", - /* 730 */ "fill_opt ::=", - /* 731 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 732 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", - /* 733 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", - /* 734 */ "fill_mode ::= NONE", - /* 735 */ "fill_mode ::= PREV", - /* 736 */ "fill_mode ::= NULL", - /* 737 */ "fill_mode ::= NULL_F", - /* 738 */ "fill_mode ::= LINEAR", - /* 739 */ "fill_mode ::= NEXT", - /* 740 */ "group_by_clause_opt ::=", - /* 741 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 742 */ "group_by_list ::= expr_or_subquery", - /* 743 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 744 */ "having_clause_opt ::=", - /* 745 */ "having_clause_opt ::= HAVING search_condition", - /* 746 */ "range_opt ::=", - /* 747 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 748 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", - /* 749 */ "every_opt ::=", - /* 750 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 751 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 752 */ "query_simple ::= query_specification", - /* 753 */ "query_simple ::= union_query_expression", - /* 754 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 755 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 756 */ "query_simple_or_subquery ::= query_simple", - /* 757 */ "query_simple_or_subquery ::= subquery", - /* 758 */ "query_or_subquery ::= query_expression", - /* 759 */ "query_or_subquery ::= subquery", - /* 760 */ "order_by_clause_opt ::=", - /* 761 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 762 */ "slimit_clause_opt ::=", - /* 763 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 764 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 765 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 766 */ "limit_clause_opt ::=", - /* 767 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 768 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 769 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 770 */ "subquery ::= NK_LP query_expression NK_RP", - /* 771 */ "subquery ::= NK_LP subquery NK_RP", - /* 772 */ "search_condition ::= common_expression", - /* 773 */ "sort_specification_list ::= sort_specification", - /* 774 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 775 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 776 */ "ordering_specification_opt ::=", - /* 777 */ "ordering_specification_opt ::= ASC", - /* 778 */ "ordering_specification_opt ::= DESC", - /* 779 */ "null_ordering_opt ::=", - /* 780 */ "null_ordering_opt ::= NULLS FIRST", - /* 781 */ "null_ordering_opt ::= NULLS LAST", - /* 782 */ "column_options ::=", - /* 783 */ "column_options ::= column_options PRIMARY KEY", - /* 784 */ "column_options ::= column_options NK_ID NK_STRING", + /* 145 */ "db_options ::= db_options DNODES NK_STRING", + /* 146 */ "alter_db_options ::= alter_db_option", + /* 147 */ "alter_db_options ::= alter_db_options alter_db_option", + /* 148 */ "alter_db_option ::= BUFFER NK_INTEGER", + /* 149 */ "alter_db_option ::= CACHEMODEL NK_STRING", + /* 150 */ "alter_db_option ::= CACHESIZE NK_INTEGER", + /* 151 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", + /* 152 */ "alter_db_option ::= KEEP integer_list", + /* 153 */ "alter_db_option ::= KEEP variable_list", + /* 154 */ "alter_db_option ::= PAGES NK_INTEGER", + /* 155 */ "alter_db_option ::= REPLICA NK_INTEGER", + /* 156 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", + /* 157 */ "alter_db_option ::= STT_TRIGGER NK_INTEGER", + /* 158 */ "alter_db_option ::= MINROWS NK_INTEGER", + /* 159 */ "alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER", + /* 160 */ "alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", + /* 161 */ "alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER", + /* 162 */ "alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", + /* 163 */ "alter_db_option ::= S3_KEEPLOCAL NK_INTEGER", + /* 164 */ "alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE", + /* 165 */ "alter_db_option ::= S3_COMPACT NK_INTEGER", + /* 166 */ "alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER", + /* 167 */ "alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING", + /* 168 */ "integer_list ::= NK_INTEGER", + /* 169 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", + /* 170 */ "variable_list ::= NK_VARIABLE", + /* 171 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", + /* 172 */ "retention_list ::= retention", + /* 173 */ "retention_list ::= retention_list NK_COMMA retention", + /* 174 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", + /* 175 */ "retention ::= NK_MINUS NK_COLON NK_VARIABLE", + /* 176 */ "speed_opt ::=", + /* 177 */ "speed_opt ::= BWLIMIT NK_INTEGER", + /* 178 */ "start_opt ::=", + /* 179 */ "start_opt ::= START WITH NK_INTEGER", + /* 180 */ "start_opt ::= START WITH NK_STRING", + /* 181 */ "start_opt ::= START WITH TIMESTAMP NK_STRING", + /* 182 */ "end_opt ::=", + /* 183 */ "end_opt ::= END WITH NK_INTEGER", + /* 184 */ "end_opt ::= END WITH NK_STRING", + /* 185 */ "end_opt ::= END WITH TIMESTAMP NK_STRING", + /* 186 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", + /* 187 */ "cmd ::= CREATE TABLE multi_create_clause", + /* 188 */ "cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING", + /* 189 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", + /* 190 */ "cmd ::= DROP TABLE with_opt multi_drop_clause", + /* 191 */ "cmd ::= DROP STABLE with_opt exists_opt full_table_name", + /* 192 */ "cmd ::= ALTER TABLE alter_table_clause", + /* 193 */ "cmd ::= ALTER STABLE alter_table_clause", + /* 194 */ "alter_table_clause ::= full_table_name alter_table_options", + /* 195 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options", + /* 196 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", + /* 197 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", + /* 198 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options", + /* 199 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", + /* 200 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", + /* 201 */ "alter_table_clause ::= full_table_name DROP TAG column_name", + /* 202 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", + /* 203 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", + /* 204 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal", + /* 205 */ "multi_create_clause ::= create_subtable_clause", + /* 206 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", + /* 207 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options", + /* 208 */ "multi_drop_clause ::= drop_table_clause", + /* 209 */ "multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause", + /* 210 */ "drop_table_clause ::= exists_opt full_table_name", + /* 211 */ "with_opt ::=", + /* 212 */ "with_opt ::= WITH", + /* 213 */ "specific_cols_opt ::=", + /* 214 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", + /* 215 */ "full_table_name ::= table_name", + /* 216 */ "full_table_name ::= db_name NK_DOT table_name", + /* 217 */ "tag_def_list ::= tag_def", + /* 218 */ "tag_def_list ::= tag_def_list NK_COMMA tag_def", + /* 219 */ "tag_def ::= column_name type_name", + /* 220 */ "column_def_list ::= column_def", + /* 221 */ "column_def_list ::= column_def_list NK_COMMA column_def", + /* 222 */ "column_def ::= column_name type_name column_options", + /* 223 */ "type_name ::= BOOL", + /* 224 */ "type_name ::= TINYINT", + /* 225 */ "type_name ::= SMALLINT", + /* 226 */ "type_name ::= INT", + /* 227 */ "type_name ::= INTEGER", + /* 228 */ "type_name ::= BIGINT", + /* 229 */ "type_name ::= FLOAT", + /* 230 */ "type_name ::= DOUBLE", + /* 231 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", + /* 232 */ "type_name ::= TIMESTAMP", + /* 233 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", + /* 234 */ "type_name ::= TINYINT UNSIGNED", + /* 235 */ "type_name ::= SMALLINT UNSIGNED", + /* 236 */ "type_name ::= INT UNSIGNED", + /* 237 */ "type_name ::= BIGINT UNSIGNED", + /* 238 */ "type_name ::= JSON", + /* 239 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", + /* 240 */ "type_name ::= MEDIUMBLOB", + /* 241 */ "type_name ::= BLOB", + /* 242 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", + /* 243 */ "type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP", + /* 244 */ "type_name ::= DECIMAL", + /* 245 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", + /* 246 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 247 */ "type_name_default_len ::= BINARY", + /* 248 */ "type_name_default_len ::= NCHAR", + /* 249 */ "type_name_default_len ::= VARCHAR", + /* 250 */ "type_name_default_len ::= VARBINARY", + /* 251 */ "tags_def_opt ::=", + /* 252 */ "tags_def_opt ::= tags_def", + /* 253 */ "tags_def ::= TAGS NK_LP tag_def_list NK_RP", + /* 254 */ "table_options ::=", + /* 255 */ "table_options ::= table_options COMMENT NK_STRING", + /* 256 */ "table_options ::= table_options MAX_DELAY duration_list", + /* 257 */ "table_options ::= table_options WATERMARK duration_list", + /* 258 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", + /* 259 */ "table_options ::= table_options TTL NK_INTEGER", + /* 260 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", + /* 261 */ "table_options ::= table_options DELETE_MARK duration_list", + /* 262 */ "alter_table_options ::= alter_table_option", + /* 263 */ "alter_table_options ::= alter_table_options alter_table_option", + /* 264 */ "alter_table_option ::= COMMENT NK_STRING", + /* 265 */ "alter_table_option ::= TTL NK_INTEGER", + /* 266 */ "duration_list ::= duration_literal", + /* 267 */ "duration_list ::= duration_list NK_COMMA duration_literal", + /* 268 */ "rollup_func_list ::= rollup_func_name", + /* 269 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", + /* 270 */ "rollup_func_name ::= function_name", + /* 271 */ "rollup_func_name ::= FIRST", + /* 272 */ "rollup_func_name ::= LAST", + /* 273 */ "col_name_list ::= col_name", + /* 274 */ "col_name_list ::= col_name_list NK_COMMA col_name", + /* 275 */ "col_name ::= column_name", + /* 276 */ "cmd ::= SHOW DNODES", + /* 277 */ "cmd ::= SHOW USERS", + /* 278 */ "cmd ::= SHOW USERS FULL", + /* 279 */ "cmd ::= SHOW USER PRIVILEGES", + /* 280 */ "cmd ::= SHOW db_kind_opt DATABASES", + /* 281 */ "cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt", + /* 282 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", + /* 283 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", + /* 284 */ "cmd ::= SHOW MNODES", + /* 285 */ "cmd ::= SHOW QNODES", + /* 286 */ "cmd ::= SHOW ANODES", + /* 287 */ "cmd ::= SHOW ANODES FULL", + /* 288 */ "cmd ::= SHOW ARBGROUPS", + /* 289 */ "cmd ::= SHOW FUNCTIONS", + /* 290 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", + /* 291 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name", + /* 292 */ "cmd ::= SHOW STREAMS", + /* 293 */ "cmd ::= SHOW ACCOUNTS", + /* 294 */ "cmd ::= SHOW APPS", + /* 295 */ "cmd ::= SHOW CONNECTIONS", + /* 296 */ "cmd ::= SHOW LICENCES", + /* 297 */ "cmd ::= SHOW GRANTS", + /* 298 */ "cmd ::= SHOW GRANTS FULL", + /* 299 */ "cmd ::= SHOW GRANTS LOGS", + /* 300 */ "cmd ::= SHOW CLUSTER MACHINES", + /* 301 */ "cmd ::= SHOW CREATE DATABASE db_name", + /* 302 */ "cmd ::= SHOW CREATE TABLE full_table_name", + /* 303 */ "cmd ::= SHOW CREATE STABLE full_table_name", + /* 304 */ "cmd ::= SHOW ENCRYPTIONS", + /* 305 */ "cmd ::= SHOW QUERIES", + /* 306 */ "cmd ::= SHOW SCORES", + /* 307 */ "cmd ::= SHOW TOPICS", + /* 308 */ "cmd ::= SHOW VARIABLES", + /* 309 */ "cmd ::= SHOW CLUSTER VARIABLES", + /* 310 */ "cmd ::= SHOW LOCAL VARIABLES", + /* 311 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", + /* 312 */ "cmd ::= SHOW BNODES", + /* 313 */ "cmd ::= SHOW SNODES", + /* 314 */ "cmd ::= SHOW CLUSTER", + /* 315 */ "cmd ::= SHOW TRANSACTIONS", + /* 316 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", + /* 317 */ "cmd ::= SHOW CONSUMERS", + /* 318 */ "cmd ::= SHOW SUBSCRIPTIONS", + /* 319 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", + /* 320 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name", + /* 321 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", + /* 322 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name", + /* 323 */ "cmd ::= SHOW VNODES ON DNODE NK_INTEGER", + /* 324 */ "cmd ::= SHOW VNODES", + /* 325 */ "cmd ::= SHOW db_name_cond_opt ALIVE", + /* 326 */ "cmd ::= SHOW CLUSTER ALIVE", + /* 327 */ "cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt", + /* 328 */ "cmd ::= SHOW CREATE VIEW full_table_name", + /* 329 */ "cmd ::= SHOW COMPACTS", + /* 330 */ "cmd ::= SHOW COMPACT NK_INTEGER", + /* 331 */ "table_kind_db_name_cond_opt ::=", + /* 332 */ "table_kind_db_name_cond_opt ::= table_kind", + /* 333 */ "table_kind_db_name_cond_opt ::= db_name NK_DOT", + /* 334 */ "table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT", + /* 335 */ "table_kind ::= NORMAL", + /* 336 */ "table_kind ::= CHILD", + /* 337 */ "db_name_cond_opt ::=", + /* 338 */ "db_name_cond_opt ::= db_name NK_DOT", + /* 339 */ "like_pattern_opt ::=", + /* 340 */ "like_pattern_opt ::= LIKE NK_STRING", + /* 341 */ "table_name_cond ::= table_name", + /* 342 */ "from_db_opt ::=", + /* 343 */ "from_db_opt ::= FROM db_name", + /* 344 */ "tag_list_opt ::=", + /* 345 */ "tag_list_opt ::= tag_item", + /* 346 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", + /* 347 */ "tag_item ::= TBNAME", + /* 348 */ "tag_item ::= QTAGS", + /* 349 */ "tag_item ::= column_name", + /* 350 */ "tag_item ::= column_name column_alias", + /* 351 */ "tag_item ::= column_name AS column_alias", + /* 352 */ "db_kind_opt ::=", + /* 353 */ "db_kind_opt ::= USER", + /* 354 */ "db_kind_opt ::= SYSTEM", + /* 355 */ "cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP", + /* 356 */ "cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP", + /* 357 */ "cmd ::= DROP TSMA exists_opt full_tsma_name", + /* 358 */ "cmd ::= SHOW db_name_cond_opt TSMAS", + /* 359 */ "full_tsma_name ::= tsma_name", + /* 360 */ "full_tsma_name ::= db_name NK_DOT tsma_name", + /* 361 */ "tsma_func_list ::= FUNCTION NK_LP func_list NK_RP", + /* 362 */ "cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options", + /* 363 */ "cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP", + /* 364 */ "cmd ::= DROP INDEX exists_opt full_index_name", + /* 365 */ "full_index_name ::= index_name", + /* 366 */ "full_index_name ::= db_name NK_DOT index_name", + /* 367 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", + /* 368 */ "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", + /* 369 */ "func_list ::= func", + /* 370 */ "func_list ::= func_list NK_COMMA func", + /* 371 */ "func ::= sma_func_name NK_LP expression_list NK_RP", + /* 372 */ "sma_func_name ::= function_name", + /* 373 */ "sma_func_name ::= COUNT", + /* 374 */ "sma_func_name ::= FIRST", + /* 375 */ "sma_func_name ::= LAST", + /* 376 */ "sma_func_name ::= LAST_ROW", + /* 377 */ "sma_stream_opt ::=", + /* 378 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", + /* 379 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", + /* 380 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", + /* 381 */ "with_meta ::= AS", + /* 382 */ "with_meta ::= WITH META AS", + /* 383 */ "with_meta ::= ONLY META AS", + /* 384 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", + /* 385 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name", + /* 386 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt", + /* 387 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 388 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", + /* 389 */ "cmd ::= DESC full_table_name", + /* 390 */ "cmd ::= DESCRIBE full_table_name", + /* 391 */ "cmd ::= RESET QUERY CACHE", + /* 392 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", + /* 393 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", + /* 394 */ "analyze_opt ::=", + /* 395 */ "analyze_opt ::= ANALYZE", + /* 396 */ "explain_options ::=", + /* 397 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 398 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 399 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt", + /* 400 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 401 */ "agg_func_opt ::=", + /* 402 */ "agg_func_opt ::= AGGREGATE", + /* 403 */ "bufsize_opt ::=", + /* 404 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 405 */ "language_opt ::=", + /* 406 */ "language_opt ::= LANGUAGE NK_STRING", + /* 407 */ "or_replace_opt ::=", + /* 408 */ "or_replace_opt ::= OR REPLACE", + /* 409 */ "cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery", + /* 410 */ "cmd ::= DROP VIEW exists_opt full_view_name", + /* 411 */ "full_view_name ::= view_name", + /* 412 */ "full_view_name ::= db_name NK_DOT view_name", + /* 413 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery", + /* 414 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 415 */ "cmd ::= PAUSE STREAM exists_opt stream_name", + /* 416 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name", + /* 417 */ "col_list_opt ::=", + /* 418 */ "col_list_opt ::= NK_LP column_stream_def_list NK_RP", + /* 419 */ "column_stream_def_list ::= column_stream_def", + /* 420 */ "column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def", + /* 421 */ "column_stream_def ::= column_name stream_col_options", + /* 422 */ "stream_col_options ::=", + /* 423 */ "stream_col_options ::= stream_col_options PRIMARY KEY", + /* 424 */ "tag_def_or_ref_opt ::=", + /* 425 */ "tag_def_or_ref_opt ::= tags_def", + /* 426 */ "tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP", + /* 427 */ "stream_options ::=", + /* 428 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 429 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 430 */ "stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE", + /* 431 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", + /* 432 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 433 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", + /* 434 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", + /* 435 */ "stream_options ::= stream_options DELETE_MARK duration_literal", + /* 436 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER", + /* 437 */ "subtable_opt ::=", + /* 438 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", + /* 439 */ "ignore_opt ::=", + /* 440 */ "ignore_opt ::= IGNORE UNTREATED", + /* 441 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 442 */ "cmd ::= KILL QUERY NK_STRING", + /* 443 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 444 */ "cmd ::= KILL COMPACT NK_INTEGER", + /* 445 */ "cmd ::= BALANCE VGROUP", + /* 446 */ "cmd ::= BALANCE VGROUP LEADER on_vgroup_id", + /* 447 */ "cmd ::= BALANCE VGROUP LEADER DATABASE db_name", + /* 448 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 449 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 450 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 451 */ "on_vgroup_id ::=", + /* 452 */ "on_vgroup_id ::= ON NK_INTEGER", + /* 453 */ "dnode_list ::= DNODE NK_INTEGER", + /* 454 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 455 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", + /* 456 */ "cmd ::= query_or_subquery", + /* 457 */ "cmd ::= insert_query", + /* 458 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", + /* 459 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", + /* 460 */ "tags_literal ::= NK_INTEGER", + /* 461 */ "tags_literal ::= NK_INTEGER NK_PLUS duration_literal", + /* 462 */ "tags_literal ::= NK_INTEGER NK_MINUS duration_literal", + /* 463 */ "tags_literal ::= NK_PLUS NK_INTEGER", + /* 464 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal", + /* 465 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal", + /* 466 */ "tags_literal ::= NK_MINUS NK_INTEGER", + /* 467 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal", + /* 468 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal", + /* 469 */ "tags_literal ::= NK_FLOAT", + /* 470 */ "tags_literal ::= NK_PLUS NK_FLOAT", + /* 471 */ "tags_literal ::= NK_MINUS NK_FLOAT", + /* 472 */ "tags_literal ::= NK_BIN", + /* 473 */ "tags_literal ::= NK_BIN NK_PLUS duration_literal", + /* 474 */ "tags_literal ::= NK_BIN NK_MINUS duration_literal", + /* 475 */ "tags_literal ::= NK_PLUS NK_BIN", + /* 476 */ "tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal", + /* 477 */ "tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal", + /* 478 */ "tags_literal ::= NK_MINUS NK_BIN", + /* 479 */ "tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal", + /* 480 */ "tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal", + /* 481 */ "tags_literal ::= NK_HEX", + /* 482 */ "tags_literal ::= NK_HEX NK_PLUS duration_literal", + /* 483 */ "tags_literal ::= NK_HEX NK_MINUS duration_literal", + /* 484 */ "tags_literal ::= NK_PLUS NK_HEX", + /* 485 */ "tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal", + /* 486 */ "tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal", + /* 487 */ "tags_literal ::= NK_MINUS NK_HEX", + /* 488 */ "tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal", + /* 489 */ "tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal", + /* 490 */ "tags_literal ::= NK_STRING", + /* 491 */ "tags_literal ::= NK_STRING NK_PLUS duration_literal", + /* 492 */ "tags_literal ::= NK_STRING NK_MINUS duration_literal", + /* 493 */ "tags_literal ::= NK_BOOL", + /* 494 */ "tags_literal ::= NULL", + /* 495 */ "tags_literal ::= literal_func", + /* 496 */ "tags_literal ::= literal_func NK_PLUS duration_literal", + /* 497 */ "tags_literal ::= literal_func NK_MINUS duration_literal", + /* 498 */ "tags_literal_list ::= tags_literal", + /* 499 */ "tags_literal_list ::= tags_literal_list NK_COMMA tags_literal", + /* 500 */ "literal ::= NK_INTEGER", + /* 501 */ "literal ::= NK_FLOAT", + /* 502 */ "literal ::= NK_STRING", + /* 503 */ "literal ::= NK_BOOL", + /* 504 */ "literal ::= TIMESTAMP NK_STRING", + /* 505 */ "literal ::= duration_literal", + /* 506 */ "literal ::= NULL", + /* 507 */ "literal ::= NK_QUESTION", + /* 508 */ "duration_literal ::= NK_VARIABLE", + /* 509 */ "signed ::= NK_INTEGER", + /* 510 */ "signed ::= NK_PLUS NK_INTEGER", + /* 511 */ "signed ::= NK_MINUS NK_INTEGER", + /* 512 */ "signed ::= NK_FLOAT", + /* 513 */ "signed ::= NK_PLUS NK_FLOAT", + /* 514 */ "signed ::= NK_MINUS NK_FLOAT", + /* 515 */ "signed_literal ::= signed", + /* 516 */ "signed_literal ::= NK_STRING", + /* 517 */ "signed_literal ::= NK_BOOL", + /* 518 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 519 */ "signed_literal ::= duration_literal", + /* 520 */ "signed_literal ::= NULL", + /* 521 */ "signed_literal ::= literal_func", + /* 522 */ "signed_literal ::= NK_QUESTION", + /* 523 */ "literal_list ::= signed_literal", + /* 524 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 525 */ "db_name ::= NK_ID", + /* 526 */ "table_name ::= NK_ID", + /* 527 */ "column_name ::= NK_ID", + /* 528 */ "function_name ::= NK_ID", + /* 529 */ "view_name ::= NK_ID", + /* 530 */ "table_alias ::= NK_ID", + /* 531 */ "column_alias ::= NK_ID", + /* 532 */ "column_alias ::= NK_ALIAS", + /* 533 */ "user_name ::= NK_ID", + /* 534 */ "topic_name ::= NK_ID", + /* 535 */ "stream_name ::= NK_ID", + /* 536 */ "cgroup_name ::= NK_ID", + /* 537 */ "index_name ::= NK_ID", + /* 538 */ "tsma_name ::= NK_ID", + /* 539 */ "expr_or_subquery ::= expression", + /* 540 */ "expression ::= literal", + /* 541 */ "expression ::= pseudo_column", + /* 542 */ "expression ::= column_reference", + /* 543 */ "expression ::= function_expression", + /* 544 */ "expression ::= case_when_expression", + /* 545 */ "expression ::= NK_LP expression NK_RP", + /* 546 */ "expression ::= NK_PLUS expr_or_subquery", + /* 547 */ "expression ::= NK_MINUS expr_or_subquery", + /* 548 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", + /* 549 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", + /* 550 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", + /* 551 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", + /* 552 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", + /* 553 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 554 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", + /* 555 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", + /* 556 */ "expression_list ::= expr_or_subquery", + /* 557 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", + /* 558 */ "column_reference ::= column_name", + /* 559 */ "column_reference ::= table_name NK_DOT column_name", + /* 560 */ "column_reference ::= NK_ALIAS", + /* 561 */ "column_reference ::= table_name NK_DOT NK_ALIAS", + /* 562 */ "pseudo_column ::= ROWTS", + /* 563 */ "pseudo_column ::= TBNAME", + /* 564 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 565 */ "pseudo_column ::= QSTART", + /* 566 */ "pseudo_column ::= QEND", + /* 567 */ "pseudo_column ::= QDURATION", + /* 568 */ "pseudo_column ::= WSTART", + /* 569 */ "pseudo_column ::= WEND", + /* 570 */ "pseudo_column ::= WDURATION", + /* 571 */ "pseudo_column ::= IROWTS", + /* 572 */ "pseudo_column ::= ISFILLED", + /* 573 */ "pseudo_column ::= QTAGS", + /* 574 */ "pseudo_column ::= FLOW", + /* 575 */ "pseudo_column ::= FHIGH", + /* 576 */ "pseudo_column ::= FROWTS", + /* 577 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 578 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 579 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", + /* 580 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP", + /* 581 */ "function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP", + /* 582 */ "function_expression ::= TRIM NK_LP expr_or_subquery NK_RP", + /* 583 */ "function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP", + /* 584 */ "function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP", + /* 585 */ "function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP", + /* 586 */ "function_expression ::= substr_func NK_LP expression_list NK_RP", + /* 587 */ "function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP", + /* 588 */ "function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP", + /* 589 */ "function_expression ::= REPLACE NK_LP expression_list NK_RP", + /* 590 */ "function_expression ::= literal_func", + /* 591 */ "function_expression ::= rand_func", + /* 592 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 593 */ "literal_func ::= NOW", + /* 594 */ "literal_func ::= TODAY", + /* 595 */ "rand_func ::= RAND NK_LP NK_RP", + /* 596 */ "rand_func ::= RAND NK_LP expression_list NK_RP", + /* 597 */ "substr_func ::= SUBSTR", + /* 598 */ "substr_func ::= SUBSTRING", + /* 599 */ "trim_specification_type ::= BOTH", + /* 600 */ "trim_specification_type ::= TRAILING", + /* 601 */ "trim_specification_type ::= LEADING", + /* 602 */ "noarg_func ::= NOW", + /* 603 */ "noarg_func ::= TODAY", + /* 604 */ "noarg_func ::= TIMEZONE", + /* 605 */ "noarg_func ::= DATABASE", + /* 606 */ "noarg_func ::= CLIENT_VERSION", + /* 607 */ "noarg_func ::= SERVER_VERSION", + /* 608 */ "noarg_func ::= SERVER_STATUS", + /* 609 */ "noarg_func ::= CURRENT_USER", + /* 610 */ "noarg_func ::= USER", + /* 611 */ "noarg_func ::= PI", + /* 612 */ "star_func ::= COUNT", + /* 613 */ "star_func ::= FIRST", + /* 614 */ "star_func ::= LAST", + /* 615 */ "star_func ::= LAST_ROW", + /* 616 */ "star_func_para_list ::= NK_STAR", + /* 617 */ "star_func_para_list ::= other_para_list", + /* 618 */ "other_para_list ::= star_func_para", + /* 619 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 620 */ "star_func_para ::= expr_or_subquery", + /* 621 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 622 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", + /* 623 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", + /* 624 */ "when_then_list ::= when_then_expr", + /* 625 */ "when_then_list ::= when_then_list when_then_expr", + /* 626 */ "when_then_expr ::= WHEN common_expression THEN common_expression", + /* 627 */ "case_when_else_opt ::=", + /* 628 */ "case_when_else_opt ::= ELSE common_expression", + /* 629 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", + /* 630 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", + /* 631 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", + /* 632 */ "predicate ::= expr_or_subquery IS NULL", + /* 633 */ "predicate ::= expr_or_subquery IS NOT NULL", + /* 634 */ "predicate ::= expr_or_subquery in_op in_predicate_value", + /* 635 */ "compare_op ::= NK_LT", + /* 636 */ "compare_op ::= NK_GT", + /* 637 */ "compare_op ::= NK_LE", + /* 638 */ "compare_op ::= NK_GE", + /* 639 */ "compare_op ::= NK_NE", + /* 640 */ "compare_op ::= NK_EQ", + /* 641 */ "compare_op ::= LIKE", + /* 642 */ "compare_op ::= NOT LIKE", + /* 643 */ "compare_op ::= MATCH", + /* 644 */ "compare_op ::= NMATCH", + /* 645 */ "compare_op ::= CONTAINS", + /* 646 */ "in_op ::= IN", + /* 647 */ "in_op ::= NOT IN", + /* 648 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 649 */ "boolean_value_expression ::= boolean_primary", + /* 650 */ "boolean_value_expression ::= NOT boolean_primary", + /* 651 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 652 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 653 */ "boolean_primary ::= predicate", + /* 654 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 655 */ "common_expression ::= expr_or_subquery", + /* 656 */ "common_expression ::= boolean_value_expression", + /* 657 */ "from_clause_opt ::=", + /* 658 */ "from_clause_opt ::= FROM table_reference_list", + /* 659 */ "table_reference_list ::= table_reference", + /* 660 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 661 */ "table_reference ::= table_primary", + /* 662 */ "table_reference ::= joined_table", + /* 663 */ "table_primary ::= table_name alias_opt", + /* 664 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 665 */ "table_primary ::= subquery alias_opt", + /* 666 */ "table_primary ::= parenthesized_joined_table", + /* 667 */ "alias_opt ::=", + /* 668 */ "alias_opt ::= table_alias", + /* 669 */ "alias_opt ::= AS table_alias", + /* 670 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 671 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 672 */ "joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt", + /* 673 */ "join_type ::=", + /* 674 */ "join_type ::= INNER", + /* 675 */ "join_type ::= LEFT", + /* 676 */ "join_type ::= RIGHT", + /* 677 */ "join_type ::= FULL", + /* 678 */ "join_subtype ::=", + /* 679 */ "join_subtype ::= OUTER", + /* 680 */ "join_subtype ::= SEMI", + /* 681 */ "join_subtype ::= ANTI", + /* 682 */ "join_subtype ::= ASOF", + /* 683 */ "join_subtype ::= WINDOW", + /* 684 */ "join_on_clause_opt ::=", + /* 685 */ "join_on_clause_opt ::= ON search_condition", + /* 686 */ "window_offset_clause_opt ::=", + /* 687 */ "window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP", + /* 688 */ "window_offset_literal ::= NK_VARIABLE", + /* 689 */ "window_offset_literal ::= NK_MINUS NK_VARIABLE", + /* 690 */ "jlimit_clause_opt ::=", + /* 691 */ "jlimit_clause_opt ::= JLIMIT NK_INTEGER", + /* 692 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", + /* 693 */ "hint_list ::=", + /* 694 */ "hint_list ::= NK_HINT", + /* 695 */ "tag_mode_opt ::=", + /* 696 */ "tag_mode_opt ::= TAGS", + /* 697 */ "set_quantifier_opt ::=", + /* 698 */ "set_quantifier_opt ::= DISTINCT", + /* 699 */ "set_quantifier_opt ::= ALL", + /* 700 */ "select_list ::= select_item", + /* 701 */ "select_list ::= select_list NK_COMMA select_item", + /* 702 */ "select_item ::= NK_STAR", + /* 703 */ "select_item ::= common_expression", + /* 704 */ "select_item ::= common_expression column_alias", + /* 705 */ "select_item ::= common_expression AS column_alias", + /* 706 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 707 */ "where_clause_opt ::=", + /* 708 */ "where_clause_opt ::= WHERE search_condition", + /* 709 */ "partition_by_clause_opt ::=", + /* 710 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 711 */ "partition_list ::= partition_item", + /* 712 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 713 */ "partition_item ::= expr_or_subquery", + /* 714 */ "partition_item ::= expr_or_subquery column_alias", + /* 715 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 716 */ "twindow_clause_opt ::=", + /* 717 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", + /* 718 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 719 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 720 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 721 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 722 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", + /* 723 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 724 */ "twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP", + /* 725 */ "twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP", + /* 726 */ "sliding_opt ::=", + /* 727 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", + /* 728 */ "interval_sliding_duration_literal ::= NK_VARIABLE", + /* 729 */ "interval_sliding_duration_literal ::= NK_STRING", + /* 730 */ "interval_sliding_duration_literal ::= NK_INTEGER", + /* 731 */ "fill_opt ::=", + /* 732 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 733 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", + /* 734 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", + /* 735 */ "fill_mode ::= NONE", + /* 736 */ "fill_mode ::= PREV", + /* 737 */ "fill_mode ::= NULL", + /* 738 */ "fill_mode ::= NULL_F", + /* 739 */ "fill_mode ::= LINEAR", + /* 740 */ "fill_mode ::= NEXT", + /* 741 */ "group_by_clause_opt ::=", + /* 742 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 743 */ "group_by_list ::= expr_or_subquery", + /* 744 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 745 */ "having_clause_opt ::=", + /* 746 */ "having_clause_opt ::= HAVING search_condition", + /* 747 */ "range_opt ::=", + /* 748 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 749 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", + /* 750 */ "every_opt ::=", + /* 751 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 752 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 753 */ "query_simple ::= query_specification", + /* 754 */ "query_simple ::= union_query_expression", + /* 755 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 756 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 757 */ "query_simple_or_subquery ::= query_simple", + /* 758 */ "query_simple_or_subquery ::= subquery", + /* 759 */ "query_or_subquery ::= query_expression", + /* 760 */ "query_or_subquery ::= subquery", + /* 761 */ "order_by_clause_opt ::=", + /* 762 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 763 */ "slimit_clause_opt ::=", + /* 764 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 765 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 766 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 767 */ "limit_clause_opt ::=", + /* 768 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 769 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 770 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 771 */ "subquery ::= NK_LP query_expression NK_RP", + /* 772 */ "subquery ::= NK_LP subquery NK_RP", + /* 773 */ "search_condition ::= common_expression", + /* 774 */ "sort_specification_list ::= sort_specification", + /* 775 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 776 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 777 */ "ordering_specification_opt ::=", + /* 778 */ "ordering_specification_opt ::= ASC", + /* 779 */ "ordering_specification_opt ::= DESC", + /* 780 */ "null_ordering_opt ::=", + /* 781 */ "null_ordering_opt ::= NULLS FIRST", + /* 782 */ "null_ordering_opt ::= NULLS LAST", + /* 783 */ "column_options ::=", + /* 784 */ "column_options ::= column_options PRIMARY KEY", + /* 785 */ "column_options ::= column_options NK_ID NK_STRING", }; #endif /* NDEBUG */ @@ -4540,646 +4541,647 @@ static const YYCODETYPE yyRuleInfoLhs[] = { 415, /* (142) db_options ::= db_options S3_COMPACT NK_INTEGER */ 415, /* (143) db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ 415, /* (144) db_options ::= db_options ENCRYPT_ALGORITHM NK_STRING */ - 417, /* (145) alter_db_options ::= alter_db_option */ - 417, /* (146) alter_db_options ::= alter_db_options alter_db_option */ - 425, /* (147) alter_db_option ::= BUFFER NK_INTEGER */ - 425, /* (148) alter_db_option ::= CACHEMODEL NK_STRING */ - 425, /* (149) alter_db_option ::= CACHESIZE NK_INTEGER */ - 425, /* (150) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ - 425, /* (151) alter_db_option ::= KEEP integer_list */ - 425, /* (152) alter_db_option ::= KEEP variable_list */ - 425, /* (153) alter_db_option ::= PAGES NK_INTEGER */ - 425, /* (154) alter_db_option ::= REPLICA NK_INTEGER */ - 425, /* (155) alter_db_option ::= WAL_LEVEL NK_INTEGER */ - 425, /* (156) alter_db_option ::= STT_TRIGGER NK_INTEGER */ - 425, /* (157) alter_db_option ::= MINROWS NK_INTEGER */ - 425, /* (158) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ - 425, /* (159) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - 425, /* (160) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ - 425, /* (161) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - 425, /* (162) alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ - 425, /* (163) alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ - 425, /* (164) alter_db_option ::= S3_COMPACT NK_INTEGER */ - 425, /* (165) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ - 425, /* (166) alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ - 421, /* (167) integer_list ::= NK_INTEGER */ - 421, /* (168) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - 422, /* (169) variable_list ::= NK_VARIABLE */ - 422, /* (170) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - 423, /* (171) retention_list ::= retention */ - 423, /* (172) retention_list ::= retention_list NK_COMMA retention */ - 426, /* (173) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - 426, /* (174) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ - 418, /* (175) speed_opt ::= */ - 418, /* (176) speed_opt ::= BWLIMIT NK_INTEGER */ - 419, /* (177) start_opt ::= */ - 419, /* (178) start_opt ::= START WITH NK_INTEGER */ - 419, /* (179) start_opt ::= START WITH NK_STRING */ - 419, /* (180) start_opt ::= START WITH TIMESTAMP NK_STRING */ - 420, /* (181) end_opt ::= */ - 420, /* (182) end_opt ::= END WITH NK_INTEGER */ - 420, /* (183) end_opt ::= END WITH NK_STRING */ - 420, /* (184) end_opt ::= END WITH TIMESTAMP NK_STRING */ - 390, /* (185) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - 390, /* (186) cmd ::= CREATE TABLE multi_create_clause */ - 390, /* (187) cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ - 390, /* (188) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - 390, /* (189) cmd ::= DROP TABLE with_opt multi_drop_clause */ - 390, /* (190) cmd ::= DROP STABLE with_opt exists_opt full_table_name */ - 390, /* (191) cmd ::= ALTER TABLE alter_table_clause */ - 390, /* (192) cmd ::= ALTER STABLE alter_table_clause */ - 436, /* (193) alter_table_clause ::= full_table_name alter_table_options */ - 436, /* (194) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ - 436, /* (195) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - 436, /* (196) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - 436, /* (197) alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ - 436, /* (198) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - 436, /* (199) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - 436, /* (200) alter_table_clause ::= full_table_name DROP TAG column_name */ - 436, /* (201) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - 436, /* (202) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - 436, /* (203) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ - 431, /* (204) multi_create_clause ::= create_subtable_clause */ - 431, /* (205) multi_create_clause ::= multi_create_clause create_subtable_clause */ - 442, /* (206) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ - 435, /* (207) multi_drop_clause ::= drop_table_clause */ - 435, /* (208) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ - 445, /* (209) drop_table_clause ::= exists_opt full_table_name */ - 434, /* (210) with_opt ::= */ - 434, /* (211) with_opt ::= WITH */ - 443, /* (212) specific_cols_opt ::= */ - 443, /* (213) specific_cols_opt ::= NK_LP col_name_list NK_RP */ - 427, /* (214) full_table_name ::= table_name */ - 427, /* (215) full_table_name ::= db_name NK_DOT table_name */ - 447, /* (216) tag_def_list ::= tag_def */ - 447, /* (217) tag_def_list ::= tag_def_list NK_COMMA tag_def */ - 448, /* (218) tag_def ::= column_name type_name */ - 428, /* (219) column_def_list ::= column_def */ - 428, /* (220) column_def_list ::= column_def_list NK_COMMA column_def */ - 449, /* (221) column_def ::= column_name type_name column_options */ - 439, /* (222) type_name ::= BOOL */ - 439, /* (223) type_name ::= TINYINT */ - 439, /* (224) type_name ::= SMALLINT */ - 439, /* (225) type_name ::= INT */ - 439, /* (226) type_name ::= INTEGER */ - 439, /* (227) type_name ::= BIGINT */ - 439, /* (228) type_name ::= FLOAT */ - 439, /* (229) type_name ::= DOUBLE */ - 439, /* (230) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - 439, /* (231) type_name ::= TIMESTAMP */ - 439, /* (232) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - 439, /* (233) type_name ::= TINYINT UNSIGNED */ - 439, /* (234) type_name ::= SMALLINT UNSIGNED */ - 439, /* (235) type_name ::= INT UNSIGNED */ - 439, /* (236) type_name ::= BIGINT UNSIGNED */ - 439, /* (237) type_name ::= JSON */ - 439, /* (238) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - 439, /* (239) type_name ::= MEDIUMBLOB */ - 439, /* (240) type_name ::= BLOB */ - 439, /* (241) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - 439, /* (242) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ - 439, /* (243) type_name ::= DECIMAL */ - 439, /* (244) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - 439, /* (245) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 450, /* (246) type_name_default_len ::= BINARY */ - 450, /* (247) type_name_default_len ::= NCHAR */ - 450, /* (248) type_name_default_len ::= VARCHAR */ - 450, /* (249) type_name_default_len ::= VARBINARY */ - 429, /* (250) tags_def_opt ::= */ - 429, /* (251) tags_def_opt ::= tags_def */ - 433, /* (252) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - 430, /* (253) table_options ::= */ - 430, /* (254) table_options ::= table_options COMMENT NK_STRING */ - 430, /* (255) table_options ::= table_options MAX_DELAY duration_list */ - 430, /* (256) table_options ::= table_options WATERMARK duration_list */ - 430, /* (257) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - 430, /* (258) table_options ::= table_options TTL NK_INTEGER */ - 430, /* (259) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - 430, /* (260) table_options ::= table_options DELETE_MARK duration_list */ - 437, /* (261) alter_table_options ::= alter_table_option */ - 437, /* (262) alter_table_options ::= alter_table_options alter_table_option */ - 453, /* (263) alter_table_option ::= COMMENT NK_STRING */ - 453, /* (264) alter_table_option ::= TTL NK_INTEGER */ - 451, /* (265) duration_list ::= duration_literal */ - 451, /* (266) duration_list ::= duration_list NK_COMMA duration_literal */ - 452, /* (267) rollup_func_list ::= rollup_func_name */ - 452, /* (268) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - 455, /* (269) rollup_func_name ::= function_name */ - 455, /* (270) rollup_func_name ::= FIRST */ - 455, /* (271) rollup_func_name ::= LAST */ - 446, /* (272) col_name_list ::= col_name */ - 446, /* (273) col_name_list ::= col_name_list NK_COMMA col_name */ - 457, /* (274) col_name ::= column_name */ - 390, /* (275) cmd ::= SHOW DNODES */ - 390, /* (276) cmd ::= SHOW USERS */ - 390, /* (277) cmd ::= SHOW USERS FULL */ - 390, /* (278) cmd ::= SHOW USER PRIVILEGES */ - 390, /* (279) cmd ::= SHOW db_kind_opt DATABASES */ - 390, /* (280) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ - 390, /* (281) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - 390, /* (282) cmd ::= SHOW db_name_cond_opt VGROUPS */ - 390, /* (283) cmd ::= SHOW MNODES */ - 390, /* (284) cmd ::= SHOW QNODES */ - 390, /* (285) cmd ::= SHOW ANODES */ - 390, /* (286) cmd ::= SHOW ANODES FULL */ - 390, /* (287) cmd ::= SHOW ARBGROUPS */ - 390, /* (288) cmd ::= SHOW FUNCTIONS */ - 390, /* (289) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - 390, /* (290) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ - 390, /* (291) cmd ::= SHOW STREAMS */ - 390, /* (292) cmd ::= SHOW ACCOUNTS */ - 390, /* (293) cmd ::= SHOW APPS */ - 390, /* (294) cmd ::= SHOW CONNECTIONS */ - 390, /* (295) cmd ::= SHOW LICENCES */ - 390, /* (296) cmd ::= SHOW GRANTS */ - 390, /* (297) cmd ::= SHOW GRANTS FULL */ - 390, /* (298) cmd ::= SHOW GRANTS LOGS */ - 390, /* (299) cmd ::= SHOW CLUSTER MACHINES */ - 390, /* (300) cmd ::= SHOW CREATE DATABASE db_name */ - 390, /* (301) cmd ::= SHOW CREATE TABLE full_table_name */ - 390, /* (302) cmd ::= SHOW CREATE STABLE full_table_name */ - 390, /* (303) cmd ::= SHOW ENCRYPTIONS */ - 390, /* (304) cmd ::= SHOW QUERIES */ - 390, /* (305) cmd ::= SHOW SCORES */ - 390, /* (306) cmd ::= SHOW TOPICS */ - 390, /* (307) cmd ::= SHOW VARIABLES */ - 390, /* (308) cmd ::= SHOW CLUSTER VARIABLES */ - 390, /* (309) cmd ::= SHOW LOCAL VARIABLES */ - 390, /* (310) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - 390, /* (311) cmd ::= SHOW BNODES */ - 390, /* (312) cmd ::= SHOW SNODES */ - 390, /* (313) cmd ::= SHOW CLUSTER */ - 390, /* (314) cmd ::= SHOW TRANSACTIONS */ - 390, /* (315) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - 390, /* (316) cmd ::= SHOW CONSUMERS */ - 390, /* (317) cmd ::= SHOW SUBSCRIPTIONS */ - 390, /* (318) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - 390, /* (319) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ - 390, /* (320) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - 390, /* (321) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ - 390, /* (322) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ - 390, /* (323) cmd ::= SHOW VNODES */ - 390, /* (324) cmd ::= SHOW db_name_cond_opt ALIVE */ - 390, /* (325) cmd ::= SHOW CLUSTER ALIVE */ - 390, /* (326) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ - 390, /* (327) cmd ::= SHOW CREATE VIEW full_table_name */ - 390, /* (328) cmd ::= SHOW COMPACTS */ - 390, /* (329) cmd ::= SHOW COMPACT NK_INTEGER */ - 459, /* (330) table_kind_db_name_cond_opt ::= */ - 459, /* (331) table_kind_db_name_cond_opt ::= table_kind */ - 459, /* (332) table_kind_db_name_cond_opt ::= db_name NK_DOT */ - 459, /* (333) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ - 464, /* (334) table_kind ::= NORMAL */ - 464, /* (335) table_kind ::= CHILD */ - 461, /* (336) db_name_cond_opt ::= */ - 461, /* (337) db_name_cond_opt ::= db_name NK_DOT */ - 460, /* (338) like_pattern_opt ::= */ - 460, /* (339) like_pattern_opt ::= LIKE NK_STRING */ - 462, /* (340) table_name_cond ::= table_name */ - 463, /* (341) from_db_opt ::= */ - 463, /* (342) from_db_opt ::= FROM db_name */ - 432, /* (343) tag_list_opt ::= */ - 432, /* (344) tag_list_opt ::= tag_item */ - 432, /* (345) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - 465, /* (346) tag_item ::= TBNAME */ - 465, /* (347) tag_item ::= QTAGS */ - 465, /* (348) tag_item ::= column_name */ - 465, /* (349) tag_item ::= column_name column_alias */ - 465, /* (350) tag_item ::= column_name AS column_alias */ - 458, /* (351) db_kind_opt ::= */ - 458, /* (352) db_kind_opt ::= USER */ - 458, /* (353) db_kind_opt ::= SYSTEM */ - 390, /* (354) cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ - 390, /* (355) cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ - 390, /* (356) cmd ::= DROP TSMA exists_opt full_tsma_name */ - 390, /* (357) cmd ::= SHOW db_name_cond_opt TSMAS */ - 469, /* (358) full_tsma_name ::= tsma_name */ - 469, /* (359) full_tsma_name ::= db_name NK_DOT tsma_name */ - 468, /* (360) tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ - 390, /* (361) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ - 390, /* (362) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ - 390, /* (363) cmd ::= DROP INDEX exists_opt full_index_name */ - 472, /* (364) full_index_name ::= index_name */ - 472, /* (365) full_index_name ::= db_name NK_DOT index_name */ - 471, /* (366) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - 471, /* (367) 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 */ - 470, /* (368) func_list ::= func */ - 470, /* (369) func_list ::= func_list NK_COMMA func */ - 476, /* (370) func ::= sma_func_name NK_LP expression_list NK_RP */ - 477, /* (371) sma_func_name ::= function_name */ - 477, /* (372) sma_func_name ::= COUNT */ - 477, /* (373) sma_func_name ::= FIRST */ - 477, /* (374) sma_func_name ::= LAST */ - 477, /* (375) sma_func_name ::= LAST_ROW */ - 475, /* (376) sma_stream_opt ::= */ - 475, /* (377) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - 475, /* (378) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - 475, /* (379) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - 479, /* (380) with_meta ::= AS */ - 479, /* (381) with_meta ::= WITH META AS */ - 479, /* (382) with_meta ::= ONLY META AS */ - 390, /* (383) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - 390, /* (384) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ - 390, /* (385) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ - 390, /* (386) cmd ::= DROP TOPIC exists_opt topic_name */ - 390, /* (387) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - 390, /* (388) cmd ::= DESC full_table_name */ - 390, /* (389) cmd ::= DESCRIBE full_table_name */ - 390, /* (390) cmd ::= RESET QUERY CACHE */ - 390, /* (391) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - 390, /* (392) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - 483, /* (393) analyze_opt ::= */ - 483, /* (394) analyze_opt ::= ANALYZE */ - 484, /* (395) explain_options ::= */ - 484, /* (396) explain_options ::= explain_options VERBOSE NK_BOOL */ - 484, /* (397) explain_options ::= explain_options RATIO NK_FLOAT */ - 390, /* (398) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ - 390, /* (399) cmd ::= DROP FUNCTION exists_opt function_name */ - 487, /* (400) agg_func_opt ::= */ - 487, /* (401) agg_func_opt ::= AGGREGATE */ - 488, /* (402) bufsize_opt ::= */ - 488, /* (403) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 489, /* (404) language_opt ::= */ - 489, /* (405) language_opt ::= LANGUAGE NK_STRING */ - 486, /* (406) or_replace_opt ::= */ - 486, /* (407) or_replace_opt ::= OR REPLACE */ - 390, /* (408) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ - 390, /* (409) cmd ::= DROP VIEW exists_opt full_view_name */ - 490, /* (410) full_view_name ::= view_name */ - 490, /* (411) full_view_name ::= db_name NK_DOT view_name */ - 390, /* (412) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ - 390, /* (413) cmd ::= DROP STREAM exists_opt stream_name */ - 390, /* (414) cmd ::= PAUSE STREAM exists_opt stream_name */ - 390, /* (415) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ - 494, /* (416) col_list_opt ::= */ - 494, /* (417) col_list_opt ::= NK_LP column_stream_def_list NK_RP */ - 498, /* (418) column_stream_def_list ::= column_stream_def */ - 498, /* (419) column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ - 499, /* (420) column_stream_def ::= column_name stream_col_options */ - 500, /* (421) stream_col_options ::= */ - 500, /* (422) stream_col_options ::= stream_col_options PRIMARY KEY */ - 495, /* (423) tag_def_or_ref_opt ::= */ - 495, /* (424) tag_def_or_ref_opt ::= tags_def */ - 495, /* (425) tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ - 493, /* (426) stream_options ::= */ - 493, /* (427) stream_options ::= stream_options TRIGGER AT_ONCE */ - 493, /* (428) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - 493, /* (429) stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ - 493, /* (430) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - 493, /* (431) stream_options ::= stream_options WATERMARK duration_literal */ - 493, /* (432) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - 493, /* (433) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - 493, /* (434) stream_options ::= stream_options DELETE_MARK duration_literal */ - 493, /* (435) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ - 496, /* (436) subtable_opt ::= */ - 496, /* (437) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - 497, /* (438) ignore_opt ::= */ - 497, /* (439) ignore_opt ::= IGNORE UNTREATED */ - 390, /* (440) cmd ::= KILL CONNECTION NK_INTEGER */ - 390, /* (441) cmd ::= KILL QUERY NK_STRING */ - 390, /* (442) cmd ::= KILL TRANSACTION NK_INTEGER */ - 390, /* (443) cmd ::= KILL COMPACT NK_INTEGER */ - 390, /* (444) cmd ::= BALANCE VGROUP */ - 390, /* (445) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ - 390, /* (446) cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ - 390, /* (447) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - 390, /* (448) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - 390, /* (449) cmd ::= SPLIT VGROUP NK_INTEGER */ - 502, /* (450) on_vgroup_id ::= */ - 502, /* (451) on_vgroup_id ::= ON NK_INTEGER */ - 503, /* (452) dnode_list ::= DNODE NK_INTEGER */ - 503, /* (453) dnode_list ::= dnode_list DNODE NK_INTEGER */ - 390, /* (454) cmd ::= DELETE FROM full_table_name where_clause_opt */ - 390, /* (455) cmd ::= query_or_subquery */ - 390, /* (456) cmd ::= insert_query */ - 485, /* (457) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - 485, /* (458) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - 441, /* (459) tags_literal ::= NK_INTEGER */ - 441, /* (460) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - 441, /* (461) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ - 441, /* (462) tags_literal ::= NK_PLUS NK_INTEGER */ - 441, /* (463) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - 441, /* (464) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ - 441, /* (465) tags_literal ::= NK_MINUS NK_INTEGER */ - 441, /* (466) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ - 441, /* (467) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ - 441, /* (468) tags_literal ::= NK_FLOAT */ - 441, /* (469) tags_literal ::= NK_PLUS NK_FLOAT */ - 441, /* (470) tags_literal ::= NK_MINUS NK_FLOAT */ - 441, /* (471) tags_literal ::= NK_BIN */ - 441, /* (472) tags_literal ::= NK_BIN NK_PLUS duration_literal */ - 441, /* (473) tags_literal ::= NK_BIN NK_MINUS duration_literal */ - 441, /* (474) tags_literal ::= NK_PLUS NK_BIN */ - 441, /* (475) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ - 441, /* (476) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ - 441, /* (477) tags_literal ::= NK_MINUS NK_BIN */ - 441, /* (478) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ - 441, /* (479) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ - 441, /* (480) tags_literal ::= NK_HEX */ - 441, /* (481) tags_literal ::= NK_HEX NK_PLUS duration_literal */ - 441, /* (482) tags_literal ::= NK_HEX NK_MINUS duration_literal */ - 441, /* (483) tags_literal ::= NK_PLUS NK_HEX */ - 441, /* (484) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ - 441, /* (485) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ - 441, /* (486) tags_literal ::= NK_MINUS NK_HEX */ - 441, /* (487) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ - 441, /* (488) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ - 441, /* (489) tags_literal ::= NK_STRING */ - 441, /* (490) tags_literal ::= NK_STRING NK_PLUS duration_literal */ - 441, /* (491) tags_literal ::= NK_STRING NK_MINUS duration_literal */ - 441, /* (492) tags_literal ::= NK_BOOL */ - 441, /* (493) tags_literal ::= NULL */ - 441, /* (494) tags_literal ::= literal_func */ - 441, /* (495) tags_literal ::= literal_func NK_PLUS duration_literal */ - 441, /* (496) tags_literal ::= literal_func NK_MINUS duration_literal */ - 444, /* (497) tags_literal_list ::= tags_literal */ - 444, /* (498) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ - 393, /* (499) literal ::= NK_INTEGER */ - 393, /* (500) literal ::= NK_FLOAT */ - 393, /* (501) literal ::= NK_STRING */ - 393, /* (502) literal ::= NK_BOOL */ - 393, /* (503) literal ::= TIMESTAMP NK_STRING */ - 393, /* (504) literal ::= duration_literal */ - 393, /* (505) literal ::= NULL */ - 393, /* (506) literal ::= NK_QUESTION */ - 454, /* (507) duration_literal ::= NK_VARIABLE */ - 424, /* (508) signed ::= NK_INTEGER */ - 424, /* (509) signed ::= NK_PLUS NK_INTEGER */ - 424, /* (510) signed ::= NK_MINUS NK_INTEGER */ - 424, /* (511) signed ::= NK_FLOAT */ - 424, /* (512) signed ::= NK_PLUS NK_FLOAT */ - 424, /* (513) signed ::= NK_MINUS NK_FLOAT */ - 505, /* (514) signed_literal ::= signed */ - 505, /* (515) signed_literal ::= NK_STRING */ - 505, /* (516) signed_literal ::= NK_BOOL */ - 505, /* (517) signed_literal ::= TIMESTAMP NK_STRING */ - 505, /* (518) signed_literal ::= duration_literal */ - 505, /* (519) signed_literal ::= NULL */ - 505, /* (520) signed_literal ::= literal_func */ - 505, /* (521) signed_literal ::= NK_QUESTION */ - 506, /* (522) literal_list ::= signed_literal */ - 506, /* (523) literal_list ::= literal_list NK_COMMA signed_literal */ - 407, /* (524) db_name ::= NK_ID */ - 408, /* (525) table_name ::= NK_ID */ - 438, /* (526) column_name ::= NK_ID */ - 456, /* (527) function_name ::= NK_ID */ - 491, /* (528) view_name ::= NK_ID */ - 507, /* (529) table_alias ::= NK_ID */ - 466, /* (530) column_alias ::= NK_ID */ - 466, /* (531) column_alias ::= NK_ALIAS */ - 400, /* (532) user_name ::= NK_ID */ - 409, /* (533) topic_name ::= NK_ID */ - 492, /* (534) stream_name ::= NK_ID */ - 482, /* (535) cgroup_name ::= NK_ID */ - 473, /* (536) index_name ::= NK_ID */ - 467, /* (537) tsma_name ::= NK_ID */ - 508, /* (538) expr_or_subquery ::= expression */ - 501, /* (539) expression ::= literal */ - 501, /* (540) expression ::= pseudo_column */ - 501, /* (541) expression ::= column_reference */ - 501, /* (542) expression ::= function_expression */ - 501, /* (543) expression ::= case_when_expression */ - 501, /* (544) expression ::= NK_LP expression NK_RP */ - 501, /* (545) expression ::= NK_PLUS expr_or_subquery */ - 501, /* (546) expression ::= NK_MINUS expr_or_subquery */ - 501, /* (547) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - 501, /* (548) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - 501, /* (549) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - 501, /* (550) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - 501, /* (551) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - 501, /* (552) expression ::= column_reference NK_ARROW NK_STRING */ - 501, /* (553) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - 501, /* (554) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - 478, /* (555) expression_list ::= expr_or_subquery */ - 478, /* (556) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - 510, /* (557) column_reference ::= column_name */ - 510, /* (558) column_reference ::= table_name NK_DOT column_name */ - 510, /* (559) column_reference ::= NK_ALIAS */ - 510, /* (560) column_reference ::= table_name NK_DOT NK_ALIAS */ - 509, /* (561) pseudo_column ::= ROWTS */ - 509, /* (562) pseudo_column ::= TBNAME */ - 509, /* (563) pseudo_column ::= table_name NK_DOT TBNAME */ - 509, /* (564) pseudo_column ::= QSTART */ - 509, /* (565) pseudo_column ::= QEND */ - 509, /* (566) pseudo_column ::= QDURATION */ - 509, /* (567) pseudo_column ::= WSTART */ - 509, /* (568) pseudo_column ::= WEND */ - 509, /* (569) pseudo_column ::= WDURATION */ - 509, /* (570) pseudo_column ::= IROWTS */ - 509, /* (571) pseudo_column ::= ISFILLED */ - 509, /* (572) pseudo_column ::= QTAGS */ - 509, /* (573) pseudo_column ::= FLOW */ - 509, /* (574) pseudo_column ::= FHIGH */ - 509, /* (575) pseudo_column ::= FROWTS */ - 511, /* (576) function_expression ::= function_name NK_LP expression_list NK_RP */ - 511, /* (577) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - 511, /* (578) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - 511, /* (579) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ - 511, /* (580) function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ - 511, /* (581) function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ - 511, /* (582) function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ - 511, /* (583) function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ - 511, /* (584) function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ - 511, /* (585) function_expression ::= substr_func NK_LP expression_list NK_RP */ - 511, /* (586) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ - 511, /* (587) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ - 511, /* (588) function_expression ::= REPLACE NK_LP expression_list NK_RP */ - 511, /* (589) function_expression ::= literal_func */ - 511, /* (590) function_expression ::= rand_func */ - 504, /* (591) literal_func ::= noarg_func NK_LP NK_RP */ - 504, /* (592) literal_func ::= NOW */ - 504, /* (593) literal_func ::= TODAY */ - 517, /* (594) rand_func ::= RAND NK_LP NK_RP */ - 517, /* (595) rand_func ::= RAND NK_LP expression_list NK_RP */ - 516, /* (596) substr_func ::= SUBSTR */ - 516, /* (597) substr_func ::= SUBSTRING */ - 515, /* (598) trim_specification_type ::= BOTH */ - 515, /* (599) trim_specification_type ::= TRAILING */ - 515, /* (600) trim_specification_type ::= LEADING */ - 518, /* (601) noarg_func ::= NOW */ - 518, /* (602) noarg_func ::= TODAY */ - 518, /* (603) noarg_func ::= TIMEZONE */ - 518, /* (604) noarg_func ::= DATABASE */ - 518, /* (605) noarg_func ::= CLIENT_VERSION */ - 518, /* (606) noarg_func ::= SERVER_VERSION */ - 518, /* (607) noarg_func ::= SERVER_STATUS */ - 518, /* (608) noarg_func ::= CURRENT_USER */ - 518, /* (609) noarg_func ::= USER */ - 518, /* (610) noarg_func ::= PI */ - 513, /* (611) star_func ::= COUNT */ - 513, /* (612) star_func ::= FIRST */ - 513, /* (613) star_func ::= LAST */ - 513, /* (614) star_func ::= LAST_ROW */ - 514, /* (615) star_func_para_list ::= NK_STAR */ - 514, /* (616) star_func_para_list ::= other_para_list */ - 519, /* (617) other_para_list ::= star_func_para */ - 519, /* (618) other_para_list ::= other_para_list NK_COMMA star_func_para */ - 520, /* (619) star_func_para ::= expr_or_subquery */ - 520, /* (620) star_func_para ::= table_name NK_DOT NK_STAR */ - 512, /* (621) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - 512, /* (622) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - 521, /* (623) when_then_list ::= when_then_expr */ - 521, /* (624) when_then_list ::= when_then_list when_then_expr */ - 524, /* (625) when_then_expr ::= WHEN common_expression THEN common_expression */ - 522, /* (626) case_when_else_opt ::= */ - 522, /* (627) case_when_else_opt ::= ELSE common_expression */ - 525, /* (628) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - 525, /* (629) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - 525, /* (630) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - 525, /* (631) predicate ::= expr_or_subquery IS NULL */ - 525, /* (632) predicate ::= expr_or_subquery IS NOT NULL */ - 525, /* (633) predicate ::= expr_or_subquery in_op in_predicate_value */ - 526, /* (634) compare_op ::= NK_LT */ - 526, /* (635) compare_op ::= NK_GT */ - 526, /* (636) compare_op ::= NK_LE */ - 526, /* (637) compare_op ::= NK_GE */ - 526, /* (638) compare_op ::= NK_NE */ - 526, /* (639) compare_op ::= NK_EQ */ - 526, /* (640) compare_op ::= LIKE */ - 526, /* (641) compare_op ::= NOT LIKE */ - 526, /* (642) compare_op ::= MATCH */ - 526, /* (643) compare_op ::= NMATCH */ - 526, /* (644) compare_op ::= CONTAINS */ - 527, /* (645) in_op ::= IN */ - 527, /* (646) in_op ::= NOT IN */ - 528, /* (647) in_predicate_value ::= NK_LP literal_list NK_RP */ - 529, /* (648) boolean_value_expression ::= boolean_primary */ - 529, /* (649) boolean_value_expression ::= NOT boolean_primary */ - 529, /* (650) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - 529, /* (651) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - 530, /* (652) boolean_primary ::= predicate */ - 530, /* (653) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - 523, /* (654) common_expression ::= expr_or_subquery */ - 523, /* (655) common_expression ::= boolean_value_expression */ - 531, /* (656) from_clause_opt ::= */ - 531, /* (657) from_clause_opt ::= FROM table_reference_list */ - 532, /* (658) table_reference_list ::= table_reference */ - 532, /* (659) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - 533, /* (660) table_reference ::= table_primary */ - 533, /* (661) table_reference ::= joined_table */ - 534, /* (662) table_primary ::= table_name alias_opt */ - 534, /* (663) table_primary ::= db_name NK_DOT table_name alias_opt */ - 534, /* (664) table_primary ::= subquery alias_opt */ - 534, /* (665) table_primary ::= parenthesized_joined_table */ - 536, /* (666) alias_opt ::= */ - 536, /* (667) alias_opt ::= table_alias */ - 536, /* (668) alias_opt ::= AS table_alias */ - 538, /* (669) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - 538, /* (670) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - 535, /* (671) joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ - 539, /* (672) join_type ::= */ - 539, /* (673) join_type ::= INNER */ - 539, /* (674) join_type ::= LEFT */ - 539, /* (675) join_type ::= RIGHT */ - 539, /* (676) join_type ::= FULL */ - 540, /* (677) join_subtype ::= */ - 540, /* (678) join_subtype ::= OUTER */ - 540, /* (679) join_subtype ::= SEMI */ - 540, /* (680) join_subtype ::= ANTI */ - 540, /* (681) join_subtype ::= ASOF */ - 540, /* (682) join_subtype ::= WINDOW */ - 541, /* (683) join_on_clause_opt ::= */ - 541, /* (684) join_on_clause_opt ::= ON search_condition */ - 542, /* (685) window_offset_clause_opt ::= */ - 542, /* (686) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ - 544, /* (687) window_offset_literal ::= NK_VARIABLE */ - 544, /* (688) window_offset_literal ::= NK_MINUS NK_VARIABLE */ - 543, /* (689) jlimit_clause_opt ::= */ - 543, /* (690) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - 545, /* (691) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 546, /* (692) hint_list ::= */ - 546, /* (693) hint_list ::= NK_HINT */ - 548, /* (694) tag_mode_opt ::= */ - 548, /* (695) tag_mode_opt ::= TAGS */ - 547, /* (696) set_quantifier_opt ::= */ - 547, /* (697) set_quantifier_opt ::= DISTINCT */ - 547, /* (698) set_quantifier_opt ::= ALL */ - 549, /* (699) select_list ::= select_item */ - 549, /* (700) select_list ::= select_list NK_COMMA select_item */ - 557, /* (701) select_item ::= NK_STAR */ - 557, /* (702) select_item ::= common_expression */ - 557, /* (703) select_item ::= common_expression column_alias */ - 557, /* (704) select_item ::= common_expression AS column_alias */ - 557, /* (705) select_item ::= table_name NK_DOT NK_STAR */ - 481, /* (706) where_clause_opt ::= */ - 481, /* (707) where_clause_opt ::= WHERE search_condition */ - 550, /* (708) partition_by_clause_opt ::= */ - 550, /* (709) partition_by_clause_opt ::= PARTITION BY partition_list */ - 558, /* (710) partition_list ::= partition_item */ - 558, /* (711) partition_list ::= partition_list NK_COMMA partition_item */ - 559, /* (712) partition_item ::= expr_or_subquery */ - 559, /* (713) partition_item ::= expr_or_subquery column_alias */ - 559, /* (714) partition_item ::= expr_or_subquery AS column_alias */ - 554, /* (715) twindow_clause_opt ::= */ - 554, /* (716) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - 554, /* (717) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - 554, /* (718) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 554, /* (719) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 554, /* (720) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - 554, /* (721) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ - 554, /* (722) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 554, /* (723) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ - 554, /* (724) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ - 474, /* (725) sliding_opt ::= */ - 474, /* (726) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - 560, /* (727) interval_sliding_duration_literal ::= NK_VARIABLE */ - 560, /* (728) interval_sliding_duration_literal ::= NK_STRING */ - 560, /* (729) interval_sliding_duration_literal ::= NK_INTEGER */ - 553, /* (730) fill_opt ::= */ - 553, /* (731) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - 553, /* (732) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - 553, /* (733) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - 561, /* (734) fill_mode ::= NONE */ - 561, /* (735) fill_mode ::= PREV */ - 561, /* (736) fill_mode ::= NULL */ - 561, /* (737) fill_mode ::= NULL_F */ - 561, /* (738) fill_mode ::= LINEAR */ - 561, /* (739) fill_mode ::= NEXT */ - 555, /* (740) group_by_clause_opt ::= */ - 555, /* (741) group_by_clause_opt ::= GROUP BY group_by_list */ - 562, /* (742) group_by_list ::= expr_or_subquery */ - 562, /* (743) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 556, /* (744) having_clause_opt ::= */ - 556, /* (745) having_clause_opt ::= HAVING search_condition */ - 551, /* (746) range_opt ::= */ - 551, /* (747) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - 551, /* (748) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 552, /* (749) every_opt ::= */ - 552, /* (750) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - 563, /* (751) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - 564, /* (752) query_simple ::= query_specification */ - 564, /* (753) query_simple ::= union_query_expression */ - 568, /* (754) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - 568, /* (755) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - 569, /* (756) query_simple_or_subquery ::= query_simple */ - 569, /* (757) query_simple_or_subquery ::= subquery */ - 480, /* (758) query_or_subquery ::= query_expression */ - 480, /* (759) query_or_subquery ::= subquery */ - 565, /* (760) order_by_clause_opt ::= */ - 565, /* (761) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 566, /* (762) slimit_clause_opt ::= */ - 566, /* (763) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - 566, /* (764) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - 566, /* (765) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 567, /* (766) limit_clause_opt ::= */ - 567, /* (767) limit_clause_opt ::= LIMIT NK_INTEGER */ - 567, /* (768) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - 567, /* (769) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 537, /* (770) subquery ::= NK_LP query_expression NK_RP */ - 537, /* (771) subquery ::= NK_LP subquery NK_RP */ - 410, /* (772) search_condition ::= common_expression */ - 570, /* (773) sort_specification_list ::= sort_specification */ - 570, /* (774) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - 571, /* (775) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 572, /* (776) ordering_specification_opt ::= */ - 572, /* (777) ordering_specification_opt ::= ASC */ - 572, /* (778) ordering_specification_opt ::= DESC */ - 573, /* (779) null_ordering_opt ::= */ - 573, /* (780) null_ordering_opt ::= NULLS FIRST */ - 573, /* (781) null_ordering_opt ::= NULLS LAST */ - 440, /* (782) column_options ::= */ - 440, /* (783) column_options ::= column_options PRIMARY KEY */ - 440, /* (784) column_options ::= column_options NK_ID NK_STRING */ + 415, /* (145) db_options ::= db_options DNODES NK_STRING */ + 417, /* (146) alter_db_options ::= alter_db_option */ + 417, /* (147) alter_db_options ::= alter_db_options alter_db_option */ + 425, /* (148) alter_db_option ::= BUFFER NK_INTEGER */ + 425, /* (149) alter_db_option ::= CACHEMODEL NK_STRING */ + 425, /* (150) alter_db_option ::= CACHESIZE NK_INTEGER */ + 425, /* (151) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + 425, /* (152) alter_db_option ::= KEEP integer_list */ + 425, /* (153) alter_db_option ::= KEEP variable_list */ + 425, /* (154) alter_db_option ::= PAGES NK_INTEGER */ + 425, /* (155) alter_db_option ::= REPLICA NK_INTEGER */ + 425, /* (156) alter_db_option ::= WAL_LEVEL NK_INTEGER */ + 425, /* (157) alter_db_option ::= STT_TRIGGER NK_INTEGER */ + 425, /* (158) alter_db_option ::= MINROWS NK_INTEGER */ + 425, /* (159) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ + 425, /* (160) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + 425, /* (161) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ + 425, /* (162) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + 425, /* (163) alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ + 425, /* (164) alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ + 425, /* (165) alter_db_option ::= S3_COMPACT NK_INTEGER */ + 425, /* (166) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ + 425, /* (167) alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ + 421, /* (168) integer_list ::= NK_INTEGER */ + 421, /* (169) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + 422, /* (170) variable_list ::= NK_VARIABLE */ + 422, /* (171) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + 423, /* (172) retention_list ::= retention */ + 423, /* (173) retention_list ::= retention_list NK_COMMA retention */ + 426, /* (174) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + 426, /* (175) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ + 418, /* (176) speed_opt ::= */ + 418, /* (177) speed_opt ::= BWLIMIT NK_INTEGER */ + 419, /* (178) start_opt ::= */ + 419, /* (179) start_opt ::= START WITH NK_INTEGER */ + 419, /* (180) start_opt ::= START WITH NK_STRING */ + 419, /* (181) start_opt ::= START WITH TIMESTAMP NK_STRING */ + 420, /* (182) end_opt ::= */ + 420, /* (183) end_opt ::= END WITH NK_INTEGER */ + 420, /* (184) end_opt ::= END WITH NK_STRING */ + 420, /* (185) end_opt ::= END WITH TIMESTAMP NK_STRING */ + 390, /* (186) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + 390, /* (187) cmd ::= CREATE TABLE multi_create_clause */ + 390, /* (188) cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ + 390, /* (189) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + 390, /* (190) cmd ::= DROP TABLE with_opt multi_drop_clause */ + 390, /* (191) cmd ::= DROP STABLE with_opt exists_opt full_table_name */ + 390, /* (192) cmd ::= ALTER TABLE alter_table_clause */ + 390, /* (193) cmd ::= ALTER STABLE alter_table_clause */ + 436, /* (194) alter_table_clause ::= full_table_name alter_table_options */ + 436, /* (195) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ + 436, /* (196) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + 436, /* (197) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + 436, /* (198) alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ + 436, /* (199) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + 436, /* (200) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + 436, /* (201) alter_table_clause ::= full_table_name DROP TAG column_name */ + 436, /* (202) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + 436, /* (203) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + 436, /* (204) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ + 431, /* (205) multi_create_clause ::= create_subtable_clause */ + 431, /* (206) multi_create_clause ::= multi_create_clause create_subtable_clause */ + 442, /* (207) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ + 435, /* (208) multi_drop_clause ::= drop_table_clause */ + 435, /* (209) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ + 445, /* (210) drop_table_clause ::= exists_opt full_table_name */ + 434, /* (211) with_opt ::= */ + 434, /* (212) with_opt ::= WITH */ + 443, /* (213) specific_cols_opt ::= */ + 443, /* (214) specific_cols_opt ::= NK_LP col_name_list NK_RP */ + 427, /* (215) full_table_name ::= table_name */ + 427, /* (216) full_table_name ::= db_name NK_DOT table_name */ + 447, /* (217) tag_def_list ::= tag_def */ + 447, /* (218) tag_def_list ::= tag_def_list NK_COMMA tag_def */ + 448, /* (219) tag_def ::= column_name type_name */ + 428, /* (220) column_def_list ::= column_def */ + 428, /* (221) column_def_list ::= column_def_list NK_COMMA column_def */ + 449, /* (222) column_def ::= column_name type_name column_options */ + 439, /* (223) type_name ::= BOOL */ + 439, /* (224) type_name ::= TINYINT */ + 439, /* (225) type_name ::= SMALLINT */ + 439, /* (226) type_name ::= INT */ + 439, /* (227) type_name ::= INTEGER */ + 439, /* (228) type_name ::= BIGINT */ + 439, /* (229) type_name ::= FLOAT */ + 439, /* (230) type_name ::= DOUBLE */ + 439, /* (231) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + 439, /* (232) type_name ::= TIMESTAMP */ + 439, /* (233) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + 439, /* (234) type_name ::= TINYINT UNSIGNED */ + 439, /* (235) type_name ::= SMALLINT UNSIGNED */ + 439, /* (236) type_name ::= INT UNSIGNED */ + 439, /* (237) type_name ::= BIGINT UNSIGNED */ + 439, /* (238) type_name ::= JSON */ + 439, /* (239) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + 439, /* (240) type_name ::= MEDIUMBLOB */ + 439, /* (241) type_name ::= BLOB */ + 439, /* (242) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + 439, /* (243) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ + 439, /* (244) type_name ::= DECIMAL */ + 439, /* (245) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + 439, /* (246) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + 450, /* (247) type_name_default_len ::= BINARY */ + 450, /* (248) type_name_default_len ::= NCHAR */ + 450, /* (249) type_name_default_len ::= VARCHAR */ + 450, /* (250) type_name_default_len ::= VARBINARY */ + 429, /* (251) tags_def_opt ::= */ + 429, /* (252) tags_def_opt ::= tags_def */ + 433, /* (253) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + 430, /* (254) table_options ::= */ + 430, /* (255) table_options ::= table_options COMMENT NK_STRING */ + 430, /* (256) table_options ::= table_options MAX_DELAY duration_list */ + 430, /* (257) table_options ::= table_options WATERMARK duration_list */ + 430, /* (258) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + 430, /* (259) table_options ::= table_options TTL NK_INTEGER */ + 430, /* (260) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + 430, /* (261) table_options ::= table_options DELETE_MARK duration_list */ + 437, /* (262) alter_table_options ::= alter_table_option */ + 437, /* (263) alter_table_options ::= alter_table_options alter_table_option */ + 453, /* (264) alter_table_option ::= COMMENT NK_STRING */ + 453, /* (265) alter_table_option ::= TTL NK_INTEGER */ + 451, /* (266) duration_list ::= duration_literal */ + 451, /* (267) duration_list ::= duration_list NK_COMMA duration_literal */ + 452, /* (268) rollup_func_list ::= rollup_func_name */ + 452, /* (269) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + 455, /* (270) rollup_func_name ::= function_name */ + 455, /* (271) rollup_func_name ::= FIRST */ + 455, /* (272) rollup_func_name ::= LAST */ + 446, /* (273) col_name_list ::= col_name */ + 446, /* (274) col_name_list ::= col_name_list NK_COMMA col_name */ + 457, /* (275) col_name ::= column_name */ + 390, /* (276) cmd ::= SHOW DNODES */ + 390, /* (277) cmd ::= SHOW USERS */ + 390, /* (278) cmd ::= SHOW USERS FULL */ + 390, /* (279) cmd ::= SHOW USER PRIVILEGES */ + 390, /* (280) cmd ::= SHOW db_kind_opt DATABASES */ + 390, /* (281) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + 390, /* (282) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + 390, /* (283) cmd ::= SHOW db_name_cond_opt VGROUPS */ + 390, /* (284) cmd ::= SHOW MNODES */ + 390, /* (285) cmd ::= SHOW QNODES */ + 390, /* (286) cmd ::= SHOW ANODES */ + 390, /* (287) cmd ::= SHOW ANODES FULL */ + 390, /* (288) cmd ::= SHOW ARBGROUPS */ + 390, /* (289) cmd ::= SHOW FUNCTIONS */ + 390, /* (290) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + 390, /* (291) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + 390, /* (292) cmd ::= SHOW STREAMS */ + 390, /* (293) cmd ::= SHOW ACCOUNTS */ + 390, /* (294) cmd ::= SHOW APPS */ + 390, /* (295) cmd ::= SHOW CONNECTIONS */ + 390, /* (296) cmd ::= SHOW LICENCES */ + 390, /* (297) cmd ::= SHOW GRANTS */ + 390, /* (298) cmd ::= SHOW GRANTS FULL */ + 390, /* (299) cmd ::= SHOW GRANTS LOGS */ + 390, /* (300) cmd ::= SHOW CLUSTER MACHINES */ + 390, /* (301) cmd ::= SHOW CREATE DATABASE db_name */ + 390, /* (302) cmd ::= SHOW CREATE TABLE full_table_name */ + 390, /* (303) cmd ::= SHOW CREATE STABLE full_table_name */ + 390, /* (304) cmd ::= SHOW ENCRYPTIONS */ + 390, /* (305) cmd ::= SHOW QUERIES */ + 390, /* (306) cmd ::= SHOW SCORES */ + 390, /* (307) cmd ::= SHOW TOPICS */ + 390, /* (308) cmd ::= SHOW VARIABLES */ + 390, /* (309) cmd ::= SHOW CLUSTER VARIABLES */ + 390, /* (310) cmd ::= SHOW LOCAL VARIABLES */ + 390, /* (311) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + 390, /* (312) cmd ::= SHOW BNODES */ + 390, /* (313) cmd ::= SHOW SNODES */ + 390, /* (314) cmd ::= SHOW CLUSTER */ + 390, /* (315) cmd ::= SHOW TRANSACTIONS */ + 390, /* (316) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + 390, /* (317) cmd ::= SHOW CONSUMERS */ + 390, /* (318) cmd ::= SHOW SUBSCRIPTIONS */ + 390, /* (319) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + 390, /* (320) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + 390, /* (321) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + 390, /* (322) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + 390, /* (323) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + 390, /* (324) cmd ::= SHOW VNODES */ + 390, /* (325) cmd ::= SHOW db_name_cond_opt ALIVE */ + 390, /* (326) cmd ::= SHOW CLUSTER ALIVE */ + 390, /* (327) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ + 390, /* (328) cmd ::= SHOW CREATE VIEW full_table_name */ + 390, /* (329) cmd ::= SHOW COMPACTS */ + 390, /* (330) cmd ::= SHOW COMPACT NK_INTEGER */ + 459, /* (331) table_kind_db_name_cond_opt ::= */ + 459, /* (332) table_kind_db_name_cond_opt ::= table_kind */ + 459, /* (333) table_kind_db_name_cond_opt ::= db_name NK_DOT */ + 459, /* (334) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + 464, /* (335) table_kind ::= NORMAL */ + 464, /* (336) table_kind ::= CHILD */ + 461, /* (337) db_name_cond_opt ::= */ + 461, /* (338) db_name_cond_opt ::= db_name NK_DOT */ + 460, /* (339) like_pattern_opt ::= */ + 460, /* (340) like_pattern_opt ::= LIKE NK_STRING */ + 462, /* (341) table_name_cond ::= table_name */ + 463, /* (342) from_db_opt ::= */ + 463, /* (343) from_db_opt ::= FROM db_name */ + 432, /* (344) tag_list_opt ::= */ + 432, /* (345) tag_list_opt ::= tag_item */ + 432, /* (346) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + 465, /* (347) tag_item ::= TBNAME */ + 465, /* (348) tag_item ::= QTAGS */ + 465, /* (349) tag_item ::= column_name */ + 465, /* (350) tag_item ::= column_name column_alias */ + 465, /* (351) tag_item ::= column_name AS column_alias */ + 458, /* (352) db_kind_opt ::= */ + 458, /* (353) db_kind_opt ::= USER */ + 458, /* (354) db_kind_opt ::= SYSTEM */ + 390, /* (355) cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ + 390, /* (356) cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ + 390, /* (357) cmd ::= DROP TSMA exists_opt full_tsma_name */ + 390, /* (358) cmd ::= SHOW db_name_cond_opt TSMAS */ + 469, /* (359) full_tsma_name ::= tsma_name */ + 469, /* (360) full_tsma_name ::= db_name NK_DOT tsma_name */ + 468, /* (361) tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ + 390, /* (362) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + 390, /* (363) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + 390, /* (364) cmd ::= DROP INDEX exists_opt full_index_name */ + 472, /* (365) full_index_name ::= index_name */ + 472, /* (366) full_index_name ::= db_name NK_DOT index_name */ + 471, /* (367) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + 471, /* (368) 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 */ + 470, /* (369) func_list ::= func */ + 470, /* (370) func_list ::= func_list NK_COMMA func */ + 476, /* (371) func ::= sma_func_name NK_LP expression_list NK_RP */ + 477, /* (372) sma_func_name ::= function_name */ + 477, /* (373) sma_func_name ::= COUNT */ + 477, /* (374) sma_func_name ::= FIRST */ + 477, /* (375) sma_func_name ::= LAST */ + 477, /* (376) sma_func_name ::= LAST_ROW */ + 475, /* (377) sma_stream_opt ::= */ + 475, /* (378) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + 475, /* (379) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + 475, /* (380) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + 479, /* (381) with_meta ::= AS */ + 479, /* (382) with_meta ::= WITH META AS */ + 479, /* (383) with_meta ::= ONLY META AS */ + 390, /* (384) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + 390, /* (385) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + 390, /* (386) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + 390, /* (387) cmd ::= DROP TOPIC exists_opt topic_name */ + 390, /* (388) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + 390, /* (389) cmd ::= DESC full_table_name */ + 390, /* (390) cmd ::= DESCRIBE full_table_name */ + 390, /* (391) cmd ::= RESET QUERY CACHE */ + 390, /* (392) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + 390, /* (393) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + 483, /* (394) analyze_opt ::= */ + 483, /* (395) analyze_opt ::= ANALYZE */ + 484, /* (396) explain_options ::= */ + 484, /* (397) explain_options ::= explain_options VERBOSE NK_BOOL */ + 484, /* (398) explain_options ::= explain_options RATIO NK_FLOAT */ + 390, /* (399) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + 390, /* (400) cmd ::= DROP FUNCTION exists_opt function_name */ + 487, /* (401) agg_func_opt ::= */ + 487, /* (402) agg_func_opt ::= AGGREGATE */ + 488, /* (403) bufsize_opt ::= */ + 488, /* (404) bufsize_opt ::= BUFSIZE NK_INTEGER */ + 489, /* (405) language_opt ::= */ + 489, /* (406) language_opt ::= LANGUAGE NK_STRING */ + 486, /* (407) or_replace_opt ::= */ + 486, /* (408) or_replace_opt ::= OR REPLACE */ + 390, /* (409) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + 390, /* (410) cmd ::= DROP VIEW exists_opt full_view_name */ + 490, /* (411) full_view_name ::= view_name */ + 490, /* (412) full_view_name ::= db_name NK_DOT view_name */ + 390, /* (413) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ + 390, /* (414) cmd ::= DROP STREAM exists_opt stream_name */ + 390, /* (415) cmd ::= PAUSE STREAM exists_opt stream_name */ + 390, /* (416) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + 494, /* (417) col_list_opt ::= */ + 494, /* (418) col_list_opt ::= NK_LP column_stream_def_list NK_RP */ + 498, /* (419) column_stream_def_list ::= column_stream_def */ + 498, /* (420) column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ + 499, /* (421) column_stream_def ::= column_name stream_col_options */ + 500, /* (422) stream_col_options ::= */ + 500, /* (423) stream_col_options ::= stream_col_options PRIMARY KEY */ + 495, /* (424) tag_def_or_ref_opt ::= */ + 495, /* (425) tag_def_or_ref_opt ::= tags_def */ + 495, /* (426) tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ + 493, /* (427) stream_options ::= */ + 493, /* (428) stream_options ::= stream_options TRIGGER AT_ONCE */ + 493, /* (429) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + 493, /* (430) stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ + 493, /* (431) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + 493, /* (432) stream_options ::= stream_options WATERMARK duration_literal */ + 493, /* (433) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + 493, /* (434) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + 493, /* (435) stream_options ::= stream_options DELETE_MARK duration_literal */ + 493, /* (436) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + 496, /* (437) subtable_opt ::= */ + 496, /* (438) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + 497, /* (439) ignore_opt ::= */ + 497, /* (440) ignore_opt ::= IGNORE UNTREATED */ + 390, /* (441) cmd ::= KILL CONNECTION NK_INTEGER */ + 390, /* (442) cmd ::= KILL QUERY NK_STRING */ + 390, /* (443) cmd ::= KILL TRANSACTION NK_INTEGER */ + 390, /* (444) cmd ::= KILL COMPACT NK_INTEGER */ + 390, /* (445) cmd ::= BALANCE VGROUP */ + 390, /* (446) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + 390, /* (447) cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ + 390, /* (448) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + 390, /* (449) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + 390, /* (450) cmd ::= SPLIT VGROUP NK_INTEGER */ + 502, /* (451) on_vgroup_id ::= */ + 502, /* (452) on_vgroup_id ::= ON NK_INTEGER */ + 503, /* (453) dnode_list ::= DNODE NK_INTEGER */ + 503, /* (454) dnode_list ::= dnode_list DNODE NK_INTEGER */ + 390, /* (455) cmd ::= DELETE FROM full_table_name where_clause_opt */ + 390, /* (456) cmd ::= query_or_subquery */ + 390, /* (457) cmd ::= insert_query */ + 485, /* (458) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + 485, /* (459) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + 441, /* (460) tags_literal ::= NK_INTEGER */ + 441, /* (461) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + 441, /* (462) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ + 441, /* (463) tags_literal ::= NK_PLUS NK_INTEGER */ + 441, /* (464) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + 441, /* (465) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ + 441, /* (466) tags_literal ::= NK_MINUS NK_INTEGER */ + 441, /* (467) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ + 441, /* (468) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ + 441, /* (469) tags_literal ::= NK_FLOAT */ + 441, /* (470) tags_literal ::= NK_PLUS NK_FLOAT */ + 441, /* (471) tags_literal ::= NK_MINUS NK_FLOAT */ + 441, /* (472) tags_literal ::= NK_BIN */ + 441, /* (473) tags_literal ::= NK_BIN NK_PLUS duration_literal */ + 441, /* (474) tags_literal ::= NK_BIN NK_MINUS duration_literal */ + 441, /* (475) tags_literal ::= NK_PLUS NK_BIN */ + 441, /* (476) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ + 441, /* (477) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ + 441, /* (478) tags_literal ::= NK_MINUS NK_BIN */ + 441, /* (479) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ + 441, /* (480) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ + 441, /* (481) tags_literal ::= NK_HEX */ + 441, /* (482) tags_literal ::= NK_HEX NK_PLUS duration_literal */ + 441, /* (483) tags_literal ::= NK_HEX NK_MINUS duration_literal */ + 441, /* (484) tags_literal ::= NK_PLUS NK_HEX */ + 441, /* (485) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ + 441, /* (486) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ + 441, /* (487) tags_literal ::= NK_MINUS NK_HEX */ + 441, /* (488) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ + 441, /* (489) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ + 441, /* (490) tags_literal ::= NK_STRING */ + 441, /* (491) tags_literal ::= NK_STRING NK_PLUS duration_literal */ + 441, /* (492) tags_literal ::= NK_STRING NK_MINUS duration_literal */ + 441, /* (493) tags_literal ::= NK_BOOL */ + 441, /* (494) tags_literal ::= NULL */ + 441, /* (495) tags_literal ::= literal_func */ + 441, /* (496) tags_literal ::= literal_func NK_PLUS duration_literal */ + 441, /* (497) tags_literal ::= literal_func NK_MINUS duration_literal */ + 444, /* (498) tags_literal_list ::= tags_literal */ + 444, /* (499) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ + 393, /* (500) literal ::= NK_INTEGER */ + 393, /* (501) literal ::= NK_FLOAT */ + 393, /* (502) literal ::= NK_STRING */ + 393, /* (503) literal ::= NK_BOOL */ + 393, /* (504) literal ::= TIMESTAMP NK_STRING */ + 393, /* (505) literal ::= duration_literal */ + 393, /* (506) literal ::= NULL */ + 393, /* (507) literal ::= NK_QUESTION */ + 454, /* (508) duration_literal ::= NK_VARIABLE */ + 424, /* (509) signed ::= NK_INTEGER */ + 424, /* (510) signed ::= NK_PLUS NK_INTEGER */ + 424, /* (511) signed ::= NK_MINUS NK_INTEGER */ + 424, /* (512) signed ::= NK_FLOAT */ + 424, /* (513) signed ::= NK_PLUS NK_FLOAT */ + 424, /* (514) signed ::= NK_MINUS NK_FLOAT */ + 505, /* (515) signed_literal ::= signed */ + 505, /* (516) signed_literal ::= NK_STRING */ + 505, /* (517) signed_literal ::= NK_BOOL */ + 505, /* (518) signed_literal ::= TIMESTAMP NK_STRING */ + 505, /* (519) signed_literal ::= duration_literal */ + 505, /* (520) signed_literal ::= NULL */ + 505, /* (521) signed_literal ::= literal_func */ + 505, /* (522) signed_literal ::= NK_QUESTION */ + 506, /* (523) literal_list ::= signed_literal */ + 506, /* (524) literal_list ::= literal_list NK_COMMA signed_literal */ + 407, /* (525) db_name ::= NK_ID */ + 408, /* (526) table_name ::= NK_ID */ + 438, /* (527) column_name ::= NK_ID */ + 456, /* (528) function_name ::= NK_ID */ + 491, /* (529) view_name ::= NK_ID */ + 507, /* (530) table_alias ::= NK_ID */ + 466, /* (531) column_alias ::= NK_ID */ + 466, /* (532) column_alias ::= NK_ALIAS */ + 400, /* (533) user_name ::= NK_ID */ + 409, /* (534) topic_name ::= NK_ID */ + 492, /* (535) stream_name ::= NK_ID */ + 482, /* (536) cgroup_name ::= NK_ID */ + 473, /* (537) index_name ::= NK_ID */ + 467, /* (538) tsma_name ::= NK_ID */ + 508, /* (539) expr_or_subquery ::= expression */ + 501, /* (540) expression ::= literal */ + 501, /* (541) expression ::= pseudo_column */ + 501, /* (542) expression ::= column_reference */ + 501, /* (543) expression ::= function_expression */ + 501, /* (544) expression ::= case_when_expression */ + 501, /* (545) expression ::= NK_LP expression NK_RP */ + 501, /* (546) expression ::= NK_PLUS expr_or_subquery */ + 501, /* (547) expression ::= NK_MINUS expr_or_subquery */ + 501, /* (548) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + 501, /* (549) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + 501, /* (550) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + 501, /* (551) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + 501, /* (552) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + 501, /* (553) expression ::= column_reference NK_ARROW NK_STRING */ + 501, /* (554) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + 501, /* (555) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + 478, /* (556) expression_list ::= expr_or_subquery */ + 478, /* (557) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + 510, /* (558) column_reference ::= column_name */ + 510, /* (559) column_reference ::= table_name NK_DOT column_name */ + 510, /* (560) column_reference ::= NK_ALIAS */ + 510, /* (561) column_reference ::= table_name NK_DOT NK_ALIAS */ + 509, /* (562) pseudo_column ::= ROWTS */ + 509, /* (563) pseudo_column ::= TBNAME */ + 509, /* (564) pseudo_column ::= table_name NK_DOT TBNAME */ + 509, /* (565) pseudo_column ::= QSTART */ + 509, /* (566) pseudo_column ::= QEND */ + 509, /* (567) pseudo_column ::= QDURATION */ + 509, /* (568) pseudo_column ::= WSTART */ + 509, /* (569) pseudo_column ::= WEND */ + 509, /* (570) pseudo_column ::= WDURATION */ + 509, /* (571) pseudo_column ::= IROWTS */ + 509, /* (572) pseudo_column ::= ISFILLED */ + 509, /* (573) pseudo_column ::= QTAGS */ + 509, /* (574) pseudo_column ::= FLOW */ + 509, /* (575) pseudo_column ::= FHIGH */ + 509, /* (576) pseudo_column ::= FROWTS */ + 511, /* (577) function_expression ::= function_name NK_LP expression_list NK_RP */ + 511, /* (578) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + 511, /* (579) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + 511, /* (580) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ + 511, /* (581) function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ + 511, /* (582) function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ + 511, /* (583) function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ + 511, /* (584) function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + 511, /* (585) function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ + 511, /* (586) function_expression ::= substr_func NK_LP expression_list NK_RP */ + 511, /* (587) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + 511, /* (588) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ + 511, /* (589) function_expression ::= REPLACE NK_LP expression_list NK_RP */ + 511, /* (590) function_expression ::= literal_func */ + 511, /* (591) function_expression ::= rand_func */ + 504, /* (592) literal_func ::= noarg_func NK_LP NK_RP */ + 504, /* (593) literal_func ::= NOW */ + 504, /* (594) literal_func ::= TODAY */ + 517, /* (595) rand_func ::= RAND NK_LP NK_RP */ + 517, /* (596) rand_func ::= RAND NK_LP expression_list NK_RP */ + 516, /* (597) substr_func ::= SUBSTR */ + 516, /* (598) substr_func ::= SUBSTRING */ + 515, /* (599) trim_specification_type ::= BOTH */ + 515, /* (600) trim_specification_type ::= TRAILING */ + 515, /* (601) trim_specification_type ::= LEADING */ + 518, /* (602) noarg_func ::= NOW */ + 518, /* (603) noarg_func ::= TODAY */ + 518, /* (604) noarg_func ::= TIMEZONE */ + 518, /* (605) noarg_func ::= DATABASE */ + 518, /* (606) noarg_func ::= CLIENT_VERSION */ + 518, /* (607) noarg_func ::= SERVER_VERSION */ + 518, /* (608) noarg_func ::= SERVER_STATUS */ + 518, /* (609) noarg_func ::= CURRENT_USER */ + 518, /* (610) noarg_func ::= USER */ + 518, /* (611) noarg_func ::= PI */ + 513, /* (612) star_func ::= COUNT */ + 513, /* (613) star_func ::= FIRST */ + 513, /* (614) star_func ::= LAST */ + 513, /* (615) star_func ::= LAST_ROW */ + 514, /* (616) star_func_para_list ::= NK_STAR */ + 514, /* (617) star_func_para_list ::= other_para_list */ + 519, /* (618) other_para_list ::= star_func_para */ + 519, /* (619) other_para_list ::= other_para_list NK_COMMA star_func_para */ + 520, /* (620) star_func_para ::= expr_or_subquery */ + 520, /* (621) star_func_para ::= table_name NK_DOT NK_STAR */ + 512, /* (622) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + 512, /* (623) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + 521, /* (624) when_then_list ::= when_then_expr */ + 521, /* (625) when_then_list ::= when_then_list when_then_expr */ + 524, /* (626) when_then_expr ::= WHEN common_expression THEN common_expression */ + 522, /* (627) case_when_else_opt ::= */ + 522, /* (628) case_when_else_opt ::= ELSE common_expression */ + 525, /* (629) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + 525, /* (630) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + 525, /* (631) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + 525, /* (632) predicate ::= expr_or_subquery IS NULL */ + 525, /* (633) predicate ::= expr_or_subquery IS NOT NULL */ + 525, /* (634) predicate ::= expr_or_subquery in_op in_predicate_value */ + 526, /* (635) compare_op ::= NK_LT */ + 526, /* (636) compare_op ::= NK_GT */ + 526, /* (637) compare_op ::= NK_LE */ + 526, /* (638) compare_op ::= NK_GE */ + 526, /* (639) compare_op ::= NK_NE */ + 526, /* (640) compare_op ::= NK_EQ */ + 526, /* (641) compare_op ::= LIKE */ + 526, /* (642) compare_op ::= NOT LIKE */ + 526, /* (643) compare_op ::= MATCH */ + 526, /* (644) compare_op ::= NMATCH */ + 526, /* (645) compare_op ::= CONTAINS */ + 527, /* (646) in_op ::= IN */ + 527, /* (647) in_op ::= NOT IN */ + 528, /* (648) in_predicate_value ::= NK_LP literal_list NK_RP */ + 529, /* (649) boolean_value_expression ::= boolean_primary */ + 529, /* (650) boolean_value_expression ::= NOT boolean_primary */ + 529, /* (651) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + 529, /* (652) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + 530, /* (653) boolean_primary ::= predicate */ + 530, /* (654) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + 523, /* (655) common_expression ::= expr_or_subquery */ + 523, /* (656) common_expression ::= boolean_value_expression */ + 531, /* (657) from_clause_opt ::= */ + 531, /* (658) from_clause_opt ::= FROM table_reference_list */ + 532, /* (659) table_reference_list ::= table_reference */ + 532, /* (660) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + 533, /* (661) table_reference ::= table_primary */ + 533, /* (662) table_reference ::= joined_table */ + 534, /* (663) table_primary ::= table_name alias_opt */ + 534, /* (664) table_primary ::= db_name NK_DOT table_name alias_opt */ + 534, /* (665) table_primary ::= subquery alias_opt */ + 534, /* (666) table_primary ::= parenthesized_joined_table */ + 536, /* (667) alias_opt ::= */ + 536, /* (668) alias_opt ::= table_alias */ + 536, /* (669) alias_opt ::= AS table_alias */ + 538, /* (670) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + 538, /* (671) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + 535, /* (672) joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ + 539, /* (673) join_type ::= */ + 539, /* (674) join_type ::= INNER */ + 539, /* (675) join_type ::= LEFT */ + 539, /* (676) join_type ::= RIGHT */ + 539, /* (677) join_type ::= FULL */ + 540, /* (678) join_subtype ::= */ + 540, /* (679) join_subtype ::= OUTER */ + 540, /* (680) join_subtype ::= SEMI */ + 540, /* (681) join_subtype ::= ANTI */ + 540, /* (682) join_subtype ::= ASOF */ + 540, /* (683) join_subtype ::= WINDOW */ + 541, /* (684) join_on_clause_opt ::= */ + 541, /* (685) join_on_clause_opt ::= ON search_condition */ + 542, /* (686) window_offset_clause_opt ::= */ + 542, /* (687) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ + 544, /* (688) window_offset_literal ::= NK_VARIABLE */ + 544, /* (689) window_offset_literal ::= NK_MINUS NK_VARIABLE */ + 543, /* (690) jlimit_clause_opt ::= */ + 543, /* (691) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + 545, /* (692) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 546, /* (693) hint_list ::= */ + 546, /* (694) hint_list ::= NK_HINT */ + 548, /* (695) tag_mode_opt ::= */ + 548, /* (696) tag_mode_opt ::= TAGS */ + 547, /* (697) set_quantifier_opt ::= */ + 547, /* (698) set_quantifier_opt ::= DISTINCT */ + 547, /* (699) set_quantifier_opt ::= ALL */ + 549, /* (700) select_list ::= select_item */ + 549, /* (701) select_list ::= select_list NK_COMMA select_item */ + 557, /* (702) select_item ::= NK_STAR */ + 557, /* (703) select_item ::= common_expression */ + 557, /* (704) select_item ::= common_expression column_alias */ + 557, /* (705) select_item ::= common_expression AS column_alias */ + 557, /* (706) select_item ::= table_name NK_DOT NK_STAR */ + 481, /* (707) where_clause_opt ::= */ + 481, /* (708) where_clause_opt ::= WHERE search_condition */ + 550, /* (709) partition_by_clause_opt ::= */ + 550, /* (710) partition_by_clause_opt ::= PARTITION BY partition_list */ + 558, /* (711) partition_list ::= partition_item */ + 558, /* (712) partition_list ::= partition_list NK_COMMA partition_item */ + 559, /* (713) partition_item ::= expr_or_subquery */ + 559, /* (714) partition_item ::= expr_or_subquery column_alias */ + 559, /* (715) partition_item ::= expr_or_subquery AS column_alias */ + 554, /* (716) twindow_clause_opt ::= */ + 554, /* (717) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + 554, /* (718) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + 554, /* (719) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 554, /* (720) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 554, /* (721) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + 554, /* (722) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ + 554, /* (723) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + 554, /* (724) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ + 554, /* (725) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ + 474, /* (726) sliding_opt ::= */ + 474, /* (727) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + 560, /* (728) interval_sliding_duration_literal ::= NK_VARIABLE */ + 560, /* (729) interval_sliding_duration_literal ::= NK_STRING */ + 560, /* (730) interval_sliding_duration_literal ::= NK_INTEGER */ + 553, /* (731) fill_opt ::= */ + 553, /* (732) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + 553, /* (733) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + 553, /* (734) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + 561, /* (735) fill_mode ::= NONE */ + 561, /* (736) fill_mode ::= PREV */ + 561, /* (737) fill_mode ::= NULL */ + 561, /* (738) fill_mode ::= NULL_F */ + 561, /* (739) fill_mode ::= LINEAR */ + 561, /* (740) fill_mode ::= NEXT */ + 555, /* (741) group_by_clause_opt ::= */ + 555, /* (742) group_by_clause_opt ::= GROUP BY group_by_list */ + 562, /* (743) group_by_list ::= expr_or_subquery */ + 562, /* (744) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 556, /* (745) having_clause_opt ::= */ + 556, /* (746) having_clause_opt ::= HAVING search_condition */ + 551, /* (747) range_opt ::= */ + 551, /* (748) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + 551, /* (749) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 552, /* (750) every_opt ::= */ + 552, /* (751) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + 563, /* (752) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + 564, /* (753) query_simple ::= query_specification */ + 564, /* (754) query_simple ::= union_query_expression */ + 568, /* (755) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + 568, /* (756) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + 569, /* (757) query_simple_or_subquery ::= query_simple */ + 569, /* (758) query_simple_or_subquery ::= subquery */ + 480, /* (759) query_or_subquery ::= query_expression */ + 480, /* (760) query_or_subquery ::= subquery */ + 565, /* (761) order_by_clause_opt ::= */ + 565, /* (762) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 566, /* (763) slimit_clause_opt ::= */ + 566, /* (764) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + 566, /* (765) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + 566, /* (766) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 567, /* (767) limit_clause_opt ::= */ + 567, /* (768) limit_clause_opt ::= LIMIT NK_INTEGER */ + 567, /* (769) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + 567, /* (770) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 537, /* (771) subquery ::= NK_LP query_expression NK_RP */ + 537, /* (772) subquery ::= NK_LP subquery NK_RP */ + 410, /* (773) search_condition ::= common_expression */ + 570, /* (774) sort_specification_list ::= sort_specification */ + 570, /* (775) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + 571, /* (776) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 572, /* (777) ordering_specification_opt ::= */ + 572, /* (778) ordering_specification_opt ::= ASC */ + 572, /* (779) ordering_specification_opt ::= DESC */ + 573, /* (780) null_ordering_opt ::= */ + 573, /* (781) null_ordering_opt ::= NULLS FIRST */ + 573, /* (782) null_ordering_opt ::= NULLS LAST */ + 440, /* (783) column_options ::= */ + 440, /* (784) column_options ::= column_options PRIMARY KEY */ + 440, /* (785) column_options ::= column_options NK_ID NK_STRING */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -5330,646 +5332,647 @@ static const signed char yyRuleInfoNRhs[] = { -3, /* (142) db_options ::= db_options S3_COMPACT NK_INTEGER */ -3, /* (143) db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ -3, /* (144) db_options ::= db_options ENCRYPT_ALGORITHM NK_STRING */ - -1, /* (145) alter_db_options ::= alter_db_option */ - -2, /* (146) alter_db_options ::= alter_db_options alter_db_option */ - -2, /* (147) alter_db_option ::= BUFFER NK_INTEGER */ - -2, /* (148) alter_db_option ::= CACHEMODEL NK_STRING */ - -2, /* (149) alter_db_option ::= CACHESIZE NK_INTEGER */ - -2, /* (150) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ - -2, /* (151) alter_db_option ::= KEEP integer_list */ - -2, /* (152) alter_db_option ::= KEEP variable_list */ - -2, /* (153) alter_db_option ::= PAGES NK_INTEGER */ - -2, /* (154) alter_db_option ::= REPLICA NK_INTEGER */ - -2, /* (155) alter_db_option ::= WAL_LEVEL NK_INTEGER */ - -2, /* (156) alter_db_option ::= STT_TRIGGER NK_INTEGER */ - -2, /* (157) alter_db_option ::= MINROWS NK_INTEGER */ - -2, /* (158) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ - -3, /* (159) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - -2, /* (160) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ - -3, /* (161) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - -2, /* (162) alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ - -2, /* (163) alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ - -2, /* (164) alter_db_option ::= S3_COMPACT NK_INTEGER */ - -2, /* (165) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ - -2, /* (166) alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ - -1, /* (167) integer_list ::= NK_INTEGER */ - -3, /* (168) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - -1, /* (169) variable_list ::= NK_VARIABLE */ - -3, /* (170) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - -1, /* (171) retention_list ::= retention */ - -3, /* (172) retention_list ::= retention_list NK_COMMA retention */ - -3, /* (173) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - -3, /* (174) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ - 0, /* (175) speed_opt ::= */ - -2, /* (176) speed_opt ::= BWLIMIT NK_INTEGER */ - 0, /* (177) start_opt ::= */ - -3, /* (178) start_opt ::= START WITH NK_INTEGER */ - -3, /* (179) start_opt ::= START WITH NK_STRING */ - -4, /* (180) start_opt ::= START WITH TIMESTAMP NK_STRING */ - 0, /* (181) end_opt ::= */ - -3, /* (182) end_opt ::= END WITH NK_INTEGER */ - -3, /* (183) end_opt ::= END WITH NK_STRING */ - -4, /* (184) end_opt ::= END WITH TIMESTAMP NK_STRING */ - -9, /* (185) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - -3, /* (186) cmd ::= CREATE TABLE multi_create_clause */ - -10, /* (187) cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ - -9, /* (188) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - -4, /* (189) cmd ::= DROP TABLE with_opt multi_drop_clause */ - -5, /* (190) cmd ::= DROP STABLE with_opt exists_opt full_table_name */ - -3, /* (191) cmd ::= ALTER TABLE alter_table_clause */ - -3, /* (192) cmd ::= ALTER STABLE alter_table_clause */ - -2, /* (193) alter_table_clause ::= full_table_name alter_table_options */ - -6, /* (194) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ - -4, /* (195) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - -5, /* (196) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - -5, /* (197) alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ - -5, /* (198) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - -5, /* (199) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - -4, /* (200) alter_table_clause ::= full_table_name DROP TAG column_name */ - -5, /* (201) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - -5, /* (202) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - -6, /* (203) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ - -1, /* (204) multi_create_clause ::= create_subtable_clause */ - -2, /* (205) multi_create_clause ::= multi_create_clause create_subtable_clause */ - -10, /* (206) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ - -1, /* (207) multi_drop_clause ::= drop_table_clause */ - -3, /* (208) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ - -2, /* (209) drop_table_clause ::= exists_opt full_table_name */ - 0, /* (210) with_opt ::= */ - -1, /* (211) with_opt ::= WITH */ - 0, /* (212) specific_cols_opt ::= */ - -3, /* (213) specific_cols_opt ::= NK_LP col_name_list NK_RP */ - -1, /* (214) full_table_name ::= table_name */ - -3, /* (215) full_table_name ::= db_name NK_DOT table_name */ - -1, /* (216) tag_def_list ::= tag_def */ - -3, /* (217) tag_def_list ::= tag_def_list NK_COMMA tag_def */ - -2, /* (218) tag_def ::= column_name type_name */ - -1, /* (219) column_def_list ::= column_def */ - -3, /* (220) column_def_list ::= column_def_list NK_COMMA column_def */ - -3, /* (221) column_def ::= column_name type_name column_options */ - -1, /* (222) type_name ::= BOOL */ - -1, /* (223) type_name ::= TINYINT */ - -1, /* (224) type_name ::= SMALLINT */ - -1, /* (225) type_name ::= INT */ - -1, /* (226) type_name ::= INTEGER */ - -1, /* (227) type_name ::= BIGINT */ - -1, /* (228) type_name ::= FLOAT */ - -1, /* (229) type_name ::= DOUBLE */ - -4, /* (230) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - -1, /* (231) type_name ::= TIMESTAMP */ - -4, /* (232) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - -2, /* (233) type_name ::= TINYINT UNSIGNED */ - -2, /* (234) type_name ::= SMALLINT UNSIGNED */ - -2, /* (235) type_name ::= INT UNSIGNED */ - -2, /* (236) type_name ::= BIGINT UNSIGNED */ - -1, /* (237) type_name ::= JSON */ - -4, /* (238) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - -1, /* (239) type_name ::= MEDIUMBLOB */ - -1, /* (240) type_name ::= BLOB */ - -4, /* (241) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - -4, /* (242) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ - -1, /* (243) type_name ::= DECIMAL */ - -4, /* (244) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - -6, /* (245) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - -1, /* (246) type_name_default_len ::= BINARY */ - -1, /* (247) type_name_default_len ::= NCHAR */ - -1, /* (248) type_name_default_len ::= VARCHAR */ - -1, /* (249) type_name_default_len ::= VARBINARY */ - 0, /* (250) tags_def_opt ::= */ - -1, /* (251) tags_def_opt ::= tags_def */ - -4, /* (252) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - 0, /* (253) table_options ::= */ - -3, /* (254) table_options ::= table_options COMMENT NK_STRING */ - -3, /* (255) table_options ::= table_options MAX_DELAY duration_list */ - -3, /* (256) table_options ::= table_options WATERMARK duration_list */ - -5, /* (257) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - -3, /* (258) table_options ::= table_options TTL NK_INTEGER */ - -5, /* (259) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - -3, /* (260) table_options ::= table_options DELETE_MARK duration_list */ - -1, /* (261) alter_table_options ::= alter_table_option */ - -2, /* (262) alter_table_options ::= alter_table_options alter_table_option */ - -2, /* (263) alter_table_option ::= COMMENT NK_STRING */ - -2, /* (264) alter_table_option ::= TTL NK_INTEGER */ - -1, /* (265) duration_list ::= duration_literal */ - -3, /* (266) duration_list ::= duration_list NK_COMMA duration_literal */ - -1, /* (267) rollup_func_list ::= rollup_func_name */ - -3, /* (268) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - -1, /* (269) rollup_func_name ::= function_name */ - -1, /* (270) rollup_func_name ::= FIRST */ - -1, /* (271) rollup_func_name ::= LAST */ - -1, /* (272) col_name_list ::= col_name */ - -3, /* (273) col_name_list ::= col_name_list NK_COMMA col_name */ - -1, /* (274) col_name ::= column_name */ - -2, /* (275) cmd ::= SHOW DNODES */ - -2, /* (276) cmd ::= SHOW USERS */ - -3, /* (277) cmd ::= SHOW USERS FULL */ - -3, /* (278) cmd ::= SHOW USER PRIVILEGES */ - -3, /* (279) cmd ::= SHOW db_kind_opt DATABASES */ - -4, /* (280) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ - -4, /* (281) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - -3, /* (282) cmd ::= SHOW db_name_cond_opt VGROUPS */ - -2, /* (283) cmd ::= SHOW MNODES */ - -2, /* (284) cmd ::= SHOW QNODES */ - -2, /* (285) cmd ::= SHOW ANODES */ - -3, /* (286) cmd ::= SHOW ANODES FULL */ - -2, /* (287) cmd ::= SHOW ARBGROUPS */ - -2, /* (288) cmd ::= SHOW FUNCTIONS */ - -5, /* (289) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - -6, /* (290) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ - -2, /* (291) cmd ::= SHOW STREAMS */ - -2, /* (292) cmd ::= SHOW ACCOUNTS */ - -2, /* (293) cmd ::= SHOW APPS */ - -2, /* (294) cmd ::= SHOW CONNECTIONS */ - -2, /* (295) cmd ::= SHOW LICENCES */ - -2, /* (296) cmd ::= SHOW GRANTS */ - -3, /* (297) cmd ::= SHOW GRANTS FULL */ - -3, /* (298) cmd ::= SHOW GRANTS LOGS */ - -3, /* (299) cmd ::= SHOW CLUSTER MACHINES */ - -4, /* (300) cmd ::= SHOW CREATE DATABASE db_name */ - -4, /* (301) cmd ::= SHOW CREATE TABLE full_table_name */ - -4, /* (302) cmd ::= SHOW CREATE STABLE full_table_name */ - -2, /* (303) cmd ::= SHOW ENCRYPTIONS */ - -2, /* (304) cmd ::= SHOW QUERIES */ - -2, /* (305) cmd ::= SHOW SCORES */ - -2, /* (306) cmd ::= SHOW TOPICS */ - -2, /* (307) cmd ::= SHOW VARIABLES */ - -3, /* (308) cmd ::= SHOW CLUSTER VARIABLES */ - -3, /* (309) cmd ::= SHOW LOCAL VARIABLES */ - -5, /* (310) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - -2, /* (311) cmd ::= SHOW BNODES */ - -2, /* (312) cmd ::= SHOW SNODES */ - -2, /* (313) cmd ::= SHOW CLUSTER */ - -2, /* (314) cmd ::= SHOW TRANSACTIONS */ - -4, /* (315) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - -2, /* (316) cmd ::= SHOW CONSUMERS */ - -2, /* (317) cmd ::= SHOW SUBSCRIPTIONS */ - -5, /* (318) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - -6, /* (319) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ - -7, /* (320) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - -8, /* (321) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ - -5, /* (322) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ - -2, /* (323) cmd ::= SHOW VNODES */ - -3, /* (324) cmd ::= SHOW db_name_cond_opt ALIVE */ - -3, /* (325) cmd ::= SHOW CLUSTER ALIVE */ - -4, /* (326) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ - -4, /* (327) cmd ::= SHOW CREATE VIEW full_table_name */ - -2, /* (328) cmd ::= SHOW COMPACTS */ - -3, /* (329) cmd ::= SHOW COMPACT NK_INTEGER */ - 0, /* (330) table_kind_db_name_cond_opt ::= */ - -1, /* (331) table_kind_db_name_cond_opt ::= table_kind */ - -2, /* (332) table_kind_db_name_cond_opt ::= db_name NK_DOT */ - -3, /* (333) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ - -1, /* (334) table_kind ::= NORMAL */ - -1, /* (335) table_kind ::= CHILD */ - 0, /* (336) db_name_cond_opt ::= */ - -2, /* (337) db_name_cond_opt ::= db_name NK_DOT */ - 0, /* (338) like_pattern_opt ::= */ - -2, /* (339) like_pattern_opt ::= LIKE NK_STRING */ - -1, /* (340) table_name_cond ::= table_name */ - 0, /* (341) from_db_opt ::= */ - -2, /* (342) from_db_opt ::= FROM db_name */ - 0, /* (343) tag_list_opt ::= */ - -1, /* (344) tag_list_opt ::= tag_item */ - -3, /* (345) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - -1, /* (346) tag_item ::= TBNAME */ - -1, /* (347) tag_item ::= QTAGS */ - -1, /* (348) tag_item ::= column_name */ - -2, /* (349) tag_item ::= column_name column_alias */ - -3, /* (350) tag_item ::= column_name AS column_alias */ - 0, /* (351) db_kind_opt ::= */ - -1, /* (352) db_kind_opt ::= USER */ - -1, /* (353) db_kind_opt ::= SYSTEM */ - -11, /* (354) cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ - -11, /* (355) cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ - -4, /* (356) cmd ::= DROP TSMA exists_opt full_tsma_name */ - -3, /* (357) cmd ::= SHOW db_name_cond_opt TSMAS */ - -1, /* (358) full_tsma_name ::= tsma_name */ - -3, /* (359) full_tsma_name ::= db_name NK_DOT tsma_name */ - -4, /* (360) tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ - -8, /* (361) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ - -9, /* (362) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ - -4, /* (363) cmd ::= DROP INDEX exists_opt full_index_name */ - -1, /* (364) full_index_name ::= index_name */ - -3, /* (365) full_index_name ::= db_name NK_DOT index_name */ - -10, /* (366) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - -12, /* (367) 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 */ - -1, /* (368) func_list ::= func */ - -3, /* (369) func_list ::= func_list NK_COMMA func */ - -4, /* (370) func ::= sma_func_name NK_LP expression_list NK_RP */ - -1, /* (371) sma_func_name ::= function_name */ - -1, /* (372) sma_func_name ::= COUNT */ - -1, /* (373) sma_func_name ::= FIRST */ - -1, /* (374) sma_func_name ::= LAST */ - -1, /* (375) sma_func_name ::= LAST_ROW */ - 0, /* (376) sma_stream_opt ::= */ - -3, /* (377) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - -3, /* (378) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - -3, /* (379) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - -1, /* (380) with_meta ::= AS */ - -3, /* (381) with_meta ::= WITH META AS */ - -3, /* (382) with_meta ::= ONLY META AS */ - -6, /* (383) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - -7, /* (384) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ - -8, /* (385) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ - -4, /* (386) cmd ::= DROP TOPIC exists_opt topic_name */ - -7, /* (387) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - -2, /* (388) cmd ::= DESC full_table_name */ - -2, /* (389) cmd ::= DESCRIBE full_table_name */ - -3, /* (390) cmd ::= RESET QUERY CACHE */ - -4, /* (391) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - -4, /* (392) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - 0, /* (393) analyze_opt ::= */ - -1, /* (394) analyze_opt ::= ANALYZE */ - 0, /* (395) explain_options ::= */ - -3, /* (396) explain_options ::= explain_options VERBOSE NK_BOOL */ - -3, /* (397) explain_options ::= explain_options RATIO NK_FLOAT */ - -12, /* (398) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ - -4, /* (399) cmd ::= DROP FUNCTION exists_opt function_name */ - 0, /* (400) agg_func_opt ::= */ - -1, /* (401) agg_func_opt ::= AGGREGATE */ - 0, /* (402) bufsize_opt ::= */ - -2, /* (403) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 0, /* (404) language_opt ::= */ - -2, /* (405) language_opt ::= LANGUAGE NK_STRING */ - 0, /* (406) or_replace_opt ::= */ - -2, /* (407) or_replace_opt ::= OR REPLACE */ - -6, /* (408) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ - -4, /* (409) cmd ::= DROP VIEW exists_opt full_view_name */ - -1, /* (410) full_view_name ::= view_name */ - -3, /* (411) full_view_name ::= db_name NK_DOT view_name */ - -12, /* (412) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ - -4, /* (413) cmd ::= DROP STREAM exists_opt stream_name */ - -4, /* (414) cmd ::= PAUSE STREAM exists_opt stream_name */ - -5, /* (415) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ - 0, /* (416) col_list_opt ::= */ - -3, /* (417) col_list_opt ::= NK_LP column_stream_def_list NK_RP */ - -1, /* (418) column_stream_def_list ::= column_stream_def */ - -3, /* (419) column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ - -2, /* (420) column_stream_def ::= column_name stream_col_options */ - 0, /* (421) stream_col_options ::= */ - -3, /* (422) stream_col_options ::= stream_col_options PRIMARY KEY */ - 0, /* (423) tag_def_or_ref_opt ::= */ - -1, /* (424) tag_def_or_ref_opt ::= tags_def */ - -4, /* (425) tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ - 0, /* (426) stream_options ::= */ - -3, /* (427) stream_options ::= stream_options TRIGGER AT_ONCE */ - -3, /* (428) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - -3, /* (429) stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ - -4, /* (430) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - -3, /* (431) stream_options ::= stream_options WATERMARK duration_literal */ - -4, /* (432) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - -3, /* (433) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - -3, /* (434) stream_options ::= stream_options DELETE_MARK duration_literal */ - -4, /* (435) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ - 0, /* (436) subtable_opt ::= */ - -4, /* (437) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - 0, /* (438) ignore_opt ::= */ - -2, /* (439) ignore_opt ::= IGNORE UNTREATED */ - -3, /* (440) cmd ::= KILL CONNECTION NK_INTEGER */ - -3, /* (441) cmd ::= KILL QUERY NK_STRING */ - -3, /* (442) cmd ::= KILL TRANSACTION NK_INTEGER */ - -3, /* (443) cmd ::= KILL COMPACT NK_INTEGER */ - -2, /* (444) cmd ::= BALANCE VGROUP */ - -4, /* (445) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ - -5, /* (446) cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ - -4, /* (447) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - -4, /* (448) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - -3, /* (449) cmd ::= SPLIT VGROUP NK_INTEGER */ - 0, /* (450) on_vgroup_id ::= */ - -2, /* (451) on_vgroup_id ::= ON NK_INTEGER */ - -2, /* (452) dnode_list ::= DNODE NK_INTEGER */ - -3, /* (453) dnode_list ::= dnode_list DNODE NK_INTEGER */ - -4, /* (454) cmd ::= DELETE FROM full_table_name where_clause_opt */ - -1, /* (455) cmd ::= query_or_subquery */ - -1, /* (456) cmd ::= insert_query */ - -7, /* (457) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - -4, /* (458) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - -1, /* (459) tags_literal ::= NK_INTEGER */ - -3, /* (460) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - -3, /* (461) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ - -2, /* (462) tags_literal ::= NK_PLUS NK_INTEGER */ - -4, /* (463) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - -4, /* (464) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ - -2, /* (465) tags_literal ::= NK_MINUS NK_INTEGER */ - -4, /* (466) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ - -4, /* (467) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ - -1, /* (468) tags_literal ::= NK_FLOAT */ - -2, /* (469) tags_literal ::= NK_PLUS NK_FLOAT */ - -2, /* (470) tags_literal ::= NK_MINUS NK_FLOAT */ - -1, /* (471) tags_literal ::= NK_BIN */ - -3, /* (472) tags_literal ::= NK_BIN NK_PLUS duration_literal */ - -3, /* (473) tags_literal ::= NK_BIN NK_MINUS duration_literal */ - -2, /* (474) tags_literal ::= NK_PLUS NK_BIN */ - -4, /* (475) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ - -4, /* (476) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ - -2, /* (477) tags_literal ::= NK_MINUS NK_BIN */ - -4, /* (478) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ - -4, /* (479) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ - -1, /* (480) tags_literal ::= NK_HEX */ - -3, /* (481) tags_literal ::= NK_HEX NK_PLUS duration_literal */ - -3, /* (482) tags_literal ::= NK_HEX NK_MINUS duration_literal */ - -2, /* (483) tags_literal ::= NK_PLUS NK_HEX */ - -4, /* (484) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ - -4, /* (485) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ - -2, /* (486) tags_literal ::= NK_MINUS NK_HEX */ - -4, /* (487) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ - -4, /* (488) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ - -1, /* (489) tags_literal ::= NK_STRING */ - -3, /* (490) tags_literal ::= NK_STRING NK_PLUS duration_literal */ - -3, /* (491) tags_literal ::= NK_STRING NK_MINUS duration_literal */ - -1, /* (492) tags_literal ::= NK_BOOL */ - -1, /* (493) tags_literal ::= NULL */ - -1, /* (494) tags_literal ::= literal_func */ - -3, /* (495) tags_literal ::= literal_func NK_PLUS duration_literal */ - -3, /* (496) tags_literal ::= literal_func NK_MINUS duration_literal */ - -1, /* (497) tags_literal_list ::= tags_literal */ - -3, /* (498) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ - -1, /* (499) literal ::= NK_INTEGER */ - -1, /* (500) literal ::= NK_FLOAT */ - -1, /* (501) literal ::= NK_STRING */ - -1, /* (502) literal ::= NK_BOOL */ - -2, /* (503) literal ::= TIMESTAMP NK_STRING */ - -1, /* (504) literal ::= duration_literal */ - -1, /* (505) literal ::= NULL */ - -1, /* (506) literal ::= NK_QUESTION */ - -1, /* (507) duration_literal ::= NK_VARIABLE */ - -1, /* (508) signed ::= NK_INTEGER */ - -2, /* (509) signed ::= NK_PLUS NK_INTEGER */ - -2, /* (510) signed ::= NK_MINUS NK_INTEGER */ - -1, /* (511) signed ::= NK_FLOAT */ - -2, /* (512) signed ::= NK_PLUS NK_FLOAT */ - -2, /* (513) signed ::= NK_MINUS NK_FLOAT */ - -1, /* (514) signed_literal ::= signed */ - -1, /* (515) signed_literal ::= NK_STRING */ - -1, /* (516) signed_literal ::= NK_BOOL */ - -2, /* (517) signed_literal ::= TIMESTAMP NK_STRING */ - -1, /* (518) signed_literal ::= duration_literal */ - -1, /* (519) signed_literal ::= NULL */ - -1, /* (520) signed_literal ::= literal_func */ - -1, /* (521) signed_literal ::= NK_QUESTION */ - -1, /* (522) literal_list ::= signed_literal */ - -3, /* (523) literal_list ::= literal_list NK_COMMA signed_literal */ - -1, /* (524) db_name ::= NK_ID */ - -1, /* (525) table_name ::= NK_ID */ - -1, /* (526) column_name ::= NK_ID */ - -1, /* (527) function_name ::= NK_ID */ - -1, /* (528) view_name ::= NK_ID */ - -1, /* (529) table_alias ::= NK_ID */ - -1, /* (530) column_alias ::= NK_ID */ - -1, /* (531) column_alias ::= NK_ALIAS */ - -1, /* (532) user_name ::= NK_ID */ - -1, /* (533) topic_name ::= NK_ID */ - -1, /* (534) stream_name ::= NK_ID */ - -1, /* (535) cgroup_name ::= NK_ID */ - -1, /* (536) index_name ::= NK_ID */ - -1, /* (537) tsma_name ::= NK_ID */ - -1, /* (538) expr_or_subquery ::= expression */ - -1, /* (539) expression ::= literal */ - -1, /* (540) expression ::= pseudo_column */ - -1, /* (541) expression ::= column_reference */ - -1, /* (542) expression ::= function_expression */ - -1, /* (543) expression ::= case_when_expression */ - -3, /* (544) expression ::= NK_LP expression NK_RP */ - -2, /* (545) expression ::= NK_PLUS expr_or_subquery */ - -2, /* (546) expression ::= NK_MINUS expr_or_subquery */ - -3, /* (547) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - -3, /* (548) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - -3, /* (549) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - -3, /* (550) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - -3, /* (551) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - -3, /* (552) expression ::= column_reference NK_ARROW NK_STRING */ - -3, /* (553) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - -3, /* (554) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - -1, /* (555) expression_list ::= expr_or_subquery */ - -3, /* (556) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - -1, /* (557) column_reference ::= column_name */ - -3, /* (558) column_reference ::= table_name NK_DOT column_name */ - -1, /* (559) column_reference ::= NK_ALIAS */ - -3, /* (560) column_reference ::= table_name NK_DOT NK_ALIAS */ - -1, /* (561) pseudo_column ::= ROWTS */ - -1, /* (562) pseudo_column ::= TBNAME */ - -3, /* (563) pseudo_column ::= table_name NK_DOT TBNAME */ - -1, /* (564) pseudo_column ::= QSTART */ - -1, /* (565) pseudo_column ::= QEND */ - -1, /* (566) pseudo_column ::= QDURATION */ - -1, /* (567) pseudo_column ::= WSTART */ - -1, /* (568) pseudo_column ::= WEND */ - -1, /* (569) pseudo_column ::= WDURATION */ - -1, /* (570) pseudo_column ::= IROWTS */ - -1, /* (571) pseudo_column ::= ISFILLED */ - -1, /* (572) pseudo_column ::= QTAGS */ - -1, /* (573) pseudo_column ::= FLOW */ - -1, /* (574) pseudo_column ::= FHIGH */ - -1, /* (575) pseudo_column ::= FROWTS */ - -4, /* (576) function_expression ::= function_name NK_LP expression_list NK_RP */ - -4, /* (577) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - -6, /* (578) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - -6, /* (579) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ - -6, /* (580) function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ - -4, /* (581) function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ - -6, /* (582) function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ - -6, /* (583) function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ - -7, /* (584) function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ - -4, /* (585) function_expression ::= substr_func NK_LP expression_list NK_RP */ - -6, /* (586) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ - -8, /* (587) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ - -4, /* (588) function_expression ::= REPLACE NK_LP expression_list NK_RP */ - -1, /* (589) function_expression ::= literal_func */ - -1, /* (590) function_expression ::= rand_func */ - -3, /* (591) literal_func ::= noarg_func NK_LP NK_RP */ - -1, /* (592) literal_func ::= NOW */ - -1, /* (593) literal_func ::= TODAY */ - -3, /* (594) rand_func ::= RAND NK_LP NK_RP */ - -4, /* (595) rand_func ::= RAND NK_LP expression_list NK_RP */ - -1, /* (596) substr_func ::= SUBSTR */ - -1, /* (597) substr_func ::= SUBSTRING */ - -1, /* (598) trim_specification_type ::= BOTH */ - -1, /* (599) trim_specification_type ::= TRAILING */ - -1, /* (600) trim_specification_type ::= LEADING */ - -1, /* (601) noarg_func ::= NOW */ - -1, /* (602) noarg_func ::= TODAY */ - -1, /* (603) noarg_func ::= TIMEZONE */ - -1, /* (604) noarg_func ::= DATABASE */ - -1, /* (605) noarg_func ::= CLIENT_VERSION */ - -1, /* (606) noarg_func ::= SERVER_VERSION */ - -1, /* (607) noarg_func ::= SERVER_STATUS */ - -1, /* (608) noarg_func ::= CURRENT_USER */ - -1, /* (609) noarg_func ::= USER */ - -1, /* (610) noarg_func ::= PI */ - -1, /* (611) star_func ::= COUNT */ - -1, /* (612) star_func ::= FIRST */ - -1, /* (613) star_func ::= LAST */ - -1, /* (614) star_func ::= LAST_ROW */ - -1, /* (615) star_func_para_list ::= NK_STAR */ - -1, /* (616) star_func_para_list ::= other_para_list */ - -1, /* (617) other_para_list ::= star_func_para */ - -3, /* (618) other_para_list ::= other_para_list NK_COMMA star_func_para */ - -1, /* (619) star_func_para ::= expr_or_subquery */ - -3, /* (620) star_func_para ::= table_name NK_DOT NK_STAR */ - -4, /* (621) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - -5, /* (622) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - -1, /* (623) when_then_list ::= when_then_expr */ - -2, /* (624) when_then_list ::= when_then_list when_then_expr */ - -4, /* (625) when_then_expr ::= WHEN common_expression THEN common_expression */ - 0, /* (626) case_when_else_opt ::= */ - -2, /* (627) case_when_else_opt ::= ELSE common_expression */ - -3, /* (628) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - -5, /* (629) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - -6, /* (630) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - -3, /* (631) predicate ::= expr_or_subquery IS NULL */ - -4, /* (632) predicate ::= expr_or_subquery IS NOT NULL */ - -3, /* (633) predicate ::= expr_or_subquery in_op in_predicate_value */ - -1, /* (634) compare_op ::= NK_LT */ - -1, /* (635) compare_op ::= NK_GT */ - -1, /* (636) compare_op ::= NK_LE */ - -1, /* (637) compare_op ::= NK_GE */ - -1, /* (638) compare_op ::= NK_NE */ - -1, /* (639) compare_op ::= NK_EQ */ - -1, /* (640) compare_op ::= LIKE */ - -2, /* (641) compare_op ::= NOT LIKE */ - -1, /* (642) compare_op ::= MATCH */ - -1, /* (643) compare_op ::= NMATCH */ - -1, /* (644) compare_op ::= CONTAINS */ - -1, /* (645) in_op ::= IN */ - -2, /* (646) in_op ::= NOT IN */ - -3, /* (647) in_predicate_value ::= NK_LP literal_list NK_RP */ - -1, /* (648) boolean_value_expression ::= boolean_primary */ - -2, /* (649) boolean_value_expression ::= NOT boolean_primary */ - -3, /* (650) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - -3, /* (651) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - -1, /* (652) boolean_primary ::= predicate */ - -3, /* (653) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - -1, /* (654) common_expression ::= expr_or_subquery */ - -1, /* (655) common_expression ::= boolean_value_expression */ - 0, /* (656) from_clause_opt ::= */ - -2, /* (657) from_clause_opt ::= FROM table_reference_list */ - -1, /* (658) table_reference_list ::= table_reference */ - -3, /* (659) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - -1, /* (660) table_reference ::= table_primary */ - -1, /* (661) table_reference ::= joined_table */ - -2, /* (662) table_primary ::= table_name alias_opt */ - -4, /* (663) table_primary ::= db_name NK_DOT table_name alias_opt */ - -2, /* (664) table_primary ::= subquery alias_opt */ - -1, /* (665) table_primary ::= parenthesized_joined_table */ - 0, /* (666) alias_opt ::= */ - -1, /* (667) alias_opt ::= table_alias */ - -2, /* (668) alias_opt ::= AS table_alias */ - -3, /* (669) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - -3, /* (670) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - -8, /* (671) joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ - 0, /* (672) join_type ::= */ - -1, /* (673) join_type ::= INNER */ - -1, /* (674) join_type ::= LEFT */ - -1, /* (675) join_type ::= RIGHT */ - -1, /* (676) join_type ::= FULL */ - 0, /* (677) join_subtype ::= */ - -1, /* (678) join_subtype ::= OUTER */ - -1, /* (679) join_subtype ::= SEMI */ - -1, /* (680) join_subtype ::= ANTI */ - -1, /* (681) join_subtype ::= ASOF */ - -1, /* (682) join_subtype ::= WINDOW */ - 0, /* (683) join_on_clause_opt ::= */ - -2, /* (684) join_on_clause_opt ::= ON search_condition */ - 0, /* (685) window_offset_clause_opt ::= */ - -6, /* (686) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ - -1, /* (687) window_offset_literal ::= NK_VARIABLE */ - -2, /* (688) window_offset_literal ::= NK_MINUS NK_VARIABLE */ - 0, /* (689) jlimit_clause_opt ::= */ - -2, /* (690) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - -14, /* (691) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 0, /* (692) hint_list ::= */ - -1, /* (693) hint_list ::= NK_HINT */ - 0, /* (694) tag_mode_opt ::= */ - -1, /* (695) tag_mode_opt ::= TAGS */ - 0, /* (696) set_quantifier_opt ::= */ - -1, /* (697) set_quantifier_opt ::= DISTINCT */ - -1, /* (698) set_quantifier_opt ::= ALL */ - -1, /* (699) select_list ::= select_item */ - -3, /* (700) select_list ::= select_list NK_COMMA select_item */ - -1, /* (701) select_item ::= NK_STAR */ - -1, /* (702) select_item ::= common_expression */ - -2, /* (703) select_item ::= common_expression column_alias */ - -3, /* (704) select_item ::= common_expression AS column_alias */ - -3, /* (705) select_item ::= table_name NK_DOT NK_STAR */ - 0, /* (706) where_clause_opt ::= */ - -2, /* (707) where_clause_opt ::= WHERE search_condition */ - 0, /* (708) partition_by_clause_opt ::= */ - -3, /* (709) partition_by_clause_opt ::= PARTITION BY partition_list */ - -1, /* (710) partition_list ::= partition_item */ - -3, /* (711) partition_list ::= partition_list NK_COMMA partition_item */ - -1, /* (712) partition_item ::= expr_or_subquery */ - -2, /* (713) partition_item ::= expr_or_subquery column_alias */ - -3, /* (714) partition_item ::= expr_or_subquery AS column_alias */ - 0, /* (715) twindow_clause_opt ::= */ - -6, /* (716) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - -4, /* (717) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - -6, /* (718) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -8, /* (719) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -7, /* (720) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - -4, /* (721) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ - -6, /* (722) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - -4, /* (723) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ - -6, /* (724) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ - 0, /* (725) sliding_opt ::= */ - -4, /* (726) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - -1, /* (727) interval_sliding_duration_literal ::= NK_VARIABLE */ - -1, /* (728) interval_sliding_duration_literal ::= NK_STRING */ - -1, /* (729) interval_sliding_duration_literal ::= NK_INTEGER */ - 0, /* (730) fill_opt ::= */ - -4, /* (731) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - -6, /* (732) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - -6, /* (733) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - -1, /* (734) fill_mode ::= NONE */ - -1, /* (735) fill_mode ::= PREV */ - -1, /* (736) fill_mode ::= NULL */ - -1, /* (737) fill_mode ::= NULL_F */ - -1, /* (738) fill_mode ::= LINEAR */ - -1, /* (739) fill_mode ::= NEXT */ - 0, /* (740) group_by_clause_opt ::= */ - -3, /* (741) group_by_clause_opt ::= GROUP BY group_by_list */ - -1, /* (742) group_by_list ::= expr_or_subquery */ - -3, /* (743) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 0, /* (744) having_clause_opt ::= */ - -2, /* (745) having_clause_opt ::= HAVING search_condition */ - 0, /* (746) range_opt ::= */ - -6, /* (747) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - -4, /* (748) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 0, /* (749) every_opt ::= */ - -4, /* (750) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - -4, /* (751) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - -1, /* (752) query_simple ::= query_specification */ - -1, /* (753) query_simple ::= union_query_expression */ - -4, /* (754) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - -3, /* (755) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - -1, /* (756) query_simple_or_subquery ::= query_simple */ - -1, /* (757) query_simple_or_subquery ::= subquery */ - -1, /* (758) query_or_subquery ::= query_expression */ - -1, /* (759) query_or_subquery ::= subquery */ - 0, /* (760) order_by_clause_opt ::= */ - -3, /* (761) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 0, /* (762) slimit_clause_opt ::= */ - -2, /* (763) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - -4, /* (764) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - -4, /* (765) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 0, /* (766) limit_clause_opt ::= */ - -2, /* (767) limit_clause_opt ::= LIMIT NK_INTEGER */ - -4, /* (768) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - -4, /* (769) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - -3, /* (770) subquery ::= NK_LP query_expression NK_RP */ - -3, /* (771) subquery ::= NK_LP subquery NK_RP */ - -1, /* (772) search_condition ::= common_expression */ - -1, /* (773) sort_specification_list ::= sort_specification */ - -3, /* (774) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - -3, /* (775) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 0, /* (776) ordering_specification_opt ::= */ - -1, /* (777) ordering_specification_opt ::= ASC */ - -1, /* (778) ordering_specification_opt ::= DESC */ - 0, /* (779) null_ordering_opt ::= */ - -2, /* (780) null_ordering_opt ::= NULLS FIRST */ - -2, /* (781) null_ordering_opt ::= NULLS LAST */ - 0, /* (782) column_options ::= */ - -3, /* (783) column_options ::= column_options PRIMARY KEY */ - -3, /* (784) column_options ::= column_options NK_ID NK_STRING */ + -3, /* (145) db_options ::= db_options DNODES NK_STRING */ + -1, /* (146) alter_db_options ::= alter_db_option */ + -2, /* (147) alter_db_options ::= alter_db_options alter_db_option */ + -2, /* (148) alter_db_option ::= BUFFER NK_INTEGER */ + -2, /* (149) alter_db_option ::= CACHEMODEL NK_STRING */ + -2, /* (150) alter_db_option ::= CACHESIZE NK_INTEGER */ + -2, /* (151) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + -2, /* (152) alter_db_option ::= KEEP integer_list */ + -2, /* (153) alter_db_option ::= KEEP variable_list */ + -2, /* (154) alter_db_option ::= PAGES NK_INTEGER */ + -2, /* (155) alter_db_option ::= REPLICA NK_INTEGER */ + -2, /* (156) alter_db_option ::= WAL_LEVEL NK_INTEGER */ + -2, /* (157) alter_db_option ::= STT_TRIGGER NK_INTEGER */ + -2, /* (158) alter_db_option ::= MINROWS NK_INTEGER */ + -2, /* (159) alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ + -3, /* (160) alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + -2, /* (161) alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ + -3, /* (162) alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + -2, /* (163) alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ + -2, /* (164) alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ + -2, /* (165) alter_db_option ::= S3_COMPACT NK_INTEGER */ + -2, /* (166) alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ + -2, /* (167) alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ + -1, /* (168) integer_list ::= NK_INTEGER */ + -3, /* (169) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + -1, /* (170) variable_list ::= NK_VARIABLE */ + -3, /* (171) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + -1, /* (172) retention_list ::= retention */ + -3, /* (173) retention_list ::= retention_list NK_COMMA retention */ + -3, /* (174) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + -3, /* (175) retention ::= NK_MINUS NK_COLON NK_VARIABLE */ + 0, /* (176) speed_opt ::= */ + -2, /* (177) speed_opt ::= BWLIMIT NK_INTEGER */ + 0, /* (178) start_opt ::= */ + -3, /* (179) start_opt ::= START WITH NK_INTEGER */ + -3, /* (180) start_opt ::= START WITH NK_STRING */ + -4, /* (181) start_opt ::= START WITH TIMESTAMP NK_STRING */ + 0, /* (182) end_opt ::= */ + -3, /* (183) end_opt ::= END WITH NK_INTEGER */ + -3, /* (184) end_opt ::= END WITH NK_STRING */ + -4, /* (185) end_opt ::= END WITH TIMESTAMP NK_STRING */ + -9, /* (186) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + -3, /* (187) cmd ::= CREATE TABLE multi_create_clause */ + -10, /* (188) cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ + -9, /* (189) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + -4, /* (190) cmd ::= DROP TABLE with_opt multi_drop_clause */ + -5, /* (191) cmd ::= DROP STABLE with_opt exists_opt full_table_name */ + -3, /* (192) cmd ::= ALTER TABLE alter_table_clause */ + -3, /* (193) cmd ::= ALTER STABLE alter_table_clause */ + -2, /* (194) alter_table_clause ::= full_table_name alter_table_options */ + -6, /* (195) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ + -4, /* (196) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + -5, /* (197) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + -5, /* (198) alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ + -5, /* (199) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + -5, /* (200) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + -4, /* (201) alter_table_clause ::= full_table_name DROP TAG column_name */ + -5, /* (202) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + -5, /* (203) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + -6, /* (204) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ + -1, /* (205) multi_create_clause ::= create_subtable_clause */ + -2, /* (206) multi_create_clause ::= multi_create_clause create_subtable_clause */ + -10, /* (207) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ + -1, /* (208) multi_drop_clause ::= drop_table_clause */ + -3, /* (209) multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ + -2, /* (210) drop_table_clause ::= exists_opt full_table_name */ + 0, /* (211) with_opt ::= */ + -1, /* (212) with_opt ::= WITH */ + 0, /* (213) specific_cols_opt ::= */ + -3, /* (214) specific_cols_opt ::= NK_LP col_name_list NK_RP */ + -1, /* (215) full_table_name ::= table_name */ + -3, /* (216) full_table_name ::= db_name NK_DOT table_name */ + -1, /* (217) tag_def_list ::= tag_def */ + -3, /* (218) tag_def_list ::= tag_def_list NK_COMMA tag_def */ + -2, /* (219) tag_def ::= column_name type_name */ + -1, /* (220) column_def_list ::= column_def */ + -3, /* (221) column_def_list ::= column_def_list NK_COMMA column_def */ + -3, /* (222) column_def ::= column_name type_name column_options */ + -1, /* (223) type_name ::= BOOL */ + -1, /* (224) type_name ::= TINYINT */ + -1, /* (225) type_name ::= SMALLINT */ + -1, /* (226) type_name ::= INT */ + -1, /* (227) type_name ::= INTEGER */ + -1, /* (228) type_name ::= BIGINT */ + -1, /* (229) type_name ::= FLOAT */ + -1, /* (230) type_name ::= DOUBLE */ + -4, /* (231) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + -1, /* (232) type_name ::= TIMESTAMP */ + -4, /* (233) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + -2, /* (234) type_name ::= TINYINT UNSIGNED */ + -2, /* (235) type_name ::= SMALLINT UNSIGNED */ + -2, /* (236) type_name ::= INT UNSIGNED */ + -2, /* (237) type_name ::= BIGINT UNSIGNED */ + -1, /* (238) type_name ::= JSON */ + -4, /* (239) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + -1, /* (240) type_name ::= MEDIUMBLOB */ + -1, /* (241) type_name ::= BLOB */ + -4, /* (242) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + -4, /* (243) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ + -1, /* (244) type_name ::= DECIMAL */ + -4, /* (245) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + -6, /* (246) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + -1, /* (247) type_name_default_len ::= BINARY */ + -1, /* (248) type_name_default_len ::= NCHAR */ + -1, /* (249) type_name_default_len ::= VARCHAR */ + -1, /* (250) type_name_default_len ::= VARBINARY */ + 0, /* (251) tags_def_opt ::= */ + -1, /* (252) tags_def_opt ::= tags_def */ + -4, /* (253) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + 0, /* (254) table_options ::= */ + -3, /* (255) table_options ::= table_options COMMENT NK_STRING */ + -3, /* (256) table_options ::= table_options MAX_DELAY duration_list */ + -3, /* (257) table_options ::= table_options WATERMARK duration_list */ + -5, /* (258) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + -3, /* (259) table_options ::= table_options TTL NK_INTEGER */ + -5, /* (260) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + -3, /* (261) table_options ::= table_options DELETE_MARK duration_list */ + -1, /* (262) alter_table_options ::= alter_table_option */ + -2, /* (263) alter_table_options ::= alter_table_options alter_table_option */ + -2, /* (264) alter_table_option ::= COMMENT NK_STRING */ + -2, /* (265) alter_table_option ::= TTL NK_INTEGER */ + -1, /* (266) duration_list ::= duration_literal */ + -3, /* (267) duration_list ::= duration_list NK_COMMA duration_literal */ + -1, /* (268) rollup_func_list ::= rollup_func_name */ + -3, /* (269) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + -1, /* (270) rollup_func_name ::= function_name */ + -1, /* (271) rollup_func_name ::= FIRST */ + -1, /* (272) rollup_func_name ::= LAST */ + -1, /* (273) col_name_list ::= col_name */ + -3, /* (274) col_name_list ::= col_name_list NK_COMMA col_name */ + -1, /* (275) col_name ::= column_name */ + -2, /* (276) cmd ::= SHOW DNODES */ + -2, /* (277) cmd ::= SHOW USERS */ + -3, /* (278) cmd ::= SHOW USERS FULL */ + -3, /* (279) cmd ::= SHOW USER PRIVILEGES */ + -3, /* (280) cmd ::= SHOW db_kind_opt DATABASES */ + -4, /* (281) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + -4, /* (282) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + -3, /* (283) cmd ::= SHOW db_name_cond_opt VGROUPS */ + -2, /* (284) cmd ::= SHOW MNODES */ + -2, /* (285) cmd ::= SHOW QNODES */ + -2, /* (286) cmd ::= SHOW ANODES */ + -3, /* (287) cmd ::= SHOW ANODES FULL */ + -2, /* (288) cmd ::= SHOW ARBGROUPS */ + -2, /* (289) cmd ::= SHOW FUNCTIONS */ + -5, /* (290) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + -6, /* (291) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + -2, /* (292) cmd ::= SHOW STREAMS */ + -2, /* (293) cmd ::= SHOW ACCOUNTS */ + -2, /* (294) cmd ::= SHOW APPS */ + -2, /* (295) cmd ::= SHOW CONNECTIONS */ + -2, /* (296) cmd ::= SHOW LICENCES */ + -2, /* (297) cmd ::= SHOW GRANTS */ + -3, /* (298) cmd ::= SHOW GRANTS FULL */ + -3, /* (299) cmd ::= SHOW GRANTS LOGS */ + -3, /* (300) cmd ::= SHOW CLUSTER MACHINES */ + -4, /* (301) cmd ::= SHOW CREATE DATABASE db_name */ + -4, /* (302) cmd ::= SHOW CREATE TABLE full_table_name */ + -4, /* (303) cmd ::= SHOW CREATE STABLE full_table_name */ + -2, /* (304) cmd ::= SHOW ENCRYPTIONS */ + -2, /* (305) cmd ::= SHOW QUERIES */ + -2, /* (306) cmd ::= SHOW SCORES */ + -2, /* (307) cmd ::= SHOW TOPICS */ + -2, /* (308) cmd ::= SHOW VARIABLES */ + -3, /* (309) cmd ::= SHOW CLUSTER VARIABLES */ + -3, /* (310) cmd ::= SHOW LOCAL VARIABLES */ + -5, /* (311) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + -2, /* (312) cmd ::= SHOW BNODES */ + -2, /* (313) cmd ::= SHOW SNODES */ + -2, /* (314) cmd ::= SHOW CLUSTER */ + -2, /* (315) cmd ::= SHOW TRANSACTIONS */ + -4, /* (316) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + -2, /* (317) cmd ::= SHOW CONSUMERS */ + -2, /* (318) cmd ::= SHOW SUBSCRIPTIONS */ + -5, /* (319) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + -6, /* (320) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + -7, /* (321) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + -8, /* (322) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + -5, /* (323) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + -2, /* (324) cmd ::= SHOW VNODES */ + -3, /* (325) cmd ::= SHOW db_name_cond_opt ALIVE */ + -3, /* (326) cmd ::= SHOW CLUSTER ALIVE */ + -4, /* (327) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ + -4, /* (328) cmd ::= SHOW CREATE VIEW full_table_name */ + -2, /* (329) cmd ::= SHOW COMPACTS */ + -3, /* (330) cmd ::= SHOW COMPACT NK_INTEGER */ + 0, /* (331) table_kind_db_name_cond_opt ::= */ + -1, /* (332) table_kind_db_name_cond_opt ::= table_kind */ + -2, /* (333) table_kind_db_name_cond_opt ::= db_name NK_DOT */ + -3, /* (334) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + -1, /* (335) table_kind ::= NORMAL */ + -1, /* (336) table_kind ::= CHILD */ + 0, /* (337) db_name_cond_opt ::= */ + -2, /* (338) db_name_cond_opt ::= db_name NK_DOT */ + 0, /* (339) like_pattern_opt ::= */ + -2, /* (340) like_pattern_opt ::= LIKE NK_STRING */ + -1, /* (341) table_name_cond ::= table_name */ + 0, /* (342) from_db_opt ::= */ + -2, /* (343) from_db_opt ::= FROM db_name */ + 0, /* (344) tag_list_opt ::= */ + -1, /* (345) tag_list_opt ::= tag_item */ + -3, /* (346) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + -1, /* (347) tag_item ::= TBNAME */ + -1, /* (348) tag_item ::= QTAGS */ + -1, /* (349) tag_item ::= column_name */ + -2, /* (350) tag_item ::= column_name column_alias */ + -3, /* (351) tag_item ::= column_name AS column_alias */ + 0, /* (352) db_kind_opt ::= */ + -1, /* (353) db_kind_opt ::= USER */ + -1, /* (354) db_kind_opt ::= SYSTEM */ + -11, /* (355) cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ + -11, /* (356) cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ + -4, /* (357) cmd ::= DROP TSMA exists_opt full_tsma_name */ + -3, /* (358) cmd ::= SHOW db_name_cond_opt TSMAS */ + -1, /* (359) full_tsma_name ::= tsma_name */ + -3, /* (360) full_tsma_name ::= db_name NK_DOT tsma_name */ + -4, /* (361) tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ + -8, /* (362) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + -9, /* (363) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + -4, /* (364) cmd ::= DROP INDEX exists_opt full_index_name */ + -1, /* (365) full_index_name ::= index_name */ + -3, /* (366) full_index_name ::= db_name NK_DOT index_name */ + -10, /* (367) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + -12, /* (368) 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 */ + -1, /* (369) func_list ::= func */ + -3, /* (370) func_list ::= func_list NK_COMMA func */ + -4, /* (371) func ::= sma_func_name NK_LP expression_list NK_RP */ + -1, /* (372) sma_func_name ::= function_name */ + -1, /* (373) sma_func_name ::= COUNT */ + -1, /* (374) sma_func_name ::= FIRST */ + -1, /* (375) sma_func_name ::= LAST */ + -1, /* (376) sma_func_name ::= LAST_ROW */ + 0, /* (377) sma_stream_opt ::= */ + -3, /* (378) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + -3, /* (379) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + -3, /* (380) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + -1, /* (381) with_meta ::= AS */ + -3, /* (382) with_meta ::= WITH META AS */ + -3, /* (383) with_meta ::= ONLY META AS */ + -6, /* (384) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + -7, /* (385) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + -8, /* (386) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + -4, /* (387) cmd ::= DROP TOPIC exists_opt topic_name */ + -7, /* (388) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + -2, /* (389) cmd ::= DESC full_table_name */ + -2, /* (390) cmd ::= DESCRIBE full_table_name */ + -3, /* (391) cmd ::= RESET QUERY CACHE */ + -4, /* (392) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + -4, /* (393) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + 0, /* (394) analyze_opt ::= */ + -1, /* (395) analyze_opt ::= ANALYZE */ + 0, /* (396) explain_options ::= */ + -3, /* (397) explain_options ::= explain_options VERBOSE NK_BOOL */ + -3, /* (398) explain_options ::= explain_options RATIO NK_FLOAT */ + -12, /* (399) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + -4, /* (400) cmd ::= DROP FUNCTION exists_opt function_name */ + 0, /* (401) agg_func_opt ::= */ + -1, /* (402) agg_func_opt ::= AGGREGATE */ + 0, /* (403) bufsize_opt ::= */ + -2, /* (404) bufsize_opt ::= BUFSIZE NK_INTEGER */ + 0, /* (405) language_opt ::= */ + -2, /* (406) language_opt ::= LANGUAGE NK_STRING */ + 0, /* (407) or_replace_opt ::= */ + -2, /* (408) or_replace_opt ::= OR REPLACE */ + -6, /* (409) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + -4, /* (410) cmd ::= DROP VIEW exists_opt full_view_name */ + -1, /* (411) full_view_name ::= view_name */ + -3, /* (412) full_view_name ::= db_name NK_DOT view_name */ + -12, /* (413) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ + -4, /* (414) cmd ::= DROP STREAM exists_opt stream_name */ + -4, /* (415) cmd ::= PAUSE STREAM exists_opt stream_name */ + -5, /* (416) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + 0, /* (417) col_list_opt ::= */ + -3, /* (418) col_list_opt ::= NK_LP column_stream_def_list NK_RP */ + -1, /* (419) column_stream_def_list ::= column_stream_def */ + -3, /* (420) column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ + -2, /* (421) column_stream_def ::= column_name stream_col_options */ + 0, /* (422) stream_col_options ::= */ + -3, /* (423) stream_col_options ::= stream_col_options PRIMARY KEY */ + 0, /* (424) tag_def_or_ref_opt ::= */ + -1, /* (425) tag_def_or_ref_opt ::= tags_def */ + -4, /* (426) tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ + 0, /* (427) stream_options ::= */ + -3, /* (428) stream_options ::= stream_options TRIGGER AT_ONCE */ + -3, /* (429) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + -3, /* (430) stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ + -4, /* (431) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + -3, /* (432) stream_options ::= stream_options WATERMARK duration_literal */ + -4, /* (433) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + -3, /* (434) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + -3, /* (435) stream_options ::= stream_options DELETE_MARK duration_literal */ + -4, /* (436) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + 0, /* (437) subtable_opt ::= */ + -4, /* (438) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + 0, /* (439) ignore_opt ::= */ + -2, /* (440) ignore_opt ::= IGNORE UNTREATED */ + -3, /* (441) cmd ::= KILL CONNECTION NK_INTEGER */ + -3, /* (442) cmd ::= KILL QUERY NK_STRING */ + -3, /* (443) cmd ::= KILL TRANSACTION NK_INTEGER */ + -3, /* (444) cmd ::= KILL COMPACT NK_INTEGER */ + -2, /* (445) cmd ::= BALANCE VGROUP */ + -4, /* (446) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + -5, /* (447) cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ + -4, /* (448) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + -4, /* (449) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + -3, /* (450) cmd ::= SPLIT VGROUP NK_INTEGER */ + 0, /* (451) on_vgroup_id ::= */ + -2, /* (452) on_vgroup_id ::= ON NK_INTEGER */ + -2, /* (453) dnode_list ::= DNODE NK_INTEGER */ + -3, /* (454) dnode_list ::= dnode_list DNODE NK_INTEGER */ + -4, /* (455) cmd ::= DELETE FROM full_table_name where_clause_opt */ + -1, /* (456) cmd ::= query_or_subquery */ + -1, /* (457) cmd ::= insert_query */ + -7, /* (458) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + -4, /* (459) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + -1, /* (460) tags_literal ::= NK_INTEGER */ + -3, /* (461) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + -3, /* (462) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ + -2, /* (463) tags_literal ::= NK_PLUS NK_INTEGER */ + -4, /* (464) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + -4, /* (465) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ + -2, /* (466) tags_literal ::= NK_MINUS NK_INTEGER */ + -4, /* (467) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ + -4, /* (468) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ + -1, /* (469) tags_literal ::= NK_FLOAT */ + -2, /* (470) tags_literal ::= NK_PLUS NK_FLOAT */ + -2, /* (471) tags_literal ::= NK_MINUS NK_FLOAT */ + -1, /* (472) tags_literal ::= NK_BIN */ + -3, /* (473) tags_literal ::= NK_BIN NK_PLUS duration_literal */ + -3, /* (474) tags_literal ::= NK_BIN NK_MINUS duration_literal */ + -2, /* (475) tags_literal ::= NK_PLUS NK_BIN */ + -4, /* (476) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ + -4, /* (477) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ + -2, /* (478) tags_literal ::= NK_MINUS NK_BIN */ + -4, /* (479) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ + -4, /* (480) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ + -1, /* (481) tags_literal ::= NK_HEX */ + -3, /* (482) tags_literal ::= NK_HEX NK_PLUS duration_literal */ + -3, /* (483) tags_literal ::= NK_HEX NK_MINUS duration_literal */ + -2, /* (484) tags_literal ::= NK_PLUS NK_HEX */ + -4, /* (485) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ + -4, /* (486) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ + -2, /* (487) tags_literal ::= NK_MINUS NK_HEX */ + -4, /* (488) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ + -4, /* (489) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ + -1, /* (490) tags_literal ::= NK_STRING */ + -3, /* (491) tags_literal ::= NK_STRING NK_PLUS duration_literal */ + -3, /* (492) tags_literal ::= NK_STRING NK_MINUS duration_literal */ + -1, /* (493) tags_literal ::= NK_BOOL */ + -1, /* (494) tags_literal ::= NULL */ + -1, /* (495) tags_literal ::= literal_func */ + -3, /* (496) tags_literal ::= literal_func NK_PLUS duration_literal */ + -3, /* (497) tags_literal ::= literal_func NK_MINUS duration_literal */ + -1, /* (498) tags_literal_list ::= tags_literal */ + -3, /* (499) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ + -1, /* (500) literal ::= NK_INTEGER */ + -1, /* (501) literal ::= NK_FLOAT */ + -1, /* (502) literal ::= NK_STRING */ + -1, /* (503) literal ::= NK_BOOL */ + -2, /* (504) literal ::= TIMESTAMP NK_STRING */ + -1, /* (505) literal ::= duration_literal */ + -1, /* (506) literal ::= NULL */ + -1, /* (507) literal ::= NK_QUESTION */ + -1, /* (508) duration_literal ::= NK_VARIABLE */ + -1, /* (509) signed ::= NK_INTEGER */ + -2, /* (510) signed ::= NK_PLUS NK_INTEGER */ + -2, /* (511) signed ::= NK_MINUS NK_INTEGER */ + -1, /* (512) signed ::= NK_FLOAT */ + -2, /* (513) signed ::= NK_PLUS NK_FLOAT */ + -2, /* (514) signed ::= NK_MINUS NK_FLOAT */ + -1, /* (515) signed_literal ::= signed */ + -1, /* (516) signed_literal ::= NK_STRING */ + -1, /* (517) signed_literal ::= NK_BOOL */ + -2, /* (518) signed_literal ::= TIMESTAMP NK_STRING */ + -1, /* (519) signed_literal ::= duration_literal */ + -1, /* (520) signed_literal ::= NULL */ + -1, /* (521) signed_literal ::= literal_func */ + -1, /* (522) signed_literal ::= NK_QUESTION */ + -1, /* (523) literal_list ::= signed_literal */ + -3, /* (524) literal_list ::= literal_list NK_COMMA signed_literal */ + -1, /* (525) db_name ::= NK_ID */ + -1, /* (526) table_name ::= NK_ID */ + -1, /* (527) column_name ::= NK_ID */ + -1, /* (528) function_name ::= NK_ID */ + -1, /* (529) view_name ::= NK_ID */ + -1, /* (530) table_alias ::= NK_ID */ + -1, /* (531) column_alias ::= NK_ID */ + -1, /* (532) column_alias ::= NK_ALIAS */ + -1, /* (533) user_name ::= NK_ID */ + -1, /* (534) topic_name ::= NK_ID */ + -1, /* (535) stream_name ::= NK_ID */ + -1, /* (536) cgroup_name ::= NK_ID */ + -1, /* (537) index_name ::= NK_ID */ + -1, /* (538) tsma_name ::= NK_ID */ + -1, /* (539) expr_or_subquery ::= expression */ + -1, /* (540) expression ::= literal */ + -1, /* (541) expression ::= pseudo_column */ + -1, /* (542) expression ::= column_reference */ + -1, /* (543) expression ::= function_expression */ + -1, /* (544) expression ::= case_when_expression */ + -3, /* (545) expression ::= NK_LP expression NK_RP */ + -2, /* (546) expression ::= NK_PLUS expr_or_subquery */ + -2, /* (547) expression ::= NK_MINUS expr_or_subquery */ + -3, /* (548) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + -3, /* (549) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + -3, /* (550) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + -3, /* (551) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + -3, /* (552) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + -3, /* (553) expression ::= column_reference NK_ARROW NK_STRING */ + -3, /* (554) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + -3, /* (555) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + -1, /* (556) expression_list ::= expr_or_subquery */ + -3, /* (557) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + -1, /* (558) column_reference ::= column_name */ + -3, /* (559) column_reference ::= table_name NK_DOT column_name */ + -1, /* (560) column_reference ::= NK_ALIAS */ + -3, /* (561) column_reference ::= table_name NK_DOT NK_ALIAS */ + -1, /* (562) pseudo_column ::= ROWTS */ + -1, /* (563) pseudo_column ::= TBNAME */ + -3, /* (564) pseudo_column ::= table_name NK_DOT TBNAME */ + -1, /* (565) pseudo_column ::= QSTART */ + -1, /* (566) pseudo_column ::= QEND */ + -1, /* (567) pseudo_column ::= QDURATION */ + -1, /* (568) pseudo_column ::= WSTART */ + -1, /* (569) pseudo_column ::= WEND */ + -1, /* (570) pseudo_column ::= WDURATION */ + -1, /* (571) pseudo_column ::= IROWTS */ + -1, /* (572) pseudo_column ::= ISFILLED */ + -1, /* (573) pseudo_column ::= QTAGS */ + -1, /* (574) pseudo_column ::= FLOW */ + -1, /* (575) pseudo_column ::= FHIGH */ + -1, /* (576) pseudo_column ::= FROWTS */ + -4, /* (577) function_expression ::= function_name NK_LP expression_list NK_RP */ + -4, /* (578) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + -6, /* (579) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + -6, /* (580) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ + -6, /* (581) function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ + -4, /* (582) function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ + -6, /* (583) function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ + -6, /* (584) function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + -7, /* (585) function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ + -4, /* (586) function_expression ::= substr_func NK_LP expression_list NK_RP */ + -6, /* (587) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + -8, /* (588) function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ + -4, /* (589) function_expression ::= REPLACE NK_LP expression_list NK_RP */ + -1, /* (590) function_expression ::= literal_func */ + -1, /* (591) function_expression ::= rand_func */ + -3, /* (592) literal_func ::= noarg_func NK_LP NK_RP */ + -1, /* (593) literal_func ::= NOW */ + -1, /* (594) literal_func ::= TODAY */ + -3, /* (595) rand_func ::= RAND NK_LP NK_RP */ + -4, /* (596) rand_func ::= RAND NK_LP expression_list NK_RP */ + -1, /* (597) substr_func ::= SUBSTR */ + -1, /* (598) substr_func ::= SUBSTRING */ + -1, /* (599) trim_specification_type ::= BOTH */ + -1, /* (600) trim_specification_type ::= TRAILING */ + -1, /* (601) trim_specification_type ::= LEADING */ + -1, /* (602) noarg_func ::= NOW */ + -1, /* (603) noarg_func ::= TODAY */ + -1, /* (604) noarg_func ::= TIMEZONE */ + -1, /* (605) noarg_func ::= DATABASE */ + -1, /* (606) noarg_func ::= CLIENT_VERSION */ + -1, /* (607) noarg_func ::= SERVER_VERSION */ + -1, /* (608) noarg_func ::= SERVER_STATUS */ + -1, /* (609) noarg_func ::= CURRENT_USER */ + -1, /* (610) noarg_func ::= USER */ + -1, /* (611) noarg_func ::= PI */ + -1, /* (612) star_func ::= COUNT */ + -1, /* (613) star_func ::= FIRST */ + -1, /* (614) star_func ::= LAST */ + -1, /* (615) star_func ::= LAST_ROW */ + -1, /* (616) star_func_para_list ::= NK_STAR */ + -1, /* (617) star_func_para_list ::= other_para_list */ + -1, /* (618) other_para_list ::= star_func_para */ + -3, /* (619) other_para_list ::= other_para_list NK_COMMA star_func_para */ + -1, /* (620) star_func_para ::= expr_or_subquery */ + -3, /* (621) star_func_para ::= table_name NK_DOT NK_STAR */ + -4, /* (622) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + -5, /* (623) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + -1, /* (624) when_then_list ::= when_then_expr */ + -2, /* (625) when_then_list ::= when_then_list when_then_expr */ + -4, /* (626) when_then_expr ::= WHEN common_expression THEN common_expression */ + 0, /* (627) case_when_else_opt ::= */ + -2, /* (628) case_when_else_opt ::= ELSE common_expression */ + -3, /* (629) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + -5, /* (630) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + -6, /* (631) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + -3, /* (632) predicate ::= expr_or_subquery IS NULL */ + -4, /* (633) predicate ::= expr_or_subquery IS NOT NULL */ + -3, /* (634) predicate ::= expr_or_subquery in_op in_predicate_value */ + -1, /* (635) compare_op ::= NK_LT */ + -1, /* (636) compare_op ::= NK_GT */ + -1, /* (637) compare_op ::= NK_LE */ + -1, /* (638) compare_op ::= NK_GE */ + -1, /* (639) compare_op ::= NK_NE */ + -1, /* (640) compare_op ::= NK_EQ */ + -1, /* (641) compare_op ::= LIKE */ + -2, /* (642) compare_op ::= NOT LIKE */ + -1, /* (643) compare_op ::= MATCH */ + -1, /* (644) compare_op ::= NMATCH */ + -1, /* (645) compare_op ::= CONTAINS */ + -1, /* (646) in_op ::= IN */ + -2, /* (647) in_op ::= NOT IN */ + -3, /* (648) in_predicate_value ::= NK_LP literal_list NK_RP */ + -1, /* (649) boolean_value_expression ::= boolean_primary */ + -2, /* (650) boolean_value_expression ::= NOT boolean_primary */ + -3, /* (651) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + -3, /* (652) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + -1, /* (653) boolean_primary ::= predicate */ + -3, /* (654) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + -1, /* (655) common_expression ::= expr_or_subquery */ + -1, /* (656) common_expression ::= boolean_value_expression */ + 0, /* (657) from_clause_opt ::= */ + -2, /* (658) from_clause_opt ::= FROM table_reference_list */ + -1, /* (659) table_reference_list ::= table_reference */ + -3, /* (660) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + -1, /* (661) table_reference ::= table_primary */ + -1, /* (662) table_reference ::= joined_table */ + -2, /* (663) table_primary ::= table_name alias_opt */ + -4, /* (664) table_primary ::= db_name NK_DOT table_name alias_opt */ + -2, /* (665) table_primary ::= subquery alias_opt */ + -1, /* (666) table_primary ::= parenthesized_joined_table */ + 0, /* (667) alias_opt ::= */ + -1, /* (668) alias_opt ::= table_alias */ + -2, /* (669) alias_opt ::= AS table_alias */ + -3, /* (670) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + -3, /* (671) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + -8, /* (672) joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ + 0, /* (673) join_type ::= */ + -1, /* (674) join_type ::= INNER */ + -1, /* (675) join_type ::= LEFT */ + -1, /* (676) join_type ::= RIGHT */ + -1, /* (677) join_type ::= FULL */ + 0, /* (678) join_subtype ::= */ + -1, /* (679) join_subtype ::= OUTER */ + -1, /* (680) join_subtype ::= SEMI */ + -1, /* (681) join_subtype ::= ANTI */ + -1, /* (682) join_subtype ::= ASOF */ + -1, /* (683) join_subtype ::= WINDOW */ + 0, /* (684) join_on_clause_opt ::= */ + -2, /* (685) join_on_clause_opt ::= ON search_condition */ + 0, /* (686) window_offset_clause_opt ::= */ + -6, /* (687) window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ + -1, /* (688) window_offset_literal ::= NK_VARIABLE */ + -2, /* (689) window_offset_literal ::= NK_MINUS NK_VARIABLE */ + 0, /* (690) jlimit_clause_opt ::= */ + -2, /* (691) jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + -14, /* (692) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 0, /* (693) hint_list ::= */ + -1, /* (694) hint_list ::= NK_HINT */ + 0, /* (695) tag_mode_opt ::= */ + -1, /* (696) tag_mode_opt ::= TAGS */ + 0, /* (697) set_quantifier_opt ::= */ + -1, /* (698) set_quantifier_opt ::= DISTINCT */ + -1, /* (699) set_quantifier_opt ::= ALL */ + -1, /* (700) select_list ::= select_item */ + -3, /* (701) select_list ::= select_list NK_COMMA select_item */ + -1, /* (702) select_item ::= NK_STAR */ + -1, /* (703) select_item ::= common_expression */ + -2, /* (704) select_item ::= common_expression column_alias */ + -3, /* (705) select_item ::= common_expression AS column_alias */ + -3, /* (706) select_item ::= table_name NK_DOT NK_STAR */ + 0, /* (707) where_clause_opt ::= */ + -2, /* (708) where_clause_opt ::= WHERE search_condition */ + 0, /* (709) partition_by_clause_opt ::= */ + -3, /* (710) partition_by_clause_opt ::= PARTITION BY partition_list */ + -1, /* (711) partition_list ::= partition_item */ + -3, /* (712) partition_list ::= partition_list NK_COMMA partition_item */ + -1, /* (713) partition_item ::= expr_or_subquery */ + -2, /* (714) partition_item ::= expr_or_subquery column_alias */ + -3, /* (715) partition_item ::= expr_or_subquery AS column_alias */ + 0, /* (716) twindow_clause_opt ::= */ + -6, /* (717) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + -4, /* (718) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + -6, /* (719) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -8, /* (720) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -7, /* (721) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + -4, /* (722) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ + -6, /* (723) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + -4, /* (724) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ + -6, /* (725) twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ + 0, /* (726) sliding_opt ::= */ + -4, /* (727) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + -1, /* (728) interval_sliding_duration_literal ::= NK_VARIABLE */ + -1, /* (729) interval_sliding_duration_literal ::= NK_STRING */ + -1, /* (730) interval_sliding_duration_literal ::= NK_INTEGER */ + 0, /* (731) fill_opt ::= */ + -4, /* (732) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + -6, /* (733) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + -6, /* (734) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + -1, /* (735) fill_mode ::= NONE */ + -1, /* (736) fill_mode ::= PREV */ + -1, /* (737) fill_mode ::= NULL */ + -1, /* (738) fill_mode ::= NULL_F */ + -1, /* (739) fill_mode ::= LINEAR */ + -1, /* (740) fill_mode ::= NEXT */ + 0, /* (741) group_by_clause_opt ::= */ + -3, /* (742) group_by_clause_opt ::= GROUP BY group_by_list */ + -1, /* (743) group_by_list ::= expr_or_subquery */ + -3, /* (744) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 0, /* (745) having_clause_opt ::= */ + -2, /* (746) having_clause_opt ::= HAVING search_condition */ + 0, /* (747) range_opt ::= */ + -6, /* (748) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + -4, /* (749) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 0, /* (750) every_opt ::= */ + -4, /* (751) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + -4, /* (752) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + -1, /* (753) query_simple ::= query_specification */ + -1, /* (754) query_simple ::= union_query_expression */ + -4, /* (755) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + -3, /* (756) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + -1, /* (757) query_simple_or_subquery ::= query_simple */ + -1, /* (758) query_simple_or_subquery ::= subquery */ + -1, /* (759) query_or_subquery ::= query_expression */ + -1, /* (760) query_or_subquery ::= subquery */ + 0, /* (761) order_by_clause_opt ::= */ + -3, /* (762) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 0, /* (763) slimit_clause_opt ::= */ + -2, /* (764) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + -4, /* (765) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + -4, /* (766) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 0, /* (767) limit_clause_opt ::= */ + -2, /* (768) limit_clause_opt ::= LIMIT NK_INTEGER */ + -4, /* (769) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + -4, /* (770) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + -3, /* (771) subquery ::= NK_LP query_expression NK_RP */ + -3, /* (772) subquery ::= NK_LP subquery NK_RP */ + -1, /* (773) search_condition ::= common_expression */ + -1, /* (774) sort_specification_list ::= sort_specification */ + -3, /* (775) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + -3, /* (776) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 0, /* (777) ordering_specification_opt ::= */ + -1, /* (778) ordering_specification_opt ::= ASC */ + -1, /* (779) ordering_specification_opt ::= DESC */ + 0, /* (780) null_ordering_opt ::= */ + -2, /* (781) null_ordering_opt ::= NULLS FIRST */ + -2, /* (782) null_ordering_opt ::= NULLS LAST */ + 0, /* (783) column_options ::= */ + -3, /* (784) column_options ::= column_options PRIMARY KEY */ + -3, /* (785) column_options ::= column_options NK_ID NK_STRING */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -6072,20 +6075,20 @@ static YYACTIONTYPE yy_reduce( { yymsp[-1].minor.yy628 = yymsp[0].minor.yy628; } break; case 27: /* white_list_opt ::= */ - case 212: /* specific_cols_opt ::= */ yytestcase(yyruleno==212); - case 250: /* tags_def_opt ::= */ yytestcase(yyruleno==250); - case 343: /* tag_list_opt ::= */ yytestcase(yyruleno==343); - case 416: /* col_list_opt ::= */ yytestcase(yyruleno==416); - case 423: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==423); - case 708: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==708); - case 740: /* group_by_clause_opt ::= */ yytestcase(yyruleno==740); - case 760: /* order_by_clause_opt ::= */ yytestcase(yyruleno==760); + case 213: /* specific_cols_opt ::= */ yytestcase(yyruleno==213); + case 251: /* tags_def_opt ::= */ yytestcase(yyruleno==251); + case 344: /* tag_list_opt ::= */ yytestcase(yyruleno==344); + case 417: /* col_list_opt ::= */ yytestcase(yyruleno==417); + case 424: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==424); + case 709: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==709); + case 741: /* group_by_clause_opt ::= */ yytestcase(yyruleno==741); + case 761: /* order_by_clause_opt ::= */ yytestcase(yyruleno==761); { yymsp[1].minor.yy628 = NULL; } break; case 28: /* white_list_opt ::= white_list */ - case 251: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==251); - case 424: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==424); - case 616: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==616); + case 252: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==252); + case 425: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==425); + case 617: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==617); { yylhsminor.yy628 = yymsp[0].minor.yy628; } yymsp[0].minor.yy628 = yylhsminor.yy628; break; @@ -6175,31 +6178,31 @@ static YYACTIONTYPE yy_reduce( yymsp[0].minor.yy469 = yylhsminor.yy469; break; case 57: /* with_clause_opt ::= */ - case 177: /* start_opt ::= */ yytestcase(yyruleno==177); - case 181: /* end_opt ::= */ yytestcase(yyruleno==181); - case 338: /* like_pattern_opt ::= */ yytestcase(yyruleno==338); - case 436: /* subtable_opt ::= */ yytestcase(yyruleno==436); - case 626: /* case_when_else_opt ::= */ yytestcase(yyruleno==626); - case 656: /* from_clause_opt ::= */ yytestcase(yyruleno==656); - case 683: /* join_on_clause_opt ::= */ yytestcase(yyruleno==683); - case 685: /* window_offset_clause_opt ::= */ yytestcase(yyruleno==685); - case 689: /* jlimit_clause_opt ::= */ yytestcase(yyruleno==689); - case 706: /* where_clause_opt ::= */ yytestcase(yyruleno==706); - case 715: /* twindow_clause_opt ::= */ yytestcase(yyruleno==715); - case 725: /* sliding_opt ::= */ yytestcase(yyruleno==725); - case 730: /* fill_opt ::= */ yytestcase(yyruleno==730); - case 744: /* having_clause_opt ::= */ yytestcase(yyruleno==744); - case 746: /* range_opt ::= */ yytestcase(yyruleno==746); - case 749: /* every_opt ::= */ yytestcase(yyruleno==749); - case 762: /* slimit_clause_opt ::= */ yytestcase(yyruleno==762); - case 766: /* limit_clause_opt ::= */ yytestcase(yyruleno==766); + case 178: /* start_opt ::= */ yytestcase(yyruleno==178); + case 182: /* end_opt ::= */ yytestcase(yyruleno==182); + case 339: /* like_pattern_opt ::= */ yytestcase(yyruleno==339); + case 437: /* subtable_opt ::= */ yytestcase(yyruleno==437); + case 627: /* case_when_else_opt ::= */ yytestcase(yyruleno==627); + case 657: /* from_clause_opt ::= */ yytestcase(yyruleno==657); + case 684: /* join_on_clause_opt ::= */ yytestcase(yyruleno==684); + case 686: /* window_offset_clause_opt ::= */ yytestcase(yyruleno==686); + case 690: /* jlimit_clause_opt ::= */ yytestcase(yyruleno==690); + case 707: /* where_clause_opt ::= */ yytestcase(yyruleno==707); + case 716: /* twindow_clause_opt ::= */ yytestcase(yyruleno==716); + case 726: /* sliding_opt ::= */ yytestcase(yyruleno==726); + case 731: /* fill_opt ::= */ yytestcase(yyruleno==731); + case 745: /* having_clause_opt ::= */ yytestcase(yyruleno==745); + case 747: /* range_opt ::= */ yytestcase(yyruleno==747); + case 750: /* every_opt ::= */ yytestcase(yyruleno==750); + case 763: /* slimit_clause_opt ::= */ yytestcase(yyruleno==763); + case 767: /* limit_clause_opt ::= */ yytestcase(yyruleno==767); { yymsp[1].minor.yy980 = NULL; } break; case 58: /* with_clause_opt ::= WITH search_condition */ - case 657: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==657); - case 684: /* join_on_clause_opt ::= ON search_condition */ yytestcase(yyruleno==684); - case 707: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==707); - case 745: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==745); + case 658: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==658); + case 685: /* join_on_clause_opt ::= ON search_condition */ yytestcase(yyruleno==685); + case 708: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==708); + case 746: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==746); { yymsp[-1].minor.yy980 = yymsp[0].minor.yy980; } break; case 59: /* cmd ::= CREATE ENCRYPT_KEY NK_STRING */ @@ -6253,62 +6256,62 @@ static YYACTIONTYPE yy_reduce( case 75: /* dnode_endpoint ::= NK_STRING */ case 76: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==76); case 77: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==77); - case 372: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==372); - case 373: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==373); - case 374: /* sma_func_name ::= LAST */ yytestcase(yyruleno==374); - case 375: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==375); - case 524: /* db_name ::= NK_ID */ yytestcase(yyruleno==524); - case 525: /* table_name ::= NK_ID */ yytestcase(yyruleno==525); - case 526: /* column_name ::= NK_ID */ yytestcase(yyruleno==526); - case 527: /* function_name ::= NK_ID */ yytestcase(yyruleno==527); - case 528: /* view_name ::= NK_ID */ yytestcase(yyruleno==528); - case 529: /* table_alias ::= NK_ID */ yytestcase(yyruleno==529); - case 530: /* column_alias ::= NK_ID */ yytestcase(yyruleno==530); - case 531: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==531); - case 532: /* user_name ::= NK_ID */ yytestcase(yyruleno==532); - case 533: /* topic_name ::= NK_ID */ yytestcase(yyruleno==533); - case 534: /* stream_name ::= NK_ID */ yytestcase(yyruleno==534); - case 535: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==535); - case 536: /* index_name ::= NK_ID */ yytestcase(yyruleno==536); - case 537: /* tsma_name ::= NK_ID */ yytestcase(yyruleno==537); - case 596: /* substr_func ::= SUBSTR */ yytestcase(yyruleno==596); - case 597: /* substr_func ::= SUBSTRING */ yytestcase(yyruleno==597); - case 601: /* noarg_func ::= NOW */ yytestcase(yyruleno==601); - case 602: /* noarg_func ::= TODAY */ yytestcase(yyruleno==602); - case 603: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==603); - case 604: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==604); - case 605: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==605); - case 606: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==606); - case 607: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==607); - case 608: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==608); - case 609: /* noarg_func ::= USER */ yytestcase(yyruleno==609); - case 610: /* noarg_func ::= PI */ yytestcase(yyruleno==610); - case 611: /* star_func ::= COUNT */ yytestcase(yyruleno==611); - case 612: /* star_func ::= FIRST */ yytestcase(yyruleno==612); - case 613: /* star_func ::= LAST */ yytestcase(yyruleno==613); - case 614: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==614); + case 373: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==373); + case 374: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==374); + case 375: /* sma_func_name ::= LAST */ yytestcase(yyruleno==375); + case 376: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==376); + case 525: /* db_name ::= NK_ID */ yytestcase(yyruleno==525); + case 526: /* table_name ::= NK_ID */ yytestcase(yyruleno==526); + case 527: /* column_name ::= NK_ID */ yytestcase(yyruleno==527); + case 528: /* function_name ::= NK_ID */ yytestcase(yyruleno==528); + case 529: /* view_name ::= NK_ID */ yytestcase(yyruleno==529); + case 530: /* table_alias ::= NK_ID */ yytestcase(yyruleno==530); + case 531: /* column_alias ::= NK_ID */ yytestcase(yyruleno==531); + case 532: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==532); + case 533: /* user_name ::= NK_ID */ yytestcase(yyruleno==533); + case 534: /* topic_name ::= NK_ID */ yytestcase(yyruleno==534); + case 535: /* stream_name ::= NK_ID */ yytestcase(yyruleno==535); + case 536: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==536); + case 537: /* index_name ::= NK_ID */ yytestcase(yyruleno==537); + case 538: /* tsma_name ::= NK_ID */ yytestcase(yyruleno==538); + case 597: /* substr_func ::= SUBSTR */ yytestcase(yyruleno==597); + case 598: /* substr_func ::= SUBSTRING */ yytestcase(yyruleno==598); + case 602: /* noarg_func ::= NOW */ yytestcase(yyruleno==602); + case 603: /* noarg_func ::= TODAY */ yytestcase(yyruleno==603); + case 604: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==604); + case 605: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==605); + case 606: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==606); + case 607: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==607); + case 608: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==608); + case 609: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==609); + case 610: /* noarg_func ::= USER */ yytestcase(yyruleno==610); + case 611: /* noarg_func ::= PI */ yytestcase(yyruleno==611); + case 612: /* star_func ::= COUNT */ yytestcase(yyruleno==612); + case 613: /* star_func ::= FIRST */ yytestcase(yyruleno==613); + case 614: /* star_func ::= LAST */ yytestcase(yyruleno==614); + case 615: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==615); { yylhsminor.yy561 = yymsp[0].minor.yy0; } yymsp[0].minor.yy561 = yylhsminor.yy561; break; case 78: /* force_opt ::= */ case 105: /* not_exists_opt ::= */ yytestcase(yyruleno==105); case 107: /* exists_opt ::= */ yytestcase(yyruleno==107); - case 210: /* with_opt ::= */ yytestcase(yyruleno==210); - case 393: /* analyze_opt ::= */ yytestcase(yyruleno==393); - case 400: /* agg_func_opt ::= */ yytestcase(yyruleno==400); - case 406: /* or_replace_opt ::= */ yytestcase(yyruleno==406); - case 438: /* ignore_opt ::= */ yytestcase(yyruleno==438); - case 694: /* tag_mode_opt ::= */ yytestcase(yyruleno==694); - case 696: /* set_quantifier_opt ::= */ yytestcase(yyruleno==696); + case 211: /* with_opt ::= */ yytestcase(yyruleno==211); + case 394: /* analyze_opt ::= */ yytestcase(yyruleno==394); + case 401: /* agg_func_opt ::= */ yytestcase(yyruleno==401); + case 407: /* or_replace_opt ::= */ yytestcase(yyruleno==407); + case 439: /* ignore_opt ::= */ yytestcase(yyruleno==439); + case 695: /* tag_mode_opt ::= */ yytestcase(yyruleno==695); + case 697: /* set_quantifier_opt ::= */ yytestcase(yyruleno==697); { yymsp[1].minor.yy957 = false; } break; case 79: /* force_opt ::= FORCE */ case 80: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==80); - case 211: /* with_opt ::= WITH */ yytestcase(yyruleno==211); - case 394: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==394); - case 401: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==401); - case 695: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==695); - case 697: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==697); + case 212: /* with_opt ::= WITH */ yytestcase(yyruleno==212); + case 395: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==395); + case 402: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==402); + case 696: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==696); + case 698: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==698); { yymsp[0].minor.yy957 = true; } break; case 81: /* cmd ::= ALTER CLUSTER NK_STRING */ @@ -6384,8 +6387,8 @@ static YYACTIONTYPE yy_reduce( { yymsp[-2].minor.yy957 = true; } break; case 106: /* exists_opt ::= IF EXISTS */ - case 407: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==407); - case 439: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==439); + case 408: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==408); + case 440: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==440); { yymsp[-1].minor.yy957 = true; } break; case 108: /* db_options ::= */ @@ -6534,897 +6537,901 @@ static YYACTIONTYPE yy_reduce( { yylhsminor.yy980 = setDatabaseOption(pCxt, yymsp[-2].minor.yy980, DB_OPTION_ENCRYPT_ALGORITHM, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 145: /* alter_db_options ::= alter_db_option */ + case 145: /* db_options ::= db_options DNODES NK_STRING */ +{ yylhsminor.yy980 = setDatabaseOption(pCxt, yymsp[-2].minor.yy980, DB_OPTION_DNODES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy980 = yylhsminor.yy980; + break; + case 146: /* alter_db_options ::= alter_db_option */ { yylhsminor.yy980 = createAlterDatabaseOptions(pCxt); yylhsminor.yy980 = setAlterDatabaseOption(pCxt, yylhsminor.yy980, &yymsp[0].minor.yy529); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 146: /* alter_db_options ::= alter_db_options alter_db_option */ + case 147: /* alter_db_options ::= alter_db_options alter_db_option */ { yylhsminor.yy980 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy980, &yymsp[0].minor.yy529); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 147: /* alter_db_option ::= BUFFER NK_INTEGER */ + case 148: /* alter_db_option ::= BUFFER NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 148: /* alter_db_option ::= CACHEMODEL NK_STRING */ + case 149: /* alter_db_option ::= CACHEMODEL NK_STRING */ { yymsp[-1].minor.yy529.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 149: /* alter_db_option ::= CACHESIZE NK_INTEGER */ + case 150: /* alter_db_option ::= CACHESIZE NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 150: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + case 151: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 151: /* alter_db_option ::= KEEP integer_list */ - case 152: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==152); + case 152: /* alter_db_option ::= KEEP integer_list */ + case 153: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==153); { yymsp[-1].minor.yy529.type = DB_OPTION_KEEP; yymsp[-1].minor.yy529.pList = yymsp[0].minor.yy628; } break; - case 153: /* alter_db_option ::= PAGES NK_INTEGER */ + case 154: /* alter_db_option ::= PAGES NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_PAGES; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 154: /* alter_db_option ::= REPLICA NK_INTEGER */ + case 155: /* alter_db_option ::= REPLICA NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 155: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ + case 156: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_WAL; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 156: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ + case 157: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 157: /* alter_db_option ::= MINROWS NK_INTEGER */ + case 158: /* alter_db_option ::= MINROWS NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 158: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ + case 159: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 159: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + case 160: /* alter_db_option ::= 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; yymsp[-2].minor.yy529.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy529.val = t; } break; - case 160: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ + case 161: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 161: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + case 162: /* alter_db_option ::= 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; yymsp[-2].minor.yy529.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy529.val = t; } break; - case 162: /* alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ - case 163: /* alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ yytestcase(yyruleno==163); + case 163: /* alter_db_option ::= S3_KEEPLOCAL NK_INTEGER */ + case 164: /* alter_db_option ::= S3_KEEPLOCAL NK_VARIABLE */ yytestcase(yyruleno==164); { yymsp[-1].minor.yy529.type = DB_OPTION_S3_KEEPLOCAL; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 164: /* alter_db_option ::= S3_COMPACT NK_INTEGER */ + case 165: /* alter_db_option ::= S3_COMPACT NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_S3_COMPACT, yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 165: /* alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ + case 166: /* alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ { yymsp[-1].minor.yy529.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 166: /* alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ + case 167: /* alter_db_option ::= ENCRYPT_ALGORITHM NK_STRING */ { yymsp[-1].minor.yy529.type = DB_OPTION_ENCRYPT_ALGORITHM; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 167: /* integer_list ::= NK_INTEGER */ + case 168: /* integer_list ::= NK_INTEGER */ { yylhsminor.yy628 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 168: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 453: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==453); + case 169: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ + case 454: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==454); { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-2].minor.yy628, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy628 = yylhsminor.yy628; break; - case 169: /* variable_list ::= NK_VARIABLE */ + case 170: /* variable_list ::= NK_VARIABLE */ { yylhsminor.yy628 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 170: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + case 171: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-2].minor.yy628, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy628 = yylhsminor.yy628; break; - case 171: /* retention_list ::= retention */ - case 204: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==204); - case 207: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==207); - case 216: /* tag_def_list ::= tag_def */ yytestcase(yyruleno==216); - case 219: /* column_def_list ::= column_def */ yytestcase(yyruleno==219); - case 267: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==267); - case 272: /* col_name_list ::= col_name */ yytestcase(yyruleno==272); - case 344: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==344); - case 368: /* func_list ::= func */ yytestcase(yyruleno==368); - case 418: /* column_stream_def_list ::= column_stream_def */ yytestcase(yyruleno==418); - case 497: /* tags_literal_list ::= tags_literal */ yytestcase(yyruleno==497); - case 522: /* literal_list ::= signed_literal */ yytestcase(yyruleno==522); - case 617: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==617); - case 623: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==623); - case 699: /* select_list ::= select_item */ yytestcase(yyruleno==699); - case 710: /* partition_list ::= partition_item */ yytestcase(yyruleno==710); - case 773: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==773); + case 172: /* retention_list ::= retention */ + case 205: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==205); + case 208: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==208); + case 217: /* tag_def_list ::= tag_def */ yytestcase(yyruleno==217); + case 220: /* column_def_list ::= column_def */ yytestcase(yyruleno==220); + case 268: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==268); + case 273: /* col_name_list ::= col_name */ yytestcase(yyruleno==273); + case 345: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==345); + case 369: /* func_list ::= func */ yytestcase(yyruleno==369); + case 419: /* column_stream_def_list ::= column_stream_def */ yytestcase(yyruleno==419); + case 498: /* tags_literal_list ::= tags_literal */ yytestcase(yyruleno==498); + case 523: /* literal_list ::= signed_literal */ yytestcase(yyruleno==523); + case 618: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==618); + case 624: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==624); + case 700: /* select_list ::= select_item */ yytestcase(yyruleno==700); + case 711: /* partition_list ::= partition_item */ yytestcase(yyruleno==711); + case 774: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==774); { yylhsminor.yy628 = createNodeList(pCxt, yymsp[0].minor.yy980); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 172: /* retention_list ::= retention_list NK_COMMA retention */ - case 208: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==208); - case 217: /* tag_def_list ::= tag_def_list NK_COMMA tag_def */ yytestcase(yyruleno==217); - case 220: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==220); - case 268: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==268); - case 273: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==273); - case 345: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==345); - case 369: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==369); - case 419: /* column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ yytestcase(yyruleno==419); - case 498: /* tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ yytestcase(yyruleno==498); - case 523: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==523); - case 618: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==618); - case 700: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==700); - case 711: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==711); - case 774: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==774); + case 173: /* retention_list ::= retention_list NK_COMMA retention */ + case 209: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==209); + case 218: /* tag_def_list ::= tag_def_list NK_COMMA tag_def */ yytestcase(yyruleno==218); + case 221: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==221); + case 269: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==269); + case 274: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==274); + case 346: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==346); + case 370: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==370); + case 420: /* column_stream_def_list ::= column_stream_def_list NK_COMMA column_stream_def */ yytestcase(yyruleno==420); + case 499: /* tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ yytestcase(yyruleno==499); + case 524: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==524); + case 619: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==619); + case 701: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==701); + case 712: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==712); + case 775: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==775); { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-2].minor.yy628, yymsp[0].minor.yy980); } yymsp[-2].minor.yy628 = yylhsminor.yy628; break; - case 173: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - case 174: /* retention ::= NK_MINUS NK_COLON NK_VARIABLE */ yytestcase(yyruleno==174); + case 174: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + case 175: /* retention ::= NK_MINUS NK_COLON NK_VARIABLE */ yytestcase(yyruleno==175); { yylhsminor.yy980 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 175: /* speed_opt ::= */ - case 402: /* bufsize_opt ::= */ yytestcase(yyruleno==402); + case 176: /* speed_opt ::= */ + case 403: /* bufsize_opt ::= */ yytestcase(yyruleno==403); { yymsp[1].minor.yy844 = 0; } break; - case 176: /* speed_opt ::= BWLIMIT NK_INTEGER */ - case 403: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==403); + case 177: /* speed_opt ::= BWLIMIT NK_INTEGER */ + case 404: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==404); { yymsp[-1].minor.yy844 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 178: /* start_opt ::= START WITH NK_INTEGER */ - case 182: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==182); + case 179: /* start_opt ::= START WITH NK_INTEGER */ + case 183: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==183); { yymsp[-2].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; - case 179: /* start_opt ::= START WITH NK_STRING */ - case 183: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==183); + case 180: /* start_opt ::= START WITH NK_STRING */ + case 184: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==184); { yymsp[-2].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 180: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ - case 184: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==184); + case 181: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ + case 185: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==185); { yymsp[-3].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 185: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - case 188: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==188); + case 186: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + case 189: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==189); { pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy957, yymsp[-5].minor.yy980, yymsp[-3].minor.yy628, yymsp[-1].minor.yy628, yymsp[0].minor.yy980); } break; - case 186: /* cmd ::= CREATE TABLE multi_create_clause */ + case 187: /* cmd ::= CREATE TABLE multi_create_clause */ { pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy628); } break; - case 187: /* cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ + case 188: /* cmd ::= CREATE TABLE not_exists_opt USING full_table_name NK_LP tag_list_opt NK_RP FILE NK_STRING */ { pCxt->pRootNode = createCreateSubTableFromFileClause(pCxt, yymsp[-7].minor.yy957, yymsp[-5].minor.yy980, yymsp[-3].minor.yy628, &yymsp[0].minor.yy0); } break; - case 189: /* cmd ::= DROP TABLE with_opt multi_drop_clause */ + case 190: /* cmd ::= DROP TABLE with_opt multi_drop_clause */ { pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy628); } break; - case 190: /* cmd ::= DROP STABLE with_opt exists_opt full_table_name */ + case 191: /* cmd ::= DROP STABLE with_opt exists_opt full_table_name */ { pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-2].minor.yy957, yymsp[-1].minor.yy957, yymsp[0].minor.yy980); } break; - case 191: /* cmd ::= ALTER TABLE alter_table_clause */ - case 455: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==455); - case 456: /* cmd ::= insert_query */ yytestcase(yyruleno==456); + case 192: /* cmd ::= ALTER TABLE alter_table_clause */ + case 456: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==456); + case 457: /* cmd ::= insert_query */ yytestcase(yyruleno==457); { pCxt->pRootNode = yymsp[0].minor.yy980; } break; - case 192: /* cmd ::= ALTER STABLE alter_table_clause */ + case 193: /* cmd ::= ALTER STABLE alter_table_clause */ { pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy980); } break; - case 193: /* alter_table_clause ::= full_table_name alter_table_options */ + case 194: /* alter_table_clause ::= full_table_name alter_table_options */ { yylhsminor.yy980 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 194: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ + case 195: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name column_options */ { yylhsminor.yy980 = createAlterTableAddModifyColOptions2(pCxt, yymsp[-5].minor.yy980, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-2].minor.yy561, yymsp[-1].minor.yy896, yymsp[0].minor.yy980); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 195: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ + case 196: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ { yylhsminor.yy980 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy980, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy561); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 196: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + case 197: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ { yylhsminor.yy980 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy561, yymsp[0].minor.yy896); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 197: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ + case 198: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ { yylhsminor.yy980 = createAlterTableAddModifyColOptions(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS, &yymsp[-1].minor.yy561, yymsp[0].minor.yy980); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 198: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + case 199: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ { yylhsminor.yy980 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 199: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + case 200: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ { yylhsminor.yy980 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy561, yymsp[0].minor.yy896); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 200: /* alter_table_clause ::= full_table_name DROP TAG column_name */ + case 201: /* alter_table_clause ::= full_table_name DROP TAG column_name */ { yylhsminor.yy980 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy980, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy561); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 201: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + case 202: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ { yylhsminor.yy980 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy561, yymsp[0].minor.yy896); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 202: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + case 203: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ { yylhsminor.yy980 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy980, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 203: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ + case 204: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ { yylhsminor.yy980 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy980, &yymsp[-2].minor.yy561, yymsp[0].minor.yy980); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 205: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ - case 624: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==624); + case 206: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ + case 625: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==625); { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-1].minor.yy628, yymsp[0].minor.yy980); } yymsp[-1].minor.yy628 = yylhsminor.yy628; break; - case 206: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ + case 207: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ { yylhsminor.yy980 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy957, yymsp[-8].minor.yy980, yymsp[-6].minor.yy980, yymsp[-5].minor.yy628, yymsp[-2].minor.yy628, yymsp[0].minor.yy980); } yymsp[-9].minor.yy980 = yylhsminor.yy980; break; - case 209: /* drop_table_clause ::= exists_opt full_table_name */ + case 210: /* drop_table_clause ::= exists_opt full_table_name */ { yylhsminor.yy980 = createDropTableClause(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy980); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 213: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ - case 417: /* col_list_opt ::= NK_LP column_stream_def_list NK_RP */ yytestcase(yyruleno==417); + case 214: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ + case 418: /* col_list_opt ::= NK_LP column_stream_def_list NK_RP */ yytestcase(yyruleno==418); { yymsp[-2].minor.yy628 = yymsp[-1].minor.yy628; } break; - case 214: /* full_table_name ::= table_name */ - case 358: /* full_tsma_name ::= tsma_name */ yytestcase(yyruleno==358); + case 215: /* full_table_name ::= table_name */ + case 359: /* full_tsma_name ::= tsma_name */ yytestcase(yyruleno==359); { yylhsminor.yy980 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy561, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 215: /* full_table_name ::= db_name NK_DOT table_name */ - case 359: /* full_tsma_name ::= db_name NK_DOT tsma_name */ yytestcase(yyruleno==359); + case 216: /* full_table_name ::= db_name NK_DOT table_name */ + case 360: /* full_tsma_name ::= db_name NK_DOT tsma_name */ yytestcase(yyruleno==360); { yylhsminor.yy980 = createRealTableNode(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561, NULL); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 218: /* tag_def ::= column_name type_name */ + case 219: /* tag_def ::= column_name type_name */ { yylhsminor.yy980 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy561, yymsp[0].minor.yy896, NULL); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 221: /* column_def ::= column_name type_name column_options */ + case 222: /* column_def ::= column_name type_name column_options */ { yylhsminor.yy980 = createColumnDefNode(pCxt, &yymsp[-2].minor.yy561, yymsp[-1].minor.yy896, yymsp[0].minor.yy980); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 222: /* type_name ::= BOOL */ + case 223: /* type_name ::= BOOL */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_BOOL); } break; - case 223: /* type_name ::= TINYINT */ + case 224: /* type_name ::= TINYINT */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; - case 224: /* type_name ::= SMALLINT */ + case 225: /* type_name ::= SMALLINT */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; - case 225: /* type_name ::= INT */ - case 226: /* type_name ::= INTEGER */ yytestcase(yyruleno==226); + case 226: /* type_name ::= INT */ + case 227: /* type_name ::= INTEGER */ yytestcase(yyruleno==227); { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_INT); } break; - case 227: /* type_name ::= BIGINT */ + case 228: /* type_name ::= BIGINT */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; - case 228: /* type_name ::= FLOAT */ + case 229: /* type_name ::= FLOAT */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; - case 229: /* type_name ::= DOUBLE */ + case 230: /* type_name ::= DOUBLE */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; - case 230: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + case 231: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; - case 231: /* type_name ::= TIMESTAMP */ + case 232: /* type_name ::= TIMESTAMP */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; - case 232: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + case 233: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; - case 233: /* type_name ::= TINYINT UNSIGNED */ + case 234: /* type_name ::= TINYINT UNSIGNED */ { yymsp[-1].minor.yy896 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; - case 234: /* type_name ::= SMALLINT UNSIGNED */ + case 235: /* type_name ::= SMALLINT UNSIGNED */ { yymsp[-1].minor.yy896 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; - case 235: /* type_name ::= INT UNSIGNED */ + case 236: /* type_name ::= INT UNSIGNED */ { yymsp[-1].minor.yy896 = createDataType(TSDB_DATA_TYPE_UINT); } break; - case 236: /* type_name ::= BIGINT UNSIGNED */ + case 237: /* type_name ::= BIGINT UNSIGNED */ { yymsp[-1].minor.yy896 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; - case 237: /* type_name ::= JSON */ + case 238: /* type_name ::= JSON */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_JSON); } break; - case 238: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + case 239: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; - case 239: /* type_name ::= MEDIUMBLOB */ + case 240: /* type_name ::= MEDIUMBLOB */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; - case 240: /* type_name ::= BLOB */ + case 241: /* type_name ::= BLOB */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_BLOB); } break; - case 241: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + case 242: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; - case 242: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ + case 243: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } break; - case 243: /* type_name ::= DECIMAL */ + case 244: /* type_name ::= DECIMAL */ { yymsp[0].minor.yy896 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 244: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + case 245: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy896 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 245: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + case 246: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ { yymsp[-5].minor.yy896 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 246: /* type_name_default_len ::= BINARY */ + case 247: /* type_name_default_len ::= BINARY */ { yymsp[0].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, NULL); } break; - case 247: /* type_name_default_len ::= NCHAR */ + case 248: /* type_name_default_len ::= NCHAR */ { yymsp[0].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, NULL); } break; - case 248: /* type_name_default_len ::= VARCHAR */ + case 249: /* type_name_default_len ::= VARCHAR */ { yymsp[0].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, NULL); } break; - case 249: /* type_name_default_len ::= VARBINARY */ + case 250: /* type_name_default_len ::= VARBINARY */ { yymsp[0].minor.yy896 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, NULL); } break; - case 252: /* tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - case 425: /* tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ yytestcase(yyruleno==425); + case 253: /* tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + case 426: /* tag_def_or_ref_opt ::= TAGS NK_LP column_stream_def_list NK_RP */ yytestcase(yyruleno==426); { yymsp[-3].minor.yy628 = yymsp[-1].minor.yy628; } break; - case 253: /* table_options ::= */ + case 254: /* table_options ::= */ { yymsp[1].minor.yy980 = createDefaultTableOptions(pCxt); } break; - case 254: /* table_options ::= table_options COMMENT NK_STRING */ + case 255: /* table_options ::= table_options COMMENT NK_STRING */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-2].minor.yy980, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 255: /* table_options ::= table_options MAX_DELAY duration_list */ + case 256: /* table_options ::= table_options MAX_DELAY duration_list */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-2].minor.yy980, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy628); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 256: /* table_options ::= table_options WATERMARK duration_list */ + case 257: /* table_options ::= table_options WATERMARK duration_list */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-2].minor.yy980, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy628); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 257: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + case 258: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-4].minor.yy980, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy628); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 258: /* table_options ::= table_options TTL NK_INTEGER */ + case 259: /* table_options ::= table_options TTL NK_INTEGER */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-2].minor.yy980, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 259: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + case 260: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-4].minor.yy980, TABLE_OPTION_SMA, yymsp[-1].minor.yy628); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 260: /* table_options ::= table_options DELETE_MARK duration_list */ + case 261: /* table_options ::= table_options DELETE_MARK duration_list */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-2].minor.yy980, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy628); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 261: /* alter_table_options ::= alter_table_option */ + case 262: /* alter_table_options ::= alter_table_option */ { yylhsminor.yy980 = createAlterTableOptions(pCxt); yylhsminor.yy980 = setTableOption(pCxt, yylhsminor.yy980, yymsp[0].minor.yy529.type, &yymsp[0].minor.yy529.val); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 262: /* alter_table_options ::= alter_table_options alter_table_option */ + case 263: /* alter_table_options ::= alter_table_options alter_table_option */ { yylhsminor.yy980 = setTableOption(pCxt, yymsp[-1].minor.yy980, yymsp[0].minor.yy529.type, &yymsp[0].minor.yy529.val); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 263: /* alter_table_option ::= COMMENT NK_STRING */ + case 264: /* alter_table_option ::= COMMENT NK_STRING */ { yymsp[-1].minor.yy529.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 264: /* alter_table_option ::= TTL NK_INTEGER */ + case 265: /* alter_table_option ::= TTL NK_INTEGER */ { yymsp[-1].minor.yy529.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy529.val = yymsp[0].minor.yy0; } break; - case 265: /* duration_list ::= duration_literal */ - case 555: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==555); + case 266: /* duration_list ::= duration_literal */ + case 556: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==556); { yylhsminor.yy628 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 266: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 556: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==556); + case 267: /* duration_list ::= duration_list NK_COMMA duration_literal */ + case 557: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==557); { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-2].minor.yy628, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[-2].minor.yy628 = yylhsminor.yy628; break; - case 269: /* rollup_func_name ::= function_name */ + case 270: /* rollup_func_name ::= function_name */ { yylhsminor.yy980 = createFunctionNode(pCxt, &yymsp[0].minor.yy561, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 270: /* rollup_func_name ::= FIRST */ - case 271: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==271); - case 347: /* tag_item ::= QTAGS */ yytestcase(yyruleno==347); + case 271: /* rollup_func_name ::= FIRST */ + case 272: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==272); + case 348: /* tag_item ::= QTAGS */ yytestcase(yyruleno==348); { yylhsminor.yy980 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 274: /* col_name ::= column_name */ - case 348: /* tag_item ::= column_name */ yytestcase(yyruleno==348); + case 275: /* col_name ::= column_name */ + case 349: /* tag_item ::= column_name */ yytestcase(yyruleno==349); { yylhsminor.yy980 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy561); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 275: /* cmd ::= SHOW DNODES */ + case 276: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } break; - case 276: /* cmd ::= SHOW USERS */ + case 277: /* cmd ::= SHOW USERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); } break; - case 277: /* cmd ::= SHOW USERS FULL */ + case 278: /* cmd ::= SHOW USERS FULL */ { pCxt->pRootNode = createShowStmtWithFull(pCxt, QUERY_NODE_SHOW_USERS_FULL_STMT); } break; - case 278: /* cmd ::= SHOW USER PRIVILEGES */ + case 279: /* cmd ::= SHOW USER PRIVILEGES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); } break; - case 279: /* cmd ::= SHOW db_kind_opt DATABASES */ + case 280: /* cmd ::= SHOW db_kind_opt DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); (void)setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy1041); } break; - case 280: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + case 281: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ { pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy513, yymsp[0].minor.yy980, OP_TYPE_LIKE); } break; - case 281: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + case 282: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy980, yymsp[0].minor.yy980, OP_TYPE_LIKE); } break; - case 282: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ + case 283: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy980, NULL, OP_TYPE_LIKE); } break; - case 283: /* cmd ::= SHOW MNODES */ + case 284: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } break; - case 284: /* cmd ::= SHOW QNODES */ + case 285: /* cmd ::= SHOW QNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } break; - case 285: /* cmd ::= SHOW ANODES */ + case 286: /* cmd ::= SHOW ANODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ANODES_STMT); } break; - case 286: /* cmd ::= SHOW ANODES FULL */ + case 287: /* cmd ::= SHOW ANODES FULL */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ANODES_FULL_STMT); } break; - case 287: /* cmd ::= SHOW ARBGROUPS */ + case 288: /* cmd ::= SHOW ARBGROUPS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ARBGROUPS_STMT); } break; - case 288: /* cmd ::= SHOW FUNCTIONS */ + case 289: /* cmd ::= SHOW FUNCTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } break; - case 289: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + case 290: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy980, yymsp[-1].minor.yy980, OP_TYPE_EQUAL); } break; - case 290: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + case 291: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy561), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy561), OP_TYPE_EQUAL); } break; - case 291: /* cmd ::= SHOW STREAMS */ + case 292: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } break; - case 292: /* cmd ::= SHOW ACCOUNTS */ + case 293: /* cmd ::= SHOW ACCOUNTS */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } break; - case 293: /* cmd ::= SHOW APPS */ + case 294: /* cmd ::= SHOW APPS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } break; - case 294: /* cmd ::= SHOW CONNECTIONS */ + case 295: /* cmd ::= SHOW CONNECTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } break; - case 295: /* cmd ::= SHOW LICENCES */ - case 296: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==296); + case 296: /* cmd ::= SHOW LICENCES */ + case 297: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==297); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } break; - case 297: /* cmd ::= SHOW GRANTS FULL */ + case 298: /* cmd ::= SHOW GRANTS FULL */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_FULL_STMT); } break; - case 298: /* cmd ::= SHOW GRANTS LOGS */ + case 299: /* cmd ::= SHOW GRANTS LOGS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_LOGS_STMT); } break; - case 299: /* cmd ::= SHOW CLUSTER MACHINES */ + case 300: /* cmd ::= SHOW CLUSTER MACHINES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); } break; - case 300: /* cmd ::= SHOW CREATE DATABASE db_name */ + case 301: /* cmd ::= SHOW CREATE DATABASE db_name */ { pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy561); } break; - case 301: /* cmd ::= SHOW CREATE TABLE full_table_name */ + case 302: /* cmd ::= SHOW CREATE TABLE full_table_name */ { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy980); } break; - case 302: /* cmd ::= SHOW CREATE STABLE full_table_name */ + case 303: /* cmd ::= SHOW CREATE STABLE full_table_name */ { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy980); } break; - case 303: /* cmd ::= SHOW ENCRYPTIONS */ + case 304: /* cmd ::= SHOW ENCRYPTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ENCRYPTIONS_STMT); } break; - case 304: /* cmd ::= SHOW QUERIES */ + case 305: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } break; - case 305: /* cmd ::= SHOW SCORES */ + case 306: /* cmd ::= SHOW SCORES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } break; - case 306: /* cmd ::= SHOW TOPICS */ + case 307: /* cmd ::= SHOW TOPICS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } break; - case 307: /* cmd ::= SHOW VARIABLES */ - case 308: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==308); + case 308: /* cmd ::= SHOW VARIABLES */ + case 309: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==309); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } break; - case 309: /* cmd ::= SHOW LOCAL VARIABLES */ + case 310: /* cmd ::= SHOW LOCAL VARIABLES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } break; - case 310: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + case 311: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ { pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy980); } break; - case 311: /* cmd ::= SHOW BNODES */ + case 312: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } break; - case 312: /* cmd ::= SHOW SNODES */ + case 313: /* cmd ::= SHOW SNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } break; - case 313: /* cmd ::= SHOW CLUSTER */ + case 314: /* cmd ::= SHOW CLUSTER */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } break; - case 314: /* cmd ::= SHOW TRANSACTIONS */ + case 315: /* cmd ::= SHOW TRANSACTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } break; - case 315: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + case 316: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ { pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy980); } break; - case 316: /* cmd ::= SHOW CONSUMERS */ + case 317: /* cmd ::= SHOW CONSUMERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } break; - case 317: /* cmd ::= SHOW SUBSCRIPTIONS */ + case 318: /* cmd ::= SHOW SUBSCRIPTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } break; - case 318: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + case 319: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy980, yymsp[-1].minor.yy980, OP_TYPE_EQUAL); } break; - case 319: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + case 320: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy561), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy561), OP_TYPE_EQUAL); } break; - case 320: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + case 321: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy980, yymsp[0].minor.yy980, yymsp[-3].minor.yy628); } break; - case 321: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + case 322: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ { pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy561), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy561), yymsp[-4].minor.yy628); } break; - case 322: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + case 323: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } break; - case 323: /* cmd ::= SHOW VNODES */ + case 324: /* cmd ::= SHOW VNODES */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } break; - case 324: /* cmd ::= SHOW db_name_cond_opt ALIVE */ + case 325: /* cmd ::= SHOW db_name_cond_opt ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy980, QUERY_NODE_SHOW_DB_ALIVE_STMT); } break; - case 325: /* cmd ::= SHOW CLUSTER ALIVE */ + case 326: /* cmd ::= SHOW CLUSTER ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } break; - case 326: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ + case 327: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy980, yymsp[0].minor.yy980, OP_TYPE_LIKE); } break; - case 327: /* cmd ::= SHOW CREATE VIEW full_table_name */ + case 328: /* cmd ::= SHOW CREATE VIEW full_table_name */ { pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy980); } break; - case 328: /* cmd ::= SHOW COMPACTS */ + case 329: /* cmd ::= SHOW COMPACTS */ { pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); } break; - case 329: /* cmd ::= SHOW COMPACT NK_INTEGER */ + case 330: /* cmd ::= SHOW COMPACT NK_INTEGER */ { pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 330: /* table_kind_db_name_cond_opt ::= */ + case 331: /* table_kind_db_name_cond_opt ::= */ { yymsp[1].minor.yy513.kind = SHOW_KIND_ALL; yymsp[1].minor.yy513.dbName = nil_token; } break; - case 331: /* table_kind_db_name_cond_opt ::= table_kind */ + case 332: /* table_kind_db_name_cond_opt ::= table_kind */ { yylhsminor.yy513.kind = yymsp[0].minor.yy1041; yylhsminor.yy513.dbName = nil_token; } yymsp[0].minor.yy513 = yylhsminor.yy513; break; - case 332: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ + case 333: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ { yylhsminor.yy513.kind = SHOW_KIND_ALL; yylhsminor.yy513.dbName = yymsp[-1].minor.yy561; } yymsp[-1].minor.yy513 = yylhsminor.yy513; break; - case 333: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + case 334: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ { yylhsminor.yy513.kind = yymsp[-2].minor.yy1041; yylhsminor.yy513.dbName = yymsp[-1].minor.yy561; } yymsp[-2].minor.yy513 = yylhsminor.yy513; break; - case 334: /* table_kind ::= NORMAL */ + case 335: /* table_kind ::= NORMAL */ { yymsp[0].minor.yy1041 = SHOW_KIND_TABLES_NORMAL; } break; - case 335: /* table_kind ::= CHILD */ + case 336: /* table_kind ::= CHILD */ { yymsp[0].minor.yy1041 = SHOW_KIND_TABLES_CHILD; } break; - case 336: /* db_name_cond_opt ::= */ - case 341: /* from_db_opt ::= */ yytestcase(yyruleno==341); + case 337: /* db_name_cond_opt ::= */ + case 342: /* from_db_opt ::= */ yytestcase(yyruleno==342); { yymsp[1].minor.yy980 = createDefaultDatabaseCondValue(pCxt); } break; - case 337: /* db_name_cond_opt ::= db_name NK_DOT */ + case 338: /* db_name_cond_opt ::= db_name NK_DOT */ { yylhsminor.yy980 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy561); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 339: /* like_pattern_opt ::= LIKE NK_STRING */ + case 340: /* like_pattern_opt ::= LIKE NK_STRING */ { yymsp[-1].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; - case 340: /* table_name_cond ::= table_name */ + case 341: /* table_name_cond ::= table_name */ { yylhsminor.yy980 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy561); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 342: /* from_db_opt ::= FROM db_name */ + case 343: /* from_db_opt ::= FROM db_name */ { yymsp[-1].minor.yy980 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy561); } break; - case 346: /* tag_item ::= TBNAME */ + case 347: /* tag_item ::= TBNAME */ { yylhsminor.yy980 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 349: /* tag_item ::= column_name column_alias */ + case 350: /* tag_item ::= column_name column_alias */ { yylhsminor.yy980 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy561), &yymsp[0].minor.yy561); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 350: /* tag_item ::= column_name AS column_alias */ + case 351: /* tag_item ::= column_name AS column_alias */ { yylhsminor.yy980 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy561), &yymsp[0].minor.yy561); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 351: /* db_kind_opt ::= */ + case 352: /* db_kind_opt ::= */ { yymsp[1].minor.yy1041 = SHOW_KIND_ALL; } break; - case 352: /* db_kind_opt ::= USER */ + case 353: /* db_kind_opt ::= USER */ { yymsp[0].minor.yy1041 = SHOW_KIND_DATABASES_USER; } break; - case 353: /* db_kind_opt ::= SYSTEM */ + case 354: /* db_kind_opt ::= SYSTEM */ { yymsp[0].minor.yy1041 = SHOW_KIND_DATABASES_SYSTEM; } break; - case 354: /* cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ + case 355: /* cmd ::= CREATE TSMA not_exists_opt tsma_name ON full_table_name tsma_func_list INTERVAL NK_LP duration_literal NK_RP */ { pCxt->pRootNode = createCreateTSMAStmt(pCxt, yymsp[-8].minor.yy957, &yymsp[-7].minor.yy561, yymsp[-4].minor.yy980, yymsp[-5].minor.yy980, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 355: /* cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ + case 356: /* cmd ::= CREATE RECURSIVE TSMA not_exists_opt tsma_name ON full_table_name INTERVAL NK_LP duration_literal NK_RP */ { pCxt->pRootNode = createCreateTSMAStmt(pCxt, yymsp[-7].minor.yy957, &yymsp[-6].minor.yy561, NULL, yymsp[-4].minor.yy980, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 356: /* cmd ::= DROP TSMA exists_opt full_tsma_name */ + case 357: /* cmd ::= DROP TSMA exists_opt full_tsma_name */ { pCxt->pRootNode = createDropTSMAStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy980); } break; - case 357: /* cmd ::= SHOW db_name_cond_opt TSMAS */ + case 358: /* cmd ::= SHOW db_name_cond_opt TSMAS */ { pCxt->pRootNode = createShowTSMASStmt(pCxt, yymsp[-1].minor.yy980); } break; - case 360: /* tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ + case 361: /* tsma_func_list ::= FUNCTION NK_LP func_list NK_RP */ { yymsp[-3].minor.yy980 = createTSMAOptions(pCxt, yymsp[-1].minor.yy628); } break; - case 361: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + case 362: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy957, yymsp[-3].minor.yy980, yymsp[-1].minor.yy980, NULL, yymsp[0].minor.yy980); } break; - case 362: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + case 363: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy957, yymsp[-5].minor.yy980, yymsp[-3].minor.yy980, yymsp[-1].minor.yy628, NULL); } break; - case 363: /* cmd ::= DROP INDEX exists_opt full_index_name */ + case 364: /* cmd ::= DROP INDEX exists_opt full_index_name */ { pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy980); } break; - case 364: /* full_index_name ::= index_name */ + case 365: /* full_index_name ::= index_name */ { yylhsminor.yy980 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy561); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 365: /* full_index_name ::= db_name NK_DOT index_name */ + case 366: /* full_index_name ::= db_name NK_DOT index_name */ { yylhsminor.yy980 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 366: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + case 367: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ { yymsp[-9].minor.yy980 = createIndexOption(pCxt, yymsp[-7].minor.yy628, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), NULL, yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 367: /* 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 */ + case 368: /* 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.yy980 = createIndexOption(pCxt, yymsp[-9].minor.yy628, releaseRawExprNode(pCxt, yymsp[-5].minor.yy980), releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 370: /* func ::= sma_func_name NK_LP expression_list NK_RP */ + case 371: /* func ::= sma_func_name NK_LP expression_list NK_RP */ { yylhsminor.yy980 = createFunctionNode(pCxt, &yymsp[-3].minor.yy561, yymsp[-1].minor.yy628); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 371: /* sma_func_name ::= function_name */ - case 667: /* alias_opt ::= table_alias */ yytestcase(yyruleno==667); + case 372: /* sma_func_name ::= function_name */ + case 668: /* alias_opt ::= table_alias */ yytestcase(yyruleno==668); { yylhsminor.yy561 = yymsp[0].minor.yy561; } yymsp[0].minor.yy561 = yylhsminor.yy561; break; - case 376: /* sma_stream_opt ::= */ - case 426: /* stream_options ::= */ yytestcase(yyruleno==426); + case 377: /* sma_stream_opt ::= */ + case 427: /* stream_options ::= */ yytestcase(yyruleno==427); { yymsp[1].minor.yy980 = createStreamOptions(pCxt); } break; - case 377: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + case 378: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ { ((SStreamOptions*)yymsp[-2].minor.yy980)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = yymsp[-2].minor.yy980; } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 378: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + case 379: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ { ((SStreamOptions*)yymsp[-2].minor.yy980)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = yymsp[-2].minor.yy980; } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 379: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + case 380: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ { ((SStreamOptions*)yymsp[-2].minor.yy980)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = yymsp[-2].minor.yy980; } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 380: /* with_meta ::= AS */ + case 381: /* with_meta ::= AS */ { yymsp[0].minor.yy844 = 0; } break; - case 381: /* with_meta ::= WITH META AS */ + case 382: /* with_meta ::= WITH META AS */ { yymsp[-2].minor.yy844 = 1; } break; - case 382: /* with_meta ::= ONLY META AS */ + case 383: /* with_meta ::= ONLY META AS */ { yymsp[-2].minor.yy844 = 2; } break; - case 383: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + case 384: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ { pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy957, &yymsp[-2].minor.yy561, yymsp[0].minor.yy980); } break; - case 384: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + case 385: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ { pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy957, &yymsp[-3].minor.yy561, &yymsp[0].minor.yy561, yymsp[-2].minor.yy844); } break; - case 385: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + case 386: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ { pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy957, &yymsp[-4].minor.yy561, yymsp[-1].minor.yy980, yymsp[-3].minor.yy844, yymsp[0].minor.yy980); } break; - case 386: /* cmd ::= DROP TOPIC exists_opt topic_name */ + case 387: /* cmd ::= DROP TOPIC exists_opt topic_name */ { pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy561); } break; - case 387: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + case 388: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ { pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy957, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561); } break; - case 388: /* cmd ::= DESC full_table_name */ - case 389: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==389); + case 389: /* cmd ::= DESC full_table_name */ + case 390: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==390); { pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy980); } break; - case 390: /* cmd ::= RESET QUERY CACHE */ + case 391: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; - case 391: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - case 392: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==392); + case 392: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + case 393: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==393); { pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy957, yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 395: /* explain_options ::= */ + case 396: /* explain_options ::= */ { yymsp[1].minor.yy980 = createDefaultExplainOptions(pCxt); } break; - case 396: /* explain_options ::= explain_options VERBOSE NK_BOOL */ + case 397: /* explain_options ::= explain_options VERBOSE NK_BOOL */ { yylhsminor.yy980 = setExplainVerbose(pCxt, yymsp[-2].minor.yy980, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 397: /* explain_options ::= explain_options RATIO NK_FLOAT */ + case 398: /* explain_options ::= explain_options RATIO NK_FLOAT */ { yylhsminor.yy980 = setExplainRatio(pCxt, yymsp[-2].minor.yy980, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 398: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + case 399: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ { pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy957, yymsp[-9].minor.yy957, &yymsp[-6].minor.yy561, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy896, yymsp[-1].minor.yy844, &yymsp[0].minor.yy561, yymsp[-10].minor.yy957); } break; - case 399: /* cmd ::= DROP FUNCTION exists_opt function_name */ + case 400: /* cmd ::= DROP FUNCTION exists_opt function_name */ { pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy561); } break; - case 404: /* language_opt ::= */ - case 450: /* on_vgroup_id ::= */ yytestcase(yyruleno==450); + case 405: /* language_opt ::= */ + case 451: /* on_vgroup_id ::= */ yytestcase(yyruleno==451); { yymsp[1].minor.yy561 = nil_token; } break; - case 405: /* language_opt ::= LANGUAGE NK_STRING */ - case 451: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==451); + case 406: /* language_opt ::= LANGUAGE NK_STRING */ + case 452: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==452); { yymsp[-1].minor.yy561 = yymsp[0].minor.yy0; } break; - case 408: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + case 409: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ { pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy957, yymsp[-2].minor.yy980, &yymsp[-1].minor.yy0, yymsp[0].minor.yy980); } break; - case 409: /* cmd ::= DROP VIEW exists_opt full_view_name */ + case 410: /* cmd ::= DROP VIEW exists_opt full_view_name */ { pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy980); } break; - case 410: /* full_view_name ::= view_name */ + case 411: /* full_view_name ::= view_name */ { yylhsminor.yy980 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy561); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 411: /* full_view_name ::= db_name NK_DOT view_name */ + case 412: /* full_view_name ::= db_name NK_DOT view_name */ { yylhsminor.yy980 = createViewNode(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 412: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ + case 413: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ { pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy957, &yymsp[-8].minor.yy561, yymsp[-5].minor.yy980, yymsp[-7].minor.yy980, yymsp[-3].minor.yy628, yymsp[-2].minor.yy980, yymsp[0].minor.yy980, yymsp[-4].minor.yy628); } break; - case 413: /* cmd ::= DROP STREAM exists_opt stream_name */ + case 414: /* cmd ::= DROP STREAM exists_opt stream_name */ { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy561); } break; - case 414: /* cmd ::= PAUSE STREAM exists_opt stream_name */ + case 415: /* cmd ::= PAUSE STREAM exists_opt stream_name */ { pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy561); } break; - case 415: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + case 416: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ { pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy957, yymsp[-1].minor.yy957, &yymsp[0].minor.yy561); } break; - case 420: /* column_stream_def ::= column_name stream_col_options */ + case 421: /* column_stream_def ::= column_name stream_col_options */ { yylhsminor.yy980 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy561, createDataType(TSDB_DATA_TYPE_NULL), yymsp[0].minor.yy980); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 421: /* stream_col_options ::= */ - case 782: /* column_options ::= */ yytestcase(yyruleno==782); + case 422: /* stream_col_options ::= */ + case 783: /* column_options ::= */ yytestcase(yyruleno==783); { yymsp[1].minor.yy980 = createDefaultColumnOptions(pCxt); } break; - case 422: /* stream_col_options ::= stream_col_options PRIMARY KEY */ - case 783: /* column_options ::= column_options PRIMARY KEY */ yytestcase(yyruleno==783); + case 423: /* stream_col_options ::= stream_col_options PRIMARY KEY */ + case 784: /* column_options ::= column_options PRIMARY KEY */ yytestcase(yyruleno==784); { yylhsminor.yy980 = setColumnOptionsPK(pCxt, yymsp[-2].minor.yy980); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 427: /* stream_options ::= stream_options TRIGGER AT_ONCE */ - case 428: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==428); - case 429: /* stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ yytestcase(yyruleno==429); + case 428: /* stream_options ::= stream_options TRIGGER AT_ONCE */ + case 429: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==429); + case 430: /* stream_options ::= stream_options TRIGGER FORCE_WINDOW_CLOSE */ yytestcase(yyruleno==430); { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-2].minor.yy980, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 430: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + case 431: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-3].minor.yy980, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 431: /* stream_options ::= stream_options WATERMARK duration_literal */ + case 432: /* stream_options ::= stream_options WATERMARK duration_literal */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-2].minor.yy980, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 432: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + case 433: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-3].minor.yy980, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 433: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + case 434: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-2].minor.yy980, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 434: /* stream_options ::= stream_options DELETE_MARK duration_literal */ + case 435: /* stream_options ::= stream_options DELETE_MARK duration_literal */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-2].minor.yy980, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 435: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + case 436: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ { yylhsminor.yy980 = setStreamOptions(pCxt, yymsp[-3].minor.yy980, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 437: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 726: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==726); - case 750: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==750); + case 438: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + case 727: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==727); + case 751: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==751); { yymsp[-3].minor.yy980 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy980); } break; - case 440: /* cmd ::= KILL CONNECTION NK_INTEGER */ + case 441: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } break; - case 441: /* cmd ::= KILL QUERY NK_STRING */ + case 442: /* cmd ::= KILL QUERY NK_STRING */ { pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 442: /* cmd ::= KILL TRANSACTION NK_INTEGER */ + case 443: /* cmd ::= KILL TRANSACTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } break; - case 443: /* cmd ::= KILL COMPACT NK_INTEGER */ + case 444: /* cmd ::= KILL COMPACT NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_COMPACT_STMT, &yymsp[0].minor.yy0); } break; - case 444: /* cmd ::= BALANCE VGROUP */ + case 445: /* cmd ::= BALANCE VGROUP */ { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } break; - case 445: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + case 446: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ { pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy561); } break; - case 446: /* cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ + case 447: /* cmd ::= BALANCE VGROUP LEADER DATABASE db_name */ { pCxt->pRootNode = createBalanceVgroupLeaderDBNameStmt(pCxt, &yymsp[0].minor.yy561); } break; - case 447: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + case 448: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 448: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + case 449: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ { pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy628); } break; - case 449: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 450: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 452: /* dnode_list ::= DNODE NK_INTEGER */ + case 453: /* dnode_list ::= DNODE NK_INTEGER */ { yymsp[-1].minor.yy628 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 454: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ + case 455: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ { pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 457: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + case 458: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ { yymsp[-6].minor.yy980 = createInsertStmt(pCxt, yymsp[-4].minor.yy980, yymsp[-2].minor.yy628, yymsp[0].minor.yy980); } break; - case 458: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ + case 459: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ { yymsp[-3].minor.yy980 = createInsertStmt(pCxt, yymsp[-1].minor.yy980, NULL, yymsp[0].minor.yy980); } break; - case 459: /* tags_literal ::= NK_INTEGER */ - case 471: /* tags_literal ::= NK_BIN */ yytestcase(yyruleno==471); - case 480: /* tags_literal ::= NK_HEX */ yytestcase(yyruleno==480); + case 460: /* tags_literal ::= NK_INTEGER */ + case 472: /* tags_literal ::= NK_BIN */ yytestcase(yyruleno==472); + case 481: /* tags_literal ::= NK_HEX */ yytestcase(yyruleno==481); { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 460: /* tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - case 461: /* tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==461); - case 472: /* tags_literal ::= NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==472); - case 473: /* tags_literal ::= NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==473); - case 481: /* tags_literal ::= NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==481); - case 482: /* tags_literal ::= NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==482); - case 490: /* tags_literal ::= NK_STRING NK_PLUS duration_literal */ yytestcase(yyruleno==490); - case 491: /* tags_literal ::= NK_STRING NK_MINUS duration_literal */ yytestcase(yyruleno==491); + case 461: /* tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + case 462: /* tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==462); + case 473: /* tags_literal ::= NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==473); + case 474: /* tags_literal ::= NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==474); + case 482: /* tags_literal ::= NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==482); + case 483: /* tags_literal ::= NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==483); + case 491: /* tags_literal ::= NK_STRING NK_PLUS duration_literal */ yytestcase(yyruleno==491); + case 492: /* tags_literal ::= NK_STRING NK_MINUS duration_literal */ yytestcase(yyruleno==492); { SToken l = yymsp[-2].minor.yy0; SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7433,12 +7440,12 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 462: /* tags_literal ::= NK_PLUS NK_INTEGER */ - case 465: /* tags_literal ::= NK_MINUS NK_INTEGER */ yytestcase(yyruleno==465); - case 474: /* tags_literal ::= NK_PLUS NK_BIN */ yytestcase(yyruleno==474); - case 477: /* tags_literal ::= NK_MINUS NK_BIN */ yytestcase(yyruleno==477); - case 483: /* tags_literal ::= NK_PLUS NK_HEX */ yytestcase(yyruleno==483); - case 486: /* tags_literal ::= NK_MINUS NK_HEX */ yytestcase(yyruleno==486); + case 463: /* tags_literal ::= NK_PLUS NK_INTEGER */ + case 466: /* tags_literal ::= NK_MINUS NK_INTEGER */ yytestcase(yyruleno==466); + case 475: /* tags_literal ::= NK_PLUS NK_BIN */ yytestcase(yyruleno==475); + case 478: /* tags_literal ::= NK_MINUS NK_BIN */ yytestcase(yyruleno==478); + case 484: /* tags_literal ::= NK_PLUS NK_HEX */ yytestcase(yyruleno==484); + case 487: /* tags_literal ::= NK_MINUS NK_HEX */ yytestcase(yyruleno==487); { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -7446,18 +7453,18 @@ yymsp[0].minor.yy980); } } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 463: /* tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - case 464: /* tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==464); - case 466: /* tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ yytestcase(yyruleno==466); - case 467: /* tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==467); - case 475: /* tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==475); - case 476: /* tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==476); - case 478: /* tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==478); - case 479: /* tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==479); - case 484: /* tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==484); - case 485: /* tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==485); - case 487: /* tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==487); - case 488: /* tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==488); + case 464: /* tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + case 465: /* tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==465); + case 467: /* tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ yytestcase(yyruleno==467); + case 468: /* tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==468); + case 476: /* tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==476); + case 477: /* tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==477); + case 479: /* tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==479); + case 480: /* tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==480); + case 485: /* tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==485); + case 486: /* tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==486); + case 488: /* tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==488); + case 489: /* tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==489); { SToken l = yymsp[-3].minor.yy0; SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7466,12 +7473,12 @@ yymsp[0].minor.yy980); } } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 468: /* tags_literal ::= NK_FLOAT */ + case 469: /* tags_literal ::= NK_FLOAT */ { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 469: /* tags_literal ::= NK_PLUS NK_FLOAT */ - case 470: /* tags_literal ::= NK_MINUS NK_FLOAT */ yytestcase(yyruleno==470); + case 470: /* tags_literal ::= NK_PLUS NK_FLOAT */ + case 471: /* tags_literal ::= NK_MINUS NK_FLOAT */ yytestcase(yyruleno==471); { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -7479,24 +7486,24 @@ yymsp[0].minor.yy980); } } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 489: /* tags_literal ::= NK_STRING */ + case 490: /* tags_literal ::= NK_STRING */ { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 492: /* tags_literal ::= NK_BOOL */ + case 493: /* tags_literal ::= NK_BOOL */ { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 493: /* tags_literal ::= NULL */ + case 494: /* tags_literal ::= NULL */ { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 494: /* tags_literal ::= literal_func */ + case 495: /* tags_literal ::= literal_func */ { yylhsminor.yy980 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, NULL, yymsp[0].minor.yy980); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 495: /* tags_literal ::= literal_func NK_PLUS duration_literal */ - case 496: /* tags_literal ::= literal_func NK_MINUS duration_literal */ yytestcase(yyruleno==496); + case 496: /* tags_literal ::= literal_func NK_PLUS duration_literal */ + case 497: /* tags_literal ::= literal_func NK_MINUS duration_literal */ yytestcase(yyruleno==497); { SToken l = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7505,73 +7512,73 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 499: /* literal ::= NK_INTEGER */ + case 500: /* literal ::= NK_INTEGER */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 500: /* literal ::= NK_FLOAT */ + case 501: /* literal ::= NK_FLOAT */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 501: /* literal ::= NK_STRING */ + case 502: /* literal ::= NK_STRING */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 502: /* literal ::= NK_BOOL */ + case 503: /* literal ::= NK_BOOL */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 503: /* literal ::= TIMESTAMP NK_STRING */ + case 504: /* literal ::= TIMESTAMP NK_STRING */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 504: /* literal ::= duration_literal */ - case 514: /* signed_literal ::= signed */ yytestcase(yyruleno==514); - case 538: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==538); - case 539: /* expression ::= literal */ yytestcase(yyruleno==539); - case 541: /* expression ::= column_reference */ yytestcase(yyruleno==541); - case 542: /* expression ::= function_expression */ yytestcase(yyruleno==542); - case 543: /* expression ::= case_when_expression */ yytestcase(yyruleno==543); - case 589: /* function_expression ::= literal_func */ yytestcase(yyruleno==589); - case 590: /* function_expression ::= rand_func */ yytestcase(yyruleno==590); - case 648: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==648); - case 652: /* boolean_primary ::= predicate */ yytestcase(yyruleno==652); - case 654: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==654); - case 655: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==655); - case 658: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==658); - case 660: /* table_reference ::= table_primary */ yytestcase(yyruleno==660); - case 661: /* table_reference ::= joined_table */ yytestcase(yyruleno==661); - case 665: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==665); - case 752: /* query_simple ::= query_specification */ yytestcase(yyruleno==752); - case 753: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==753); - case 756: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==756); - case 758: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==758); + case 505: /* literal ::= duration_literal */ + case 515: /* signed_literal ::= signed */ yytestcase(yyruleno==515); + case 539: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==539); + case 540: /* expression ::= literal */ yytestcase(yyruleno==540); + case 542: /* expression ::= column_reference */ yytestcase(yyruleno==542); + case 543: /* expression ::= function_expression */ yytestcase(yyruleno==543); + case 544: /* expression ::= case_when_expression */ yytestcase(yyruleno==544); + case 590: /* function_expression ::= literal_func */ yytestcase(yyruleno==590); + case 591: /* function_expression ::= rand_func */ yytestcase(yyruleno==591); + case 649: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==649); + case 653: /* boolean_primary ::= predicate */ yytestcase(yyruleno==653); + case 655: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==655); + case 656: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==656); + case 659: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==659); + case 661: /* table_reference ::= table_primary */ yytestcase(yyruleno==661); + case 662: /* table_reference ::= joined_table */ yytestcase(yyruleno==662); + case 666: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==666); + case 753: /* query_simple ::= query_specification */ yytestcase(yyruleno==753); + case 754: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==754); + case 757: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==757); + case 759: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==759); { yylhsminor.yy980 = yymsp[0].minor.yy980; } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 505: /* literal ::= NULL */ + case 506: /* literal ::= NULL */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 506: /* literal ::= NK_QUESTION */ + case 507: /* literal ::= NK_QUESTION */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 507: /* duration_literal ::= NK_VARIABLE */ - case 727: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==727); - case 728: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==728); - case 729: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==729); + case 508: /* duration_literal ::= NK_VARIABLE */ + case 728: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==728); + case 729: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==729); + case 730: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==730); { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 508: /* signed ::= NK_INTEGER */ + case 509: /* signed ::= NK_INTEGER */ { yylhsminor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 509: /* signed ::= NK_PLUS NK_INTEGER */ + case 510: /* signed ::= NK_PLUS NK_INTEGER */ { yymsp[-1].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } break; - case 510: /* signed ::= NK_MINUS NK_INTEGER */ + case 511: /* 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; @@ -7579,14 +7586,14 @@ yymsp[0].minor.yy980); } } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 511: /* signed ::= NK_FLOAT */ + case 512: /* signed ::= NK_FLOAT */ { yylhsminor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 512: /* signed ::= NK_PLUS NK_FLOAT */ + case 513: /* signed ::= NK_PLUS NK_FLOAT */ { yymsp[-1].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 513: /* signed ::= NK_MINUS NK_FLOAT */ + case 514: /* 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; @@ -7594,61 +7601,61 @@ yymsp[0].minor.yy980); } } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 515: /* signed_literal ::= NK_STRING */ + case 516: /* signed_literal ::= NK_STRING */ { yylhsminor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 516: /* signed_literal ::= NK_BOOL */ + case 517: /* signed_literal ::= NK_BOOL */ { yylhsminor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 517: /* signed_literal ::= TIMESTAMP NK_STRING */ + case 518: /* signed_literal ::= TIMESTAMP NK_STRING */ { yymsp[-1].minor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 518: /* signed_literal ::= duration_literal */ - case 520: /* signed_literal ::= literal_func */ yytestcase(yyruleno==520); - case 619: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==619); - case 702: /* select_item ::= common_expression */ yytestcase(yyruleno==702); - case 712: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==712); - case 757: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==757); - case 759: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==759); - case 772: /* search_condition ::= common_expression */ yytestcase(yyruleno==772); + case 519: /* signed_literal ::= duration_literal */ + case 521: /* signed_literal ::= literal_func */ yytestcase(yyruleno==521); + case 620: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==620); + case 703: /* select_item ::= common_expression */ yytestcase(yyruleno==703); + case 713: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==713); + case 758: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==758); + case 760: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==760); + case 773: /* search_condition ::= common_expression */ yytestcase(yyruleno==773); { yylhsminor.yy980 = releaseRawExprNode(pCxt, yymsp[0].minor.yy980); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 519: /* signed_literal ::= NULL */ + case 520: /* signed_literal ::= NULL */ { yylhsminor.yy980 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 521: /* signed_literal ::= NK_QUESTION */ + case 522: /* signed_literal ::= NK_QUESTION */ { yylhsminor.yy980 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 540: /* expression ::= pseudo_column */ + case 541: /* expression ::= pseudo_column */ { yylhsminor.yy980 = yymsp[0].minor.yy980; (void)setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy980, true); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 544: /* expression ::= NK_LP expression NK_RP */ - case 653: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==653); - case 771: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==771); + case 545: /* expression ::= NK_LP expression NK_RP */ + case 654: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==654); + case 772: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==772); { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 545: /* expression ::= NK_PLUS expr_or_subquery */ + case 546: /* expression ::= NK_PLUS expr_or_subquery */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 546: /* expression ::= NK_MINUS expr_or_subquery */ + case 547: /* expression ::= NK_MINUS expr_or_subquery */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy980), NULL)); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 547: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + case 548: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7656,7 +7663,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 548: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + case 549: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7664,7 +7671,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 549: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + case 550: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7672,7 +7679,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 550: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + case 551: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7680,7 +7687,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 551: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ + case 552: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7688,14 +7695,14 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 552: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 553: /* expression ::= column_reference NK_ARROW NK_STRING */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy980), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 553: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + case 554: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7703,7 +7710,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 554: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + case 555: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7711,131 +7718,131 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 557: /* column_reference ::= column_name */ + case 558: /* column_reference ::= column_name */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy561, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy561)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 558: /* column_reference ::= table_name NK_DOT column_name */ + case 559: /* column_reference ::= table_name NK_DOT column_name */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561, createColumnNode(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy561)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 559: /* column_reference ::= NK_ALIAS */ + case 560: /* column_reference ::= NK_ALIAS */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 560: /* column_reference ::= table_name NK_DOT NK_ALIAS */ + case 561: /* column_reference ::= table_name NK_DOT NK_ALIAS */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 561: /* pseudo_column ::= ROWTS */ - case 562: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==562); - case 564: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==564); - case 565: /* pseudo_column ::= QEND */ yytestcase(yyruleno==565); - case 566: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==566); - case 567: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==567); - case 568: /* pseudo_column ::= WEND */ yytestcase(yyruleno==568); - case 569: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==569); - case 570: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==570); - case 571: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==571); - case 572: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==572); - case 573: /* pseudo_column ::= FLOW */ yytestcase(yyruleno==573); - case 574: /* pseudo_column ::= FHIGH */ yytestcase(yyruleno==574); - case 575: /* pseudo_column ::= FROWTS */ yytestcase(yyruleno==575); - case 592: /* literal_func ::= NOW */ yytestcase(yyruleno==592); - case 593: /* literal_func ::= TODAY */ yytestcase(yyruleno==593); + case 562: /* pseudo_column ::= ROWTS */ + case 563: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==563); + case 565: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==565); + case 566: /* pseudo_column ::= QEND */ yytestcase(yyruleno==566); + case 567: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==567); + case 568: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==568); + case 569: /* pseudo_column ::= WEND */ yytestcase(yyruleno==569); + case 570: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==570); + case 571: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==571); + case 572: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==572); + case 573: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==573); + case 574: /* pseudo_column ::= FLOW */ yytestcase(yyruleno==574); + case 575: /* pseudo_column ::= FHIGH */ yytestcase(yyruleno==575); + case 576: /* pseudo_column ::= FROWTS */ yytestcase(yyruleno==576); + case 593: /* literal_func ::= NOW */ yytestcase(yyruleno==593); + case 594: /* literal_func ::= TODAY */ yytestcase(yyruleno==594); { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 563: /* pseudo_column ::= table_name NK_DOT TBNAME */ + case 564: /* pseudo_column ::= table_name NK_DOT TBNAME */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy561)))); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 576: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 577: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==577); - case 585: /* function_expression ::= substr_func NK_LP expression_list NK_RP */ yytestcase(yyruleno==585); + case 577: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 578: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==578); + case 586: /* function_expression ::= substr_func NK_LP expression_list NK_RP */ yytestcase(yyruleno==586); { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy561, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy561, yymsp[-1].minor.yy628)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 578: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - case 579: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ yytestcase(yyruleno==579); + case 579: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + case 580: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ yytestcase(yyruleno==580); { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), yymsp[-1].minor.yy896)); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 580: /* function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ + case 581: /* function_expression ::= POSITION NK_LP expr_or_subquery IN expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createPositionFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980))); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 581: /* function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ + case 582: /* function_expression ::= TRIM NK_LP expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createTrimFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), TRIM_TYPE_BOTH)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 582: /* function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ + case 583: /* function_expression ::= TRIM NK_LP trim_specification_type FROM expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createTrimFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), yymsp[-3].minor.yy840)); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 583: /* function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + case 584: /* function_expression ::= TRIM NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createTrimFunctionNodeExt(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), TRIM_TYPE_BOTH)); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 584: /* function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ + case 585: /* function_expression ::= TRIM NK_LP trim_specification_type expr_or_subquery FROM expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-6].minor.yy0, &yymsp[0].minor.yy0, createTrimFunctionNodeExt(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), yymsp[-4].minor.yy840)); } yymsp[-6].minor.yy980 = yylhsminor.yy980; break; - case 586: /* function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ + case 587: /* function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy561, &yymsp[0].minor.yy0, createSubstrFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980))); } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 587: /* function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ + case 588: /* function_expression ::= substr_func NK_LP expr_or_subquery FROM expr_or_subquery FOR expr_or_subquery NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-7].minor.yy561, &yymsp[0].minor.yy0, createSubstrFunctionNodeExt(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy980), releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980))); } yymsp[-7].minor.yy980 = yylhsminor.yy980; break; - case 588: /* function_expression ::= REPLACE NK_LP expression_list NK_RP */ - case 595: /* rand_func ::= RAND NK_LP expression_list NK_RP */ yytestcase(yyruleno==595); + case 589: /* function_expression ::= REPLACE NK_LP expression_list NK_RP */ + case 596: /* rand_func ::= RAND NK_LP expression_list NK_RP */ yytestcase(yyruleno==596); { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy628)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 591: /* literal_func ::= noarg_func NK_LP NK_RP */ + case 592: /* literal_func ::= noarg_func NK_LP NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy561, NULL)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 594: /* rand_func ::= RAND NK_LP NK_RP */ + case 595: /* rand_func ::= RAND NK_LP NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy0, NULL)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 598: /* trim_specification_type ::= BOTH */ + case 599: /* trim_specification_type ::= BOTH */ { yymsp[0].minor.yy840 = TRIM_TYPE_BOTH; } break; - case 599: /* trim_specification_type ::= TRAILING */ + case 600: /* trim_specification_type ::= TRAILING */ { yymsp[0].minor.yy840 = TRIM_TYPE_TRAILING; } break; - case 600: /* trim_specification_type ::= LEADING */ + case 601: /* trim_specification_type ::= LEADING */ { yymsp[0].minor.yy840 = TRIM_TYPE_LEADING; } break; - case 615: /* star_func_para_list ::= NK_STAR */ + case 616: /* star_func_para_list ::= NK_STAR */ { yylhsminor.yy628 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 620: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 705: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==705); + case 621: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 706: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==706); { yylhsminor.yy980 = createColumnNode(pCxt, &yymsp[-2].minor.yy561, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 621: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ + case 622: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy628, yymsp[-1].minor.yy980)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 622: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + case 623: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), yymsp[-2].minor.yy628, yymsp[-1].minor.yy980)); } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 625: /* when_then_expr ::= WHEN common_expression THEN common_expression */ + case 626: /* when_then_expr ::= WHEN common_expression THEN common_expression */ { yymsp[-3].minor.yy980 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy980), releaseRawExprNode(pCxt, yymsp[0].minor.yy980)); } break; - case 627: /* case_when_else_opt ::= ELSE common_expression */ + case 628: /* case_when_else_opt ::= ELSE common_expression */ { yymsp[-1].minor.yy980 = releaseRawExprNode(pCxt, yymsp[0].minor.yy980); } break; - case 628: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ - case 633: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==633); + case 629: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ + case 634: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==634); { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7843,7 +7850,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 629: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + case 630: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7851,7 +7858,7 @@ yymsp[0].minor.yy980); } } yymsp[-4].minor.yy980 = yylhsminor.yy980; break; - case 630: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + case 631: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7859,71 +7866,71 @@ yymsp[0].minor.yy980); } } yymsp[-5].minor.yy980 = yylhsminor.yy980; break; - case 631: /* predicate ::= expr_or_subquery IS NULL */ + case 632: /* predicate ::= expr_or_subquery IS NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy980), NULL)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 632: /* predicate ::= expr_or_subquery IS NOT NULL */ + case 633: /* predicate ::= expr_or_subquery IS NOT NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), NULL)); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 634: /* compare_op ::= NK_LT */ + case 635: /* compare_op ::= NK_LT */ { yymsp[0].minor.yy688 = OP_TYPE_LOWER_THAN; } break; - case 635: /* compare_op ::= NK_GT */ + case 636: /* compare_op ::= NK_GT */ { yymsp[0].minor.yy688 = OP_TYPE_GREATER_THAN; } break; - case 636: /* compare_op ::= NK_LE */ + case 637: /* compare_op ::= NK_LE */ { yymsp[0].minor.yy688 = OP_TYPE_LOWER_EQUAL; } break; - case 637: /* compare_op ::= NK_GE */ + case 638: /* compare_op ::= NK_GE */ { yymsp[0].minor.yy688 = OP_TYPE_GREATER_EQUAL; } break; - case 638: /* compare_op ::= NK_NE */ + case 639: /* compare_op ::= NK_NE */ { yymsp[0].minor.yy688 = OP_TYPE_NOT_EQUAL; } break; - case 639: /* compare_op ::= NK_EQ */ + case 640: /* compare_op ::= NK_EQ */ { yymsp[0].minor.yy688 = OP_TYPE_EQUAL; } break; - case 640: /* compare_op ::= LIKE */ + case 641: /* compare_op ::= LIKE */ { yymsp[0].minor.yy688 = OP_TYPE_LIKE; } break; - case 641: /* compare_op ::= NOT LIKE */ + case 642: /* compare_op ::= NOT LIKE */ { yymsp[-1].minor.yy688 = OP_TYPE_NOT_LIKE; } break; - case 642: /* compare_op ::= MATCH */ + case 643: /* compare_op ::= MATCH */ { yymsp[0].minor.yy688 = OP_TYPE_MATCH; } break; - case 643: /* compare_op ::= NMATCH */ + case 644: /* compare_op ::= NMATCH */ { yymsp[0].minor.yy688 = OP_TYPE_NMATCH; } break; - case 644: /* compare_op ::= CONTAINS */ + case 645: /* compare_op ::= CONTAINS */ { yymsp[0].minor.yy688 = OP_TYPE_JSON_CONTAINS; } break; - case 645: /* in_op ::= IN */ + case 646: /* in_op ::= IN */ { yymsp[0].minor.yy688 = OP_TYPE_IN; } break; - case 646: /* in_op ::= NOT IN */ + case 647: /* in_op ::= NOT IN */ { yymsp[-1].minor.yy688 = OP_TYPE_NOT_IN; } break; - case 647: /* in_predicate_value ::= NK_LP literal_list NK_RP */ + case 648: /* in_predicate_value ::= NK_LP literal_list NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy628)); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 649: /* boolean_value_expression ::= NOT boolean_primary */ + case 650: /* boolean_value_expression ::= NOT boolean_primary */ { SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy980), NULL)); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 650: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 651: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7931,7 +7938,7 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 651: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 652: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy980); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy980); @@ -7939,33 +7946,33 @@ yymsp[0].minor.yy980); } } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 659: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ + case 660: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ { yylhsminor.yy980 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, JOIN_STYPE_NONE, yymsp[-2].minor.yy980, yymsp[0].minor.yy980, NULL); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 662: /* table_primary ::= table_name alias_opt */ + case 663: /* table_primary ::= table_name alias_opt */ { yylhsminor.yy980 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 663: /* table_primary ::= db_name NK_DOT table_name alias_opt */ + case 664: /* table_primary ::= db_name NK_DOT table_name alias_opt */ { yylhsminor.yy980 = createRealTableNode(pCxt, &yymsp[-3].minor.yy561, &yymsp[-1].minor.yy561, &yymsp[0].minor.yy561); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 664: /* table_primary ::= subquery alias_opt */ + case 665: /* table_primary ::= subquery alias_opt */ { yylhsminor.yy980 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), &yymsp[0].minor.yy561); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 666: /* alias_opt ::= */ + case 667: /* alias_opt ::= */ { yymsp[1].minor.yy561 = nil_token; } break; - case 668: /* alias_opt ::= AS table_alias */ + case 669: /* alias_opt ::= AS table_alias */ { yymsp[-1].minor.yy561 = yymsp[0].minor.yy561; } break; - case 669: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 670: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==670); + case 670: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 671: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==671); { yymsp[-2].minor.yy980 = yymsp[-1].minor.yy980; } break; - case 671: /* joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ + case 672: /* joined_table ::= table_reference join_type join_subtype JOIN table_reference join_on_clause_opt window_offset_clause_opt jlimit_clause_opt */ { yylhsminor.yy980 = createJoinTableNode(pCxt, yymsp[-6].minor.yy652, yymsp[-5].minor.yy606, yymsp[-7].minor.yy980, yymsp[-3].minor.yy980, yymsp[-2].minor.yy980); yylhsminor.yy980 = addWindowOffsetClause(pCxt, yylhsminor.yy980, yymsp[-1].minor.yy980); @@ -7973,47 +7980,47 @@ yymsp[0].minor.yy980); } } yymsp[-7].minor.yy980 = yylhsminor.yy980; break; - case 672: /* join_type ::= */ + case 673: /* join_type ::= */ { yymsp[1].minor.yy652 = JOIN_TYPE_INNER; } break; - case 673: /* join_type ::= INNER */ + case 674: /* join_type ::= INNER */ { yymsp[0].minor.yy652 = JOIN_TYPE_INNER; } break; - case 674: /* join_type ::= LEFT */ + case 675: /* join_type ::= LEFT */ { yymsp[0].minor.yy652 = JOIN_TYPE_LEFT; } break; - case 675: /* join_type ::= RIGHT */ + case 676: /* join_type ::= RIGHT */ { yymsp[0].minor.yy652 = JOIN_TYPE_RIGHT; } break; - case 676: /* join_type ::= FULL */ + case 677: /* join_type ::= FULL */ { yymsp[0].minor.yy652 = JOIN_TYPE_FULL; } break; - case 677: /* join_subtype ::= */ + case 678: /* join_subtype ::= */ { yymsp[1].minor.yy606 = JOIN_STYPE_NONE; } break; - case 678: /* join_subtype ::= OUTER */ + case 679: /* join_subtype ::= OUTER */ { yymsp[0].minor.yy606 = JOIN_STYPE_OUTER; } break; - case 679: /* join_subtype ::= SEMI */ + case 680: /* join_subtype ::= SEMI */ { yymsp[0].minor.yy606 = JOIN_STYPE_SEMI; } break; - case 680: /* join_subtype ::= ANTI */ + case 681: /* join_subtype ::= ANTI */ { yymsp[0].minor.yy606 = JOIN_STYPE_ANTI; } break; - case 681: /* join_subtype ::= ASOF */ + case 682: /* join_subtype ::= ASOF */ { yymsp[0].minor.yy606 = JOIN_STYPE_ASOF; } break; - case 682: /* join_subtype ::= WINDOW */ + case 683: /* join_subtype ::= WINDOW */ { yymsp[0].minor.yy606 = JOIN_STYPE_WIN; } break; - case 686: /* window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ + case 687: /* window_offset_clause_opt ::= WINDOW_OFFSET NK_LP window_offset_literal NK_COMMA window_offset_literal NK_RP */ { yymsp[-5].minor.yy980 = createWindowOffsetNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 687: /* window_offset_literal ::= NK_VARIABLE */ + case 688: /* window_offset_literal ::= NK_VARIABLE */ { yylhsminor.yy980 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createTimeOffsetValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 688: /* window_offset_literal ::= NK_MINUS NK_VARIABLE */ + case 689: /* window_offset_literal ::= NK_MINUS NK_VARIABLE */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -8021,12 +8028,12 @@ yymsp[0].minor.yy980); } } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 690: /* jlimit_clause_opt ::= JLIMIT NK_INTEGER */ - case 763: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ yytestcase(yyruleno==763); - case 767: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==767); + case 691: /* jlimit_clause_opt ::= JLIMIT NK_INTEGER */ + case 764: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ yytestcase(yyruleno==764); + case 768: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==768); { yymsp[-1].minor.yy980 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 691: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 692: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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[-13].minor.yy980 = createSelectStmt(pCxt, yymsp[-11].minor.yy957, yymsp[-9].minor.yy628, yymsp[-8].minor.yy980, yymsp[-12].minor.yy628); yymsp[-13].minor.yy980 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy980, yymsp[-10].minor.yy957); @@ -8040,104 +8047,104 @@ yymsp[0].minor.yy980); } yymsp[-13].minor.yy980 = addFillClause(pCxt, yymsp[-13].minor.yy980, yymsp[-3].minor.yy980); } break; - case 692: /* hint_list ::= */ + case 693: /* hint_list ::= */ { yymsp[1].minor.yy628 = createHintNodeList(pCxt, NULL); } break; - case 693: /* hint_list ::= NK_HINT */ + case 694: /* hint_list ::= NK_HINT */ { yylhsminor.yy628 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 698: /* set_quantifier_opt ::= ALL */ + case 699: /* set_quantifier_opt ::= ALL */ { yymsp[0].minor.yy957 = false; } break; - case 701: /* select_item ::= NK_STAR */ + case 702: /* select_item ::= NK_STAR */ { yylhsminor.yy980 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy980 = yylhsminor.yy980; break; - case 703: /* select_item ::= common_expression column_alias */ - case 713: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==713); + case 704: /* select_item ::= common_expression column_alias */ + case 714: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==714); { yylhsminor.yy980 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), &yymsp[0].minor.yy561); } yymsp[-1].minor.yy980 = yylhsminor.yy980; break; - case 704: /* select_item ::= common_expression AS column_alias */ - case 714: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==714); + case 705: /* select_item ::= common_expression AS column_alias */ + case 715: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==715); { yylhsminor.yy980 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy980), &yymsp[0].minor.yy561); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 709: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 741: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==741); - case 761: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==761); + case 710: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 742: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==742); + case 762: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==762); { yymsp[-2].minor.yy628 = yymsp[0].minor.yy628; } break; - case 716: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + case 717: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ { yymsp[-5].minor.yy980 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 717: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + case 718: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ { yymsp[-3].minor.yy980 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 718: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + case 719: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-5].minor.yy980 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), NULL, yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 719: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + case 720: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-7].minor.yy980 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy980), releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), yymsp[-1].minor.yy980, yymsp[0].minor.yy980); } break; - case 720: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + case 721: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ { yymsp[-6].minor.yy980 = createEventWindowNode(pCxt, yymsp[-3].minor.yy980, yymsp[0].minor.yy980); } break; - case 721: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ + case 722: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy980 = createCountWindowNode(pCxt, &yymsp[-1].minor.yy0, &yymsp[-1].minor.yy0); } break; - case 722: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + case 723: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ { yymsp[-5].minor.yy980 = createCountWindowNode(pCxt, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0); } break; - case 723: /* twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ + case 724: /* twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_RP */ { yymsp[-3].minor.yy980 = createAnomalyWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980), NULL); } break; - case 724: /* twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ + case 725: /* twindow_clause_opt ::= ANOMALY_WINDOW NK_LP expr_or_subquery NK_COMMA NK_STRING NK_RP */ { yymsp[-5].minor.yy980 = createAnomalyWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), &yymsp[-1].minor.yy0); } break; - case 731: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ + case 732: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ { yymsp[-3].minor.yy980 = createFillNode(pCxt, yymsp[-1].minor.yy690, NULL); } break; - case 732: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + case 733: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ { yymsp[-5].minor.yy980 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy628)); } break; - case 733: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + case 734: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ { yymsp[-5].minor.yy980 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy628)); } break; - case 734: /* fill_mode ::= NONE */ + case 735: /* fill_mode ::= NONE */ { yymsp[0].minor.yy690 = FILL_MODE_NONE; } break; - case 735: /* fill_mode ::= PREV */ + case 736: /* fill_mode ::= PREV */ { yymsp[0].minor.yy690 = FILL_MODE_PREV; } break; - case 736: /* fill_mode ::= NULL */ + case 737: /* fill_mode ::= NULL */ { yymsp[0].minor.yy690 = FILL_MODE_NULL; } break; - case 737: /* fill_mode ::= NULL_F */ + case 738: /* fill_mode ::= NULL_F */ { yymsp[0].minor.yy690 = FILL_MODE_NULL_F; } break; - case 738: /* fill_mode ::= LINEAR */ + case 739: /* fill_mode ::= LINEAR */ { yymsp[0].minor.yy690 = FILL_MODE_LINEAR; } break; - case 739: /* fill_mode ::= NEXT */ + case 740: /* fill_mode ::= NEXT */ { yymsp[0].minor.yy690 = FILL_MODE_NEXT; } break; - case 742: /* group_by_list ::= expr_or_subquery */ + case 743: /* group_by_list ::= expr_or_subquery */ { yylhsminor.yy628 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy980))); } yymsp[0].minor.yy628 = yylhsminor.yy628; break; - case 743: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + case 744: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ { yylhsminor.yy628 = addNodeToList(pCxt, yymsp[-2].minor.yy628, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy980))); } yymsp[-2].minor.yy628 = yylhsminor.yy628; break; - case 747: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + case 748: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ { yymsp[-5].minor.yy980 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy980), releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 748: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + case 749: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ { yymsp[-3].minor.yy980 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy980)); } break; - case 751: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 752: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ { yylhsminor.yy980 = addOrderByClause(pCxt, yymsp[-3].minor.yy980, yymsp[-2].minor.yy628); yylhsminor.yy980 = addSlimitClause(pCxt, yylhsminor.yy980, yymsp[-1].minor.yy980); @@ -8145,49 +8152,49 @@ yymsp[0].minor.yy980); } } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 754: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + case 755: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ { yylhsminor.yy980 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy980, yymsp[0].minor.yy980); } yymsp[-3].minor.yy980 = yylhsminor.yy980; break; - case 755: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + case 756: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ { yylhsminor.yy980 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy980, yymsp[0].minor.yy980); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 764: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 768: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==768); + case 765: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 769: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==769); { yymsp[-3].minor.yy980 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 765: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 769: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==769); + case 766: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 770: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==770); { yymsp[-3].minor.yy980 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 770: /* subquery ::= NK_LP query_expression NK_RP */ + case 771: /* subquery ::= NK_LP query_expression NK_RP */ { yylhsminor.yy980 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy980); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 775: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + case 776: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ { yylhsminor.yy980 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy980), yymsp[-1].minor.yy274, yymsp[0].minor.yy305); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; - case 776: /* ordering_specification_opt ::= */ + case 777: /* ordering_specification_opt ::= */ { yymsp[1].minor.yy274 = ORDER_ASC; } break; - case 777: /* ordering_specification_opt ::= ASC */ + case 778: /* ordering_specification_opt ::= ASC */ { yymsp[0].minor.yy274 = ORDER_ASC; } break; - case 778: /* ordering_specification_opt ::= DESC */ + case 779: /* ordering_specification_opt ::= DESC */ { yymsp[0].minor.yy274 = ORDER_DESC; } break; - case 779: /* null_ordering_opt ::= */ + case 780: /* null_ordering_opt ::= */ { yymsp[1].minor.yy305 = NULL_ORDER_DEFAULT; } break; - case 780: /* null_ordering_opt ::= NULLS FIRST */ + case 781: /* null_ordering_opt ::= NULLS FIRST */ { yymsp[-1].minor.yy305 = NULL_ORDER_FIRST; } break; - case 781: /* null_ordering_opt ::= NULLS LAST */ + case 782: /* null_ordering_opt ::= NULLS LAST */ { yymsp[-1].minor.yy305 = NULL_ORDER_LAST; } break; - case 784: /* column_options ::= column_options NK_ID NK_STRING */ + case 785: /* column_options ::= column_options NK_ID NK_STRING */ { yylhsminor.yy980 = setColumnOptions(pCxt, yymsp[-2].minor.yy980, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy980 = yylhsminor.yy980; break; diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index 6f6362a8f791..9e75abcfe899 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -2085,7 +2085,8 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp (void)memcpy(varDataVal(output), convBuf, len); varDataSetLen(output, len); } else { - NUM_TO_STRING(inputType, input, bufSize, buf); + int32_t outputSize = (outputLen - VARSTR_HEADER_SIZE) < bufSize ? (outputLen - VARSTR_HEADER_SIZE + 1): bufSize; + NUM_TO_STRING(inputType, input, outputSize, buf); int32_t len = (int32_t)strlen(buf); len = (outputLen - VARSTR_HEADER_SIZE) > len ? len : (outputLen - VARSTR_HEADER_SIZE); (void)memcpy(varDataVal(output), buf, len); diff --git a/source/libs/scalar/src/sclvector.c b/source/libs/scalar/src/sclvector.c index 54794b9044fa..8db0562c631a 100644 --- a/source/libs/scalar/src/sclvector.c +++ b/source/libs/scalar/src/sclvector.c @@ -1031,23 +1031,23 @@ int8_t gConvertTypes[TSDB_DATA_TYPE_MAX][TSDB_DATA_TYPE_MAX] = { /*GEOM*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0}; int8_t gDisplyTypes[TSDB_DATA_TYPE_MAX][TSDB_DATA_TYPE_MAX] = { - /*NULL BOOL TINY SMAL INT BIGI FLOA DOUB VARC TIME NCHA UTINY USMA UINT UBIG JSON VARB DECI BLOB MEDB GEOM*/ - /*NULL*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, -1, -1, -1, 8, - /*BOOL*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 10, 11, 12, 13, 14, 8, -1, -1, -1, -1, 8, - /*TINY*/ 0, 0, 2, 3, 4, 5, 8, 8, 8, 5, 10, 3, 4, 5, 8, 8, -1, -1, -1, -1, 8, - /*SMAL*/ 0, 0, 0, 3, 4, 5, 8, 8, 8, 5, 10, 3, 4, 5, 8, 8, -1, -1, -1, -1, 8, - /*INT */ 0, 0, 0, 0, 4, 5, 8, 8, 8, 5, 10, 4, 4, 5, 8, 8, -1, -1, -1, -1, 8, - /*BIGI*/ 0, 0, 0, 0, 0, 5, 8, 8, 8, 5, 10, 5, 5, 5, 8, 8, -1, -1, -1, -1, 8, - /*FLOA*/ 0, 0, 0, 0, 0, 0, 6, 7, 8, 8, 10, 8, 8, 8, 8, 8, -1, -1, -1, -1, 8, - /*DOUB*/ 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 10, 8, 8, 8, 8, 8, -1, -1, -1, -1, 8, - /*VARC*/ 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 10, 8, 8, 8, 8, 8, -1, -1, -1, -1, 8, - /*TIME*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 5, 5, 5, 8, 8, -1, -1, -1, -1, 8, - /*NCHA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10, -1, -1, -1, -1, 10, - /*UTINY*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 12, 13, 14, 8, -1, -1, -1, -1, 8, - /*USMA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, 8, -1, -1, -1, -1, 8, - /*UINT*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 8, -1, -1, -1, -1, 8, - /*UBIG*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 8, -1, -1, -1, -1, 8, - /*JSON*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, -1, -1, -1, -1, 8, + /*NULL BOOL TINY SMAL INT BIGI FLOA DOUB VARC TIM NCHA UTIN USMA UINT UBIG JSON VARB DECI BLOB MEDB GEOM*/ + /*NULL*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, -1, -1, -1, 20, + /*BOOL*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 10, 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, + /*TINY*/ 0, 0, 2, 3, 4, 5, 8, 8, 8, 5, 10, 3, 4, 5, 8, -1, -1, -1, -1, -1, -1, + /*SMAL*/ 0, 0, 0, 3, 4, 5, 8, 8, 8, 5, 10, 3, 4, 5, 8, -1, -1, -1, -1, -1, -1, + /*INT */ 0, 0, 0, 0, 4, 5, 8, 8, 8, 5, 10, 4, 4, 5, 8, -1, -1, -1, -1, -1, -1, + /*BIGI*/ 0, 0, 0, 0, 0, 5, 8, 8, 8, 5, 10, 5, 5, 5, 8, -1, -1, -1, -1, -1, -1, + /*FLOA*/ 0, 0, 0, 0, 0, 0, 6, 7, 8, 8, 10, 8, 8, 8, 8, -1, -1, -1, -1, -1, -1, + /*DOUB*/ 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 10, 8, 8, 8, 8, -1, -1, -1, -1, -1, -1, + /*VARC*/ 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 10, 8, 8, 8, 8, -1, 16, -1, -1, -1, -1, + /*TIME*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 5, 5, 5, 8, -1, -1, -1, -1, -1, -1, + /*NCHA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10, 10, 10, -1, -1, -1, -1, -1, -1, + /*UTINY*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, + /*USMA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, -1, -1, -1, -1, -1, -1, + /*UINT*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, -1, -1, -1, -1, -1, -1, + /*UBIG*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, -1, -1, -1, -1, -1, -1, + /*JSON*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, -1, -1, -1, -1, -1, /*VARB*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, -1, -1, -1, -1, /*DECI*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, /*BLOB*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, diff --git a/source/libs/wal/src/walMeta.c b/source/libs/wal/src/walMeta.c index 3c396f0599d3..da26ddae3ae2 100644 --- a/source/libs/wal/src/walMeta.c +++ b/source/libs/wal/src/walMeta.c @@ -411,14 +411,14 @@ static int32_t walTrimIdxFile(SWal* pWal, int32_t fileIdx) { TAOS_RETURN(TSDB_CODE_SUCCESS); } -void printFileSet(SArray* fileSet) { +static void printFileSet(int32_t vgId, SArray* fileSet, const char* str) { int32_t sz = taosArrayGetSize(fileSet); for (int32_t i = 0; i < sz; i++) { SWalFileInfo* pFileInfo = taosArrayGet(fileSet, i); - wInfo("firstVer:%" PRId64 ", lastVer:%" PRId64 ", fileSize:%" PRId64 ", syncedOffset:%" PRId64 ", createTs:%" PRId64 - ", closeTs:%" PRId64, - pFileInfo->firstVer, pFileInfo->lastVer, pFileInfo->fileSize, pFileInfo->syncedOffset, pFileInfo->createTs, - pFileInfo->closeTs); + wInfo("vgId:%d, %s-%d, firstVer:%" PRId64 ", lastVer:%" PRId64 ", fileSize:%" PRId64 ", syncedOffset:%" PRId64 + ", createTs:%" PRId64 ", closeTs:%" PRId64, + vgId, str, i, pFileInfo->firstVer, pFileInfo->lastVer, pFileInfo->fileSize, pFileInfo->syncedOffset, + pFileInfo->createTs, pFileInfo->closeTs); } } @@ -430,6 +430,9 @@ int32_t walCheckAndRepairMeta(SWal* pWal) { regex_t logRegPattern; regex_t idxRegPattern; + wInfo("vgId:%d, begin to repair meta, wal path:%s, firstVer:%" PRId64 ", lastVer:%" PRId64 ", snapshotVer:%" PRId64, + pWal->cfg.vgId, pWal->path, pWal->vers.firstVer, pWal->vers.lastVer, pWal->vers.snapshotVer); + if (regcomp(&logRegPattern, logPattern, REG_EXTENDED) != 0) { wError("failed to compile log pattern, error:%s", tstrerror(terrno)); return terrno; @@ -482,9 +485,9 @@ int32_t walCheckAndRepairMeta(SWal* pWal) { taosArraySort(actualLog, compareWalFileInfo); - wInfo("vgId:%d, wal path:%s, actual log file num:%d", pWal->cfg.vgId, pWal->path, + wInfo("vgId:%d, actual log file, wal path:%s, num:%d", pWal->cfg.vgId, pWal->path, (int32_t)taosArrayGetSize(actualLog)); - printFileSet(actualLog); + printFileSet(pWal->cfg.vgId, actualLog, "actual log file"); int metaFileNum = taosArrayGetSize(pWal->fileInfoSet); int actualFileNum = taosArrayGetSize(actualLog); @@ -500,9 +503,9 @@ int32_t walCheckAndRepairMeta(SWal* pWal) { TAOS_RETURN(code); } - wInfo("vgId:%d, wal path:%s, meta log file num:%d", pWal->cfg.vgId, pWal->path, + wInfo("vgId:%d, log file in meta, wal path:%s, num:%d", pWal->cfg.vgId, pWal->path, (int32_t)taosArrayGetSize(pWal->fileInfoSet)); - printFileSet(pWal->fileInfoSet); + printFileSet(pWal->cfg.vgId, pWal->fileInfoSet, "log file in meta"); int32_t sz = taosArrayGetSize(pWal->fileInfoSet); @@ -563,7 +566,9 @@ int32_t walCheckAndRepairMeta(SWal* pWal) { // repair ts of files TAOS_CHECK_RETURN(walRepairLogFileTs(pWal, &updateMeta)); - printFileSet(pWal->fileInfoSet); + wInfo("vgId:%d, log file after repair, wal path:%s, num:%d", pWal->cfg.vgId, pWal->path, + (int32_t)taosArrayGetSize(pWal->fileInfoSet)); + printFileSet(pWal->cfg.vgId, pWal->fileInfoSet, "file after repair"); // update meta file if (updateMeta) { TAOS_CHECK_RETURN(walSaveMeta(pWal)); @@ -571,6 +576,9 @@ int32_t walCheckAndRepairMeta(SWal* pWal) { TAOS_CHECK_RETURN(walLogEntriesComplete(pWal)); + wInfo("vgId:%d, success to repair meta, wal path:%s, firstVer:%" PRId64 ", lastVer:%" PRId64 ", snapshotVer:%" PRId64, + pWal->cfg.vgId, pWal->path, pWal->vers.firstVer, pWal->vers.lastVer, pWal->vers.snapshotVer); + return code; } @@ -1157,9 +1165,9 @@ int32_t walLoadMeta(SWal* pWal) { (void)taosCloseFile(&pFile); taosMemoryFree(buf); - wInfo("vgId:%d, load meta file: %s, firstVer:%" PRId64 ", lastVer:%" PRId64 ", fileInfoSet size:%d", pWal->cfg.vgId, + wInfo("vgId:%d, meta file loaded: %s, firstVer:%" PRId64 ", lastVer:%" PRId64 ", fileInfoSet size:%d", pWal->cfg.vgId, fnameStr, pWal->vers.firstVer, pWal->vers.lastVer, (int32_t)taosArrayGetSize(pWal->fileInfoSet)); - printFileSet(pWal->fileInfoSet); + printFileSet(pWal->cfg.vgId, pWal->fileInfoSet, "file in meta"); TAOS_RETURN(code); } diff --git a/source/os/src/osEnv.c b/source/os/src/osEnv.c index a3791eb02678..05c9936c2eae 100644 --- a/source/os/src/osEnv.c +++ b/source/os/src/osEnv.c @@ -37,7 +37,6 @@ float tsNumOfCores = 0; int64_t tsTotalMemoryKB = 0; char *tsProcPath = NULL; -char tsSIMDEnable = 1; char tsAVX512Enable = 0; char tsSSE42Supported = 0; char tsAVXSupported = 0; diff --git a/source/util/CMakeLists.txt b/source/util/CMakeLists.txt index 063988ea00c5..7f5955f3ddb6 100644 --- a/source/util/CMakeLists.txt +++ b/source/util/CMakeLists.txt @@ -1,5 +1,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/version.c.in" "${CMAKE_CURRENT_SOURCE_DIR}/src/version.c") aux_source_directory(src UTIL_SRC) +IF(COMPILER_SUPPORT_AVX2) + MESSAGE(STATUS "AVX2 instructions is ACTIVATED") + set_source_files_properties(src/tdecompressavx.c PROPERTIES COMPILE_FLAGS -mavx2) +ENDIF() add_library(util STATIC ${UTIL_SRC}) if(DEFINED GRANT_CFG_INCLUDE_DIR) diff --git a/source/util/src/tcompression.c b/source/util/src/tcompression.c index 9c9ded693e03..6ffb5b635acc 100644 --- a/source/util/src/tcompression.c +++ b/source/util/src/tcompression.c @@ -471,12 +471,12 @@ int32_t tsDecompressINTImp(const char *const input, const int32_t nelements, cha return nelements * word_length; } -#ifdef __AVX512F__ if (tsSIMDEnable && tsAVX512Enable && tsAVX512Supported) { - tsDecompressIntImpl_Hw(input, nelements, output, type); - return nelements * word_length; + int32_t cnt = tsDecompressIntImpl_Hw(input, nelements, output, type); + if (cnt >= 0) { + return cnt; + } } -#endif // Selector value: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 char bit_per_integer[] = {0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 20, 30, 60}; @@ -867,12 +867,12 @@ int32_t tsDecompressTimestampImp(const char *const input, const int32_t nelement memcpy(output, input + 1, nelements * longBytes); return nelements * longBytes; } else if (input[0] == 1) { // Decompress -#ifdef __AVX512VL__ if (tsSIMDEnable && tsAVX512Enable && tsAVX512Supported) { - tsDecompressTimestampAvx512(const char *const input, const int32_t nelements, char *const output, bool bigEndian); - return nelements * longBytes; + int32_t cnt = tsDecompressTimestampAvx512(input, nelements, output, false); + if (cnt >= 0) { + return cnt; + } } -#endif int64_t *ostream = (int64_t *)output; @@ -1103,13 +1103,14 @@ int32_t tsDecompressDoubleImp(const char *const input, int32_t ninput, const int return nelements * DOUBLE_BYTES; } -#ifdef __AVX2__ // use AVX2 implementation when allowed and the compression ratio is not high double compressRatio = 1.0 * nelements * DOUBLE_BYTES / ninput; if (tsSIMDEnable && tsAVX2Supported && compressRatio < 2) { - return tsDecompressDoubleImpAvx2(input + 1, nelements, output); + int32_t cnt = tsDecompressDoubleImpAvx2(input + 1, nelements, output); + if (cnt >= 0) { + return cnt; + } } -#endif // use implementation without SIMD instructions by default return tsDecompressDoubleImpHelper(input + 1, nelements, output); @@ -1257,13 +1258,14 @@ int32_t tsDecompressFloatImp(const char *const input, int32_t ninput, const int3 return nelements * FLOAT_BYTES; } -#ifdef __AVX2__ // use AVX2 implementation when allowed and the compression ratio is not high double compressRatio = 1.0 * nelements * FLOAT_BYTES / ninput; if (tsSIMDEnable && tsAVX2Supported && compressRatio < 2) { - return tsDecompressFloatImpAvx2(input + 1, nelements, output); + int32_t cnt = tsDecompressFloatImpAvx2(input + 1, nelements, output); + if (cnt >= 0) { + return cnt; + } } -#endif // use implementation without SIMD instructions by default return tsDecompressFloatImpHelper(input + 1, nelements, output); @@ -1617,7 +1619,10 @@ int32_t tsDecompressBigint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int uTrace("encode:%s, compress:%s, level:%d, type:%s, l1:%d", compressL1Dict[l1].name, compressL2Dict[l2].name, \ lvl, tDataTypes[type].name, l1); \ int32_t len = compressL1Dict[l1].comprFn(pIn, nEle, pBuf, type); \ - int8_t alvl = tsGetCompressL2Level(l2, lvl); \ + if (len < 0) { \ + return len; \ + } \ + int8_t alvl = tsGetCompressL2Level(l2, lvl); \ return compressL2Dict[l2].comprFn(pBuf, len, pOut, nOut, type, alvl); \ } else { \ uTrace("dencode:%s, decompress:%s, level:%d, type:%s", compressL1Dict[l1].name, compressL2Dict[l2].name, lvl, \ @@ -1628,8 +1633,7 @@ int32_t tsDecompressBigint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int } \ } else if (l1 == L1_DISABLED && l2 != L2_DISABLED) { \ if (compress) { \ - uTrace("encode:%s, compress:%s, level:%d, type:%s", "disabled", compressL2Dict[l1].name, lvl, \ - tDataTypes[type].name); \ + uTrace("encode:%s, compress:%s, level:%d, type:%s", "disabled", "disable", lvl, tDataTypes[type].name); \ int8_t alvl = tsGetCompressL2Level(l2, lvl); \ return compressL2Dict[l2].comprFn(pIn, nIn, pOut, nOut, type, alvl); \ } else { \ @@ -1883,3 +1887,26 @@ int8_t tUpdateCompress(uint32_t oldCmpr, uint32_t newCmpr, uint8_t l2Disabled, u return update; } + +int32_t getWordLength(char type) { + int32_t wordLength = 0; + switch (type) { + case TSDB_DATA_TYPE_BIGINT: + wordLength = LONG_BYTES; + break; + case TSDB_DATA_TYPE_INT: + wordLength = INT_BYTES; + break; + case TSDB_DATA_TYPE_SMALLINT: + wordLength = SHORT_BYTES; + break; + case TSDB_DATA_TYPE_TINYINT: + wordLength = CHAR_BYTES; + break; + default: + uError("Invalid decompress integer type:%d", type); + return TSDB_CODE_INVALID_PARA; + } + + return wordLength; +} diff --git a/source/util/src/tdecompress.c b/source/util/src/tdecompressavx.c similarity index 95% rename from source/util/src/tdecompress.c rename to source/util/src/tdecompressavx.c index 81223d73111a..143867b783e1 100644 --- a/source/util/src/tdecompress.c +++ b/source/util/src/tdecompressavx.c @@ -13,35 +13,16 @@ * along with this program. If not, see . */ -#include "os.h" #include "tcompression.h" -#include "ttypes.h" - -int32_t getWordLength(char type) { - int32_t wordLength = 0; - switch (type) { - case TSDB_DATA_TYPE_BIGINT: - wordLength = LONG_BYTES; - break; - case TSDB_DATA_TYPE_INT: - wordLength = INT_BYTES; - break; - case TSDB_DATA_TYPE_SMALLINT: - wordLength = SHORT_BYTES; - break; - case TSDB_DATA_TYPE_TINYINT: - wordLength = CHAR_BYTES; - break; - default: - uError("Invalid decompress integer type:%d", type); - return TSDB_CODE_INVALID_PARA; - } - - return wordLength; -} #ifdef __AVX2__ +char tsSIMDEnable = 1; +#else +char tsSIMDEnable = 0; +#endif + int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, char *const output, const char type) { +#ifdef __AVX2__ int32_t word_length = getWordLength(type); // Selector value: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 @@ -75,12 +56,12 @@ int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, int32_t batch = 0; int32_t remain = 0; if (tsSIMDEnable && tsAVX512Supported && tsAVX512Enable) { -#if __AVX512F__ +#ifdef __AVX512F__ batch = num >> 3; remain = num & 0x07; #endif } else if (tsSIMDEnable && tsAVX2Supported) { -#if __AVX2__ +#ifdef __AVX2__ batch = num >> 2; remain = num & 0x03; #endif @@ -88,7 +69,7 @@ int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, if (selector == 0 || selector == 1) { if (tsSIMDEnable && tsAVX512Supported && tsAVX512Enable) { -#if __AVX512F__ +#ifdef __AVX512F__ for (int32_t i = 0; i < batch; ++i) { __m512i prev = _mm512_set1_epi64(prevValue); _mm512_storeu_si512((__m512i *)&p[_pos], prev); @@ -117,7 +98,7 @@ int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, } } else { if (tsSIMDEnable && tsAVX512Supported && tsAVX512Enable) { -#if __AVX512F__ +#ifdef __AVX512F__ __m512i sum_mask1 = _mm512_set_epi64(6, 6, 4, 4, 2, 2, 0, 0); __m512i sum_mask2 = _mm512_set_epi64(5, 5, 5, 5, 1, 1, 1, 1); __m512i sum_mask3 = _mm512_set_epi64(3, 3, 3, 3, 3, 3, 3, 3); @@ -310,10 +291,13 @@ int32_t tsDecompressIntImpl_Hw(const char *const input, const int32_t nelements, } return nelements * word_length; +#else + uError("unable run %s without avx2 instructions", __func__); + return -1; +#endif } -#define M256_BYTES sizeof(__m256i) - +#ifdef __AVX2__ FORCE_INLINE __m256i decodeFloatAvx2(const char *data, const char *flag) { __m256i dataVec = _mm256_load_si256((__m256i *)data); __m256i flagVec = _mm256_load_si256((__m256i *)flag); @@ -332,7 +316,27 @@ FORCE_INLINE __m256i decodeFloatAvx2(const char *data, const char *flag) { return diffVec; } +FORCE_INLINE __m256i decodeDoubleAvx2(const char *data, const char *flag) { + __m256i dataVec = _mm256_load_si256((__m256i *)data); + __m256i flagVec = _mm256_load_si256((__m256i *)flag); + __m256i k7 = _mm256_set1_epi64x(7); + __m256i lopart = _mm256_set_epi64x(0, -1, 0, -1); + __m256i hipart = _mm256_set_epi64x(-1, 0, -1, 0); + __m256i trTail = _mm256_cmpgt_epi64(flagVec, k7); + __m256i trHead = _mm256_andnot_si256(trTail, _mm256_set1_epi64x(-1)); + __m256i shiftVec = _mm256_slli_epi64(_mm256_sub_epi64(k7, _mm256_and_si256(flagVec, k7)), 3); + __m256i maskVec = hipart; + __m256i diffVec = _mm256_sllv_epi64(dataVec, _mm256_and_si256(shiftVec, maskVec)); + maskVec = _mm256_or_si256(trHead, lopart); + diffVec = _mm256_srlv_epi64(diffVec, _mm256_and_si256(shiftVec, maskVec)); + maskVec = _mm256_and_si256(trTail, lopart); + diffVec = _mm256_sllv_epi64(diffVec, _mm256_and_si256(shiftVec, maskVec)); + return diffVec; +} +#endif + int32_t tsDecompressFloatImpAvx2(const char *input, int32_t nelements, char *output) { +#ifdef __AVX2__ // Allocate memory-aligned buffer char buf[M256_BYTES * 3]; memset(buf, 0, sizeof(buf)); @@ -343,7 +347,7 @@ int32_t tsDecompressFloatImpAvx2(const char *input, int32_t nelements, char *out // Load data into the buffer for batch processing int32_t batchSize = M256_BYTES / FLOAT_BYTES; - int32_t idx = 0; + int32_t idx = 0; uint32_t cur = 0; for (int32_t i = 0; i < nelements; i += 2) { if (idx == batchSize) { @@ -380,27 +384,14 @@ int32_t tsDecompressFloatImpAvx2(const char *input, int32_t nelements, char *out out += idx * FLOAT_BYTES; } return (int32_t)(out - output); -} - -FORCE_INLINE __m256i decodeDoubleAvx2(const char *data, const char *flag) { - __m256i dataVec = _mm256_load_si256((__m256i *)data); - __m256i flagVec = _mm256_load_si256((__m256i *)flag); - __m256i k7 = _mm256_set1_epi64x(7); - __m256i lopart = _mm256_set_epi64x(0, -1, 0, -1); - __m256i hipart = _mm256_set_epi64x(-1, 0, -1, 0); - __m256i trTail = _mm256_cmpgt_epi64(flagVec, k7); - __m256i trHead = _mm256_andnot_si256(trTail, _mm256_set1_epi64x(-1)); - __m256i shiftVec = _mm256_slli_epi64(_mm256_sub_epi64(k7, _mm256_and_si256(flagVec, k7)), 3); - __m256i maskVec = hipart; - __m256i diffVec = _mm256_sllv_epi64(dataVec, _mm256_and_si256(shiftVec, maskVec)); - maskVec = _mm256_or_si256(trHead, lopart); - diffVec = _mm256_srlv_epi64(diffVec, _mm256_and_si256(shiftVec, maskVec)); - maskVec = _mm256_and_si256(trTail, lopart); - diffVec = _mm256_sllv_epi64(diffVec, _mm256_and_si256(shiftVec, maskVec)); - return diffVec; +#else + uError("unable run %s without avx2 instructions", __func__); + return -1; +#endif } int32_t tsDecompressDoubleImpAvx2(const char *input, const int32_t nelements, char *const output) { +#ifdef __AVX2__ // Allocate memory-aligned buffer char buf[M256_BYTES * 3]; memset(buf, 0, sizeof(buf)); @@ -448,12 +439,15 @@ int32_t tsDecompressDoubleImpAvx2(const char *input, const int32_t nelements, ch out += idx * DOUBLE_BYTES; } return (int32_t)(out - output); -} +#else + uError("unable run %s without avx2 instructions", __func__); + return -1; #endif +} -#if __AVX512VL__ -// decode two timestamps in one loop. -void tsDecompressTimestampAvx2(const char *const input, const int32_t nelements, char *const output, bool bigEndian) { +int32_t tsDecompressTimestampAvx2(const char *const input, const int32_t nelements, char *const output, + bool bigEndian) { +#ifdef __AVX512VL__ int64_t *ostream = (int64_t *)output; int32_t ipos = 1, opos = 0; @@ -588,11 +582,16 @@ void tsDecompressTimestampAvx2(const char *const input, const int32_t nelements, ostream[opos++] = prevVal[1] + prevDeltaX; } } - return; + return opos; +#else + uError("unable run %s without avx512 instructions", __func__); + return -1; +#endif } -void tsDecompressTimestampAvx512(const char *const input, const int32_t nelements, char *const output, - bool UNUSED_PARAM(bigEndian)) { +int32_t tsDecompressTimestampAvx512(const char *const input, const int32_t nelements, char *const output, + bool UNUSED_PARAM(bigEndian)) { +#ifdef __AVX512VL__ int64_t *ostream = (int64_t *)output; int32_t ipos = 1, opos = 0; @@ -700,6 +699,9 @@ void tsDecompressTimestampAvx512(const char *const input, const int32_t nelement } } - return; -} + return opos; +#else + uError("unable run %s without avx512 instructions", __func__); + return -1; #endif +} diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 4d8b3627efc5..d660edd0b86e 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -268,6 +268,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_IN_CREATING, "Database in creating TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SYS_TABLENAME, "Invalid system table name") TAOS_DEFINE_ERROR(TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE, "Encryption is not allowed to be changed after database is created") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_WAL_LEVEL, "Invalid option, wal_level 0 should be used with replica 1") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DNODE_LIST_FMT, "Invalid dnode list format") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_LIST_REPEAT, "Duplicate items in the dnode list") // mnode-node TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_ALREADY_EXIST, "Mnode already exists") diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index 47dcac20358f..45c5023c2e6a 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -1084,6 +1084,7 @@ ,,y,script,./test.sh -f tsim/user/privilege_table.sim ,,y,script,./test.sh -f tsim/user/privilege_create_db.sim ,,y,script,./test.sh -f tsim/db/alter_option.sim +,,y,script,./test.sh -f tsim/db/dnodelist.sim # ,,y,script,./test.sh -f tsim/db/alter_replica_31.sim ,,y,script,./test.sh -f tsim/db/basic1.sim ,,y,script,./test.sh -f tsim/db/basic2.sim diff --git a/tests/script/tsim/compress/commitlog.sim b/tests/script/tsim/compress/commitlog.sim index 38899b95ba9f..d0380dd55959 100644 --- a/tests/script/tsim/compress/commitlog.sim +++ b/tests/script/tsim/compress/commitlog.sim @@ -20,7 +20,7 @@ sql create table $tb (ts timestamp, b bool, t tinyint, s smallint, i int, big bi $count = 0 while $count < $N $ms = 1591200000000 + $count - sql insert into $tb values( $ms , 1, 0, $count , $count , $count ,'it is a string') + sql insert into $tb values( $ms , 10, 0, $count , $count , $count ,'it is a string') $count = $count + 1 endw @@ -29,6 +29,13 @@ if $rows != $N then return -1 endi +sql flush database $db + +sql select * from $tb +if $rows != $N then + return -1 +endi + print =============== step2 $i = 1 $db = $dbPrefix . $i diff --git a/tests/script/tsim/compress/compressDisable.sim b/tests/script/tsim/compress/compressDisable.sim new file mode 100644 index 000000000000..dac7ef712ae5 --- /dev/null +++ b/tests/script/tsim/compress/compressDisable.sim @@ -0,0 +1,146 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +system sh/exec.sh -n dnode1 -s start +sql connect + +print ============================ dnode1 start +$i = 0 +$dbPrefix = db +$tbPrefix = tb +$db = $dbPrefix . $i +$tb = $tbPrefix . $i + +$N = 2000 + +print =============== step1 +sql create database $db +sql use $db +sql create table $tb (ts timestamp, b bool encode 'disabled', t tinyint encode 'disabled', s smallint encode 'disabled', i int encode 'disabled', big bigint encode 'disabled', str binary(256)) + +$count = 0 +while $count < $N + $ms = 1591200000000 + $count + sql insert into $tb values( $ms , 1, 0, $count , $count , $count ,'it is a string') + $count = $count + 1 +endw + +sql select * from $tb +if $rows != $N then + return -1 +endi + +sql flush database $db + +sql select * from $tb +if $rows != $N then + return -1 +endi + +sql alter table $tb modify column ts encode 'disabled' + +$count = 0 +while $count < $N + $ms = 1591200030000 + $count + sql insert into $tb values( $ms , 1, 0, $count , $count , $count ,'it is a string') + $count = $count + 1 +endw + +$M = 4000 +sql select * from $tb +if $rows != $M then + return -1 +endi + +sql flush database $db + +sql select * from $tb +if $rows != $M then + return -1 +endi + + +$stb1 = txx1 +sql create table txx1 (ts timestamp encode 'disabled' compress 'disabled' level 'h', f int compress 'lz4') tags(t int) + +$count = 0 +$subTb1 = txx1_sub1 +$subTb2 = txx1_sub2 + +sql create table $subTb1 using $stb1 tags(1) +sql create table $subTb2 using $stb1 tags(2) + +while $count < $N + $ms = 1591200030000 + $count + sql insert into $subTb1 values( $ms , 1) + + $ms2 = 1591200040000 + $count + sql insert into $subTb2 values( $ms2 , 1) + $count = $count + 1 +endw + +$count = 0 +sql select * from $stb1 +if $rows != $M then + return -1 +endi + +sql flush database $db + +sql select * from $stb1 +if $rows != $M then + return -1 +endi + +$L = 8000 +sql alter table $stb1 modify column ts encode 'delta-i' +sql alter table $stb1 modify column f encode 'disabled' + +while $count < $N + $ms = 1591200050000 + $count + sql insert into $subTb1 values( $ms , 1) + + $ms2 = 1591200060000 + $count + sql insert into $subTb2 values( $ms2 , 1) + $count = $count + 1 +endw + + +sql select * from $stb1 +if $rows != $L then + return -1 +endi + +sql flush database $db + +sql select * from $stb1 +if $rows != $L then + return -1 +endi + +sql alter table $stb1 modify column ts encode 'disabled' + + +$count = 0 +$I = 12000 +while $count < $N + $ms = 1591200070000 + $count + sql insert into $subTb1 values( $ms , 1) + + $ms2 = 1591200080000 + $count + sql insert into $subTb2 values( $ms2 , 1) + $count = $count + 1 +endw + + +sql select * from $stb1 +if $rows != $I then + return -1 +endi + +sql flush database $db + +sql select * from $stb1 +if $rows != $I then + return -1 +endi + diff --git a/tests/script/tsim/db/dnodelist.sim b/tests/script/tsim/db/dnodelist.sim new file mode 100644 index 000000000000..08bf08a1fef3 --- /dev/null +++ b/tests/script/tsim/db/dnodelist.sim @@ -0,0 +1,258 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +system sh/deploy.sh -n dnode2 -i 2 +system sh/deploy.sh -n dnode3 -i 3 +system sh/deploy.sh -n dnode4 -i 4 +system sh/deploy.sh -n dnode5 -i 5 +system sh/exec.sh -n dnode1 -s start +system sh/exec.sh -n dnode2 -s start +system sh/exec.sh -n dnode3 -s start +system sh/exec.sh -n dnode4 -s start +system sh/exec.sh -n dnode5 -s start + +sql connect +sql create dnode $hostname port 7200 +sql create dnode $hostname port 7300 +sql create dnode $hostname port 7400 +sql create dnode $hostname port 7500 + +$x = 0 +step1: + $x = $x + 1 + sleep 1000 + if $x == 10 then + print ====> dnode not ready! + return -1 + endi +sql select * from information_schema.ins_dnodes +print ===> $data00 $data01 $data02 $data03 $data04 $data05 +print ===> $data10 $data11 $data12 $data13 $data14 $data15 +print ===> $data20 $data21 $data22 $data23 $data24 $data25 +print ===> $data30 $data31 $data32 $data33 $data34 $data35 +print ===> $data40 $data41 $data42 $data43 $data44 $data45 +if $rows != 5 then + return -1 +endi +if $data(1)[4] != ready then + goto step1 +endi +if $data(2)[4] != ready then + goto step1 +endi +if $data(3)[4] != ready then + goto step1 +endi +if $data(4)[4] != ready then + goto step1 +endi +if $data(5)[4] != ready then + goto step1 +endi + +print --- error case + +sql_error create database d1 vgroups 1 dnodes '1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890'; +sql_error create database d1 vgroups 1 dnodes '1 '; +sql_error create database d1 vgroups 1 dnodes ' 1'; +sql_error create database d1 vgroups 1 dnodes '1,'; +sql_error create database d1 vgroups 1 dnodes '1, '; +sql_error create database d1 vgroups 1 dnodes 'a '; +sql_error create database d1 vgroups 1 dnodes '- '; +sql_error create database d1 vgroups 1 dnodes '1,1'; +sql_error create database d1 vgroups 1 dnodes '1, 1'; +sql_error create database d1 vgroups 1 dnodes '1,1234567890'; +sql_error create database d1 vgroups 1 dnodes '1,2,6'; +sql_error create database d1 vgroups 1 dnodes ',1,2'; +sql_error create database d1 vgroups 1 dnodes 'x1,2'; +sql_error create database d1 vgroups 1 dnodes 'c1,ab2'; +sql_error create database d1 vgroups 1 dnodes '1,1,2'; + +sql_error create database d1 vgroups 1 replica 2 dnodes '1'; +sql_error create database d1 vgroups 1 replica 2 dnodes '1,8'; +sql_error create database d1 vgroups 1 replica 3 dnodes '1'; +sql_error create database d1 vgroups 1 replica 3 dnodes '1,2'; +sql_error create database d1 vgroups 1 replica 3 dnodes '1,2,4,6'; + +print --- replica 1 + +print --- case10 +sql create database d10 vgroups 1 dnodes '1'; +sql show dnodes; +if $data(1)[2] != 1 then + return -1 +endi +sql_error alter database d10 replica 1 dnodes '1,2,3'; +sql drop database d10; + +print --- case11 +sql create database d11 vgroups 1 dnodes '2'; +sql show dnodes; +if $data(2)[2] != 1 then + return -1 +endi +sql drop database d11; + +print --- case12 +sql create database d12 vgroups 2 dnodes '3,4'; +sql show dnodes; +if $data(3)[2] != 1 then + return -1 +endi +if $data(4)[2] != 1 then + return -1 +endi +sql drop database d12; + +print --- case13 +sql create database d13 vgroups 2 dnodes '5'; +sql show dnodes; +if $data(5)[2] != 2 then + return -1 +endi +sql drop database d13; + +print --- case14 +sql create database d14 vgroups 1 dnodes '1,2,5'; +sql drop database d14; + +print --- case15 +sql create database d15 vgroups 2 dnodes '1,4,3'; +sql drop database d15; + +print --- case16 +sql create database d16 vgroups 3 dnodes '1'; +sql show dnodes; +if $data(1)[2] != 3 then + return -1 +endi +sql drop database d16; + +print --- case17 +sql create database d17 vgroups 3 dnodes '1,4'; +sql drop database d17; + +print --- case18 +sql create database d18 vgroups 3 dnodes '1,2,4'; +sql show dnodes; +if $data(1)[2] != 1 then + return -1 +endi +if $data(2)[2] != 1 then + return -1 +endi +if $data(4)[2] != 1 then + return -1 +endi +sql drop database d18; + +print --- replica 2 + +print --- case20 +sql create database d20 replica 2 vgroups 1 dnodes '1,2'; +sql show dnodes; +if $data(1)[2] != 1 then + return -1 +endi +if $data(2)[2] != 1 then + return -1 +endi +sql drop database d20; + +print --- case21 +sql create database d21 replica 2 vgroups 3 dnodes '1,2,3'; +sql show dnodes; +if $data(1)[2] != 2 then + return -1 +endi +if $data(2)[2] != 2 then + return -1 +endi +if $data(3)[2] != 2 then + return -1 +endi +sql drop database d21; + +print --- case22 +sql create database d22 replica 2 vgroups 2 dnodes '1,2'; +sql show dnodes; +if $data(1)[2] != 2 then + return -1 +endi +if $data(2)[2] != 2 then + return -1 +endi +sql drop database d22; + +print --- replica 3 + +print --- case30 +sql create database d30 replica 3 vgroups 3 dnodes '1,2,3'; +sql show dnodes; +if $data(1)[2] != 3 then + return -1 +endi +if $data(2)[2] != 3 then + return -1 +endi +if $data(3)[2] != 3 then + return -1 +endi +sql_error alter database d30 replica 1 dnodes '1'; +sql drop database d30; + +print --- case31 +sql create database d31 replica 3 vgroups 2 dnodes '1,2,4'; +sql show dnodes; +if $data(1)[2] != 2 then + return -1 +endi +if $data(2)[2] != 2 then + return -1 +endi +if $data(4)[2] != 2 then + return -1 +endi +sql drop database d31; + +print --- case32 +sql create database d32 replica 3 vgroups 4 dnodes '4,2,3,1'; +sql show dnodes; +if $data(1)[2] != 3 then + return -1 +endi +if $data(2)[2] != 3 then + return -1 +endi +if $data(3)[2] != 3 then + return -1 +endi +if $data(4)[2] != 3 then + return -1 +endi +sql drop database d32; + +print --- case33 +sql create database d33 replica 3 vgroups 5 dnodes '4,2,3,1,5'; +sql show dnodes; +if $data(1)[2] != 3 then + return -1 +endi +if $data(2)[2] != 3 then + return -1 +endi +if $data(3)[2] != 3 then + return -1 +endi +if $data(4)[2] != 3 then + return -1 +endi +if $data(5)[2] != 3 then + return -1 +endi +sql drop database d33; + +return + +system sh/exec.sh -n dnode1 -s stop -x SIGINT +system sh/exec.sh -n dnode2 -s stop -x SIGINT +system sh/exec.sh -n dnode3 -s stop -x SIGINT diff --git a/tests/script/tsim/scalar/caseWhen.sim b/tests/script/tsim/scalar/caseWhen.sim index 67c8ac36735b..4753e245137c 100644 --- a/tests/script/tsim/scalar/caseWhen.sim +++ b/tests/script/tsim/scalar/caseWhen.sim @@ -838,7 +838,7 @@ endi if $data20 != 11 then return -1 endi -if $data30 != 1664176504 then +if $data30 != 1664176504000 then return -1 endi @@ -1130,38 +1130,38 @@ if $data00 != varchar_val then return -1 endi -sql select case when ts > '2022-01-01 00:00:00' then c_varchar else c_geometry end as result from t_test; -if $data00 != varchar_val then - return -1 -endi - -sql select case when ts > '2022-01-01 00:00:00' then c_bool else c_geometry end as result from t_test; -if $data00 != true then +sql select case when 1 then 1234567890987654 else 'abcertyuiojhgfddhjgfcvbn' end; +if $data00 != 1234567890987654 then return -1 endi -sql select case when 0 then tag_id else c_geometry end as result from t_test; -if $data00 != 16842773 then +sql select case when 0 then 1234567890987654 else 'abcertyuiojhgfddhjgfcvbn' end; +if $data00 != abcertyuiojhgfddhjgfcvbn then return -1 endi -sql select case when 0 then tag_id else c_nchar end as result from t_test; +sql select case when 0 then 1234567890987654 else c_nchar end from t_test; if $data00 != 涛思数据 then return -1 endi -sql select case when 0 then tag_id else c_int end as result from t_test; -if $data00 != 123 then +sql select case when 1 then 1234567890987654 else c_nchar end from t_test; +if $data00 != 1234567890987654 then return -1 endi -sql select case when 0 then tag_id else c_float end as result from t_test; -if $data00 != 123.449997 then +sql select case when 1 then c_varchar else c_varbinary end from t_test; +if $data00 != null then return -1 endi +sql_error select case when ts > '2022-01-01 00:00:00' then c_varchar else c_geometry end as result from t_test; +sql_error select case when ts > '2022-01-01 00:00:00' then c_bool else c_geometry end as result from t_test; +sql_error select case when 0 then tag_id else c_geometry end as result from t_test; +sql_error select case when 0 then tag_id else c_nchar end as result from t_test; +sql_error select case when 0 then tag_id else c_int end as result from t_test; +sql_error select case when 0 then tag_id else c_float end as result from t_test; sql_error select case when c_double > 100 then c_varbinary else c_geometry end as result from t_test; sql_error select case when c_bool then c_double else c_varbinary end as result from t_test; -sql_error select case when c_bool then c_varbinary else c_varchar end as result from t_test; system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/win-test-file b/tests/script/win-test-file index ff69e9196729..ef99442214ea 100644 --- a/tests/script/win-test-file +++ b/tests/script/win-test-file @@ -325,6 +325,7 @@ ./test.sh -f tsim/compress/compress.sim ./test.sh -f tsim/compress/compress_col.sim ./test.sh -f tsim/compress/uncompress.sim +./test.sh -f tsim/compress/compressDisable.sim ./test.sh -f tsim/compute/avg.sim ./test.sh -f tsim/compute/block_dist.sim ./test.sh -f tsim/compute/bottom.sim diff --git a/tools/keeper/main.go b/tools/keeper/main.go index 43432bde3d70..5f7d47cb1cf5 100644 --- a/tools/keeper/main.go +++ b/tools/keeper/main.go @@ -1,11 +1,8 @@ package main -import ( - "github.com/taosdata/taoskeeper/system" -) +import "github.com/taosdata/taoskeeper/system" func main() { r := system.Init() system.Start(r) - // config.IsEnterprise } diff --git a/tools/keeper/process/empty_test.go b/tools/keeper/process/empty_test.go deleted file mode 100644 index 6718d125255f..000000000000 --- a/tools/keeper/process/empty_test.go +++ /dev/null @@ -1,8 +0,0 @@ -package process - -import ( - "testing" -) - -func TestEmpty(t *testing.T) { -} diff --git a/tools/keeper/process/handle_test.go b/tools/keeper/process/handle_test.go new file mode 100644 index 000000000000..bfd5c369b4cb --- /dev/null +++ b/tools/keeper/process/handle_test.go @@ -0,0 +1,121 @@ +package process + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func Test_i2string(t *testing.T) { + tests := []struct { + value interface{} + expected string + }{ + {"abc", "abc"}, + {"abcdef", "abcdef"}, + {[]byte{97, 98, 99, 100, 101, 102}, "abcdef"}, + } + + for _, tt := range tests { + res := i2string(tt.value) + assert.Equal(t, tt.expected, res) + } +} + +func Test_i2string_panic(t *testing.T) { + defer func() { + if r := recover(); r == nil { + t.Errorf("Expected panic for unexpected type, but did not panic") + } + }() + + i2string(12345) +} + +func Test_i2float(t *testing.T) { + tests := []struct { + value interface{} + expected float64 + }{ + {int8(1), 1.0}, + {int16(1), 1.0}, + {int32(1), 1.0}, + {int64(1), 1.0}, + {uint8(1), 1.0}, + {uint16(1), 1.0}, + {uint32(1), 1.0}, + {uint64(1), 1.0}, + {float32(1.5), 1.5}, + {float64(1.5), 1.5}, + {true, 1.0}, + {false, 0.0}, + } + + for _, tt := range tests { + res := i2float(tt.value) + assert.Equal(t, tt.expected, res) + } +} + +func Test_i2float_panic(t *testing.T) { + defer func() { + if r := recover(); r == nil { + t.Errorf("Expected panic for unexpected type, but did not panic") + } + }() + + i2float("unexpected type") +} + +func Test_getRoleStr(t *testing.T) { + tests := []struct { + value float64 + expected string + }{ + {0, "offline"}, + {99.5, "follower"}, + {100, "follower"}, + {100.4, "follower"}, + {100.5, "candidate"}, + {101, "candidate"}, + {101.4, "candidate"}, + {101.5, "leader"}, + {102, "leader"}, + {102.4, "leader"}, + {102.5, "error"}, + {103, "error"}, + {104, "learner"}, + {99.4, "unknown"}, + {105, "unknown"}, + {-1, "unknown"}, + {150, "unknown"}, + } + + for _, tt := range tests { + res := getRoleStr(tt.value) + assert.Equal(t, tt.expected, res) + } +} + +func Test_getStatusStr(t *testing.T) { + tests := []struct { + value float64 + expected string + }{ + {-0.4, "offline"}, + {0, "offline"}, + {0.4, "offline"}, + {0.5, "ready"}, + {1, "ready"}, + {1.4, "ready"}, + {1.5, "unknown"}, + {2, "unknown"}, + {-0.5, "unknown"}, + {-1, "unknown"}, + } + + for _, tt := range tests { + res := getStatusStr(tt.value) + assert.Equal(t, tt.expected, res) + } +} diff --git a/tools/keeper/system/program_test.go b/tools/keeper/system/program_test.go index eabc4fff35ec..63fbb6301418 100644 --- a/tools/keeper/system/program_test.go +++ b/tools/keeper/system/program_test.go @@ -3,15 +3,18 @@ package system import ( "context" "fmt" + "net/http" "testing" + "time" + "github.com/kardianos/service" "github.com/stretchr/testify/assert" "github.com/taosdata/taoskeeper/db" "github.com/taosdata/taoskeeper/infrastructure/config" "github.com/taosdata/taoskeeper/util" ) -func TestStart(t *testing.T) { +func TestInit(t *testing.T) { server := Init() assert.NotNil(t, server) @@ -20,3 +23,23 @@ func TestStart(t *testing.T) { conn.Query(context.Background(), fmt.Sprintf("drop database if exists %s", config.Conf.Metrics.Database.Name), util.GetQidOwn()) conn.Query(context.Background(), fmt.Sprintf("drop database if exists %s", config.Conf.Audit.Database.Name), util.GetQidOwn()) } + +func Test_program(t *testing.T) { + server := &http.Server{} + prg := newProgram(server) + svcConfig := &service.Config{ + Name: "taoskeeper", + DisplayName: "taoskeeper", + Description: "taosKeeper is a tool for TDengine that exports monitoring metrics", + } + svc, err := service.New(prg, svcConfig) + assert.NoError(t, err) + + err = prg.Start(svc) + assert.NoError(t, err) + + time.Sleep(100 * time.Millisecond) + + err = prg.Stop(svc) + assert.NoError(t, err) +}