tmsg.c 252.3 KB
Newer Older
D
dapan1121 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

S
common  
Shengliang Guan 已提交
16
#define _DEFAULT_SOURCE
H
Hongze Cheng 已提交
17
#include "tmsg.h"
D
dapan1121 已提交
18

H
Hongze Cheng 已提交
19 20 21 22 23
#undef TD_MSG_NUMBER_
#undef TD_MSG_DICT_
#define TD_MSG_INFO_
#undef TD_MSG_SEG_CODE_
#include "tmsgdef.h"
D
dapan1121 已提交
24

H
Hongze Cheng 已提交
25 26 27 28
#undef TD_MSG_NUMBER_
#undef TD_MSG_INFO_
#define TD_MSG_DICT_
#undef TD_MSG_SEG_CODE_
H
Hongze Cheng 已提交
29
#include "tmsgdef.h"
C
Cary Xu 已提交
30

S
Shengliang Guan 已提交
31 32
#include "tlog.h"

33
int32_t tInitSubmitMsgIter(const SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
C
Cary Xu 已提交
34 35 36 37 38 39
  if (pMsg == NULL) {
    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
    return -1;
  }

  pIter->totalLen = htonl(pMsg->length);
C
Cary Xu 已提交
40
  pIter->numOfBlocks = htonl(pMsg->numOfBlocks);
41
  ASSERT(pIter->totalLen > 0);
C
Cary Xu 已提交
42 43 44 45 46 47 48 49 50 51
  pIter->len = 0;
  pIter->pMsg = pMsg;
  if (pIter->totalLen <= sizeof(SSubmitReq)) {
    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
    return -1;
  }

  return 0;
}

52
int32_t tGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
53
  ASSERT(pIter->len >= 0);
C
Cary Xu 已提交
54 55 56 57 58

  if (pIter->len == 0) {
    pIter->len += sizeof(SSubmitReq);
  } else {
    if (pIter->len >= pIter->totalLen) {
59
      ASSERT(0);
C
Cary Xu 已提交
60 61 62
    }

    pIter->len += (sizeof(SSubmitBlk) + pIter->dataLen + pIter->schemaLen);
63
    ASSERT(pIter->len > 0);
C
Cary Xu 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
  }

  if (pIter->len > pIter->totalLen) {
    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
    *pPBlock = NULL;
    return -1;
  }

  if (pIter->len == pIter->totalLen) {
    *pPBlock = NULL;
  } else {
    *pPBlock = (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
    pIter->uid = htobe64((*pPBlock)->uid);
    pIter->suid = htobe64((*pPBlock)->suid);
    pIter->sversion = htonl((*pPBlock)->sversion);
    pIter->dataLen = htonl((*pPBlock)->dataLen);
    pIter->schemaLen = htonl((*pPBlock)->schemaLen);
81
    pIter->numOfRows = htonl((*pPBlock)->numOfRows);
C
Cary Xu 已提交
82 83 84 85
  }
  return 0;
}

86
int32_t tInitSubmitBlkIter(SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
C
Cary Xu 已提交
87 88 89 90 91 92 93
  if (pMsgIter->dataLen <= 0) return -1;
  pIter->totalLen = pMsgIter->dataLen;
  pIter->len = 0;
  pIter->row = (STSRow *)(pBlock->data + pMsgIter->schemaLen);
  return 0;
}

94
STSRow *tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
C
Cary Xu 已提交
95 96 97 98 99 100 101 102 103 104 105 106
  STSRow *row = pIter->row;

  if (pIter->len >= pIter->totalLen) {
    return NULL;
  } else {
    pIter->len += TD_ROW_LEN(row);
    if (pIter->len < pIter->totalLen) {
      pIter->row = POINTER_SHIFT(row, TD_ROW_LEN(row));
    }
    return row;
  }
}
C
Cary Xu 已提交
107

108
int32_t tPrintFixedSchemaSubmitReq(SSubmitReq *pReq, STSchema *pTschema) {
L
Liu Jicong 已提交
109
  SSubmitMsgIter msgIter = {0};
L
Liu Jicong 已提交
110
  if (tInitSubmitMsgIter(pReq, &msgIter) < 0) return -1;
L
Liu Jicong 已提交
111 112
  while (true) {
    SSubmitBlk *pBlock = NULL;
L
Liu Jicong 已提交
113
    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
L
Liu Jicong 已提交
114 115
    if (pBlock == NULL) break;
    SSubmitBlkIter blkIter = {0};
L
Liu Jicong 已提交
116
    tInitSubmitBlkIter(&msgIter, pBlock, &blkIter);
L
Liu Jicong 已提交
117 118 119
    STSRowIter rowIter = {0};
    tdSTSRowIterInit(&rowIter, pTschema);
    STSRow *row;
L
Liu Jicong 已提交
120
    while ((row = tGetSubmitBlkNext(&blkIter)) != NULL) {
L
Liu Jicong 已提交
121 122 123 124 125 126
      tdSRowPrint(row, pTschema, "stream");
    }
  }
  return 0;
}

H
Hongze Cheng 已提交
127
int32_t tEncodeSEpSet(SEncoder *pEncoder, const SEpSet *pEp) {
S
Shengliang Guan 已提交
128 129 130 131
  if (tEncodeI8(pEncoder, pEp->inUse) < 0) return -1;
  if (tEncodeI8(pEncoder, pEp->numOfEps) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; i++) {
    if (tEncodeU16(pEncoder, pEp->eps[i].port) < 0) return -1;
132
    if (tEncodeCStrWithLen(pEncoder, pEp->eps[i].fqdn, TSDB_FQDN_LEN) < 0) return -1;
S
Shengliang Guan 已提交
133 134 135 136
  }
  return 0;
}

H
Hongze Cheng 已提交
137
int32_t tDecodeSEpSet(SDecoder *pDecoder, SEpSet *pEp) {
S
Shengliang Guan 已提交
138 139 140 141 142 143 144 145 146
  if (tDecodeI8(pDecoder, &pEp->inUse) < 0) return -1;
  if (tDecodeI8(pDecoder, &pEp->numOfEps) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; i++) {
    if (tDecodeU16(pDecoder, &pEp->eps[i].port) < 0) return -1;
    if (tDecodeCStrTo(pDecoder, pEp->eps[i].fqdn) < 0) return -1;
  }
  return 0;
}

H
Hongze Cheng 已提交
147
int32_t tEncodeSQueryNodeAddr(SEncoder *pEncoder, SQueryNodeAddr *pAddr) {
D
dapan1121 已提交
148 149 150 151 152
  if (tEncodeI32(pEncoder, pAddr->nodeId) < 0) return -1;
  if (tEncodeSEpSet(pEncoder, &pAddr->epSet) < 0) return -1;
  return 0;
}

153 154 155 156 157 158
int32_t tEncodeSQueryNodeLoad(SEncoder *pEncoder, SQueryNodeLoad *pLoad) {
  if (tEncodeSQueryNodeAddr(pEncoder, &pLoad->addr) < 0) return -1;
  if (tEncodeU64(pEncoder, pLoad->load) < 0) return -1;
  return 0;
}

H
Hongze Cheng 已提交
159
int32_t tDecodeSQueryNodeAddr(SDecoder *pDecoder, SQueryNodeAddr *pAddr) {
D
dapan1121 已提交
160 161 162 163 164
  if (tDecodeI32(pDecoder, &pAddr->nodeId) < 0) return -1;
  if (tDecodeSEpSet(pDecoder, &pAddr->epSet) < 0) return -1;
  return 0;
}

165 166 167 168 169 170
int32_t tDecodeSQueryNodeLoad(SDecoder *pDecoder, SQueryNodeLoad *pLoad) {
  if (tDecodeSQueryNodeAddr(pDecoder, &pLoad->addr) < 0) return -1;
  if (tDecodeU64(pDecoder, &pLoad->load) < 0) return -1;
  return 0;
}

S
Shengliang Guan 已提交
171 172 173 174 175 176 177 178 179 180 181
int32_t taosEncodeSEpSet(void **buf, const SEpSet *pEp) {
  int32_t tlen = 0;
  tlen += taosEncodeFixedI8(buf, pEp->inUse);
  tlen += taosEncodeFixedI8(buf, pEp->numOfEps);
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; i++) {
    tlen += taosEncodeFixedU16(buf, pEp->eps[i].port);
    tlen += taosEncodeString(buf, pEp->eps[i].fqdn);
  }
  return tlen;
}

182
void *taosDecodeSEpSet(const void *buf, SEpSet *pEp) {
S
Shengliang Guan 已提交
183 184 185 186 187 188
  buf = taosDecodeFixedI8(buf, &pEp->inUse);
  buf = taosDecodeFixedI8(buf, &pEp->numOfEps);
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; i++) {
    buf = taosDecodeFixedU16(buf, &pEp->eps[i].port);
    buf = taosDecodeStringTo(buf, pEp->eps[i].fqdn);
  }
189
  return (void *)buf;
S
Shengliang Guan 已提交
190 191
}

H
Hongze Cheng 已提交
192
static int32_t tSerializeSClientHbReq(SEncoder *pEncoder, const SClientHbReq *pReq) {
S
Shengliang Guan 已提交
193
  if (tEncodeSClientHbKey(pEncoder, &pReq->connKey) < 0) return -1;
L
Liu Jicong 已提交
194

D
dapan1121 已提交
195
  if (pReq->connKey.connType == CONN_TYPE__QUERY) {
D
dapan1121 已提交
196 197 198 199 200 201 202 203 204 205 206 207 208
    if (tEncodeI64(pEncoder, pReq->app.appId) < 0) return -1;
    if (tEncodeI32(pEncoder, pReq->app.pid) < 0) return -1;
    if (tEncodeCStr(pEncoder, pReq->app.name) < 0) return -1;
    if (tEncodeI64(pEncoder, pReq->app.startTime) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.numOfInsertsReq) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.numOfInsertRows) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.insertElapsedTime) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.insertBytes) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.fetchBytes) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.queryElapsedTime) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.numOfSlowQueries) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.totalRequests) < 0) return -1;
    if (tEncodeU64(pEncoder, pReq->app.summary.currentRequests) < 0) return -1;
X
Xiaoyu Wang 已提交
209

D
dapan1121 已提交
210 211 212 213 214
    int32_t queryNum = 0;
    if (pReq->query) {
      queryNum = 1;
      if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
      if (tEncodeU32(pEncoder, pReq->query->connId) < 0) return -1;
215

D
dapan1121 已提交
216 217
      int32_t num = taosArrayGetSize(pReq->query->queryDesc);
      if (tEncodeI32(pEncoder, num) < 0) return -1;
218

D
dapan1121 已提交
219 220 221 222 223 224 225
      for (int32_t i = 0; i < num; ++i) {
        SQueryDesc *desc = taosArrayGet(pReq->query->queryDesc, i);
        if (tEncodeCStr(pEncoder, desc->sql) < 0) return -1;
        if (tEncodeU64(pEncoder, desc->queryId) < 0) return -1;
        if (tEncodeI64(pEncoder, desc->useconds) < 0) return -1;
        if (tEncodeI64(pEncoder, desc->stime) < 0) return -1;
        if (tEncodeI64(pEncoder, desc->reqRid) < 0) return -1;
226
        if (tEncodeI8(pEncoder, desc->stableQuery) < 0) return -1;
D
dapan1121 已提交
227 228 229 230 231 232 233 234
        if (tEncodeCStr(pEncoder, desc->fqdn) < 0) return -1;
        if (tEncodeI32(pEncoder, desc->subPlanNum) < 0) return -1;

        int32_t snum = desc->subDesc ? taosArrayGetSize(desc->subDesc) : 0;
        if (tEncodeI32(pEncoder, snum) < 0) return -1;
        for (int32_t m = 0; m < snum; ++m) {
          SQuerySubDesc *sDesc = taosArrayGet(desc->subDesc, m);
          if (tEncodeI64(pEncoder, sDesc->tid) < 0) return -1;
235
          if (tEncodeCStr(pEncoder, sDesc->status) < 0) return -1;
D
dapan1121 已提交
236 237 238 239 240 241
        }
      }
    } else {
      if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
    }
  }
242

L
Liu Jicong 已提交
243
  int32_t kvNum = taosHashGetSize(pReq->info);
S
Shengliang Guan 已提交
244
  if (tEncodeI32(pEncoder, kvNum) < 0) return -1;
S
Shengliang Guan 已提交
245
  void *pIter = taosHashIterate(pReq->info, NULL);
L
Liu Jicong 已提交
246
  while (pIter != NULL) {
S
Shengliang Guan 已提交
247 248
    SKv *kv = pIter;
    if (tEncodeSKv(pEncoder, kv) < 0) return -1;
L
Liu Jicong 已提交
249
    pIter = taosHashIterate(pReq->info, pIter);
L
Liu Jicong 已提交
250
  }
S
Shengliang Guan 已提交
251 252

  return 0;
L
Liu Jicong 已提交
253 254
}

H
Hongze Cheng 已提交
255
static int32_t tDeserializeSClientHbReq(SDecoder *pDecoder, SClientHbReq *pReq) {
S
Shengliang Guan 已提交
256
  if (tDecodeSClientHbKey(pDecoder, &pReq->connKey) < 0) return -1;
L
Liu Jicong 已提交
257

D
dapan1121 已提交
258
  if (pReq->connKey.connType == CONN_TYPE__QUERY) {
D
dapan1121 已提交
259 260 261 262 263 264 265 266 267 268 269 270 271 272
    if (tDecodeI64(pDecoder, &pReq->app.appId) < 0) return -1;
    if (tDecodeI32(pDecoder, &pReq->app.pid) < 0) return -1;
    if (tDecodeCStrTo(pDecoder, pReq->app.name) < 0) return -1;
    if (tDecodeI64(pDecoder, &pReq->app.startTime) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.numOfInsertsReq) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.numOfInsertRows) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.insertElapsedTime) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.insertBytes) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.fetchBytes) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.queryElapsedTime) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.numOfSlowQueries) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.totalRequests) < 0) return -1;
    if (tDecodeU64(pDecoder, &pReq->app.summary.currentRequests) < 0) return -1;

D
dapan1121 已提交
273 274 275 276 277 278 279 280 281 282 283 284
    int32_t queryNum = 0;
    if (tDecodeI32(pDecoder, &queryNum) < 0) return -1;
    if (queryNum) {
      pReq->query = taosMemoryCalloc(1, sizeof(*pReq->query));
      if (NULL == pReq->query) return -1;
      if (tDecodeU32(pDecoder, &pReq->query->connId) < 0) return -1;

      int32_t num = 0;
      if (tDecodeI32(pDecoder, &num) < 0) return -1;
      if (num > 0) {
        pReq->query->queryDesc = taosArrayInit(num, sizeof(SQueryDesc));
        if (NULL == pReq->query->queryDesc) return -1;
285

D
dapan1121 已提交
286 287 288 289 290 291 292
        for (int32_t i = 0; i < num; ++i) {
          SQueryDesc desc = {0};
          if (tDecodeCStrTo(pDecoder, desc.sql) < 0) return -1;
          if (tDecodeU64(pDecoder, &desc.queryId) < 0) return -1;
          if (tDecodeI64(pDecoder, &desc.useconds) < 0) return -1;
          if (tDecodeI64(pDecoder, &desc.stime) < 0) return -1;
          if (tDecodeI64(pDecoder, &desc.reqRid) < 0) return -1;
293
          if (tDecodeI8(pDecoder, (int8_t *)&desc.stableQuery) < 0) return -1;
D
dapan1121 已提交
294 295 296 297 298 299 300 301
          if (tDecodeCStrTo(pDecoder, desc.fqdn) < 0) return -1;
          if (tDecodeI32(pDecoder, &desc.subPlanNum) < 0) return -1;

          int32_t snum = 0;
          if (tDecodeI32(pDecoder, &snum) < 0) return -1;
          if (snum > 0) {
            desc.subDesc = taosArrayInit(snum, sizeof(SQuerySubDesc));
            if (NULL == desc.subDesc) return -1;
302

D
dapan1121 已提交
303 304 305
            for (int32_t m = 0; m < snum; ++m) {
              SQuerySubDesc sDesc = {0};
              if (tDecodeI64(pDecoder, &sDesc.tid) < 0) return -1;
306
              if (tDecodeCStrTo(pDecoder, sDesc.status) < 0) return -1;
D
dapan1121 已提交
307 308 309
              taosArrayPush(desc.subDesc, &sDesc);
            }
          }
310

311
          ASSERT(desc.subPlanNum == taosArrayGetSize(desc.subDesc));
D
dapan1121 已提交
312 313 314 315 316 317 318

          taosArrayPush(pReq->query->queryDesc, &desc);
        }
      }
    }
  }

S
Shengliang Guan 已提交
319 320
  int32_t kvNum = 0;
  if (tDecodeI32(pDecoder, &kvNum) < 0) return -1;
L
Liu Jicong 已提交
321 322 323
  if (pReq->info == NULL) {
    pReq->info = taosHashInit(kvNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
  }
S
Shengliang Guan 已提交
324
  if (pReq->info == NULL) return -1;
S
Shengliang Guan 已提交
325
  for (int32_t i = 0; i < kvNum; i++) {
S
Shengliang Guan 已提交
326 327
    SKv kv = {0};
    if (tDecodeSKv(pDecoder, &kv) < 0) return -1;
D
dapan1121 已提交
328
    taosHashPut(pReq->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
L
Liu Jicong 已提交
329 330
  }

S
Shengliang Guan 已提交
331
  return 0;
L
Liu Jicong 已提交
332 333
}

H
Hongze Cheng 已提交
334
static int32_t tSerializeSClientHbRsp(SEncoder *pEncoder, const SClientHbRsp *pRsp) {
S
Shengliang Guan 已提交
335 336 337
  if (tEncodeSClientHbKey(pEncoder, &pRsp->connKey) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->status) < 0) return -1;

D
dapan1121 已提交
338 339 340
  int32_t queryNum = 0;
  if (pRsp->query) {
    queryNum = 1;
341
    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
D
dapan1121 已提交
342 343 344 345 346 347
    if (tEncodeU32(pEncoder, pRsp->query->connId) < 0) return -1;
    if (tEncodeU64(pEncoder, pRsp->query->killRid) < 0) return -1;
    if (tEncodeI32(pEncoder, pRsp->query->totalDnodes) < 0) return -1;
    if (tEncodeI32(pEncoder, pRsp->query->onlineDnodes) < 0) return -1;
    if (tEncodeI8(pEncoder, pRsp->query->killConnection) < 0) return -1;
    if (tEncodeSEpSet(pEncoder, &pRsp->query->epSet) < 0) return -1;
348 349 350 351 352 353
    int32_t num = taosArrayGetSize(pRsp->query->pQnodeList);
    if (tEncodeI32(pEncoder, num) < 0) return -1;
    for (int32_t i = 0; i < num; ++i) {
      SQueryNodeLoad *pLoad = taosArrayGet(pRsp->query->pQnodeList, i);
      if (tEncodeSQueryNodeLoad(pEncoder, pLoad) < 0) return -1;
    }
D
dapan1121 已提交
354
  } else {
355
    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
D
dapan1121 已提交
356
  }
357

D
dapan1121 已提交
358
  int32_t kvNum = taosArrayGetSize(pRsp->info);
S
Shengliang Guan 已提交
359
  if (tEncodeI32(pEncoder, kvNum) < 0) return -1;
S
Shengliang Guan 已提交
360
  for (int32_t i = 0; i < kvNum; i++) {
S
Shengliang Guan 已提交
361 362
    SKv *kv = taosArrayGet(pRsp->info, i);
    if (tEncodeSKv(pEncoder, kv) < 0) return -1;
D
dapan1121 已提交
363
  }
S
Shengliang Guan 已提交
364 365

  return 0;
L
Liu Jicong 已提交
366
}
S
Shengliang Guan 已提交
367

H
Hongze Cheng 已提交
368
static int32_t tDeserializeSClientHbRsp(SDecoder *pDecoder, SClientHbRsp *pRsp) {
S
Shengliang Guan 已提交
369 370 371
  if (tDecodeSClientHbKey(pDecoder, &pRsp->connKey) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->status) < 0) return -1;

D
dapan1121 已提交
372 373 374 375 376 377 378 379 380 381 382
  int32_t queryNum = 0;
  if (tDecodeI32(pDecoder, &queryNum) < 0) return -1;
  if (queryNum) {
    pRsp->query = taosMemoryCalloc(1, sizeof(*pRsp->query));
    if (NULL == pRsp->query) return -1;
    if (tDecodeU32(pDecoder, &pRsp->query->connId) < 0) return -1;
    if (tDecodeU64(pDecoder, &pRsp->query->killRid) < 0) return -1;
    if (tDecodeI32(pDecoder, &pRsp->query->totalDnodes) < 0) return -1;
    if (tDecodeI32(pDecoder, &pRsp->query->onlineDnodes) < 0) return -1;
    if (tDecodeI8(pDecoder, &pRsp->query->killConnection) < 0) return -1;
    if (tDecodeSEpSet(pDecoder, &pRsp->query->epSet) < 0) return -1;
383 384 385 386 387
    int32_t pQnodeNum = 0;
    if (tDecodeI32(pDecoder, &pQnodeNum) < 0) return -1;
    if (pQnodeNum > 0) {
      pRsp->query->pQnodeList = taosArrayInit(pQnodeNum, sizeof(SQueryNodeLoad));
      if (NULL == pRsp->query->pQnodeList) return -1;
D
dapan1121 已提交
388 389 390 391 392
      for (int32_t i = 0; i < pQnodeNum; ++i) {
        SQueryNodeLoad load = {0};
        if (tDecodeSQueryNodeLoad(pDecoder, &load) < 0) return -1;
        taosArrayPush(pRsp->query->pQnodeList, &load);
      }
393
    }
D
dapan1121 已提交
394 395
  }

D
dapan1121 已提交
396
  int32_t kvNum = 0;
S
Shengliang Guan 已提交
397
  if (tDecodeI32(pDecoder, &kvNum) < 0) return -1;
D
dapan1121 已提交
398
  pRsp->info = taosArrayInit(kvNum, sizeof(SKv));
S
Shengliang Guan 已提交
399
  if (pRsp->info == NULL) return -1;
S
Shengliang Guan 已提交
400
  for (int32_t i = 0; i < kvNum; i++) {
D
dapan1121 已提交
401
    SKv kv = {0};
S
Shengliang Guan 已提交
402
    tDecodeSKv(pDecoder, &kv);
D
dapan1121 已提交
403 404
    taosArrayPush(pRsp->info, &kv);
  }
S
Shengliang Guan 已提交
405

S
Shengliang Guan 已提交
406
  return 0;
L
Liu Jicong 已提交
407 408
}

S
Shengliang Guan 已提交
409
int32_t tSerializeSClientHbBatchReq(void *buf, int32_t bufLen, const SClientHbBatchReq *pBatchReq) {
H
Hongze Cheng 已提交
410 411
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
412 413 414 415

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pBatchReq->reqId) < 0) return -1;

L
Liu Jicong 已提交
416
  int32_t reqNum = taosArrayGetSize(pBatchReq->reqs);
S
Shengliang Guan 已提交
417
  if (tEncodeI32(&encoder, reqNum) < 0) return -1;
S
Shengliang Guan 已提交
418 419
  for (int32_t i = 0; i < reqNum; i++) {
    SClientHbReq *pReq = taosArrayGet(pBatchReq->reqs, i);
S
Shengliang Guan 已提交
420
    if (tSerializeSClientHbReq(&encoder, pReq) < 0) return -1;
L
Liu Jicong 已提交
421
  }
S
Shengliang Guan 已提交
422 423 424
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
425
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
426 427 428
  return tlen;
}

S
Shengliang Guan 已提交
429
int32_t tDeserializeSClientHbBatchReq(void *buf, int32_t bufLen, SClientHbBatchReq *pBatchReq) {
H
Hongze Cheng 已提交
430 431
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
432 433 434 435 436 437

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pBatchReq->reqId) < 0) return -1;

  int32_t reqNum = 0;
  if (tDecodeI32(&decoder, &reqNum) < 0) return -1;
D
dapan1121 已提交
438
  if (reqNum > 0) {
S
Shengliang Guan 已提交
439
    pBatchReq->reqs = taosArrayInit(reqNum, sizeof(SClientHbReq));
D
dapan1121 已提交
440
    if (NULL == pBatchReq->reqs) return -1;
L
Liu Jicong 已提交
441
  }
S
Shengliang Guan 已提交
442
  for (int32_t i = 0; i < reqNum; i++) {
L
Liu Jicong 已提交
443
    SClientHbReq req = {0};
S
Shengliang Guan 已提交
444
    tDeserializeSClientHbReq(&decoder, &req);
L
Liu Jicong 已提交
445 446
    taosArrayPush(pBatchReq->reqs, &req);
  }
S
Shengliang Guan 已提交
447 448

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
449
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
450
  return 0;
L
Liu Jicong 已提交
451 452
}

S
Shengliang Guan 已提交
453
int32_t tSerializeSClientHbBatchRsp(void *buf, int32_t bufLen, const SClientHbBatchRsp *pBatchRsp) {
H
Hongze Cheng 已提交
454 455
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
456 457 458 459

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pBatchRsp->reqId) < 0) return -1;
  if (tEncodeI64(&encoder, pBatchRsp->rspId) < 0) return -1;
460
  if (tEncodeI32(&encoder, pBatchRsp->svrTimestamp) < 0) return -1;
S
Shengliang Guan 已提交
461 462 463 464

  int32_t rspNum = taosArrayGetSize(pBatchRsp->rsps);
  if (tEncodeI32(&encoder, rspNum) < 0) return -1;
  for (int32_t i = 0; i < rspNum; i++) {
S
Shengliang Guan 已提交
465
    SClientHbRsp *pRsp = taosArrayGet(pBatchRsp->rsps, i);
S
Shengliang Guan 已提交
466
    if (tSerializeSClientHbRsp(&encoder, pRsp) < 0) return -1;
L
Liu Jicong 已提交
467
  }
S
Shengliang Guan 已提交
468 469 470
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
471
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
472 473 474
  return tlen;
}

S
Shengliang Guan 已提交
475
int32_t tDeserializeSClientHbBatchRsp(void *buf, int32_t bufLen, SClientHbBatchRsp *pBatchRsp) {
H
Hongze Cheng 已提交
476 477
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
478 479 480 481

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pBatchRsp->reqId) < 0) return -1;
  if (tDecodeI64(&decoder, &pBatchRsp->rspId) < 0) return -1;
482
  if (tDecodeI32(&decoder, &pBatchRsp->svrTimestamp) < 0) return -1;
S
Shengliang Guan 已提交
483 484 485 486

  int32_t rspNum = 0;
  if (tDecodeI32(&decoder, &rspNum) < 0) return -1;
  if (pBatchRsp->rsps == NULL) {
L
Liu Jicong 已提交
487
    pBatchRsp->rsps = taosArrayInit(rspNum, sizeof(SClientHbRsp));
S
Shengliang Guan 已提交
488 489
  }
  for (int32_t i = 0; i < rspNum; i++) {
L
Liu Jicong 已提交
490
    SClientHbRsp rsp = {0};
S
Shengliang Guan 已提交
491
    tDeserializeSClientHbRsp(&decoder, &rsp);
L
Liu Jicong 已提交
492 493
    taosArrayPush(pBatchRsp->rsps, &rsp);
  }
S
Shengliang Guan 已提交
494 495

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
496
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
497
  return 0;
L
Liu Jicong 已提交
498 499
}

S
Shengliang Guan 已提交
500
int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq) {
H
Hongze Cheng 已提交
501 502
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
503

S
Shengliang Guan 已提交
504 505 506
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
507 508 509 510 511
  if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
    if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
  }
  if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
512 513 514 515
  if (tEncodeI64(&encoder, pReq->delay1) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->delay2) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->watermark1) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->watermark2) < 0) return -1;
S
sma  
Shengliang Guan 已提交
516
  if (tEncodeI32(&encoder, pReq->ttl) < 0) return -1;
517 518
  if (tEncodeI32(&encoder, pReq->colVer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->tagVer) < 0) return -1;
S
Shengliang Guan 已提交
519 520
  if (tEncodeI32(&encoder, pReq->numOfColumns) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfTags) < 0) return -1;
S
Shengliang Guan 已提交
521
  if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
S
sma  
Shengliang Guan 已提交
522
  if (tEncodeI32(&encoder, pReq->commentLen) < 0) return -1;
523 524
  if (tEncodeI32(&encoder, pReq->ast1Len) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->ast2Len) < 0) return -1;
S
Shengliang Guan 已提交
525 526 527

  for (int32_t i = 0; i < pReq->numOfColumns; ++i) {
    SField *pField = taosArrayGet(pReq->pColumns, i);
S
Shengliang Guan 已提交
528
    if (tEncodeI8(&encoder, pField->type) < 0) return -1;
S
Shengliang Guan 已提交
529
    if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
S
Shengliang Guan 已提交
530 531
    if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
    if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
S
Shengliang Guan 已提交
532 533 534 535
  }

  for (int32_t i = 0; i < pReq->numOfTags; ++i) {
    SField *pField = taosArrayGet(pReq->pTags, i);
S
Shengliang Guan 已提交
536
    if (tEncodeI8(&encoder, pField->type) < 0) return -1;
S
Shengliang Guan 已提交
537
    if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
S
Shengliang Guan 已提交
538 539
    if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
    if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
S
Shengliang Guan 已提交
540 541 542 543 544
  }

  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
    const char *pFunc = taosArrayGet(pReq->pFuncs, i);
    if (tEncodeCStr(&encoder, pFunc) < 0) return -1;
S
sma  
Shengliang Guan 已提交
545 546 547
  }

  if (pReq->commentLen > 0) {
S
Shengliang Guan 已提交
548
    if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
S
sma  
Shengliang Guan 已提交
549
  }
550 551 552 553 554 555
  if (pReq->ast1Len > 0) {
    if (tEncodeBinary(&encoder, pReq->pAst1, pReq->ast1Len) < 0) return -1;
  }
  if (pReq->ast2Len > 0) {
    if (tEncodeBinary(&encoder, pReq->pAst2, pReq->ast2Len) < 0) return -1;
  }
556 557
  if (tEncodeI64(&encoder, pReq->deleteMark1) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->deleteMark2) < 0) return -1;
D
dapan1121 已提交
558

S
Shengliang Guan 已提交
559 560 561
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
562
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
563 564 565
  return tlen;
}

S
Shengliang Guan 已提交
566
int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq) {
H
Hongze Cheng 已提交
567 568
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
569 570 571 572

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
573 574 575 576 577
  if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
    if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
  if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
578 579 580 581
  if (tDecodeI64(&decoder, &pReq->delay1) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->delay2) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->watermark1) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->watermark2) < 0) return -1;
S
sma  
Shengliang Guan 已提交
582
  if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
583 584
  if (tDecodeI32(&decoder, &pReq->colVer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->tagVer) < 0) return -1;
S
Shengliang Guan 已提交
585 586
  if (tDecodeI32(&decoder, &pReq->numOfColumns) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfTags) < 0) return -1;
S
Shengliang Guan 已提交
587
  if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
S
sma  
Shengliang Guan 已提交
588
  if (tDecodeI32(&decoder, &pReq->commentLen) < 0) return -1;
589 590
  if (tDecodeI32(&decoder, &pReq->ast1Len) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->ast2Len) < 0) return -1;
S
Shengliang Guan 已提交
591 592 593

  pReq->pColumns = taosArrayInit(pReq->numOfColumns, sizeof(SField));
  pReq->pTags = taosArrayInit(pReq->numOfTags, sizeof(SField));
S
Shengliang Guan 已提交
594 595
  pReq->pFuncs = taosArrayInit(pReq->numOfFuncs, TSDB_FUNC_NAME_LEN);
  if (pReq->pColumns == NULL || pReq->pTags == NULL || pReq->pFuncs == NULL) {
S
Shengliang Guan 已提交
596
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
597
    return -1;
S
Shengliang Guan 已提交
598 599 600 601
  }

  for (int32_t i = 0; i < pReq->numOfColumns; ++i) {
    SField field = {0};
S
Shengliang Guan 已提交
602
    if (tDecodeI8(&decoder, &field.type) < 0) return -1;
S
Shengliang Guan 已提交
603
    if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
S
Shengliang Guan 已提交
604 605
    if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
    if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
S
Shengliang Guan 已提交
606 607
    if (taosArrayPush(pReq->pColumns, &field) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
608
      return -1;
S
Shengliang Guan 已提交
609 610 611 612 613
    }
  }

  for (int32_t i = 0; i < pReq->numOfTags; ++i) {
    SField field = {0};
S
Shengliang Guan 已提交
614
    if (tDecodeI8(&decoder, &field.type) < 0) return -1;
S
Shengliang Guan 已提交
615
    if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
S
Shengliang Guan 已提交
616 617
    if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
    if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
S
Shengliang Guan 已提交
618 619
    if (taosArrayPush(pReq->pTags, &field) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
620
      return -1;
S
Shengliang Guan 已提交
621 622 623
    }
  }

S
Shengliang Guan 已提交
624 625 626 627 628 629 630 631 632
  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
    char pFunc[TSDB_FUNC_NAME_LEN] = {0};
    if (tDecodeCStrTo(&decoder, pFunc) < 0) return -1;
    if (taosArrayPush(pReq->pFuncs, pFunc) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

S
sma  
Shengliang Guan 已提交
633
  if (pReq->commentLen > 0) {
S
Shengliang Guan 已提交
634 635 636
    pReq->pComment = taosMemoryMalloc(pReq->commentLen + 1);
    if (pReq->pComment == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
S
sma  
Shengliang Guan 已提交
637 638
  }

639 640 641 642 643 644 645 646 647 648 649 650
  if (pReq->ast1Len > 0) {
    pReq->pAst1 = taosMemoryMalloc(pReq->ast1Len);
    if (pReq->pAst1 == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->pAst1) < 0) return -1;
  }

  if (pReq->ast2Len > 0) {
    pReq->pAst2 = taosMemoryMalloc(pReq->ast2Len);
    if (pReq->pAst2 == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->pAst2) < 0) return -1;
  }

651 652 653
  if (tDecodeI64(&decoder, &pReq->deleteMark1) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->deleteMark2) < 0) return -1;

S
Shengliang Guan 已提交
654
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
655
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
656
  return 0;
S
Shengliang Guan 已提交
657
}
S
Shengliang Guan 已提交
658

S
Shengliang Guan 已提交
659 660 661
void tFreeSMCreateStbReq(SMCreateStbReq *pReq) {
  taosArrayDestroy(pReq->pColumns);
  taosArrayDestroy(pReq->pTags);
S
Shengliang Guan 已提交
662 663
  taosArrayDestroy(pReq->pFuncs);
  taosMemoryFreeClear(pReq->pComment);
664 665
  taosMemoryFreeClear(pReq->pAst1);
  taosMemoryFreeClear(pReq->pAst2);
S
Shengliang Guan 已提交
666 667
}

S
Shengliang Guan 已提交
668
int32_t tSerializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq) {
H
Hongze Cheng 已提交
669 670
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
671

S
Shengliang Guan 已提交
672 673 674
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
675
  if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
676
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
677 678
    if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
  }
679
  if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
S
Shengliang Guan 已提交
680
  tEndEncode(&encoder);
S
Shengliang Guan 已提交
681

S
Shengliang Guan 已提交
682
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
683
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
684 685 686
  return tlen;
}

S
Shengliang Guan 已提交
687
int32_t tDeserializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq) {
H
Hongze Cheng 已提交
688 689
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
690

S
Shengliang Guan 已提交
691 692 693
  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
694
  if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
695
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
696 697
    if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
698
  if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
699

S
Shengliang Guan 已提交
700
  tEndDecode(&decoder);
S
Shengliang Guan 已提交
701

H
Hongze Cheng 已提交
702
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
703 704
  return 0;
}
S
Shengliang Guan 已提交
705

S
Shengliang Guan 已提交
706
int32_t tSerializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq) {
H
Hongze Cheng 已提交
707 708
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
709

S
Shengliang Guan 已提交
710 711 712 713
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfFields) < 0) return -1;
S
Shengliang Guan 已提交
714 715
  for (int32_t i = 0; i < pReq->numOfFields; ++i) {
    SField *pField = taosArrayGet(pReq->pFields, i);
S
Shengliang Guan 已提交
716 717 718
    if (tEncodeI8(&encoder, pField->type) < 0) return -1;
    if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
    if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
S
Shengliang Guan 已提交
719
  }
720 721 722 723 724
  if (tEncodeI32(&encoder, pReq->ttl) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
    if (tEncodeCStr(&encoder, pReq->comment) < 0) return -1;
  }
S
Shengliang Guan 已提交
725
  tEndEncode(&encoder);
S
Shengliang Guan 已提交
726

S
Shengliang Guan 已提交
727
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
728
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
729 730 731
  return tlen;
}

S
Shengliang Guan 已提交
732
int32_t tDeserializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq) {
H
Hongze Cheng 已提交
733 734
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
735

S
Shengliang Guan 已提交
736 737 738 739
  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfFields) < 0) return -1;
S
Shengliang Guan 已提交
740 741 742
  pReq->pFields = taosArrayInit(pReq->numOfFields, sizeof(SField));
  if (pReq->pFields == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
743
    return -1;
S
Shengliang Guan 已提交
744 745 746 747
  }

  for (int32_t i = 0; i < pReq->numOfFields; ++i) {
    SField field = {0};
S
Shengliang Guan 已提交
748 749 750
    if (tDecodeI8(&decoder, &field.type) < 0) return -1;
    if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
    if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
S
Shengliang Guan 已提交
751 752
    if (taosArrayPush(pReq->pFields, &field) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
753
      return -1;
S
Shengliang Guan 已提交
754 755 756
    }
  }

757 758 759
  if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
wmmhello's avatar
wmmhello 已提交
760
    pReq->comment = taosMemoryMalloc(pReq->commentLen + 1);
761 762 763 764
    if (pReq->comment == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->comment) < 0) return -1;
  }

S
Shengliang Guan 已提交
765
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
766
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
767 768 769
  return 0;
}

S
Shengliang Guan 已提交
770
void tFreeSMAltertbReq(SMAlterStbReq *pReq) {
S
Shengliang Guan 已提交
771 772
  taosArrayDestroy(pReq->pFields);
  pReq->pFields = NULL;
773
  taosMemoryFreeClear(pReq->comment);
S
Shengliang Guan 已提交
774
}
775 776

int32_t tSerializeSEpSet(void *buf, int32_t bufLen, const SEpSet *pEpset) {
H
Hongze Cheng 已提交
777 778
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
779
  if (tStartEncode(&encoder) < 0) return -1;
780
  if (tEncodeSEpSet(&encoder, pEpset) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
781

dengyihao's avatar
dengyihao 已提交
782 783
  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
784
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
785 786
  return tlen;
}
787 788

int32_t tDeserializeSEpSet(void *buf, int32_t bufLen, SEpSet *pEpset) {
H
Hongze Cheng 已提交
789 790
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
791
  if (tStartDecode(&decoder) < 0) return -1;
792
  if (tDecodeSEpSet(&decoder, pEpset) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
793 794

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
795
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
796 797
  return 0;
}
798

S
Shengliang Guan 已提交
799
int32_t tSerializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pReq) {
H
Hongze Cheng 已提交
800 801
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
802 803 804 805 806 807 808 809

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->stb) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->intervalUnit) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->slidingUnit) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->timezone) < 0) return -1;
S
sma  
Shengliang Guan 已提交
810
  if (tEncodeI32(&encoder, pReq->dstVgId) < 0) return -1;
S
Shengliang Guan 已提交
811 812 813
  if (tEncodeI64(&encoder, pReq->interval) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->offset) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->sliding) < 0) return -1;
814 815
  if (tEncodeI64(&encoder, pReq->watermark) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->maxDelay) < 0) return -1;
S
Shengliang Guan 已提交
816
  if (tEncodeI32(&encoder, pReq->exprLen) < 0) return -1;
S
sma  
Shengliang Guan 已提交
817 818 819
  if (tEncodeI32(&encoder, pReq->tagsFilterLen) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->sqlLen) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->astLen) < 0) return -1;
S
Shengliang Guan 已提交
820 821 822 823 824 825
  if (pReq->exprLen > 0) {
    if (tEncodeBinary(&encoder, pReq->expr, pReq->exprLen) < 0) return -1;
  }
  if (pReq->tagsFilterLen > 0) {
    if (tEncodeBinary(&encoder, pReq->tagsFilter, pReq->tagsFilterLen) < 0) return -1;
  }
S
sma  
Shengliang Guan 已提交
826 827 828 829 830 831
  if (pReq->sqlLen > 0) {
    if (tEncodeBinary(&encoder, pReq->sql, pReq->sqlLen) < 0) return -1;
  }
  if (pReq->astLen > 0) {
    if (tEncodeBinary(&encoder, pReq->ast, pReq->astLen) < 0) return -1;
  }
832
  if (tEncodeI64(&encoder, pReq->deleteMark) < 0) return -1;
S
Shengliang Guan 已提交
833 834 835
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
836
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
837 838 839 840
  return tlen;
}

int32_t tDeserializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pReq) {
H
Hongze Cheng 已提交
841 842
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
843 844 845 846 847 848 849 850

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->stb) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->intervalUnit) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->slidingUnit) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->timezone) < 0) return -1;
S
sma  
Shengliang Guan 已提交
851
  if (tDecodeI32(&decoder, &pReq->dstVgId) < 0) return -1;
S
Shengliang Guan 已提交
852 853 854
  if (tDecodeI64(&decoder, &pReq->interval) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->offset) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->sliding) < 0) return -1;
855 856
  if (tDecodeI64(&decoder, &pReq->watermark) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->maxDelay) < 0) return -1;
S
Shengliang Guan 已提交
857
  if (tDecodeI32(&decoder, &pReq->exprLen) < 0) return -1;
S
sma  
Shengliang Guan 已提交
858 859 860
  if (tDecodeI32(&decoder, &pReq->tagsFilterLen) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->sqlLen) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->astLen) < 0) return -1;
S
Shengliang Guan 已提交
861
  if (pReq->exprLen > 0) {
862
    pReq->expr = taosMemoryMalloc(pReq->exprLen);
S
Shengliang Guan 已提交
863 864 865 866
    if (pReq->expr == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->expr) < 0) return -1;
  }
  if (pReq->tagsFilterLen > 0) {
867
    pReq->tagsFilter = taosMemoryMalloc(pReq->tagsFilterLen);
S
Shengliang Guan 已提交
868 869 870
    if (pReq->tagsFilter == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->tagsFilter) < 0) return -1;
  }
S
sma  
Shengliang Guan 已提交
871
  if (pReq->sqlLen > 0) {
872
    pReq->sql = taosMemoryMalloc(pReq->sqlLen);
S
sma  
Shengliang Guan 已提交
873 874 875 876
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }
  if (pReq->astLen > 0) {
877
    pReq->ast = taosMemoryMalloc(pReq->astLen);
S
sma  
Shengliang Guan 已提交
878 879 880
    if (pReq->ast == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
  }
881
  if (tDecodeI64(&decoder, &pReq->deleteMark) < 0) return -1;
S
Shengliang Guan 已提交
882
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
883
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
884 885 886 887
  return 0;
}

void tFreeSMCreateSmaReq(SMCreateSmaReq *pReq) {
888 889 890 891
  taosMemoryFreeClear(pReq->expr);
  taosMemoryFreeClear(pReq->tagsFilter);
  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->ast);
S
Shengliang Guan 已提交
892 893 894
}

int32_t tSerializeSMDropSmaReq(void *buf, int32_t bufLen, SMDropSmaReq *pReq) {
H
Hongze Cheng 已提交
895 896
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
897 898 899

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
900

S
Shengliang Guan 已提交
901 902 903 904
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
905
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
906 907 908 909
  return tlen;
}

int32_t tDeserializeSMDropSmaReq(void *buf, int32_t bufLen, SMDropSmaReq *pReq) {
H
Hongze Cheng 已提交
910 911
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
912 913 914 915 916 917

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
918
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
919 920
  return 0;
}
dengyihao's avatar
dengyihao 已提交
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953

int32_t tSerializeSCreateTagIdxReq(void *buf, int32_t bufLen, SCreateTagIndexReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->dbFName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->stbName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->colName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->idxName) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->idxType) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}
int32_t tDeserializeSCreateTagIdxReq(void *buf, int32_t bufLen, SCreateTagIndexReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeCStrTo(&decoder, pReq->dbFName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->stbName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->colName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->idxName) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->idxType) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}
dengyihao's avatar
dengyihao 已提交
954 955 956 957 958 959
int32_t tSerializeSDropTagIdxReq(void *buf, int32_t bufLen, SDropTagIndexReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;
  tEndEncode(&encoder);

dengyihao's avatar
dengyihao 已提交
960 961
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
962 963 964 965 966 967 968 969 970 971

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}
int32_t tDeserializeSDropTagIdxReq(void *buf, int32_t bufLen, SDropTagIndexReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
  if (tStartDecode(&decoder) < 0) return -1;

dengyihao's avatar
dengyihao 已提交
972 973
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
974 975 976 977 978 979

  tEndDecode(&decoder);
  tDecoderClear(&decoder);

  return 0;
}
dengyihao's avatar
dengyihao 已提交
980
int32_t tSerializeSMCreateFullTextReq(void *buf, int32_t bufLen, SMCreateFullTextReq *pReq) {
H
Hongze Cheng 已提交
981 982
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
983 984 985 986 987

  if (tStartEncode(&encoder) < 0) return -1;

  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
988
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
989 990 991
  return tlen;
}
int32_t tDeserializeSMCreateFullTextReq(void *buf, int32_t bufLen, SMCreateFullTextReq *pReq) {
H
Hongze Cheng 已提交
992 993
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
994 995 996
  if (tStartDecode(&decoder) < 0) return -1;

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
997
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
998 999 1000 1001 1002 1003
  return 0;
}
void tFreeSMCreateFullTextReq(SMCreateFullTextReq *pReq) {
  // impl later
  return;
}
dengyihao's avatar
dengyihao 已提交
1004
int32_t tSerializeSMDropFullTextReq(void *buf, int32_t bufLen, SMDropFullTextReq *pReq) {
H
Hongze Cheng 已提交
1005 1006
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
1007 1008 1009

  if (tStartEncode(&encoder) < 0) return -1;

dengyihao's avatar
dengyihao 已提交
1010 1011 1012 1013
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;

  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;

dengyihao's avatar
dengyihao 已提交
1014 1015
  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1016
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
1017 1018 1019
  return tlen;
}
int32_t tDeserializeSMDropFullTextReq(void *buf, int32_t bufLen, SMDropFullTextReq *pReq) {
H
Hongze Cheng 已提交
1020 1021
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
1022
  if (tStartDecode(&decoder) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
1023 1024
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
1025 1026

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
1027
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
1028 1029
  return 0;
}
S
Shengliang Guan 已提交
1030

S
Shengliang Guan 已提交
1031
int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
H
Hongze Cheng 已提交
1032 1033
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1034 1035

  if (tStartEncode(&encoder) < 0) return -1;
1036 1037

  // status
S
Shengliang Guan 已提交
1038
  if (tEncodeI32(&encoder, pReq->sver) < 0) return -1;
1039
  if (tEncodeI64(&encoder, pReq->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1040 1041 1042 1043
  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->clusterId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->rebootTime) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->updateTime) < 0) return -1;
S
Shengliang Guan 已提交
1044
  if (tEncodeFloat(&encoder, pReq->numOfCores) < 0) return -1;
S
Shengliang Guan 已提交
1045
  if (tEncodeI32(&encoder, pReq->numOfSupportVnodes) < 0) return -1;
1046 1047
  if (tEncodeI64(&encoder, pReq->memTotal) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->memAvail) < 0) return -1;
S
Shengliang Guan 已提交
1048
  if (tEncodeCStr(&encoder, pReq->dnodeEp) < 0) return -1;
1049 1050

  // cluster cfg
S
Shengliang Guan 已提交
1051 1052 1053 1054 1055
  if (tEncodeI32(&encoder, pReq->clusterCfg.statusInterval) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->clusterCfg.checkTime) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->clusterCfg.timezone) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->clusterCfg.locale) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->clusterCfg.charset) < 0) return -1;
1056 1057 1058

  // vnode loads
  int32_t vlen = (int32_t)taosArrayGetSize(pReq->pVloads);
S
Shengliang Guan 已提交
1059
  if (tEncodeI32(&encoder, vlen) < 0) return -1;
1060 1061
  for (int32_t i = 0; i < vlen; ++i) {
    SVnodeLoad *pload = taosArrayGet(pReq->pVloads, i);
1062
    int64_t     reserved = 0;
S
Shengliang Guan 已提交
1063
    if (tEncodeI32(&encoder, pload->vgId) < 0) return -1;
1064 1065
    if (tEncodeI8(&encoder, pload->syncState) < 0) return -1;
    if (tEncodeI8(&encoder, pload->syncRestore) < 0) return -1;
1066
    if (tEncodeI8(&encoder, pload->syncCanRead) < 0) return -1;
1067
    if (tEncodeI64(&encoder, pload->cacheUsage) < 0) return -1;
S
Shengliang Guan 已提交
1068 1069 1070 1071 1072
    if (tEncodeI64(&encoder, pload->numOfTables) < 0) return -1;
    if (tEncodeI64(&encoder, pload->numOfTimeSeries) < 0) return -1;
    if (tEncodeI64(&encoder, pload->totalStorage) < 0) return -1;
    if (tEncodeI64(&encoder, pload->compStorage) < 0) return -1;
    if (tEncodeI64(&encoder, pload->pointsWritten) < 0) return -1;
D
dapan1121 已提交
1073 1074
    if (tEncodeI32(&encoder, pload->numOfCachedTables) < 0) return -1;
    if (tEncodeI32(&encoder, reserved) < 0) return -1;
1075 1076
    if (tEncodeI64(&encoder, reserved) < 0) return -1;
    if (tEncodeI64(&encoder, reserved) < 0) return -1;
1077 1078
  }

1079
  // mnode loads
1080 1081
  if (tEncodeI8(&encoder, pReq->mload.syncState) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->mload.syncRestore) < 0) return -1;
1082

1083 1084 1085 1086 1087 1088
  if (tEncodeI32(&encoder, pReq->qload.dnodeId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedQuery) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedCQuery) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedFetch) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedDrop) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedHb) < 0) return -1;
D
dapan1121 已提交
1089
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedDelete) < 0) return -1;
1090 1091 1092 1093 1094 1095
  if (tEncodeI64(&encoder, pReq->qload.cacheDataSize) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfQueryInQueue) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.numOfFetchInQueue) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.timeInQueryQueue) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->qload.timeInFetchQueue) < 0) return -1;

1096
  if (tEncodeI32(&encoder, pReq->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1097 1098 1099
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1100
  tEncoderClear(&encoder);
1101 1102 1103
  return tlen;
}

S
Shengliang Guan 已提交
1104
int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
H
Hongze Cheng 已提交
1105 1106
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1107 1108 1109

  if (tStartDecode(&decoder) < 0) return -1;

1110
  // status
S
Shengliang Guan 已提交
1111
  if (tDecodeI32(&decoder, &pReq->sver) < 0) return -1;
1112
  if (tDecodeI64(&decoder, &pReq->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1113 1114 1115 1116
  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->clusterId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->rebootTime) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->updateTime) < 0) return -1;
S
Shengliang Guan 已提交
1117
  if (tDecodeFloat(&decoder, &pReq->numOfCores) < 0) return -1;
S
Shengliang Guan 已提交
1118
  if (tDecodeI32(&decoder, &pReq->numOfSupportVnodes) < 0) return -1;
1119 1120
  if (tDecodeI64(&decoder, &pReq->memTotal) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->memAvail) < 0) return -1;
S
Shengliang Guan 已提交
1121
  if (tDecodeCStrTo(&decoder, pReq->dnodeEp) < 0) return -1;
1122 1123

  // cluster cfg
S
Shengliang Guan 已提交
1124 1125 1126 1127 1128
  if (tDecodeI32(&decoder, &pReq->clusterCfg.statusInterval) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->clusterCfg.checkTime) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->clusterCfg.timezone) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->clusterCfg.locale) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->clusterCfg.charset) < 0) return -1;
1129 1130 1131

  // vnode loads
  int32_t vlen = 0;
S
Shengliang Guan 已提交
1132
  if (tDecodeI32(&decoder, &vlen) < 0) return -1;
1133 1134 1135
  pReq->pVloads = taosArrayInit(vlen, sizeof(SVnodeLoad));
  if (pReq->pVloads == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1136
    return -1;
1137 1138 1139 1140
  }

  for (int32_t i = 0; i < vlen; ++i) {
    SVnodeLoad vload = {0};
1141
    int64_t    reserved = 0;
S
Shengliang Guan 已提交
1142
    if (tDecodeI32(&decoder, &vload.vgId) < 0) return -1;
1143 1144
    if (tDecodeI8(&decoder, &vload.syncState) < 0) return -1;
    if (tDecodeI8(&decoder, &vload.syncRestore) < 0) return -1;
1145
    if (tDecodeI8(&decoder, &vload.syncCanRead) < 0) return -1;
1146
    if (tDecodeI64(&decoder, &vload.cacheUsage) < 0) return -1;
S
Shengliang Guan 已提交
1147 1148 1149 1150 1151
    if (tDecodeI64(&decoder, &vload.numOfTables) < 0) return -1;
    if (tDecodeI64(&decoder, &vload.numOfTimeSeries) < 0) return -1;
    if (tDecodeI64(&decoder, &vload.totalStorage) < 0) return -1;
    if (tDecodeI64(&decoder, &vload.compStorage) < 0) return -1;
    if (tDecodeI64(&decoder, &vload.pointsWritten) < 0) return -1;
D
dapan1121 已提交
1152
    if (tDecodeI32(&decoder, &vload.numOfCachedTables) < 0) return -1;
1153
    if (tDecodeI32(&decoder, (int32_t *)&reserved) < 0) return -1;
1154 1155
    if (tDecodeI64(&decoder, &reserved) < 0) return -1;
    if (tDecodeI64(&decoder, &reserved) < 0) return -1;
1156 1157
    if (taosArrayPush(pReq->pVloads, &vload) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1158
      return -1;
1159 1160 1161
    }
  }

1162 1163
  if (tDecodeI8(&decoder, &pReq->mload.syncState) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->mload.syncRestore) < 0) return -1;
1164

1165 1166 1167 1168 1169 1170
  if (tDecodeI32(&decoder, &pReq->qload.dnodeId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedQuery) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedCQuery) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedFetch) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedDrop) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedHb) < 0) return -1;
D
dapan1121 已提交
1171
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedDelete) < 0) return -1;
1172 1173 1174 1175 1176 1177
  if (tDecodeI64(&decoder, &pReq->qload.cacheDataSize) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfQueryInQueue) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.numOfFetchInQueue) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.timeInQueryQueue) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->qload.timeInFetchQueue) < 0) return -1;

1178
  if (tDecodeI32(&decoder, &pReq->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1179
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
1180
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1181
  return 0;
1182
}
S
Shengliang Guan 已提交
1183

1184 1185
void tFreeSStatusReq(SStatusReq *pReq) { taosArrayDestroy(pReq->pVloads); }

S
Shengliang Guan 已提交
1186
int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
H
Hongze Cheng 已提交
1187 1188
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1189

S
Shengliang Guan 已提交
1190
  if (tStartEncode(&encoder) < 0) return -1;
S
Shengliang Guan 已提交
1191

S
Shengliang Guan 已提交
1192
  // status
1193
  if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1194 1195

  // dnode cfg
S
Shengliang Guan 已提交
1196 1197
  if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId) < 0) return -1;
S
Shengliang Guan 已提交
1198 1199 1200

  // dnode eps
  int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps);
S
Shengliang Guan 已提交
1201
  if (tEncodeI32(&encoder, dlen) < 0) return -1;
S
Shengliang Guan 已提交
1202 1203
  for (int32_t i = 0; i < dlen; ++i) {
    SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i);
S
Shengliang Guan 已提交
1204 1205 1206 1207
    if (tEncodeI32(&encoder, pDnodeEp->id) < 0) return -1;
    if (tEncodeI8(&encoder, pDnodeEp->isMnode) < 0) return -1;
    if (tEncodeCStr(&encoder, pDnodeEp->ep.fqdn) < 0) return -1;
    if (tEncodeU16(&encoder, pDnodeEp->ep.port) < 0) return -1;
S
Shengliang Guan 已提交
1208 1209
  }

1210
  if (tEncodeI32(&encoder, pRsp->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1211 1212 1213
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1214
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1215 1216 1217
  return tlen;
}

S
Shengliang Guan 已提交
1218
int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
H
Hongze Cheng 已提交
1219 1220
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1221 1222 1223

  if (tStartDecode(&decoder) < 0) return -1;

S
Shengliang Guan 已提交
1224
  // status
1225
  if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1226 1227

  // cluster cfg
S
Shengliang Guan 已提交
1228 1229
  if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId) < 0) return -1;
S
Shengliang Guan 已提交
1230 1231 1232

  // dnode eps
  int32_t dlen = 0;
S
Shengliang Guan 已提交
1233
  if (tDecodeI32(&decoder, &dlen) < 0) return -1;
S
Shengliang Guan 已提交
1234 1235 1236
  pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp));
  if (pRsp->pDnodeEps == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1237
    return -1;
S
Shengliang Guan 已提交
1238 1239 1240 1241
  }

  for (int32_t i = 0; i < dlen; ++i) {
    SDnodeEp dnodeEp = {0};
S
Shengliang Guan 已提交
1242 1243 1244 1245
    if (tDecodeI32(&decoder, &dnodeEp.id) < 0) return -1;
    if (tDecodeI8(&decoder, &dnodeEp.isMnode) < 0) return -1;
    if (tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn) < 0) return -1;
    if (tDecodeU16(&decoder, &dnodeEp.ep.port) < 0) return -1;
S
Shengliang Guan 已提交
1246 1247
    if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1248
      return -1;
S
Shengliang Guan 已提交
1249 1250 1251
    }
  }

1252
  if (tDecodeI32(&decoder, &pRsp->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1253
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
1254
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1255
  return 0;
S
Shengliang Guan 已提交
1256
}
1257

S
shm  
Shengliang Guan 已提交
1258 1259
void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); }

1260
int32_t tSerializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
H
Hongze Cheng 已提交
1261 1262
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxUsers) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxDbs) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxTimeSeries) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxStreams) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->accessState) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->maxStorage) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1276
  tEncoderClear(&encoder);
1277 1278 1279
  return tlen;
}

1280
int32_t tDeserializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
H
Hongze Cheng 已提交
1281 1282
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxUsers) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxDbs) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxTimeSeries) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxStreams) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->accessState) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->maxStorage) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1295
  tDecoderClear(&decoder);
1296
  return 0;
1297 1298
}

1299
int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
H
Hongze Cheng 已提交
1300 1301
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1302 1303 1304 1305 1306 1307

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1308
  tEncoderClear(&encoder);
1309 1310 1311
  return tlen;
}

1312
int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
H
Hongze Cheng 已提交
1313 1314
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1315 1316 1317 1318 1319

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1320
  tDecoderClear(&decoder);
1321
  return 0;
1322 1323
}

1324
int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
H
Hongze Cheng 已提交
1325 1326
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1327 1328 1329 1330

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->createType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1;
1331 1332
  if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->enable) < 0) return -1;
1333 1334 1335 1336 1337
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1338
  tEncoderClear(&encoder);
1339 1340 1341
  return tlen;
}

1342
int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
H
Hongze Cheng 已提交
1343 1344
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1345 1346 1347 1348

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1;
1349 1350
  if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1;
1351 1352 1353 1354
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1355
  tDecoderClear(&decoder);
1356
  return 0;
1357 1358
}

1359
int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
H
Hongze Cheng 已提交
1360 1361
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1362 1363 1364 1365

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1;
1366 1367
  if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->enable) < 0) return -1;
1368 1369
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
1370
  if (tEncodeCStr(&encoder, pReq->objname) < 0) return -1;
1371 1372 1373 1374 1375
  int32_t len = strlen(pReq->tabName);
  if (tEncodeI32(&encoder, len) < 0) return -1;
  if (len > 0) {
    if (tEncodeCStr(&encoder, pReq->tabName) < 0) return -1;
  }
1376
  if (tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen) < 0) return -1;
1377 1378 1379
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1380
  tEncoderClear(&encoder);
1381 1382 1383
  return tlen;
}

1384
int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
H
Hongze Cheng 已提交
1385 1386
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1387 1388 1389 1390

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1;
1391 1392
  if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1;
1393 1394
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
1395
  if (tDecodeCStrTo(&decoder, pReq->objname) < 0) return -1;
1396 1397 1398 1399 1400 1401
  if (!tDecodeIsEnd(&decoder)) {
    int32_t len = 0;
    if (tDecodeI32(&decoder, &len) < 0) return -1;
    if (len > 0) {
      if (tDecodeCStrTo(&decoder, pReq->tabName) < 0) return -1;
    }
1402 1403 1404
    uint64_t tagCondLen = 0;
    if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen) < 0) return -1;
    pReq->tagCondLen = tagCondLen;
1405
  }
1406 1407
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1408
  tDecoderClear(&decoder);
1409
  return 0;
1410 1411
}

1412 1413
void tFreeSAlterUserReq(SAlterUserReq *pReq) { taosMemoryFreeClear(pReq->tagCond); }

1414
int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
H
Hongze Cheng 已提交
1415 1416
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1417 1418 1419 1420 1421 1422

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1423
  tEncoderClear(&encoder);
1424 1425 1426
  return tlen;
}

1427
int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
H
Hongze Cheng 已提交
1428 1429
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1430 1431 1432 1433 1434

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1435
  tDecoderClear(&decoder);
1436
  return 0;
1437 1438
}

H
Hongze Cheng 已提交
1439
int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1440 1441
  if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1;
1442 1443 1444
  if (tEncodeI8(pEncoder, pRsp->sysInfo) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->enable) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->reserve) < 0) return -1;
D
dapan 已提交
1445
  if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1;
1446

D
dapan 已提交
1447
  int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
S
Shengliang Guan 已提交
1448 1449
  int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
  int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
C
cademfly 已提交
1450

D
dapan 已提交
1451 1452 1453
  if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1;
1454

D
dapan 已提交
1455
  char *db = taosHashIterate(pRsp->createdDbs, NULL);
1456
  while (db != NULL) {
D
dapan 已提交
1457 1458 1459 1460 1461 1462 1463
    if (tEncodeCStr(pEncoder, db) < 0) return -1;
    db = taosHashIterate(pRsp->createdDbs, db);
  }

  db = taosHashIterate(pRsp->readDbs, NULL);
  while (db != NULL) {
    if (tEncodeCStr(pEncoder, db) < 0) return -1;
S
Shengliang Guan 已提交
1464
    db = taosHashIterate(pRsp->readDbs, db);
1465 1466
  }

S
Shengliang Guan 已提交
1467
  db = taosHashIterate(pRsp->writeDbs, NULL);
1468
  while (db != NULL) {
D
dapan 已提交
1469
    if (tEncodeCStr(pEncoder, db) < 0) return -1;
S
Shengliang Guan 已提交
1470
    db = taosHashIterate(pRsp->writeDbs, db);
1471 1472
  }

1473 1474 1475 1476 1477 1478 1479
  int32_t numOfReadTbs = taosHashGetSize(pRsp->readTbs);
  int32_t numOfWriteTbs = taosHashGetSize(pRsp->writeTbs);
  int32_t numOfUseTbs = taosHashGetSize(pRsp->useDbs);
  if (tEncodeI32(pEncoder, numOfReadTbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfWriteTbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfUseTbs) < 0) return -1;

C
cademfly 已提交
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
  char *tb = taosHashIterate(pRsp->readTbs, NULL);
  while (tb != NULL) {
    size_t keyLen = 0;
    void  *key = taosHashGetKey(tb, &keyLen);
    if (tEncodeI32(pEncoder, keyLen) < 0) return -1;
    if (tEncodeCStr(pEncoder, key) < 0) return -1;

    size_t valueLen = 0;
    valueLen = strlen(tb);
    if (tEncodeI32(pEncoder, valueLen) < 0) return -1;
    if (tEncodeCStr(pEncoder, tb) < 0) return -1;

    tb = taosHashIterate(pRsp->readTbs, tb);
  }

  tb = taosHashIterate(pRsp->writeTbs, NULL);
  while (tb != NULL) {
    size_t keyLen = 0;
    void  *key = taosHashGetKey(tb, &keyLen);
    if (tEncodeI32(pEncoder, keyLen) < 0) return -1;
    if (tEncodeCStr(pEncoder, key) < 0) return -1;

    size_t valueLen = 0;
    valueLen = strlen(tb);
    if (tEncodeI32(pEncoder, valueLen) < 0) return -1;
    if (tEncodeCStr(pEncoder, tb) < 0) return -1;

    tb = taosHashIterate(pRsp->writeTbs, tb);
  }

1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
  int32_t *useDb = taosHashIterate(pRsp->useDbs, NULL);
  while (useDb != NULL) {
    size_t keyLen = 0;
    void  *key = taosHashGetKey(useDb, &keyLen);
    if (tEncodeI32(pEncoder, keyLen) < 0) return -1;
    if (tEncodeCStr(pEncoder, key) < 0) return -1;

    if (tEncodeI32(pEncoder, *useDb) < 0) return -1;
    useDb = taosHashIterate(pRsp->useDbs, useDb);
  }

D
dapan 已提交
1521 1522 1523 1524
  return 0;
}

int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
H
Hongze Cheng 已提交
1525 1526
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
1527 1528 1529 1530 1531

  if (tStartEncode(&encoder) < 0) return -1;

  if (tSerializeSGetUserAuthRspImpl(&encoder, pRsp) < 0) return -1;

1532 1533 1534
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1535
  tEncoderClear(&encoder);
1536 1537 1538
  return tlen;
}

H
Hongze Cheng 已提交
1539
int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1540 1541 1542
  pRsp->createdDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
  pRsp->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
  pRsp->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
1543 1544
  pRsp->readTbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
  pRsp->writeTbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
1545 1546 1547
  pRsp->useDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
  if (pRsp->createdDbs == NULL || pRsp->readDbs == NULL || pRsp->writeDbs == NULL || pRsp->readTbs == NULL ||
      pRsp->writeTbs == NULL || pRsp->useDbs == NULL) {
1548
    return -1;
1549 1550
  }

D
dapan 已提交
1551 1552
  if (tDecodeCStrTo(pDecoder, pRsp->user) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->superAuth) < 0) return -1;
1553 1554 1555
  if (tDecodeI8(pDecoder, &pRsp->sysInfo) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->enable) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->reserve) < 0) return -1;
D
dapan 已提交
1556
  if (tDecodeI32(pDecoder, &pRsp->version) < 0) return -1;
1557

D
dapan 已提交
1558
  int32_t numOfCreatedDbs = 0;
1559 1560
  int32_t numOfReadDbs = 0;
  int32_t numOfWriteDbs = 0;
D
dapan 已提交
1561 1562 1563 1564 1565 1566 1567
  if (tDecodeI32(pDecoder, &numOfCreatedDbs) < 0) return -1;
  if (tDecodeI32(pDecoder, &numOfReadDbs) < 0) return -1;
  if (tDecodeI32(pDecoder, &numOfWriteDbs) < 0) return -1;

  for (int32_t i = 0; i < numOfCreatedDbs; ++i) {
    char db[TSDB_DB_FNAME_LEN] = {0};
    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
D
fix bug  
dapan 已提交
1568
    int32_t len = strlen(db);
D
dapan 已提交
1569 1570
    taosHashPut(pRsp->createdDbs, db, len, db, len);
  }
1571 1572 1573

  for (int32_t i = 0; i < numOfReadDbs; ++i) {
    char db[TSDB_DB_FNAME_LEN] = {0};
D
dapan 已提交
1574
    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
D
fix bug  
dapan 已提交
1575
    int32_t len = strlen(db);
S
Shengliang Guan 已提交
1576
    taosHashPut(pRsp->readDbs, db, len, db, len);
1577 1578 1579 1580
  }

  for (int32_t i = 0; i < numOfWriteDbs; ++i) {
    char db[TSDB_DB_FNAME_LEN] = {0};
D
dapan 已提交
1581
    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
D
fix bug  
dapan 已提交
1582
    int32_t len = strlen(db);
S
Shengliang Guan 已提交
1583
    taosHashPut(pRsp->writeDbs, db, len, db, len);
1584 1585
  }

1586 1587 1588 1589 1590 1591 1592
  if (!tDecodeIsEnd(pDecoder)) {
    int32_t numOfReadTbs = 0;
    int32_t numOfWriteTbs = 0;
    int32_t numOfUseDbs = 0;
    if (tDecodeI32(pDecoder, &numOfReadTbs) < 0) return -1;
    if (tDecodeI32(pDecoder, &numOfWriteTbs) < 0) return -1;
    if (tDecodeI32(pDecoder, &numOfUseDbs) < 0) return -1;
C
cademfly 已提交
1593

1594 1595 1596
    for (int32_t i = 0; i < numOfReadTbs; ++i) {
      int32_t keyLen = 0;
      if (tDecodeI32(pDecoder, &keyLen) < 0) return -1;
C
cademfly 已提交
1597

1598 1599
      char *key = taosMemoryCalloc(keyLen + 1, sizeof(char));
      if (tDecodeCStrTo(pDecoder, key) < 0) return -1;
C
cademfly 已提交
1600

1601 1602 1603 1604
      int32_t valuelen = 0;
      if (tDecodeI32(pDecoder, &valuelen) < 0) return -1;
      char *value = taosMemoryCalloc(valuelen + 1, sizeof(char));
      if (tDecodeCStrTo(pDecoder, value) < 0) return -1;
C
cademfly 已提交
1605

1606 1607 1608 1609 1610
      taosHashPut(pRsp->readTbs, key, strlen(key), value, valuelen + 1);

      taosMemoryFree(key);
      taosMemoryFree(value);
    }
C
cademfly 已提交
1611

1612 1613 1614
    for (int32_t i = 0; i < numOfWriteTbs; ++i) {
      int32_t keyLen = 0;
      if (tDecodeI32(pDecoder, &keyLen) < 0) return -1;
C
cademfly 已提交
1615

1616 1617
      char *key = taosMemoryCalloc(keyLen + 1, sizeof(char));
      if (tDecodeCStrTo(pDecoder, key) < 0) return -1;
C
cademfly 已提交
1618

1619 1620 1621 1622
      int32_t valuelen = 0;
      if (tDecodeI32(pDecoder, &valuelen) < 0) return -1;
      char *value = taosMemoryCalloc(valuelen + 1, sizeof(char));
      if (tDecodeCStrTo(pDecoder, value) < 0) return -1;
C
cademfly 已提交
1623

1624
      taosHashPut(pRsp->writeTbs, key, strlen(key), value, valuelen + 1);
C
cademfly 已提交
1625

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
      taosMemoryFree(key);
      taosMemoryFree(value);
    }

    for (int32_t i = 0; i < numOfUseDbs; ++i) {
      int32_t keyLen = 0;
      if (tDecodeI32(pDecoder, &keyLen) < 0) return -1;

      char *key = taosMemoryCalloc(keyLen + 1, sizeof(char));
      if (tDecodeCStrTo(pDecoder, key) < 0) return -1;

      int32_t ref = 0;
      if (tDecodeI32(pDecoder, &ref) < 0) return -1;
      taosHashPut(pRsp->useDbs, key, strlen(key), &ref, sizeof(ref));
1640
      taosMemoryFree(key);
1641
    }
C
cademfly 已提交
1642 1643
  }

D
dapan 已提交
1644 1645 1646 1647
  return 0;
}

int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
H
Hongze Cheng 已提交
1648 1649
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
1650 1651 1652 1653 1654

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDeserializeSGetUserAuthRspImpl(&decoder, pRsp) < 0) return -1;

1655 1656
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1657
  tDecoderClear(&decoder);
1658
  return 0;
1659
}
S
Shengliang Guan 已提交
1660

1661
void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1662
  taosHashCleanup(pRsp->createdDbs);
1663 1664
  taosHashCleanup(pRsp->readDbs);
  taosHashCleanup(pRsp->writeDbs);
X
Xiaoyu Wang 已提交
1665 1666
  taosHashCleanup(pRsp->writeTbs);
  taosHashCleanup(pRsp->readTbs);
1667
  taosHashCleanup(pRsp->useDbs);
1668 1669
}

1670
int32_t tSerializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
H
Hongze Cheng 已提交
1671 1672
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1673 1674 1675 1676 1677 1678

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1679
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1680 1681 1682
  return tlen;
}

1683
int32_t tDeserializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
H
Hongze Cheng 已提交
1684 1685
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1686 1687 1688 1689 1690

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1691
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1692 1693
  return 0;
}
S
Shengliang Guan 已提交
1694 1695

int32_t tSerializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
H
Hongze Cheng 已提交
1696 1697
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1698 1699 1700 1701 1702

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->port) < 0) return -1;
1703
  if (tEncodeI8(&encoder, pReq->force) < 0) return -1;
1704 1705 1706
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1707
  tEncoderClear(&encoder);
1708
  return tlen;
S
Shengliang Guan 已提交
1709 1710 1711
}

int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
H
Hongze Cheng 已提交
1712 1713
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1714 1715 1716 1717 1718

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->port) < 0) return -1;
1719
  if (tDecodeI8(&decoder, &pReq->force) < 0) return -1;
1720 1721
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1722
  tDecoderClear(&decoder);
1723
  return 0;
S
Shengliang Guan 已提交
1724 1725 1726
}

int32_t tSerializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) {
H
Hongze Cheng 已提交
1727 1728
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1729 1730 1731 1732 1733 1734 1735 1736

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->config) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->value) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1737
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1738 1739 1740 1741
  return tlen;
}

int32_t tDeserializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) {
H
Hongze Cheng 已提交
1742 1743
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1744 1745 1746 1747 1748 1749 1750

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1751
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1752 1753 1754
  return 0;
}

1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
int32_t tSerializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->config) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->value) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

S
Shengliang Guan 已提交
1782
int32_t tSerializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) {
H
Hongze Cheng 已提交
1783 1784
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1785 1786 1787 1788 1789 1790 1791

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->port) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1792
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1793 1794 1795 1796
  return tlen;
}

int32_t tDeserializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) {
H
Hongze Cheng 已提交
1797 1798
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1799 1800 1801 1802 1803 1804

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->port) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1805
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1806 1807
  return 0;
}
S
Shengliang Guan 已提交
1808 1809

int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
H
Hongze Cheng 已提交
1810 1811
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->funcType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->scriptType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->outputType) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1;
1821
  if (tEncodeI32(&encoder, pReq->codeLen) < 0) return -1;
S
Shengliang Guan 已提交
1822
  if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
1823 1824

  if (pReq->pCode != NULL) {
1825
    if (tEncodeBinary(&encoder, pReq->pCode, pReq->codeLen) < 0) return -1;
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
  }

  int32_t commentSize = 0;
  if (pReq->pComment != NULL) {
    commentSize = strlen(pReq->pComment) + 1;
  }
  if (tEncodeI32(&encoder, commentSize) < 0) return -1;
  if (pReq->pComment != NULL) {
    if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
  }

1837 1838
  if (tEncodeI8(&encoder, pReq->orReplace) < 0) return -1;

S
Shengliang Guan 已提交
1839 1840 1841
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1842
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1843 1844 1845 1846
  return tlen;
}

int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
H
Hongze Cheng 已提交
1847 1848
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1849 1850 1851 1852 1853 1854 1855 1856 1857

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->funcType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->scriptType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->outputType) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1;
1858
  if (tDecodeI32(&decoder, &pReq->codeLen) < 0) return -1;
S
Shengliang Guan 已提交
1859
  if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
1860

1861 1862
  if (pReq->codeLen > 0) {
    pReq->pCode = taosMemoryCalloc(1, pReq->codeLen);
1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
    if (pReq->pCode == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
    if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1;
  }

  int32_t commentSize = 0;
  if (tDecodeI32(&decoder, &commentSize) < 0) return -1;
  if (commentSize > 0) {
    pReq->pComment = taosMemoryCalloc(1, commentSize);
    if (pReq->pComment == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
    if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
  }

1881 1882 1883 1884 1885 1886
  if (!tDecodeIsEnd(&decoder)) {
    if (tDecodeI8(&decoder, &pReq->orReplace) < 0) return -1;
  } else {
    pReq->orReplace = false;
  }

S
Shengliang Guan 已提交
1887 1888
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1889
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1890 1891 1892
  return 0;
}

1893 1894 1895 1896 1897
void tFreeSCreateFuncReq(SCreateFuncReq *pReq) {
  taosMemoryFree(pReq->pCode);
  taosMemoryFree(pReq->pComment);
}

S
Shengliang Guan 已提交
1898
int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
H
Hongze Cheng 已提交
1899 1900
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1901 1902 1903 1904 1905 1906 1907

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1908
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1909 1910 1911 1912
  return tlen;
}

int32_t tDeserializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
H
Hongze Cheng 已提交
1913 1914
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1915 1916 1917 1918 1919 1920

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1921
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1922 1923 1924 1925
  return 0;
}

int32_t tSerializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
H
Hongze Cheng 已提交
1926 1927
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1928 1929 1930

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
D
dapan1121 已提交
1931
  if (tEncodeI8(&encoder, pReq->ignoreCodeComment) < 0) return -1;
S
Shengliang Guan 已提交
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941

  if (pReq->numOfFuncs != (int32_t)taosArrayGetSize(pReq->pFuncNames)) return -1;
  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
    char *fname = taosArrayGet(pReq->pFuncNames, i);
    if (tEncodeCStr(&encoder, fname) < 0) return -1;
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1942
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1943 1944 1945 1946
  return tlen;
}

int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
H
Hongze Cheng 已提交
1947 1948
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1949 1950 1951

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
D
dapan1121 已提交
1952
  if (tDecodeI8(&decoder, (int8_t *)&pReq->ignoreCodeComment) < 0) return -1;
S
Shengliang Guan 已提交
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963

  pReq->pFuncNames = taosArrayInit(pReq->numOfFuncs, TSDB_FUNC_NAME_LEN);
  if (pReq->pFuncNames == NULL) return -1;

  for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
    char fname[TSDB_FUNC_NAME_LEN] = {0};
    if (tDecodeCStrTo(&decoder, fname) < 0) return -1;
    taosArrayPush(pReq->pFuncNames, fname);
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1964
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1965 1966 1967
  return 0;
}

1968 1969
void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); }

S
Shengliang Guan 已提交
1970
int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
H
Hongze Cheng 已提交
1971 1972
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfFuncs) < 0) return -1;

  if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncInfos)) return -1;
  for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
    SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i);

    if (tEncodeCStr(&encoder, pInfo->name) < 0) return -1;
    if (tEncodeI8(&encoder, pInfo->funcType) < 0) return -1;
    if (tEncodeI8(&encoder, pInfo->scriptType) < 0) return -1;
    if (tEncodeI8(&encoder, pInfo->outputType) < 0) return -1;
    if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1;
    if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1;
    if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1;
    if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1;
1989
    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
D
dapan1121 已提交
1990
    if (pInfo->codeSize) {
1991
      if (tEncodeBinary(&encoder, pInfo->pCode, pInfo->codeSize) < 0) return -1;
D
dapan1121 已提交
1992 1993 1994 1995
    }
    if (pInfo->commentSize) {
      if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
    }
S
Shengliang Guan 已提交
1996 1997
  }

1998
  if (pRsp->numOfFuncs != (int32_t)taosArrayGetSize(pRsp->pFuncExtraInfos)) return -1;
1999
  for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
2000 2001 2002
    SFuncExtraInfo *extraInfo = taosArrayGet(pRsp->pFuncExtraInfos, i);
    if (tEncodeI32(&encoder, extraInfo->funcVersion) < 0) return -1;
    if (tEncodeI64(&encoder, extraInfo->funcCreatedTime) < 0) return -1;
2003 2004
  }

S
Shengliang Guan 已提交
2005 2006 2007
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2008
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2009 2010 2011 2012
  return tlen;
}

int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
H
Hongze Cheng 已提交
2013 2014
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfFuncs) < 0) return -1;

  pRsp->pFuncInfos = taosArrayInit(pRsp->numOfFuncs, sizeof(SFuncInfo));
  if (pRsp->pFuncInfos == NULL) return -1;

  for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
    SFuncInfo fInfo = {0};
    if (tDecodeCStrTo(&decoder, fInfo.name) < 0) return -1;
    if (tDecodeI8(&decoder, &fInfo.funcType) < 0) return -1;
    if (tDecodeI8(&decoder, &fInfo.scriptType) < 0) return -1;
    if (tDecodeI8(&decoder, &fInfo.outputType) < 0) return -1;
    if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1;
    if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1;
    if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1;
    if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1;
2032
    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
D
dapan1121 已提交
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
    if (fInfo.codeSize) {
      fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize);
      if (fInfo.pCode == NULL) {
        terrno = TSDB_CODE_OUT_OF_MEMORY;
        return -1;
      }
      if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1;
    }
    if (fInfo.commentSize) {
      fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize);
      if (fInfo.pComment == NULL) {
        terrno = TSDB_CODE_OUT_OF_MEMORY;
        return -1;
      }
      if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
2048 2049
    }

S
Shengliang Guan 已提交
2050 2051
    taosArrayPush(pRsp->pFuncInfos, &fInfo);
  }
2052

2053 2054
  pRsp->pFuncExtraInfos = taosArrayInit(pRsp->numOfFuncs, sizeof(SFuncExtraInfo));
  if (pRsp->pFuncExtraInfos == NULL) return -1;
2055 2056
  if (tDecodeIsEnd(&decoder)) {
    for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
2057
      SFuncExtraInfo extraInfo = {0};
2058
      taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo);
2059 2060 2061
    }
  } else {
    for (int32_t i = 0; i < pRsp->numOfFuncs; ++i) {
2062
      SFuncExtraInfo extraInfo = {0};
2063 2064 2065
      if (tDecodeI32(&decoder, &extraInfo.funcVersion) < 0) return -1;
      if (tDecodeI64(&decoder, &extraInfo.funcCreatedTime) < 0) return -1;
      taosArrayPush(pRsp->pFuncExtraInfos, &extraInfo);
2066
    }
2067
  }
S
Shengliang Guan 已提交
2068 2069
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2070
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2071 2072
  return 0;
}
S
Shengliang Guan 已提交
2073

D
dapan1121 已提交
2074 2075 2076 2077 2078 2079 2080 2081 2082
void tFreeSFuncInfo(SFuncInfo *pInfo) {
  if (NULL == pInfo) {
    return;
  }

  taosMemoryFree(pInfo->pCode);
  taosMemoryFree(pInfo->pComment);
}

2083 2084 2085 2086
void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp *pRsp) {
  int32_t size = taosArrayGetSize(pRsp->pFuncInfos);
  for (int32_t i = 0; i < size; ++i) {
    SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i);
D
dapan1121 已提交
2087
    tFreeSFuncInfo(pInfo);
2088 2089
  }
  taosArrayDestroy(pRsp->pFuncInfos);
2090
  taosArrayDestroy(pRsp->pFuncExtraInfos);
2091 2092
}

D
dapan1121 已提交
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
int32_t tSerializeSTableCfgReq(void *buf, int32_t bufLen, STableCfgReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->dbFName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->tbName) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSTableCfgReq(void *buf, int32_t bufLen, STableCfgReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->dbFName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->tbName) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp) {
D
dapan1121 已提交
2140 2141
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2142

D
dapan1121 已提交
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->tbName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->stbName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfTags) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfColumns) < 0) return -1;
  if (tEncodeI8(&encoder, pRsp->tableType) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->delay1) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->delay2) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->watermark1) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->watermark2) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->ttl) < 0) return -1;
2155

D
dapan1121 已提交
2156 2157 2158 2159 2160 2161 2162
  int32_t numOfFuncs = taosArrayGetSize(pRsp->pFuncs);
  if (tEncodeI32(&encoder, numOfFuncs) < 0) return -1;
  for (int32_t i = 0; i < numOfFuncs; ++i) {
    const char *pFunc = taosArrayGet(pRsp->pFuncs, i);
    if (tEncodeCStr(&encoder, pFunc) < 0) return -1;
  }

2163
  if (tEncodeI32(&encoder, pRsp->commentLen) < 0) return -1;
D
dapan1121 已提交
2164 2165 2166
  if (pRsp->commentLen > 0) {
    if (tEncodeCStr(&encoder, pRsp->pComment) < 0) return -1;
  }
2167

D
dapan1121 已提交
2168 2169 2170 2171 2172
  for (int32_t i = 0; i < pRsp->numOfColumns + pRsp->numOfTags; ++i) {
    SSchema *pSchema = &pRsp->pSchemas[i];
    if (tEncodeSSchema(&encoder, pSchema) < 0) return -1;
  }

2173 2174 2175
  if (tEncodeI32(&encoder, pRsp->tagsLen) < 0) return -1;
  if (tEncodeBinary(&encoder, pRsp->pTags, pRsp->tagsLen) < 0) return -1;

D
dapan1121 已提交
2176 2177 2178 2179 2180
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
D
dapan1121 已提交
2181 2182 2183
}

int32_t tDeserializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp) {
D
dapan1121 已提交
2184 2185
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2186

D
dapan1121 已提交
2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->tbName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->stbName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfTags) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfColumns) < 0) return -1;
  if (tDecodeI8(&decoder, &pRsp->tableType) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->delay1) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->delay2) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->watermark1) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->watermark2) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->ttl) < 0) return -1;

  int32_t numOfFuncs = 0;
  if (tDecodeI32(&decoder, &numOfFuncs) < 0) return -1;
  if (numOfFuncs > 0) {
    pRsp->pFuncs = taosArrayInit(numOfFuncs, TSDB_FUNC_NAME_LEN);
    if (NULL == pRsp->pFuncs) return -1;
  }
  for (int32_t i = 0; i < numOfFuncs; ++i) {
    char pFunc[TSDB_FUNC_NAME_LEN];
    if (tDecodeCStrTo(&decoder, pFunc) < 0) return -1;
    if (taosArrayPush(pRsp->pFuncs, pFunc) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

  if (tDecodeI32(&decoder, &pRsp->commentLen) < 0) return -1;
  if (pRsp->commentLen > 0) {
    if (tDecodeCStrAlloc(&decoder, &pRsp->pComment) < 0) return -1;
  } else {
    pRsp->pComment = NULL;
  }

  int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
  pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
  if (pRsp->pSchemas == NULL) return -1;

  for (int32_t i = 0; i < totalCols; ++i) {
    SSchema *pSchema = &pRsp->pSchemas[i];
    if (tDecodeSSchema(&decoder, pSchema) < 0) return -1;
  }

  if (tDecodeI32(&decoder, &pRsp->tagsLen) < 0) return -1;
2232
  if (tDecodeBinaryAlloc(&decoder, (void **)&pRsp->pTags, NULL) < 0) return -1;
D
dapan1121 已提交
2233 2234 2235 2236 2237

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
D
dapan1121 已提交
2238 2239
}

D
dapan1121 已提交
2240 2241 2242 2243 2244 2245 2246 2247
void tFreeSTableCfgRsp(STableCfgRsp *pRsp) {
  if (NULL == pRsp) {
    return;
  }

  taosMemoryFreeClear(pRsp->pComment);
  taosMemoryFreeClear(pRsp->pSchemas);
  taosMemoryFreeClear(pRsp->pTags);
2248

D
dapan1121 已提交
2249 2250
  taosArrayDestroy(pRsp->pFuncs);
}
D
dapan1121 已提交
2251

S
Shengliang Guan 已提交
2252
int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
H
Hongze Cheng 已提交
2253 2254
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2255 2256 2257 2258

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfVgroups) < 0) return -1;
2259 2260 2261 2262
  if (tEncodeI32(&encoder, pReq->numOfStables) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
2263
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2264 2265 2266 2267 2268 2269
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxRows) < 0) return -1;
2270
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2271 2272 2273 2274
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
2275
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
2276
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
2277
  if (tEncodeI8(&encoder, pReq->schemaless) < 0) return -1;
2278
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
2279
  if (tEncodeI64(&encoder, pReq->walRetentionSize) < 0) return -1;
2280
  if (tEncodeI32(&encoder, pReq->walRollPeriod) < 0) return -1;
2281
  if (tEncodeI64(&encoder, pReq->walSegmentSize) < 0) return -1;
2282
  if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1;
2283 2284
  if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1;
  if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2285
  if (tEncodeI8(&encoder, pReq->ignoreExist) < 0) return -1;
S
Shengliang Guan 已提交
2286 2287 2288
  if (tEncodeI32(&encoder, pReq->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pReq->pRetensions, i);
2289 2290
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
2291 2292
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
S
Shengliang Guan 已提交
2293
  }
2294
  if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1;
S
Shengliang Guan 已提交
2295 2296 2297
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2298
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2299 2300 2301 2302
  return tlen;
}

int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
H
Hongze Cheng 已提交
2303 2304
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2305 2306 2307 2308

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfVgroups) < 0) return -1;
2309 2310 2311 2312
  if (tDecodeI32(&decoder, &pReq->numOfStables) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
2313
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2314 2315 2316 2317 2318 2319
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxRows) < 0) return -1;
2320
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2321 2322 2323 2324
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
2325
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
2326
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
2327
  if (tDecodeI8(&decoder, &pReq->schemaless) < 0) return -1;
2328
  if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
2329
  if (tDecodeI64(&decoder, &pReq->walRetentionSize) < 0) return -1;
2330
  if (tDecodeI32(&decoder, &pReq->walRollPeriod) < 0) return -1;
2331
  if (tDecodeI64(&decoder, &pReq->walSegmentSize) < 0) return -1;
2332
  if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1;
2333 2334
  if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1;
  if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2335
  if (tDecodeI8(&decoder, &pReq->ignoreExist) < 0) return -1;
S
Shengliang Guan 已提交
2336 2337 2338 2339 2340 2341 2342 2343 2344
  if (tDecodeI32(&decoder, &pReq->numOfRetensions) < 0) return -1;
  pReq->pRetensions = taosArrayInit(pReq->numOfRetensions, sizeof(SRetention));
  if (pReq->pRetensions == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention rentension = {0};
2345 2346
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
2347 2348
    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
S
Shengliang Guan 已提交
2349 2350 2351 2352 2353 2354
    if (taosArrayPush(pReq->pRetensions, &rentension) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

2355 2356
  if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1;

S
Shengliang Guan 已提交
2357 2358
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2359
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2360 2361 2362
  return 0;
}

S
Shengliang Guan 已提交
2363 2364 2365 2366 2367
void tFreeSCreateDbReq(SCreateDbReq *pReq) {
  taosArrayDestroy(pReq->pRetensions);
  pReq->pRetensions = NULL;
}

S
Shengliang Guan 已提交
2368
int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
H
Hongze Cheng 已提交
2369 2370
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2371 2372 2373

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
2374 2375 2376
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
2377
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
2378
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
2379 2380 2381
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
2382
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2383
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
2384
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
2385
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2386
  if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
2387
  if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1;
H
Hongze Cheng 已提交
2388 2389

  // 1st modification
2390
  if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1;
2391 2392 2393
  // 2nd modification
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->walRetentionSize) < 0) return -1;
S
Shengliang Guan 已提交
2394 2395 2396
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2397
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2398 2399 2400 2401
  return tlen;
}

int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
H
Hongze Cheng 已提交
2402 2403
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2404 2405 2406

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
2407 2408 2409
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
2410
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
2411
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
2412 2413 2414
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
2415
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2416
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
2417
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
2418
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2419
  if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
2420
  if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1;
H
Hongze Cheng 已提交
2421 2422

  // 1st modification
2423 2424
  if (!tDecodeIsEnd(&decoder)) {
    if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1;
H
Hongze Cheng 已提交
2425 2426
  } else {
    pReq->minRows = -1;
2427
  }
2428 2429 2430 2431 2432 2433 2434 2435 2436

  // 2nd modification
  if (!tDecodeIsEnd(&decoder)) {
    if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
    if (tDecodeI32(&decoder, &pReq->walRetentionSize) < 0) return -1;
  } else {
    pReq->walRetentionPeriod = -1;
    pReq->walRetentionSize = -1;
  }
S
Shengliang Guan 已提交
2437 2438
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2439
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2440 2441 2442 2443
  return 0;
}

int32_t tSerializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
H
Hongze Cheng 已提交
2444 2445
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2446 2447 2448 2449 2450 2451 2452

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->ignoreNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2453
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2454 2455 2456 2457
  return tlen;
}

int32_t tDeserializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
H
Hongze Cheng 已提交
2458 2459
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2460 2461 2462 2463 2464 2465

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->ignoreNotExists) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2466
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2467 2468 2469 2470
  return 0;
}

int32_t tSerializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
H
Hongze Cheng 已提交
2471 2472
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2473 2474 2475

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2476
  if (tEncodeI64(&encoder, pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2477 2478 2479
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2480
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2481 2482 2483 2484
  return tlen;
}

int32_t tDeserializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
H
Hongze Cheng 已提交
2485 2486
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2487 2488 2489

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2490
  if (tDecodeI64(&decoder, &pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2491 2492
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2493
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2494 2495 2496 2497
  return 0;
}

int32_t tSerializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
H
Hongze Cheng 已提交
2498 2499
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2500 2501 2502

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
D
dapan1121 已提交
2503
  if (tEncodeI64(&encoder, pReq->dbId) < 0) return -1;
S
Shengliang Guan 已提交
2504
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
D
dapan1121 已提交
2505
  if (tEncodeI32(&encoder, pReq->numOfTable) < 0) return -1;
2506
  if (tEncodeI64(&encoder, pReq->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2507 2508 2509
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2510
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2511 2512 2513 2514
  return tlen;
}

int32_t tDeserializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
H
Hongze Cheng 已提交
2515 2516
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2517 2518 2519

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
D
dapan1121 已提交
2520
  if (tDecodeI64(&decoder, &pReq->dbId) < 0) return -1;
S
Shengliang Guan 已提交
2521
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
D
dapan1121 已提交
2522
  if (tDecodeI32(&decoder, &pReq->numOfTable) < 0) return -1;
2523
  if (tDecodeI64(&decoder, &pReq->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2524 2525
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2526
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2527 2528 2529
  return 0;
}

L
Liu Jicong 已提交
2530
int32_t tSerializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) {
H
Hongze Cheng 已提交
2531 2532
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2533 2534 2535 2536 2537 2538

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->rowNum) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2539
  tEncoderClear(&encoder);
D
dapan1121 已提交
2540 2541 2542 2543
  return tlen;
}

int32_t tDeserializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) {
H
Hongze Cheng 已提交
2544 2545
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2546 2547 2548 2549 2550

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->rowNum) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2551
  tDecoderClear(&decoder);
D
dapan1121 已提交
2552 2553 2554
  return 0;
}

D
dapan1121 已提交
2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
int32_t tSerializeSDnodeListReq(void *buf, int32_t bufLen, SDnodeListReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->rowNum) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSDnodeListReq(void *buf, int32_t bufLen, SDnodeListReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->rowNum) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
int32_t tSerializeSServerVerReq(void *buf, int32_t bufLen, SServerVerReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSServerVerReq(void *buf, int32_t bufLen, SServerVerReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSServerVerRsp(void *buf, int32_t bufLen, SServerVerRsp *pRsp) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->ver) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSServerVerRsp(void *buf, int32_t bufLen, SServerVerRsp *pRsp) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->ver) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
2630
int32_t tSerializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
H
Hongze Cheng 已提交
2631 2632
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2633 2634

  if (tStartEncode(&encoder) < 0) return -1;
2635
  int32_t num = taosArrayGetSize(pRsp->qnodeList);
L
Liu Jicong 已提交
2636
  if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
2637
  for (int32_t i = 0; i < num; ++i) {
2638 2639
    SQueryNodeLoad *pLoad = taosArrayGet(pRsp->qnodeList, i);
    if (tEncodeSQueryNodeLoad(&encoder, pLoad) < 0) return -1;
D
dapan1121 已提交
2640 2641 2642 2643
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2644
  tEncoderClear(&encoder);
D
dapan1121 已提交
2645 2646 2647 2648
  return tlen;
}

int32_t tDeserializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
H
Hongze Cheng 已提交
2649 2650
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2651 2652 2653 2654

  if (tStartDecode(&decoder) < 0) return -1;
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
2655 2656 2657
  if (NULL == pRsp->qnodeList) {
    pRsp->qnodeList = taosArrayInit(num, sizeof(SQueryNodeLoad));
    if (NULL == pRsp->qnodeList) return -1;
D
dapan 已提交
2658
  }
2659

D
dapan1121 已提交
2660
  for (int32_t i = 0; i < num; ++i) {
2661 2662 2663
    SQueryNodeLoad load = {0};
    if (tDecodeSQueryNodeLoad(&decoder, &load) < 0) return -1;
    taosArrayPush(pRsp->qnodeList, &load);
D
dapan1121 已提交
2664 2665 2666
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2667
  tDecoderClear(&decoder);
D
dapan1121 已提交
2668 2669 2670
  return 0;
}

2671
void tFreeSQnodeListRsp(SQnodeListRsp *pRsp) { taosArrayDestroy(pRsp->qnodeList); }
D
dapan1121 已提交
2672

D
dapan1121 已提交
2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
int32_t tSerializeSDnodeListRsp(void *buf, int32_t bufLen, SDnodeListRsp *pRsp) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  int32_t num = taosArrayGetSize(pRsp->dnodeList);
  if (tEncodeI32(&encoder, num) < 0) return -1;
  for (int32_t i = 0; i < num; ++i) {
    SEpSet *pEpSet = taosArrayGet(pRsp->dnodeList, i);
    if (tEncodeSEpSet(&encoder, pEpSet) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSDnodeListRsp(void *buf, int32_t bufLen, SDnodeListRsp *pRsp) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (NULL == pRsp->dnodeList) {
    pRsp->dnodeList = taosArrayInit(num, sizeof(SEpSet));
    if (NULL == pRsp->dnodeList) return -1;
  }

  for (int32_t i = 0; i < num; ++i) {
    SEpSet epSet = {0};
    if (tDecodeSEpSet(&decoder, &epSet) < 0) return -1;
    taosArrayPush(pRsp->dnodeList, &epSet);
  }
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

void tFreeSDnodeListRsp(SDnodeListRsp *pRsp) { taosArrayDestroy(pRsp->dnodeList); }

2716
int32_t tSerializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
H
Hongze Cheng 已提交
2717 2718
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2719 2720 2721

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
2722 2723
  if (tEncodeI64(&encoder, pReq->timeRange.skey) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->timeRange.ekey) < 0) return -1;
S
Shengliang Guan 已提交
2724 2725 2726
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2727
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2728 2729 2730
  return tlen;
}

2731
int32_t tDeserializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
H
Hongze Cheng 已提交
2732 2733
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2734 2735 2736

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
2737 2738
  if (tDecodeI64(&decoder, &pReq->timeRange.skey) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->timeRange.ekey) < 0) return -1;
S
Shengliang Guan 已提交
2739 2740
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2741
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2742
  return 0;
S
Shengliang Guan 已提交
2743 2744
}

H
Hongze Cheng 已提交
2745
int32_t tSerializeSUseDbRspImp(SEncoder *pEncoder, const SUseDbRsp *pRsp) {
S
Shengliang Guan 已提交
2746
  if (tEncodeCStr(pEncoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2747
  if (tEncodeI64(pEncoder, pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2748 2749
  if (tEncodeI32(pEncoder, pRsp->vgVersion) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->vgNum) < 0) return -1;
2750 2751
  if (tEncodeI16(pEncoder, pRsp->hashPrefix) < 0) return -1;
  if (tEncodeI16(pEncoder, pRsp->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2752 2753 2754 2755 2756 2757 2758
  if (tEncodeI8(pEncoder, pRsp->hashMethod) < 0) return -1;

  for (int32_t i = 0; i < pRsp->vgNum; ++i) {
    SVgroupInfo *pVgInfo = taosArrayGet(pRsp->pVgroupInfos, i);
    if (tEncodeI32(pEncoder, pVgInfo->vgId) < 0) return -1;
    if (tEncodeU32(pEncoder, pVgInfo->hashBegin) < 0) return -1;
    if (tEncodeU32(pEncoder, pVgInfo->hashEnd) < 0) return -1;
L
Liu Jicong 已提交
2759
    if (tEncodeSEpSet(pEncoder, &pVgInfo->epSet) < 0) return -1;
D
dapan1121 已提交
2760
    if (tEncodeI32(pEncoder, pVgInfo->numOfTable) < 0) return -1;
S
Shengliang Guan 已提交
2761 2762
  }

2763
  if (tEncodeI32(pEncoder, pRsp->errCode) < 0) return -1;
2764
  if (tEncodeI64(pEncoder, pRsp->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2765 2766 2767
  return 0;
}

2768
int32_t tSerializeSUseDbRsp(void *buf, int32_t bufLen, const SUseDbRsp *pRsp) {
H
Hongze Cheng 已提交
2769 2770
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2771 2772 2773 2774 2775 2776

  if (tStartEncode(&encoder) < 0) return -1;
  if (tSerializeSUseDbRspImp(&encoder, pRsp) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2777
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2778 2779 2780 2781
  return tlen;
}

int32_t tSerializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2782 2783
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795

  if (tStartEncode(&encoder) < 0) return -1;

  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  if (tEncodeI32(&encoder, numOfBatch) < 0) return -1;
  for (int32_t i = 0; i < numOfBatch; ++i) {
    SUseDbRsp *pUsedbRsp = taosArrayGet(pRsp->pArray, i);
    if (tSerializeSUseDbRspImp(&encoder, pUsedbRsp) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2796
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2797 2798 2799
  return tlen;
}

H
Hongze Cheng 已提交
2800
int32_t tDeserializeSUseDbRspImp(SDecoder *pDecoder, SUseDbRsp *pRsp) {
S
Shengliang Guan 已提交
2801
  if (tDecodeCStrTo(pDecoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2802
  if (tDecodeI64(pDecoder, &pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2803 2804
  if (tDecodeI32(pDecoder, &pRsp->vgVersion) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->vgNum) < 0) return -1;
2805 2806
  if (tDecodeI16(pDecoder, &pRsp->hashPrefix) < 0) return -1;
  if (tDecodeI16(pDecoder, &pRsp->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2807 2808
  if (tDecodeI8(pDecoder, &pRsp->hashMethod) < 0) return -1;

2809 2810 2811 2812 2813 2814
  if (pRsp->vgNum > 0) {
    pRsp->pVgroupInfos = taosArrayInit(pRsp->vgNum, sizeof(SVgroupInfo));
    if (pRsp->pVgroupInfos == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
S
Shengliang Guan 已提交
2815

2816 2817 2818 2819 2820 2821 2822 2823 2824
    for (int32_t i = 0; i < pRsp->vgNum; ++i) {
      SVgroupInfo vgInfo = {0};
      if (tDecodeI32(pDecoder, &vgInfo.vgId) < 0) return -1;
      if (tDecodeU32(pDecoder, &vgInfo.hashBegin) < 0) return -1;
      if (tDecodeU32(pDecoder, &vgInfo.hashEnd) < 0) return -1;
      if (tDecodeSEpSet(pDecoder, &vgInfo.epSet) < 0) return -1;
      if (tDecodeI32(pDecoder, &vgInfo.numOfTable) < 0) return -1;
      taosArrayPush(pRsp->pVgroupInfos, &vgInfo);
    }
S
Shengliang Guan 已提交
2825 2826
  }

2827
  if (tDecodeI32(pDecoder, &pRsp->errCode) < 0) return -1;
2828
  if (tDecodeI64(pDecoder, &pRsp->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2829 2830 2831 2832
  return 0;
}

int32_t tDeserializeSUseDbRsp(void *buf, int32_t bufLen, SUseDbRsp *pRsp) {
H
Hongze Cheng 已提交
2833 2834
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2835 2836 2837 2838 2839

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDeserializeSUseDbRspImp(&decoder, pRsp) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2840
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2841 2842 2843 2844
  return 0;
}

int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2845 2846
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2847 2848 2849 2850 2851 2852

  if (tStartDecode(&decoder) < 0) return -1;

  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1;

D
dapan1121 已提交
2853
  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SUseDbRsp));
S
Shengliang Guan 已提交
2854 2855 2856 2857 2858 2859 2860
  if (pRsp->pArray == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

  for (int32_t i = 0; i < numOfBatch; ++i) {
    SUseDbRsp usedbRsp = {0};
2861 2862 2863 2864
    if (tDeserializeSUseDbRspImp(&decoder, &usedbRsp) < 0) {
      tDecoderClear(&decoder);
      return -1;
    }
S
Shengliang Guan 已提交
2865 2866 2867 2868
    taosArrayPush(pRsp->pArray, &usedbRsp);
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2869
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882
  return 0;
}

void tFreeSUsedbRsp(SUseDbRsp *pRsp) { taosArrayDestroy(pRsp->pVgroupInfos); }

void tFreeSUseDbBatchRsp(SUseDbBatchRsp *pRsp) {
  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  for (int32_t i = 0; i < numOfBatch; ++i) {
    SUseDbRsp *pUsedbRsp = taosArrayGet(pRsp->pArray, i);
    tFreeSUsedbRsp(pUsedbRsp);
  }

  taosArrayDestroy(pRsp->pArray);
S
Shengliang Guan 已提交
2883 2884
}

2885
int32_t tSerializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2886 2887
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899

  if (tStartEncode(&encoder) < 0) return -1;

  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  if (tEncodeI32(&encoder, numOfBatch) < 0) return -1;
  for (int32_t i = 0; i < numOfBatch; ++i) {
    SGetUserAuthRsp *pUserAuthRsp = taosArrayGet(pRsp->pArray, i);
    if (tSerializeSGetUserAuthRspImpl(&encoder, pUserAuthRsp) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2900
  tEncoderClear(&encoder);
D
dapan 已提交
2901 2902 2903
  return tlen;
}

2904
int32_t tDeserializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2905 2906
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925

  if (tStartDecode(&decoder) < 0) return -1;

  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1;

  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SGetUserAuthRsp));
  if (pRsp->pArray == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

  for (int32_t i = 0; i < numOfBatch; ++i) {
    SGetUserAuthRsp rsp = {0};
    if (tDeserializeSGetUserAuthRspImpl(&decoder, &rsp) < 0) return -1;
    taosArrayPush(pRsp->pArray, &rsp);
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2926
  tDecoderClear(&decoder);
D
dapan 已提交
2927 2928 2929
  return 0;
}

2930
void tFreeSUserAuthBatchRsp(SUserAuthBatchRsp *pRsp) {
D
dapan 已提交
2931 2932 2933 2934 2935 2936 2937 2938 2939
  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
  for (int32_t i = 0; i < numOfBatch; ++i) {
    SGetUserAuthRsp *pUserAuthRsp = taosArrayGet(pRsp->pArray, i);
    tFreeSGetUserAuthRsp(pUserAuthRsp);
  }

  taosArrayDestroy(pRsp->pArray);
}

2940
int32_t tSerializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
H
Hongze Cheng 已提交
2941 2942
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2943 2944 2945 2946 2947 2948

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2949
  tEncoderClear(&encoder);
D
dapan1121 已提交
2950 2951 2952
  return tlen;
}

2953
int32_t tDeserializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
H
Hongze Cheng 已提交
2954 2955
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2956 2957 2958 2959 2960

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2961
  tDecoderClear(&decoder);
D
dapan1121 已提交
2962 2963 2964
  return 0;
}

2965 2966 2967 2968 2969 2970
int32_t tSerializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
2971
  if (tEncodeI32(&encoder, pReq->maxSpeed) < 0) return -1;
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
2985
  if (tDecodeI32(&decoder, &pReq->maxSpeed) < 0) return -1;
2986 2987 2988 2989 2990 2991
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

S
Shengliang Guan 已提交
2992 2993 2994 2995 2996
int32_t tSerializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
2997
  if (tEncodeI32(&encoder, pReq->timestamp) < 0) return -1;
S
Shengliang Guan 已提交
2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
3010
  if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1;
S
Shengliang Guan 已提交
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSVDropTtlTableReq(void *buf, int32_t bufLen, SVDropTtlTableReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->timestamp) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSVDropTtlTableReq(void *buf, int32_t bufLen, SVDropTtlTableReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

3042
int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
H
Hongze Cheng 已提交
3043 3044
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
3045 3046 3047

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfVgroups) < 0) return -1;
3048 3049
  if (tEncodeI32(&encoder, pRsp->numOfStables) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->buffer) < 0) return -1;
3050
  if (tEncodeI32(&encoder, pRsp->cacheSize) < 0) return -1;
3051 3052
  if (tEncodeI32(&encoder, pRsp->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->pages) < 0) return -1;
D
dapan1121 已提交
3053 3054 3055 3056 3057 3058
  if (tEncodeI32(&encoder, pRsp->daysPerFile) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->daysToKeep2) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->minRows) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->maxRows) < 0) return -1;
3059
  if (tEncodeI32(&encoder, pRsp->walFsyncPeriod) < 0) return -1;
3060 3061
  if (tEncodeI16(&encoder, pRsp->hashPrefix) < 0) return -1;
  if (tEncodeI16(&encoder, pRsp->hashSuffix) < 0) return -1;
D
dapan1121 已提交
3062 3063 3064 3065
  if (tEncodeI8(&encoder, pRsp->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pRsp->precision) < 0) return -1;
  if (tEncodeI8(&encoder, pRsp->compression) < 0) return -1;
  if (tEncodeI8(&encoder, pRsp->replications) < 0) return -1;
3066
  if (tEncodeI8(&encoder, pRsp->strict) < 0) return -1;
3067
  if (tEncodeI8(&encoder, pRsp->cacheLast) < 0) return -1;
3068 3069 3070 3071 3072
  if (tEncodeI32(&encoder, pRsp->tsdbPageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->walRetentionPeriod) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->walRollPeriod) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->walRetentionSize) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->walSegmentSize) < 0) return -1;
3073 3074 3075
  if (tEncodeI32(&encoder, pRsp->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
3076 3077
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
3078 3079 3080
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
  }
wmmhello's avatar
wmmhello 已提交
3081
  if (tEncodeI8(&encoder, pRsp->schemaless) < 0) return -1;
3082
  if (tEncodeI16(&encoder, pRsp->sstTrigger) < 0) return -1;
D
dapan1121 已提交
3083 3084
  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3085
  tEncoderClear(&encoder);
D
dapan1121 已提交
3086 3087 3088
  return tlen;
}

3089
int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
H
Hongze Cheng 已提交
3090 3091
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
3092 3093 3094

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfVgroups) < 0) return -1;
3095 3096
  if (tDecodeI32(&decoder, &pRsp->numOfStables) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->buffer) < 0) return -1;
3097
  if (tDecodeI32(&decoder, &pRsp->cacheSize) < 0) return -1;
3098 3099
  if (tDecodeI32(&decoder, &pRsp->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->pages) < 0) return -1;
D
dapan1121 已提交
3100 3101 3102 3103 3104 3105
  if (tDecodeI32(&decoder, &pRsp->daysPerFile) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->daysToKeep2) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->minRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->maxRows) < 0) return -1;
3106
  if (tDecodeI32(&decoder, &pRsp->walFsyncPeriod) < 0) return -1;
3107 3108
  if (tDecodeI16(&decoder, &pRsp->hashPrefix) < 0) return -1;
  if (tDecodeI16(&decoder, &pRsp->hashSuffix) < 0) return -1;
D
dapan1121 已提交
3109 3110 3111 3112
  if (tDecodeI8(&decoder, &pRsp->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pRsp->precision) < 0) return -1;
  if (tDecodeI8(&decoder, &pRsp->compression) < 0) return -1;
  if (tDecodeI8(&decoder, &pRsp->replications) < 0) return -1;
3113
  if (tDecodeI8(&decoder, &pRsp->strict) < 0) return -1;
3114
  if (tDecodeI8(&decoder, &pRsp->cacheLast) < 0) return -1;
3115 3116 3117 3118 3119
  if (tDecodeI32(&decoder, &pRsp->tsdbPageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->walRetentionPeriod) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->walRollPeriod) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->walRetentionSize) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->walSegmentSize) < 0) return -1;
3120
  if (tDecodeI32(&decoder, &pRsp->numOfRetensions) < 0) return -1;
3121 3122 3123 3124 3125 3126
  if (pRsp->numOfRetensions > 0) {
    pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention));
    if (pRsp->pRetensions == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
3127
  }
D
dapan1121 已提交
3128

3129 3130
  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
    SRetention rentension = {0};
3131 3132
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
3133 3134 3135 3136 3137 3138 3139
    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
    if (taosArrayPush(pRsp->pRetensions, &rentension) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }
wmmhello's avatar
wmmhello 已提交
3140
  if (tDecodeI8(&decoder, &pRsp->schemaless) < 0) return -1;
3141
  if (tDecodeI16(&decoder, &pRsp->sstTrigger) < 0) return -1;
D
dapan1121 已提交
3142 3143
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3144
  tDecoderClear(&decoder);
D
dapan1121 已提交
3145 3146 3147
  return 0;
}

3148
int32_t tSerializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) {
H
Hongze Cheng 已提交
3149 3150
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
3151 3152 3153 3154 3155 3156

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->indexFName) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3157
  tEncoderClear(&encoder);
D
dapan1121 已提交
3158 3159 3160
  return tlen;
}

3161
int32_t tDeserializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) {
H
Hongze Cheng 已提交
3162 3163
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
3164 3165 3166 3167 3168

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->indexFName) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3169
  tDecoderClear(&decoder);
D
dapan1121 已提交
3170 3171 3172
  return 0;
}

3173
int32_t tSerializeSUserIndexRsp(void *buf, int32_t bufLen, const SUserIndexRsp *pRsp) {
H
Hongze Cheng 已提交
3174 3175
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
3176 3177 3178 3179 3180 3181 3182 3183 3184 3185

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->tblFName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->colName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->indexType) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->indexExts) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3186
  tEncoderClear(&encoder);
D
dapan1121 已提交
3187 3188 3189
  return tlen;
}

3190
int32_t tDeserializeSUserIndexRsp(void *buf, int32_t bufLen, SUserIndexRsp *pRsp) {
H
Hongze Cheng 已提交
3191 3192
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
3193 3194 3195 3196 3197 3198 3199 3200 3201

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->tblFName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->colName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->indexType) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->indexExts) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3202
  tDecoderClear(&decoder);
D
dapan1121 已提交
3203 3204 3205
  return 0;
}

D
dapan1121 已提交
3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230
int32_t tSerializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->tbFName) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->tbFName) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

C
Cary Xu 已提交
3231
int32_t tSerializeSTableIndexInfo(SEncoder *pEncoder, STableIndexInfo *pInfo) {
D
dapan1121 已提交
3232 3233 3234 3235 3236 3237 3238
  if (tEncodeI8(pEncoder, pInfo->intervalUnit) < 0) return -1;
  if (tEncodeI8(pEncoder, pInfo->slidingUnit) < 0) return -1;
  if (tEncodeI64(pEncoder, pInfo->interval) < 0) return -1;
  if (tEncodeI64(pEncoder, pInfo->offset) < 0) return -1;
  if (tEncodeI64(pEncoder, pInfo->sliding) < 0) return -1;
  if (tEncodeI64(pEncoder, pInfo->dstTbUid) < 0) return -1;
  if (tEncodeI32(pEncoder, pInfo->dstVgId) < 0) return -1;
D
dapan1121 已提交
3239
  if (tEncodeSEpSet(pEncoder, &pInfo->epSet) < 0) return -1;
D
dapan1121 已提交
3240 3241 3242 3243 3244 3245 3246 3247 3248
  if (tEncodeCStr(pEncoder, pInfo->expr) < 0) return -1;
  return 0;
}

int32_t tSerializeSTableIndexRsp(void *buf, int32_t bufLen, const STableIndexRsp *pRsp) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
D
dapan1121 已提交
3249 3250
  if (tEncodeCStr(&encoder, pRsp->tbName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1;
D
dapan1121 已提交
3251
  if (tEncodeU64(&encoder, pRsp->suid) < 0) return -1;
D
dapan1121 已提交
3252
  if (tEncodeI32(&encoder, pRsp->version) < 0) return -1;
D
dapan1121 已提交
3253 3254 3255 3256
  int32_t num = taosArrayGetSize(pRsp->pIndex);
  if (tEncodeI32(&encoder, num) < 0) return -1;
  if (num > 0) {
    for (int32_t i = 0; i < num; ++i) {
C
Cary Xu 已提交
3257
      STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pRsp->pIndex, i);
D
dapan1121 已提交
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267
      if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
    }
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

3268 3269
void tFreeSerializeSTableIndexRsp(STableIndexRsp *pRsp) {
  if (pRsp->pIndex != NULL) {
K
kailixu 已提交
3270
    tFreeSTableIndexRsp(pRsp);
3271 3272 3273 3274
    pRsp->pIndex = NULL;
  }
}

D
dapan1121 已提交
3275 3276 3277 3278 3279 3280 3281 3282
int32_t tDeserializeSTableIndexInfo(SDecoder *pDecoder, STableIndexInfo *pInfo) {
  if (tDecodeI8(pDecoder, &pInfo->intervalUnit) < 0) return -1;
  if (tDecodeI8(pDecoder, &pInfo->slidingUnit) < 0) return -1;
  if (tDecodeI64(pDecoder, &pInfo->interval) < 0) return -1;
  if (tDecodeI64(pDecoder, &pInfo->offset) < 0) return -1;
  if (tDecodeI64(pDecoder, &pInfo->sliding) < 0) return -1;
  if (tDecodeI64(pDecoder, &pInfo->dstTbUid) < 0) return -1;
  if (tDecodeI32(pDecoder, &pInfo->dstVgId) < 0) return -1;
D
dapan1121 已提交
3283
  if (tDecodeSEpSet(pDecoder, &pInfo->epSet) < 0) return -1;
D
dapan1121 已提交
3284 3285 3286 3287 3288 3289 3290 3291 3292 3293
  if (tDecodeCStrAlloc(pDecoder, &pInfo->expr) < 0) return -1;

  return 0;
}

int32_t tDeserializeSTableIndexRsp(void *buf, int32_t bufLen, STableIndexRsp *pRsp) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
D
dapan1121 已提交
3294 3295
  if (tDecodeCStrTo(&decoder, pRsp->tbName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1;
D
dapan1121 已提交
3296
  if (tDecodeU64(&decoder, &pRsp->suid) < 0) return -1;
D
dapan1121 已提交
3297
  if (tDecodeI32(&decoder, &pRsp->version) < 0) return -1;
D
dapan1121 已提交
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (num > 0) {
    pRsp->pIndex = taosArrayInit(num, sizeof(STableIndexInfo));
    if (NULL == pRsp->pIndex) return -1;
    STableIndexInfo info;
    for (int32_t i = 0; i < num; ++i) {
      if (tDeserializeSTableIndexInfo(&decoder, &info) < 0) return -1;
      if (NULL == taosArrayPush(pRsp->pIndex, &info)) {
        taosMemoryFree(info.expr);
        return -1;
      }
    }
  }
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

3318
void tFreeSTableIndexInfo(void *info) {
D
dapan1121 已提交
3319 3320 3321 3322
  if (NULL == info) {
    return;
  }

3323
  STableIndexInfo *pInfo = (STableIndexInfo *)info;
D
dapan1121 已提交
3324 3325 3326

  taosMemoryFree(pInfo->expr);
}
D
dapan1121 已提交
3327

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352
int32_t tSerializeSShowVariablesReq(void *buf, int32_t bufLen, SShowVariablesReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSShowVariablesReq(void *buf, int32_t bufLen, SShowVariablesReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

3353
int32_t tEncodeSVariablesInfo(SEncoder *pEncoder, SVariablesInfo *pInfo) {
3354 3355 3356 3357 3358
  if (tEncodeCStr(pEncoder, pInfo->name) < 0) return -1;
  if (tEncodeCStr(pEncoder, pInfo->value) < 0) return -1;
  return 0;
}

3359
int32_t tDecodeSVariablesInfo(SDecoder *pDecoder, SVariablesInfo *pInfo) {
3360 3361 3362 3363 3364
  if (tDecodeCStrTo(pDecoder, pInfo->name) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pInfo->value) < 0) return -1;
  return 0;
}

3365
int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *pRsp) {
3366 3367 3368 3369 3370 3371 3372
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  int32_t varNum = taosArrayGetSize(pRsp->variables);
  if (tEncodeI32(&encoder, varNum) < 0) return -1;
  for (int32_t i = 0; i < varNum; ++i) {
3373
    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
3374 3375 3376 3377 3378 3379 3380 3381 3382
    if (tEncodeSVariablesInfo(&encoder, pInfo) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

3383
int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *pRsp) {
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  int32_t varNum = 0;
  if (tDecodeI32(&decoder, &varNum) < 0) return -1;
  if (varNum > 0) {
    pRsp->variables = taosArrayInit(varNum, sizeof(SVariablesInfo));
    if (NULL == pRsp->variables) return -1;
    for (int32_t i = 0; i < varNum; ++i) {
      SVariablesInfo info = {0};
      if (tDecodeSVariablesInfo(&decoder, &info) < 0) return -1;
      if (NULL == taosArrayPush(pRsp->variables, &info)) return -1;
    }
  }

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

3405
void tFreeSShowVariablesRsp(SShowVariablesRsp *pRsp) {
3406 3407 3408
  if (NULL == pRsp) {
    return;
  }
3409

3410 3411 3412
  taosArrayDestroy(pRsp->variables);
}

S
Shengliang Guan 已提交
3413
int32_t tSerializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
H
Hongze Cheng 已提交
3414 3415
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3416 3417 3418 3419 3420 3421

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->type) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->payloadLen) < 0) return -1;
  if (pReq->payloadLen > 0) {
S
Shengliang Guan 已提交
3422
    if (tEncodeBinary(&encoder, pReq->payload, pReq->payloadLen) < 0) return -1;
S
Shengliang Guan 已提交
3423 3424 3425 3426
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3427
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3428 3429 3430 3431
  return tlen;
}

int32_t tDeserializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
H
Hongze Cheng 已提交
3432 3433
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3434 3435 3436 3437 3438 3439

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->type) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->payloadLen) < 0) return -1;
  if (pReq->payloadLen > 0) {
3440
    pReq->payload = taosMemoryMalloc(pReq->payloadLen);
S
Shengliang Guan 已提交
3441 3442 3443 3444 3445
    if (pReq->payload == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->payload) < 0) return -1;
  }

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3446
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3447 3448 3449
  return 0;
}

3450
void tFreeSShowReq(SShowReq *pReq) { taosMemoryFreeClear(pReq->payload); }
3451 3452

int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
H
Hongze Cheng 已提交
3453 3454
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
3455 3456 3457

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
3458 3459
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
3460
  if (tEncodeCStr(&encoder, pReq->filterTb) < 0) return -1;
3461
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
3462 3463 3464
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3465
  tEncoderClear(&encoder);
3466 3467 3468 3469
  return tlen;
}

int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
H
Hongze Cheng 已提交
3470 3471
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
3472 3473 3474

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
3475 3476
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
3477
  if (tDecodeCStrTo(&decoder, pReq->filterTb) < 0) return -1;
3478 3479
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;

3480
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3481
  tDecoderClear(&decoder);
3482 3483
  return 0;
}
S
Shengliang Guan 已提交
3484

H
Hongze Cheng 已提交
3485
static int32_t tEncodeSTableMetaRsp(SEncoder *pEncoder, STableMetaRsp *pRsp) {
S
Shengliang Guan 已提交
3486 3487 3488
  if (tEncodeCStr(pEncoder, pRsp->tbName) < 0) return -1;
  if (tEncodeCStr(pEncoder, pRsp->stbName) < 0) return -1;
  if (tEncodeCStr(pEncoder, pRsp->dbFName) < 0) return -1;
L
Liu Jicong 已提交
3489
  if (tEncodeI64(pEncoder, pRsp->dbId) < 0) return -1;
S
Shengliang Guan 已提交
3490 3491 3492 3493 3494 3495
  if (tEncodeI32(pEncoder, pRsp->numOfTags) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->numOfColumns) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->precision) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->tableType) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->sversion) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->tversion) < 0) return -1;
L
Liu Jicong 已提交
3496 3497
  if (tEncodeU64(pEncoder, pRsp->suid) < 0) return -1;
  if (tEncodeU64(pEncoder, pRsp->tuid) < 0) return -1;
S
Shengliang Guan 已提交
3498 3499 3500 3501 3502 3503 3504 3505 3506
  if (tEncodeI32(pEncoder, pRsp->vgId) < 0) return -1;
  for (int32_t i = 0; i < pRsp->numOfColumns + pRsp->numOfTags; ++i) {
    SSchema *pSchema = &pRsp->pSchemas[i];
    if (tEncodeSSchema(pEncoder, pSchema) < 0) return -1;
  }

  return 0;
}

H
Hongze Cheng 已提交
3507
static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
S
Shengliang Guan 已提交
3508 3509 3510
  if (tDecodeCStrTo(pDecoder, pRsp->tbName) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pRsp->stbName) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pRsp->dbFName) < 0) return -1;
L
Liu Jicong 已提交
3511
  if (tDecodeI64(pDecoder, &pRsp->dbId) < 0) return -1;
S
Shengliang Guan 已提交
3512 3513 3514 3515 3516 3517
  if (tDecodeI32(pDecoder, &pRsp->numOfTags) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->numOfColumns) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->precision) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->tableType) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->sversion) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->tversion) < 0) return -1;
L
Liu Jicong 已提交
3518 3519
  if (tDecodeU64(pDecoder, &pRsp->suid) < 0) return -1;
  if (tDecodeU64(pDecoder, &pRsp->tuid) < 0) return -1;
S
Shengliang Guan 已提交
3520 3521 3522
  if (tDecodeI32(pDecoder, &pRsp->vgId) < 0) return -1;

  int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
3523 3524 3525
  if (totalCols > 0) {
    pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
    if (pRsp->pSchemas == NULL) return -1;
S
Shengliang Guan 已提交
3526

3527 3528 3529 3530 3531 3532
    for (int32_t i = 0; i < totalCols; ++i) {
      SSchema *pSchema = &pRsp->pSchemas[i];
      if (tDecodeSSchema(pDecoder, pSchema) < 0) return -1;
    }
  } else {
    pRsp->pSchemas = NULL;
S
Shengliang Guan 已提交
3533 3534 3535 3536 3537 3538
  }

  return 0;
}

int32_t tSerializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *pRsp) {
H
Hongze Cheng 已提交
3539 3540
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3541 3542 3543 3544 3545 3546

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeSTableMetaRsp(&encoder, pRsp) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3547
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3548 3549 3550
  return tlen;
}

D
dapan1121 已提交
3551
int32_t tSerializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) {
H
Hongze Cheng 已提交
3552 3553
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3554 3555 3556

  if (tStartEncode(&encoder) < 0) return -1;

D
dapan1121 已提交
3557 3558 3559 3560
  int32_t numOfMeta = taosArrayGetSize(pRsp->pMetaRsp);
  if (tEncodeI32(&encoder, numOfMeta) < 0) return -1;
  for (int32_t i = 0; i < numOfMeta; ++i) {
    STableMetaRsp *pMetaRsp = taosArrayGet(pRsp->pMetaRsp, i);
S
Shengliang Guan 已提交
3561 3562
    if (tEncodeSTableMetaRsp(&encoder, pMetaRsp) < 0) return -1;
  }
D
dapan1121 已提交
3563 3564

  int32_t numOfIndex = taosArrayGetSize(pRsp->pIndexRsp);
C
Cary Xu 已提交
3565
  if (tEncodeI32(&encoder, numOfIndex) < 0) return -1;
D
dapan1121 已提交
3566
  for (int32_t i = 0; i < numOfIndex; ++i) {
D
dapan1121 已提交
3567 3568 3569 3570 3571 3572 3573
    STableIndexRsp *pIndexRsp = taosArrayGet(pRsp->pIndexRsp, i);
    if (tEncodeCStr(&encoder, pIndexRsp->tbName) < 0) return -1;
    if (tEncodeCStr(&encoder, pIndexRsp->dbFName) < 0) return -1;
    if (tEncodeU64(&encoder, pIndexRsp->suid) < 0) return -1;
    if (tEncodeI32(&encoder, pIndexRsp->version) < 0) return -1;
    int32_t num = taosArrayGetSize(pIndexRsp->pIndex);
    if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
3574 3575 3576 3577
    for (int32_t i = 0; i < num; ++i) {
      STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pIndexRsp->pIndex, i);
      if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
    }
D
dapan1121 已提交
3578 3579
  }

S
Shengliang Guan 已提交
3580 3581 3582
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3583
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3584 3585 3586 3587
  return tlen;
}

int32_t tDeserializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *pRsp) {
H
Hongze Cheng 已提交
3588 3589
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3590 3591 3592 3593 3594

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeSTableMetaRsp(&decoder, pRsp) < 0) return -1;

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3595
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3596 3597 3598
  return 0;
}

D
dapan1121 已提交
3599
int32_t tDeserializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) {
H
Hongze Cheng 已提交
3600 3601
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3602 3603 3604

  if (tStartDecode(&decoder) < 0) return -1;

D
dapan1121 已提交
3605
  int32_t numOfMeta = 0;
D
dapan1121 已提交
3606 3607 3608
  if (tDecodeI32(&decoder, &numOfMeta) < 0) return -1;
  pRsp->pMetaRsp = taosArrayInit(numOfMeta, sizeof(STableMetaRsp));
  if (pRsp->pMetaRsp == NULL) {
S
Shengliang Guan 已提交
3609 3610 3611 3612
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

D
dapan1121 已提交
3613
  for (int32_t i = 0; i < numOfMeta; ++i) {
S
Shengliang Guan 已提交
3614 3615
    STableMetaRsp tableMetaRsp = {0};
    if (tDecodeSTableMetaRsp(&decoder, &tableMetaRsp) < 0) return -1;
D
dapan1121 已提交
3616 3617 3618
    taosArrayPush(pRsp->pMetaRsp, &tableMetaRsp);
  }

D
dapan1121 已提交
3619
  int32_t numOfIndex = 0;
D
dapan1121 已提交
3620 3621 3622 3623 3624 3625
  if (tDecodeI32(&decoder, &numOfIndex) < 0) return -1;

  pRsp->pIndexRsp = taosArrayInit(numOfIndex, sizeof(STableIndexRsp));
  if (pRsp->pIndexRsp == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
S
Shengliang Guan 已提交
3626
  }
D
dapan1121 已提交
3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648

  for (int32_t i = 0; i < numOfIndex; ++i) {
    STableIndexRsp tableIndexRsp = {0};
    if (tDecodeCStrTo(&decoder, tableIndexRsp.tbName) < 0) return -1;
    if (tDecodeCStrTo(&decoder, tableIndexRsp.dbFName) < 0) return -1;
    if (tDecodeU64(&decoder, &tableIndexRsp.suid) < 0) return -1;
    if (tDecodeI32(&decoder, &tableIndexRsp.version) < 0) return -1;
    int32_t num = 0;
    if (tDecodeI32(&decoder, &num) < 0) return -1;
    if (num > 0) {
      tableIndexRsp.pIndex = taosArrayInit(num, sizeof(STableIndexInfo));
      if (NULL == tableIndexRsp.pIndex) return -1;
      STableIndexInfo info;
      for (int32_t i = 0; i < num; ++i) {
        if (tDeserializeSTableIndexInfo(&decoder, &info) < 0) return -1;
        if (NULL == taosArrayPush(tableIndexRsp.pIndex, &info)) {
          taosMemoryFree(info.expr);
          return -1;
        }
      }
    }
    taosArrayPush(pRsp->pIndexRsp, &tableIndexRsp);
S
Shengliang Guan 已提交
3649
  }
C
Cary Xu 已提交
3650

S
Shengliang Guan 已提交
3651 3652
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3653
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3654 3655 3656
  return 0;
}

3657
void tFreeSTableMetaRsp(void *pRsp) {
3658 3659 3660
  if (NULL == pRsp) {
    return;
  }
3661 3662

  taosMemoryFreeClear(((STableMetaRsp *)pRsp)->pSchemas);
3663
}
S
Shengliang Guan 已提交
3664

D
dapan1121 已提交
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674
void tFreeSTableIndexRsp(void *info) {
  if (NULL == info) {
    return;
  }

  STableIndexRsp *pInfo = (STableIndexRsp *)info;

  taosArrayDestroyEx(pInfo->pIndex, tFreeSTableIndexInfo);
}

D
dapan1121 已提交
3675
void tFreeSSTbHbRsp(SSTbHbRsp *pRsp) {
D
dapan1121 已提交
3676 3677 3678
  int32_t numOfMeta = taosArrayGetSize(pRsp->pMetaRsp);
  for (int32_t i = 0; i < numOfMeta; ++i) {
    STableMetaRsp *pMetaRsp = taosArrayGet(pRsp->pMetaRsp, i);
S
Shengliang Guan 已提交
3679 3680 3681
    tFreeSTableMetaRsp(pMetaRsp);
  }

D
dapan1121 已提交
3682 3683 3684 3685 3686 3687 3688 3689 3690
  taosArrayDestroy(pRsp->pMetaRsp);

  int32_t numOfIndex = taosArrayGetSize(pRsp->pIndexRsp);
  for (int32_t i = 0; i < numOfIndex; ++i) {
    STableIndexRsp *pIndexRsp = taosArrayGet(pRsp->pIndexRsp, i);
    tFreeSTableIndexRsp(pIndexRsp);
  }

  taosArrayDestroy(pRsp->pIndexRsp);
S
Shengliang Guan 已提交
3691 3692 3693
}

int32_t tSerializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
H
Hongze Cheng 已提交
3694 3695
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3696 3697 3698 3699 3700 3701 3702

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->showId) < 0) return -1;
  if (tEncodeSTableMetaRsp(&encoder, &pRsp->tableMeta) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3703
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3704 3705 3706 3707
  return tlen;
}

int32_t tDeserializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
H
Hongze Cheng 已提交
3708 3709
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3710 3711 3712 3713 3714 3715

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->showId) < 0) return -1;
  if (tDecodeSTableMetaRsp(&decoder, &pRsp->tableMeta) < 0) return -1;

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3716
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3717 3718 3719 3720 3721 3722 3723
  return 0;
}

void tFreeSShowRsp(SShowRsp *pRsp) { tFreeSTableMetaRsp(&pRsp->tableMeta); }

int32_t tSerializeSTableInfoReq(void *buf, int32_t bufLen, STableInfoReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
S
Shengliang Guan 已提交
3724 3725 3726 3727
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }
S
Shengliang Guan 已提交
3728

H
Hongze Cheng 已提交
3729 3730
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3731 3732 3733 3734 3735 3736 3737

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->dbFName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->tbName) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3738
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3739 3740 3741 3742 3743 3744 3745 3746

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
S
Shengliang Guan 已提交
3747 3748 3749
}

int32_t tDeserializeSTableInfoReq(void *buf, int32_t bufLen, STableInfoReq *pReq) {
S
Shengliang Guan 已提交
3750 3751 3752 3753 3754
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;
S
Shengliang Guan 已提交
3755

H
Hongze Cheng 已提交
3756 3757
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);
S
Shengliang Guan 已提交
3758 3759 3760 3761 3762 3763

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->dbFName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->tbName) < 0) return -1;

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3764
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3765 3766
  return 0;
}
3767

S
Shengliang Guan 已提交
3768
int32_t tSerializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *pReq) {
H
Hongze Cheng 已提交
3769 3770
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
3771 3772 3773 3774 3775 3776 3777

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3778
  tEncoderClear(&encoder);
3779 3780 3781 3782
  return tlen;
}

int32_t tDeserializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *pReq) {
H
Hongze Cheng 已提交
3783 3784
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
3785 3786 3787 3788 3789 3790

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3791
  tDecoderClear(&decoder);
3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820
  return 0;
}

int32_t tSerializeSMDropCgroupReq(void *buf, int32_t bufLen, SMDropCgroupReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->topic) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->cgroup) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSMDropCgroupReq(void *buf, int32_t bufLen, SMDropCgroupReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->topic) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->cgroup) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
3821 3822
  return 0;
}
3823

L
Liu Jicong 已提交
3824
int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTopicReq *pReq) {
H
Hongze Cheng 已提交
3825 3826
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3827 3828 3829 3830

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
L
Liu Jicong 已提交
3831
  if (tEncodeI8(&encoder, pReq->subType) < 0) return -1;
3832
  if (tEncodeI8(&encoder, pReq->withMeta) < 0) return -1;
L
Liu Jicong 已提交
3833
  if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1;
3834 3835 3836 3837 3838 3839 3840 3841 3842
  if (TOPIC_SUB_TYPE__DB == pReq->subType) {
  } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
    if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;
  } else {
    if (tEncodeI32(&encoder, strlen(pReq->ast)) < 0) return -1;
    if (tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
  }
  if (tEncodeI32(&encoder, strlen(pReq->sql)) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
S
Shengliang Guan 已提交
3843

3844 3845 3846 3847
  if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
    if (tEncodeI32(&encoder, strlen(pReq->subStbFilterAst)) < 0) return -1;
    if (tEncodeCStr(&encoder, pReq->subStbFilterAst) < 0) return -1;
  }
S
Shengliang Guan 已提交
3848 3849 3850
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3851
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3852 3853 3854
  return tlen;
}

L
Liu Jicong 已提交
3855
int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicReq *pReq) {
S
Shengliang Guan 已提交
3856
  int32_t sqlLen = 0;
3857
  int32_t astLen = 0;
S
Shengliang Guan 已提交
3858

H
Hongze Cheng 已提交
3859 3860
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3861 3862 3863 3864

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
L
Liu Jicong 已提交
3865
  if (tDecodeI8(&decoder, &pReq->subType) < 0) return -1;
3866
  if (tDecodeI8(&decoder, &pReq->withMeta) < 0) return -1;
L
Liu Jicong 已提交
3867
  if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1;
3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878
  if (TOPIC_SUB_TYPE__DB == pReq->subType) {
  } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
    if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;
  } else {
    if (tDecodeI32(&decoder, &astLen) < 0) return -1;
    if (astLen > 0) {
      pReq->ast = taosMemoryCalloc(1, astLen + 1);
      if (pReq->ast == NULL) return -1;
      if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
    }
  }
S
Shengliang Guan 已提交
3879
  if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
3880
  if (sqlLen > 0) {
3881
    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
3882 3883 3884 3885
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }

3886 3887 3888 3889 3890 3891 3892 3893 3894
  if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
    if (tDecodeI32(&decoder, &astLen) < 0) return -1;
    if (astLen > 0) {
      pReq->subStbFilterAst = taosMemoryCalloc(1, astLen + 1);
      if (pReq->subStbFilterAst == NULL) return -1;
      if (tDecodeCStrTo(&decoder, pReq->subStbFilterAst) < 0) return -1;
    }
  }

S
Shengliang Guan 已提交
3895 3896
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3897
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3898 3899 3900
  return 0;
}

L
Liu Jicong 已提交
3901
void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
3902
  taosMemoryFreeClear(pReq->sql);
3903 3904
  if (TOPIC_SUB_TYPE__COLUMN == pReq->subType) {
    taosMemoryFreeClear(pReq->ast);
3905 3906
  }else if(TOPIC_SUB_TYPE__TABLE == pReq->subType) {
    taosMemoryFreeClear(pReq->subStbFilterAst);
3907
  }
S
Shengliang Guan 已提交
3908 3909
}

L
Liu Jicong 已提交
3910
int32_t tSerializeSCMCreateTopicRsp(void *buf, int32_t bufLen, const SCMCreateTopicRsp *pRsp) {
H
Hongze Cheng 已提交
3911 3912
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3913 3914 3915 3916 3917 3918

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->topicId) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3919
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3920 3921 3922
  return tlen;
}

L
Liu Jicong 已提交
3923
int32_t tDeserializeSCMCreateTopicRsp(void *buf, int32_t bufLen, SCMCreateTopicRsp *pRsp) {
H
Hongze Cheng 已提交
3924 3925
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3926 3927 3928 3929 3930

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->topicId) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3931
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3932 3933
  return 0;
}
S
Shengliang Guan 已提交
3934 3935

int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
H
Hongze Cheng 已提交
3936 3937
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3938 3939

  if (tStartEncode(&encoder) < 0) return -1;
3940
  if (tEncodeI8(&encoder, pReq->connType) < 0) return -1;
S
Shengliang Guan 已提交
3941 3942 3943
  if (tEncodeI32(&encoder, pReq->pid) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->app) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
3944
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
3945
  if (tEncodeCStrWithLen(&encoder, pReq->passwd, TSDB_PASSWORD_LEN) < 0) return -1;
S
Shengliang Guan 已提交
3946
  if (tEncodeI64(&encoder, pReq->startTime) < 0) return -1;
3947
  if (tEncodeCStr(&encoder, pReq->sVer) < 0) return -1;
S
Shengliang Guan 已提交
3948 3949 3950
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3951
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3952 3953 3954 3955
  return tlen;
}

int32_t tDeserializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
H
Hongze Cheng 已提交
3956 3957
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3958 3959

  if (tStartDecode(&decoder) < 0) return -1;
3960
  if (tDecodeI8(&decoder, &pReq->connType) < 0) return -1;
S
Shengliang Guan 已提交
3961 3962 3963
  if (tDecodeI32(&decoder, &pReq->pid) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->app) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
3964 3965
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->passwd) < 0) return -1;
S
Shengliang Guan 已提交
3966
  if (tDecodeI64(&decoder, &pReq->startTime) < 0) return -1;
3967 3968 3969 3970 3971 3972
  // Check the client version from version 3.0.3.0
  if (tDecodeIsEnd(&decoder)) {
    tDecoderClear(&decoder);
    return TSDB_CODE_VERSION_NOT_COMPATIBLE;
  }
  if (tDecodeCStrTo(&decoder, pReq->sVer) < 0) return -1;
S
Shengliang Guan 已提交
3973 3974
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3975
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3976 3977 3978 3979
  return 0;
}

int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
H
Hongze Cheng 已提交
3980 3981
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3982 3983 3984 3985

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->acctId) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->clusterId) < 0) return -1;
D
dapan1121 已提交
3986
  if (tEncodeU32(&encoder, pRsp->connId) < 0) return -1;
3987
  if (tEncodeI32(&encoder, pRsp->dnodeNum) < 0) return -1;
S
Shengliang Guan 已提交
3988
  if (tEncodeI8(&encoder, pRsp->superUser) < 0) return -1;
3989
  if (tEncodeI8(&encoder, pRsp->sysInfo) < 0) return -1;
3990
  if (tEncodeI8(&encoder, pRsp->connType) < 0) return -1;
S
Shengliang Guan 已提交
3991
  if (tEncodeSEpSet(&encoder, &pRsp->epSet) < 0) return -1;
3992
  if (tEncodeI32(&encoder, pRsp->svrTimestamp) < 0) return -1;
3993 3994
  if (tEncodeCStr(&encoder, pRsp->sVer) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->sDetailVer) < 0) return -1;
S
Shengliang Guan 已提交
3995 3996 3997
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3998
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3999 4000 4001 4002
  return tlen;
}

int32_t tDeserializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
H
Hongze Cheng 已提交
4003 4004
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4005 4006 4007 4008

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->acctId) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->clusterId) < 0) return -1;
D
dapan1121 已提交
4009
  if (tDecodeU32(&decoder, &pRsp->connId) < 0) return -1;
4010
  if (tDecodeI32(&decoder, &pRsp->dnodeNum) < 0) return -1;
S
Shengliang Guan 已提交
4011
  if (tDecodeI8(&decoder, &pRsp->superUser) < 0) return -1;
4012
  if (tDecodeI8(&decoder, &pRsp->sysInfo) < 0) return -1;
4013
  if (tDecodeI8(&decoder, &pRsp->connType) < 0) return -1;
S
Shengliang Guan 已提交
4014
  if (tDecodeSEpSet(&decoder, &pRsp->epSet) < 0) return -1;
4015
  if (tDecodeI32(&decoder, &pRsp->svrTimestamp) < 0) return -1;
4016 4017
  if (tDecodeCStrTo(&decoder, pRsp->sVer) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->sDetailVer) < 0) return -1;
S
Shengliang Guan 已提交
4018 4019
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4020
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4021 4022
  return 0;
}
S
Shengliang Guan 已提交
4023 4024

int32_t tSerializeSMTimerMsg(void *buf, int32_t bufLen, SMTimerReq *pReq) {
H
Hongze Cheng 已提交
4025 4026
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4027 4028 4029 4030 4031 4032

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->reserved) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4033
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4034 4035 4036 4037
  return tlen;
}

int32_t tDeserializeSMTimerMsg(void *buf, int32_t bufLen, SMTimerReq *pReq) {
H
Hongze Cheng 已提交
4038 4039
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4040 4041 4042 4043 4044

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->reserved) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4045
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4046 4047
  return 0;
}
4048

4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073
int32_t tSerializeSMStreamTickMsg(void *buf, int32_t bufLen, SMStreamTickReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->tick) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSMStreamTickMsg(void *buf, int32_t bufLen, SMStreamTickReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->tick) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

H
Hongze Cheng 已提交
4074
int32_t tEncodeSReplica(SEncoder *pEncoder, SReplica *pReplica) {
S
Shengliang Guan 已提交
4075 4076 4077 4078 4079 4080
  if (tEncodeI32(pEncoder, pReplica->id) < 0) return -1;
  if (tEncodeU16(pEncoder, pReplica->port) < 0) return -1;
  if (tEncodeCStr(pEncoder, pReplica->fqdn) < 0) return -1;
  return 0;
}

H
Hongze Cheng 已提交
4081
int32_t tDecodeSReplica(SDecoder *pDecoder, SReplica *pReplica) {
S
Shengliang Guan 已提交
4082 4083 4084 4085 4086 4087
  if (tDecodeI32(pDecoder, &pReplica->id) < 0) return -1;
  if (tDecodeU16(pDecoder, &pReplica->port) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pReplica->fqdn) < 0) return -1;
  return 0;
}

4088
int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pReq) {
H
Hongze Cheng 已提交
4089 4090
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
4091 4092 4093 4094

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
L
Liu Jicong 已提交
4095
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
4096
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
4097 4098 4099 4100
  if (tEncodeI32(&encoder, pReq->numOfStables) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
4101
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
4102 4103 4104 4105 4106 4107
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->maxRows) < 0) return -1;
4108
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
4109 4110 4111
  if (tEncodeU32(&encoder, pReq->hashBegin) < 0) return -1;
  if (tEncodeU32(&encoder, pReq->hashEnd) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->hashMethod) < 0) return -1;
4112 4113 4114
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
4115
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
4116
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
4117 4118 4119 4120
  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
S
Shengliang Guan 已提交
4121
    if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
4122
  }
S
sma  
Shengliang Guan 已提交
4123 4124 4125
  if (tEncodeI32(&encoder, pReq->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pReq->pRetensions, i);
4126 4127
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
4128 4129 4130
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
  }
4131 4132

  if (tEncodeI8(&encoder, pReq->isTsma) < 0) return -1;
C
Cary Xu 已提交
4133 4134 4135 4136
  if (pReq->isTsma) {
    uint32_t tsmaLen = (uint32_t)(htonl(((SMsgHead *)pReq->pTsma)->contLen));
    if (tEncodeBinary(&encoder, (const uint8_t *)pReq->pTsma, tsmaLen) < 0) return -1;
  }
4137
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
L
Liu Jicong 已提交
4138
  if (tEncodeI64(&encoder, pReq->walRetentionSize) < 0) return -1;
4139
  if (tEncodeI32(&encoder, pReq->walRollPeriod) < 0) return -1;
L
Liu Jicong 已提交
4140
  if (tEncodeI64(&encoder, pReq->walSegmentSize) < 0) return -1;
4141
  if (tEncodeI16(&encoder, pReq->sstTrigger) < 0) return -1;
4142 4143
  if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1;
  if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1;
4144
  if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1;
4145 4146 4147
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
C
Cary Xu 已提交
4148

4149 4150 4151
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4152
  tEncoderClear(&encoder);
4153 4154 4155 4156
  return tlen;
}

int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pReq) {
H
Hongze Cheng 已提交
4157 4158
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
4159 4160 4161 4162

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
L
Liu Jicong 已提交
4163
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
4164
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
4165 4166 4167 4168
  if (tDecodeI32(&decoder, &pReq->numOfStables) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
4169
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
4170 4171 4172 4173 4174 4175
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->maxRows) < 0) return -1;
4176
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
4177 4178 4179
  if (tDecodeU32(&decoder, &pReq->hashBegin) < 0) return -1;
  if (tDecodeU32(&decoder, &pReq->hashEnd) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->hashMethod) < 0) return -1;
4180 4181 4182
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
4183
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
4184
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
4185 4186 4187 4188
  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
S
Shengliang Guan 已提交
4189
    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
4190
  }
4191
  if (tDecodeI32(&decoder, &pReq->numOfRetensions) < 0) return -1;
S
sma  
Shengliang Guan 已提交
4192 4193 4194 4195 4196 4197 4198 4199
  pReq->pRetensions = taosArrayInit(pReq->numOfRetensions, sizeof(SRetention));
  if (pReq->pRetensions == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention rentension = {0};
4200 4201
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
4202 4203 4204 4205 4206 4207 4208 4209
    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
    if (taosArrayPush(pReq->pRetensions, &rentension) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

4210
  if (tDecodeI8(&decoder, &pReq->isTsma) < 0) return -1;
C
Cary Xu 已提交
4211
  if (pReq->isTsma) {
4212
    if (tDecodeBinary(&decoder, (uint8_t **)&pReq->pTsma, NULL) < 0) return -1;
C
Cary Xu 已提交
4213
  }
4214

4215
  if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
L
Liu Jicong 已提交
4216
  if (tDecodeI64(&decoder, &pReq->walRetentionSize) < 0) return -1;
4217
  if (tDecodeI32(&decoder, &pReq->walRollPeriod) < 0) return -1;
L
Liu Jicong 已提交
4218
  if (tDecodeI64(&decoder, &pReq->walSegmentSize) < 0) return -1;
4219
  if (tDecodeI16(&decoder, &pReq->sstTrigger) < 0) return -1;
4220 4221
  if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1;
  if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1;
4222
  if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1;
4223 4224 4225
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
4226

4227
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4228
  tDecoderClear(&decoder);
4229 4230 4231
  return 0;
}

S
sma  
Shengliang Guan 已提交
4232 4233 4234
int32_t tFreeSCreateVnodeReq(SCreateVnodeReq *pReq) {
  taosArrayDestroy(pReq->pRetensions);
  pReq->pRetensions = NULL;
4235
  return 0;
S
sma  
Shengliang Guan 已提交
4236 4237
}

4238
int32_t tSerializeSDropVnodeReq(void *buf, int32_t bufLen, SDropVnodeReq *pReq) {
H
Hongze Cheng 已提交
4239 4240
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
4241 4242 4243 4244

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
L
Liu Jicong 已提交
4245
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
4246
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
4247 4248 4249
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
4250 4251 4252
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4253
  tEncoderClear(&encoder);
4254 4255 4256 4257
  return tlen;
}

int32_t tDeserializeSDropVnodeReq(void *buf, int32_t bufLen, SDropVnodeReq *pReq) {
H
Hongze Cheng 已提交
4258 4259
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
4260 4261 4262 4263

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
L
Liu Jicong 已提交
4264
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
4265
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
4266 4267 4268
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
4269 4270
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4271
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4272 4273
  return 0;
}
dengyihao's avatar
dengyihao 已提交
4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311
int32_t tSerializeSDropIdxReq(void *buf, int32_t bufLen, SDropIndexReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->colName) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->stb) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->stbUid) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
  // TODO
  return 0;
}
int32_t tDeserializeSDropIdxReq(void *buf, int32_t bufLen, SDropIndexReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->colName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->stb) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->stbUid) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  // TODO
  return 0;
}
S
Shengliang Guan 已提交
4312

4313
int32_t tSerializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
H
Hongze Cheng 已提交
4314 4315
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
4316 4317 4318 4319

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
4320
  if (tEncodeI64(&encoder, pReq->compactStartTime) < 0) return -1;
H
Hongze Cheng 已提交
4321 4322 4323 4324 4325

  // 1.1 add tw.skey and tw.ekey
  if (tEncodeI64(&encoder, pReq->tw.skey) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->tw.ekey) < 0) return -1;

4326 4327 4328
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4329
  tEncoderClear(&encoder);
4330 4331 4332 4333
  return tlen;
}

int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
H
Hongze Cheng 已提交
4334 4335
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
4336 4337

  if (tStartDecode(&decoder) < 0) return -1;
H
Hongze Cheng 已提交
4338

4339 4340
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
4341
  if (tDecodeI64(&decoder, &pReq->compactStartTime) < 0) return -1;
4342

H
Hongze Cheng 已提交
4343 4344 4345 4346 4347 4348 4349 4350 4351 4352
  // 1.1
  if (tDecodeIsEnd(&decoder)) {
    pReq->tw.skey = TSKEY_MIN;
    pReq->tw.ekey = TSKEY_MAX;
  } else {
    if (tDecodeI64(&decoder, &pReq->tw.skey) < 0) return -1;
    if (tDecodeI64(&decoder, &pReq->tw.ekey) < 0) return -1;
  }

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4353
  tDecoderClear(&decoder);
4354 4355 4356
  return 0;
}

4357
int32_t tSerializeSAlterVnodeConfigReq(void *buf, int32_t bufLen, SAlterVnodeConfigReq *pReq) {
H
Hongze Cheng 已提交
4358 4359
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
4360 4361 4362

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
4363 4364 4365
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
4366
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
4367
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
4368 4369 4370
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
4371
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
4372 4373
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
4374
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
4375 4376
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
4377
  }
4378

H
refact  
Hongze Cheng 已提交
4379
  // 1st modification
4380 4381
  if (tEncodeI16(&encoder, pReq->sttTrigger) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->minRows) < 0) return -1;
4382 4383 4384
  // 2nd modification
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->walRetentionSize) < 0) return -1;
4385 4386 4387
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4388
  tEncoderClear(&encoder);
4389 4390 4391
  return tlen;
}

4392
int32_t tDeserializeSAlterVnodeConfigReq(void *buf, int32_t bufLen, SAlterVnodeConfigReq *pReq) {
H
Hongze Cheng 已提交
4393 4394
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
4395 4396 4397

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
4398 4399 4400
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
4401
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
4402
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
4403 4404 4405
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
4406
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
4407 4408
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
4409
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
4410 4411 4412
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
4413

H
refact  
Hongze Cheng 已提交
4414
  // 1st modification
4415 4416 4417 4418 4419 4420 4421
  if (tDecodeIsEnd(&decoder)) {
    pReq->sttTrigger = -1;
    pReq->minRows = -1;
  } else {
    if (tDecodeI16(&decoder, &pReq->sttTrigger) < 0) return -1;
    if (tDecodeI32(&decoder, &pReq->minRows) < 0) return -1;
  }
4422

4423 4424 4425 4426 4427 4428 4429 4430
  // 2n modification
  if (tDecodeIsEnd(&decoder)) {
    pReq->walRetentionPeriod = -1;
    pReq->walRetentionSize = -1;
  } else {
    if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
    if (tDecodeI32(&decoder, &pReq->walRetentionSize) < 0) return -1;
  }
4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465
  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSAlterVnodeReplicaReq(void *buf, int32_t bufLen, SAlterVnodeReplicaReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
    if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
  }
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSAlterVnodeReplicaReq(void *buf, int32_t bufLen, SAlterVnodeReplicaReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
4466
  if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
4467
  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
4468 4469 4470 4471
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
  }
4472 4473 4474
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
4475

4476
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4477
  tDecoderClear(&decoder);
4478 4479 4480
  return 0;
}

4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508
int32_t tSerializeSDisableVnodeWriteReq(void *buf, int32_t bufLen, SDisableVnodeWriteReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->disable) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSDisableVnodeWriteReq(void *buf, int32_t bufLen, SDisableVnodeWriteReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->disable) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542
int32_t tSerializeSAlterVnodeHashRangeReq(void *buf, int32_t bufLen, SAlterVnodeHashRangeReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->srcVgId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dstVgId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->hashBegin) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->hashEnd) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->reserved) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSAlterVnodeHashRangeReq(void *buf, int32_t bufLen, SAlterVnodeHashRangeReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->srcVgId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dstVgId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->hashBegin) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->hashEnd) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->reserved) < 0) return -1;

  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

S
Shengliang Guan 已提交
4543
int32_t tSerializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
H
Hongze Cheng 已提交
4544 4545
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4546 4547

  if (tStartEncode(&encoder) < 0) return -1;
X
Xiaoyu Wang 已提交
4548
  if (tEncodeCStr(&encoder, pReq->queryStrId) < 0) return -1;
S
Shengliang Guan 已提交
4549 4550 4551
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4552
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4553 4554 4555 4556
  return tlen;
}

int32_t tDeserializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
H
Hongze Cheng 已提交
4557 4558
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4559 4560

  if (tStartDecode(&decoder) < 0) return -1;
X
Xiaoyu Wang 已提交
4561
  if (tDecodeCStrTo(&decoder, pReq->queryStrId) < 0) return -1;
S
Shengliang Guan 已提交
4562 4563
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4564
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4565 4566 4567 4568
  return 0;
}

int32_t tSerializeSKillConnReq(void *buf, int32_t bufLen, SKillConnReq *pReq) {
H
Hongze Cheng 已提交
4569 4570
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4571 4572

  if (tStartEncode(&encoder) < 0) return -1;
D
dapan1121 已提交
4573
  if (tEncodeU32(&encoder, pReq->connId) < 0) return -1;
S
Shengliang Guan 已提交
4574 4575 4576
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4577
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4578 4579 4580 4581
  return tlen;
}

int32_t tDeserializeSKillConnReq(void *buf, int32_t bufLen, SKillConnReq *pReq) {
H
Hongze Cheng 已提交
4582 4583
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4584 4585

  if (tStartDecode(&decoder) < 0) return -1;
D
dapan1121 已提交
4586
  if (tDecodeU32(&decoder, &pReq->connId) < 0) return -1;
S
Shengliang Guan 已提交
4587 4588
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4589
  tDecoderClear(&decoder);
4590
  return 0;
S
Shengliang Guan 已提交
4591 4592
}

S
Shengliang Guan 已提交
4593
int32_t tSerializeSKillTransReq(void *buf, int32_t bufLen, SKillTransReq *pReq) {
H
Hongze Cheng 已提交
4594 4595
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4596 4597 4598 4599 4600 4601

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->transId) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4602
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4603 4604 4605 4606
  return tlen;
}

int32_t tDeserializeSKillTransReq(void *buf, int32_t bufLen, SKillTransReq *pReq) {
H
Hongze Cheng 已提交
4607 4608
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4609 4610 4611 4612 4613

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->transId) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4614
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4615 4616 4617
  return 0;
}

4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642
int32_t tSerializeSBalanceVgroupReq(void *buf, int32_t bufLen, SBalanceVgroupReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSBalanceVgroupReq(void *buf, int32_t bufLen, SBalanceVgroupReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

C
cadem 已提交
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667
int32_t tSerializeSBalanceVgroupLeaderReq(void *buf, int32_t bufLen, SBalanceVgroupLeaderReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSBalanceVgroupLeaderReq(void *buf, int32_t bufLen, SBalanceVgroupLeaderReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725
int32_t tSerializeSMergeVgroupReq(void *buf, int32_t bufLen, SMergeVgroupReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId2) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSMergeVgroupReq(void *buf, int32_t bufLen, SMergeVgroupReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId2) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSRedistributeVgroupReq(void *buf, int32_t bufLen, SRedistributeVgroupReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId2) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->dnodeId3) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSRedistributeVgroupReq(void *buf, int32_t bufLen, SRedistributeVgroupReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId2) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->dnodeId3) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
int32_t tSerializeSSplitVgroupReq(void *buf, int32_t bufLen, SSplitVgroupReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSSplitVgroupReq(void *buf, int32_t bufLen, SSplitVgroupReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

4751
int32_t tSerializeSForceBecomeFollowerReq(void *buf, int32_t bufLen, SForceBecomeFollowerReq *pReq) {
C
cadem 已提交
4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

4764
int32_t tDeserializeSForceBecomeFollowerReq(void *buf, int32_t bufLen, SForceBecomeFollowerReq *pReq) {
C
cadem 已提交
4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

S
Shengliang Guan 已提交
4776
int32_t tSerializeSDCreateMnodeReq(void *buf, int32_t bufLen, SDCreateMnodeReq *pReq) {
H
Hongze Cheng 已提交
4777 4778
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4779 4780 4781 4782 4783 4784 4785 4786 4787 4788

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
    if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4789
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4790 4791 4792 4793
  return tlen;
}

int32_t tDeserializeSDCreateMnodeReq(void *buf, int32_t bufLen, SDCreateMnodeReq *pReq) {
H
Hongze Cheng 已提交
4794 4795
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4796 4797 4798 4799 4800 4801 4802 4803 4804

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4805
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4806 4807 4808 4809
  return 0;
}

int32_t tSerializeSAuthReq(void *buf, int32_t bufLen, SAuthReq *pReq) {
H
Hongze Cheng 已提交
4810 4811
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4812 4813 4814 4815 4816 4817 4818 4819 4820 4821

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->spi) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->encrypt) < 0) return -1;
  if (tEncodeBinary(&encoder, pReq->secret, TSDB_PASSWORD_LEN) < 0) return -1;
  if (tEncodeBinary(&encoder, pReq->ckey, TSDB_PASSWORD_LEN) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4822
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4823 4824 4825 4826
  return tlen;
}

int32_t tDeserializeSAuthReq(void *buf, int32_t bufLen, SAuthReq *pReq) {
H
Hongze Cheng 已提交
4827 4828
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4829 4830 4831 4832 4833 4834 4835 4836 4837

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->spi) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->encrypt) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->secret) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->ckey) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4838
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4839 4840
  return 0;
}
L
Liu Jicong 已提交
4841

4842
int32_t tSerializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
H
Hongze Cheng 已提交
4843 4844
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
4845 4846 4847

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->statusCode) < 0) return -1;
4848
  if (tEncodeCStr(&encoder, pRsp->details) < 0) return -1;
4849 4850 4851 4852

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4853
  tEncoderClear(&encoder);
4854 4855 4856 4857
  return tlen;
}

int32_t tDeserializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
H
Hongze Cheng 已提交
4858 4859
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
4860 4861 4862

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->statusCode) < 0) return -1;
4863
  if (tDecodeCStrTo(&decoder, pRsp->details) < 0) return -1;
4864 4865

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4866
  tDecoderClear(&decoder);
4867 4868
  return 0;
}
H
Hongze Cheng 已提交
4869
int32_t tEncodeSMqOffset(SEncoder *encoder, const SMqOffset *pOffset) {
L
Liu Jicong 已提交
4870 4871 4872 4873 4874 4875 4876
  if (tEncodeI32(encoder, pOffset->vgId) < 0) return -1;
  if (tEncodeI64(encoder, pOffset->offset) < 0) return -1;
  if (tEncodeCStr(encoder, pOffset->topicName) < 0) return -1;
  if (tEncodeCStr(encoder, pOffset->cgroup) < 0) return -1;
  return encoder->pos;
}

H
Hongze Cheng 已提交
4877
int32_t tDecodeSMqOffset(SDecoder *decoder, SMqOffset *pOffset) {
L
Liu Jicong 已提交
4878 4879 4880 4881 4882 4883 4884
  if (tDecodeI32(decoder, &pOffset->vgId) < 0) return -1;
  if (tDecodeI64(decoder, &pOffset->offset) < 0) return -1;
  if (tDecodeCStrTo(decoder, pOffset->topicName) < 0) return -1;
  if (tDecodeCStrTo(decoder, pOffset->cgroup) < 0) return -1;
  return 0;
}

H
Hongze Cheng 已提交
4885
int32_t tEncodeSMqCMCommitOffsetReq(SEncoder *encoder, const SMqCMCommitOffsetReq *pReq) {
L
Liu Jicong 已提交
4886 4887 4888 4889 4890 4891 4892 4893 4894
  if (tStartEncode(encoder) < 0) return -1;
  if (tEncodeI32(encoder, pReq->num) < 0) return -1;
  for (int32_t i = 0; i < pReq->num; i++) {
    tEncodeSMqOffset(encoder, &pReq->offsets[i]);
  }
  tEndEncode(encoder);
  return encoder->pos;
}

H
Hongze Cheng 已提交
4895
int32_t tDecodeSMqCMCommitOffsetReq(SDecoder *decoder, SMqCMCommitOffsetReq *pReq) {
L
Liu Jicong 已提交
4896
  if (tStartDecode(decoder) < 0) return -1;
L
Liu Jicong 已提交
4897
  if (tDecodeI32(decoder, &pReq->num) < 0) return -1;
H
Hongze Cheng 已提交
4898
  pReq->offsets = (SMqOffset *)tDecoderMalloc(decoder, sizeof(SMqOffset) * pReq->num);
L
Liu Jicong 已提交
4899 4900 4901 4902
  if (pReq->offsets == NULL) return -1;
  for (int32_t i = 0; i < pReq->num; i++) {
    tDecodeSMqOffset(decoder, &pReq->offsets[i]);
  }
L
Liu Jicong 已提交
4903
  tEndDecode(decoder);
L
Liu Jicong 已提交
4904 4905
  return 0;
}
dengyihao's avatar
dengyihao 已提交
4906
int32_t tSerializeSExplainRsp(void *buf, int32_t bufLen, SExplainRsp *pRsp) {
H
Hongze Cheng 已提交
4907 4908
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
4909 4910 4911 4912 4913

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfPlans) < 0) return -1;
  for (int32_t i = 0; i < pRsp->numOfPlans; ++i) {
    SExplainExecInfo *info = &pRsp->subplanInfo[i];
4914 4915
    if (tEncodeDouble(&encoder, info->startupCost) < 0) return -1;
    if (tEncodeDouble(&encoder, info->totalCost) < 0) return -1;
D
dapan1121 已提交
4916
    if (tEncodeU64(&encoder, info->numOfRows) < 0) return -1;
4917 4918
    if (tEncodeU32(&encoder, info->verboseLen) < 0) return -1;
    if (tEncodeBinary(&encoder, info->verboseInfo, info->verboseLen) < 0) return -1;
D
dapan1121 已提交
4919 4920 4921 4922 4923
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4924
  tEncoderClear(&encoder);
D
dapan1121 已提交
4925 4926 4927
  return tlen;
}

dengyihao's avatar
dengyihao 已提交
4928
int32_t tDeserializeSExplainRsp(void *buf, int32_t bufLen, SExplainRsp *pRsp) {
H
Hongze Cheng 已提交
4929 4930
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
4931 4932 4933 4934

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfPlans) < 0) return -1;
  if (pRsp->numOfPlans > 0) {
4935
    pRsp->subplanInfo = taosMemoryCalloc(pRsp->numOfPlans, sizeof(SExplainExecInfo));
D
dapan1121 已提交
4936 4937 4938
    if (pRsp->subplanInfo == NULL) return -1;
  }
  for (int32_t i = 0; i < pRsp->numOfPlans; ++i) {
4939 4940
    if (tDecodeDouble(&decoder, &pRsp->subplanInfo[i].startupCost) < 0) return -1;
    if (tDecodeDouble(&decoder, &pRsp->subplanInfo[i].totalCost) < 0) return -1;
D
dapan1121 已提交
4941
    if (tDecodeU64(&decoder, &pRsp->subplanInfo[i].numOfRows) < 0) return -1;
4942
    if (tDecodeU32(&decoder, &pRsp->subplanInfo[i].verboseLen) < 0) return -1;
4943
    if (tDecodeBinaryAlloc(&decoder, &pRsp->subplanInfo[i].verboseInfo, NULL) < 0) return -1;
D
dapan1121 已提交
4944 4945 4946 4947
  }

  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4948
  tDecoderClear(&decoder);
D
dapan1121 已提交
4949 4950 4951
  return 0;
}

4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964
void tFreeSExplainRsp(SExplainRsp *pRsp) {
  if (NULL == pRsp) {
    return;
  }

  for (int32_t i = 0; i < pRsp->numOfPlans; ++i) {
    SExplainExecInfo *pExec = pRsp->subplanInfo + i;
    taosMemoryFree(pExec->verboseInfo);
  }

  taosMemoryFreeClear(pRsp->subplanInfo);
}

4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016
int32_t tSerializeSBatchReq(void *buf, int32_t bufLen, SBatchReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  int32_t num = taosArrayGetSize(pReq->pMsgs);
  if (tEncodeI32(&encoder, num) < 0) return -1;
  for (int32_t i = 0; i < num; ++i) {
    SBatchMsg *pMsg = taosArrayGet(pReq->pMsgs, i);
    if (tEncodeI32(&encoder, pMsg->msgIdx) < 0) return -1;
    if (tEncodeI32(&encoder, pMsg->msgType) < 0) return -1;
    if (tEncodeI32(&encoder, pMsg->msgLen) < 0) return -1;
    if (tEncodeBinary(&encoder, pMsg->msg, pMsg->msgLen) < 0) return -1;
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSBatchReq(void *buf, int32_t bufLen, SBatchReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;

  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (num <= 0) {
    pReq->pMsgs = NULL;
    tEndDecode(&decoder);
5017

5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028
    tDecoderClear(&decoder);
    return 0;
  }

  pReq->pMsgs = taosArrayInit(num, sizeof(SBatchMsg));
  if (NULL == pReq->pMsgs) return -1;
  for (int32_t i = 0; i < num; ++i) {
    SBatchMsg msg = {0};
    if (tDecodeI32(&decoder, &msg.msgIdx) < 0) return -1;
    if (tDecodeI32(&decoder, &msg.msgType) < 0) return -1;
    if (tDecodeI32(&decoder, &msg.msgLen) < 0) return -1;
D
dapan1121 已提交
5029
    if (tDecodeBinaryAlloc(&decoder, &msg.msg, NULL) < 0) return -1;
5030 5031
    if (NULL == taosArrayPush(pReq->pMsgs, &msg)) return -1;
  }
5032

5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSBatchRsp(void *buf, int32_t bufLen, SBatchRsp *pRsp) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  int32_t num = taosArrayGetSize(pRsp->pRsps);
  if (tEncodeI32(&encoder, num) < 0) return -1;
  for (int32_t i = 0; i < num; ++i) {
    SBatchRspMsg *pMsg = taosArrayGet(pRsp->pRsps, i);
    if (tEncodeI32(&encoder, pMsg->reqType) < 0) return -1;
    if (tEncodeI32(&encoder, pMsg->msgIdx) < 0) return -1;
    if (tEncodeI32(&encoder, pMsg->msgLen) < 0) return -1;
    if (tEncodeI32(&encoder, pMsg->rspCode) < 0) return -1;
    if (tEncodeBinary(&encoder, pMsg->msg, pMsg->msgLen) < 0) return -1;
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  return tlen;
}

int32_t tDeserializeSBatchRsp(void *buf, int32_t bufLen, SBatchRsp *pRsp) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;

  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (num <= 0) {
    pRsp->pRsps = NULL;
    tEndDecode(&decoder);
5074

5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089
    tDecoderClear(&decoder);
    return 0;
  }

  pRsp->pRsps = taosArrayInit(num, sizeof(SBatchRspMsg));
  if (NULL == pRsp->pRsps) return -1;
  for (int32_t i = 0; i < num; ++i) {
    SBatchRspMsg msg = {0};
    if (tDecodeI32(&decoder, &msg.reqType) < 0) return -1;
    if (tDecodeI32(&decoder, &msg.msgIdx) < 0) return -1;
    if (tDecodeI32(&decoder, &msg.msgLen) < 0) return -1;
    if (tDecodeI32(&decoder, &msg.rspCode) < 0) return -1;
    if (tDecodeBinaryAlloc(&decoder, &msg.msg, NULL) < 0) return -1;
    if (NULL == taosArrayPush(pRsp->pRsps, &msg)) return -1;
  }
5090

5091 5092 5093 5094 5095 5096
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122
int32_t tSerializeSMqAskEpReq(void *buf, int32_t bufLen, SMqAskEpReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeI64(&encoder, pReq->consumerId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->epoch) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->cgroup) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  return tlen;
}

int32_t tDeserializeSMqAskEpReq(void *buf, int32_t bufLen, SMqAskEpReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->epoch) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->cgroup) < 0) return -1;
5123

D
dapan1121 已提交
5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

int32_t tSerializeSMqHbReq(void *buf, int32_t bufLen, SMqHbReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeI64(&encoder, pReq->consumerId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->epoch) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  return tlen;
}

int32_t tDeserializeSMqHbReq(void *buf, int32_t bufLen, SMqHbReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->epoch) < 0) return -1;
5154

D
dapan1121 已提交
5155 5156 5157 5158 5159 5160
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183
int32_t tSerializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->refId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->execId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->msgMask) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->taskType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->explain) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->needFetch) < 0) return -1;
  if (tEncodeU32(&encoder, pReq->sqlLen) < 0) return -1;
  if (tEncodeCStrWithLen(&encoder, pReq->sql, pReq->sqlLen) < 0) return -1;
  if (tEncodeU32(&encoder, pReq->msgLen) < 0) return -1;
5184
  if (tEncodeBinary(&encoder, (uint8_t *)pReq->msg, pReq->msgLen) < 0) return -1;
D
dapan1121 已提交
5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->queryId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->refId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->execId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->msgMask) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->taskType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->explain) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->needFetch) < 0) return -1;
  if (tDecodeU32(&decoder, &pReq->sqlLen) < 0) return -1;
  if (tDecodeCStrAlloc(&decoder, &pReq->sql) < 0) return -1;
  if (tDecodeU32(&decoder, &pReq->msgLen) < 0) return -1;
5224 5225
  if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, NULL) < 0) return -1;

D
dapan1121 已提交
5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

void tFreeSSubQueryMsg(SSubQueryMsg *pReq) {
  if (NULL == pReq) {
    return;
  }

  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->msg);
}

D
dapan1121 已提交
5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286
int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->execId) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->queryId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->execId) < 0) return -1;
5287

D
dapan1121 已提交
5288 5289 5290 5291 5292 5293
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336
int32_t tSerializeSTqOffsetVal(SEncoder *pEncoder, STqOffsetVal *pOffset) {
  if (tEncodeI8(pEncoder, pOffset->type) < 0) return -1;
  if (tEncodeI64(pEncoder, pOffset->uid) < 0) return -1;
  if (tEncodeI64(pEncoder, pOffset->ts) < 0) return -1;

  return 0;
}

int32_t tDerializeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffset) {
  if (tDecodeI8(pDecoder, &pOffset->type) < 0) return -1;
  if (tDecodeI64(pDecoder, &pOffset->uid) < 0) return -1;
  if (tDecodeI64(pDecoder, &pOffset->ts) < 0) return -1;

  return 0;
}

int32_t tSerializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeCStr(&encoder, pReq->subKey) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->withTbName) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->useSnapshot) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->epoch) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->reqId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->consumerId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->timeout) < 0) return -1;
  if (tSerializeSTqOffsetVal(&encoder, &pReq->reqOffset) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
5337
    pHead->vgId = htonl(pReq->head.vgId);
5338 5339 5340 5341 5342 5343 5344 5345 5346
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

5347 5348 5349
//  SMsgHead *pHead = buf;
//  pHead->vgId = pReq->head.vgId;
//  pHead->contLen = pReq->head.contLen;
5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeCStrTo(&decoder, pReq->subKey) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->withTbName) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->useSnapshot) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->epoch) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->reqId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->timeout) < 0) return -1;
  if (tDerializeSTqOffsetVal(&decoder, &pReq->reqOffset) < 0) return -1;
5364

5365 5366 5367 5368 5369 5370
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
int32_t tSerializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->refId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->execId) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->queryId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->refId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->execId) < 0) return -1;
5419

D
dapan1121 已提交
5420 5421 5422 5423 5424 5425
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455
int32_t tSerializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
  if (tStartEncode(&encoder) < 0) return -1;

  if (tEncodeI32(&encoder, pRsp->code) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->tbFName) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->sversion) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->tversion) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->affectedRows) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);

  return tlen;
}

int32_t tDeserializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;

  if (tDecodeI32(&decoder, &pRsp->code) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->tbFName) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->sversion) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->tversion) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->affectedRows) < 0) return -1;
5456

5457 5458 5459 5460 5461 5462
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
5463 5464 5465 5466 5467 5468 5469
int32_t tSerializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

H
Hongze Cheng 已提交
5470 5471
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
5472 5473

  if (tStartEncode(&encoder) < 0) return -1;
L
Liu Jicong 已提交
5474 5475
  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->epId.nodeId) < 0) return -1;
D
dapan1121 已提交
5476
  if (tEncodeU16(&encoder, pReq->epId.ep.port) < 0) return -1;
L
Liu Jicong 已提交
5477
  if (tEncodeCStr(&encoder, pReq->epId.ep.fqdn) < 0) return -1;
D
dapan1121 已提交
5478 5479
  if (pReq->taskAction) {
    int32_t num = taosArrayGetSize(pReq->taskAction);
L
Liu Jicong 已提交
5480
    if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
5481 5482
    for (int32_t i = 0; i < num; ++i) {
      STaskAction *action = taosArrayGet(pReq->taskAction, i);
L
Liu Jicong 已提交
5483 5484 5485
      if (tEncodeU64(&encoder, action->queryId) < 0) return -1;
      if (tEncodeU64(&encoder, action->taskId) < 0) return -1;
      if (tEncodeI8(&encoder, action->action) < 0) return -1;
D
dapan1121 已提交
5486 5487
    }
  } else {
L
Liu Jicong 已提交
5488
    if (tEncodeI32(&encoder, 0) < 0) return -1;
D
dapan1121 已提交
5489 5490 5491 5492
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5493
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
5494

D
dapan1121 已提交
5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510
  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;

H
Hongze Cheng 已提交
5511 5512
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);
D
dapan1121 已提交
5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->epId.nodeId) < 0) return -1;
  if (tDecodeU16(&decoder, &pReq->epId.ep.port) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->epId.ep.fqdn) < 0) return -1;
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (num > 0) {
    pReq->taskAction = taosArrayInit(num, sizeof(STaskStatus));
    if (NULL == pReq->taskAction) return -1;
    for (int32_t i = 0; i < num; ++i) {
      STaskAction action = {0};
      if (tDecodeU64(&decoder, &action.queryId) < 0) return -1;
      if (tDecodeU64(&decoder, &action.taskId) < 0) return -1;
      if (tDecodeI8(&decoder, &action.action) < 0) return -1;
      taosArrayPush(pReq->taskAction, &action);
    }
  } else {
    pReq->taskAction = NULL;
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
5536
  tDecoderClear(&decoder);
D
dapan1121 已提交
5537 5538 5539 5540 5541 5542
  return 0;
}

void tFreeSSchedulerHbReq(SSchedulerHbReq *pReq) { taosArrayDestroy(pReq->taskAction); }

int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
H
Hongze Cheng 已提交
5543 5544
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
5545 5546

  if (tStartEncode(&encoder) < 0) return -1;
L
Liu Jicong 已提交
5547
  if (tEncodeI32(&encoder, pRsp->epId.nodeId) < 0) return -1;
D
dapan1121 已提交
5548
  if (tEncodeU16(&encoder, pRsp->epId.ep.port) < 0) return -1;
L
Liu Jicong 已提交
5549
  if (tEncodeCStr(&encoder, pRsp->epId.ep.fqdn) < 0) return -1;
D
dapan1121 已提交
5550 5551
  if (pRsp->taskStatus) {
    int32_t num = taosArrayGetSize(pRsp->taskStatus);
L
Liu Jicong 已提交
5552
    if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
5553 5554
    for (int32_t i = 0; i < num; ++i) {
      STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
L
Liu Jicong 已提交
5555 5556 5557
      if (tEncodeU64(&encoder, status->queryId) < 0) return -1;
      if (tEncodeU64(&encoder, status->taskId) < 0) return -1;
      if (tEncodeI64(&encoder, status->refId) < 0) return -1;
D
dapan1121 已提交
5558
      if (tEncodeI32(&encoder, status->execId) < 0) return -1;
L
Liu Jicong 已提交
5559
      if (tEncodeI8(&encoder, status->status) < 0) return -1;
D
dapan1121 已提交
5560 5561
    }
  } else {
L
Liu Jicong 已提交
5562
    if (tEncodeI32(&encoder, 0) < 0) return -1;
D
dapan1121 已提交
5563 5564 5565 5566
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5567
  tEncoderClear(&encoder);
D
dapan1121 已提交
5568 5569 5570 5571
  return tlen;
}

int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
H
Hongze Cheng 已提交
5572 5573
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->epId.nodeId) < 0) return -1;
  if (tDecodeU16(&decoder, &pRsp->epId.ep.port) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->epId.ep.fqdn) < 0) return -1;
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
  if (num > 0) {
    pRsp->taskStatus = taosArrayInit(num, sizeof(STaskStatus));
    if (NULL == pRsp->taskStatus) return -1;
    for (int32_t i = 0; i < num; ++i) {
      STaskStatus status = {0};
      if (tDecodeU64(&decoder, &status.queryId) < 0) return -1;
      if (tDecodeU64(&decoder, &status.taskId) < 0) return -1;
      if (tDecodeI64(&decoder, &status.refId) < 0) return -1;
D
dapan1121 已提交
5589
      if (tDecodeI32(&decoder, &status.execId) < 0) return -1;
D
dapan1121 已提交
5590 5591 5592 5593 5594 5595 5596 5597
      if (tDecodeI8(&decoder, &status.status) < 0) return -1;
      taosArrayPush(pRsp->taskStatus, &status);
    }
  } else {
    pRsp->taskStatus = NULL;
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
5598
  tDecoderClear(&decoder);
D
dapan1121 已提交
5599 5600 5601 5602 5603
  return 0;
}

void tFreeSSchedulerHbRsp(SSchedulerHbRsp *pRsp) { taosArrayDestroy(pRsp->taskStatus); }

D
dapan 已提交
5604
int32_t tSerializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5605 5606
  // SEncoder encoder = {0};
  // tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
5607

H
Hongze Cheng 已提交
5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619
  // if (tStartEncode(&encoder) < 0) return -1;
  // if (pRsp->rspList) {
  //   int32_t num = taosArrayGetSize(pRsp->rspList);
  //   if (tEncodeI32(&encoder, num) < 0) return -1;
  //   for (int32_t i = 0; i < num; ++i) {
  //     SVCreateTbRsp *rsp = taosArrayGet(pRsp->rspList, i);
  //     if (tEncodeI32(&encoder, rsp->code) < 0) return -1;
  //   }
  // } else {
  //   if (tEncodeI32(&encoder, 0) < 0) return -1;
  // }
  // tEndEncode(&encoder);
D
dapan 已提交
5620

H
Hongze Cheng 已提交
5621
  // int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5622
  // tEncoderClear(&encoder);
H
Hongze Cheng 已提交
5623 5624
  // reture tlen;
  return 0;
D
dapan 已提交
5625 5626 5627
}

int32_t tDeserializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5628
  // SDecoder  decoder = {0};
H
Hongze Cheng 已提交
5629
  // int32_t num = 0;
H
Hongze Cheng 已提交
5630
  // tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
5631

H
Hongze Cheng 已提交
5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
  // if (tStartDecode(&decoder) < 0) return -1;
  // if (tDecodeI32(&decoder, &num) < 0) return -1;
  // if (num > 0) {
  //   pRsp->rspList = taosArrayInit(num, sizeof(SVCreateTbRsp));
  //   if (NULL == pRsp->rspList) return -1;
  //   for (int32_t i = 0; i < num; ++i) {
  //     SVCreateTbRsp rsp = {0};
  //     if (tDecodeI32(&decoder, &rsp.code) < 0) return -1;
  //     if (NULL == taosArrayPush(pRsp->rspList, &rsp)) return -1;
  //   }
  // } else {
  //   pRsp->rspList = NULL;
  // }
  // tEndDecode(&decoder);
D
dapan 已提交
5646

H
Hongze Cheng 已提交
5647
  // tDecoderClear(&decoder);
D
dapan 已提交
5648 5649 5650
  return 0;
}

H
Hongze Cheng 已提交
5651
int tEncodeSVCreateTbBatchRsp(SEncoder *pCoder, const SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5652 5653 5654 5655 5656 5657 5658 5659 5660
  int32_t        nRsps = taosArrayGetSize(pRsp->pArray);
  SVCreateTbRsp *pCreateRsp;

  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, nRsps) < 0) return -1;
  for (int32_t i = 0; i < nRsps; i++) {
    pCreateRsp = taosArrayGet(pRsp->pArray, i);
    if (tEncodeSVCreateTbRsp(pCoder, pCreateRsp) < 0) return -1;
D
dapan 已提交
5661 5662
  }

H
Hongze Cheng 已提交
5663 5664 5665 5666 5667
  tEndEncode(pCoder);

  return 0;
}

H
Hongze Cheng 已提交
5668
int tDecodeSVCreateTbBatchRsp(SDecoder *pCoder, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5669 5670 5671
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
H
Hongze Cheng 已提交
5672
  pRsp->pRsps = (SVCreateTbRsp *)tDecoderMalloc(pCoder, sizeof(*pRsp->pRsps) * pRsp->nRsps);
H
Hongze Cheng 已提交
5673 5674 5675 5676 5677
  for (int32_t i = 0; i < pRsp->nRsps; i++) {
    if (tDecodeSVCreateTbRsp(pCoder, pRsp->pRsps + i) < 0) return -1;
  }

  tEndDecode(pCoder);
D
dapan 已提交
5678 5679 5680
  return 0;
}

5681 5682 5683 5684 5685
int32_t tEncodeTSma(SEncoder *pCoder, const STSma *pSma) {
  if (tEncodeI8(pCoder, pSma->version) < 0) return -1;
  if (tEncodeI8(pCoder, pSma->intervalUnit) < 0) return -1;
  if (tEncodeI8(pCoder, pSma->slidingUnit) < 0) return -1;
  if (tEncodeI8(pCoder, pSma->timezoneInt) < 0) return -1;
C
Cary Xu 已提交
5686
  if (tEncodeI32(pCoder, pSma->dstVgId) < 0) return -1;
5687 5688 5689 5690 5691
  if (tEncodeCStr(pCoder, pSma->indexName) < 0) return -1;
  if (tEncodeI32(pCoder, pSma->exprLen) < 0) return -1;
  if (tEncodeI32(pCoder, pSma->tagsFilterLen) < 0) return -1;
  if (tEncodeI64(pCoder, pSma->indexUid) < 0) return -1;
  if (tEncodeI64(pCoder, pSma->tableUid) < 0) return -1;
5692 5693
  if (tEncodeI64(pCoder, pSma->dstTbUid) < 0) return -1;
  if (tEncodeCStr(pCoder, pSma->dstTbName) < 0) return -1;
5694 5695 5696 5697 5698 5699 5700 5701 5702
  if (tEncodeI64(pCoder, pSma->interval) < 0) return -1;
  if (tEncodeI64(pCoder, pSma->offset) < 0) return -1;
  if (tEncodeI64(pCoder, pSma->sliding) < 0) return -1;
  if (pSma->exprLen > 0) {
    if (tEncodeCStr(pCoder, pSma->expr) < 0) return -1;
  }
  if (pSma->tagsFilterLen > 0) {
    if (tEncodeCStr(pCoder, pSma->tagsFilter) < 0) return -1;
  }
5703

C
Cary Xu 已提交
5704 5705
  tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow);
  tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag);
5706

5707 5708 5709
  return 0;
}

C
Cary Xu 已提交
5710
int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) {
5711 5712 5713 5714
  if (tDecodeI8(pCoder, &pSma->version) < 0) return -1;
  if (tDecodeI8(pCoder, &pSma->intervalUnit) < 0) return -1;
  if (tDecodeI8(pCoder, &pSma->slidingUnit) < 0) return -1;
  if (tDecodeI8(pCoder, &pSma->timezoneInt) < 0) return -1;
5715
  if (tDecodeI32(pCoder, &pSma->dstVgId) < 0) return -1;
C
Cary Xu 已提交
5716
  if (tDecodeCStrTo(pCoder, pSma->indexName) < 0) return -1;
5717 5718 5719 5720
  if (tDecodeI32(pCoder, &pSma->exprLen) < 0) return -1;
  if (tDecodeI32(pCoder, &pSma->tagsFilterLen) < 0) return -1;
  if (tDecodeI64(pCoder, &pSma->indexUid) < 0) return -1;
  if (tDecodeI64(pCoder, &pSma->tableUid) < 0) return -1;
5721
  if (tDecodeI64(pCoder, &pSma->dstTbUid) < 0) return -1;
C
Cary Xu 已提交
5722 5723 5724 5725 5726 5727
  if (deepCopy) {
    if (tDecodeCStrAlloc(pCoder, &pSma->dstTbName) < 0) return -1;
  } else {
    if (tDecodeCStr(pCoder, &pSma->dstTbName) < 0) return -1;
  }

5728 5729 5730 5731
  if (tDecodeI64(pCoder, &pSma->interval) < 0) return -1;
  if (tDecodeI64(pCoder, &pSma->offset) < 0) return -1;
  if (tDecodeI64(pCoder, &pSma->sliding) < 0) return -1;
  if (pSma->exprLen > 0) {
C
Cary Xu 已提交
5732 5733 5734 5735 5736
    if (deepCopy) {
      if (tDecodeCStrAlloc(pCoder, &pSma->expr) < 0) return -1;
    } else {
      if (tDecodeCStr(pCoder, &pSma->expr) < 0) return -1;
    }
5737 5738 5739 5740
  } else {
    pSma->expr = NULL;
  }
  if (pSma->tagsFilterLen > 0) {
C
Cary Xu 已提交
5741 5742 5743 5744 5745
    if (deepCopy) {
      if (tDecodeCStrAlloc(pCoder, &pSma->tagsFilter) < 0) return -1;
    } else {
      if (tDecodeCStr(pCoder, &pSma->tagsFilter) < 0) return -1;
    }
5746 5747 5748
  } else {
    pSma->tagsFilter = NULL;
  }
C
Cary Xu 已提交
5749 5750 5751
  // only needed in dstVgroup
  tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow);
  tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag);
5752 5753 5754 5755 5756 5757

  return 0;
}

int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;
5758

5759
  tEncodeTSma(pCoder, pReq);
5760

5761 5762
  tEndEncode(pCoder);
  return 0;
5763
}
D
dapan1121 已提交
5764

5765 5766 5767
int32_t tDecodeSVCreateTSmaReq(SDecoder *pCoder, SVCreateTSmaReq *pReq) {
  if (tStartDecode(pCoder) < 0) return -1;

C
Cary Xu 已提交
5768
  tDecodeTSma(pCoder, pReq, false);
D
dapan1121 已提交
5769

5770 5771
  tEndDecode(pCoder);
  return 0;
5772 5773
}

5774 5775
int32_t tEncodeSVDropTSmaReq(SEncoder *pCoder, const SVDropTSmaReq *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;
5776

5777 5778
  if (tEncodeI64(pCoder, pReq->indexUid) < 0) return -1;
  if (tEncodeCStr(pCoder, pReq->indexName) < 0) return -1;
5779

5780 5781
  tEndEncode(pCoder);
  return 0;
5782 5783
}

5784 5785 5786 5787
int32_t tDecodeSVDropTSmaReq(SDecoder *pCoder, SVDropTSmaReq *pReq) {
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI64(pCoder, &pReq->indexUid) < 0) return -1;
C
Cary Xu 已提交
5788
  if (tDecodeCStrTo(pCoder, pReq->indexName) < 0) return -1;
5789 5790 5791

  tEndDecode(pCoder);
  return 0;
5792
}
L
Liu Jicong 已提交
5793

D
dapan1121 已提交
5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809
int32_t tSerializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }

  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1;
  if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1;
  if (tEncodeU32(&encoder, pReq->sqlLen) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
5810
  if (tEncodeBinary(&encoder, pReq->msg, pReq->phyLen) < 0) return -1;
D
dapan1121 已提交
5811 5812 5813 5814
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
5815

D
dapan1121 已提交
5816 5817 5818 5819
  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
5820 5821
  }

D
dapan1121 已提交
5822
  return tlen + headLen;
5823 5824
}

D
dapan1121 已提交
5825 5826
int32_t tDeserializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
5827

D
dapan1121 已提交
5828 5829 5830
  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;
5831

D
dapan1121 已提交
5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->queryId) < 0) return -1;
  if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1;
  if (tDecodeU32(&decoder, &pReq->sqlLen) < 0) return -1;
  pReq->sql = taosMemoryCalloc(1, pReq->sqlLen + 1);
  if (NULL == pReq->sql) return -1;
  if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
5843 5844 5845
  uint64_t msgLen = 0;
  if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, &msgLen) < 0) return -1;
  pReq->phyLen = msgLen;
D
dapan1121 已提交
5846 5847 5848 5849

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
5850 5851 5852
  return 0;
}

5853
int32_t tEncodeSVDeleteRsp(SEncoder *pCoder, const SVDeleteRsp *pReq) {
5854 5855 5856 5857 5858 5859 5860 5861
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI64(pCoder, pReq->affectedRows) < 0) return -1;

  tEndEncode(pCoder);
  return 0;
}

5862
int32_t tDecodeSVDeleteRsp(SDecoder *pCoder, SVDeleteRsp *pReq) {
5863 5864 5865 5866 5867 5868 5869 5870
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI64(pCoder, &pReq->affectedRows) < 0) return -1;

  tEndDecode(pCoder);
  return 0;
}

L
Liu Jicong 已提交
5871
int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {
L
Liu Jicong 已提交
5872 5873 5874 5875 5876
  int32_t sqlLen = 0;
  int32_t astLen = 0;
  if (pReq->sql != NULL) sqlLen = (int32_t)strlen(pReq->sql);
  if (pReq->ast != NULL) astLen = (int32_t)strlen(pReq->ast);

H
Hongze Cheng 已提交
5877 5878
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
L
Liu Jicong 已提交
5879 5880 5881

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
L
Liu Jicong 已提交
5882
  if (tEncodeCStr(&encoder, pReq->sourceDB) < 0) return -1;
L
Liu Jicong 已提交
5883
  if (tEncodeCStr(&encoder, pReq->targetStbFullName) < 0) return -1;
L
Liu Jicong 已提交
5884
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
5885
  if (tEncodeI8(&encoder, pReq->fillHistory) < 0) return -1;
L
Liu Jicong 已提交
5886 5887
  if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
  if (tEncodeI32(&encoder, astLen) < 0) return -1;
L
Liu Jicong 已提交
5888
  if (tEncodeI8(&encoder, pReq->triggerType) < 0) return -1;
5889
  if (tEncodeI64(&encoder, pReq->maxDelay) < 0) return -1;
L
Liu Jicong 已提交
5890
  if (tEncodeI64(&encoder, pReq->watermark) < 0) return -1;
5891
  if (tEncodeI8(&encoder, pReq->igExpired) < 0) return -1;
L
Liu Jicong 已提交
5892 5893
  if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
  if (astLen > 0 && tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
5894 5895 5896 5897 5898 5899 5900 5901
  if (tEncodeI32(&encoder, pReq->numOfTags) < 0) return -1;
  for (int32_t i = 0; i < pReq->numOfTags; ++i) {
    SField *pField = taosArrayGet(pReq->pTags, i);
    if (tEncodeI8(&encoder, pField->type) < 0) return -1;
    if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
    if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
    if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
  }
X
Xiaoyu Wang 已提交
5902

5903
  if (tEncodeI8(&encoder, pReq->createStb) < 0) return -1;
5904
  if (tEncodeU64(&encoder, pReq->targetStbUid) < 0) return -1;
5905 5906 5907 5908 5909 5910 5911
  if (tEncodeI32(&encoder, taosArrayGetSize(pReq->fillNullCols)) < 0) return -1;
  for (int32_t i = 0; i < taosArrayGetSize(pReq->fillNullCols); ++i) {
    SColLocation *pCol = taosArrayGet(pReq->fillNullCols, i);
    if (tEncodeI16(&encoder, pCol->slotId) < 0) return -1;
    if (tEncodeI16(&encoder, pCol->colId) < 0) return -1;
    if (tEncodeI8(&encoder, pCol->type) < 0) return -1;
  }
5912
  if (tEncodeI64(&encoder, pReq->deleteMark) < 0) return -1;
5913
  if (tEncodeI8(&encoder, pReq->igUpdate) < 0) return -1;
L
Liu Jicong 已提交
5914

L
Liu Jicong 已提交
5915 5916 5917
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5918
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
5919 5920 5921 5922
  return tlen;
}

int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStreamReq *pReq) {
L
Liu Jicong 已提交
5923 5924 5925
  int32_t sqlLen = 0;
  int32_t astLen = 0;

H
Hongze Cheng 已提交
5926 5927
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
L
Liu Jicong 已提交
5928 5929 5930

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
L
Liu Jicong 已提交
5931
  if (tDecodeCStrTo(&decoder, pReq->sourceDB) < 0) return -1;
L
Liu Jicong 已提交
5932
  if (tDecodeCStrTo(&decoder, pReq->targetStbFullName) < 0) return -1;
L
Liu Jicong 已提交
5933
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
5934
  if (tDecodeI8(&decoder, &pReq->fillHistory) < 0) return -1;
L
Liu Jicong 已提交
5935 5936
  if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
  if (tDecodeI32(&decoder, &astLen) < 0) return -1;
5937
  if (tDecodeI8(&decoder, &pReq->triggerType) < 0) return -1;
5938
  if (tDecodeI64(&decoder, &pReq->maxDelay) < 0) return -1;
5939
  if (tDecodeI64(&decoder, &pReq->watermark) < 0) return -1;
5940
  if (tDecodeI8(&decoder, &pReq->igExpired) < 0) return -1;
L
Liu Jicong 已提交
5941 5942

  if (sqlLen > 0) {
5943
    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
L
Liu Jicong 已提交
5944 5945 5946 5947 5948
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }

  if (astLen > 0) {
5949
    pReq->ast = taosMemoryCalloc(1, astLen + 1);
L
Liu Jicong 已提交
5950 5951 5952
    if (pReq->ast == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
  }
5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973

  if (tDecodeI32(&decoder, &pReq->numOfTags) < 0) return -1;
  if (pReq->numOfTags > 0) {
    pReq->pTags = taosArrayInit(pReq->numOfTags, sizeof(SField));
    if (pReq->pTags == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }

    for (int32_t i = 0; i < pReq->numOfTags; ++i) {
      SField field = {0};
      if (tDecodeI8(&decoder, &field.type) < 0) return -1;
      if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
      if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
      if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
      if (taosArrayPush(pReq->pTags, &field) == NULL) {
        terrno = TSDB_CODE_OUT_OF_MEMORY;
        return -1;
      }
    }
  }
5974
  if (tDecodeI8(&decoder, &pReq->createStb) < 0) return -1;
5975
  if (tDecodeU64(&decoder, &pReq->targetStbUid) < 0) return -1;
5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995
  int32_t numOfFillNullCols = 0;
  if (tDecodeI32(&decoder, &numOfFillNullCols) < 0) return -1;
  if (numOfFillNullCols > 0) {
    pReq->fillNullCols = taosArrayInit(numOfFillNullCols, sizeof(SColLocation));
    if (pReq->fillNullCols == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }

    for (int32_t i = 0; i < numOfFillNullCols; ++i) {
      SColLocation col = {0};
      if (tDecodeI16(&decoder, &col.slotId) < 0) return -1;
      if (tDecodeI16(&decoder, &col.colId) < 0) return -1;
      if (tDecodeI8(&decoder, &col.type) < 0) return -1;
      if (taosArrayPush(pReq->fillNullCols, &col) == NULL) {
        terrno = TSDB_CODE_OUT_OF_MEMORY;
        return -1;
      }
    }
  }
5996

5997
  if (tDecodeI64(&decoder, &pReq->deleteMark) < 0) return -1;
5998 5999
  if (tDecodeI8(&decoder, &pReq->igUpdate) < 0) return -1;

L
Liu Jicong 已提交
6000 6001
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
6002
  tDecoderClear(&decoder);
L
Liu Jicong 已提交
6003 6004 6005
  return 0;
}

6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034
int32_t tSerializeSMDropStreamReq(void *buf, int32_t bufLen, const SMDropStreamReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSMDropStreamReq(void *buf, int32_t bufLen, SMDropStreamReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063
int32_t tSerializeSMRecoverStreamReq(void *buf, int32_t bufLen, const SMRecoverStreamReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSMRecoverStreamReq(void *buf, int32_t bufLen, SMRecoverStreamReq *pReq) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

L
Liu Jicong 已提交
6064
void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
X
Xiaoyu Wang 已提交
6065
  taosArrayDestroy(pReq->pTags);
6066 6067
  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->ast);
6068
  taosArrayDestroy(pReq->fillNullCols);
L
Liu Jicong 已提交
6069
}
C
Cary Xu 已提交
6070

H
Hongze Cheng 已提交
6071
int32_t tEncodeSRSmaParam(SEncoder *pCoder, const SRSmaParam *pRSmaParam) {
6072 6073 6074 6075 6076 6077 6078 6079 6080
  for (int32_t i = 0; i < 2; ++i) {
    if (tEncodeI64v(pCoder, pRSmaParam->maxdelay[i]) < 0) return -1;
    if (tEncodeI64v(pCoder, pRSmaParam->watermark[i]) < 0) return -1;
    if (tEncodeI32v(pCoder, pRSmaParam->qmsgLen[i]) < 0) return -1;
    if (pRSmaParam->qmsgLen[i] > 0) {
      if (tEncodeBinary(pCoder, pRSmaParam->qmsg[i], (uint64_t)pRSmaParam->qmsgLen[i]) <
          0)  // qmsgLen contains len of '\0'
        return -1;
    }
C
Cary Xu 已提交
6081 6082 6083 6084 6085
  }

  return 0;
}

H
Hongze Cheng 已提交
6086
int32_t tDecodeSRSmaParam(SDecoder *pCoder, SRSmaParam *pRSmaParam) {
6087 6088 6089 6090 6091
  for (int32_t i = 0; i < 2; ++i) {
    if (tDecodeI64v(pCoder, &pRSmaParam->maxdelay[i]) < 0) return -1;
    if (tDecodeI64v(pCoder, &pRSmaParam->watermark[i]) < 0) return -1;
    if (tDecodeI32v(pCoder, &pRSmaParam->qmsgLen[i]) < 0) return -1;
    if (pRSmaParam->qmsgLen[i] > 0) {
6092
      if (tDecodeBinary(pCoder, (uint8_t **)&pRSmaParam->qmsg[i], NULL) < 0) return -1;  // qmsgLen contains len of '\0'
6093 6094 6095
    } else {
      pRSmaParam->qmsg[i] = NULL;
    }
C
Cary Xu 已提交
6096
  }
6097

C
Cary Xu 已提交
6098 6099 6100
  return 0;
}

H
Hongze Cheng 已提交
6101
int tEncodeSVCreateStbReq(SEncoder *pCoder, const SVCreateStbReq *pReq) {
H
Hongze Cheng 已提交
6102 6103 6104 6105 6106
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
  if (tEncodeI64(pCoder, pReq->suid) < 0) return -1;
  if (tEncodeI8(pCoder, pReq->rollup) < 0) return -1;
6107
  if (tEncodeSSchemaWrapper(pCoder, &pReq->schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
6108
  if (tEncodeSSchemaWrapper(pCoder, &pReq->schemaTag) < 0) return -1;
C
Cary Xu 已提交
6109
  if (pReq->rollup) {
C
Cary Xu 已提交
6110
    if (tEncodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
C
Cary Xu 已提交
6111
  }
H
Hongze Cheng 已提交
6112

6113 6114 6115 6116 6117
  if (tEncodeI32(pCoder, pReq->alterOriDataLen) < 0) return -1;
  if (pReq->alterOriDataLen > 0) {
    if (tEncodeBinary(pCoder, pReq->alterOriData, pReq->alterOriDataLen) < 0) return -1;
  }

H
Hongze Cheng 已提交
6118 6119 6120 6121
  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6122
int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
H
Hongze Cheng 已提交
6123 6124 6125 6126 6127
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
  if (tDecodeI64(pCoder, &pReq->suid) < 0) return -1;
  if (tDecodeI8(pCoder, &pReq->rollup) < 0) return -1;
6128 6129
  if (tDecodeSSchemaWrapperEx(pCoder, &pReq->schemaRow) < 0) return -1;
  if (tDecodeSSchemaWrapperEx(pCoder, &pReq->schemaTag) < 0) return -1;
C
Cary Xu 已提交
6130
  if (pReq->rollup) {
C
Cary Xu 已提交
6131
    if (tDecodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
C
Cary Xu 已提交
6132
  }
H
Hongze Cheng 已提交
6133

6134 6135 6136 6137 6138
  if (tDecodeI32(pCoder, &pReq->alterOriDataLen) < 0) return -1;
  if (pReq->alterOriDataLen > 0) {
    if (tDecodeBinary(pCoder, (uint8_t **)&pReq->alterOriData, NULL) < 0) return -1;
  }

H
Hongze Cheng 已提交
6139 6140 6141
  tEndDecode(pCoder);
  return 0;
}
6142

H
Hongze Cheng 已提交
6143
int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
H
Hongze Cheng 已提交
6144 6145
  if (tStartEncode(pCoder) < 0) return -1;

6146
  if (tEncodeI32v(pCoder, pReq->flags) < 0) return -1;
6147
  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
H
Hongze Cheng 已提交
6148 6149 6150 6151
  if (tEncodeI64(pCoder, pReq->uid) < 0) return -1;
  if (tEncodeI64(pCoder, pReq->ctime) < 0) return -1;
  if (tEncodeI32(pCoder, pReq->ttl) < 0) return -1;
  if (tEncodeI8(pCoder, pReq->type) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
6152 6153 6154 6155
  if (tEncodeI32(pCoder, pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
    if (tEncodeCStr(pCoder, pReq->comment) < 0) return -1;
  }
H
Hongze Cheng 已提交
6156 6157

  if (pReq->type == TSDB_CHILD_TABLE) {
6158
    if (tEncodeCStr(pCoder, pReq->ctb.stbName) < 0) return -1;
6159
    if (tEncodeU8(pCoder, pReq->ctb.tagNum) < 0) return -1;
H
Hongze Cheng 已提交
6160
    if (tEncodeI64(pCoder, pReq->ctb.suid) < 0) return -1;
6161
    if (tEncodeTag(pCoder, (const STag *)pReq->ctb.pTag) < 0) return -1;
6162 6163
    int32_t len = taosArrayGetSize(pReq->ctb.tagName);
    if (tEncodeI32(pCoder, len) < 0) return -1;
6164 6165
    for (int32_t i = 0; i < len; i++) {
      char *name = taosArrayGet(pReq->ctb.tagName, i);
6166 6167
      if (tEncodeCStr(pCoder, name) < 0) return -1;
    }
H
Hongze Cheng 已提交
6168
  } else if (pReq->type == TSDB_NORMAL_TABLE) {
6169
    if (tEncodeSSchemaWrapper(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
6170
  } else {
6171
    ASSERT(0);
H
Hongze Cheng 已提交
6172 6173 6174 6175 6176 6177
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6178
int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
H
Hongze Cheng 已提交
6179 6180
  if (tStartDecode(pCoder) < 0) return -1;

6181
  if (tDecodeI32v(pCoder, &pReq->flags) < 0) return -1;
6182
  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
H
Hongze Cheng 已提交
6183 6184 6185 6186
  if (tDecodeI64(pCoder, &pReq->uid) < 0) return -1;
  if (tDecodeI64(pCoder, &pReq->ctime) < 0) return -1;
  if (tDecodeI32(pCoder, &pReq->ttl) < 0) return -1;
  if (tDecodeI8(pCoder, &pReq->type) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
6187 6188
  if (tDecodeI32(pCoder, &pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
wmmhello's avatar
wmmhello 已提交
6189
    pReq->comment = taosMemoryMalloc(pReq->commentLen + 1);
wmmhello's avatar
wmmhello 已提交
6190 6191 6192
    if (pReq->comment == NULL) return -1;
    if (tDecodeCStrTo(pCoder, pReq->comment) < 0) return -1;
  }
H
Hongze Cheng 已提交
6193 6194

  if (pReq->type == TSDB_CHILD_TABLE) {
6195
    if (tDecodeCStr(pCoder, &pReq->ctb.stbName) < 0) return -1;
6196
    if (tDecodeU8(pCoder, &pReq->ctb.tagNum) < 0) return -1;
H
Hongze Cheng 已提交
6197
    if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
6198
    if (tDecodeTag(pCoder, (STag **)&pReq->ctb.pTag) < 0) return -1;
6199 6200 6201
    int32_t len = 0;
    if (tDecodeI32(pCoder, &len) < 0) return -1;
    pReq->ctb.tagName = taosArrayInit(len, TSDB_COL_NAME_LEN);
6202 6203 6204
    if (pReq->ctb.tagName == NULL) return -1;
    for (int32_t i = 0; i < len; i++) {
      char  name[TSDB_COL_NAME_LEN] = {0};
wmmhello's avatar
wmmhello 已提交
6205 6206
      char *tmp = NULL;
      if (tDecodeCStr(pCoder, &tmp) < 0) return -1;
G
Ganlin Zhao 已提交
6207
      strncpy(name, tmp, TSDB_COL_NAME_LEN - 1);
6208 6209
      taosArrayPush(pReq->ctb.tagName, name);
    }
H
Hongze Cheng 已提交
6210
  } else if (pReq->type == TSDB_NORMAL_TABLE) {
6211
    if (tDecodeSSchemaWrapperEx(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
6212
  } else {
6213
    ASSERT(0);
H
Hongze Cheng 已提交
6214 6215
  }

H
Hongze Cheng 已提交
6216 6217 6218 6219
  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238
void tDestroySVCreateTbReq(SVCreateTbReq *pReq, int32_t flags) {
  if (pReq == NULL) return;

  if (flags & TSDB_MSG_FLG_ENCODE) {
    // TODO
  } else if (flags & TSDB_MSG_FLG_DECODE) {
    if (pReq->comment) {
      pReq->comment = NULL;
      taosMemoryFree(pReq->comment);
    }

    if (pReq->type == TSDB_CHILD_TABLE) {
      if (pReq->ctb.tagName) taosArrayDestroy(pReq->ctb.tagName);
    } else if (pReq->type == TSDB_NORMAL_TABLE) {
      if (pReq->ntb.schemaRow.pSchema) taosMemoryFree(pReq->ntb.schemaRow.pSchema);
    }
  }
}

H
Hongze Cheng 已提交
6239
int tEncodeSVCreateTbBatchReq(SEncoder *pCoder, const SVCreateTbBatchReq *pReq) {
H
Hongze Cheng 已提交
6240 6241
  int32_t nReq = taosArrayGetSize(pReq->pArray);

H
Hongze Cheng 已提交
6242 6243
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
6244 6245
  if (tEncodeI32v(pCoder, nReq) < 0) return -1;
  for (int iReq = 0; iReq < nReq; iReq++) {
H
Hongze Cheng 已提交
6246 6247 6248 6249 6250 6251 6252
    if (tEncodeSVCreateTbReq(pCoder, (SVCreateTbReq *)taosArrayGet(pReq->pArray, iReq)) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6253
int tDecodeSVCreateTbBatchReq(SDecoder *pCoder, SVCreateTbBatchReq *pReq) {
H
Hongze Cheng 已提交
6254 6255 6256
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
H
Hongze Cheng 已提交
6257
  pReq->pReqs = (SVCreateTbReq *)tDecoderMalloc(pCoder, sizeof(SVCreateTbReq) * pReq->nReqs);
H
Hongze Cheng 已提交
6258 6259 6260 6261 6262
  if (pReq->pReqs == NULL) return -1;
  for (int iReq = 0; iReq < pReq->nReqs; iReq++) {
    if (tDecodeSVCreateTbReq(pCoder, pReq->pReqs + iReq) < 0) return -1;
  }

H
Hongze Cheng 已提交
6263 6264 6265 6266
  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6267
int tEncodeSVCreateTbRsp(SEncoder *pCoder, const SVCreateTbRsp *pRsp) {
H
Hongze Cheng 已提交
6268 6269 6270
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32(pCoder, pRsp->code) < 0) return -1;
6271 6272 6273 6274
  if (tEncodeI32(pCoder, pRsp->pMeta ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta) {
    if (tEncodeSTableMetaRsp(pCoder, pRsp->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
6275 6276 6277 6278 6279

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6280
int tDecodeSVCreateTbRsp(SDecoder *pCoder, SVCreateTbRsp *pRsp) {
H
Hongze Cheng 已提交
6281 6282 6283 6284
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32(pCoder, &pRsp->code) < 0) return -1;

6285 6286 6287 6288 6289 6290 6291 6292 6293
  int32_t meta = 0;
  if (tDecodeI32(pCoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(pCoder, pRsp->pMeta) < 0) return -1;
  } else {
    pRsp->pMeta = NULL;
  }
L
Liu Jicong 已提交
6294

H
Hongze Cheng 已提交
6295 6296 6297 6298
  tEndDecode(pCoder);
  return 0;
}

L
Liu Jicong 已提交
6299
void tFreeSVCreateTbRsp(void *param) {
6300 6301 6302
  if (NULL == param) {
    return;
  }
L
Liu Jicong 已提交
6303 6304

  SVCreateTbRsp *pRsp = (SVCreateTbRsp *)param;
6305 6306 6307 6308
  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
6309 6310
}

H
Hongze Cheng 已提交
6311
// TDMT_VND_DROP_TABLE =================
H
Hongze Cheng 已提交
6312
static int32_t tEncodeSVDropTbReq(SEncoder *pCoder, const SVDropTbReq *pReq) {
H
Hongze Cheng 已提交
6313 6314 6315
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
6316
  if (tEncodeU64(pCoder, pReq->suid) < 0) return -1;
6317
  if (tEncodeI8(pCoder, pReq->igNotExists) < 0) return -1;
H
Hongze Cheng 已提交
6318 6319 6320 6321 6322

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6323
static int32_t tDecodeSVDropTbReq(SDecoder *pCoder, SVDropTbReq *pReq) {
H
Hongze Cheng 已提交
6324 6325 6326
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
6327
  if (tDecodeU64(pCoder, &pReq->suid) < 0) return -1;
6328
  if (tDecodeI8(pCoder, &pReq->igNotExists) < 0) return -1;
H
Hongze Cheng 已提交
6329 6330 6331 6332 6333

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6334
static int32_t tEncodeSVDropTbRsp(SEncoder *pCoder, const SVDropTbRsp *pReq) {
H
Hongze Cheng 已提交
6335 6336 6337 6338 6339 6340 6341 6342
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32(pCoder, pReq->code) < 0) return -1;

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6343
static int32_t tDecodeSVDropTbRsp(SDecoder *pCoder, SVDropTbRsp *pReq) {
H
Hongze Cheng 已提交
6344 6345 6346 6347 6348 6349 6350 6351
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32(pCoder, &pReq->code) < 0) return -1;

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6352
int32_t tEncodeSVDropTbBatchReq(SEncoder *pCoder, const SVDropTbBatchReq *pReq) {
H
Hongze Cheng 已提交
6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367
  int32_t      nReqs = taosArrayGetSize(pReq->pArray);
  SVDropTbReq *pDropTbReq;

  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, nReqs) < 0) return -1;
  for (int iReq = 0; iReq < nReqs; iReq++) {
    pDropTbReq = (SVDropTbReq *)taosArrayGet(pReq->pArray, iReq);
    if (tEncodeSVDropTbReq(pCoder, pDropTbReq) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6368
int32_t tDecodeSVDropTbBatchReq(SDecoder *pCoder, SVDropTbBatchReq *pReq) {
H
Hongze Cheng 已提交
6369 6370 6371
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
H
Hongze Cheng 已提交
6372
  pReq->pReqs = (SVDropTbReq *)tDecoderMalloc(pCoder, sizeof(SVDropTbReq) * pReq->nReqs);
H
Hongze Cheng 已提交
6373 6374 6375 6376 6377 6378 6379 6380 6381
  if (pReq->pReqs == NULL) return -1;
  for (int iReq = 0; iReq < pReq->nReqs; iReq++) {
    if (tDecodeSVDropTbReq(pCoder, pReq->pReqs + iReq) < 0) return -1;
  }

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6382
int32_t tEncodeSVDropTbBatchRsp(SEncoder *pCoder, const SVDropTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394
  int32_t nRsps = taosArrayGetSize(pRsp->pArray);
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, nRsps) < 0) return -1;
  for (int iRsp = 0; iRsp < nRsps; iRsp++) {
    if (tEncodeSVDropTbRsp(pCoder, (SVDropTbRsp *)taosArrayGet(pRsp->pArray, iRsp)) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6395
int32_t tDecodeSVDropTbBatchRsp(SDecoder *pCoder, SVDropTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
6396 6397 6398
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
H
Hongze Cheng 已提交
6399
  pRsp->pRsps = (SVDropTbRsp *)tDecoderMalloc(pCoder, sizeof(SVDropTbRsp) * pRsp->nRsps);
H
Hongze Cheng 已提交
6400 6401 6402 6403 6404 6405 6406 6407 6408
  if (pRsp->pRsps == NULL) return -1;
  for (int iRsp = 0; iRsp < pRsp->nRsps; iRsp++) {
    if (tDecodeSVDropTbRsp(pCoder, pRsp->pRsps + iRsp) < 0) return -1;
  }

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6409
int32_t tEncodeSVDropStbReq(SEncoder *pCoder, const SVDropStbReq *pReq) {
H
Hongze Cheng 已提交
6410 6411 6412 6413 6414 6415 6416 6417 6418
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
  if (tEncodeI64(pCoder, pReq->suid) < 0) return -1;

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6419
int32_t tDecodeSVDropStbReq(SDecoder *pCoder, SVDropStbReq *pReq) {
H
Hongze Cheng 已提交
6420 6421 6422 6423 6424
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
  if (tDecodeI64(pCoder, &pReq->suid) < 0) return -1;

H
Hongze Cheng 已提交
6425 6426
  tEndDecode(pCoder);
  return 0;
6427
}
H
Hongze Cheng 已提交
6428

H
Hongze Cheng 已提交
6429
static int32_t tEncodeSVSubmitBlk(SEncoder *pCoder, const SVSubmitBlk *pBlock, int32_t flags) {
H
Hongze Cheng 已提交
6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI64(pCoder, pBlock->suid) < 0) return -1;
  if (tEncodeI64(pCoder, pBlock->uid) < 0) return -1;
  if (tEncodeI32v(pCoder, pBlock->sver) < 0) return -1;
  if (tEncodeBinary(pCoder, pBlock->pData, pBlock->nData) < 0) return -1;

  if (flags & TD_AUTO_CREATE_TABLE) {
    if (tEncodeSVCreateTbReq(pCoder, &pBlock->cTbReq) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6445
static int32_t tDecodeSVSubmitBlk(SDecoder *pCoder, SVSubmitBlk *pBlock, int32_t flags) {
H
Hongze Cheng 已提交
6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI64(pCoder, &pBlock->suid) < 0) return -1;
  if (tDecodeI64(pCoder, &pBlock->uid) < 0) return -1;
  if (tDecodeI32v(pCoder, &pBlock->sver) < 0) return -1;
  if (tDecodeBinary(pCoder, &pBlock->pData, &pBlock->nData) < 0) return -1;

  if (flags & TD_AUTO_CREATE_TABLE) {
    if (tDecodeSVCreateTbReq(pCoder, &pBlock->cTbReq) < 0) return -1;
  }

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6461
int32_t tEncodeSVSubmitReq(SEncoder *pCoder, const SVSubmitReq *pReq) {
H
Hongze Cheng 已提交
6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475
  int32_t nBlocks = taosArrayGetSize(pReq->pArray);

  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, pReq->flags) < 0) return -1;
  if (tEncodeI32v(pCoder, nBlocks) < 0) return -1;
  for (int32_t iBlock = 0; iBlock < nBlocks; iBlock++) {
    if (tEncodeSVSubmitBlk(pCoder, (SVSubmitBlk *)taosArrayGet(pReq->pArray, iBlock), pReq->flags) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6476
int32_t tDecodeSVSubmitReq(SDecoder *pCoder, SVSubmitReq *pReq) {
H
Hongze Cheng 已提交
6477 6478 6479 6480
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pReq->flags) < 0) return -1;
  if (tDecodeI32v(pCoder, &pReq->nBlocks) < 0) return -1;
H
Hongze Cheng 已提交
6481
  pReq->pBlocks = tDecoderMalloc(pCoder, sizeof(SVSubmitBlk) * pReq->nBlocks);
H
Hongze Cheng 已提交
6482 6483 6484 6485 6486 6487 6488
  if (pReq->pBlocks == NULL) return -1;
  for (int32_t iBlock = 0; iBlock < pReq->nBlocks; iBlock++) {
    if (tDecodeSVSubmitBlk(pCoder, pReq->pBlocks + iBlock, pReq->flags) < 0) return -1;
  }

  tEndDecode(pCoder);
  return 0;
6489
}
H
Hongze Cheng 已提交
6490 6491 6492 6493

static int32_t tEncodeSSubmitBlkRsp(SEncoder *pEncoder, const SSubmitBlkRsp *pBlock) {
  if (tStartEncode(pEncoder) < 0) return -1;

6494
  if (tEncodeI32(pEncoder, pBlock->code) < 0) return -1;
6495
  if (tEncodeI64(pEncoder, pBlock->uid) < 0) return -1;
6496 6497 6498 6499 6500
  if (pBlock->tblFName) {
    if (tEncodeCStr(pEncoder, pBlock->tblFName) < 0) return -1;
  } else {
    if (tEncodeCStr(pEncoder, "") < 0) return -1;
  }
H
Hongze Cheng 已提交
6501 6502
  if (tEncodeI32v(pEncoder, pBlock->numOfRows) < 0) return -1;
  if (tEncodeI32v(pEncoder, pBlock->affectedRows) < 0) return -1;
6503
  if (tEncodeI64v(pEncoder, pBlock->sver) < 0) return -1;
6504 6505 6506 6507
  if (tEncodeI32(pEncoder, pBlock->pMeta ? 1 : 0) < 0) return -1;
  if (pBlock->pMeta) {
    if (tEncodeSTableMetaRsp(pEncoder, pBlock->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
6508 6509 6510 6511 6512 6513 6514 6515

  tEndEncode(pEncoder);
  return 0;
}

static int32_t tDecodeSSubmitBlkRsp(SDecoder *pDecoder, SSubmitBlkRsp *pBlock) {
  if (tStartDecode(pDecoder) < 0) return -1;

6516
  if (tDecodeI32(pDecoder, &pBlock->code) < 0) return -1;
6517 6518 6519 6520
  if (tDecodeI64(pDecoder, &pBlock->uid) < 0) return -1;
  pBlock->tblFName = taosMemoryCalloc(TSDB_TABLE_FNAME_LEN, 1);
  if (NULL == pBlock->tblFName) return -1;
  if (tDecodeCStrTo(pDecoder, pBlock->tblFName) < 0) return -1;
H
Hongze Cheng 已提交
6521 6522
  if (tDecodeI32v(pDecoder, &pBlock->numOfRows) < 0) return -1;
  if (tDecodeI32v(pDecoder, &pBlock->affectedRows) < 0) return -1;
6523
  if (tDecodeI64v(pDecoder, &pBlock->sver) < 0) return -1;
L
Liu Jicong 已提交
6524

6525 6526 6527 6528 6529 6530 6531 6532 6533
  int32_t meta = 0;
  if (tDecodeI32(pDecoder, &meta) < 0) return -1;
  if (meta) {
    pBlock->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pBlock->pMeta) return -1;
    if (tDecodeSTableMetaRsp(pDecoder, pBlock->pMeta) < 0) return -1;
  } else {
    pBlock->pMeta = NULL;
  }
H
Hongze Cheng 已提交
6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560

  tEndDecode(pDecoder);
  return 0;
}

int32_t tEncodeSSubmitRsp(SEncoder *pEncoder, const SSubmitRsp *pRsp) {
  int32_t nBlocks = taosArrayGetSize(pRsp->pArray);

  if (tStartEncode(pEncoder) < 0) return -1;

  if (tEncodeI32v(pEncoder, pRsp->numOfRows) < 0) return -1;
  if (tEncodeI32v(pEncoder, pRsp->affectedRows) < 0) return -1;
  if (tEncodeI32v(pEncoder, nBlocks) < 0) return -1;
  for (int32_t iBlock = 0; iBlock < nBlocks; iBlock++) {
    if (tEncodeSSubmitBlkRsp(pEncoder, (SSubmitBlkRsp *)taosArrayGet(pRsp->pArray, iBlock)) < 0) return -1;
  }

  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSSubmitRsp(SDecoder *pDecoder, SSubmitRsp *pRsp) {
  if (tStartDecode(pDecoder) < 0) return -1;

  if (tDecodeI32v(pDecoder, &pRsp->numOfRows) < 0) return -1;
  if (tDecodeI32v(pDecoder, &pRsp->affectedRows) < 0) return -1;
  if (tDecodeI32v(pDecoder, &pRsp->nBlocks) < 0) return -1;
D
dapan 已提交
6561
  pRsp->pBlocks = taosMemoryCalloc(pRsp->nBlocks, sizeof(*pRsp->pBlocks));
H
Hongze Cheng 已提交
6562 6563 6564 6565 6566
  if (pRsp->pBlocks == NULL) return -1;
  for (int32_t iBlock = 0; iBlock < pRsp->nBlocks; iBlock++) {
    if (tDecodeSSubmitBlkRsp(pDecoder, pRsp->pBlocks + iBlock) < 0) return -1;
  }

6567
  tEndDecode(pDecoder);
D
dapan 已提交
6568
  tDecoderClear(pDecoder);
H
Hongze Cheng 已提交
6569 6570
  return 0;
}
D
dapan 已提交
6571

L
Liu Jicong 已提交
6572
void tFreeSSubmitBlkRsp(void *param) {
6573 6574 6575
  if (NULL == param) {
    return;
  }
L
Liu Jicong 已提交
6576 6577

  SSubmitBlkRsp *pRsp = (SSubmitBlkRsp *)param;
6578 6579 6580 6581 6582 6583 6584 6585

  taosMemoryFree(pRsp->tblFName);
  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
}

D
dapan 已提交
6586 6587 6588 6589 6590 6591 6592
void tFreeSSubmitRsp(SSubmitRsp *pRsp) {
  if (NULL == pRsp) return;

  if (pRsp->pBlocks) {
    for (int32_t i = 0; i < pRsp->nBlocks; ++i) {
      SSubmitBlkRsp *sRsp = pRsp->pBlocks + i;
      taosMemoryFree(sRsp->tblFName);
6593 6594
      tFreeSTableMetaRsp(sRsp->pMeta);
      taosMemoryFree(sRsp->pMeta);
D
dapan 已提交
6595 6596 6597 6598 6599 6600 6601
    }

    taosMemoryFree(pRsp->pBlocks);
  }

  taosMemoryFree(pRsp);
}
H
Hongze Cheng 已提交
6602 6603 6604 6605 6606 6607

int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
  if (tStartEncode(pEncoder) < 0) return -1;

  if (tEncodeCStr(pEncoder, pReq->tbName) < 0) return -1;
  if (tEncodeI8(pEncoder, pReq->action) < 0) return -1;
6608
  if (tEncodeI32(pEncoder, pReq->colId) < 0) return -1;
H
Hongze Cheng 已提交
6609 6610
  switch (pReq->action) {
    case TSDB_ALTER_TABLE_ADD_COLUMN:
H
fix  
Hongze Cheng 已提交
6611
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6612
      if (tEncodeI8(pEncoder, pReq->type) < 0) return -1;
H
Hongze Cheng 已提交
6613
      if (tEncodeI8(pEncoder, pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
6614 6615 6616
      if (tEncodeI32v(pEncoder, pReq->bytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_DROP_COLUMN:
H
fix  
Hongze Cheng 已提交
6617
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6618 6619
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
H
fix  
Hongze Cheng 已提交
6620
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
6621
      if (tEncodeI8(pEncoder, pReq->colModType) < 0) return -1;
H
Hongze Cheng 已提交
6622 6623 6624
      if (tEncodeI32v(pEncoder, pReq->colModBytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
H
fix  
Hongze Cheng 已提交
6625
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6626 6627 6628 6629 6630
      if (tEncodeCStr(pEncoder, pReq->colNewName) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
      if (tEncodeCStr(pEncoder, pReq->tagName) < 0) return -1;
      if (tEncodeI8(pEncoder, pReq->isNull) < 0) return -1;
6631
      if (tEncodeI8(pEncoder, pReq->tagType) < 0) return -1;
H
Hongze Cheng 已提交
6632 6633 6634 6635 6636 6637 6638 6639 6640
      if (!pReq->isNull) {
        if (tEncodeBinary(pEncoder, pReq->pTagVal, pReq->nTagVal) < 0) return -1;
      }
      break;
    case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
      if (tEncodeI8(pEncoder, pReq->updateTTL) < 0) return -1;
      if (pReq->updateTTL) {
        if (tEncodeI32v(pEncoder, pReq->newTTL) < 0) return -1;
      }
wmmhello's avatar
wmmhello 已提交
6641 6642
      if (tEncodeI32v(pEncoder, pReq->newCommentLen) < 0) return -1;
      if (pReq->newCommentLen > 0) {
H
Hongze Cheng 已提交
6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658
        if (tEncodeCStr(pEncoder, pReq->newComment) < 0) return -1;
      }
      break;
    default:
      break;
  }

  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSVAlterTbReq(SDecoder *pDecoder, SVAlterTbReq *pReq) {
  if (tStartDecode(pDecoder) < 0) return -1;

  if (tDecodeCStr(pDecoder, &pReq->tbName) < 0) return -1;
  if (tDecodeI8(pDecoder, &pReq->action) < 0) return -1;
6659
  if (tDecodeI32(pDecoder, &pReq->colId) < 0) return -1;
H
Hongze Cheng 已提交
6660 6661
  switch (pReq->action) {
    case TSDB_ALTER_TABLE_ADD_COLUMN:
H
fix  
Hongze Cheng 已提交
6662
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6663
      if (tDecodeI8(pDecoder, &pReq->type) < 0) return -1;
H
Hongze Cheng 已提交
6664
      if (tDecodeI8(pDecoder, &pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
6665 6666 6667
      if (tDecodeI32v(pDecoder, &pReq->bytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_DROP_COLUMN:
H
fix  
Hongze Cheng 已提交
6668
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6669 6670
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
H
fix  
Hongze Cheng 已提交
6671
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
6672
      if (tDecodeI8(pDecoder, &pReq->colModType) < 0) return -1;
H
Hongze Cheng 已提交
6673 6674 6675
      if (tDecodeI32v(pDecoder, &pReq->colModBytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
H
fix  
Hongze Cheng 已提交
6676
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6677 6678 6679 6680 6681
      if (tDecodeCStr(pDecoder, &pReq->colNewName) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
      if (tDecodeCStr(pDecoder, &pReq->tagName) < 0) return -1;
      if (tDecodeI8(pDecoder, &pReq->isNull) < 0) return -1;
6682
      if (tDecodeI8(pDecoder, &pReq->tagType) < 0) return -1;
H
Hongze Cheng 已提交
6683 6684 6685 6686 6687 6688 6689 6690 6691
      if (!pReq->isNull) {
        if (tDecodeBinary(pDecoder, &pReq->pTagVal, &pReq->nTagVal) < 0) return -1;
      }
      break;
    case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
      if (tDecodeI8(pDecoder, &pReq->updateTTL) < 0) return -1;
      if (pReq->updateTTL) {
        if (tDecodeI32v(pDecoder, &pReq->newTTL) < 0) return -1;
      }
wmmhello's avatar
wmmhello 已提交
6692 6693
      if (tDecodeI32v(pDecoder, &pReq->newCommentLen) < 0) return -1;
      if (pReq->newCommentLen > 0) {
H
Hongze Cheng 已提交
6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707
        if (tDecodeCStr(pDecoder, &pReq->newComment) < 0) return -1;
      }
      break;
    default:
      break;
  }

  tEndDecode(pDecoder);
  return 0;
}

int32_t tEncodeSVAlterTbRsp(SEncoder *pEncoder, const SVAlterTbRsp *pRsp) {
  if (tStartEncode(pEncoder) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->code) < 0) return -1;
D
dapan1121 已提交
6708 6709 6710 6711
  if (tEncodeI32(pEncoder, pRsp->pMeta ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta) {
    if (tEncodeSTableMetaRsp(pEncoder, pRsp->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
6712 6713 6714 6715 6716
  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSVAlterTbRsp(SDecoder *pDecoder, SVAlterTbRsp *pRsp) {
D
dapan1121 已提交
6717
  int32_t meta = 0;
H
Hongze Cheng 已提交
6718 6719
  if (tStartDecode(pDecoder) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->code) < 0) return -1;
D
dapan1121 已提交
6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730
  if (tDecodeI32(pDecoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(pDecoder, pRsp->pMeta) < 0) return -1;
  }
  tEndDecode(pDecoder);
  return 0;
}

int32_t tDeserializeSVAlterTbRsp(void *buf, int32_t bufLen, SVAlterTbRsp *pRsp) {
6731
  int32_t  meta = 0;
D
dapan1121 已提交
6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->code) < 0) return -1;
  if (tDecodeI32(&decoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(&decoder, pRsp->pMeta) < 0) return -1;
  }
  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

int32_t tEncodeSMAlterStbRsp(SEncoder *pEncoder, const SMAlterStbRsp *pRsp) {
  if (tStartEncode(pEncoder) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->pMeta->pSchemas ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta->pSchemas) {
    if (tEncodeSTableMetaRsp(pEncoder, pRsp->pMeta) < 0) return -1;
  }
  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSMAlterStbRsp(SDecoder *pDecoder, SMAlterStbRsp *pRsp) {
  int32_t meta = 0;
  if (tStartDecode(pDecoder) < 0) return -1;
  if (tDecodeI32(pDecoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(pDecoder, pRsp->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
6767 6768 6769
  tEndDecode(pDecoder);
  return 0;
}
D
dapan1121 已提交
6770 6771

int32_t tDeserializeSMAlterStbRsp(void *buf, int32_t bufLen, SMAlterStbRsp *pRsp) {
6772
  int32_t  meta = 0;
D
dapan1121 已提交
6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(&decoder, pRsp->pMeta) < 0) return -1;
  }
  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

6788
void tFreeSMAlterStbRsp(SMAlterStbRsp *pRsp) {
D
dapan1121 已提交
6789 6790 6791 6792 6793 6794 6795 6796 6797
  if (NULL == pRsp) {
    return;
  }

  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
}
6798

6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849
int32_t tEncodeSMCreateStbRsp(SEncoder *pEncoder, const SMCreateStbRsp *pRsp) {
  if (tStartEncode(pEncoder) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->pMeta->pSchemas ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta->pSchemas) {
    if (tEncodeSTableMetaRsp(pEncoder, pRsp->pMeta) < 0) return -1;
  }
  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSMCreateStbRsp(SDecoder *pDecoder, SMCreateStbRsp *pRsp) {
  int32_t meta = 0;
  if (tStartDecode(pDecoder) < 0) return -1;
  if (tDecodeI32(pDecoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(pDecoder, pRsp->pMeta) < 0) return -1;
  }
  tEndDecode(pDecoder);
  return 0;
}

int32_t tDeserializeSMCreateStbRsp(void *buf, int32_t bufLen, SMCreateStbRsp *pRsp) {
  int32_t  meta = 0;
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &meta) < 0) return -1;
  if (meta) {
    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
    if (NULL == pRsp->pMeta) return -1;
    if (tDecodeSTableMetaRsp(&decoder, pRsp->pMeta) < 0) return -1;
  }
  tEndDecode(&decoder);
  tDecoderClear(&decoder);
  return 0;
}

void tFreeSMCreateStbRsp(SMCreateStbRsp *pRsp) {
  if (NULL == pRsp) {
    return;
  }

  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
}

6850 6851
int32_t tEncodeSTqOffsetVal(SEncoder *pEncoder, const STqOffsetVal *pOffsetVal) {
  if (tEncodeI8(pEncoder, pOffsetVal->type) < 0) return -1;
6852
  if (pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_META) {
6853 6854 6855 6856
    if (tEncodeI64(pEncoder, pOffsetVal->uid) < 0) return -1;
    if (tEncodeI64(pEncoder, pOffsetVal->ts) < 0) return -1;
  } else if (pOffsetVal->type == TMQ_OFFSET__LOG) {
    if (tEncodeI64(pEncoder, pOffsetVal->version) < 0) return -1;
6857
  } else {
6858
    // do nothing
6859 6860 6861 6862
  }
  return 0;
}

6863 6864
int32_t tDecodeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffsetVal) {
  if (tDecodeI8(pDecoder, &pOffsetVal->type) < 0) return -1;
L
Liu Jicong 已提交
6865
  if (pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_META) {
6866 6867 6868 6869 6870
    if (tDecodeI64(pDecoder, &pOffsetVal->uid) < 0) return -1;
    if (tDecodeI64(pDecoder, &pOffsetVal->ts) < 0) return -1;
  } else if (pOffsetVal->type == TMQ_OFFSET__LOG) {
    if (tDecodeI64(pDecoder, &pOffsetVal->version) < 0) return -1;
  } else {
6871
    // do nothing
6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883
  }
  return 0;
}

int32_t tFormatOffset(char *buf, int32_t maxLen, const STqOffsetVal *pVal) {
  if (pVal->type == TMQ_OFFSET__RESET_NONE) {
    snprintf(buf, maxLen, "offset(reset to none)");
  } else if (pVal->type == TMQ_OFFSET__RESET_EARLIEAST) {
    snprintf(buf, maxLen, "offset(reset to earlieast)");
  } else if (pVal->type == TMQ_OFFSET__RESET_LATEST) {
    snprintf(buf, maxLen, "offset(reset to latest)");
  } else if (pVal->type == TMQ_OFFSET__LOG) {
S
Shengliang Guan 已提交
6884
    snprintf(buf, maxLen, "offset(log) ver:%" PRId64, pVal->version);
L
Liu Jicong 已提交
6885
  } else if (pVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pVal->type == TMQ_OFFSET__SNAPSHOT_META) {
H
Haojun Liao 已提交
6886
    snprintf(buf, maxLen, "offset(snapshot) uid:%" PRId64 " ts:%" PRId64, pVal->uid, pVal->ts);
6887
  } else {
D
dapan1121 已提交
6888
    return TSDB_CODE_INVALID_PARA;
6889
  }
D
dapan1121 已提交
6890

6891 6892 6893 6894 6895 6896 6897 6898 6899 6900
  return 0;
}

bool tOffsetEqual(const STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
  if (pLeft->type == pRight->type) {
    if (pLeft->type == TMQ_OFFSET__LOG) {
      return pLeft->version == pRight->version;
    } else if (pLeft->type == TMQ_OFFSET__SNAPSHOT_DATA) {
      return pLeft->uid == pRight->uid && pLeft->ts == pRight->ts;
    } else if (pLeft->type == TMQ_OFFSET__SNAPSHOT_META) {
6901
      return pLeft->uid == pRight->uid;
6902
    } else {
6903 6904
      ASSERT(0);
      /*ASSERT(pLeft->type == TMQ_OFFSET__RESET_NONE || pLeft->type == TMQ_OFFSET__RESET_EARLIEAST ||*/
6905 6906
      /*pLeft->type == TMQ_OFFSET__RESET_LATEST);*/
      /*return true;*/
6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919
    }
  }
  return false;
}

int32_t tEncodeSTqOffset(SEncoder *pEncoder, const STqOffset *pOffset) {
  if (tEncodeSTqOffsetVal(pEncoder, &pOffset->val) < 0) return -1;
  if (tEncodeCStr(pEncoder, pOffset->subKey) < 0) return -1;
  return 0;
}

int32_t tDecodeSTqOffset(SDecoder *pDecoder, STqOffset *pOffset) {
  if (tDecodeSTqOffsetVal(pDecoder, &pOffset->val) < 0) return -1;
6920 6921 6922
  if (tDecodeCStrTo(pDecoder, pOffset->subKey) < 0) return -1;
  return 0;
}
6923

6924
int32_t tEncodeSTqCheckInfo(SEncoder *pEncoder, const STqCheckInfo *pInfo) {
6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935
  if (tEncodeCStr(pEncoder, pInfo->topic) < 0) return -1;
  if (tEncodeI64(pEncoder, pInfo->ntbUid) < 0) return -1;
  int32_t sz = taosArrayGetSize(pInfo->colIdList);
  if (tEncodeI32(pEncoder, sz) < 0) return -1;
  for (int32_t i = 0; i < sz; i++) {
    int16_t colId = *(int16_t *)taosArrayGet(pInfo->colIdList, i);
    if (tEncodeI16(pEncoder, colId) < 0) return -1;
  }
  return pEncoder->pos;
}

6936
int32_t tDecodeSTqCheckInfo(SDecoder *pDecoder, STqCheckInfo *pInfo) {
6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949
  if (tDecodeCStrTo(pDecoder, pInfo->topic) < 0) return -1;
  if (tDecodeI64(pDecoder, &pInfo->ntbUid) < 0) return -1;
  int32_t sz;
  if (tDecodeI32(pDecoder, &sz) < 0) return -1;
  pInfo->colIdList = taosArrayInit(sz, sizeof(int16_t));
  if (pInfo->colIdList == NULL) return -1;
  for (int32_t i = 0; i < sz; i++) {
    int16_t colId;
    if (tDecodeI16(pDecoder, &colId) < 0) return -1;
    taosArrayPush(pInfo->colIdList, &colId);
  }
  return 0;
}
L
Liu Jicong 已提交
6950
void tDeleteSTqCheckInfo(STqCheckInfo *pInfo) { taosArrayDestroy(pInfo->colIdList); }
6951

H
Hongze Cheng 已提交
6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963
int32_t tEncodeDeleteRes(SEncoder *pCoder, const SDeleteRes *pRes) {
  int32_t nUid = taosArrayGetSize(pRes->uidList);

  if (tEncodeU64(pCoder, pRes->suid) < 0) return -1;
  if (tEncodeI32v(pCoder, nUid) < 0) return -1;
  for (int32_t iUid = 0; iUid < nUid; iUid++) {
    if (tEncodeU64(pCoder, *(uint64_t *)taosArrayGet(pRes->uidList, iUid)) < 0) return -1;
  }
  if (tEncodeI64(pCoder, pRes->skey) < 0) return -1;
  if (tEncodeI64(pCoder, pRes->ekey) < 0) return -1;
  if (tEncodeI64v(pCoder, pRes->affectedRows) < 0) return -1;

6964
  if (tEncodeCStr(pCoder, pRes->tableFName) < 0) return -1;
6965
  if (tEncodeCStr(pCoder, pRes->tsColName) < 0) return -1;
H
Hongze Cheng 已提交
6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976
  return 0;
}

int32_t tDecodeDeleteRes(SDecoder *pCoder, SDeleteRes *pRes) {
  int32_t  nUid;
  uint64_t uid;

  if (tDecodeU64(pCoder, &pRes->suid) < 0) return -1;
  if (tDecodeI32v(pCoder, &nUid) < 0) return -1;
  for (int32_t iUid = 0; iUid < nUid; iUid++) {
    if (tDecodeU64(pCoder, &uid) < 0) return -1;
6977
    if (pRes->uidList) taosArrayPush(pRes->uidList, &uid);
H
Hongze Cheng 已提交
6978 6979 6980 6981 6982
  }
  if (tDecodeI64(pCoder, &pRes->skey) < 0) return -1;
  if (tDecodeI64(pCoder, &pRes->ekey) < 0) return -1;
  if (tDecodeI64v(pCoder, &pRes->affectedRows) < 0) return -1;

6983
  if (tDecodeCStrTo(pCoder, pRes->tableFName) < 0) return -1;
6984
  if (tDecodeCStrTo(pCoder, pRes->tsColName) < 0) return -1;
H
Hongze Cheng 已提交
6985
  return 0;
6986
}
6987

L
Liu Jicong 已提交
6988
int32_t tEncodeSMqMetaRsp(SEncoder *pEncoder, const SMqMetaRsp *pRsp) {
6989
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->rspOffset) < 0) return -1;
L
Liu Jicong 已提交
6990 6991
  if (tEncodeI16(pEncoder, pRsp->resMsgType)) return -1;
  if (tEncodeBinary(pEncoder, pRsp->metaRsp, pRsp->metaRspLen)) return -1;
6992 6993 6994
  return 0;
}

L
Liu Jicong 已提交
6995
int32_t tDecodeSMqMetaRsp(SDecoder *pDecoder, SMqMetaRsp *pRsp) {
6996 6997
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->rspOffset) < 0) return -1;
  if (tDecodeI16(pDecoder, &pRsp->resMsgType) < 0) return -1;
L
Liu Jicong 已提交
6998
  if (tDecodeBinaryAlloc(pDecoder, &pRsp->metaRsp, (uint64_t *)&pRsp->metaRspLen) < 0) return -1;
6999 7000 7001
  return 0;
}

7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053
int32_t tEncodeSMqDataRsp(SEncoder *pEncoder, const SMqDataRsp *pRsp) {
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->reqOffset) < 0) return -1;
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->rspOffset) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->blockNum) < 0) return -1;
  if (pRsp->blockNum != 0) {
    if (tEncodeI8(pEncoder, pRsp->withTbName) < 0) return -1;
    if (tEncodeI8(pEncoder, pRsp->withSchema) < 0) return -1;

    for (int32_t i = 0; i < pRsp->blockNum; i++) {
      int32_t bLen = *(int32_t *)taosArrayGet(pRsp->blockDataLen, i);
      void   *data = taosArrayGetP(pRsp->blockData, i);
      if (tEncodeBinary(pEncoder, (const uint8_t *)data, bLen) < 0) return -1;
      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosArrayGetP(pRsp->blockSchema, i);
        if (tEncodeSSchemaWrapper(pEncoder, pSW) < 0) return -1;
      }
      if (pRsp->withTbName) {
        char *tbName = (char *)taosArrayGetP(pRsp->blockTbName, i);
        if (tEncodeCStr(pEncoder, tbName) < 0) return -1;
      }
    }
  }
  return 0;
}

int32_t tDecodeSMqDataRsp(SDecoder *pDecoder, SMqDataRsp *pRsp) {
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->reqOffset) < 0) return -1;
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->rspOffset) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->blockNum) < 0) return -1;
  if (pRsp->blockNum != 0) {
    pRsp->blockData = taosArrayInit(pRsp->blockNum, sizeof(void *));
    pRsp->blockDataLen = taosArrayInit(pRsp->blockNum, sizeof(int32_t));
    if (tDecodeI8(pDecoder, &pRsp->withTbName) < 0) return -1;
    if (tDecodeI8(pDecoder, &pRsp->withSchema) < 0) return -1;
    if (pRsp->withTbName) {
      pRsp->blockTbName = taosArrayInit(pRsp->blockNum, sizeof(void *));
    }
    if (pRsp->withSchema) {
      pRsp->blockSchema = taosArrayInit(pRsp->blockNum, sizeof(void *));
    }

    for (int32_t i = 0; i < pRsp->blockNum; i++) {
      void    *data;
      uint64_t bLen;
      if (tDecodeBinaryAlloc(pDecoder, &data, &bLen) < 0) return -1;
      taosArrayPush(pRsp->blockData, &data);
      int32_t len = bLen;
      taosArrayPush(pRsp->blockDataLen, &len);

      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
        if (pSW == NULL) return -1;
L
Liu Jicong 已提交
7054 7055 7056 7057 7058
        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
          taosMemoryFree(pSW);
          return -1;
        }

7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070
        taosArrayPush(pRsp->blockSchema, &pSW);
      }

      if (pRsp->withTbName) {
        char *tbName;
        if (tDecodeCStrAlloc(pDecoder, &tbName) < 0) return -1;
        taosArrayPush(pRsp->blockTbName, &tbName);
      }
    }
  }
  return 0;
}
7071

L
Liu Jicong 已提交
7072
void tDeleteSMqDataRsp(SMqDataRsp *pRsp) {
7073
  pRsp->blockDataLen = taosArrayDestroy(pRsp->blockDataLen);
L
Liu Jicong 已提交
7074
  taosArrayDestroyP(pRsp->blockData, (FDelete)taosMemoryFree);
L
Liu Jicong 已提交
7075
  pRsp->blockData = NULL;
7076
  taosArrayDestroyP(pRsp->blockSchema, (FDelete)tDeleteSchemaWrapper);
L
Liu Jicong 已提交
7077
  pRsp->blockSchema = NULL;
L
Liu Jicong 已提交
7078
  taosArrayDestroyP(pRsp->blockTbName, (FDelete)taosMemoryFree);
L
Liu Jicong 已提交
7079
  pRsp->blockTbName = NULL;
L
Liu Jicong 已提交
7080 7081
}

L
Liu Jicong 已提交
7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141
int32_t tEncodeSTaosxRsp(SEncoder *pEncoder, const STaosxRsp *pRsp) {
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->reqOffset) < 0) return -1;
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->rspOffset) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->blockNum) < 0) return -1;
  if (pRsp->blockNum != 0) {
    if (tEncodeI8(pEncoder, pRsp->withTbName) < 0) return -1;
    if (tEncodeI8(pEncoder, pRsp->withSchema) < 0) return -1;

    for (int32_t i = 0; i < pRsp->blockNum; i++) {
      int32_t bLen = *(int32_t *)taosArrayGet(pRsp->blockDataLen, i);
      void   *data = taosArrayGetP(pRsp->blockData, i);
      if (tEncodeBinary(pEncoder, (const uint8_t *)data, bLen) < 0) return -1;
      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosArrayGetP(pRsp->blockSchema, i);
        if (tEncodeSSchemaWrapper(pEncoder, pSW) < 0) return -1;
      }
      if (pRsp->withTbName) {
        char *tbName = (char *)taosArrayGetP(pRsp->blockTbName, i);
        if (tEncodeCStr(pEncoder, tbName) < 0) return -1;
      }
    }
  }
  if (tEncodeI32(pEncoder, pRsp->createTableNum) < 0) return -1;
  if (pRsp->createTableNum) {
    for (int32_t i = 0; i < pRsp->createTableNum; i++) {
      void   *createTableReq = taosArrayGetP(pRsp->createTableReq, i);
      int32_t createTableLen = *(int32_t *)taosArrayGet(pRsp->createTableLen, i);
      if (tEncodeBinary(pEncoder, createTableReq, createTableLen) < 0) return -1;
    }
  }
  return 0;
}

int32_t tDecodeSTaosxRsp(SDecoder *pDecoder, STaosxRsp *pRsp) {
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->reqOffset) < 0) return -1;
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->rspOffset) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->blockNum) < 0) return -1;
  if (pRsp->blockNum != 0) {
    pRsp->blockData = taosArrayInit(pRsp->blockNum, sizeof(void *));
    pRsp->blockDataLen = taosArrayInit(pRsp->blockNum, sizeof(int32_t));
    if (tDecodeI8(pDecoder, &pRsp->withTbName) < 0) return -1;
    if (tDecodeI8(pDecoder, &pRsp->withSchema) < 0) return -1;
    if (pRsp->withTbName) {
      pRsp->blockTbName = taosArrayInit(pRsp->blockNum, sizeof(void *));
    }
    if (pRsp->withSchema) {
      pRsp->blockSchema = taosArrayInit(pRsp->blockNum, sizeof(void *));
    }

    for (int32_t i = 0; i < pRsp->blockNum; i++) {
      void    *data;
      uint64_t bLen;
      if (tDecodeBinaryAlloc(pDecoder, &data, &bLen) < 0) return -1;
      taosArrayPush(pRsp->blockData, &data);
      int32_t len = bLen;
      taosArrayPush(pRsp->blockDataLen, &len);

      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
        if (pSW == NULL) return -1;
L
Liu Jicong 已提交
7142 7143 7144 7145
        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
          taosMemoryFree(pSW);
          return -1;
        }
L
Liu Jicong 已提交
7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170
        taosArrayPush(pRsp->blockSchema, &pSW);
      }

      if (pRsp->withTbName) {
        char *tbName;
        if (tDecodeCStrAlloc(pDecoder, &tbName) < 0) return -1;
        taosArrayPush(pRsp->blockTbName, &tbName);
      }
    }
  }
  if (tDecodeI32(pDecoder, &pRsp->createTableNum) < 0) return -1;
  if (pRsp->createTableNum) {
    pRsp->createTableLen = taosArrayInit(pRsp->createTableNum, sizeof(int32_t));
    pRsp->createTableReq = taosArrayInit(pRsp->createTableNum, sizeof(void *));
    for (int32_t i = 0; i < pRsp->createTableNum; i++) {
      void    *pCreate = NULL;
      uint64_t len;
      if (tDecodeBinaryAlloc(pDecoder, &pCreate, &len) < 0) return -1;
      int32_t l = (int32_t)len;
      taosArrayPush(pRsp->createTableLen, &l);
      taosArrayPush(pRsp->createTableReq, &pCreate);
    }
  }
  return 0;
}
7171 7172 7173

void tDeleteSTaosxRsp(STaosxRsp *pRsp) {
  taosArrayDestroy(pRsp->blockDataLen);
7174
  pRsp->blockDataLen = NULL;
7175
  taosArrayDestroyP(pRsp->blockData, (FDelete)taosMemoryFree);
7176
  pRsp->blockData = NULL;
7177
  taosArrayDestroyP(pRsp->blockSchema, (FDelete)tDeleteSchemaWrapper);
7178
  pRsp->blockSchema = NULL;
7179
  taosArrayDestroyP(pRsp->blockTbName, (FDelete)taosMemoryFree);
7180
  pRsp->blockTbName = NULL;
7181 7182

  taosArrayDestroy(pRsp->createTableLen);
7183
  pRsp->createTableLen = NULL;
7184
  taosArrayDestroyP(pRsp->createTableReq, (FDelete)taosMemoryFree);
7185
  pRsp->createTableReq = NULL;
7186 7187
}

7188
int32_t tEncodeSSingleDeleteReq(SEncoder *pEncoder, const SSingleDeleteReq *pReq) {
7189
  if (tEncodeCStr(pEncoder, pReq->tbname) < 0) return -1;
7190 7191
  if (tEncodeI64(pEncoder, pReq->startTs) < 0) return -1;
  if (tEncodeI64(pEncoder, pReq->endTs) < 0) return -1;
7192 7193 7194 7195
  return 0;
}

int32_t tDecodeSSingleDeleteReq(SDecoder *pDecoder, SSingleDeleteReq *pReq) {
7196
  if (tDecodeCStrTo(pDecoder, pReq->tbname) < 0) return -1;
7197 7198
  if (tDecodeI64(pDecoder, &pReq->startTs) < 0) return -1;
  if (tDecodeI64(pDecoder, &pReq->endTs) < 0) return -1;
7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225
  return 0;
}

int32_t tEncodeSBatchDeleteReq(SEncoder *pEncoder, const SBatchDeleteReq *pReq) {
  if (tEncodeI64(pEncoder, pReq->suid) < 0) return -1;
  int32_t sz = taosArrayGetSize(pReq->deleteReqs);
  if (tEncodeI32(pEncoder, sz) < 0) return -1;
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq *pOneReq = taosArrayGet(pReq->deleteReqs, i);
    if (tEncodeSSingleDeleteReq(pEncoder, pOneReq) < 0) return -1;
  }
  return 0;
}

int32_t tDecodeSBatchDeleteReq(SDecoder *pDecoder, SBatchDeleteReq *pReq) {
  if (tDecodeI64(pDecoder, &pReq->suid) < 0) return -1;
  int32_t sz;
  if (tDecodeI32(pDecoder, &sz) < 0) return -1;
  pReq->deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq));
  if (pReq->deleteReqs == NULL) return -1;
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq deleteReq;
    if (tDecodeSSingleDeleteReq(pDecoder, &deleteReq) < 0) return -1;
    taosArrayPush(pReq->deleteReqs, &deleteReq);
  }
  return 0;
}
H
Hongze Cheng 已提交
7226

H
Hongze Cheng 已提交
7227
static int32_t tEncodeSSubmitTbData(SEncoder *pCoder, const SSubmitTbData *pSubmitTbData) {
H
Hongze Cheng 已提交
7228 7229
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
7230 7231 7232 7233 7234 7235 7236 7237 7238
  if (tEncodeI32v(pCoder, pSubmitTbData->flags) < 0) return -1;

  // auto create table
  if (pSubmitTbData->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
    ASSERT(pSubmitTbData->pCreateTbReq);
    if (tEncodeSVCreateTbReq(pCoder, pSubmitTbData->pCreateTbReq) < 0) return -1;
  }

  // submit data
H
Hongze Cheng 已提交
7239 7240 7241 7242
  if (tEncodeI64(pCoder, pSubmitTbData->suid) < 0) return -1;
  if (tEncodeI64(pCoder, pSubmitTbData->uid) < 0) return -1;
  if (tEncodeI32v(pCoder, pSubmitTbData->sver) < 0) return -1;

H
Hongze Cheng 已提交
7243
  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
H
Hongze Cheng 已提交
7244 7245 7246 7247 7248 7249 7250 7251
    uint64_t  nColData = TARRAY_SIZE(pSubmitTbData->aCol);
    SColData *aColData = (SColData *)TARRAY_DATA(pSubmitTbData->aCol);

    if (tEncodeU64v(pCoder, nColData) < 0) return -1;

    for (uint64_t i = 0; i < nColData; i++) {
      pCoder->pos += tPutColData(pCoder->data ? pCoder->data + pCoder->pos : NULL, &aColData[i]);
    }
H
Hongze Cheng 已提交
7252
  } else {
H
Hongze Cheng 已提交
7253 7254 7255 7256 7257 7258
    if (tEncodeU64v(pCoder, TARRAY_SIZE(pSubmitTbData->aRowP)) < 0) return -1;

    SRow **rows = (SRow **)TARRAY_DATA(pSubmitTbData->aRowP);
    for (int32_t iRow = 0; iRow < TARRAY_SIZE(pSubmitTbData->aRowP); ++iRow) {
      if (pCoder->data) memcpy(pCoder->data + pCoder->pos, rows[iRow], rows[iRow]->len);
      pCoder->pos += rows[iRow]->len;
H
Hongze Cheng 已提交
7259 7260 7261 7262 7263 7264 7265
    }
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
7266
static int32_t tDecodeSSubmitTbData(SDecoder *pCoder, SSubmitTbData *pSubmitTbData) {
H
Hongze Cheng 已提交
7267 7268 7269 7270 7271 7272 7273
  int32_t code = 0;

  if (tStartDecode(pCoder) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289
  if (tDecodeI32v(pCoder, &pSubmitTbData->flags) < 0) return -1;

  if (pSubmitTbData->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
    pSubmitTbData->pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));
    if (pSubmitTbData->pCreateTbReq == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }

    if (tDecodeSVCreateTbReq(pCoder, pSubmitTbData->pCreateTbReq) < 0) {
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }
  }

  // submit data
H
Hongze Cheng 已提交
7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302
  if (tDecodeI64(pCoder, &pSubmitTbData->suid) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }
  if (tDecodeI64(pCoder, &pSubmitTbData->uid) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }
  if (tDecodeI32v(pCoder, &pSubmitTbData->sver) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
7303
  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
H
Hongze Cheng 已提交
7304 7305 7306 7307 7308 7309 7310
    uint64_t nColData;

    if (tDecodeU64v(pCoder, &nColData) < 0) {
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }

H
Hongze Cheng 已提交
7311
    pSubmitTbData->aCol = taosArrayInit(nColData, sizeof(SColData));
H
Hongze Cheng 已提交
7312 7313 7314 7315 7316 7317 7318 7319
    if (pSubmitTbData->aCol == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }

    for (int32_t i = 0; i < nColData; ++i) {
      pCoder->pos += tGetColData(pCoder->data + pCoder->pos, taosArrayReserve(pSubmitTbData->aCol, 1));
    }
H
Hongze Cheng 已提交
7320
  } else {
H
Hongze Cheng 已提交
7321 7322
    uint64_t nRow;
    if (tDecodeU64v(pCoder, &nRow) < 0) {
H
Hongze Cheng 已提交
7323 7324 7325 7326
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }

H
Hongze Cheng 已提交
7327
    pSubmitTbData->aRowP = taosArrayInit(nRow, sizeof(SRow *));
H
Hongze Cheng 已提交
7328 7329 7330 7331 7332
    if (pSubmitTbData->aRowP == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }

H
Hongze Cheng 已提交
7333
    for (int32_t iRow = 0; iRow < nRow; ++iRow) {
H
Hongze Cheng 已提交
7334
      SRow **ppRow = taosArrayReserve(pSubmitTbData->aRowP, 1);
H
Hongze Cheng 已提交
7335

H
Hongze Cheng 已提交
7336 7337
      *ppRow = (SRow *)(pCoder->data + pCoder->pos);
      pCoder->pos += (*ppRow)->len;
H
Hongze Cheng 已提交
7338 7339 7340 7341 7342 7343 7344
    }
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
H
Hongze Cheng 已提交
7345
    // TODO: clear
H
Hongze Cheng 已提交
7346 7347 7348 7349
  }
  return 0;
}

7350
int32_t tEncodeSubmitReq(SEncoder *pCoder, const SSubmitReq2 *pReq) {
H
Hongze Cheng 已提交
7351 7352
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
7353 7354 7355
  if (tEncodeU64v(pCoder, taosArrayGetSize(pReq->aSubmitTbData)) < 0) return -1;
  for (uint64_t i = 0; i < taosArrayGetSize(pReq->aSubmitTbData); i++) {
    if (tEncodeSSubmitTbData(pCoder, taosArrayGet(pReq->aSubmitTbData, i)) < 0) return -1;
H
Hongze Cheng 已提交
7356 7357 7358 7359 7360 7361
  }

  tEndEncode(pCoder);
  return 0;
}

7362
int32_t tDecodeSubmitReq(SDecoder *pCoder, SSubmitReq2 *pReq) {
H
Hongze Cheng 已提交
7363 7364
  int32_t code = 0;

H
Hongze Cheng 已提交
7365
  memset(pReq, 0, sizeof(*pReq));
H
Hongze Cheng 已提交
7366 7367 7368 7369 7370 7371 7372

  // decode
  if (tStartDecode(pCoder) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
7373 7374
  uint64_t nSubmitTbData;
  if (tDecodeU64v(pCoder, &nSubmitTbData) < 0) {
H
Hongze Cheng 已提交
7375 7376 7377 7378 7379 7380 7381 7382 7383 7384
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

  pReq->aSubmitTbData = taosArrayInit(nSubmitTbData, sizeof(SSubmitTbData));
  if (pReq->aSubmitTbData == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

H
Hongze Cheng 已提交
7385 7386
  for (uint64_t i = 0; i < nSubmitTbData; i++) {
    if (tDecodeSSubmitTbData(pCoder, taosArrayReserve(pReq->aSubmitTbData, 1)) < 0) {
H
Hongze Cheng 已提交
7387 7388 7389 7390 7391 7392 7393 7394 7395
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
H
Hongze Cheng 已提交
7396 7397 7398 7399
    if (pReq->aSubmitTbData) {
      // todo
      taosArrayDestroy(pReq->aSubmitTbData);
      pReq->aSubmitTbData = NULL;
H
Hongze Cheng 已提交
7400 7401
    }
  }
H
Hongze Cheng 已提交
7402
  return code;
H
Hongze Cheng 已提交
7403 7404
}

7405
void tDestroySubmitTbData(SSubmitTbData *pTbData, int32_t flag) {
7406 7407 7408
  if (NULL == pTbData) {
    return;
  }
H
Hongze Cheng 已提交
7409

7410
  if (flag == TSDB_MSG_FLG_ENCODE || flag == TSDB_MSG_FLG_CMPT) {
7411
    if (pTbData->pCreateTbReq) {
7412 7413 7414 7415 7416
      if (flag == TSDB_MSG_FLG_ENCODE) {
        tdDestroySVCreateTbReq(pTbData->pCreateTbReq);
      } else {
        tDestroySVCreateTbReq(pTbData->pCreateTbReq, TSDB_MSG_FLG_DECODE);
      }
7417 7418 7419
      taosMemoryFree(pTbData->pCreateTbReq);
    }

H
Hongze Cheng 已提交
7420 7421 7422 7423 7424 7425 7426 7427
    if (pTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
      int32_t   nColData = TARRAY_SIZE(pTbData->aCol);
      SColData *aColData = (SColData *)TARRAY_DATA(pTbData->aCol);

      for (int32_t i = 0; i < nColData; ++i) {
        tColDataDestroy(&aColData[i]);
      }
      taosArrayDestroy(pTbData->aCol);
H
Hongze Cheng 已提交
7428 7429 7430 7431 7432 7433 7434 7435
    } else {
      int32_t nRow = TARRAY_SIZE(pTbData->aRowP);
      SRow  **rows = (SRow **)TARRAY_DATA(pTbData->aRowP);

      for (int32_t i = 0; i < nRow; ++i) {
        tRowDestroy(rows[i]);
      }
      taosArrayDestroy(pTbData->aRowP);
H
Hongze Cheng 已提交
7436 7437
    }
  } else if (flag == TSDB_MSG_FLG_DECODE) {
7438
    if (pTbData->pCreateTbReq) {
H
Hongze Cheng 已提交
7439
      tDestroySVCreateTbReq(pTbData->pCreateTbReq, TSDB_MSG_FLG_DECODE);
7440 7441 7442
      taosMemoryFree(pTbData->pCreateTbReq);
    }

H
Hongze Cheng 已提交
7443 7444 7445 7446
    if (pTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
      taosArrayDestroy(pTbData->aCol);
    } else {
      taosArrayDestroy(pTbData->aRowP);
H
Hongze Cheng 已提交
7447
    }
X
Xiaoyu Wang 已提交
7448
  }
X
Xiaoyu Wang 已提交
7449 7450
}

7451
void tDestroySubmitReq(SSubmitReq2 *pReq, int32_t flag) {
H
Hongze Cheng 已提交
7452 7453
  if (pReq->aSubmitTbData == NULL) return;

H
Hongze Cheng 已提交
7454 7455
  int32_t        nSubmitTbData = TARRAY_SIZE(pReq->aSubmitTbData);
  SSubmitTbData *aSubmitTbData = (SSubmitTbData *)TARRAY_DATA(pReq->aSubmitTbData);
H
Hongze Cheng 已提交
7456

H
Hongze Cheng 已提交
7457
  for (int32_t i = 0; i < nSubmitTbData; i++) {
7458
    tDestroySubmitTbData(&aSubmitTbData[i], flag);
H
Hongze Cheng 已提交
7459 7460
  }
  taosArrayDestroy(pReq->aSubmitTbData);
wmmhello's avatar
wmmhello 已提交
7461
  pReq->aSubmitTbData = NULL;
H
Hongze Cheng 已提交
7462
}
H
Hongze Cheng 已提交
7463 7464 7465 7466 7467

int32_t tEncodeSSubmitRsp2(SEncoder *pCoder, const SSubmitRsp2 *pRsp) {
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, pRsp->affectedRows) < 0) return -1;
H
Hongze Cheng 已提交
7468 7469

  if (tEncodeU64v(pCoder, taosArrayGetSize(pRsp->aCreateTbRsp)) < 0) return -1;
H
Hongze Cheng 已提交
7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493
  for (int32_t i = 0; i < taosArrayGetSize(pRsp->aCreateTbRsp); ++i) {
    if (tEncodeSVCreateTbRsp(pCoder, taosArrayGet(pRsp->aCreateTbRsp, i)) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

int32_t tDecodeSSubmitRsp2(SDecoder *pCoder, SSubmitRsp2 *pRsp) {
  int32_t code = 0;

  memset(pRsp, 0, sizeof(SSubmitRsp2));

  // decode
  if (tStartDecode(pCoder) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

  if (tDecodeI32v(pCoder, &pRsp->affectedRows) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
7494 7495
  uint64_t nCreateTbRsp;
  if (tDecodeU64v(pCoder, &nCreateTbRsp) < 0) {
H
Hongze Cheng 已提交
7496 7497 7498 7499
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
7500 7501 7502 7503
  if (nCreateTbRsp) {
    pRsp->aCreateTbRsp = taosArrayInit(nCreateTbRsp, sizeof(SVCreateTbRsp));
    if (pRsp->aCreateTbRsp == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
H
Hongze Cheng 已提交
7504 7505
      goto _exit;
    }
H
Hongze Cheng 已提交
7506 7507 7508 7509 7510 7511 7512 7513

    for (int32_t i = 0; i < nCreateTbRsp; ++i) {
      SVCreateTbRsp *pCreateTbRsp = taosArrayReserve(pRsp->aCreateTbRsp, 1);
      if (tDecodeSVCreateTbRsp(pCoder, pCreateTbRsp) < 0) {
        code = TSDB_CODE_INVALID_MSG;
        goto _exit;
      }
    }
H
Hongze Cheng 已提交
7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
    if (pRsp->aCreateTbRsp) {
      taosArrayDestroyEx(pRsp->aCreateTbRsp, NULL /* todo */);
    }
  }
  return code;
}

void tDestroySSubmitRsp2(SSubmitRsp2 *pRsp, int32_t flag) {
7528 7529 7530
  if (NULL == pRsp) {
    return;
  }
H
Hongze Cheng 已提交
7531

7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543
  if (flag & TSDB_MSG_FLG_ENCODE) {
    if (pRsp->aCreateTbRsp) {
      int32_t        nCreateTbRsp = TARRAY_SIZE(pRsp->aCreateTbRsp);
      SVCreateTbRsp *aCreateTbRsp = TARRAY_DATA(pRsp->aCreateTbRsp);
      for (int32_t i = 0; i < nCreateTbRsp; ++i) {
        if (aCreateTbRsp[i].pMeta) {
          taosMemoryFree(aCreateTbRsp[i].pMeta);
        }
      }
      taosArrayDestroy(pRsp->aCreateTbRsp);
    }
  } else if (flag & TSDB_MSG_FLG_DECODE) {
H
Hongze Cheng 已提交
7544 7545 7546 7547 7548 7549 7550 7551 7552 7553
    if (pRsp->aCreateTbRsp) {
      int32_t        nCreateTbRsp = TARRAY_SIZE(pRsp->aCreateTbRsp);
      SVCreateTbRsp *aCreateTbRsp = TARRAY_DATA(pRsp->aCreateTbRsp);
      for (int32_t i = 0; i < nCreateTbRsp; ++i) {
        if (aCreateTbRsp[i].pMeta) {
          taosMemoryFree(aCreateTbRsp[i].pMeta);
        }
      }
      taosArrayDestroy(pRsp->aCreateTbRsp);
    }
H
Hongze Cheng 已提交
7554 7555
  }
}
新手
引导
客服 返回
顶部