Merge branch '3.0' of https://github.com/taosdata/TDengine into 3.0
This commit is contained in:
54liuyao
commit
b3b62326b2
|
|
@ -16,7 +16,7 @@ TDengine 采用 SQL 作为查询语言，大大降低学习成本、降低迁移
|
|||
|
||||
如果你是系统管理员，关心安装、升级、容错灾备、关心数据导入、导出、配置参数，如何监测 TDengine 是否健康运行，如何提升系统运行的性能，请仔细参考[运维指南](./operation)一章。
|
||||
|
||||
如果你对数据库内核设计感兴趣，或是开源爱好者，建议仔细阅读[技术内幕](./tdinterna)一章。该章从分布式架构到存储引擎、查询引擎、数据订阅，再到流计算引擎都做了详细阐述。建议对照文档，查看TDengine在GitHub的源代码，对TDengine的设计和编码做深入了解，更欢迎加入开源社区，贡献代码。
|
||||
如果你对数据库内核设计感兴趣，或是开源爱好者，建议仔细阅读[技术内幕](./tdinternal)一章。该章从分布式架构到存储引擎、查询引擎、数据订阅，再到流计算引擎都做了详细阐述。建议对照文档，查看TDengine在GitHub的源代码，对TDengine的设计和编码做深入了解，更欢迎加入开源社区，贡献代码。
|
||||
|
||||
最后，作为一个开源软件，欢迎大家的参与。如果发现文档有任何错误、描述不清晰的地方，请在每个页面的最下方，点击“编辑本文档”直接进行修改。
|
||||
|
||||
|
|
|
|||
|
|
@ -8,8 +8,6 @@ import Tabs from "@theme/Tabs";
|
|||
import TabItem from "@theme/TabItem";
|
||||
import PkgListV3 from "/components/PkgListV3";
|
||||
|
||||
您可以[用 Docker 立即体验](../../get-started/docker/) TDengine。如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
|
||||
|
||||
TDengine 完整的软件包包括服务端（taosd）、应用驱动（taosc）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、命令行程序（CLI，taos）和一些工具软件。目前 TDinsight 仅在 Linux 系统上安装和运行，后续将支持 Windows、macOS 等系统。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](../../reference/components/taosadapter/) 提供 [RESTful 接口](../../reference/connector/rest-api/)。
|
||||
|
||||
为方便使用，标准的服务端安装包包含了 taosd、taosAdapter、taosc、taos、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码；如果您只需要用到服务端程序和客户端连接的 C/C++ 语言支持，也可以仅下载 Lite 版本的安装包。
|
||||
|
|
@ -319,4 +317,4 @@ SELECT AVG(current), MAX(voltage), MIN(phase) FROM test.meters WHERE groupId = 1
|
|||
SELECT _wstart, AVG(current), MAX(voltage), MIN(phase) FROM test.d1001 INTERVAL(10s);
|
||||
```
|
||||
|
||||
在上面的查询中，使用系统提供的伪列 _wstart 来给出每个窗口的开始时间。
|
||||
在上面的查询中，使用系统提供的伪列 _wstart 来给出每个窗口的开始时间。
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ import official_account from './official-account.webp'
|
|||
|
||||
TDengine 完整的软件包包括服务端（taosd）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、应用驱动（taosc）、命令行程序 (CLI，taos) 和一些工具软件。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](../reference/components/taosadapter) 提供 [RESTful 接口](../reference/connector/rest-api)。
|
||||
|
||||
本章主要介绍如何利用 Docker 或者安装包快速设置 TDengine 环境并体验其高效写入和查询。
|
||||
本章主要介绍如何快速设置 TDengine 环境并体验其高效写入和查询。
|
||||
|
||||
```mdx-code-block
|
||||
import DocCardList from '@theme/DocCardList';
|
||||
|
|
@ -34,4 +34,4 @@ import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
|
|||
<td style={{padding:'1em 3em',border:0}}>关注 TDengine 视频号<br/>收看技术直播与教学视频</td>
|
||||
<td style={{padding:'1em 3em',border:0}}>关注 TDengine 公众号<br/>阅读技术文章与行业案例</td>
|
||||
</tr>
|
||||
</table>
|
||||
</table>
|
||||
|
|
|
|||
|
|
@ -175,7 +175,7 @@ TDengine 对于修改数据提供两种处理方式，由 IGNORE UPDATE 选项
|
|||
|
||||
用户可以为每个 partition 对应的子表生成自定义的 TAG 值，如下创建流的语句，
|
||||
```sql
|
||||
CREATE STREAM output_tag trigger at_once INTO output_tag_s TAGS(alias_tag varchar(100)) as select _wstart, count(*) from power.meters partition by concat("tag-", tbname) as alias_tag interval(10s));
|
||||
CREATE STREAM output_tag trigger at_once INTO output_tag_s TAGS(alias_tag varchar(100)) as select _wstart, count(*) from power.meters partition by concat("tag-", tbname) as alias_tag interval(10s);
|
||||
```
|
||||
|
||||
在 PARTITION 子句中，为 concat（"tag-"， tbname）定义了一个别名 alias_tag， 对应超级表 output_tag_s 的自定义 TAG 的名字。在上述示例中，流新创建的子表的 TAG 将以前缀 'tag-' 连接原表名作为 TAG 的值。会对 TAG 信息进行如下检查。
|
||||
|
|
|
|||
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
|
|
@ -294,9 +294,32 @@ let v3 = data["voltage"].split(",");
|
|||
|
||||
在任务列表页面，还可以对任务进行启动、停止、查看、删除、复制等操作，也可以查看各个任务的运行情况，包括写入的记录条数、流量等。
|
||||
|
||||
### 健康状态
|
||||
|
||||
从 3.3.5.0 开始，在任务管理列表中，增加了一项 ”健康状态“，用于指示当前任务运行过程中的健康状态。
|
||||
|
||||
在数据源的”高级选项“列表中，增加了多项健康状态监测的配置项，包括：
|
||||
|
||||
|
||||
|
||||
1. 健康监测时段（Health Check Duration）：可选项，表示对最近多长时间的任务状态进行统计。
|
||||
2. Busy 状态阈值（Busy State Threshold）：百分比，表示写入队列中入队元素数量与队列长度之比，默认 100%。
|
||||
3. 写入队列长度（Max Write Queue Length）：表示对应的写入队列长度最大值。
|
||||
4. 写入错误阈值（Write Error Threshold）：数值类型，表示健康监测时段中允许写入错误的数量。超出阈值，则报错。
|
||||
|
||||
在任务管理列表展示中，有如下状态：
|
||||
|
||||
- Ready：数据源和目标端健康检查通过，可以进行数据读取和写入。
|
||||
- Idle：表示监测时段内无数据处理（没有数据进入处理流程）。
|
||||
- Busy：表示写入队列已满（超出一定阈值，表示写入繁忙，在一定程度上意味着当前可能存在性能瓶颈，需要调整参数或配置等来进行改善，但并不说明存在错误）。
|
||||
- Bounce：数据源和目标端均正常，但在写入过程中存在错误，一定周期内超出阈值，可能意味着存在大量非正常数据或正在发生数据丢失。
|
||||
- SourceError: 数据源错误导致无法进行读取。此时工作负载将尝试重连数据源。
|
||||
- SinkError：写入端错误导致无法进行写入。此时工作负载将尝试重连数据库，恢复后进入 Ready 状态。
|
||||
- Fatal：严重或无法恢复的错误。
|
||||
|
||||
```mdx-code-block
|
||||
import DocCardList from '@theme/DocCardList';
|
||||
import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
|
||||
|
||||
<DocCardList items={useCurrentSidebarCategory().items}/>
|
||||
```
|
||||
```
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ SHOW QNODES;
|
|||
SHOW QUERIES;
|
||||
```
|
||||
|
||||
显示当前系统中正在进行的查询。
|
||||
显示当前系统中正在进行的写入（更新）/查询/删除。（由于内部 API 命名原因，所以统称 QUERIES）
|
||||
|
||||
## SHOW SCORES
|
||||
|
||||
|
|
|
|||
|
|
@ -378,7 +378,7 @@ typedef struct {
|
|||
TAOS_MULTI_BIND *bind;
|
||||
} SBindInfo;
|
||||
int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema,
|
||||
SArray *rowArray);
|
||||
SArray *rowArray, bool *pOrdered, bool *pDupTs);
|
||||
|
||||
// stmt2 binding
|
||||
int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int32_t buffMaxLen, initGeosFn igeos,
|
||||
|
|
@ -392,7 +392,7 @@ typedef struct {
|
|||
} SBindInfo2;
|
||||
|
||||
int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema,
|
||||
SArray *rowArray);
|
||||
SArray *rowArray, bool *pOrdered, bool *pDupTs);
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -2168,19 +2168,38 @@ int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col
|
|||
pStmt->semWaited = true;
|
||||
}
|
||||
|
||||
int32_t code = 0;
|
||||
SSHashObj *hashTbnames = tSimpleHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR));
|
||||
if (NULL == hashTbnames) {
|
||||
tscError("stmt2 bind failed: %s", tstrerror(terrno));
|
||||
return terrno;
|
||||
}
|
||||
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
for (int i = 0; i < bindv->count; ++i) {
|
||||
if (bindv->tbnames && bindv->tbnames[i]) {
|
||||
if (pStmt->sql.stbInterlaceMode) {
|
||||
if (tSimpleHashGet(hashTbnames, bindv->tbnames[i], strlen(bindv->tbnames[i])) != NULL) {
|
||||
code = terrno = TSDB_CODE_PAR_TBNAME_DUPLICATED;
|
||||
tscError("stmt2 bind failed: %s %s", tstrerror(terrno), bindv->tbnames[i]);
|
||||
goto out;
|
||||
}
|
||||
|
||||
code = tSimpleHashPut(hashTbnames, bindv->tbnames[i], strlen(bindv->tbnames[i]), NULL, 0);
|
||||
if (code) {
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
code = stmtSetTbName2(stmt, bindv->tbnames[i]);
|
||||
if (code) {
|
||||
return code;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
if (bindv->tags && bindv->tags[i]) {
|
||||
code = stmtSetTbTags2(stmt, bindv->tags[i]);
|
||||
if (code) {
|
||||
return code;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2189,26 +2208,29 @@ int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col
|
|||
|
||||
if (bind->num <= 0 || bind->num > INT16_MAX) {
|
||||
tscError("invalid bind num %d", bind->num);
|
||||
terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
|
||||
return terrno;
|
||||
code = terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
|
||||
goto out;
|
||||
}
|
||||
|
||||
int32_t insert = 0;
|
||||
(void)stmtIsInsert2(stmt, &insert);
|
||||
if (0 == insert && bind->num > 1) {
|
||||
tscError("only one row data allowed for query");
|
||||
terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
|
||||
return terrno;
|
||||
code = terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
|
||||
goto out;
|
||||
}
|
||||
|
||||
code = stmtBindBatch2(stmt, bind, col_idx);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
return code;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
out:
|
||||
tSimpleHashCleanup(hashTbnames);
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
int taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows) {
|
||||
|
|
|
|||
|
|
@ -68,10 +68,19 @@ static bool tmqAddJsonArrayItem(cJSON *array, cJSON *item){
|
|||
}
|
||||
|
||||
|
||||
static int32_t tmqWriteBatchMetaDataImpl(TAOS* taos, void* meta, int32_t metaLen);
|
||||
static tb_uid_t processSuid(tb_uid_t suid, char* db) { return suid + MurmurHash3_32(db, strlen(db)); }
|
||||
static int32_t tmqWriteBatchMetaDataImpl(TAOS* taos, void* meta, uint32_t metaLen);
|
||||
static tb_uid_t processSuid(tb_uid_t suid, char* db) {
|
||||
if (db == NULL) {
|
||||
return suid;
|
||||
}
|
||||
return suid + MurmurHash3_32(db, strlen(db));
|
||||
}
|
||||
static void buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id, int8_t t,
|
||||
SColCmprWrapper* pColCmprRow, cJSON** pJson) {
|
||||
if (schemaRow == NULL || name == NULL || pColCmprRow == NULL || pJson == NULL) {
|
||||
uError("invalid parameter, schemaRow:%p, name:%p, pColCmprRow:%p, pJson:%p", schemaRow, name, pColCmprRow, pJson);
|
||||
return;
|
||||
}
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
int8_t buildDefaultCompress = 0;
|
||||
if (pColCmprRow->nCols <= 0) {
|
||||
|
|
@ -186,6 +195,9 @@ end:
|
|||
}
|
||||
|
||||
static int32_t setCompressOption(cJSON* json, uint32_t para) {
|
||||
if (json == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
uint8_t encode = COMPRESS_L1_TYPE_U32(para);
|
||||
int32_t code = 0;
|
||||
if (encode != 0) {
|
||||
|
|
@ -219,6 +231,10 @@ end:
|
|||
return code;
|
||||
}
|
||||
static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON** pJson) {
|
||||
if (alterData == NULL || pJson == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SMAlterStbReq req = {0};
|
||||
cJSON* json = NULL;
|
||||
char* string = NULL;
|
||||
|
|
@ -362,6 +378,10 @@ end:
|
|||
}
|
||||
|
||||
static void processCreateStb(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (metaRsp == NULL || pJson == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SVCreateStbReq req = {0};
|
||||
SDecoder coder;
|
||||
|
||||
|
|
@ -382,6 +402,10 @@ end:
|
|||
}
|
||||
|
||||
static void processAlterStb(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (metaRsp == NULL || pJson == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SVCreateStbReq req = {0};
|
||||
SDecoder coder = {0};
|
||||
uDebug("alter stable data:%p", metaRsp);
|
||||
|
|
@ -402,6 +426,10 @@ end:
|
|||
}
|
||||
|
||||
static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
|
||||
if (json == NULL || pCreateReq == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
STag* pTag = (STag*)pCreateReq->ctb.pTag;
|
||||
char* sname = pCreateReq->ctb.stbName;
|
||||
char* name = pCreateReq->name;
|
||||
|
|
@ -502,6 +530,10 @@ end:
|
|||
}
|
||||
|
||||
static void buildCreateCTableJson(SVCreateTbReq* pCreateReq, int32_t nReqs, cJSON** pJson) {
|
||||
if (pJson == NULL || pCreateReq == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
int32_t code = 0;
|
||||
char* string = NULL;
|
||||
cJSON* json = cJSON_CreateObject();
|
||||
|
|
@ -531,6 +563,10 @@ end:
|
|||
}
|
||||
|
||||
static void processCreateTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (pJson == NULL || metaRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
SVCreateTbBatchReq req = {0};
|
||||
SVCreateTbReq* pCreateReq;
|
||||
|
|
@ -561,6 +597,10 @@ end:
|
|||
}
|
||||
|
||||
static void processAutoCreateTable(SMqDataRsp* rsp, char** string) {
|
||||
if (rsp == NULL || string == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder* decoder = NULL;
|
||||
SVCreateTbReq* pCreateReq = NULL;
|
||||
int32_t code = 0;
|
||||
|
|
@ -611,6 +651,10 @@ end:
|
|||
}
|
||||
|
||||
static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (pJson == NULL || metaRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
SVAlterTbReq vAlterTbReq = {0};
|
||||
char* string = NULL;
|
||||
|
|
@ -850,6 +894,10 @@ end:
|
|||
}
|
||||
|
||||
static void processDropSTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (pJson == NULL || metaRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
SVDropStbReq req = {0};
|
||||
cJSON* json = NULL;
|
||||
|
|
@ -884,6 +932,10 @@ end:
|
|||
*pJson = json;
|
||||
}
|
||||
static void processDeleteTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (pJson == NULL || metaRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDeleteRes req = {0};
|
||||
SDecoder coder = {0};
|
||||
cJSON* json = NULL;
|
||||
|
|
@ -921,6 +973,10 @@ end:
|
|||
}
|
||||
|
||||
static void processDropTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
||||
if (pJson == NULL || metaRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
SVDropTbBatchReq req = {0};
|
||||
cJSON* json = NULL;
|
||||
|
|
@ -958,7 +1014,11 @@ end:
|
|||
*pJson = json;
|
||||
}
|
||||
|
||||
static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosCreateStb(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SVCreateStbReq req = {0};
|
||||
SDecoder coder;
|
||||
SMCreateStbReq pReq = {0};
|
||||
|
|
@ -973,8 +1033,8 @@ static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
goto end;
|
||||
}
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&coder, data, len);
|
||||
if (tDecodeSVCreateStbReq(&coder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1068,7 +1128,11 @@ end:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t taosDropStb(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosDropStb(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SVDropStbReq req = {0};
|
||||
SDecoder coder = {0};
|
||||
SMDropStbReq pReq = {0};
|
||||
|
|
@ -1083,8 +1147,8 @@ static int32_t taosDropStb(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
goto end;
|
||||
}
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&coder, data, len);
|
||||
if (tDecodeSVDropStbReq(&coder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1173,11 +1237,19 @@ typedef struct SVgroupCreateTableBatch {
|
|||
} SVgroupCreateTableBatch;
|
||||
|
||||
static void destroyCreateTbReqBatch(void* data) {
|
||||
if (data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*)data;
|
||||
taosArrayDestroy(pTbBatch->req.pArray);
|
||||
}
|
||||
|
||||
static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosCreateTable(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SVCreateTbBatchReq req = {0};
|
||||
SDecoder coder = {0};
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1195,8 +1267,8 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
goto end;
|
||||
}
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&coder, data, len);
|
||||
if (tDecodeSVCreateTbBatchReq(&coder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1359,11 +1431,19 @@ typedef struct SVgroupDropTableBatch {
|
|||
} SVgroupDropTableBatch;
|
||||
|
||||
static void destroyDropTbReqBatch(void* data) {
|
||||
if (data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)data;
|
||||
taosArrayDestroy(pTbBatch->req.pArray);
|
||||
}
|
||||
|
||||
static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosDropTable(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SVDropTbBatchReq req = {0};
|
||||
SDecoder coder = {0};
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1380,8 +1460,8 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
goto end;
|
||||
}
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&coder, data, len);
|
||||
if (tDecodeSVDropTbBatchReq(&coder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1475,7 +1555,11 @@ end:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t taosDeleteData(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosDeleteData(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SDeleteRes req = {0};
|
||||
SDecoder coder = {0};
|
||||
char sql[256] = {0};
|
||||
|
|
@ -1484,8 +1568,8 @@ static int32_t taosDeleteData(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
uDebug("connId:0x%" PRIx64 " delete data, meta:%p, len:%d", *(int64_t*)taos, meta, metaLen);
|
||||
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&coder, data, len);
|
||||
if (tDecodeDeleteRes(&coder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1510,7 +1594,11 @@ end:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t taosAlterTable(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SVAlterTbReq req = {0};
|
||||
SDecoder dcoder = {0};
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1527,8 +1615,8 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
|
|||
goto end;
|
||||
}
|
||||
// decode and process req
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
int32_t len = metaLen - sizeof(SMsgHead);
|
||||
void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
|
||||
uint32_t len = metaLen - sizeof(SMsgHead);
|
||||
tDecoderInit(&dcoder, data, len);
|
||||
if (tDecodeSVAlterTbReq(&dcoder, &req) < 0) {
|
||||
code = TSDB_CODE_INVALID_PARA;
|
||||
|
|
@ -1632,7 +1720,8 @@ int taos_write_raw_block_with_fields(TAOS* taos, int rows, char* pData, const ch
|
|||
|
||||
int taos_write_raw_block_with_fields_with_reqid(TAOS* taos, int rows, char* pData, const char* tbname,
|
||||
TAOS_FIELD* fields, int numFields, int64_t reqid) {
|
||||
if (!taos || !pData || !tbname) {
|
||||
if (taos == NULL || pData == NULL || tbname == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1693,7 +1782,7 @@ int taos_write_raw_block(TAOS* taos, int rows, char* pData, const char* tbname)
|
|||
}
|
||||
|
||||
int taos_write_raw_block_with_reqid(TAOS* taos, int rows, char* pData, const char* tbname, int64_t reqid) {
|
||||
if (!taos || !pData || !tbname) {
|
||||
if (taos == NULL || pData == NULL || tbname == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1749,6 +1838,10 @@ end:
|
|||
}
|
||||
|
||||
static void* getRawDataFromRes(void* pRetrieve) {
|
||||
if (pRetrieve == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return NULL;
|
||||
}
|
||||
void* rawData = NULL;
|
||||
// deal with compatibility
|
||||
if (*(int64_t*)pRetrieve == 0) {
|
||||
|
|
@ -1760,6 +1853,10 @@ static void* getRawDataFromRes(void* pRetrieve) {
|
|||
}
|
||||
|
||||
static int32_t buildCreateTbMap(SMqDataRsp* rsp, SHashObj* pHashObj) {
|
||||
if (rsp == NULL || pHashObj == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
// find schema data info
|
||||
int32_t code = 0;
|
||||
SVCreateTbReq pCreateReq = {0};
|
||||
|
|
@ -1819,11 +1916,19 @@ typedef struct {
|
|||
} tbInfo;
|
||||
|
||||
static void tmqFreeMeta(void* data) {
|
||||
if (data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
STableMeta* pTableMeta = *(STableMeta**)data;
|
||||
taosMemoryFree(pTableMeta);
|
||||
}
|
||||
|
||||
static void freeRawCache(void* data) {
|
||||
if (data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
rawCacheInfo* pRawCache = (rawCacheInfo*)data;
|
||||
taosHashCleanup(pRawCache->pMetaHash);
|
||||
taosHashCleanup(pRawCache->pNameHash);
|
||||
|
|
@ -1842,6 +1947,10 @@ static int32_t initRawCacheHash() {
|
|||
}
|
||||
|
||||
static bool needRefreshMeta(void* rawData, STableMeta* pTableMeta, SSchemaWrapper* pSW) {
|
||||
if (rawData == NULL || pTableMeta == NULL || pSW == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return false;
|
||||
}
|
||||
char* p = (char*)rawData;
|
||||
// | version | total length | total rows | blankFill | total columns | flag seg| block group id | column schema | each
|
||||
// column length |
|
||||
|
|
@ -1877,6 +1986,10 @@ static bool needRefreshMeta(void* rawData, STableMeta* pTableMeta, SSchemaWrappe
|
|||
}
|
||||
|
||||
static int32_t getRawCache(SHashObj** pVgHash, SHashObj** pNameHash, SHashObj** pMetaHash, void* key) {
|
||||
if (pVgHash == NULL || pNameHash == NULL || pMetaHash == NULL || key == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void* cacheInfo = taosHashGet(writeRawCache, &key, POINTER_BYTES);
|
||||
if (cacheInfo == NULL) {
|
||||
|
|
@ -1905,6 +2018,10 @@ end:
|
|||
}
|
||||
|
||||
static int32_t buildRawRequest(TAOS* taos, SRequestObj** pRequest, SCatalog** pCatalog, SRequestConnInfo* conn) {
|
||||
if (taos == NULL || pRequest == NULL || pCatalog == NULL || conn == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
RAW_RETURN_CHECK(buildRequest(*(int64_t*)taos, "", 0, NULL, false, pRequest, 0));
|
||||
(*pRequest)->syncQuery = true;
|
||||
|
|
@ -1924,26 +2041,38 @@ end:
|
|||
}
|
||||
|
||||
typedef int32_t _raw_decode_func_(SDecoder* pDecoder, SMqDataRsp* pRsp);
|
||||
static int32_t decodeRawData(SDecoder* decoder, void* data, int32_t dataLen, _raw_decode_func_ func,
|
||||
static int32_t decodeRawData(SDecoder* decoder, void* data, uint32_t dataLen, _raw_decode_func_ func,
|
||||
SMqRspObj* rspObj) {
|
||||
int8_t dataVersion = *(int8_t*)data;
|
||||
if (dataVersion >= MQ_DATA_RSP_VERSION) {
|
||||
data = POINTER_SHIFT(data, sizeof(int8_t) + sizeof(int32_t));
|
||||
dataLen -= sizeof(int8_t) + sizeof(int32_t);
|
||||
if (decoder == NULL || data == NULL || func == NULL || rspObj == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int8_t dataVersion = *(int8_t*)data;
|
||||
if (dataVersion >= MQ_DATA_RSP_VERSION) {
|
||||
data = POINTER_SHIFT(data, sizeof(int8_t) + sizeof(int32_t));
|
||||
if (dataLen < sizeof(int8_t) + sizeof(int32_t)) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
dataLen -= sizeof(int8_t) + sizeof(int32_t);
|
||||
}
|
||||
|
||||
rspObj->resIter = -1;
|
||||
tDecoderInit(decoder, data, dataLen);
|
||||
int32_t code = func(decoder, &rspObj->dataRsp);
|
||||
if (code != 0) {
|
||||
SET_ERROR_MSG("decode mq taosx data rsp failed");
|
||||
rspObj->resIter = -1;
|
||||
tDecoderInit(decoder, data, dataLen);
|
||||
int32_t code = func(decoder, &rspObj->dataRsp);
|
||||
if (code != 0) {
|
||||
SET_ERROR_MSG("decode mq taosx data rsp failed");
|
||||
}
|
||||
return code;
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t processCacheMeta(SHashObj* pVgHash, SHashObj* pNameHash, SHashObj* pMetaHash,
|
||||
SVCreateTbReq* pCreateReqDst, SCatalog* pCatalog, SRequestConnInfo* conn, SName* pName,
|
||||
STableMeta** pMeta, SSchemaWrapper* pSW, void* rawData, int32_t retry) {
|
||||
if (pVgHash == NULL || pNameHash == NULL || pMetaHash == NULL || pCatalog == NULL || conn == NULL || pName == NULL ||
|
||||
pMeta == NULL || pSW == NULL || rawData == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STableMeta* pTableMeta = NULL;
|
||||
tbInfo* tmpInfo = (tbInfo*)taosHashGet(pNameHash, pName->tname, strlen(pName->tname));
|
||||
|
|
@ -2000,7 +2129,11 @@ end:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t tmqWriteRawDataImpl(TAOS* taos, void* data, int32_t dataLen) {
|
||||
static int32_t tmqWriteRawDataImpl(TAOS* taos, void* data, uint32_t dataLen) {
|
||||
if (taos == NULL || data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SQuery* pQuery = NULL;
|
||||
SMqRspObj rspObj = {0};
|
||||
|
|
@ -2073,7 +2206,11 @@ end:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen) {
|
||||
static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, uint32_t dataLen) {
|
||||
if (taos == NULL || data == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SQuery* pQuery = NULL;
|
||||
SMqRspObj rspObj = {0};
|
||||
|
|
@ -2162,6 +2299,10 @@ end:
|
|||
}
|
||||
|
||||
static void processSimpleMeta(SMqMetaRsp* pMetaRsp, cJSON** meta) {
|
||||
if (pMetaRsp == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
if (pMetaRsp->resMsgType == TDMT_VND_CREATE_STB) {
|
||||
processCreateStb(pMetaRsp, meta);
|
||||
} else if (pMetaRsp->resMsgType == TDMT_VND_ALTER_STB) {
|
||||
|
|
@ -2182,6 +2323,10 @@ static void processSimpleMeta(SMqMetaRsp* pMetaRsp, cJSON** meta) {
|
|||
}
|
||||
|
||||
static void processBatchMetaToJson(SMqBatchMetaRsp* pMsgRsp, char** string) {
|
||||
if (pMsgRsp == NULL || string == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return;
|
||||
}
|
||||
SDecoder coder;
|
||||
SMqBatchMetaRsp rsp = {0};
|
||||
int32_t code = 0;
|
||||
|
|
@ -2228,7 +2373,10 @@ end:
|
|||
}
|
||||
|
||||
char* tmq_get_json_meta(TAOS_RES* res) {
|
||||
if (res == NULL) return NULL;
|
||||
if (res == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return NULL;
|
||||
}
|
||||
uDebug("tmq_get_json_meta res:%p", res);
|
||||
if (!TD_RES_TMQ_META(res) && !TD_RES_TMQ_METADATA(res) && !TD_RES_TMQ_BATCH_META(res)) {
|
||||
return NULL;
|
||||
|
|
@ -2256,6 +2404,10 @@ char* tmq_get_json_meta(TAOS_RES* res) {
|
|||
void tmq_free_json_meta(char* jsonMeta) { taosMemoryFreeClear(jsonMeta); }
|
||||
|
||||
static int32_t getOffSetLen(const SMqDataRsp* pRsp) {
|
||||
if (pRsp == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SEncoder coder = {0};
|
||||
tEncoderInit(&coder, NULL, 0);
|
||||
if (tEncodeSTqOffsetVal(&coder, &pRsp->reqOffset) < 0) return -1;
|
||||
|
|
@ -2267,44 +2419,48 @@ static int32_t getOffSetLen(const SMqDataRsp* pRsp) {
|
|||
|
||||
typedef int32_t __encode_func__(SEncoder* pEncoder, const SMqDataRsp* pRsp);
|
||||
static int32_t encodeMqDataRsp(__encode_func__* encodeFunc, SMqDataRsp* rspObj, tmq_raw_data* raw) {
|
||||
int32_t len = 0;
|
||||
int32_t code = 0;
|
||||
SEncoder encoder = {0};
|
||||
void* buf = NULL;
|
||||
tEncodeSize(encodeFunc, rspObj, len, code);
|
||||
if (code < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
if (raw == NULL || encodeFunc == NULL || rspObj == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
len += sizeof(int8_t) + sizeof(int32_t);
|
||||
buf = taosMemoryCalloc(1, len);
|
||||
if (buf == NULL) {
|
||||
code = terrno;
|
||||
goto FAILED;
|
||||
uint32_t len = 0;
|
||||
int32_t code = 0;
|
||||
SEncoder encoder = {0};
|
||||
void* buf = NULL;
|
||||
tEncodeSize(encodeFunc, rspObj, len, code);
|
||||
if (code < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
}
|
||||
tEncoderInit(&encoder, buf, len);
|
||||
if (tEncodeI8(&encoder, MQ_DATA_RSP_VERSION) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
len += sizeof(int8_t) + sizeof(int32_t);
|
||||
buf = taosMemoryCalloc(1, len);
|
||||
if (buf == NULL) {
|
||||
code = terrno;
|
||||
goto FAILED;
|
||||
}
|
||||
int32_t offsetLen = getOffSetLen(rspObj);
|
||||
if (offsetLen <= 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
tEncoderInit(&encoder, buf, len);
|
||||
if (tEncodeI8(&encoder, MQ_DATA_RSP_VERSION) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
}
|
||||
if (tEncodeI32(&encoder, offsetLen) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
int32_t offsetLen = getOffSetLen(rspObj);
|
||||
if (offsetLen <= 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
}
|
||||
if (encodeFunc(&encoder, rspObj) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
if (tEncodeI32(&encoder, offsetLen) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
}
|
||||
tEncoderClear(&encoder);
|
||||
if (encodeFunc(&encoder, rspObj) < 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto FAILED;
|
||||
}
|
||||
tEncoderClear(&encoder);
|
||||
|
||||
raw->raw = buf;
|
||||
raw->raw_len = len;
|
||||
return code;
|
||||
raw->raw = buf;
|
||||
raw->raw_len = len;
|
||||
return code;
|
||||
FAILED:
|
||||
tEncoderClear(&encoder);
|
||||
taosMemoryFree(buf);
|
||||
|
|
@ -2312,13 +2468,14 @@ FAILED:
|
|||
}
|
||||
|
||||
int32_t tmq_get_raw(TAOS_RES* res, tmq_raw_data* raw) {
|
||||
if (!raw || !res) {
|
||||
if (raw == NULL || res == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqRspObj* rspObj = ((SMqRspObj*)res);
|
||||
if (TD_RES_TMQ_META(res)) {
|
||||
raw->raw = rspObj->metaRsp.metaRsp;
|
||||
raw->raw_len = rspObj->metaRsp.metaRspLen;
|
||||
raw->raw_len = rspObj->metaRsp.metaRspLen >= 0 ? rspObj->metaRsp.metaRspLen : 0;
|
||||
raw->raw_type = rspObj->metaRsp.resMsgType;
|
||||
uDebug("tmq get raw type meta:%p", raw);
|
||||
} else if (TD_RES_TMQ(res)) {
|
||||
|
|
@ -2378,6 +2535,10 @@ static int32_t writeRawInit() {
|
|||
}
|
||||
|
||||
static int32_t writeRawImpl(TAOS* taos, void* buf, uint32_t len, uint16_t type) {
|
||||
if (taos == NULL || buf == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
if (writeRawInit() != 0) {
|
||||
return TSDB_CODE_INTERNAL_ERROR;
|
||||
}
|
||||
|
|
@ -2415,8 +2576,9 @@ int32_t tmq_write_raw(TAOS* taos, tmq_raw_data raw) {
|
|||
return writeRawImpl(taos, raw.raw, raw.raw_len, raw.raw_type);
|
||||
}
|
||||
|
||||
static int32_t tmqWriteBatchMetaDataImpl(TAOS* taos, void* meta, int32_t metaLen) {
|
||||
static int32_t tmqWriteBatchMetaDataImpl(TAOS* taos, void* meta, uint32_t metaLen) {
|
||||
if (taos == NULL || meta == NULL) {
|
||||
uError("invalid parameter in %s", __func__);
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqBatchMetaRsp rsp = {0};
|
||||
|
|
|
|||
|
|
@ -554,6 +554,9 @@ char** tmq_list_to_c_array(const tmq_list_t* list) {
|
|||
}
|
||||
|
||||
static int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet) {
|
||||
if (pParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int64_t refId = pParamSet->refId;
|
||||
int32_t code = 0;
|
||||
tmq_t* tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
|
||||
|
|
@ -575,6 +578,9 @@ static int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet) {
|
|||
}
|
||||
|
||||
static int32_t commitRspCountDown(SMqCommitCbParamSet* pParamSet, int64_t consumerId, const char* pTopic, int32_t vgId) {
|
||||
if (pParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t waitingRspNum = atomic_sub_fetch_32(&pParamSet->waitingRspNum, 1);
|
||||
if (waitingRspNum == 0) {
|
||||
tqDebugC("consumer:0x%" PRIx64 " topic:%s vgId:%d all commit-rsp received, commit completed", consumerId, pTopic,
|
||||
|
|
@ -603,6 +609,9 @@ static int32_t tmqCommitCb(void* param, SDataBuf* pBuf, int32_t code) {
|
|||
|
||||
static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffsetVal* offset, const char* pTopicName,
|
||||
SMqCommitCbParamSet* pParamSet) {
|
||||
if (tmq == NULL || epSet == NULL || offset == NULL || pTopicName == NULL || pParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqVgOffset pOffset = {0};
|
||||
|
||||
pOffset.consumerId = tmq->consumerId;
|
||||
|
|
@ -673,6 +682,9 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
|
|||
}
|
||||
|
||||
static int32_t getTopicByName(tmq_t* tmq, const char* pTopicName, SMqClientTopic** topic) {
|
||||
if (tmq == NULL || pTopicName == NULL || topic == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t numOfTopics = taosArrayGetSize(tmq->clientTopics);
|
||||
for (int32_t i = 0; i < numOfTopics; ++i) {
|
||||
SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, i);
|
||||
|
|
@ -689,6 +701,9 @@ static int32_t getTopicByName(tmq_t* tmq, const char* pTopicName, SMqClientTopic
|
|||
|
||||
static int32_t prepareCommitCbParamSet(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* userParam, int32_t rspNum,
|
||||
SMqCommitCbParamSet** ppParamSet) {
|
||||
if (tmq == NULL || ppParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqCommitCbParamSet* pParamSet = taosMemoryCalloc(1, sizeof(SMqCommitCbParamSet));
|
||||
if (pParamSet == NULL) {
|
||||
return terrno;
|
||||
|
|
@ -704,6 +719,9 @@ static int32_t prepareCommitCbParamSet(tmq_t* tmq, tmq_commit_cb* pCommitFp, voi
|
|||
}
|
||||
|
||||
static int32_t getClientVg(tmq_t* tmq, char* pTopicName, int32_t vgId, SMqClientVg** pVg) {
|
||||
if (tmq == NULL || pTopicName == NULL || pVg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqClientTopic* pTopic = NULL;
|
||||
int32_t code = getTopicByName(tmq, pTopicName, &pTopic);
|
||||
if (code != 0) {
|
||||
|
|
@ -724,6 +742,9 @@ static int32_t getClientVg(tmq_t* tmq, char* pTopicName, int32_t vgId, SMqClient
|
|||
}
|
||||
|
||||
static int32_t innerCommit(tmq_t* tmq, char* pTopicName, STqOffsetVal* offsetVal, SMqClientVg* pVg, SMqCommitCbParamSet* pParamSet){
|
||||
if (tmq == NULL || pTopicName == NULL || offsetVal == NULL || pVg == NULL || pParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
if (offsetVal->type <= 0) {
|
||||
code = TSDB_CODE_TMQ_INVALID_MSG;
|
||||
|
|
@ -754,6 +775,9 @@ static int32_t innerCommit(tmq_t* tmq, char* pTopicName, STqOffsetVal* offsetVal
|
|||
|
||||
static int32_t asyncCommitOffset(tmq_t* tmq, char* pTopicName, int32_t vgId, STqOffsetVal* offsetVal,
|
||||
tmq_commit_cb* pCommitFp, void* userParam) {
|
||||
if (tmq == NULL || pTopicName == NULL || offsetVal == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
tqInfoC("consumer:0x%" PRIx64 " do manual commit offset for %s, vgId:%d", tmq->consumerId, pTopicName, vgId);
|
||||
SMqCommitCbParamSet* pParamSet = NULL;
|
||||
int32_t code = prepareCommitCbParamSet(tmq, pCommitFp, userParam, 0, &pParamSet);
|
||||
|
|
@ -807,6 +831,9 @@ end:
|
|||
}
|
||||
|
||||
static int32_t innerCommitAll(tmq_t* tmq, SMqCommitCbParamSet* pParamSet){
|
||||
if (tmq == NULL || pParamSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
taosRLockLatch(&tmq->lock);
|
||||
int32_t numOfTopics = taosArrayGetSize(tmq->clientTopics);
|
||||
|
|
@ -842,6 +869,9 @@ END:
|
|||
}
|
||||
|
||||
static void asyncCommitAllOffsets(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* userParam) {
|
||||
if (tmq == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqCommitCbParamSet* pParamSet = NULL;
|
||||
// init waitingRspNum as DEFAULT_COMMIT_CNT to prevent concurrency issue
|
||||
|
|
@ -1071,12 +1101,15 @@ END:
|
|||
}
|
||||
|
||||
static void defaultCommitCbFn(tmq_t* pTmq, int32_t code, void* param) {
|
||||
if (code != 0) {
|
||||
if (code != 0 && pTmq != NULL) {
|
||||
tqErrorC("consumer:0x%" PRIx64 ", failed to commit offset, code:%s", pTmq->consumerId, tstrerror(code));
|
||||
}
|
||||
}
|
||||
|
||||
static void tmqFreeRspWrapper(SMqRspWrapper* rspWrapper) {
|
||||
if (rspWrapper == NULL) {
|
||||
return;
|
||||
}
|
||||
if (rspWrapper->tmqRspType == TMQ_MSG_TYPE__EP_RSP) {
|
||||
tDeleteSMqAskEpRsp(&rspWrapper->epRsp);
|
||||
} else if (rspWrapper->tmqRspType == TMQ_MSG_TYPE__POLL_DATA_RSP) {
|
||||
|
|
@ -1091,12 +1124,18 @@ static void tmqFreeRspWrapper(SMqRspWrapper* rspWrapper) {
|
|||
}
|
||||
|
||||
static void freeClientVg(void* param) {
|
||||
if (param == NULL) {
|
||||
return;
|
||||
}
|
||||
SMqClientVg* pVg = param;
|
||||
tOffsetDestroy(&pVg->offsetInfo.endOffset);
|
||||
tOffsetDestroy(&pVg->offsetInfo.beginOffset);
|
||||
tOffsetDestroy(&pVg->offsetInfo.committedOffset);
|
||||
}
|
||||
static void freeClientTopic(void* param) {
|
||||
if (param == NULL) {
|
||||
return;
|
||||
}
|
||||
SMqClientTopic* pTopic = param;
|
||||
taosMemoryFreeClear(pTopic->schema.pSchema);
|
||||
taosArrayDestroyEx(pTopic->vgs, freeClientVg);
|
||||
|
|
@ -1104,6 +1143,9 @@ static void freeClientTopic(void* param) {
|
|||
|
||||
static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopicEp, SHashObj* pVgOffsetHashMap,
|
||||
tmq_t* tmq) {
|
||||
if (pTopic == NULL || pTopicEp == NULL || pVgOffsetHashMap == NULL || tmq == NULL) {
|
||||
return;
|
||||
}
|
||||
pTopic->schema = pTopicEp->schema;
|
||||
pTopicEp->schema.nCols = 0;
|
||||
pTopicEp->schema.pSchema = NULL;
|
||||
|
|
@ -1167,6 +1209,9 @@ static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopic
|
|||
}
|
||||
|
||||
static void buildNewTopicList(tmq_t* tmq, SArray* newTopics, const SMqAskEpRsp* pRsp){
|
||||
if (tmq == NULL || newTopics == NULL || pRsp == NULL) {
|
||||
return;
|
||||
}
|
||||
SHashObj* pVgOffsetHashMap = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
|
||||
if (pVgOffsetHashMap == NULL) {
|
||||
tqErrorC("consumer:0x%" PRIx64 " taos hash init null, code:%d", tmq->consumerId, terrno);
|
||||
|
|
@ -1221,6 +1266,9 @@ static void buildNewTopicList(tmq_t* tmq, SArray* newTopics, const SMqAskEpRsp*
|
|||
}
|
||||
|
||||
static void doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp) {
|
||||
if (tmq == NULL || pRsp == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
|
||||
// vnode transform (epoch == tmq->epoch && topicNumGet != 0)
|
||||
// ask ep rsp (epoch == tmq->epoch && topicNumGet == 0)
|
||||
|
|
@ -1337,6 +1385,9 @@ static int32_t askEpCb(void* param, SDataBuf* pMsg, int32_t code) {
|
|||
}
|
||||
|
||||
static int32_t askEp(tmq_t* pTmq, void* param, bool sync, bool updateEpSet) {
|
||||
if (pTmq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqAskEpReq req = {0};
|
||||
req.consumerId = pTmq->consumerId;
|
||||
req.epoch = updateEpSet ? -1 : pTmq->epoch;
|
||||
|
|
@ -1395,6 +1446,9 @@ static int32_t askEp(tmq_t* pTmq, void* param, bool sync, bool updateEpSet) {
|
|||
}
|
||||
|
||||
void tmqHandleAllDelayedTask(tmq_t* pTmq) {
|
||||
if (pTmq == NULL) {
|
||||
return;
|
||||
}
|
||||
STaosQall* qall = NULL;
|
||||
int32_t code = 0;
|
||||
|
||||
|
|
@ -1443,6 +1497,7 @@ void tmqHandleAllDelayedTask(tmq_t* pTmq) {
|
|||
}
|
||||
|
||||
void tmqClearUnhandleMsg(tmq_t* tmq) {
|
||||
if (tmq == NULL) return;
|
||||
SMqRspWrapper* rspWrapper = NULL;
|
||||
while (taosGetQitem(tmq->qall, (void**)&rspWrapper) != 0) {
|
||||
tmqFreeRspWrapper(rspWrapper);
|
||||
|
|
@ -1507,6 +1562,7 @@ int32_t tmq_subscription(tmq_t* tmq, tmq_list_t** topics) {
|
|||
}
|
||||
|
||||
void tmqFreeImpl(void* handle) {
|
||||
if (handle == NULL) return;
|
||||
tmq_t* tmq = (tmq_t*)handle;
|
||||
int64_t id = tmq->consumerId;
|
||||
|
||||
|
|
@ -1715,6 +1771,7 @@ _failed:
|
|||
}
|
||||
|
||||
static int32_t syncAskEp(tmq_t* pTmq) {
|
||||
if (pTmq == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
SAskEpInfo* pInfo = taosMemoryMalloc(sizeof(SAskEpInfo));
|
||||
if (pInfo == NULL) return terrno;
|
||||
if (tsem2_init(&pInfo->sem, 0, 0) != 0) {
|
||||
|
|
@ -1897,6 +1954,9 @@ void tmq_conf_set_auto_commit_cb(tmq_conf_t* conf, tmq_commit_cb* cb, void* para
|
|||
}
|
||||
|
||||
static void getVgInfo(tmq_t* tmq, char* topicName, int32_t vgId, SMqClientVg** pVg) {
|
||||
if (tmq == NULL || topicName == NULL || pVg == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
|
||||
for (int i = 0; i < topicNumCur; i++) {
|
||||
SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, i);
|
||||
|
|
@ -1914,6 +1974,9 @@ static void getVgInfo(tmq_t* tmq, char* topicName, int32_t vgId, SMqClientVg** p
|
|||
}
|
||||
|
||||
static SMqClientTopic* getTopicInfo(tmq_t* tmq, char* topicName) {
|
||||
if (tmq == NULL || topicName == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
|
||||
for (int i = 0; i < topicNumCur; i++) {
|
||||
SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, i);
|
||||
|
|
@ -2026,6 +2089,9 @@ EXIT:
|
|||
}
|
||||
|
||||
void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqClientTopic* pTopic, SMqClientVg* pVg) {
|
||||
if (pReq == NULL || tmq == NULL || pTopic == NULL || pVg == NULL) {
|
||||
return;
|
||||
}
|
||||
(void)snprintf(pReq->subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopic->topicName);
|
||||
pReq->withTbName = tmq->withTbName;
|
||||
pReq->consumerId = tmq->consumerId;
|
||||
|
|
@ -2072,7 +2138,7 @@ void changeByteEndian(char* pData) {
|
|||
}
|
||||
|
||||
static void tmqGetRawDataRowsPrecisionFromRes(void* pRetrieve, void** rawData, int64_t* rows, int32_t* precision) {
|
||||
if (pRetrieve == NULL) {
|
||||
if (pRetrieve == NULL || rawData == NULL || rows == NULL) {
|
||||
return;
|
||||
}
|
||||
if (*(int64_t*)pRetrieve == 0) {
|
||||
|
|
@ -2092,6 +2158,9 @@ static void tmqGetRawDataRowsPrecisionFromRes(void* pRetrieve, void** rawData, i
|
|||
|
||||
static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows,
|
||||
SMqRspObj* pRspObj) {
|
||||
if (pWrapper == NULL || pVg == NULL || numOfRows == NULL || pRspObj == NULL) {
|
||||
return;
|
||||
}
|
||||
pRspObj->resIter = -1;
|
||||
pRspObj->resInfo.totalRows = 0;
|
||||
pRspObj->resInfo.precision = TSDB_TIME_PRECISION_MILLI;
|
||||
|
|
@ -2130,6 +2199,9 @@ static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg
|
|||
}
|
||||
|
||||
static int32_t doTmqPollImpl(tmq_t* pTmq, SMqClientTopic* pTopic, SMqClientVg* pVg, int64_t timeout) {
|
||||
if (pTmq == NULL || pTopic == NULL || pVg == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
SMqPollReq req = {0};
|
||||
char* msg = NULL;
|
||||
SMqPollCbParam* pParam = NULL;
|
||||
|
|
@ -2199,6 +2271,9 @@ static int32_t doTmqPollImpl(tmq_t* pTmq, SMqClientTopic* pTopic, SMqClientVg* p
|
|||
|
||||
// broadcast the poll request to all related vnodes
|
||||
static int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
|
||||
if (tmq == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
|
||||
taosWLockLatch(&tmq->lock);
|
||||
|
|
@ -2258,6 +2333,9 @@ end:
|
|||
|
||||
static void updateVgInfo(SMqClientVg* pVg, STqOffsetVal* reqOffset, STqOffsetVal* rspOffset, int64_t sver, int64_t ever,
|
||||
int64_t consumerId, bool hasData) {
|
||||
if (pVg == NULL || reqOffset == NULL || rspOffset == NULL) {
|
||||
return;
|
||||
}
|
||||
if (!pVg->seekUpdated) {
|
||||
tqDebugC("consumer:0x%" PRIx64 " local offset is update, since seekupdate not set", consumerId);
|
||||
if (hasData) {
|
||||
|
|
@ -2283,6 +2361,9 @@ static SMqRspObj* buildRsp(SMqPollRspWrapper* pollRspWrapper){
|
|||
SMqBatchMetaRsp batchMetaRsp;
|
||||
} MEMSIZE;
|
||||
|
||||
if (pollRspWrapper == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
SMqRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqRspObj));
|
||||
if (pRspObj == NULL) {
|
||||
tqErrorC("buildRsp:failed to allocate memory");
|
||||
|
|
@ -2297,6 +2378,9 @@ static SMqRspObj* buildRsp(SMqPollRspWrapper* pollRspWrapper){
|
|||
}
|
||||
|
||||
static void processMqRspError(tmq_t* tmq, SMqRspWrapper* pRspWrapper){
|
||||
if (tmq == NULL || pRspWrapper == NULL) {
|
||||
return;
|
||||
}
|
||||
SMqPollRspWrapper* pollRspWrapper = &pRspWrapper->pollRsp;
|
||||
|
||||
if (pRspWrapper->code == TSDB_CODE_VND_INVALID_VGROUP_ID) { // for vnode transform
|
||||
|
|
@ -2322,6 +2406,9 @@ static void processMqRspError(tmq_t* tmq, SMqRspWrapper* pRspWrapper){
|
|||
taosWUnLockLatch(&tmq->lock);
|
||||
}
|
||||
static SMqRspObj* processMqRsp(tmq_t* tmq, SMqRspWrapper* pRspWrapper){
|
||||
if (tmq == NULL || pRspWrapper == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
SMqRspObj* pRspObj = NULL;
|
||||
|
||||
if (pRspWrapper->tmqRspType == TMQ_MSG_TYPE__EP_RSP) {
|
||||
|
|
@ -2401,6 +2488,9 @@ static SMqRspObj* processMqRsp(tmq_t* tmq, SMqRspWrapper* pRspWrapper){
|
|||
}
|
||||
|
||||
static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
|
||||
if (tmq == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
tqDebugC("consumer:0x%" PRIx64 " start to handle the rsp, total:%d", tmq->consumerId, taosQallItemSize(tmq->qall));
|
||||
|
||||
void* returnVal = NULL;
|
||||
|
|
@ -2478,6 +2568,7 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t timeout) {
|
|||
}
|
||||
|
||||
static void displayConsumeStatistics(tmq_t* pTmq) {
|
||||
if (pTmq == NULL) return;
|
||||
taosRLockLatch(&pTmq->lock);
|
||||
int32_t numOfTopics = taosArrayGetSize(pTmq->clientTopics);
|
||||
tqInfoC("consumer:0x%" PRIx64 " closing poll:%" PRId64 " rows:%" PRId64 " topics:%d, final epoch:%d",
|
||||
|
|
@ -2680,7 +2771,11 @@ void tmq_commit_async(tmq_t* tmq, const TAOS_RES* pRes, tmq_commit_cb* cb, void*
|
|||
}
|
||||
}
|
||||
|
||||
static void commitCallBackFn(tmq_t* UNUSED_PARAM(tmq), int32_t code, void* param) {
|
||||
static void commitCallBackFn(tmq_t* tmq, int32_t code, void* param) {
|
||||
if (param == NULL) {
|
||||
tqErrorC("invalid param in commit cb");
|
||||
return;
|
||||
}
|
||||
SSyncCommitInfo* pInfo = (SSyncCommitInfo*)param;
|
||||
pInfo->code = code;
|
||||
if (tsem2_post(&pInfo->sem) != 0){
|
||||
|
|
@ -2732,6 +2827,10 @@ int32_t tmq_commit_sync(tmq_t* tmq, const TAOS_RES* pRes) {
|
|||
|
||||
// wal range will be ok after calling tmq_get_topic_assignment or poll interface
|
||||
static int32_t checkWalRange(SVgOffsetInfo* offset, int64_t value) {
|
||||
if (offset == NULL) {
|
||||
tqErrorC("invalid offset, null");
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
if (offset->walVerBegin == -1 || offset->walVerEnd == -1) {
|
||||
tqErrorC("Assignment or poll interface need to be called first");
|
||||
return TSDB_CODE_TMQ_NEED_INITIALIZED;
|
||||
|
|
@ -2852,6 +2951,9 @@ end:
|
|||
|
||||
|
||||
int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pResInfo) {
|
||||
if (res == NULL || pResInfo == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqRspObj* pRspObj = (SMqRspObj*)res;
|
||||
SMqDataRsp* data = &pRspObj->dataRsp;
|
||||
|
||||
|
|
@ -2889,7 +2991,7 @@ int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pRes
|
|||
}
|
||||
|
||||
static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) {
|
||||
if (param == NULL) {
|
||||
if (param == NULL || pMsg == NULL) {
|
||||
return code;
|
||||
}
|
||||
SMqVgWalInfoParam* pParam = param;
|
||||
|
|
@ -2962,6 +3064,9 @@ static bool isInSnapshotMode(int8_t type, bool useSnapshot) {
|
|||
}
|
||||
|
||||
static int32_t tmCommittedCb(void* param, SDataBuf* pMsg, int32_t code) {
|
||||
if (param == NULL) {
|
||||
return code;
|
||||
}
|
||||
SMqCommittedParam* pParam = param;
|
||||
|
||||
if (code != 0) {
|
||||
|
|
@ -2992,6 +3097,9 @@ end:
|
|||
}
|
||||
|
||||
int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* epSet) {
|
||||
if (tmq == NULL || tname == NULL || epSet == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqVgOffset pOffset = {0};
|
||||
|
||||
|
|
|
|||
|
|
@ -449,9 +449,11 @@ static int32_t tBindInfoCompare(const void *p1, const void *p2, const void *para
|
|||
* `infoSorted` is whether the bind information is sorted by column id
|
||||
* `pTSchema` is the schema of the table
|
||||
* `rowArray` is the array to store the rows
|
||||
* `pOrdered` is the pointer to store ordered
|
||||
* `pDupTs` is the pointer to store duplicateTs
|
||||
*/
|
||||
int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema,
|
||||
SArray *rowArray) {
|
||||
SArray *rowArray, bool *pOrdered, bool *pDupTs) {
|
||||
if (infos == NULL || numOfInfos <= 0 || numOfInfos > pTSchema->numOfCols || pTSchema == NULL || rowArray == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
|
|
@ -469,6 +471,7 @@ int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted,
|
|||
return terrno;
|
||||
}
|
||||
|
||||
SRowKey rowKey, lastRowKey;
|
||||
for (int32_t iRow = 0; iRow < numOfRows; iRow++) {
|
||||
taosArrayClear(colValArray);
|
||||
|
||||
|
|
@ -507,6 +510,22 @@ int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted,
|
|||
code = terrno;
|
||||
goto _exit;
|
||||
}
|
||||
|
||||
if (pOrdered && pDupTs) {
|
||||
tRowGetKey(row, &rowKey);
|
||||
if (iRow == 0) {
|
||||
*pOrdered = true;
|
||||
*pDupTs = false;
|
||||
} else {
|
||||
// no more compare if we already get disordered or duplicate rows
|
||||
if (*pOrdered && !*pDupTs) {
|
||||
int32_t code = tRowKeyCompare(&rowKey, &lastRowKey);
|
||||
*pOrdered = (code >= 0);
|
||||
*pDupTs = (code == 0);
|
||||
}
|
||||
}
|
||||
lastRowKey = rowKey;
|
||||
}
|
||||
}
|
||||
|
||||
_exit:
|
||||
|
|
@ -3235,9 +3254,11 @@ _exit:
|
|||
* `infoSorted` is whether the bind information is sorted by column id
|
||||
* `pTSchema` is the schema of the table
|
||||
* `rowArray` is the array to store the rows
|
||||
* `pOrdered` is the pointer to store ordered
|
||||
* `pDupTs` is the pointer to store duplicateTs
|
||||
*/
|
||||
int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema,
|
||||
SArray *rowArray) {
|
||||
SArray *rowArray, bool *pOrdered, bool *pDupTs) {
|
||||
if (infos == NULL || numOfInfos <= 0 || numOfInfos > pTSchema->numOfCols || pTSchema == NULL || rowArray == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
|
|
@ -3266,6 +3287,7 @@ int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorte
|
|||
}
|
||||
}
|
||||
|
||||
SRowKey rowKey, lastRowKey;
|
||||
for (int32_t iRow = 0; iRow < numOfRows; iRow++) {
|
||||
taosArrayClear(colValArray);
|
||||
|
||||
|
|
@ -3317,6 +3339,22 @@ int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorte
|
|||
code = terrno;
|
||||
goto _exit;
|
||||
}
|
||||
|
||||
if (pOrdered && pDupTs) {
|
||||
tRowGetKey(row, &rowKey);
|
||||
if (iRow == 0) {
|
||||
*pOrdered = true;
|
||||
*pDupTs = false;
|
||||
} else {
|
||||
// no more compare if we already get disordered or duplicate rows
|
||||
if (*pOrdered && !*pDupTs) {
|
||||
int32_t code = tRowKeyCompare(&rowKey, &lastRowKey);
|
||||
*pOrdered = (code >= 0);
|
||||
*pDupTs = (code == 0);
|
||||
}
|
||||
}
|
||||
lastRowKey = rowKey;
|
||||
}
|
||||
}
|
||||
|
||||
_exit:
|
||||
|
|
|
|||
|
|
@ -52,6 +52,9 @@ int32_t mndInitConsumer(SMnode *pMnode) {
|
|||
.deleteFp = (SdbDeleteFp)mndConsumerActionDelete,
|
||||
};
|
||||
|
||||
if (pMnode == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_SUBSCRIBE, mndProcessSubscribeReq);
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_HB, mndProcessMqHbReq);
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_ASK_EP, mndProcessAskEpReq);
|
||||
|
|
@ -66,6 +69,9 @@ int32_t mndInitConsumer(SMnode *pMnode) {
|
|||
void mndCleanupConsumer(SMnode *pMnode) {}
|
||||
|
||||
int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) {
|
||||
if (pMnode == NULL || info == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void *msg = rpcMallocCont(sizeof(int64_t));
|
||||
MND_TMQ_NULL_CHECK(msg);
|
||||
|
|
@ -88,6 +94,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t validateTopics(STrans* pTrans, SCMSubscribeReq *subscribe, SMnode *pMnode, const char *pUser) {
|
||||
if (pTrans == NULL || subscribe == NULL || pMnode == NULL || pUser == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqTopicObj *pTopic = NULL;
|
||||
int32_t code = 0;
|
||||
|
||||
|
|
@ -130,6 +139,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL || pMsg->pCont == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
SMqConsumerClearMsg *pClearMsg = pMsg->pCont;
|
||||
|
|
@ -155,6 +167,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRsp *rsp, char *user) {
|
||||
if (pMnode == NULL || pConsumer == NULL || rsp == NULL || user == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
rsp->topicPrivileges = taosArrayInit(taosArrayGetSize(pConsumer->currentTopics), sizeof(STopicPrivilege));
|
||||
MND_TMQ_NULL_CHECK(rsp->topicPrivileges);
|
||||
|
|
@ -181,6 +196,9 @@ END:
|
|||
}
|
||||
|
||||
static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pConsumer){
|
||||
if (pMnode == NULL || req == NULL || pConsumer == NULL){
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < taosArrayGetSize(req->topics); i++) {
|
||||
TopicOffsetRows *data = taosArrayGet(req->topics, i);
|
||||
if (data == NULL){
|
||||
|
|
@ -210,6 +228,9 @@ static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pCons
|
|||
}
|
||||
|
||||
static int32_t buildMqHbRsp(SRpcMsg *pMsg, SMqHbRsp *rsp){
|
||||
if (pMsg == NULL || rsp == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t tlen = tSerializeSMqHbRsp(NULL, 0, rsp);
|
||||
if (tlen <= 0){
|
||||
return TSDB_CODE_TMQ_INVALID_MSG;
|
||||
|
|
@ -229,6 +250,9 @@ static int32_t buildMqHbRsp(SRpcMsg *pMsg, SMqHbRsp *rsp){
|
|||
}
|
||||
|
||||
static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
SMqHbReq req = {0};
|
||||
|
|
@ -256,6 +280,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t epoch, SMqAskEpRsp *rsp){
|
||||
if (pMnode == NULL || pConsumer == NULL || rsp == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
taosRLockLatch(&pConsumer->lock);
|
||||
|
||||
int32_t numOfTopics = taosArrayGetSize(pConsumer->currentTopics);
|
||||
|
|
@ -359,6 +386,9 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
|
|||
}
|
||||
|
||||
static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoch, int64_t consumerId){
|
||||
if (pMsg == NULL || rsp == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
// encode rsp
|
||||
int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqAskEpRsp(NULL, rsp);
|
||||
|
|
@ -388,6 +418,9 @@ static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoc
|
|||
}
|
||||
|
||||
static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
SMqAskEpReq req = {0};
|
||||
SMqAskEpRsp rsp = {0};
|
||||
|
|
@ -431,6 +464,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
|
||||
if (pConsumer == NULL || pTrans == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
|
||||
MND_TMQ_NULL_CHECK(pCommitRaw);
|
||||
|
|
@ -445,6 +481,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndSetConsumerCommitLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
|
||||
if (pConsumer == NULL || pTrans == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
|
||||
MND_TMQ_NULL_CHECK(pCommitRaw);
|
||||
|
|
@ -459,6 +498,9 @@ END:
|
|||
}
|
||||
|
||||
static void freeItem(void *param) {
|
||||
if (param == NULL) {
|
||||
return;
|
||||
}
|
||||
void *pItem = *(void **)param;
|
||||
if (pItem != NULL) {
|
||||
taosMemoryFree(pItem);
|
||||
|
|
@ -475,6 +517,9 @@ if (taosArrayPush(pConsumerNew->array, &newTopicCopy) == NULL){\
|
|||
}
|
||||
|
||||
static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerObj *pConsumerNew){
|
||||
if (pExistedConsumer == NULL || pConsumerNew == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
pConsumerNew->rebNewTopics = taosArrayInit(0, sizeof(void *));
|
||||
MND_TMQ_NULL_CHECK(pConsumerNew->rebNewTopics);
|
||||
|
|
@ -528,6 +573,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
|
||||
if (pTopicList == NULL || pMnode == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
taosArraySort(pTopicList, taosArrayCompareString);
|
||||
taosArrayRemoveDuplicate(pTopicList, taosArrayCompareString, freeItem);
|
||||
|
||||
|
|
@ -542,6 +590,9 @@ static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
|
|||
}
|
||||
|
||||
static int32_t buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer){
|
||||
if (pMnode == NULL || subscribe == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int64_t consumerId = subscribe->consumerId;
|
||||
char *cgroup = subscribe->cgroup;
|
||||
SMqConsumerObj *pConsumerNew = NULL;
|
||||
|
|
@ -581,6 +632,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
char *msgStr = pMsg->pCont;
|
||||
int32_t code = 0;
|
||||
|
|
@ -619,6 +673,9 @@ END:
|
|||
}
|
||||
|
||||
SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
|
||||
if (pConsumer == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -659,6 +716,9 @@ CM_ENCODE_OVER:
|
|||
}
|
||||
|
||||
SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) {
|
||||
if (pRaw == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
SSdbRow *pRow = NULL;
|
||||
|
|
@ -717,6 +777,9 @@ CM_DECODE_OVER:
|
|||
}
|
||||
|
||||
static int32_t mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer) {
|
||||
if (pConsumer == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mInfo("consumer:0x%" PRIx64 " sub insert, cgroup:%s status:%d(%s) epoch:%d", pConsumer->consumerId, pConsumer->cgroup,
|
||||
pConsumer->status, mndConsumerStatusName(pConsumer->status), pConsumer->epoch);
|
||||
pConsumer->subscribeTime = pConsumer->createTime;
|
||||
|
|
@ -724,6 +787,9 @@ static int32_t mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer) {
|
|||
}
|
||||
|
||||
static int32_t mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer) {
|
||||
if (pConsumer == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mInfo("consumer:0x%" PRIx64 " perform delete action, status:(%d)%s", pConsumer->consumerId, pConsumer->status,
|
||||
mndConsumerStatusName(pConsumer->status));
|
||||
tClearSMqConsumerObj(pConsumer);
|
||||
|
|
@ -744,6 +810,9 @@ static int32_t mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer) {
|
|||
|
||||
// remove from topic list
|
||||
static void removeFromTopicList(SArray *topicList, const char *pTopic, int64_t consumerId, char *type) {
|
||||
if (topicList == NULL || pTopic == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t size = taosArrayGetSize(topicList);
|
||||
for (int32_t i = 0; i < size; i++) {
|
||||
char *p = taosArrayGetP(topicList, i);
|
||||
|
|
@ -759,6 +828,9 @@ static void removeFromTopicList(SArray *topicList, const char *pTopic, int64_t c
|
|||
}
|
||||
|
||||
static bool existInCurrentTopicList(const SMqConsumerObj *pConsumer, const char *pTopic) {
|
||||
if (pConsumer == NULL || pTopic == NULL) {
|
||||
return false;
|
||||
}
|
||||
bool existing = false;
|
||||
int32_t size = taosArrayGetSize(pConsumer->currentTopics);
|
||||
for (int32_t i = 0; i < size; i++) {
|
||||
|
|
@ -773,6 +845,9 @@ static bool existInCurrentTopicList(const SMqConsumerObj *pConsumer, const char
|
|||
}
|
||||
|
||||
static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer, SMqConsumerObj *pNewConsumer) {
|
||||
if (pOldConsumer == NULL || pNewConsumer == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mInfo("consumer:0x%" PRIx64 " perform update action, update type:%d, subscribe-time:%" PRId64 ", createTime:%" PRId64,
|
||||
pOldConsumer->consumerId, pNewConsumer->updateType, pOldConsumer->subscribeTime, pOldConsumer->createTime);
|
||||
|
||||
|
|
@ -857,6 +932,9 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
|
|||
}
|
||||
|
||||
int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer) {
|
||||
if (pMnode == NULL || pConsumer == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
*pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
|
||||
if (*pConsumer == NULL) {
|
||||
|
|
@ -866,11 +944,17 @@ int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj**
|
|||
}
|
||||
|
||||
void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer) {
|
||||
if (pMnode == NULL || pConsumer == NULL) {
|
||||
return;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbRelease(pSdb, pConsumer);
|
||||
}
|
||||
|
||||
static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
|
||||
if (pReq == NULL || pShow == NULL || pBlock == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
int32_t numOfRows = 0;
|
||||
|
|
@ -1021,6 +1105,7 @@ END:
|
|||
}
|
||||
|
||||
static void mndCancelGetNextConsumer(SMnode *pMnode, void *pIter) {
|
||||
if (pMnode == NULL || pIter == NULL) return;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbCancelFetchByType(pSdb, pIter, SDB_CONSUMER);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -673,8 +673,6 @@ static int32_t mndSetUpdateIdxStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStb
|
|||
code = TSDB_CODE_MND_TAG_NOT_EXIST;
|
||||
TAOS_RETURN(code);
|
||||
}
|
||||
col_id_t colId = pOld->pTags[tag].colId;
|
||||
TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
|
||||
TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
|
||||
SSchema *pTag = pNew->pTags + tag;
|
||||
|
||||
|
|
@ -806,16 +804,7 @@ static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *re
|
|||
TAOS_RETURN(code);
|
||||
}
|
||||
|
||||
col_id_t colId = pStb->pTags[tag].colId;
|
||||
TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pStb->name, pStb->uid, colId));
|
||||
|
||||
// SSchema *pTag = pStb->pTags + tag;
|
||||
// if (IS_IDX_ON(pTag)) {
|
||||
// terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
|
||||
// return -1;
|
||||
// }
|
||||
code = mndAddIndexImpl(pMnode, pReq, pDb, pStb, &idxObj);
|
||||
|
||||
TAOS_RETURN(code);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1805,7 +1805,6 @@ static int32_t mndUpdateSuperTableColumnCompress(SMnode *pMnode, const SStbObj *
|
|||
}
|
||||
SSchema *pTarget = &pOld->pColumns[idx];
|
||||
col_id_t colId = pTarget->colId;
|
||||
TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
|
||||
|
||||
TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
|
||||
code = validColCmprByType(pTarget->type, p->bytes);
|
||||
|
|
@ -3702,10 +3701,6 @@ static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *ta
|
|||
terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
|
||||
return -1;
|
||||
}
|
||||
col_id_t colId = pOld->pTags[tag].colId;
|
||||
if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
|
||||
return -1;
|
||||
}
|
||||
if (mndAllocStbSchemas(pOld, pNew) != 0) {
|
||||
return -1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1685,11 +1685,6 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) {
|
|||
|
||||
mInfo("stream:%s,%" PRId64 " start to pause stream", pauseReq.name, pStream->uid);
|
||||
|
||||
if (pStream->status == STREAM_STATUS__PAUSE) {
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((code = mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pStream->targetDb)) != 0) {
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
return code;
|
||||
|
|
@ -1778,7 +1773,6 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) {
|
|||
|
||||
// pause stream
|
||||
taosWLockLatch(&pStream->lock);
|
||||
pStream->status = STREAM_STATUS__PAUSE;
|
||||
code = mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY);
|
||||
if (code) {
|
||||
taosWUnLockLatch(&pStream->lock);
|
||||
|
|
@ -1829,11 +1823,6 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) {
|
|||
}
|
||||
}
|
||||
|
||||
if (pStream->status != STREAM_STATUS__PAUSE) {
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
return 0;
|
||||
}
|
||||
|
||||
mInfo("stream:%s,%" PRId64 " start to resume stream from pause", resumeReq.name, pStream->uid);
|
||||
if (mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pStream->targetDb) != 0) {
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
|
|
|
|||
|
|
@ -914,8 +914,7 @@ int32_t mndResetChkptReportInfo(SHashObj *pHash, int64_t streamId) {
|
|||
return TSDB_CODE_MND_STREAM_NOT_EXIST;
|
||||
}
|
||||
|
||||
static void mndShowStreamStatus(char *dst, SStreamObj *pStream) {
|
||||
int8_t status = atomic_load_8(&pStream->status);
|
||||
static void mndShowStreamStatus(char *dst, int8_t status) {
|
||||
if (status == STREAM_STATUS__NORMAL) {
|
||||
tstrncpy(dst, "ready", MND_STREAM_TRIGGER_NAME_SIZE);
|
||||
} else if (status == STREAM_STATUS__STOP) {
|
||||
|
|
@ -951,6 +950,41 @@ static void int64ToHexStr(int64_t id, char *pBuf, int32_t bufLen) {
|
|||
varDataSetLen(pBuf, len + 2);
|
||||
}
|
||||
|
||||
static int32_t isAllTaskPaused(SStreamObj *pStream, bool *pRes) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
int32_t lino = 0;
|
||||
SStreamTaskIter *pIter = NULL;
|
||||
bool isPaused = true;
|
||||
|
||||
taosRLockLatch(&pStream->lock);
|
||||
code = createStreamTaskIter(pStream, &pIter);
|
||||
TSDB_CHECK_CODE(code, lino, _end);
|
||||
|
||||
while (streamTaskIterNextTask(pIter)) {
|
||||
SStreamTask *pTask = NULL;
|
||||
code = streamTaskIterGetCurrent(pIter, &pTask);
|
||||
TSDB_CHECK_CODE(code, lino, _end);
|
||||
|
||||
STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId};
|
||||
STaskStatusEntry *pe = taosHashGet(execInfo.pTaskMap, &id, sizeof(id));
|
||||
if (pe == NULL) {
|
||||
continue;
|
||||
}
|
||||
if (pe->status != TASK_STATUS__PAUSE) {
|
||||
isPaused = false;
|
||||
}
|
||||
}
|
||||
(*pRes) = isPaused;
|
||||
|
||||
_end:
|
||||
destroyStreamTaskIter(pIter);
|
||||
taosRUnLockLatch(&pStream->lock);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
mError("error happens when get stream status, lino:%d, code:%s", lino, tstrerror(code));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
int32_t setStreamAttrInResBlock(SStreamObj *pStream, SSDataBlock *pBlock, int32_t numOfRows) {
|
||||
int32_t code = 0;
|
||||
int32_t cols = 0;
|
||||
|
|
@ -999,7 +1033,15 @@ int32_t setStreamAttrInResBlock(SStreamObj *pStream, SSDataBlock *pBlock, int32_
|
|||
|
||||
char status[20 + VARSTR_HEADER_SIZE] = {0};
|
||||
char status2[MND_STREAM_TRIGGER_NAME_SIZE] = {0};
|
||||
mndShowStreamStatus(status2, pStream);
|
||||
bool isPaused = false;
|
||||
code = isAllTaskPaused(pStream, &isPaused);
|
||||
TSDB_CHECK_CODE(code, lino, _end);
|
||||
|
||||
int8_t streamStatus = atomic_load_8(&pStream->status);
|
||||
if (isPaused) {
|
||||
streamStatus = STREAM_STATUS__PAUSE;
|
||||
}
|
||||
mndShowStreamStatus(status2, streamStatus);
|
||||
STR_WITH_MAXSIZE_TO_VARSTR(status, status2, sizeof(status));
|
||||
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
|
||||
TSDB_CHECK_NULL(pColInfo, code, lino, _end, terrno);
|
||||
|
|
|
|||
|
|
@ -43,6 +43,9 @@ static void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter);
|
|||
static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash);
|
||||
|
||||
static int32_t mndSetSubCommitLogs(STrans *pTrans, SMqSubscribeObj *pSub) {
|
||||
if (pTrans == NULL || pSub == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);
|
||||
MND_TMQ_NULL_CHECK(pCommitRaw);
|
||||
|
|
@ -68,6 +71,9 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
|
|||
.deleteFp = (SdbDeleteFp)mndSubActionDelete,
|
||||
};
|
||||
|
||||
if (pMnode == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mndSetMsgHandle(pMnode, TDMT_VND_TMQ_SUBSCRIBE_RSP, mndTransProcessRsp);
|
||||
mndSetMsgHandle(pMnode, TDMT_VND_TMQ_DELETE_SUB_RSP, mndTransProcessRsp);
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessRebalanceReq);
|
||||
|
|
@ -81,6 +87,9 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
|
|||
}
|
||||
|
||||
static int32_t mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey, SMqSubscribeObj** pSub) {
|
||||
if(pMnode == NULL || pTopic == NULL || subKey == NULL || pSub == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
MND_TMQ_RETURN_CHECK(tNewSubscribeObj(subKey, pSub));
|
||||
(*pSub)->dbUid = pTopic->dbUid;
|
||||
|
|
@ -99,6 +108,9 @@ END:
|
|||
|
||||
static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg,
|
||||
SSubplan *pPlan) {
|
||||
if (pSub == NULL || pRebVg == NULL || pBuf == NULL || pLen == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqRebVgReq req = {0};
|
||||
int32_t code = 0;
|
||||
SEncoder encoder = {0};
|
||||
|
|
@ -146,6 +158,9 @@ END:
|
|||
|
||||
static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub,
|
||||
const SMqRebOutputVg *pRebVg, SSubplan *pPlan) {
|
||||
if (pMnode == NULL || pTrans == NULL || pSub == NULL || pRebVg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void *buf = NULL;
|
||||
|
||||
|
|
@ -180,6 +195,9 @@ END:
|
|||
}
|
||||
|
||||
static void mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) {
|
||||
if (key == NULL || topic == NULL || cgroup == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t i = 0;
|
||||
while (key[i] != TMQ_SEPARATOR_CHAR) {
|
||||
i++;
|
||||
|
|
@ -197,6 +215,9 @@ static void mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, boo
|
|||
}
|
||||
|
||||
static int32_t mndGetOrCreateRebSub(SHashObj *pHash, const char *key, SMqRebInfo **pReb) {
|
||||
if (pHash == NULL || key == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqRebInfo* pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
|
||||
if (pRebInfo == NULL) {
|
||||
|
|
@ -222,6 +243,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) {
|
||||
if (vgs == NULL || pHash == NULL || key == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqVgEp **pVgEp = (SMqVgEp **)taosArrayPop(vgs);
|
||||
MND_TMQ_NULL_CHECK(pVgEp);
|
||||
|
|
@ -233,6 +257,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) {
|
||||
if (pHash == NULL || pOutput == NULL || pInput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);
|
||||
int32_t actualRemoved = 0;
|
||||
|
|
@ -266,6 +293,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) {
|
||||
if (pOutput == NULL || pInput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t numOfNewConsumers = taosArrayGetSize(pInput->pRebInfo->newConsumers);
|
||||
|
||||
|
|
@ -285,6 +315,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) {
|
||||
if (pOutput == NULL || pHash == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t numOfVgroups = taosArrayGetSize(pOutput->pSub->unassignedVgs);
|
||||
for (int32_t i = 0; i < numOfVgroups; i++) {
|
||||
|
|
@ -296,6 +329,9 @@ END:
|
|||
|
||||
static int32_t processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt,
|
||||
int32_t remainderVgCnt) {
|
||||
if (pOutput == NULL || pHash == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t cnt = 0;
|
||||
void *pIter = NULL;
|
||||
|
|
@ -328,6 +364,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {
|
||||
if (pMnode == NULL || pOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t totalVgNum = 0;
|
||||
SVgObj *pVgroup = NULL;
|
||||
|
|
@ -403,6 +442,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
|
||||
if (pMnode == NULL || pInput == NULL || pOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqSubscribeObj *pSub = NULL;
|
||||
int32_t code = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub); // put all offset rows
|
||||
if( code != 0){
|
||||
|
|
@ -465,6 +507,7 @@ END:
|
|||
}
|
||||
|
||||
static void printRebalanceLog(SMqRebOutputObj *pOutput) {
|
||||
if (pOutput == NULL) return;
|
||||
mInfo("sub:%s mq rebalance calculation completed, re-balanced vg", pOutput->pSub->key);
|
||||
for (int32_t i = 0; i < taosArrayGetSize(pOutput->rebVgs); i++) {
|
||||
SMqRebOutputVg *pOutputRebVg = taosArrayGet(pOutput->rebVgs, i);
|
||||
|
|
@ -492,6 +535,9 @@ static void printRebalanceLog(SMqRebOutputObj *pOutput) {
|
|||
|
||||
static void calcVgroupsCnt(const SMqRebInputObj *pInput, int32_t totalVgNum, const char *pSubKey, int32_t *minVgCnt,
|
||||
int32_t *remainderVgCnt) {
|
||||
if (pInput == NULL || pSubKey == NULL || minVgCnt == NULL || remainderVgCnt == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);
|
||||
int32_t numOfAdded = taosArrayGetSize(pInput->pRebInfo->newConsumers);
|
||||
int32_t numOfFinal = pInput->oldConsumerNum + numOfAdded - numOfRemoved;
|
||||
|
|
@ -509,6 +555,9 @@ static void calcVgroupsCnt(const SMqRebInputObj *pInput, int32_t totalVgNum, con
|
|||
}
|
||||
|
||||
static int32_t assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) {
|
||||
if (pOutput == NULL || pHash == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqRebOutputVg *pRebVg = NULL;
|
||||
void *pAssignIter = NULL;
|
||||
void *pIter = NULL;
|
||||
|
|
@ -580,6 +629,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
|
||||
if (pMnode == NULL || pInput == NULL || pOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t totalVgNum = processRemoveAddVgs(pMnode, pOutput);
|
||||
if (totalVgNum < 0){
|
||||
return totalVgNum;
|
||||
|
|
@ -605,6 +657,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t type, char *cgroup, char *topic) {
|
||||
if (pTrans == NULL || consumers == NULL || cgroup == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqConsumerObj *pConsumerNew = NULL;
|
||||
int32_t consumerNum = taosArrayGetSize(consumers);
|
||||
|
|
@ -623,6 +678,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndPresistConsumer(STrans *pTrans, const SMqRebOutputObj *pOutput, char *cgroup, char *topic) {
|
||||
if (pTrans == NULL || pOutput == NULL || cgroup == NULL || topic == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL));
|
||||
MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic));
|
||||
|
|
@ -632,6 +690,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOutputObj *pOutput) {
|
||||
if (pMnode == NULL || pMsg == NULL || pOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
struct SSubplan *pPlan = NULL;
|
||||
int32_t code = 0;
|
||||
STrans *pTrans = NULL;
|
||||
|
|
@ -682,6 +743,7 @@ END:
|
|||
}
|
||||
|
||||
static void freeRebalanceItem(void *param) {
|
||||
if (param == NULL) return;
|
||||
SMqRebInfo *pInfo = param;
|
||||
taosArrayDestroy(pInfo->newConsumers);
|
||||
taosArrayDestroy(pInfo->removedConsumers);
|
||||
|
|
@ -689,6 +751,9 @@ static void freeRebalanceItem(void *param) {
|
|||
|
||||
// type = 0 remove type = 1 add
|
||||
static int32_t buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) {
|
||||
if (rebSubHash == NULL || topicList == NULL || group == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t topicNum = taosArrayGetSize(topicList);
|
||||
for (int32_t i = 0; i < topicNum; i++) {
|
||||
|
|
@ -709,6 +774,9 @@ END:
|
|||
}
|
||||
|
||||
static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHashObj *rebSubHash) {
|
||||
if (pMnode == NULL || pConsumer == NULL || rebSubHash == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t newTopicNum = taosArrayGetSize(pConsumer->currentTopics);
|
||||
for (int32_t i = 0; i < newTopicNum; i++) {
|
||||
char *topic = taosArrayGetP(pConsumer->currentTopics, i);
|
||||
|
|
@ -754,6 +822,9 @@ static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHash
|
|||
}
|
||||
|
||||
static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) {
|
||||
if (pMsg == NULL || rebSubHash == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
SMqConsumerObj *pConsumer = NULL;
|
||||
|
|
@ -818,6 +889,9 @@ void mndRebCntDec() {
|
|||
}
|
||||
|
||||
static void clearRebOutput(SMqRebOutputObj *rebOutput) {
|
||||
if (rebOutput == NULL) {
|
||||
return;
|
||||
}
|
||||
taosArrayDestroy(rebOutput->newConsumers);
|
||||
taosArrayDestroy(rebOutput->modifyConsumers);
|
||||
taosArrayDestroy(rebOutput->removedConsumers);
|
||||
|
|
@ -827,6 +901,9 @@ static void clearRebOutput(SMqRebOutputObj *rebOutput) {
|
|||
}
|
||||
|
||||
static int32_t initRebOutput(SMqRebOutputObj *rebOutput) {
|
||||
if (rebOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
rebOutput->newConsumers = taosArrayInit(0, sizeof(int64_t));
|
||||
MND_TMQ_NULL_CHECK(rebOutput->newConsumers);
|
||||
|
|
@ -845,6 +922,9 @@ END:
|
|||
|
||||
// This function only works when there are dirty consumers
|
||||
static int32_t checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) {
|
||||
if (pMnode == NULL || pSub == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void *pIter = NULL;
|
||||
while (1) {
|
||||
|
|
@ -871,6 +951,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) {
|
||||
if (pMnode == NULL || rebInput == NULL || rebOutput == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
const char *key = rebInput->pRebInfo->key;
|
||||
SMqSubscribeObj *pSub = NULL;
|
||||
int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
|
||||
|
|
@ -922,6 +1005,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int code = 0;
|
||||
void *pIter = NULL;
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
|
|
@ -986,6 +1072,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STrans *pTrans) {
|
||||
if (pMnode == NULL || pSub == NULL || pTrans == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void *pIter = NULL;
|
||||
SVgObj *pVgObj = NULL;
|
||||
int32_t code = 0;
|
||||
|
|
@ -1024,6 +1113,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndCheckConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgroup, char *topic) {
|
||||
if (pMnode == NULL || pTrans == NULL || cgroup == NULL || topic == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void *pIter = NULL;
|
||||
SMqConsumerObj *pConsumer = NULL;
|
||||
int code = 0;
|
||||
|
|
@ -1056,6 +1148,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {
|
||||
if (pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pMsg->info.node;
|
||||
SMDropCgroupReq dropReq = {0};
|
||||
STrans *pTrans = NULL;
|
||||
|
|
@ -1109,6 +1204,9 @@ END:
|
|||
void mndCleanupSubscribe(SMnode *pMnode) {}
|
||||
|
||||
static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
|
||||
if (pSub == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -1149,6 +1247,9 @@ SUB_ENCODE_OVER:
|
|||
}
|
||||
|
||||
static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
|
||||
if (pRaw == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -1218,17 +1319,18 @@ SUB_DECODE_OVER:
|
|||
}
|
||||
|
||||
static int32_t mndSubActionInsert(SSdb *pSdb, SMqSubscribeObj *pSub) {
|
||||
mTrace("subscribe:%s, perform insert action", pSub->key);
|
||||
mTrace("subscribe:%s, perform insert action", pSub != NULL ? pSub->key : "null");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mndSubActionDelete(SSdb *pSdb, SMqSubscribeObj *pSub) {
|
||||
mTrace("subscribe:%s, perform delete action", pSub->key);
|
||||
mTrace("subscribe:%s, perform delete action", pSub != NULL ? pSub->key : "null");
|
||||
tDeleteSubscribeObj(pSub);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubscribeObj *pNewSub) {
|
||||
if (pOldSub == NULL || pNewSub == NULL) return -1;
|
||||
mTrace("subscribe:%s, perform update action", pOldSub->key);
|
||||
taosWLockLatch(&pOldSub->lock);
|
||||
|
||||
|
|
@ -1249,6 +1351,9 @@ static int32_t mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubsc
|
|||
}
|
||||
|
||||
int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub) {
|
||||
if (pMnode == NULL || key == NULL || pSub == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
*pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key);
|
||||
if (*pSub == NULL) {
|
||||
|
|
@ -1258,6 +1363,7 @@ int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeOb
|
|||
}
|
||||
|
||||
int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName) {
|
||||
if (pMnode == NULL || topicName == NULL) return 0;
|
||||
int32_t num = 0;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
|
||||
|
|
@ -1283,11 +1389,13 @@ int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName) {
|
|||
}
|
||||
|
||||
void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub) {
|
||||
if (pMnode == NULL || pSub == NULL) return;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbRelease(pSdb, pSub);
|
||||
}
|
||||
|
||||
int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) {
|
||||
if (pMnode == NULL || pTrans == NULL || pSub == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
int32_t code = 0;
|
||||
SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);
|
||||
MND_TMQ_NULL_CHECK(pCommitRaw);
|
||||
|
|
@ -1302,6 +1410,7 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) {
|
||||
if (pMnode == NULL || pTrans == NULL || topicName == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
int32_t code = 0;
|
||||
void *pIter = NULL;
|
||||
|
|
@ -1337,6 +1446,9 @@ END:
|
|||
|
||||
static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t consumerId, const char* user, const char* fqdn,
|
||||
const char *topic, const char *cgroup, SArray *vgs, SArray *offsetRows) {
|
||||
if (pBlock == NULL || numOfRows == NULL || topic == NULL || cgroup == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t sz = taosArrayGetSize(vgs);
|
||||
for (int32_t j = 0; j < sz; j++) {
|
||||
|
|
@ -1424,6 +1536,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
|
||||
if (pReq == NULL || pShow == NULL || pBlock == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
int32_t numOfRows = 0;
|
||||
|
|
@ -1485,10 +1600,16 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
|
|||
return numOfRows;
|
||||
|
||||
END:
|
||||
taosRUnLockLatch(&pSub->lock);
|
||||
sdbRelease(pSdb, pSub);
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter) {
|
||||
if (pMnode == NULL) {
|
||||
return;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbCancelFetchByType(pSdb, pIter, SDB_SUBSCRIBE);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,6 +55,9 @@ int32_t mndInitTopic(SMnode *pMnode) {
|
|||
.deleteFp = (SdbDeleteFp)mndTopicActionDelete,
|
||||
};
|
||||
|
||||
if (pMnode == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CREATE_TOPIC, mndProcessCreateTopicReq);
|
||||
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_DROP_TOPIC, mndProcessDropTopicReq);
|
||||
mndSetMsgHandle(pMnode, TDMT_VND_TMQ_ADD_CHECKINFO_RSP, mndTransProcessRsp);
|
||||
|
|
@ -81,6 +84,9 @@ void mndTopicGetShowName(const char* fullTopic, char* topic) {
|
|||
}
|
||||
|
||||
SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
|
||||
if (pTopic == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -172,6 +178,7 @@ TOPIC_ENCODE_OVER:
|
|||
}
|
||||
|
||||
SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
|
||||
if (pRaw == NULL) return NULL;
|
||||
int32_t code = 0;
|
||||
int32_t lino = 0;
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -193,7 +200,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
|
|||
pTopic = sdbGetRowObj(pRow);
|
||||
if (pTopic == NULL) goto TOPIC_DECODE_OVER;
|
||||
|
||||
int32_t len;
|
||||
int32_t len = 0;
|
||||
int32_t dataPos = 0;
|
||||
SDB_GET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TOPIC_FNAME_LEN, TOPIC_DECODE_OVER);
|
||||
SDB_GET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN, TOPIC_DECODE_OVER);
|
||||
|
|
@ -292,11 +299,12 @@ TOPIC_DECODE_OVER:
|
|||
}
|
||||
|
||||
static int32_t mndTopicActionInsert(SSdb *pSdb, SMqTopicObj *pTopic) {
|
||||
mTrace("topic:%s perform insert action", pTopic->name);
|
||||
mTrace("topic:%s perform insert action", pTopic != NULL ? pTopic->name : "null");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) {
|
||||
if (pTopic == NULL) return 0;
|
||||
mTrace("topic:%s perform delete action", pTopic->name);
|
||||
taosMemoryFreeClear(pTopic->sql);
|
||||
taosMemoryFreeClear(pTopic->ast);
|
||||
|
|
@ -307,6 +315,7 @@ static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) {
|
|||
}
|
||||
|
||||
static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic) {
|
||||
if (pOldTopic == NULL || pNewTopic == NULL) return 0;
|
||||
mTrace("topic:%s perform update action", pOldTopic->name);
|
||||
(void)atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
|
||||
(void)atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
|
||||
|
|
@ -315,6 +324,9 @@ static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopic
|
|||
}
|
||||
|
||||
int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic) {
|
||||
if (pMnode == NULL || topicName == NULL || pTopic == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
*pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
|
||||
if (*pTopic == NULL) {
|
||||
|
|
@ -324,11 +336,13 @@ int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTo
|
|||
}
|
||||
|
||||
void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
|
||||
if (pMnode == NULL) return;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbRelease(pSdb, pTopic);
|
||||
}
|
||||
|
||||
static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
|
||||
if (pCreate == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
if (pCreate->sql == NULL) return TSDB_CODE_MND_INVALID_TOPIC;
|
||||
|
||||
if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
|
||||
|
|
@ -343,6 +357,7 @@ static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
|
|||
}
|
||||
|
||||
static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
|
||||
if (pAst == NULL || pTopic == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
SNodeList *pNodeList = NULL;
|
||||
int32_t code = 0;
|
||||
MND_TMQ_RETURN_CHECK(nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList));
|
||||
|
|
@ -367,6 +382,7 @@ END:
|
|||
}
|
||||
|
||||
static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj *topicObj){
|
||||
if (pTrans == NULL || pMnode == NULL || topicObj == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
STqCheckInfo info = {0};
|
||||
(void)memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);
|
||||
info.ntbUid = topicObj->ntbUid;
|
||||
|
|
@ -388,7 +404,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
|
|||
}
|
||||
|
||||
// encoder check alter info
|
||||
int32_t len;
|
||||
int32_t len = 0;
|
||||
tEncodeSize(tEncodeSTqCheckInfo, &info, len, code);
|
||||
if (code != 0) {
|
||||
code = TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -426,6 +442,7 @@ END:
|
|||
|
||||
static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *pCreate, SDbObj *pDb,
|
||||
const char *userName) {
|
||||
if (pMnode == NULL || pReq == NULL || pCreate == NULL || pDb == NULL || userName == NULL) return TSDB_CODE_INVALID_PARA;
|
||||
mInfo("start to create topic:%s", pCreate->name);
|
||||
STrans *pTrans = NULL;
|
||||
int32_t code = 0;
|
||||
|
|
@ -519,6 +536,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {
|
||||
if (pReq == NULL || pReq->contLen <= 0) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
SMqTopicObj *pTopic = NULL;
|
||||
|
|
@ -596,6 +616,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndDropTopic(SMnode *pMnode, STrans *pTrans, SRpcMsg *pReq, SMqTopicObj *pTopic) {
|
||||
if (pMnode == NULL || pTrans == NULL || pReq == NULL || pTopic == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSdbRaw *pCommitRaw = NULL;
|
||||
MND_TMQ_RETURN_CHECK(mndUserRemoveTopic(pMnode, pTrans, pTopic->name));
|
||||
|
|
@ -614,6 +637,9 @@ END:
|
|||
}
|
||||
|
||||
bool checkTopic(SArray *topics, char *topicName){
|
||||
if (topics == NULL || topicName == NULL) {
|
||||
return false;
|
||||
}
|
||||
int32_t sz = taosArrayGetSize(topics);
|
||||
for (int32_t i = 0; i < sz; i++) {
|
||||
char *name = taosArrayGetP(topics, i);
|
||||
|
|
@ -625,6 +651,9 @@ bool checkTopic(SArray *topics, char *topicName){
|
|||
}
|
||||
|
||||
static int32_t mndCheckConsumerByTopic(SMnode *pMnode, STrans *pTrans, char *topicName){
|
||||
if (pMnode == NULL || pTrans == NULL || topicName == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
void *pIter = NULL;
|
||||
|
|
@ -653,6 +682,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic){
|
||||
if (pMnode == NULL || pTrans == NULL || pTopic == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
// broadcast to all vnode
|
||||
void *pIter = NULL;
|
||||
SVgObj *pVgroup = NULL;
|
||||
|
|
@ -693,6 +725,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
|
||||
if (pReq == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
SMDropTopicReq dropReq = {0};
|
||||
int32_t code = 0;
|
||||
|
|
@ -756,6 +791,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
|
||||
if (pMnode == NULL || dbName == NULL || pNumOfTopics == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
*pNumOfTopics = 0;
|
||||
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
|
|
@ -786,6 +824,9 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
|
|||
}
|
||||
|
||||
static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
|
||||
if (schema == NULL || schemaJson == NULL) {
|
||||
return;
|
||||
}
|
||||
char* string = NULL;
|
||||
int32_t code = 0;
|
||||
cJSON* columns = cJSON_CreateArray();
|
||||
|
|
@ -838,6 +879,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
|
||||
if (pReq == NULL || pShow == NULL || pBlock == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
int32_t numOfRows = 0;
|
||||
|
|
@ -945,11 +989,15 @@ END:
|
|||
}
|
||||
|
||||
static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {
|
||||
if (pMnode == NULL) return;
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
sdbCancelFetchByType(pSdb, pIter, SDB_TOPIC);
|
||||
}
|
||||
|
||||
bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb) {
|
||||
if (pMnode == NULL || pDb == NULL) {
|
||||
return false;
|
||||
}
|
||||
SSdb *pSdb = pMnode->pSdb;
|
||||
void *pIter = NULL;
|
||||
SMqTopicObj *pTopic = NULL;
|
||||
|
|
|
|||
|
|
@ -127,11 +127,11 @@ void tqPushEmptyDataRsp(STqHandle* pHandle, int32_t vgId);
|
|||
int32_t tqMetaOpen(STQ* pTq);
|
||||
void tqMetaClose(STQ* pTq);
|
||||
int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle);
|
||||
int32_t tqMetaSaveInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen, const void* value, int32_t vLen);
|
||||
int32_t tqMetaDeleteInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen);
|
||||
int32_t tqMetaSaveInfo(STQ* pTq, TTB* ttb, const void* key, uint32_t kLen, const void* value, uint32_t vLen);
|
||||
int32_t tqMetaDeleteInfo(STQ* pTq, TTB* ttb, const void* key, uint32_t kLen);
|
||||
int32_t tqMetaCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle);
|
||||
int32_t tqMetaDecodeCheckInfo(STqCheckInfo *info, void *pVal, int32_t vLen);
|
||||
int32_t tqMetaDecodeOffsetInfo(STqOffset *info, void *pVal, int32_t vLen);
|
||||
int32_t tqMetaDecodeCheckInfo(STqCheckInfo *info, void *pVal, uint32_t vLen);
|
||||
int32_t tqMetaDecodeOffsetInfo(STqOffset *info, void *pVal, uint32_t vLen);
|
||||
int32_t tqMetaSaveOffset(STQ* pTq, STqOffset* pOffset);
|
||||
int32_t tqMetaGetHandle(STQ* pTq, const char* key, STqHandle** pHandle);
|
||||
int32_t tqMetaGetOffset(STQ* pTq, const char* subkey, STqOffset** pOffset);
|
||||
|
|
|
|||
|
|
@ -25,11 +25,12 @@
|
|||
// 2: wait to be inited or cleanup
|
||||
static int32_t tqInitialize(STQ* pTq);
|
||||
|
||||
static FORCE_INLINE bool tqIsHandleExec(STqHandle* pHandle) { return TMQ_HANDLE_STATUS_EXEC == pHandle->status; }
|
||||
static FORCE_INLINE void tqSetHandleExec(STqHandle* pHandle) { pHandle->status = TMQ_HANDLE_STATUS_EXEC; }
|
||||
static FORCE_INLINE void tqSetHandleIdle(STqHandle* pHandle) { pHandle->status = TMQ_HANDLE_STATUS_IDLE; }
|
||||
static FORCE_INLINE bool tqIsHandleExec(STqHandle* pHandle) { return pHandle != NULL ? TMQ_HANDLE_STATUS_EXEC == pHandle->status : true; }
|
||||
static FORCE_INLINE void tqSetHandleExec(STqHandle* pHandle) { if (pHandle != NULL) pHandle->status = TMQ_HANDLE_STATUS_EXEC; }
|
||||
static FORCE_INLINE void tqSetHandleIdle(STqHandle* pHandle) { if (pHandle != NULL) pHandle->status = TMQ_HANDLE_STATUS_IDLE; }
|
||||
|
||||
void tqDestroyTqHandle(void* data) {
|
||||
if (data == NULL) return;
|
||||
STqHandle* pData = (STqHandle*)data;
|
||||
qDestroyTask(pData->execHandle.task);
|
||||
|
||||
|
|
@ -59,11 +60,17 @@ void tqDestroyTqHandle(void* data) {
|
|||
}
|
||||
|
||||
static bool tqOffsetEqual(const STqOffset* pLeft, const STqOffset* pRight) {
|
||||
if (pLeft == NULL || pRight == NULL) {
|
||||
return false;
|
||||
}
|
||||
return pLeft->val.type == TMQ_OFFSET__LOG && pRight->val.type == TMQ_OFFSET__LOG &&
|
||||
pLeft->val.version == pRight->val.version;
|
||||
}
|
||||
|
||||
int32_t tqOpen(const char* path, SVnode* pVnode) {
|
||||
if (path == NULL || pVnode == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
STQ* pTq = taosMemoryCalloc(1, sizeof(STQ));
|
||||
if (pTq == NULL) {
|
||||
return terrno;
|
||||
|
|
@ -104,6 +111,9 @@ int32_t tqOpen(const char* path, SVnode* pVnode) {
|
|||
}
|
||||
|
||||
int32_t tqInitialize(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
int32_t code = streamMetaOpen(pTq->path, pTq, tqBuildStreamTask, tqExpandStreamTask, vgId, -1,
|
||||
tqStartTaskCompleteCallback, &pTq->pStreamMeta);
|
||||
|
|
@ -157,6 +167,9 @@ void tqNotifyClose(STQ* pTq) {
|
|||
}
|
||||
|
||||
void tqPushEmptyDataRsp(STqHandle* pHandle, int32_t vgId) {
|
||||
if (pHandle == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqPollReq req = {0};
|
||||
code = tDeserializeSMqPollReq(pHandle->msg->pCont, pHandle->msg->contLen, &req);
|
||||
|
|
@ -186,6 +199,9 @@ void tqPushEmptyDataRsp(STqHandle* pHandle, int32_t vgId) {
|
|||
|
||||
int32_t tqSendDataRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqDataRsp* pRsp, int32_t type,
|
||||
int32_t vgId) {
|
||||
if (pHandle == NULL || pMsg == NULL || pReq == NULL || pRsp == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int64_t sver = 0, ever = 0;
|
||||
walReaderValidVersionRange(pHandle->execHandle.pTqReader->pWalReader, &sver, &ever);
|
||||
|
||||
|
|
@ -201,6 +217,9 @@ int32_t tqSendDataRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq*
|
|||
}
|
||||
|
||||
int32_t tqProcessOffsetCommitReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqVgOffset vgOffset = {0};
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
||||
|
|
@ -243,7 +262,7 @@ int32_t tqProcessOffsetCommitReq(STQ* pTq, int64_t sversion, char* msg, int32_t
|
|||
}
|
||||
|
||||
if (tqMetaSaveInfo(pTq, pTq->pOffsetStore, pOffset->subKey, strlen(pOffset->subKey), msg,
|
||||
msgLen - sizeof(vgOffset.consumerId)) < 0) {
|
||||
msgLen >= sizeof(vgOffset.consumerId) ? msgLen - sizeof(vgOffset.consumerId) : 0) < 0) {
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -255,6 +274,9 @@ end:
|
|||
}
|
||||
|
||||
int32_t tqProcessSeekReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqSeekReq req = {0};
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
SRpcMsg rsp = {.info = pMsg->info};
|
||||
|
|
@ -297,6 +319,9 @@ end:
|
|||
}
|
||||
|
||||
int32_t tqCheckColModifiable(STQ* pTq, int64_t tbUid, int32_t colId) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* pIter = NULL;
|
||||
|
||||
while (1) {
|
||||
|
|
@ -327,6 +352,9 @@ int32_t tqCheckColModifiable(STQ* pTq, int64_t tbUid, int32_t colId) {
|
|||
}
|
||||
|
||||
int32_t tqProcessPollPush(STQ* pTq, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
taosWLockLatch(&pTq->lock);
|
||||
if (taosHashGetSize(pTq->pPushMgr) > 0) {
|
||||
|
|
@ -362,6 +390,9 @@ int32_t tqProcessPollPush(STQ* pTq, SRpcMsg* pMsg) {
|
|||
}
|
||||
|
||||
int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqPollReq req = {0};
|
||||
int code = tDeserializeSMqPollReq(pMsg->pCont, pMsg->contLen, &req);
|
||||
if (code < 0) {
|
||||
|
|
@ -439,6 +470,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqProcessVgCommittedInfoReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* data = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
|
||||
int32_t len = pMsg->contLen - sizeof(SMsgHead);
|
||||
|
||||
|
|
@ -485,6 +519,9 @@ int32_t tqProcessVgCommittedInfoReq(STQ* pTq, SRpcMsg* pMsg) {
|
|||
}
|
||||
|
||||
int32_t tqProcessVgWalInfoReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SMqPollReq req = {0};
|
||||
if (tDeserializeSMqPollReq(pMsg->pCont, pMsg->contLen, &req) < 0) {
|
||||
|
|
@ -570,6 +607,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqProcessDeleteSubReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen) {
|
||||
if (pTq == NULL || msg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMqVDeleteReq* pReq = (SMqVDeleteReq*)msg;
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
||||
|
|
@ -616,8 +656,11 @@ int32_t tqProcessDeleteSubReq(STQ* pTq, int64_t sversion, char* msg, int32_t msg
|
|||
}
|
||||
|
||||
int32_t tqProcessAddCheckInfoReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen) {
|
||||
if (pTq == NULL || msg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
STqCheckInfo info = {0};
|
||||
int32_t code = tqMetaDecodeCheckInfo(&info, msg, msgLen);
|
||||
int32_t code = tqMetaDecodeCheckInfo(&info, msg, msgLen >= 0 ? msgLen : 0);
|
||||
if (code != 0) {
|
||||
return code;
|
||||
}
|
||||
|
|
@ -628,10 +671,13 @@ int32_t tqProcessAddCheckInfoReq(STQ* pTq, int64_t sversion, char* msg, int32_t
|
|||
return code;
|
||||
}
|
||||
|
||||
return tqMetaSaveInfo(pTq, pTq->pCheckStore, info.topic, strlen(info.topic), msg, msgLen);
|
||||
return tqMetaSaveInfo(pTq, pTq->pCheckStore, info.topic, strlen(info.topic), msg, msgLen >= 0 ? msgLen : 0);
|
||||
}
|
||||
|
||||
int32_t tqProcessDelCheckInfoReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen) {
|
||||
if (pTq == NULL || msg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
if (taosHashRemove(pTq->pCheckInfo, msg, strlen(msg)) < 0) {
|
||||
return TSDB_CODE_TSC_INTERNAL_ERROR;
|
||||
}
|
||||
|
|
@ -639,6 +685,9 @@ int32_t tqProcessDelCheckInfoReq(STQ* pTq, int64_t sversion, char* msg, int32_t
|
|||
}
|
||||
|
||||
int32_t tqProcessSubscribeReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen) {
|
||||
if (pTq == NULL || msg == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int ret = 0;
|
||||
SMqRebVgReq req = {0};
|
||||
SDecoder dc = {0};
|
||||
|
|
|
|||
|
|
@ -16,6 +16,9 @@
|
|||
#include "tq.h"
|
||||
|
||||
int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
|
||||
if (pEncoder == NULL || pHandle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino;
|
||||
|
||||
|
|
@ -54,6 +57,9 @@ _exit:
|
|||
}
|
||||
|
||||
int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
|
||||
if (pDecoder == NULL || pHandle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t lino;
|
||||
|
||||
|
|
@ -91,7 +97,10 @@ _exit:
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t tqMetaDecodeCheckInfo(STqCheckInfo* info, void* pVal, int32_t vLen) {
|
||||
int32_t tqMetaDecodeCheckInfo(STqCheckInfo* info, void* pVal, uint32_t vLen) {
|
||||
if (info == NULL || pVal == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
|
||||
int32_t code = tDecodeSTqCheckInfo(&decoder, info);
|
||||
|
|
@ -104,7 +113,10 @@ int32_t tqMetaDecodeCheckInfo(STqCheckInfo* info, void* pVal, int32_t vLen) {
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t tqMetaDecodeOffsetInfo(STqOffset* info, void* pVal, int32_t vLen) {
|
||||
int32_t tqMetaDecodeOffsetInfo(STqOffset* info, void* pVal, uint32_t vLen) {
|
||||
if (info == NULL || pVal == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SDecoder decoder = {0};
|
||||
tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
|
||||
int32_t code = tDecodeSTqOffset(&decoder, info);
|
||||
|
|
@ -118,9 +130,12 @@ int32_t tqMetaDecodeOffsetInfo(STqOffset* info, void* pVal, int32_t vLen) {
|
|||
}
|
||||
|
||||
int32_t tqMetaSaveOffset(STQ* pTq, STqOffset* pOffset) {
|
||||
if (pTq == NULL || pOffset == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* buf = NULL;
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
int32_t vlen;
|
||||
uint32_t vlen;
|
||||
SEncoder encoder = {0};
|
||||
tEncodeSize(tEncodeSTqOffset, pOffset, vlen, code);
|
||||
if (code < 0) {
|
||||
|
|
@ -147,7 +162,10 @@ END:
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t tqMetaSaveInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen, const void* value, int32_t vLen) {
|
||||
int32_t tqMetaSaveInfo(STQ* pTq, TTB* ttb, const void* key, uint32_t kLen, const void* value, uint32_t vLen) {
|
||||
if (pTq == NULL || ttb == NULL || key == NULL || value == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
TXN* txn = NULL;
|
||||
|
||||
|
|
@ -164,7 +182,10 @@ END:
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t tqMetaDeleteInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen) {
|
||||
int32_t tqMetaDeleteInfo(STQ* pTq, TTB* ttb, const void* key, uint32_t kLen) {
|
||||
if (pTq == NULL || ttb == NULL || key == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
TXN* txn = NULL;
|
||||
|
||||
|
|
@ -182,6 +203,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqMetaGetOffset(STQ* pTq, const char* subkey, STqOffset** pOffset) {
|
||||
if (pTq == NULL || subkey == NULL || pOffset == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* data = taosHashGet(pTq->pOffset, subkey, strlen(subkey));
|
||||
if (data == NULL) {
|
||||
int vLen = 0;
|
||||
|
|
@ -191,7 +215,7 @@ int32_t tqMetaGetOffset(STQ* pTq, const char* subkey, STqOffset** pOffset) {
|
|||
}
|
||||
|
||||
STqOffset offset = {0};
|
||||
if (tqMetaDecodeOffsetInfo(&offset, data, vLen) != TDB_CODE_SUCCESS) {
|
||||
if (tqMetaDecodeOffsetInfo(&offset, data, vLen >= 0 ? vLen : 0) != TDB_CODE_SUCCESS) {
|
||||
tdbFree(data);
|
||||
return TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
|
|
@ -214,8 +238,11 @@ int32_t tqMetaGetOffset(STQ* pTq, const char* subkey, STqOffset** pOffset) {
|
|||
}
|
||||
|
||||
int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
|
||||
if (pTq == NULL || key == NULL || pHandle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
int32_t vlen;
|
||||
uint32_t vlen;
|
||||
void* buf = NULL;
|
||||
SEncoder encoder = {0};
|
||||
tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code);
|
||||
|
|
@ -238,7 +265,7 @@ int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
|
|||
goto END;
|
||||
}
|
||||
|
||||
TQ_ERR_GO_TO_END(tqMetaSaveInfo(pTq, pTq->pExecStore, key, (int)strlen(key), buf, vlen));
|
||||
TQ_ERR_GO_TO_END(tqMetaSaveInfo(pTq, pTq->pExecStore, key, strlen(key), buf, vlen));
|
||||
|
||||
END:
|
||||
tEncoderClear(&encoder);
|
||||
|
|
@ -247,6 +274,9 @@ END:
|
|||
}
|
||||
|
||||
static int tqMetaInitHandle(STQ* pTq, STqHandle* handle) {
|
||||
if (pTq == NULL || handle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
|
||||
SVnode* pVnode = pTq->pVnode;
|
||||
|
|
@ -318,7 +348,10 @@ END:
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t tqMetaRestoreHandle(STQ* pTq, void* pVal, int vLen, STqHandle* handle) {
|
||||
static int32_t tqMetaRestoreHandle(STQ* pTq, void* pVal, uint32_t vLen, STqHandle* handle) {
|
||||
if (pTq == NULL || pVal == NULL || handle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
SDecoder decoder = {0};
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
|
|
@ -335,6 +368,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqMetaCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle) {
|
||||
if (pTq == NULL || req == NULL || handle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
||||
(void)memcpy(handle->subKey, req->subKey, TSDB_SUBSCRIBE_KEY_LEN);
|
||||
|
|
@ -375,6 +411,9 @@ int32_t tqMetaCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle) {
|
|||
}
|
||||
|
||||
static int32_t tqMetaTransformInfo(TDB* pMetaDB, TTB* pOld, TTB* pNew) {
|
||||
if (pMetaDB == NULL || pOld == NULL || pNew == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
TBC* pCur = NULL;
|
||||
void* pKey = NULL;
|
||||
int kLen = 0;
|
||||
|
|
@ -404,6 +443,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqMetaGetHandle(STQ* pTq, const char* key, STqHandle** pHandle) {
|
||||
if (pTq == NULL || key == NULL || pHandle == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* data = taosHashGet(pTq->pHandle, key, strlen(key));
|
||||
if (data == NULL) {
|
||||
int vLen = 0;
|
||||
|
|
@ -412,7 +454,7 @@ int32_t tqMetaGetHandle(STQ* pTq, const char* key, STqHandle** pHandle) {
|
|||
return TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
|
||||
}
|
||||
STqHandle handle = {0};
|
||||
if (tqMetaRestoreHandle(pTq, data, vLen, &handle) != 0) {
|
||||
if (tqMetaRestoreHandle(pTq, data, vLen >= 0 ? vLen : 0, &handle) != 0) {
|
||||
tdbFree(data);
|
||||
tqDestroyTqHandle(&handle);
|
||||
return TSDB_CODE_OUT_OF_MEMORY;
|
||||
|
|
@ -429,6 +471,9 @@ int32_t tqMetaGetHandle(STQ* pTq, const char* key, STqHandle** pHandle) {
|
|||
}
|
||||
|
||||
int32_t tqMetaOpenTdb(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
TQ_ERR_GO_TO_END(tdbOpen(pTq->path, 16 * 1024, 1, &pTq->pMetaDB, 0, 0, NULL));
|
||||
TQ_ERR_GO_TO_END(tdbTbOpen("tq.db", -1, -1, NULL, pTq->pMetaDB, &pTq->pExecStore, 0));
|
||||
|
|
@ -440,6 +485,9 @@ END:
|
|||
}
|
||||
|
||||
static int32_t replaceTqPath(char** path) {
|
||||
if (path == NULL || *path == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
char* tpath = NULL;
|
||||
int32_t code = tqBuildFName(&tpath, *path, TQ_SUBSCRIBE_NAME);
|
||||
if (code != 0) {
|
||||
|
|
@ -451,6 +499,9 @@ static int32_t replaceTqPath(char** path) {
|
|||
}
|
||||
|
||||
static int32_t tqMetaRestoreCheckInfo(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
TBC* pCur = NULL;
|
||||
void* pKey = NULL;
|
||||
int kLen = 0;
|
||||
|
|
@ -463,7 +514,7 @@ static int32_t tqMetaRestoreCheckInfo(STQ* pTq) {
|
|||
TQ_ERR_GO_TO_END(tdbTbcMoveToFirst(pCur));
|
||||
|
||||
while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) {
|
||||
TQ_ERR_GO_TO_END(tqMetaDecodeCheckInfo(&info, pVal, vLen));
|
||||
TQ_ERR_GO_TO_END(tqMetaDecodeCheckInfo(&info, pVal, vLen >= 0 ? vLen : 0));
|
||||
TQ_ERR_GO_TO_END(taosHashPut(pTq->pCheckInfo, info.topic, strlen(info.topic), &info, sizeof(STqCheckInfo)));
|
||||
}
|
||||
info.colIdList = NULL;
|
||||
|
|
@ -477,6 +528,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqMetaOpen(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
char* maindb = NULL;
|
||||
char* offsetNew = NULL;
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
|
|
@ -504,6 +558,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqMetaTransform(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
TDB* pMetaDB = NULL;
|
||||
TTB* pExecStore = NULL;
|
||||
|
|
@ -543,6 +600,9 @@ END:
|
|||
}
|
||||
|
||||
void tqMetaClose(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t ret = 0;
|
||||
if (pTq->pExecStore) {
|
||||
tdbTbClose(pTq->pExecStore);
|
||||
|
|
|
|||
|
|
@ -17,6 +17,9 @@
|
|||
#include "tq.h"
|
||||
|
||||
int32_t tqBuildFName(char** data, const char* path, char* name) {
|
||||
if (data == NULL || path == NULL || name == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t len = strlen(path) + strlen(name) + 2;
|
||||
char* fname = taosMemoryCalloc(1, len);
|
||||
if(fname == NULL) {
|
||||
|
|
@ -33,6 +36,9 @@ int32_t tqBuildFName(char** data, const char* path, char* name) {
|
|||
}
|
||||
|
||||
int32_t tqOffsetRestoreFromFile(STQ* pTq, char* name) {
|
||||
if (pTq == NULL || name == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = TDB_CODE_SUCCESS;
|
||||
void* pMemBuf = NULL;
|
||||
|
||||
|
|
@ -54,6 +60,10 @@ int32_t tqOffsetRestoreFromFile(STQ* pTq, char* name) {
|
|||
}
|
||||
total += INT_BYTES;
|
||||
size = htonl(size);
|
||||
if (size <= 0) {
|
||||
code = TSDB_CODE_INVALID_MSG;
|
||||
goto END;
|
||||
}
|
||||
pMemBuf = taosMemoryCalloc(1, size);
|
||||
if (pMemBuf == NULL) {
|
||||
code = terrno;
|
||||
|
|
|
|||
|
|
@ -17,6 +17,9 @@
|
|||
#include "vnd.h"
|
||||
|
||||
int32_t tqProcessSubmitReqForSubscribe(STQ* pTq) {
|
||||
if (pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
if (taosHashGetSize(pTq->pPushMgr) <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -64,6 +67,9 @@ int32_t tqPushMsg(STQ* pTq, tmsg_t msgType) {
|
|||
}
|
||||
|
||||
int32_t tqRegisterPushHandle(STQ* pTq, void* handle, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || handle == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
STqHandle* pHandle = (STqHandle*)handle;
|
||||
|
||||
|
|
@ -101,6 +107,9 @@ int32_t tqRegisterPushHandle(STQ* pTq, void* handle, SRpcMsg* pMsg) {
|
|||
}
|
||||
|
||||
void tqUnregisterPushHandle(STQ* pTq, void *handle) {
|
||||
if (pTq == NULL || handle == NULL) {
|
||||
return;
|
||||
}
|
||||
STqHandle *pHandle = (STqHandle*)handle;
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,9 @@
|
|||
#include "tq.h"
|
||||
|
||||
bool isValValidForTable(STqHandle* pHandle, SWalCont* pHead) {
|
||||
if (pHandle == NULL || pHead == NULL) {
|
||||
return false;
|
||||
}
|
||||
if (pHandle->execHandle.subType != TOPIC_SUB_TYPE__TABLE) {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -198,6 +201,9 @@ end:
|
|||
}
|
||||
|
||||
int32_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, uint64_t reqId) {
|
||||
if (pTq == NULL || pHandle == NULL || fetchOffset == NULL) {
|
||||
return -1;
|
||||
}
|
||||
int32_t code = -1;
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
int64_t id = pHandle->pWalReader->readerId;
|
||||
|
|
@ -259,9 +265,17 @@ END:
|
|||
return code;
|
||||
}
|
||||
|
||||
bool tqGetTablePrimaryKey(STqReader* pReader) { return pReader->hasPrimaryKey; }
|
||||
bool tqGetTablePrimaryKey(STqReader* pReader) {
|
||||
if (pReader == NULL) {
|
||||
return false;
|
||||
}
|
||||
return pReader->hasPrimaryKey;
|
||||
}
|
||||
|
||||
void tqSetTablePrimaryKey(STqReader* pReader, int64_t uid) {
|
||||
if (pReader == NULL) {
|
||||
return;
|
||||
}
|
||||
bool ret = false;
|
||||
SSchemaWrapper* schema = metaGetTableSchema(pReader->pVnodeMeta, uid, -1, 1, NULL);
|
||||
if (schema && schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY) {
|
||||
|
|
@ -272,6 +286,9 @@ void tqSetTablePrimaryKey(STqReader* pReader, int64_t uid) {
|
|||
}
|
||||
|
||||
STqReader* tqReaderOpen(SVnode* pVnode) {
|
||||
if (pVnode == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
STqReader* pReader = taosMemoryCalloc(1, sizeof(STqReader));
|
||||
if (pReader == NULL) {
|
||||
return NULL;
|
||||
|
|
@ -323,6 +340,9 @@ void tqReaderClose(STqReader* pReader) {
|
|||
}
|
||||
|
||||
int32_t tqReaderSeek(STqReader* pReader, int64_t ver, const char* id) {
|
||||
if (pReader == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
if (walReaderSeekVer(pReader->pWalReader, ver) < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -406,6 +426,9 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
|
|||
}
|
||||
|
||||
bool tqNextBlockInWal(STqReader* pReader, const char* id, int sourceExcluded) {
|
||||
if (pReader == NULL) {
|
||||
return false;
|
||||
}
|
||||
SWalReader* pWalReader = pReader->pWalReader;
|
||||
|
||||
int64_t st = taosGetTimestampMs();
|
||||
|
|
@ -462,6 +485,9 @@ bool tqNextBlockInWal(STqReader* pReader, const char* id, int sourceExcluded) {
|
|||
}
|
||||
|
||||
int32_t tqReaderSetSubmitMsg(STqReader* pReader, void* msgStr, int32_t msgLen, int64_t ver) {
|
||||
if (pReader == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
pReader->msg.msgStr = msgStr;
|
||||
pReader->msg.msgLen = msgLen;
|
||||
pReader->msg.ver = ver;
|
||||
|
|
@ -481,14 +507,29 @@ int32_t tqReaderSetSubmitMsg(STqReader* pReader, void* msgStr, int32_t msgLen, i
|
|||
return 0;
|
||||
}
|
||||
|
||||
SWalReader* tqGetWalReader(STqReader* pReader) { return pReader->pWalReader; }
|
||||
SWalReader* tqGetWalReader(STqReader* pReader) {
|
||||
if (pReader == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
return pReader->pWalReader;
|
||||
}
|
||||
|
||||
SSDataBlock* tqGetResultBlock(STqReader* pReader) { return pReader->pResBlock; }
|
||||
SSDataBlock* tqGetResultBlock(STqReader* pReader) {
|
||||
if (pReader == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
return pReader->pResBlock;
|
||||
}
|
||||
|
||||
int64_t tqGetResultBlockTime(STqReader* pReader) { return pReader->lastTs; }
|
||||
int64_t tqGetResultBlockTime(STqReader* pReader) {
|
||||
if (pReader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
return pReader->lastTs;
|
||||
}
|
||||
|
||||
bool tqNextBlockImpl(STqReader* pReader, const char* idstr) {
|
||||
if (pReader->msg.msgStr == NULL) {
|
||||
if (pReader == NULL || pReader->msg.msgStr == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -525,7 +566,7 @@ bool tqNextBlockImpl(STqReader* pReader, const char* idstr) {
|
|||
}
|
||||
|
||||
bool tqNextDataBlockFilterOut(STqReader* pReader, SHashObj* filterOutUids) {
|
||||
if (pReader->msg.msgStr == NULL) return false;
|
||||
if (pReader == NULL || pReader->msg.msgStr == NULL) return false;
|
||||
|
||||
int32_t blockSz = taosArrayGetSize(pReader->submit.aSubmitTbData);
|
||||
while (pReader->nextBlk < blockSz) {
|
||||
|
|
@ -548,6 +589,9 @@ bool tqNextDataBlockFilterOut(STqReader* pReader, SHashObj* filterOutUids) {
|
|||
}
|
||||
|
||||
int32_t tqMaskBlock(SSchemaWrapper* pDst, SSDataBlock* pBlock, const SSchemaWrapper* pSrc, char* mask) {
|
||||
if (pDst == NULL || pBlock == NULL || pSrc == NULL || mask == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
|
||||
int32_t cnt = 0;
|
||||
|
|
@ -577,6 +621,9 @@ int32_t tqMaskBlock(SSchemaWrapper* pDst, SSDataBlock* pBlock, const SSchemaWrap
|
|||
}
|
||||
|
||||
static int32_t buildResSDataBlock(STqReader* pReader, SSchemaWrapper* pSchema, const SArray* pColIdList) {
|
||||
if (pReader == NULL || pSchema == NULL || pColIdList == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SSDataBlock* pBlock = pReader->pResBlock;
|
||||
if (blockDataGetNumOfCols(pBlock) > 0) {
|
||||
blockDataDestroy(pBlock);
|
||||
|
|
@ -659,6 +706,9 @@ static int32_t doSetVal(SColumnInfoData* pColumnInfoData, int32_t rowIndex, SCol
|
|||
}
|
||||
|
||||
int32_t tqRetrieveDataBlock(STqReader* pReader, SSDataBlock** pRes, const char* id) {
|
||||
if (pReader == NULL || pRes == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
tqTrace("tq reader retrieve data block %p, index:%d", pReader->msg.msgStr, pReader->nextBlk);
|
||||
int32_t code = 0;
|
||||
int32_t line = 0;
|
||||
|
|
@ -825,6 +875,10 @@ END:
|
|||
static int32_t processBuildNew(STqReader* pReader, SSubmitTbData* pSubmitTbData, SArray* blocks, SArray* schemas,
|
||||
SSchemaWrapper* pSchemaWrapper, char* assigned, int32_t numOfRows, int32_t curRow,
|
||||
int32_t* lastRow) {
|
||||
if (pReader == NULL || pSubmitTbData == NULL || blocks == NULL || schemas == NULL || pSchemaWrapper == NULL ||
|
||||
assigned == NULL || lastRow == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
SSchemaWrapper* pSW = NULL;
|
||||
SSDataBlock* block = NULL;
|
||||
|
|
@ -860,6 +914,9 @@ END:
|
|||
return code;
|
||||
}
|
||||
static int32_t tqProcessColData(STqReader* pReader, SSubmitTbData* pSubmitTbData, SArray* blocks, SArray* schemas) {
|
||||
if (pReader == NULL || pSubmitTbData == NULL || blocks == NULL || schemas == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
int32_t curRow = 0;
|
||||
int32_t lastRow = 0;
|
||||
|
|
@ -919,6 +976,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqProcessRowData(STqReader* pReader, SSubmitTbData* pSubmitTbData, SArray* blocks, SArray* schemas) {
|
||||
if (pReader == NULL || pSubmitTbData == NULL || blocks == NULL || schemas == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STSchema* pTSchema = NULL;
|
||||
|
||||
|
|
@ -976,6 +1036,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqRetrieveTaosxBlock(STqReader* pReader, SArray* blocks, SArray* schemas, SSubmitTbData** pSubmitTbDataRet, int64_t *createTime) {
|
||||
if (pReader == NULL || blocks == NULL || schemas == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
tqTrace("tq reader retrieve data block %p, %d", pReader->msg.msgStr, pReader->nextBlk);
|
||||
SSubmitTbData* pSubmitTbData = taosArrayGet(pReader->submit.aSubmitTbData, pReader->nextBlk);
|
||||
if (pSubmitTbData == NULL) {
|
||||
|
|
@ -1007,9 +1070,17 @@ int32_t tqRetrieveTaosxBlock(STqReader* pReader, SArray* blocks, SArray* schemas
|
|||
}
|
||||
}
|
||||
|
||||
void tqReaderSetColIdList(STqReader* pReader, SArray* pColIdList) { pReader->pColIdList = pColIdList; }
|
||||
void tqReaderSetColIdList(STqReader* pReader, SArray* pColIdList) {
|
||||
if (pReader == NULL){
|
||||
return;
|
||||
}
|
||||
pReader->pColIdList = pColIdList;
|
||||
}
|
||||
|
||||
void tqReaderSetTbUidList(STqReader* pReader, const SArray* tbUidList, const char* id) {
|
||||
if (pReader == NULL || tbUidList == NULL) {
|
||||
return;
|
||||
}
|
||||
if (pReader->tbIdHash) {
|
||||
taosHashClear(pReader->tbIdHash);
|
||||
} else {
|
||||
|
|
@ -1032,6 +1103,9 @@ void tqReaderSetTbUidList(STqReader* pReader, const SArray* tbUidList, const cha
|
|||
}
|
||||
|
||||
void tqReaderAddTbUidList(STqReader* pReader, const SArray* pTableUidList) {
|
||||
if (pReader == NULL || pTableUidList == NULL) {
|
||||
return;
|
||||
}
|
||||
if (pReader->tbIdHash == NULL) {
|
||||
pReader->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
|
||||
if (pReader->tbIdHash == NULL) {
|
||||
|
|
@ -1051,12 +1125,23 @@ void tqReaderAddTbUidList(STqReader* pReader, const SArray* pTableUidList) {
|
|||
}
|
||||
|
||||
bool tqReaderIsQueriedTable(STqReader* pReader, uint64_t uid) {
|
||||
return taosHashGet(pReader->tbIdHash, &uid, sizeof(uint64_t));
|
||||
if (pReader == NULL) {
|
||||
return false;
|
||||
}
|
||||
return taosHashGet(pReader->tbIdHash, &uid, sizeof(uint64_t)) != NULL;
|
||||
}
|
||||
|
||||
bool tqCurrentBlockConsumed(const STqReader* pReader) { return pReader->msg.msgStr == NULL; }
|
||||
bool tqCurrentBlockConsumed(const STqReader* pReader) {
|
||||
if (pReader == NULL) {
|
||||
return false;
|
||||
}
|
||||
return pReader->msg.msgStr == NULL;
|
||||
}
|
||||
|
||||
void tqReaderRemoveTbUidList(STqReader* pReader, const SArray* tbUidList) {
|
||||
if (pReader == NULL || tbUidList == NULL) {
|
||||
return;
|
||||
}
|
||||
for (int32_t i = 0; i < taosArrayGetSize(tbUidList); i++) {
|
||||
int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
|
||||
if (pKey && taosHashRemove(pReader->tbIdHash, pKey, sizeof(int64_t)) != 0) {
|
||||
|
|
@ -1066,6 +1151,9 @@ void tqReaderRemoveTbUidList(STqReader* pReader, const SArray* tbUidList) {
|
|||
}
|
||||
|
||||
int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
|
||||
if (pTq == NULL || tbUidList == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
void* pIter = NULL;
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,9 @@
|
|||
#include "tq.h"
|
||||
|
||||
int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols, int8_t precision) {
|
||||
if (pBlock == NULL || pRsp == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
|
||||
int32_t dataStrLen = sizeof(SRetrieveTableRspForTmq) + dataEncodeBufSize;
|
||||
void* buf = taosMemoryCalloc(1, dataStrLen);
|
||||
|
|
@ -47,18 +50,10 @@ int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, SMqDataRsp* pRsp) {
|
||||
SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pTqReader->pSchemaWrapper);
|
||||
if (pSW == NULL) {
|
||||
return terrno;
|
||||
}
|
||||
if (taosArrayPush(pRsp->blockSchema, &pSW) == NULL) {
|
||||
return terrno;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp, int32_t n) {
|
||||
if (pRsp == NULL || pTq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
SMetaReader mr = {0};
|
||||
metaReaderDoInit(&mr, pTq->pVnode->pMeta, META_READER_LOCK);
|
||||
|
||||
|
|
@ -84,6 +79,9 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp, i
|
|||
}
|
||||
|
||||
int32_t getDataBlock(qTaskInfo_t task, const STqHandle* pHandle, int32_t vgId, SSDataBlock** res) {
|
||||
if (task == NULL || pHandle == NULL || res == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
uint64_t ts = 0;
|
||||
qStreamSetOpen(task);
|
||||
|
||||
|
|
@ -99,6 +97,9 @@ int32_t getDataBlock(qTaskInfo_t task, const STqHandle* pHandle, int32_t vgId, S
|
|||
}
|
||||
|
||||
int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset, const SMqPollReq* pRequest) {
|
||||
if (pTq == NULL || pHandle == NULL || pRsp == NULL || pOffset == NULL || pRequest == NULL){
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
int32_t code = 0;
|
||||
int32_t line = 0;
|
||||
|
|
@ -189,6 +190,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, SMqBatchMetaRsp* pBatchMetaRsp, STqOffsetVal* pOffset) {
|
||||
if (pTq == NULL || pHandle == NULL || pRsp == NULL || pBatchMetaRsp == NULL || pOffset == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
const STqExecHandle* pExec = &pHandle->execHandle;
|
||||
qTaskInfo_t task = pExec->task;
|
||||
int code = qStreamPrepareScan(task, pOffset, pHandle->execHandle.subType);
|
||||
|
|
@ -280,6 +284,9 @@ int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, SMqBat
|
|||
}
|
||||
|
||||
static int32_t buildCreateTbInfo(SMqDataRsp* pRsp, SVCreateTbReq* pCreateTbReq){
|
||||
if (pRsp == NULL || pCreateTbReq == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void* createReq = NULL;
|
||||
if (pRsp->createTableNum == 0) {
|
||||
|
|
@ -329,6 +336,9 @@ END:
|
|||
}
|
||||
|
||||
static void tqProcessSubData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, int32_t* totalRows, int8_t sourceExcluded){
|
||||
if (pTq == NULL || pHandle == NULL || pRsp == NULL || totalRows == NULL) {
|
||||
return;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STqExecHandle* pExec = &pHandle->execHandle;
|
||||
STqReader* pReader = pExec->pTqReader;
|
||||
|
|
@ -407,6 +417,9 @@ END:
|
|||
|
||||
int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, SMqDataRsp* pRsp, int32_t* totalRows,
|
||||
int8_t sourceExcluded) {
|
||||
if (pTq == NULL || pHandle == NULL || pRsp == NULL || totalRows == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
STqExecHandle* pExec = &pHandle->execHandle;
|
||||
int32_t code = 0;
|
||||
STqReader* pReader = pExec->pTqReader;
|
||||
|
|
|
|||
|
|
@ -27,6 +27,9 @@ struct STqSnapReader {
|
|||
};
|
||||
|
||||
int32_t tqSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, int8_t type, STqSnapReader** ppReader) {
|
||||
if (pTq == NULL || ppReader == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STqSnapReader* pReader = NULL;
|
||||
|
||||
|
|
@ -77,12 +80,18 @@ _err:
|
|||
}
|
||||
|
||||
void tqSnapReaderClose(STqSnapReader** ppReader) {
|
||||
if (ppReader == NULL || *ppReader == NULL) {
|
||||
return;
|
||||
}
|
||||
tdbTbcClose((*ppReader)->pCur);
|
||||
taosMemoryFree(*ppReader);
|
||||
*ppReader = NULL;
|
||||
}
|
||||
|
||||
int32_t tqSnapRead(STqSnapReader* pReader, uint8_t** ppData) {
|
||||
if (pReader == NULL || ppData == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
void* pKey = NULL;
|
||||
void* pVal = NULL;
|
||||
|
|
@ -126,6 +135,9 @@ struct STqSnapWriter {
|
|||
};
|
||||
|
||||
int32_t tqSnapWriterOpen(STQ* pTq, int64_t sver, int64_t ever, STqSnapWriter** ppWriter) {
|
||||
if (pTq == NULL || ppWriter == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STqSnapWriter* pWriter = NULL;
|
||||
|
||||
|
|
@ -156,6 +168,9 @@ _err:
|
|||
}
|
||||
|
||||
int32_t tqSnapWriterClose(STqSnapWriter** ppWriter, int8_t rollback) {
|
||||
if (ppWriter == NULL || *ppWriter == NULL) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STqSnapWriter* pWriter = *ppWriter;
|
||||
STQ* pTq = pWriter->pTq;
|
||||
|
|
@ -180,6 +195,9 @@ _err:
|
|||
}
|
||||
|
||||
int32_t tqSnapHandleWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
|
||||
if (pWriter == NULL || pData == NULL || nData < sizeof(SSnapDataHdr)) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STQ* pTq = pWriter->pTq;
|
||||
SDecoder decoder = {0};
|
||||
|
|
@ -190,7 +208,7 @@ int32_t tqSnapHandleWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData
|
|||
code = tDecodeSTqHandle(pDecoder, &handle);
|
||||
if (code) goto end;
|
||||
taosWLockLatch(&pTq->lock);
|
||||
code = tqMetaSaveInfo(pTq, pTq->pExecStore, handle.subKey, (int)strlen(handle.subKey), pData + sizeof(SSnapDataHdr),
|
||||
code = tqMetaSaveInfo(pTq, pTq->pExecStore, handle.subKey, strlen(handle.subKey), pData + sizeof(SSnapDataHdr),
|
||||
nData - sizeof(SSnapDataHdr));
|
||||
taosWUnLockLatch(&pTq->lock);
|
||||
|
||||
|
|
@ -202,6 +220,9 @@ end:
|
|||
}
|
||||
|
||||
int32_t tqSnapCheckInfoWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
|
||||
if (pWriter == NULL || pData == NULL || nData < sizeof(SSnapDataHdr)) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STQ* pTq = pWriter->pTq;
|
||||
STqCheckInfo info = {0};
|
||||
|
|
@ -223,6 +244,9 @@ _err:
|
|||
}
|
||||
|
||||
int32_t tqSnapOffsetWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
|
||||
if (pWriter == NULL || pData == NULL || nData < sizeof(SSnapDataHdr)) {
|
||||
return TSDB_CODE_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STQ* pTq = pWriter->pTq;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,9 @@ static int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, c
|
|||
const SMqBatchMetaRsp* pRsp, int32_t vgId);
|
||||
|
||||
int32_t tqInitDataRsp(SMqDataRsp* pRsp, STqOffsetVal pOffset) {
|
||||
if (pRsp == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
pRsp->blockData = taosArrayInit(0, sizeof(void*));
|
||||
pRsp->blockDataLen = taosArrayInit(0, sizeof(int32_t));
|
||||
|
||||
|
|
@ -41,6 +44,9 @@ void tqUpdateNodeStage(STQ* pTq, bool isLeader) {
|
|||
}
|
||||
|
||||
static int32_t tqInitTaosxRsp(SMqDataRsp* pRsp, STqOffsetVal pOffset) {
|
||||
if (pRsp == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
tOffsetCopy(&pRsp->reqOffset, &pOffset);
|
||||
tOffsetCopy(&pRsp->rspOffset, &pOffset);
|
||||
|
||||
|
|
@ -81,6 +87,9 @@ static int32_t tqInitTaosxRsp(SMqDataRsp* pRsp, STqOffsetVal pOffset) {
|
|||
|
||||
static int32_t extractResetOffsetVal(STqOffsetVal* pOffsetVal, STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest,
|
||||
SRpcMsg* pMsg, bool* pBlockReturned) {
|
||||
if (pOffsetVal == NULL || pTq == NULL || pHandle == NULL || pRequest == NULL || pMsg == NULL || pBlockReturned == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
uint64_t consumerId = pRequest->consumerId;
|
||||
STqOffset* pOffset = NULL;
|
||||
int32_t code = tqMetaGetOffset(pTq, pRequest->subKey, &pOffset);
|
||||
|
|
@ -142,6 +151,9 @@ static int32_t extractResetOffsetVal(STqOffsetVal* pOffsetVal, STQ* pTq, STqHand
|
|||
|
||||
static int32_t extractDataAndRspForNormalSubscribe(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest,
|
||||
SRpcMsg* pMsg, STqOffsetVal* pOffset) {
|
||||
if (pTq == NULL || pHandle == NULL || pRequest == NULL || pMsg == NULL || pOffset == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
uint64_t consumerId = pRequest->consumerId;
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
terrno = 0;
|
||||
|
|
@ -212,6 +224,9 @@ static void tDeleteCommon(void* parm) {}
|
|||
|
||||
static int32_t extractDataAndRspForDbStbSubscribe(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest,
|
||||
SRpcMsg* pMsg, STqOffsetVal* offset) {
|
||||
if (pTq == NULL || pHandle == NULL || pRequest == NULL || pMsg == NULL || offset == NULL) {
|
||||
return TSDB_CODE_INVALID_PARA;
|
||||
}
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
SMqDataRsp taosxRsp = {0};
|
||||
SMqBatchMetaRsp btMetaRsp = {0};
|
||||
|
|
@ -410,6 +425,9 @@ END:
|
|||
}
|
||||
|
||||
int32_t tqExtractDataForMq(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest, SRpcMsg* pMsg) {
|
||||
if (pTq == NULL || pHandle == NULL || pRequest == NULL || pMsg == NULL) {
|
||||
return TSDB_CODE_TMQ_INVALID_MSG;
|
||||
}
|
||||
int32_t code = 0;
|
||||
STqOffsetVal reqOffset = {0};
|
||||
tOffsetCopy(&reqOffset, &pRequest->reqOffset);
|
||||
|
|
@ -445,6 +463,9 @@ END:
|
|||
|
||||
static void initMqRspHead(SMqRspHead* pMsgHead, int32_t type, int32_t epoch, int64_t consumerId, int64_t sver,
|
||||
int64_t ever) {
|
||||
if (pMsgHead == NULL) {
|
||||
return;
|
||||
}
|
||||
pMsgHead->consumerId = consumerId;
|
||||
pMsgHead->epoch = epoch;
|
||||
pMsgHead->mqMsgType = type;
|
||||
|
|
@ -454,6 +475,9 @@ static void initMqRspHead(SMqRspHead* pMsgHead, int32_t type, int32_t epoch, int
|
|||
|
||||
int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq,
|
||||
const SMqBatchMetaRsp* pRsp, int32_t vgId) {
|
||||
if (pHandle == NULL || pMsg == NULL || pReq == NULL || pRsp == NULL) {
|
||||
return TSDB_CODE_TMQ_INVALID_MSG;
|
||||
}
|
||||
int32_t len = 0;
|
||||
int32_t code = 0;
|
||||
tEncodeSize(tEncodeMqBatchMetaRsp, pRsp, len, code);
|
||||
|
|
@ -491,6 +515,9 @@ int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SM
|
|||
|
||||
int32_t tqSendMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqMetaRsp* pRsp,
|
||||
int32_t vgId) {
|
||||
if (pHandle == NULL || pMsg == NULL || pReq == NULL || pRsp == NULL) {
|
||||
return TSDB_CODE_TMQ_INVALID_MSG;
|
||||
}
|
||||
int32_t len = 0;
|
||||
int32_t code = 0;
|
||||
tEncodeSize(tEncodeMqMetaRsp, pRsp, len, code);
|
||||
|
|
@ -529,6 +556,9 @@ int32_t tqSendMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPoll
|
|||
|
||||
int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const SMqDataRsp* pRsp, int32_t epoch, int64_t consumerId,
|
||||
int32_t type, int64_t sver, int64_t ever) {
|
||||
if (pRpcHandleInfo == NULL || pRsp == NULL) {
|
||||
return TSDB_CODE_TMQ_INVALID_MSG;
|
||||
}
|
||||
int32_t len = 0;
|
||||
int32_t code = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -368,7 +368,7 @@ int32_t qBindStmtStbColsValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind
|
|||
// }
|
||||
}
|
||||
|
||||
code = tRowBuildFromBind(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols);
|
||||
code = tRowBuildFromBind(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs);
|
||||
|
||||
qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum);
|
||||
|
||||
|
|
@ -745,7 +745,7 @@ int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bin
|
|||
pBindInfos[c].bytes = pColSchema->bytes;
|
||||
}
|
||||
|
||||
code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols);
|
||||
code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs);
|
||||
|
||||
qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum);
|
||||
|
||||
|
|
|
|||
|
|
@ -1491,7 +1491,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader,
|
|||
ofpCell = tdbPageGetCell(ofp, 0);
|
||||
|
||||
int lastKeyPage = 0;
|
||||
if (nLeftKey <= maxLocal - sizeof(SPgno)) {
|
||||
if (nLeftKey <= ofp->maxLocal - sizeof(SPgno)) {
|
||||
bytes = nLeftKey;
|
||||
lastKeyPage = 1;
|
||||
lastKeyPageSpace = ofp->maxLocal - sizeof(SPgno) - nLeftKey;
|
||||
|
|
|
|||
|
|
@ -315,6 +315,7 @@
|
|||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_ts5466.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_ts-5473.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/td-32187.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/td-33225.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_ts4563.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_td32526.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_replay.py
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@ exe:
|
|||
# gcc $(CFLAGS) ./stmt2-get-fields.c -o $(ROOT)stmt2-get-fields $(LFLAGS)
|
||||
# gcc $(CFLAGS) ./stmt2-nohole.c -o $(ROOT)stmt2-nohole $(LFLAGS)
|
||||
gcc $(CFLAGS) ./stmt-crash.c -o $(ROOT)stmt-crash $(LFLAGS)
|
||||
gcc $(CFLAGS) ./stmt-insert-dupkeys.c -o $(ROOT)stmt-insert-dupkeys $(LFLAGS)
|
||||
gcc $(CFLAGS) ./stmt2-insert-dupkeys.c -o $(ROOT)stmt2-insert-dupkeys $(LFLAGS)
|
||||
|
||||
clean:
|
||||
rm $(ROOT)batchprepare
|
||||
|
|
@ -47,3 +49,5 @@ clean:
|
|||
rm $(ROOT)stmt2-get-fields
|
||||
rm $(ROOT)stmt2-nohole
|
||||
rm $(ROOT)stmt-crash
|
||||
rm $(ROOT)stmt-insert-dupkeys
|
||||
rm $(ROOT)stmt2-insert-dupkeys
|
||||
|
|
|
|||
|
|
@ -0,0 +1,234 @@
|
|||
// compile with
|
||||
// gcc -o stmt-insert-dupkeys stmt-insert-dupkeys.c -ltaos
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "taos.h"
|
||||
|
||||
#define NUMROWS 3
|
||||
|
||||
/**
|
||||
* @brief execute sql only and ignore result set
|
||||
*
|
||||
* @param taos
|
||||
* @param sql
|
||||
*/
|
||||
void executeSQL(TAOS *taos, const char *sql) {
|
||||
TAOS_RES *res = taos_query(taos, sql);
|
||||
int code = taos_errno(res);
|
||||
if (code != 0) {
|
||||
printf("%s\n", taos_errstr(res));
|
||||
taos_free_result(res);
|
||||
taos_close(taos);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
taos_free_result(res);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief exit program when error occur.
|
||||
*
|
||||
* @param stmt
|
||||
* @param code
|
||||
* @param msg
|
||||
*/
|
||||
void checkErrorCode(TAOS_STMT *stmt, int code, const char *msg) {
|
||||
if (code != 0) {
|
||||
printf("%s. error: %s\n", msg, taos_stmt_errstr(stmt));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
void prepareBindTags(TAOS_MULTI_BIND *tags) {
|
||||
// bind table name and tags
|
||||
char *location = "California.SanFrancisco";
|
||||
int groupId = 2;
|
||||
tags[0].buffer_type = TSDB_DATA_TYPE_BINARY;
|
||||
tags[0].buffer_length = strlen(location);
|
||||
tags[0].length = (int32_t *)&tags[0].buffer_length;
|
||||
tags[0].buffer = location;
|
||||
tags[0].is_null = NULL;
|
||||
|
||||
tags[1].buffer_type = TSDB_DATA_TYPE_INT;
|
||||
tags[1].buffer_length = sizeof(int);
|
||||
tags[1].length = (int32_t *)&tags[1].buffer_length;
|
||||
tags[1].buffer = &groupId;
|
||||
tags[1].is_null = NULL;
|
||||
}
|
||||
|
||||
void prepareBindParams(TAOS_MULTI_BIND *params, int64_t *ts, float *current, int *voltage, float *phase) {
|
||||
// is_null array
|
||||
char is_null[NUMROWS] = {0};
|
||||
// length array
|
||||
int32_t int64Len[NUMROWS] = {sizeof(int64_t)};
|
||||
int32_t floatLen[NUMROWS] = {sizeof(float)};
|
||||
int32_t intLen[NUMROWS] = {sizeof(int)};
|
||||
|
||||
params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
|
||||
params[0].buffer_length = sizeof(int64_t);
|
||||
params[0].buffer = ts;
|
||||
params[0].length = int64Len;
|
||||
params[0].is_null = is_null;
|
||||
params[0].num = NUMROWS;
|
||||
|
||||
params[1].buffer_type = TSDB_DATA_TYPE_FLOAT;
|
||||
params[1].buffer_length = sizeof(float);
|
||||
params[1].buffer = current;
|
||||
params[1].length = floatLen;
|
||||
params[1].is_null = is_null;
|
||||
params[1].num = NUMROWS;
|
||||
|
||||
params[2].buffer_type = TSDB_DATA_TYPE_INT;
|
||||
params[2].buffer_length = sizeof(int);
|
||||
params[2].buffer = voltage;
|
||||
params[2].length = intLen;
|
||||
params[2].is_null = is_null;
|
||||
params[2].num = NUMROWS;
|
||||
|
||||
params[3].buffer_type = TSDB_DATA_TYPE_FLOAT;
|
||||
params[3].buffer_length = sizeof(float);
|
||||
params[3].buffer = phase;
|
||||
params[3].length = floatLen;
|
||||
params[3].is_null = is_null;
|
||||
params[3].num = NUMROWS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief insert data using stmt API
|
||||
*
|
||||
* @param taos
|
||||
*/
|
||||
void insertData(TAOS *taos, int64_t *ts, float *current, int *voltage, float *phase) {
|
||||
// init
|
||||
TAOS_STMT *stmt = taos_stmt_init(taos);
|
||||
|
||||
// prepare
|
||||
const char *sql = "INSERT INTO ? USING meters TAGS(?, ?) values(?, ?, ?, ?)";
|
||||
int code = taos_stmt_prepare(stmt, sql, 0);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_prepare");
|
||||
|
||||
// bind table name and tags
|
||||
TAOS_MULTI_BIND tags[2];
|
||||
prepareBindTags(tags);
|
||||
code = taos_stmt_set_tbname_tags(stmt, "d1001", tags);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_set_tbname_tags");
|
||||
|
||||
TAOS_MULTI_BIND params[4];
|
||||
prepareBindParams(params, ts, current, voltage, phase);
|
||||
|
||||
code = taos_stmt_bind_param_batch(stmt, params); // bind batch
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_bind_param_batch");
|
||||
|
||||
code = taos_stmt_add_batch(stmt); // add batch
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_add_batch");
|
||||
|
||||
// execute
|
||||
code = taos_stmt_execute(stmt);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_execute");
|
||||
|
||||
int affectedRows = taos_stmt_affected_rows(stmt);
|
||||
printf("successfully inserted %d rows\n", affectedRows);
|
||||
|
||||
// close
|
||||
(void)taos_stmt_close(stmt);
|
||||
}
|
||||
|
||||
void insertDataInterlace(TAOS *taos, int64_t *ts, float *current, int *voltage, float *phase) {
|
||||
// init with interlace mode
|
||||
TAOS_STMT_OPTIONS op;
|
||||
op.reqId = 0;
|
||||
op.singleStbInsert = true;
|
||||
op.singleTableBindOnce = true;
|
||||
TAOS_STMT *stmt = taos_stmt_init_with_options(taos, &op);
|
||||
|
||||
// prepare
|
||||
const char *sql = "INSERT INTO ? values(?, ?, ?, ?)";
|
||||
int code = taos_stmt_prepare(stmt, sql, 0);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_prepare");
|
||||
|
||||
// bind table name and tags
|
||||
TAOS_MULTI_BIND tags[2];
|
||||
prepareBindTags(tags);
|
||||
code = taos_stmt_set_tbname_tags(stmt, "d1001", tags);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_set_tbname_tags");
|
||||
|
||||
TAOS_MULTI_BIND params[4];
|
||||
prepareBindParams(params, ts, current, voltage, phase);
|
||||
|
||||
code = taos_stmt_bind_param_batch(stmt, params); // bind batch
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_bind_param_batch");
|
||||
|
||||
code = taos_stmt_add_batch(stmt); // add batch
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_add_batch");
|
||||
|
||||
// execute
|
||||
code = taos_stmt_execute(stmt);
|
||||
checkErrorCode(stmt, code, "failed to execute taos_stmt_execute");
|
||||
|
||||
int affectedRows = taos_stmt_affected_rows(stmt);
|
||||
printf("successfully inserted %d rows\n", affectedRows);
|
||||
|
||||
// close
|
||||
(void)taos_stmt_close(stmt);
|
||||
}
|
||||
|
||||
int main() {
|
||||
TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 6030);
|
||||
if (taos == NULL) {
|
||||
printf("failed to connect to server\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
executeSQL(taos, "DROP DATABASE IF EXISTS power");
|
||||
executeSQL(taos, "CREATE DATABASE power");
|
||||
executeSQL(taos, "USE power");
|
||||
executeSQL(taos,
|
||||
"CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), "
|
||||
"groupId INT)");
|
||||
|
||||
// initial insert, expect insert 3 rows
|
||||
int64_t ts0[] = {1648432611234, 1648432611345, 1648432611456};
|
||||
float current0[] = {10.1f, 10.2f, 10.3f};
|
||||
int voltage0[] = {216, 217, 218};
|
||||
float phase0[] = {0.31f, 0.32f, 0.33f};
|
||||
insertData(taos, ts0, current0, voltage0, phase0);
|
||||
|
||||
// insert with interlace mode, send non-duplicate ts, expect insert 3 overlapped rows
|
||||
int64_t ts1[] = {1648432611234, 1648432611345, 1648432611456};
|
||||
int voltage1[] = {219, 220, 221};
|
||||
insertDataInterlace(taos, ts1, current0, voltage1, phase0);
|
||||
|
||||
// insert with interlace mode, send duplicate ts, expect insert 2 rows with dups merged
|
||||
int64_t ts2[] = {1648432611678, 1648432611678, 1648432611789};
|
||||
int voltage2[] = {222, 223, 224};
|
||||
insertDataInterlace(taos, ts2, current0, voltage2, phase0);
|
||||
|
||||
// insert with interlace mode, send disordered rows, expect insert 3 sorted rows
|
||||
int64_t ts3[] = {1648432611900, 1648432611890, 1648432611910};
|
||||
int voltage3[] = {225, 226, 227};
|
||||
insertDataInterlace(taos, ts3, current0, voltage3, phase0);
|
||||
|
||||
// insert with interlace mode, send disordered and duplicate rows, expect insert 2 sorted and dup-merged rows
|
||||
int64_t ts4[] = {1648432611930, 1648432611920, 1648432611930};
|
||||
int voltage4[] = {228, 229, 230};
|
||||
insertDataInterlace(taos, ts4, current0, voltage4, phase0);
|
||||
|
||||
taos_close(taos);
|
||||
taos_cleanup();
|
||||
|
||||
// final results
|
||||
// taos> select * from d1001;
|
||||
// ts | current | voltage | phase |
|
||||
// ======================================================================================
|
||||
// 2022-03-28 09:56:51.234 | 10.1000004 | 219 | 0.3100000 |
|
||||
// 2022-03-28 09:56:51.345 | 10.1999998 | 220 | 0.3200000 |
|
||||
// 2022-03-28 09:56:51.456 | 10.3000002 | 221 | 0.3300000 |
|
||||
// 2022-03-28 09:56:51.678 | 10.1999998 | 223 | 0.3200000 |
|
||||
// 2022-03-28 09:56:51.789 | 10.3000002 | 224 | 0.3300000 |
|
||||
// 2022-03-28 09:56:51.890 | 10.1999998 | 226 | 0.3200000 |
|
||||
// 2022-03-28 09:56:51.900 | 10.1000004 | 225 | 0.3100000 |
|
||||
// 2022-03-28 09:56:51.910 | 10.3000002 | 227 | 0.3300000 |
|
||||
// 2022-03-28 09:56:51.920 | 10.1999998 | 229 | 0.3200000 |
|
||||
// 2022-03-28 09:56:51.930 | 10.3000002 | 230 | 0.3300000 |
|
||||
// Query OK, 10 row(s) in set (0.005083s)
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,235 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "taos.h"
|
||||
|
||||
int CTB_NUMS = 3;
|
||||
int ROW_NUMS = 3;
|
||||
|
||||
void do_query(TAOS* taos, const char* sql) {
|
||||
TAOS_RES* result = taos_query(taos, sql);
|
||||
int code = taos_errno(result);
|
||||
if (code) {
|
||||
printf("failed to query: %s, reason:%s\n", sql, taos_errstr(result));
|
||||
taos_free_result(result);
|
||||
return;
|
||||
}
|
||||
taos_free_result(result);
|
||||
}
|
||||
|
||||
void createdb(TAOS* taos) {
|
||||
do_query(taos, "drop database if exists db");
|
||||
do_query(taos, "create database db");
|
||||
do_query(taos, "create stable db.stb (ts timestamp, b binary(10)) tags(t1 int, t2 binary(10))");
|
||||
do_query(taos, "use db");
|
||||
}
|
||||
|
||||
#define INIT(tbs, ts, ts_len, b, b_len, tags, paramv) \
|
||||
do { \
|
||||
/* tbname */ \
|
||||
tbs = (char**)malloc(CTB_NUMS * sizeof(char*)); \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
tbs[i] = (char*)malloc(sizeof(char) * 20); \
|
||||
sprintf(tbs[i], "ctb_%d", i); \
|
||||
} \
|
||||
/* col params */ \
|
||||
ts = (int64_t**)malloc(CTB_NUMS * sizeof(int64_t*)); \
|
||||
b = (char**)malloc(CTB_NUMS * sizeof(char*)); \
|
||||
ts_len = (int*)malloc(ROW_NUMS * sizeof(int)); \
|
||||
b_len = (int*)malloc(ROW_NUMS * sizeof(int)); \
|
||||
for (int i = 0; i < ROW_NUMS; i++) { \
|
||||
ts_len[i] = sizeof(int64_t); \
|
||||
b_len[i] = 1; \
|
||||
} \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
ts[i] = (int64_t*)malloc(ROW_NUMS * sizeof(int64_t)); \
|
||||
b[i] = (char*)malloc(ROW_NUMS * sizeof(char)); \
|
||||
for (int j = 0; j < ROW_NUMS; j++) { \
|
||||
ts[i][j] = 1591060628000 + j; \
|
||||
b[i][j] = (char)('a' + j); \
|
||||
} \
|
||||
} \
|
||||
/*tag params */ \
|
||||
int t1 = 0; \
|
||||
int t1len = sizeof(int); \
|
||||
int t2len = 3; \
|
||||
/* bind params */ \
|
||||
paramv = (TAOS_STMT2_BIND**)malloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); \
|
||||
tags = (TAOS_STMT2_BIND**)malloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
/* create tags */ \
|
||||
tags[i] = (TAOS_STMT2_BIND*)malloc(2 * sizeof(TAOS_STMT2_BIND)); \
|
||||
tags[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; \
|
||||
tags[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, "after", &t2len, NULL, 0}; \
|
||||
/* create col params */ \
|
||||
paramv[i] = (TAOS_STMT2_BIND*)malloc(2 * sizeof(TAOS_STMT2_BIND)); \
|
||||
paramv[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS}; \
|
||||
paramv[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS}; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define UINIT(tbs, ts, ts_len, b, b_len, tags, paramv) \
|
||||
do { \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
free(tbs[i]); \
|
||||
} \
|
||||
free(tbs); \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
free(ts[i]); \
|
||||
free(b[i]); \
|
||||
} \
|
||||
free(ts); \
|
||||
free(b); \
|
||||
free(ts_len); \
|
||||
free(b_len); \
|
||||
for (int i = 0; i < CTB_NUMS; i++) { \
|
||||
free(tags[i]); \
|
||||
free(paramv[i]); \
|
||||
} \
|
||||
free(tags); \
|
||||
free(paramv); \
|
||||
} while (0)
|
||||
|
||||
void insert(TAOS* taos, char **tbs, TAOS_STMT2_BIND **tags, TAOS_STMT2_BIND **paramv, const char* sql)
|
||||
{
|
||||
clock_t start, end;
|
||||
double cpu_time_used;
|
||||
|
||||
TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL};
|
||||
TAOS_STMT2 *stmt = taos_stmt2_init(taos, &option);
|
||||
int code = taos_stmt2_prepare(stmt, sql, 0);
|
||||
if (code != 0) {
|
||||
printf("failed to execute taos_stmt2_prepare. error:%s\n", taos_stmt2_error(stmt));
|
||||
taos_stmt2_close(stmt);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// bind
|
||||
start = clock();
|
||||
TAOS_STMT2_BINDV bindv = {CTB_NUMS, tbs, tags, paramv};
|
||||
if (taos_stmt2_bind_param(stmt, &bindv, -1)) {
|
||||
printf("failed to execute taos_stmt2_bind_param statement.error:%s\n", taos_stmt2_error(stmt));
|
||||
taos_stmt2_close(stmt);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
end = clock();
|
||||
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
|
||||
printf("stmt2-bind [%s] insert Time used: %f seconds\n", sql, cpu_time_used);
|
||||
start = clock();
|
||||
|
||||
// exec
|
||||
if (taos_stmt2_exec(stmt, NULL)) {
|
||||
printf("failed to execute taos_stmt2_exec statement.error:%s\n", taos_stmt2_error(stmt));
|
||||
taos_stmt2_close(stmt);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
end = clock();
|
||||
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
|
||||
printf("stmt2-exec [%s] insert Time used: %f seconds\n", sql, cpu_time_used);
|
||||
|
||||
taos_stmt2_close(stmt);
|
||||
}
|
||||
|
||||
void insert_dist(TAOS* taos, const char *sql) {
|
||||
char **tbs, **b;
|
||||
int64_t **ts;
|
||||
int *ts_len, *b_len;
|
||||
TAOS_STMT2_BIND **paramv, **tags;
|
||||
|
||||
INIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
|
||||
insert(taos, tbs, tags, paramv, sql);
|
||||
|
||||
UINIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
}
|
||||
|
||||
void insert_dup_rows(TAOS* taos, const char *sql) {
|
||||
char **tbs, **b;
|
||||
int64_t **ts;
|
||||
int *ts_len, *b_len;
|
||||
TAOS_STMT2_BIND **paramv, **tags;
|
||||
|
||||
INIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
|
||||
// insert duplicate rows
|
||||
for (int i = 0; i < CTB_NUMS; i++) {
|
||||
for (int j = 0; j < ROW_NUMS; j++) {
|
||||
ts[i][j] = 1591060628000;
|
||||
b[i][j] = (char)('x' + j);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < CTB_NUMS; i++) {
|
||||
paramv[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS};
|
||||
paramv[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS};
|
||||
}
|
||||
insert(taos, tbs, tags, paramv, sql);
|
||||
|
||||
UINIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
}
|
||||
|
||||
void insert_dup_tables(TAOS* taos, const char *sql) {
|
||||
char **tbs, **b;
|
||||
int64_t **ts;
|
||||
int *ts_len, *b_len;
|
||||
TAOS_STMT2_BIND **paramv, **tags;
|
||||
|
||||
INIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
|
||||
for (int i = 0; i < CTB_NUMS; i++) {
|
||||
sprintf(tbs[i], "ctb_%d", i % 2);
|
||||
}
|
||||
|
||||
for (int i = 0; i < CTB_NUMS; i++) {
|
||||
paramv[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS};
|
||||
paramv[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS};
|
||||
}
|
||||
insert(taos, tbs, tags, paramv, sql);
|
||||
|
||||
UINIT(tbs, ts, ts_len, b, b_len, tags, paramv);
|
||||
}
|
||||
|
||||
int main() {
|
||||
TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0);
|
||||
if (!taos) {
|
||||
printf("failed to connect to db, reason:%s\n", taos_errstr(taos));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
createdb(taos);
|
||||
// insert distinct rows
|
||||
insert_dist(taos, "insert into db.? using db.stb tags(?,?)values(?,?)");
|
||||
// insert duplicate rows
|
||||
insert_dup_rows(taos, "insert into db.? values(?,?)");
|
||||
// insert duplicate tables
|
||||
insert_dup_tables(taos, "insert into db.? values(?,?)");
|
||||
|
||||
taos_close(taos);
|
||||
taos_cleanup();
|
||||
}
|
||||
|
||||
// final results
|
||||
// taos> select * from ctb_0;
|
||||
// ts | b |
|
||||
// =========================================
|
||||
// 2020-06-02 09:17:08.000 | z |
|
||||
// 2020-06-02 09:17:08.001 | b |
|
||||
// 2020-06-02 09:17:08.002 | c |
|
||||
// Query OK, 3 row(s) in set (0.003975s)
|
||||
//
|
||||
// taos> select * from ctb_1;
|
||||
// ts | b |
|
||||
// =========================================
|
||||
// 2020-06-02 09:17:08.000 | z |
|
||||
// 2020-06-02 09:17:08.001 | b |
|
||||
// 2020-06-02 09:17:08.002 | c |
|
||||
// Query OK, 3 row(s) in set (0.007241s)
|
||||
|
||||
// taos> select * from ctb_2;
|
||||
// ts | b |
|
||||
// =========================================
|
||||
// 2020-06-02 09:17:08.000 | z |
|
||||
// 2020-06-02 09:17:08.001 | b |
|
||||
// 2020-06-02 09:17:08.002 | c |
|
||||
// Query OK, 3 row(s) in set (0.005443s)
|
||||
|
|
@ -398,4 +398,204 @@ endi
|
|||
|
||||
print ===== step5 over
|
||||
|
||||
print ===== step6
|
||||
sql drop database if exists test6;
|
||||
sql create database test7 vgroups 1;
|
||||
sql use test7;
|
||||
sql create stable st(ts timestamp, a int, b int , c int, d double) tags(ta int,tb int,tc int);
|
||||
sql create table ts1 using st tags(1,1,1);
|
||||
|
||||
sql create stream streams8 trigger at_once IGNORE EXPIRED 0 IGNORE UPDATE 0 watermark 1d into streamt8 as select _wstart, count(*) c1 from st interval(10s);
|
||||
sql create stream streams9 trigger at_once IGNORE EXPIRED 0 IGNORE UPDATE 0 watermark 1d into streamt9 as select _wstart, count(*) c1 from st partition by tbname interval(10s);
|
||||
|
||||
run tsim/stream/checkTaskStatus.sim
|
||||
|
||||
$loop_count = 0
|
||||
loop7:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sleep 500
|
||||
|
||||
sql select status, * from information_schema.ins_streams where status != "ready";
|
||||
|
||||
if $rows != 0 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop7
|
||||
endi
|
||||
|
||||
sql pause stream streams8;
|
||||
|
||||
sql pause stream streams9;
|
||||
|
||||
sql pause stream streams8;
|
||||
|
||||
sql pause stream streams9;
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql pause stream streams8;
|
||||
|
||||
sql pause stream streams9;
|
||||
|
||||
sleep 1000
|
||||
|
||||
$loop_count = 0
|
||||
loop80:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
print pause stream failed
|
||||
goto end_step_6
|
||||
endi
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql select status, * from information_schema.ins_stream_tasks where status != "paused";
|
||||
|
||||
if $rows != 2 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop80
|
||||
endi
|
||||
|
||||
$loop_count = 0
|
||||
loop8:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql select status, * from information_schema.ins_streams where status == "paused";
|
||||
|
||||
if $rows != 2 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop8
|
||||
endi
|
||||
|
||||
|
||||
sql resume stream streams8;
|
||||
|
||||
sql resume stream streams9;
|
||||
|
||||
sql resume stream streams8;
|
||||
|
||||
sql resume stream streams9;
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql resume stream streams8;
|
||||
|
||||
sql resume stream streams9;
|
||||
|
||||
sleep 1000
|
||||
|
||||
|
||||
$loop_count = 0
|
||||
loop90:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
print pause stream failed
|
||||
goto end_step_6
|
||||
endi
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql select status, * from information_schema.ins_stream_tasks where status == "paused";
|
||||
|
||||
if $rows != 0 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop90
|
||||
endi
|
||||
|
||||
$loop_count = 0
|
||||
loop9:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql select status, * from information_schema.ins_streams where status != "paused";
|
||||
|
||||
if $rows != 2 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop9
|
||||
endi
|
||||
|
||||
run tsim/stream/checkTaskStatus.sim
|
||||
|
||||
sql insert into ts1 values(1648791213001,1,12,3,1.0);
|
||||
|
||||
$loop_count = 0
|
||||
loop11:
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 40 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sleep 1000
|
||||
|
||||
sql select * from streamt8;
|
||||
|
||||
if $rows != 1 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop11
|
||||
endi
|
||||
|
||||
sql select * from streamt9;
|
||||
|
||||
if $rows != 1 then
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
goto loop11
|
||||
endi
|
||||
|
||||
end_step_6:
|
||||
|
||||
print ===== step6 over
|
||||
|
||||
system sh/stop_dnodes.sh
|
||||
|
|
|
|||
|
|
@ -76,7 +76,23 @@ while $i < $maxTinyLimit
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
print =============== create database with big tags
|
||||
$bigTagDb = db
|
||||
$bigTagStb = stb
|
||||
$bigTagTb = tb
|
||||
sql create database $bigTagDb
|
||||
sql use $bigTagDb
|
||||
|
||||
sql create table $bigTagStb (ts timestamp, f1 int) tags(t1 nchar(100), t2 nchar(800), t3 nchar(800), t4 nchar(800));
|
||||
|
||||
sql insert into $bigTagTb using $bigTagStb tags("abc", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") values(now, 1);
|
||||
|
||||
$tb = $bigTagTb . 2
|
||||
sql insert into $tb using $bigTagStb tags("abc", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") values(now, 1);
|
||||
|
||||
$tb = $bigTagTb . 3
|
||||
sql insert into $tb using $bigTagStb tags("abc", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") values(now, 1);
|
||||
|
||||
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
|
|||
|
|
@ -0,0 +1,44 @@
|
|||
import taos
|
||||
import sys
|
||||
import time
|
||||
import socket
|
||||
import os
|
||||
import threading
|
||||
|
||||
from util.log import *
|
||||
from util.sql import *
|
||||
from util.cases import *
|
||||
from util.dnodes import *
|
||||
from util.common import *
|
||||
from taos.tmq import *
|
||||
sys.path.append("./7-tmq")
|
||||
from tmqCommon import *
|
||||
|
||||
class TDTestCase:
|
||||
updatecfgDict = {'debugFlag': 135, 'asynclog': 0}
|
||||
def init(self, conn, logSql, replicaVar=1):
|
||||
self.replicaVar = int(replicaVar)
|
||||
tdLog.debug(f"start to excute {__file__}")
|
||||
tdSql.init(conn.cursor())
|
||||
#tdSql.init(conn.cursor(), logSql) # output sql.txt file
|
||||
|
||||
def run(self):
|
||||
tdSql.execute(f'create database if not exists db_33225')
|
||||
tdSql.execute(f'use db_33225')
|
||||
tdSql.execute(f'create stable if not exists s33225 (ts timestamp, c1 int, c2 int) tags (t binary(32), t2 int)')
|
||||
tdSql.execute(f'insert into t1 using s33225 tags("__devicid__", 1) values(1669092069068, 0, 1)')
|
||||
|
||||
tdSql.execute("create topic db_33225_topic as select ts,c1,t2 from s33225")
|
||||
tdSql.execute(f'create stream s1 into st1 as select _wstart, count(*), avg(c2),t2 from s33225 PARTITION BY tbname INTERVAL(1m)')
|
||||
|
||||
tdSql.execute(f'alter table s33225 modify column c2 COMPRESS "zlib"')
|
||||
tdSql.execute(f'create index dex1 on s33225(t2)')
|
||||
|
||||
return
|
||||
|
||||
def stop(self):
|
||||
tdSql.close()
|
||||
tdLog.success(f"{__file__} successfully executed")
|
||||
|
||||
tdCases.addLinux(__file__, TDTestCase())
|
||||
tdCases.addWindows(__file__, TDTestCase())
|
||||
Loading…
Reference in New Issue