tmsg.c 230.0 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

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

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

  return 0;
}

C
Cary Xu 已提交
50
int32_t tGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
C
Cary Xu 已提交
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
  ASSERT(pIter->len >= 0);

  if (pIter->len == 0) {
    pIter->len += sizeof(SSubmitReq);
  } else {
    if (pIter->len >= pIter->totalLen) {
      ASSERT(0);
    }

    pIter->len += (sizeof(SSubmitBlk) + pIter->dataLen + pIter->schemaLen);
    ASSERT(pIter->len > 0);
  }

  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);
79
    pIter->numOfRows = htonl((*pPBlock)->numOfRows);
C
Cary Xu 已提交
80 81 82 83
  }
  return 0;
}

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

C
Cary Xu 已提交
92
STSRow *tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
C
Cary Xu 已提交
93 94 95 96 97 98 99 100 101 102 103 104
  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 已提交
105

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

H
Hongze Cheng 已提交
125
int32_t tEncodeSEpSet(SEncoder *pEncoder, const SEpSet *pEp) {
S
Shengliang Guan 已提交
126 127 128 129
  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;
130
    if (tEncodeCStrWithLen(pEncoder, pEp->eps[i].fqdn, TSDB_FQDN_LEN) < 0) return -1;
S
Shengliang Guan 已提交
131 132 133 134
  }
  return 0;
}

H
Hongze Cheng 已提交
135
int32_t tDecodeSEpSet(SDecoder *pDecoder, SEpSet *pEp) {
S
Shengliang Guan 已提交
136 137 138 139 140 141 142 143 144
  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 已提交
145
int32_t tEncodeSQueryNodeAddr(SEncoder *pEncoder, SQueryNodeAddr *pAddr) {
D
dapan1121 已提交
146 147 148 149 150
  if (tEncodeI32(pEncoder, pAddr->nodeId) < 0) return -1;
  if (tEncodeSEpSet(pEncoder, &pAddr->epSet) < 0) return -1;
  return 0;
}

D
dapan1121 已提交
151 152 153 154 155 156
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 已提交
157
int32_t tDecodeSQueryNodeAddr(SDecoder *pDecoder, SQueryNodeAddr *pAddr) {
D
dapan1121 已提交
158 159 160 161 162
  if (tDecodeI32(pDecoder, &pAddr->nodeId) < 0) return -1;
  if (tDecodeSEpSet(pDecoder, &pAddr->epSet) < 0) return -1;
  return 0;
}

D
dapan1121 已提交
163 164 165 166 167 168
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 已提交
169 170 171 172 173 174 175 176 177 178 179
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;
}

180
void *taosDecodeSEpSet(const void *buf, SEpSet *pEp) {
S
Shengliang Guan 已提交
181 182 183 184 185 186
  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);
  }
187
  return (void *)buf;
S
Shengliang Guan 已提交
188 189
}

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

D
dapan1121 已提交
193
  if (pReq->connKey.connType == CONN_TYPE__QUERY) {
D
dapan1121 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206
    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 已提交
207

D
dapan1121 已提交
208 209 210 211 212
    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;
213

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

D
dapan1121 已提交
217 218 219 220 221 222 223
      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;
224
        if (tEncodeI8(pEncoder, desc->stableQuery) < 0) return -1;
D
dapan1121 已提交
225 226 227 228 229 230 231 232
        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;
233
          if (tEncodeCStr(pEncoder, sDesc->status) < 0) return -1;
D
dapan1121 已提交
234 235 236 237 238 239
        }
      }
    } else {
      if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
    }
  }
240

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

  return 0;
L
Liu Jicong 已提交
251 252
}

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

D
dapan1121 已提交
256
  if (pReq->connKey.connType == CONN_TYPE__QUERY) {
D
dapan1121 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269 270
    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 已提交
271 272 273 274 275 276 277 278 279 280 281 282
    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;
283

D
dapan1121 已提交
284 285 286 287 288 289 290
        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;
X
Xiaoyu Wang 已提交
291
          if (tDecodeI8(pDecoder, (int8_t *)&desc.stableQuery) < 0) return -1;
D
dapan1121 已提交
292 293 294 295 296 297 298 299
          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;
300

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

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

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

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

S
Shengliang Guan 已提交
329
  return 0;
L
Liu Jicong 已提交
330 331
}

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

D
dapan1121 已提交
336 337 338
  int32_t queryNum = 0;
  if (pRsp->query) {
    queryNum = 1;
339
    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
D
dapan1121 已提交
340 341 342 343 344 345
    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;
D
dapan1121 已提交
346 347 348 349 350 351
    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 已提交
352
  } else {
353
    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
D
dapan1121 已提交
354
  }
355

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

  return 0;
L
Liu Jicong 已提交
364
}
S
Shengliang Guan 已提交
365

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

D
dapan1121 已提交
370 371 372 373 374 375 376 377 378 379 380
  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;
D
dapan1121 已提交
381 382 383 384 385
    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 已提交
386 387 388 389 390
      for (int32_t i = 0; i < pQnodeNum; ++i) {
        SQueryNodeLoad load = {0};
        if (tDecodeSQueryNodeLoad(pDecoder, &load) < 0) return -1;
        taosArrayPush(pRsp->query->pQnodeList, &load);
      }
D
dapan1121 已提交
391
    }
D
dapan1121 已提交
392 393
  }

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

S
Shengliang Guan 已提交
404
  return 0;
L
Liu Jicong 已提交
405 406
}

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

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

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

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

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

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

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

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

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pBatchRsp->reqId) < 0) return -1;
  if (tEncodeI64(&encoder, pBatchRsp->rspId) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
458
  if (tEncodeI32(&encoder, pBatchRsp->svrTimestamp) < 0) return -1;
S
Shengliang Guan 已提交
459 460 461 462

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

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

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

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pBatchRsp->reqId) < 0) return -1;
  if (tDecodeI64(&decoder, &pBatchRsp->rspId) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
480
  if (tDecodeI32(&decoder, &pBatchRsp->svrTimestamp) < 0) return -1;
S
Shengliang Guan 已提交
481 482 483 484

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

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

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

S
Shengliang Guan 已提交
502 503 504
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
505 506 507 508 509
  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;
X
Xiaoyu Wang 已提交
510 511 512 513
  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 已提交
514
  if (tEncodeI32(&encoder, pReq->ttl) < 0) return -1;
515 516
  if (tEncodeI32(&encoder, pReq->colVer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->tagVer) < 0) return -1;
S
Shengliang Guan 已提交
517 518
  if (tEncodeI32(&encoder, pReq->numOfColumns) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfTags) < 0) return -1;
S
Shengliang Guan 已提交
519
  if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
S
sma  
Shengliang Guan 已提交
520
  if (tEncodeI32(&encoder, pReq->commentLen) < 0) return -1;
521 522
  if (tEncodeI32(&encoder, pReq->ast1Len) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->ast2Len) < 0) return -1;
S
Shengliang Guan 已提交
523 524 525

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

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

  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 已提交
543 544 545
  }

  if (pReq->commentLen > 0) {
S
Shengliang Guan 已提交
546
    if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
S
sma  
Shengliang Guan 已提交
547
  }
548 549 550 551 552 553
  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;
  }
D
dapan1121 已提交
554

S
Shengliang Guan 已提交
555 556 557
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
558
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
559 560 561
  return tlen;
}

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

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
569 570 571 572 573
  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;
X
Xiaoyu Wang 已提交
574 575 576 577
  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 已提交
578
  if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
579 580
  if (tDecodeI32(&decoder, &pReq->colVer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->tagVer) < 0) return -1;
S
Shengliang Guan 已提交
581 582
  if (tDecodeI32(&decoder, &pReq->numOfColumns) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfTags) < 0) return -1;
S
Shengliang Guan 已提交
583
  if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
S
sma  
Shengliang Guan 已提交
584
  if (tDecodeI32(&decoder, &pReq->commentLen) < 0) return -1;
585 586
  if (tDecodeI32(&decoder, &pReq->ast1Len) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->ast2Len) < 0) return -1;
S
Shengliang Guan 已提交
587 588 589

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

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

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

S
Shengliang Guan 已提交
620 621 622 623 624 625 626 627 628
  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 已提交
629
  if (pReq->commentLen > 0) {
S
Shengliang Guan 已提交
630 631 632
    pReq->pComment = taosMemoryMalloc(pReq->commentLen + 1);
    if (pReq->pComment == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
S
sma  
Shengliang Guan 已提交
633 634
  }

635 636 637 638 639 640 641 642 643 644 645 646
  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;
  }

S
Shengliang Guan 已提交
647
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
648
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
649
  return 0;
S
Shengliang Guan 已提交
650
}
S
Shengliang Guan 已提交
651

S
Shengliang Guan 已提交
652 653 654
void tFreeSMCreateStbReq(SMCreateStbReq *pReq) {
  taosArrayDestroy(pReq->pColumns);
  taosArrayDestroy(pReq->pTags);
S
Shengliang Guan 已提交
655 656
  taosArrayDestroy(pReq->pFuncs);
  taosMemoryFreeClear(pReq->pComment);
657 658
  taosMemoryFreeClear(pReq->pAst1);
  taosMemoryFreeClear(pReq->pAst2);
S
Shengliang Guan 已提交
659 660
}

S
Shengliang Guan 已提交
661
int32_t tSerializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq) {
H
Hongze Cheng 已提交
662 663
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
664

S
Shengliang Guan 已提交
665 666 667
  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
668
  if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
669
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
wmmhello's avatar
wmmhello 已提交
670 671
    if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
  }
672
  if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
S
Shengliang Guan 已提交
673
  tEndEncode(&encoder);
S
Shengliang Guan 已提交
674

S
Shengliang Guan 已提交
675
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
676
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
677 678 679
  return tlen;
}

S
Shengliang Guan 已提交
680
int32_t tDeserializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq) {
H
Hongze Cheng 已提交
681 682
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
683

S
Shengliang Guan 已提交
684 685 686
  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
687
  if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
688
  for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
wmmhello's avatar
wmmhello 已提交
689 690
    if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
691
  if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
692

S
Shengliang Guan 已提交
693
  tEndDecode(&decoder);
S
Shengliang Guan 已提交
694

H
Hongze Cheng 已提交
695
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
696 697
  return 0;
}
S
Shengliang Guan 已提交
698

S
Shengliang Guan 已提交
699
int32_t tSerializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq) {
H
Hongze Cheng 已提交
700 701
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
702

S
Shengliang Guan 已提交
703 704 705 706
  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 已提交
707 708
  for (int32_t i = 0; i < pReq->numOfFields; ++i) {
    SField *pField = taosArrayGet(pReq->pFields, i);
S
Shengliang Guan 已提交
709 710 711
    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 已提交
712
  }
X
Xiaoyu Wang 已提交
713 714 715 716 717
  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 已提交
718
  tEndEncode(&encoder);
S
Shengliang Guan 已提交
719

S
Shengliang Guan 已提交
720
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
721
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
722 723 724
  return tlen;
}

S
Shengliang Guan 已提交
725
int32_t tDeserializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq) {
H
Hongze Cheng 已提交
726 727
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
728

S
Shengliang Guan 已提交
729 730 731 732
  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 已提交
733 734 735
  pReq->pFields = taosArrayInit(pReq->numOfFields, sizeof(SField));
  if (pReq->pFields == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
736
    return -1;
S
Shengliang Guan 已提交
737 738 739 740
  }

  for (int32_t i = 0; i < pReq->numOfFields; ++i) {
    SField field = {0};
S
Shengliang Guan 已提交
741 742 743
    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 已提交
744 745
    if (taosArrayPush(pReq->pFields, &field) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
746
      return -1;
S
Shengliang Guan 已提交
747 748 749
    }
  }

X
Xiaoyu Wang 已提交
750 751 752
  if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
wmmhello's avatar
wmmhello 已提交
753
    pReq->comment = taosMemoryMalloc(pReq->commentLen + 1);
X
Xiaoyu Wang 已提交
754 755 756 757
    if (pReq->comment == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->comment) < 0) return -1;
  }

S
Shengliang Guan 已提交
758
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
759
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
760 761 762
  return 0;
}

S
Shengliang Guan 已提交
763
void tFreeSMAltertbReq(SMAlterStbReq *pReq) {
S
Shengliang Guan 已提交
764 765
  taosArrayDestroy(pReq->pFields);
  pReq->pFields = NULL;
766
  taosMemoryFreeClear(pReq->comment);
S
Shengliang Guan 已提交
767
}
768 769

int32_t tSerializeSEpSet(void *buf, int32_t bufLen, const SEpSet *pEpset) {
H
Hongze Cheng 已提交
770 771
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
772
  if (tStartEncode(&encoder) < 0) return -1;
773
  if (tEncodeSEpSet(&encoder, pEpset) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
774

dengyihao's avatar
dengyihao 已提交
775 776
  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
777
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
778 779
  return tlen;
}
780 781

int32_t tDeserializeSEpSet(void *buf, int32_t bufLen, SEpSet *pEpset) {
H
Hongze Cheng 已提交
782 783
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
784
  if (tStartDecode(&decoder) < 0) return -1;
785
  if (tDecodeSEpSet(&decoder, pEpset) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
786 787

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
788
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
789 790
  return 0;
}
S
Shengliang Guan 已提交
791

S
Shengliang Guan 已提交
792
int32_t tSerializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pReq) {
H
Hongze Cheng 已提交
793 794
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
795 796 797 798 799 800 801 802

  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 已提交
803
  if (tEncodeI32(&encoder, pReq->dstVgId) < 0) return -1;
S
Shengliang Guan 已提交
804 805 806
  if (tEncodeI64(&encoder, pReq->interval) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->offset) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->sliding) < 0) return -1;
807 808
  if (tEncodeI64(&encoder, pReq->watermark) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->maxDelay) < 0) return -1;
S
Shengliang Guan 已提交
809
  if (tEncodeI32(&encoder, pReq->exprLen) < 0) return -1;
S
sma  
Shengliang Guan 已提交
810 811 812
  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 已提交
813 814 815 816 817 818
  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 已提交
819 820 821 822 823 824
  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;
  }
S
Shengliang Guan 已提交
825 826 827
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
828
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
829 830 831 832
  return tlen;
}

int32_t tDeserializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pReq) {
H
Hongze Cheng 已提交
833 834
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
835 836 837 838 839 840 841 842

  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 已提交
843
  if (tDecodeI32(&decoder, &pReq->dstVgId) < 0) return -1;
S
Shengliang Guan 已提交
844 845 846
  if (tDecodeI64(&decoder, &pReq->interval) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->offset) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->sliding) < 0) return -1;
847 848
  if (tDecodeI64(&decoder, &pReq->watermark) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->maxDelay) < 0) return -1;
S
Shengliang Guan 已提交
849
  if (tDecodeI32(&decoder, &pReq->exprLen) < 0) return -1;
S
sma  
Shengliang Guan 已提交
850 851 852
  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 已提交
853
  if (pReq->exprLen > 0) {
wafwerar's avatar
wafwerar 已提交
854
    pReq->expr = taosMemoryMalloc(pReq->exprLen);
S
Shengliang Guan 已提交
855 856 857 858
    if (pReq->expr == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->expr) < 0) return -1;
  }
  if (pReq->tagsFilterLen > 0) {
wafwerar's avatar
wafwerar 已提交
859
    pReq->tagsFilter = taosMemoryMalloc(pReq->tagsFilterLen);
S
Shengliang Guan 已提交
860 861 862
    if (pReq->tagsFilter == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->tagsFilter) < 0) return -1;
  }
S
sma  
Shengliang Guan 已提交
863
  if (pReq->sqlLen > 0) {
wafwerar's avatar
wafwerar 已提交
864
    pReq->sql = taosMemoryMalloc(pReq->sqlLen);
S
sma  
Shengliang Guan 已提交
865 866 867 868
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }
  if (pReq->astLen > 0) {
wafwerar's avatar
wafwerar 已提交
869
    pReq->ast = taosMemoryMalloc(pReq->astLen);
S
sma  
Shengliang Guan 已提交
870 871 872
    if (pReq->ast == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
  }
S
Shengliang Guan 已提交
873 874

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
875
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
876 877 878 879
  return 0;
}

void tFreeSMCreateSmaReq(SMCreateSmaReq *pReq) {
wafwerar's avatar
wafwerar 已提交
880 881 882 883
  taosMemoryFreeClear(pReq->expr);
  taosMemoryFreeClear(pReq->tagsFilter);
  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->ast);
S
Shengliang Guan 已提交
884 885 886
}

int32_t tSerializeSMDropSmaReq(void *buf, int32_t bufLen, SMDropSmaReq *pReq) {
H
Hongze Cheng 已提交
887 888
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
889 890 891

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

S
Shengliang Guan 已提交
893 894 895 896
  if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
897
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
898 899 900 901
  return tlen;
}

int32_t tDeserializeSMDropSmaReq(void *buf, int32_t bufLen, SMDropSmaReq *pReq) {
H
Hongze Cheng 已提交
902 903
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
904 905 906 907 908 909

  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 已提交
910
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
911 912
  return 0;
}
dengyihao's avatar
dengyihao 已提交
913
int32_t tSerializeSMCreateFullTextReq(void *buf, int32_t bufLen, SMCreateFullTextReq *pReq) {
H
Hongze Cheng 已提交
914 915
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
916 917 918 919 920

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

  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
921
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
922 923 924
  return tlen;
}
int32_t tDeserializeSMCreateFullTextReq(void *buf, int32_t bufLen, SMCreateFullTextReq *pReq) {
H
Hongze Cheng 已提交
925 926
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
927 928 929
  if (tStartDecode(&decoder) < 0) return -1;

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
930
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
931 932 933 934 935 936
  return 0;
}
void tFreeSMCreateFullTextReq(SMCreateFullTextReq *pReq) {
  // impl later
  return;
}
dengyihao's avatar
dengyihao 已提交
937
int32_t tSerializeSMDropFullTextReq(void *buf, int32_t bufLen, SMDropFullTextReq *pReq) {
H
Hongze Cheng 已提交
938 939
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
940 941 942

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

dengyihao's avatar
dengyihao 已提交
943 944 945 946
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;

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

dengyihao's avatar
dengyihao 已提交
947 948
  tEndEncode(&encoder);
  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
949
  tEncoderClear(&encoder);
dengyihao's avatar
dengyihao 已提交
950 951 952
  return tlen;
}
int32_t tDeserializeSMDropFullTextReq(void *buf, int32_t bufLen, SMDropFullTextReq *pReq) {
H
Hongze Cheng 已提交
953 954
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
dengyihao's avatar
dengyihao 已提交
955
  if (tStartDecode(&decoder) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
956 957
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
958 959

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
960
  tDecoderClear(&decoder);
dengyihao's avatar
dengyihao 已提交
961 962
  return 0;
}
S
Shengliang Guan 已提交
963

S
Shengliang Guan 已提交
964
int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
H
Hongze Cheng 已提交
965 966
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
967 968

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

  // status
S
Shengliang Guan 已提交
971
  if (tEncodeI32(&encoder, pReq->sver) < 0) return -1;
S
Shengliang Guan 已提交
972
  if (tEncodeI64(&encoder, pReq->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
973 974 975 976
  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 已提交
977
  if (tEncodeFloat(&encoder, pReq->numOfCores) < 0) return -1;
S
Shengliang Guan 已提交
978
  if (tEncodeI32(&encoder, pReq->numOfSupportVnodes) < 0) return -1;
979 980
  if (tEncodeI64(&encoder, pReq->memTotal) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->memAvail) < 0) return -1;
S
Shengliang Guan 已提交
981
  if (tEncodeCStr(&encoder, pReq->dnodeEp) < 0) return -1;
S
Shengliang Guan 已提交
982 983

  // cluster cfg
S
Shengliang Guan 已提交
984 985 986 987 988
  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;
S
Shengliang Guan 已提交
989 990 991

  // vnode loads
  int32_t vlen = (int32_t)taosArrayGetSize(pReq->pVloads);
S
Shengliang Guan 已提交
992
  if (tEncodeI32(&encoder, vlen) < 0) return -1;
S
Shengliang Guan 已提交
993 994
  for (int32_t i = 0; i < vlen; ++i) {
    SVnodeLoad *pload = taosArrayGet(pReq->pVloads, i);
S
Shengliang Guan 已提交
995
    if (tEncodeI32(&encoder, pload->vgId) < 0) return -1;
996 997
    if (tEncodeI8(&encoder, pload->syncState) < 0) return -1;
    if (tEncodeI8(&encoder, pload->syncRestore) < 0) return -1;
998
    if (tEncodeI64(&encoder, pload->cacheUsage) < 0) return -1;
S
Shengliang Guan 已提交
999 1000 1001 1002 1003
    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;
S
Shengliang Guan 已提交
1004 1005
  }

1006
  // mnode loads
1007 1008
  if (tEncodeI8(&encoder, pReq->mload.syncState) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->mload.syncRestore) < 0) return -1;
1009

D
dapan1121 已提交
1010 1011 1012 1013 1014 1015
  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 已提交
1016
  if (tEncodeI64(&encoder, pReq->qload.numOfProcessedDelete) < 0) return -1;
D
dapan1121 已提交
1017 1018 1019 1020 1021 1022
  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;

1023
  if (tEncodeI32(&encoder, pReq->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1024 1025 1026
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1027
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1028 1029 1030
  return tlen;
}

S
Shengliang Guan 已提交
1031
int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
H
Hongze Cheng 已提交
1032 1033
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1034 1035 1036

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

S
Shengliang Guan 已提交
1037
  // status
S
Shengliang Guan 已提交
1038
  if (tDecodeI32(&decoder, &pReq->sver) < 0) return -1;
S
Shengliang Guan 已提交
1039
  if (tDecodeI64(&decoder, &pReq->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1040 1041 1042 1043
  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 已提交
1044
  if (tDecodeFloat(&decoder, &pReq->numOfCores) < 0) return -1;
S
Shengliang Guan 已提交
1045
  if (tDecodeI32(&decoder, &pReq->numOfSupportVnodes) < 0) return -1;
1046 1047
  if (tDecodeI64(&decoder, &pReq->memTotal) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->memAvail) < 0) return -1;
S
Shengliang Guan 已提交
1048
  if (tDecodeCStrTo(&decoder, pReq->dnodeEp) < 0) return -1;
S
Shengliang Guan 已提交
1049 1050

  // cluster cfg
S
Shengliang Guan 已提交
1051 1052 1053 1054 1055
  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;
S
Shengliang Guan 已提交
1056 1057 1058

  // vnode loads
  int32_t vlen = 0;
S
Shengliang Guan 已提交
1059
  if (tDecodeI32(&decoder, &vlen) < 0) return -1;
S
Shengliang Guan 已提交
1060 1061 1062
  pReq->pVloads = taosArrayInit(vlen, sizeof(SVnodeLoad));
  if (pReq->pVloads == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1063
    return -1;
S
Shengliang Guan 已提交
1064 1065 1066 1067
  }

  for (int32_t i = 0; i < vlen; ++i) {
    SVnodeLoad vload = {0};
S
Shengliang Guan 已提交
1068
    if (tDecodeI32(&decoder, &vload.vgId) < 0) return -1;
1069 1070
    if (tDecodeI8(&decoder, &vload.syncState) < 0) return -1;
    if (tDecodeI8(&decoder, &vload.syncRestore) < 0) return -1;
1071
    if (tDecodeI64(&decoder, &vload.cacheUsage) < 0) return -1;
S
Shengliang Guan 已提交
1072 1073 1074 1075 1076
    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;
S
Shengliang Guan 已提交
1077 1078
    if (taosArrayPush(pReq->pVloads, &vload) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1079
      return -1;
S
Shengliang Guan 已提交
1080 1081 1082
    }
  }

1083 1084
  if (tDecodeI8(&decoder, &pReq->mload.syncState) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->mload.syncRestore) < 0) return -1;
1085

D
dapan1121 已提交
1086 1087 1088 1089 1090 1091
  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 已提交
1092
  if (tDecodeI64(&decoder, &pReq->qload.numOfProcessedDelete) < 0) return -1;
D
dapan1121 已提交
1093 1094 1095 1096 1097 1098
  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;

1099
  if (tDecodeI32(&decoder, &pReq->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1100
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
1101
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1102
  return 0;
S
Shengliang Guan 已提交
1103
}
S
Shengliang Guan 已提交
1104

S
Shengliang Guan 已提交
1105 1106
void tFreeSStatusReq(SStatusReq *pReq) { taosArrayDestroy(pReq->pVloads); }

S
Shengliang Guan 已提交
1107
int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
H
Hongze Cheng 已提交
1108 1109
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1110

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

S
Shengliang Guan 已提交
1113
  // status
S
Shengliang Guan 已提交
1114
  if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1115 1116

  // dnode cfg
S
Shengliang Guan 已提交
1117 1118
  if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId) < 0) return -1;
S
Shengliang Guan 已提交
1119 1120 1121

  // dnode eps
  int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps);
S
Shengliang Guan 已提交
1122
  if (tEncodeI32(&encoder, dlen) < 0) return -1;
S
Shengliang Guan 已提交
1123 1124
  for (int32_t i = 0; i < dlen; ++i) {
    SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i);
S
Shengliang Guan 已提交
1125 1126 1127 1128
    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 已提交
1129 1130
  }

1131
  if (tEncodeI32(&encoder, pRsp->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1132 1133 1134
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1135
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1136 1137 1138
  return tlen;
}

S
Shengliang Guan 已提交
1139
int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
H
Hongze Cheng 已提交
1140 1141
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1142 1143 1144

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

S
Shengliang Guan 已提交
1145
  // status
S
Shengliang Guan 已提交
1146
  if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1;
S
Shengliang Guan 已提交
1147 1148

  // cluster cfg
S
Shengliang Guan 已提交
1149 1150
  if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId) < 0) return -1;
S
Shengliang Guan 已提交
1151 1152 1153

  // dnode eps
  int32_t dlen = 0;
S
Shengliang Guan 已提交
1154
  if (tDecodeI32(&decoder, &dlen) < 0) return -1;
S
Shengliang Guan 已提交
1155 1156 1157
  pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp));
  if (pRsp->pDnodeEps == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1158
    return -1;
S
Shengliang Guan 已提交
1159 1160 1161 1162
  }

  for (int32_t i = 0; i < dlen; ++i) {
    SDnodeEp dnodeEp = {0};
S
Shengliang Guan 已提交
1163 1164 1165 1166
    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 已提交
1167 1168
    if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
S
Shengliang Guan 已提交
1169
      return -1;
S
Shengliang Guan 已提交
1170 1171 1172
    }
  }

1173
  if (tDecodeI32(&decoder, &pRsp->statusSeq) < 0) return -1;
S
Shengliang Guan 已提交
1174
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
1175
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1176
  return 0;
S
Shengliang Guan 已提交
1177
}
S
Shengliang Guan 已提交
1178

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

S
Shengliang Guan 已提交
1181
int32_t tSerializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
H
Hongze Cheng 已提交
1182 1183
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

  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 已提交
1197
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1198 1199 1200
  return tlen;
}

S
Shengliang Guan 已提交
1201
int32_t tDeserializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) {
H
Hongze Cheng 已提交
1202 1203
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215

  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 已提交
1216
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1217
  return 0;
S
Shengliang Guan 已提交
1218 1219
}

S
Shengliang Guan 已提交
1220
int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
H
Hongze Cheng 已提交
1221 1222
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1223 1224 1225 1226 1227 1228

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1229
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1230 1231 1232
  return tlen;
}

S
Shengliang Guan 已提交
1233
int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
H
Hongze Cheng 已提交
1234 1235
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1236 1237 1238 1239 1240

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

H
Hongze Cheng 已提交
1241
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1242
  return 0;
S
Shengliang Guan 已提交
1243 1244
}

S
Shengliang Guan 已提交
1245
int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
H
Hongze Cheng 已提交
1246 1247
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1248 1249 1250 1251

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->createType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1;
1252 1253
  if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->enable) < 0) return -1;
S
Shengliang Guan 已提交
1254 1255 1256 1257 1258
  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 已提交
1259
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1260 1261 1262
  return tlen;
}

S
Shengliang Guan 已提交
1263
int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
H
Hongze Cheng 已提交
1264 1265
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1266 1267 1268 1269

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1;
1270 1271
  if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1;
S
Shengliang Guan 已提交
1272 1273 1274 1275
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1276
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1277
  return 0;
S
Shengliang Guan 已提交
1278 1279
}

S
Shengliang Guan 已提交
1280
int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
H
Hongze Cheng 已提交
1281 1282
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1283 1284 1285 1286

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1;
1287 1288
  if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->enable) < 0) return -1;
S
Shengliang Guan 已提交
1289 1290 1291 1292 1293 1294
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->dbname) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1295
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1296 1297 1298
  return tlen;
}

S
Shengliang Guan 已提交
1299
int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
H
Hongze Cheng 已提交
1300 1301
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1302 1303 1304 1305

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1;
1306 1307
  if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1;
S
Shengliang Guan 已提交
1308 1309 1310 1311 1312
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->dbname) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1313
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1314
  return 0;
S
Shengliang Guan 已提交
1315 1316
}

S
Shengliang Guan 已提交
1317
int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
H
Hongze Cheng 已提交
1318 1319
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1320 1321 1322 1323 1324 1325

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1326
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1327 1328 1329
  return tlen;
}

S
Shengliang Guan 已提交
1330
int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
H
Hongze Cheng 已提交
1331 1332
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1333 1334 1335 1336 1337

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

H
Hongze Cheng 已提交
1338
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1339
  return 0;
S
Shengliang Guan 已提交
1340 1341
}

H
Hongze Cheng 已提交
1342
int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1343 1344
  if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1;
  if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1;
1345 1346 1347
  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 已提交
1348
  if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1;
S
Shengliang Guan 已提交
1349

D
dapan 已提交
1350
  int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
S
Shengliang Guan 已提交
1351 1352
  int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
  int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
D
dapan 已提交
1353 1354 1355
  if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1;
  if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1;
S
Shengliang Guan 已提交
1356

D
dapan 已提交
1357
  char *db = taosHashIterate(pRsp->createdDbs, NULL);
S
Shengliang Guan 已提交
1358
  while (db != NULL) {
D
dapan 已提交
1359 1360 1361 1362 1363 1364 1365
    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 已提交
1366
    db = taosHashIterate(pRsp->readDbs, db);
S
Shengliang Guan 已提交
1367 1368
  }

S
Shengliang Guan 已提交
1369
  db = taosHashIterate(pRsp->writeDbs, NULL);
S
Shengliang Guan 已提交
1370
  while (db != NULL) {
D
dapan 已提交
1371
    if (tEncodeCStr(pEncoder, db) < 0) return -1;
S
Shengliang Guan 已提交
1372
    db = taosHashIterate(pRsp->writeDbs, db);
S
Shengliang Guan 已提交
1373 1374
  }

D
dapan 已提交
1375 1376 1377 1378
  return 0;
}

int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
H
Hongze Cheng 已提交
1379 1380
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
1381 1382 1383 1384 1385

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

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

S
Shengliang Guan 已提交
1386 1387 1388
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1389
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1390 1391 1392
  return tlen;
}

H
Hongze Cheng 已提交
1393
int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1394 1395 1396
  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);
S
Shengliang Guan 已提交
1397
  if (pRsp->readDbs == NULL || pRsp->writeDbs == NULL) {
S
Shengliang Guan 已提交
1398
    return -1;
S
Shengliang Guan 已提交
1399 1400
  }

D
dapan 已提交
1401 1402
  if (tDecodeCStrTo(pDecoder, pRsp->user) < 0) return -1;
  if (tDecodeI8(pDecoder, &pRsp->superAuth) < 0) return -1;
1403 1404 1405
  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 已提交
1406
  if (tDecodeI32(pDecoder, &pRsp->version) < 0) return -1;
S
Shengliang Guan 已提交
1407

D
dapan 已提交
1408
  int32_t numOfCreatedDbs = 0;
S
Shengliang Guan 已提交
1409 1410
  int32_t numOfReadDbs = 0;
  int32_t numOfWriteDbs = 0;
D
dapan 已提交
1411 1412 1413 1414 1415 1416 1417
  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 已提交
1418
    int32_t len = strlen(db);
D
dapan 已提交
1419 1420
    taosHashPut(pRsp->createdDbs, db, len, db, len);
  }
S
Shengliang Guan 已提交
1421 1422 1423

  for (int32_t i = 0; i < numOfReadDbs; ++i) {
    char db[TSDB_DB_FNAME_LEN] = {0};
D
dapan 已提交
1424
    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
D
fix bug  
dapan 已提交
1425
    int32_t len = strlen(db);
S
Shengliang Guan 已提交
1426
    taosHashPut(pRsp->readDbs, db, len, db, len);
S
Shengliang Guan 已提交
1427 1428 1429 1430
  }

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

D
dapan 已提交
1436 1437 1438 1439
  return 0;
}

int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
H
Hongze Cheng 已提交
1440 1441
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
1442 1443 1444 1445 1446

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

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

S
Shengliang Guan 已提交
1447 1448
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1449
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1450
  return 0;
S
Shengliang Guan 已提交
1451
}
S
Shengliang Guan 已提交
1452

S
Shengliang Guan 已提交
1453
void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {
D
dapan 已提交
1454
  taosHashCleanup(pRsp->createdDbs);
S
Shengliang Guan 已提交
1455 1456 1457 1458
  taosHashCleanup(pRsp->readDbs);
  taosHashCleanup(pRsp->writeDbs);
}

S
Shengliang Guan 已提交
1459
int32_t tSerializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
H
Hongze Cheng 已提交
1460 1461
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1462 1463 1464 1465 1466 1467

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1468
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1469 1470 1471
  return tlen;
}

S
Shengliang Guan 已提交
1472
int32_t tDeserializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
H
Hongze Cheng 已提交
1473 1474
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1475 1476 1477 1478 1479

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

H
Hongze Cheng 已提交
1480
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1481 1482
  return 0;
}
S
Shengliang Guan 已提交
1483 1484

int32_t tSerializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
H
Hongze Cheng 已提交
1485 1486
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
1487 1488 1489 1490 1491

  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;
1492
  if (tEncodeI8(&encoder, pReq->force) < 0) return -1;
1493 1494 1495
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1496
  tEncoderClear(&encoder);
1497
  return tlen;
S
Shengliang Guan 已提交
1498 1499 1500
}

int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
H
Hongze Cheng 已提交
1501 1502
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
1503 1504 1505 1506 1507

  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;
1508
  if (tDecodeI8(&decoder, &pReq->force) < 0) return -1;
1509 1510
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1511
  tDecoderClear(&decoder);
1512
  return 0;
S
Shengliang Guan 已提交
1513 1514 1515
}

int32_t tSerializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) {
H
Hongze Cheng 已提交
1516 1517
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1518 1519 1520 1521 1522 1523 1524 1525

  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 已提交
1526
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1527 1528 1529 1530
  return tlen;
}

int32_t tDeserializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq) {
H
Hongze Cheng 已提交
1531 1532
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1533 1534 1535 1536 1537 1538 1539

  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 已提交
1540
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1541 1542 1543
  return 0;
}

S
Shengliang Guan 已提交
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
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 已提交
1571
int32_t tSerializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) {
H
Hongze Cheng 已提交
1572 1573
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1574 1575 1576 1577 1578 1579 1580

  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 已提交
1581
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1582 1583 1584 1585
  return tlen;
}

int32_t tDeserializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) {
H
Hongze Cheng 已提交
1586 1587
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1588 1589 1590 1591 1592 1593

  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 已提交
1594
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1595 1596
  return 0;
}
S
Shengliang Guan 已提交
1597 1598

int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
H
Hongze Cheng 已提交
1599 1600
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1601 1602 1603 1604 1605 1606 1607 1608 1609

  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;
1610
  if (tEncodeI32(&encoder, pReq->codeLen) < 0) return -1;
S
Shengliang Guan 已提交
1611
  if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
1612 1613

  if (pReq->pCode != NULL) {
S
Shengliang Guan 已提交
1614
    if (tEncodeBinary(&encoder, pReq->pCode, pReq->codeLen) < 0) return -1;
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
  }

  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;
  }

S
Shengliang Guan 已提交
1626 1627 1628
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1629
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1630 1631 1632 1633
  return tlen;
}

int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq) {
H
Hongze Cheng 已提交
1634 1635
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1636 1637 1638 1639 1640 1641 1642 1643 1644

  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;
1645
  if (tDecodeI32(&decoder, &pReq->codeLen) < 0) return -1;
S
Shengliang Guan 已提交
1646
  if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
1647

S
Shengliang Guan 已提交
1648 1649
  if (pReq->codeLen > 0) {
    pReq->pCode = taosMemoryCalloc(1, pReq->codeLen);
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
    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;
  }

S
Shengliang Guan 已提交
1668 1669
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1670
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1671 1672 1673
  return 0;
}

1674 1675 1676 1677 1678
void tFreeSCreateFuncReq(SCreateFuncReq *pReq) {
  taosMemoryFree(pReq->pCode);
  taosMemoryFree(pReq->pComment);
}

S
Shengliang Guan 已提交
1679
int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
H
Hongze Cheng 已提交
1680 1681
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1682 1683 1684 1685 1686 1687 1688

  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 已提交
1689
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1690 1691 1692 1693
  return tlen;
}

int32_t tDeserializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
H
Hongze Cheng 已提交
1694 1695
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1696 1697 1698 1699 1700 1701

  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 已提交
1702
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1703 1704 1705 1706
  return 0;
}

int32_t tSerializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
H
Hongze Cheng 已提交
1707 1708
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1709 1710 1711

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
D
dapan1121 已提交
1712
  if (tEncodeI8(&encoder, pReq->ignoreCodeComment) < 0) return -1;
S
Shengliang Guan 已提交
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722

  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 已提交
1723
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1724 1725 1726 1727
  return tlen;
}

int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq *pReq) {
H
Hongze Cheng 已提交
1728 1729
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1730 1731 1732

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
D
dapan1121 已提交
1733
  if (tDecodeI8(&decoder, (int8_t *)&pReq->ignoreCodeComment) < 0) return -1;
S
Shengliang Guan 已提交
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744

  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 已提交
1745
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1746 1747 1748
  return 0;
}

1749 1750
void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); }

S
Shengliang Guan 已提交
1751
int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
H
Hongze Cheng 已提交
1752 1753
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769

  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;
1770
    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
D
dapan1121 已提交
1771
    if (pInfo->codeSize) {
S
Shengliang Guan 已提交
1772
      if (tEncodeBinary(&encoder, pInfo->pCode, pInfo->codeSize) < 0) return -1;
D
dapan1121 已提交
1773 1774 1775 1776
    }
    if (pInfo->commentSize) {
      if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
    }
S
Shengliang Guan 已提交
1777 1778 1779 1780 1781
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
1782
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
1783 1784 1785 1786
  return tlen;
}

int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
H
Hongze Cheng 已提交
1787 1788
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805

  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;
1806
    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
D
dapan1121 已提交
1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
    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;
1822 1823
    }

S
Shengliang Guan 已提交
1824 1825 1826 1827
    taosArrayPush(pRsp->pFuncInfos, &fInfo);
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
1828
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
1829 1830
  return 0;
}
S
Shengliang Guan 已提交
1831

D
dapan1121 已提交
1832 1833 1834 1835 1836 1837 1838 1839 1840
void tFreeSFuncInfo(SFuncInfo *pInfo) {
  if (NULL == pInfo) {
    return;
  }

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

1841 1842 1843 1844
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 已提交
1845
    tFreeSFuncInfo(pInfo);
1846 1847 1848 1849
  }
  taosArrayDestroy(pRsp->pFuncInfos);
}

D
dapan1121 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
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 已提交
1897 1898
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
1899

D
dapan1121 已提交
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
  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;
1912

D
dapan1121 已提交
1913 1914 1915 1916 1917 1918 1919
  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;
  }

1920
  if (tEncodeI32(&encoder, pRsp->commentLen) < 0) return -1;
D
dapan1121 已提交
1921 1922 1923
  if (pRsp->commentLen > 0) {
    if (tEncodeCStr(&encoder, pRsp->pComment) < 0) return -1;
  }
1924

D
dapan1121 已提交
1925 1926 1927 1928 1929
  for (int32_t i = 0; i < pRsp->numOfColumns + pRsp->numOfTags; ++i) {
    SSchema *pSchema = &pRsp->pSchemas[i];
    if (tEncodeSSchema(&encoder, pSchema) < 0) return -1;
  }

1930 1931 1932
  if (tEncodeI32(&encoder, pRsp->tagsLen) < 0) return -1;
  if (tEncodeBinary(&encoder, pRsp->pTags, pRsp->tagsLen) < 0) return -1;

D
dapan1121 已提交
1933 1934 1935 1936 1937
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
D
dapan1121 已提交
1938 1939 1940
}

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

D
dapan1121 已提交
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
  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;
1989
  if (tDecodeBinaryAlloc(&decoder, (void **)&pRsp->pTags, NULL) < 0) return -1;
D
dapan1121 已提交
1990 1991 1992 1993 1994

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
D
dapan1121 已提交
1995 1996
}

D
dapan1121 已提交
1997 1998 1999 2000 2001 2002 2003 2004
void tFreeSTableCfgRsp(STableCfgRsp *pRsp) {
  if (NULL == pRsp) {
    return;
  }

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

D
dapan1121 已提交
2006 2007
  taosArrayDestroy(pRsp->pFuncs);
}
D
dapan1121 已提交
2008

S
Shengliang Guan 已提交
2009
int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
H
Hongze Cheng 已提交
2010 2011
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2012 2013 2014 2015

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfVgroups) < 0) return -1;
S
Shengliang Guan 已提交
2016 2017 2018 2019
  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;
2020
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2021 2022 2023 2024 2025 2026
  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;
2027
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2028 2029 2030 2031
  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;
S
Shengliang Guan 已提交
2032
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
2033
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2034
  if (tEncodeI8(&encoder, pReq->schemaless) < 0) return -1;
X
Xiaoyu Wang 已提交
2035
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
2036
  if (tEncodeI64(&encoder, pReq->walRetentionSize) < 0) return -1;
X
Xiaoyu Wang 已提交
2037
  if (tEncodeI32(&encoder, pReq->walRollPeriod) < 0) return -1;
2038
  if (tEncodeI64(&encoder, pReq->walSegmentSize) < 0) return -1;
2039
  if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1;
2040 2041
  if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1;
  if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2042
  if (tEncodeI8(&encoder, pReq->ignoreExist) < 0) return -1;
S
Shengliang Guan 已提交
2043 2044 2045
  if (tEncodeI32(&encoder, pReq->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pReq->pRetensions, i);
C
Cary Xu 已提交
2046 2047
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
2048 2049
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
S
Shengliang Guan 已提交
2050
  }
2051
  if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1;
S
Shengliang Guan 已提交
2052 2053 2054
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2055
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2056 2057 2058 2059
  return tlen;
}

int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
H
Hongze Cheng 已提交
2060 2061
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2062 2063 2064 2065

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfVgroups) < 0) return -1;
S
Shengliang Guan 已提交
2066 2067 2068 2069
  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;
2070
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2071 2072 2073 2074 2075 2076
  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;
2077
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2078 2079 2080 2081
  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;
S
Shengliang Guan 已提交
2082
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
2083
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2084
  if (tDecodeI8(&decoder, &pReq->schemaless) < 0) return -1;
X
Xiaoyu Wang 已提交
2085
  if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
2086
  if (tDecodeI64(&decoder, &pReq->walRetentionSize) < 0) return -1;
X
Xiaoyu Wang 已提交
2087
  if (tDecodeI32(&decoder, &pReq->walRollPeriod) < 0) return -1;
2088
  if (tDecodeI64(&decoder, &pReq->walSegmentSize) < 0) return -1;
2089
  if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1;
2090 2091
  if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1;
  if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2092
  if (tDecodeI8(&decoder, &pReq->ignoreExist) < 0) return -1;
S
Shengliang Guan 已提交
2093 2094 2095 2096 2097 2098 2099 2100 2101
  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};
C
Cary Xu 已提交
2102 2103
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
2104 2105
    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
S
Shengliang Guan 已提交
2106 2107 2108 2109 2110 2111
    if (taosArrayPush(pReq->pRetensions, &rentension) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

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

S
Shengliang Guan 已提交
2114 2115
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2116
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2117 2118 2119
  return 0;
}

S
Shengliang Guan 已提交
2120 2121 2122 2123 2124
void tFreeSCreateDbReq(SCreateDbReq *pReq) {
  taosArrayDestroy(pReq->pRetensions);
  pReq->pRetensions = NULL;
}

S
Shengliang Guan 已提交
2125
int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
H
Hongze Cheng 已提交
2126 2127
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2128 2129 2130

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
2131 2132 2133
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
2134
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2135
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
2136 2137 2138
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
2139
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2140
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
S
Shengliang Guan 已提交
2141
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
2142
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2143
  if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
2144
  if (tEncodeI32(&encoder, pReq->sstTrigger) < 0) return -1;
S
Shengliang Guan 已提交
2145 2146 2147
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2148
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2149 2150 2151 2152
  return tlen;
}

int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
H
Hongze Cheng 已提交
2153 2154
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2155 2156 2157

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
2158 2159 2160
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
2161
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
2162
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
2163 2164 2165
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
2166
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
2167
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
S
Shengliang Guan 已提交
2168
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
2169
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
X
Xiaoyu Wang 已提交
2170
  if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
2171
  if (tDecodeI32(&decoder, &pReq->sstTrigger) < 0) return -1;
S
Shengliang Guan 已提交
2172 2173
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2174
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2175 2176 2177 2178
  return 0;
}

int32_t tSerializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
H
Hongze Cheng 已提交
2179 2180
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2181 2182 2183 2184 2185 2186 2187

  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 已提交
2188
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2189 2190 2191 2192
  return tlen;
}

int32_t tDeserializeSDropDbReq(void *buf, int32_t bufLen, SDropDbReq *pReq) {
H
Hongze Cheng 已提交
2193 2194
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2195 2196 2197 2198 2199 2200

  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 已提交
2201
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2202 2203 2204 2205
  return 0;
}

int32_t tSerializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
H
Hongze Cheng 已提交
2206 2207
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2208 2209 2210

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2211
  if (tEncodeI64(&encoder, pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2212 2213 2214
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2215
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2216 2217 2218 2219
  return tlen;
}

int32_t tDeserializeSDropDbRsp(void *buf, int32_t bufLen, SDropDbRsp *pRsp) {
H
Hongze Cheng 已提交
2220 2221
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2222 2223 2224

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

H
Hongze Cheng 已提交
2228
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2229 2230 2231 2232
  return 0;
}

int32_t tSerializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
H
Hongze Cheng 已提交
2233 2234
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2235 2236 2237

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
D
dapan1121 已提交
2238
  if (tEncodeI64(&encoder, pReq->dbId) < 0) return -1;
S
Shengliang Guan 已提交
2239
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
D
dapan1121 已提交
2240
  if (tEncodeI32(&encoder, pReq->numOfTable) < 0) return -1;
2241
  if (tEncodeI64(&encoder, pReq->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2242 2243 2244
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2245
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2246 2247 2248 2249
  return tlen;
}

int32_t tDeserializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
H
Hongze Cheng 已提交
2250 2251
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2252 2253 2254

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
D
dapan1121 已提交
2255
  if (tDecodeI64(&decoder, &pReq->dbId) < 0) return -1;
S
Shengliang Guan 已提交
2256
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
D
dapan1121 已提交
2257
  if (tDecodeI32(&decoder, &pReq->numOfTable) < 0) return -1;
2258
  if (tDecodeI64(&decoder, &pReq->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2259 2260
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2261
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2262 2263 2264
  return 0;
}

L
Liu Jicong 已提交
2265
int32_t tSerializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) {
H
Hongze Cheng 已提交
2266 2267
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2268 2269 2270 2271 2272 2273

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2274
  tEncoderClear(&encoder);
D
dapan1121 已提交
2275 2276 2277 2278
  return tlen;
}

int32_t tDeserializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) {
H
Hongze Cheng 已提交
2279 2280
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2281 2282 2283 2284 2285

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

H
Hongze Cheng 已提交
2286
  tDecoderClear(&decoder);
D
dapan1121 已提交
2287 2288 2289
  return 0;
}

D
dapan1121 已提交
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
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;
}

D
dapan1121 已提交
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
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 已提交
2365
int32_t tSerializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
H
Hongze Cheng 已提交
2366 2367
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2368 2369

  if (tStartEncode(&encoder) < 0) return -1;
D
dapan1121 已提交
2370
  int32_t num = taosArrayGetSize(pRsp->qnodeList);
L
Liu Jicong 已提交
2371
  if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
2372
  for (int32_t i = 0; i < num; ++i) {
D
dapan1121 已提交
2373 2374
    SQueryNodeLoad *pLoad = taosArrayGet(pRsp->qnodeList, i);
    if (tEncodeSQueryNodeLoad(&encoder, pLoad) < 0) return -1;
D
dapan1121 已提交
2375 2376 2377 2378
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2379
  tEncoderClear(&encoder);
D
dapan1121 已提交
2380 2381 2382 2383
  return tlen;
}

int32_t tDeserializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
H
Hongze Cheng 已提交
2384 2385
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2386 2387 2388 2389

  if (tStartDecode(&decoder) < 0) return -1;
  int32_t num = 0;
  if (tDecodeI32(&decoder, &num) < 0) return -1;
D
dapan1121 已提交
2390 2391 2392
  if (NULL == pRsp->qnodeList) {
    pRsp->qnodeList = taosArrayInit(num, sizeof(SQueryNodeLoad));
    if (NULL == pRsp->qnodeList) return -1;
D
dapan 已提交
2393
  }
2394

D
dapan1121 已提交
2395
  for (int32_t i = 0; i < num; ++i) {
D
dapan1121 已提交
2396 2397 2398
    SQueryNodeLoad load = {0};
    if (tDecodeSQueryNodeLoad(&decoder, &load) < 0) return -1;
    taosArrayPush(pRsp->qnodeList, &load);
D
dapan1121 已提交
2399 2400 2401
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2402
  tDecoderClear(&decoder);
D
dapan1121 已提交
2403 2404 2405
  return 0;
}

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

D
dapan1121 已提交
2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
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); }

S
Shengliang Guan 已提交
2451
int32_t tSerializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
H
Hongze Cheng 已提交
2452 2453
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2454 2455 2456 2457 2458 2459

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2460
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2461 2462 2463
  return tlen;
}

S
Shengliang Guan 已提交
2464
int32_t tDeserializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
H
Hongze Cheng 已提交
2465 2466
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2467 2468 2469 2470 2471

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

H
Hongze Cheng 已提交
2472
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2473
  return 0;
S
Shengliang Guan 已提交
2474 2475
}

H
Hongze Cheng 已提交
2476
int32_t tSerializeSUseDbRspImp(SEncoder *pEncoder, const SUseDbRsp *pRsp) {
S
Shengliang Guan 已提交
2477
  if (tEncodeCStr(pEncoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2478
  if (tEncodeI64(pEncoder, pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2479 2480
  if (tEncodeI32(pEncoder, pRsp->vgVersion) < 0) return -1;
  if (tEncodeI32(pEncoder, pRsp->vgNum) < 0) return -1;
2481 2482
  if (tEncodeI16(pEncoder, pRsp->hashPrefix) < 0) return -1;
  if (tEncodeI16(pEncoder, pRsp->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2483 2484 2485 2486 2487 2488 2489
  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 已提交
2490
    if (tEncodeSEpSet(pEncoder, &pVgInfo->epSet) < 0) return -1;
D
dapan1121 已提交
2491
    if (tEncodeI32(pEncoder, pVgInfo->numOfTable) < 0) return -1;
S
Shengliang Guan 已提交
2492 2493
  }

2494
  if (tEncodeI32(pEncoder, pRsp->errCode) < 0) return -1;
2495
  if (tEncodeI64(pEncoder, pRsp->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2496 2497 2498
  return 0;
}

L
Liu Jicong 已提交
2499
int32_t tSerializeSUseDbRsp(void *buf, int32_t bufLen, const SUseDbRsp *pRsp) {
H
Hongze Cheng 已提交
2500 2501
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2502 2503 2504 2505 2506 2507

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

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

int32_t tSerializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2513 2514
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526

  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 已提交
2527
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
2528 2529 2530
  return tlen;
}

H
Hongze Cheng 已提交
2531
int32_t tDeserializeSUseDbRspImp(SDecoder *pDecoder, SUseDbRsp *pRsp) {
S
Shengliang Guan 已提交
2532
  if (tDecodeCStrTo(pDecoder, pRsp->db) < 0) return -1;
L
Liu Jicong 已提交
2533
  if (tDecodeI64(pDecoder, &pRsp->uid) < 0) return -1;
S
Shengliang Guan 已提交
2534 2535
  if (tDecodeI32(pDecoder, &pRsp->vgVersion) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->vgNum) < 0) return -1;
2536 2537
  if (tDecodeI16(pDecoder, &pRsp->hashPrefix) < 0) return -1;
  if (tDecodeI16(pDecoder, &pRsp->hashSuffix) < 0) return -1;
S
Shengliang Guan 已提交
2538 2539
  if (tDecodeI8(pDecoder, &pRsp->hashMethod) < 0) return -1;

D
dapan1121 已提交
2540 2541 2542 2543 2544 2545
  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 已提交
2546

D
dapan1121 已提交
2547 2548 2549 2550 2551 2552 2553 2554 2555
    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 已提交
2556 2557
  }

2558
  if (tDecodeI32(pDecoder, &pRsp->errCode) < 0) return -1;
2559
  if (tDecodeI64(pDecoder, &pRsp->stateTs) < 0) return -1;
S
Shengliang Guan 已提交
2560 2561 2562 2563
  return 0;
}

int32_t tDeserializeSUseDbRsp(void *buf, int32_t bufLen, SUseDbRsp *pRsp) {
H
Hongze Cheng 已提交
2564 2565
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2566 2567 2568 2569 2570

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

H
Hongze Cheng 已提交
2571
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2572 2573 2574 2575
  return 0;
}

int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2576 2577
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
2578 2579 2580 2581 2582 2583

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

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

D
dapan1121 已提交
2584
  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SUseDbRsp));
S
Shengliang Guan 已提交
2585 2586 2587 2588 2589 2590 2591
  if (pRsp->pArray == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

  for (int32_t i = 0; i < numOfBatch; ++i) {
    SUseDbRsp usedbRsp = {0};
2592 2593 2594 2595
    if (tDeserializeSUseDbRspImp(&decoder, &usedbRsp) < 0) {
      tDecoderClear(&decoder);
      return -1;
    }
S
Shengliang Guan 已提交
2596 2597 2598 2599
    taosArrayPush(pRsp->pArray, &usedbRsp);
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2600
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
  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 已提交
2614 2615
}

H
Hongze Cheng 已提交
2616
int32_t tSerializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2617 2618
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630

  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 已提交
2631
  tEncoderClear(&encoder);
D
dapan 已提交
2632 2633 2634
  return tlen;
}

H
Hongze Cheng 已提交
2635
int32_t tDeserializeSUserAuthBatchRsp(void *buf, int32_t bufLen, SUserAuthBatchRsp *pRsp) {
H
Hongze Cheng 已提交
2636 2637
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656

  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 已提交
2657
  tDecoderClear(&decoder);
D
dapan 已提交
2658 2659 2660
  return 0;
}

H
Hongze Cheng 已提交
2661
void tFreeSUserAuthBatchRsp(SUserAuthBatchRsp *pRsp) {
D
dapan 已提交
2662 2663 2664 2665 2666 2667 2668 2669 2670
  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);
}

S
Shengliang Guan 已提交
2671
int32_t tSerializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
H
Hongze Cheng 已提交
2672 2673
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2674 2675 2676 2677 2678 2679

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2680
  tEncoderClear(&encoder);
D
dapan1121 已提交
2681 2682 2683
  return tlen;
}

S
Shengliang Guan 已提交
2684
int32_t tDeserializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
H
Hongze Cheng 已提交
2685 2686
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2687 2688 2689 2690 2691

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

H
Hongze Cheng 已提交
2692
  tDecoderClear(&decoder);
D
dapan1121 已提交
2693 2694 2695
  return 0;
}

X
Xiaoyu Wang 已提交
2696 2697 2698 2699 2700 2701
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;
2702
  if (tEncodeI32(&encoder, pReq->maxSpeed) < 0) return -1;
X
Xiaoyu Wang 已提交
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
  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;
2716
  if (tDecodeI32(&decoder, &pReq->maxSpeed) < 0) return -1;
X
Xiaoyu Wang 已提交
2717 2718 2719 2720 2721 2722
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

S
Shengliang Guan 已提交
2723 2724 2725 2726 2727
int32_t tSerializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
2728
  if (tEncodeI32(&encoder, pReq->timestamp) < 0) return -1;
S
Shengliang Guan 已提交
2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
  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;
2741
  if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1;
S
Shengliang Guan 已提交
2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
  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;
}

S
Shengliang Guan 已提交
2773
int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
H
Hongze Cheng 已提交
2774 2775
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2776 2777 2778

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->numOfVgroups) < 0) return -1;
S
Shengliang Guan 已提交
2779 2780
  if (tEncodeI32(&encoder, pRsp->numOfStables) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->buffer) < 0) return -1;
2781
  if (tEncodeI32(&encoder, pRsp->cacheSize) < 0) return -1;
S
Shengliang Guan 已提交
2782 2783
  if (tEncodeI32(&encoder, pRsp->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->pages) < 0) return -1;
D
dapan1121 已提交
2784 2785 2786 2787 2788 2789
  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;
2790
  if (tEncodeI32(&encoder, pRsp->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
2791 2792 2793 2794
  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;
S
Shengliang Guan 已提交
2795
  if (tEncodeI8(&encoder, pRsp->strict) < 0) return -1;
2796
  if (tEncodeI8(&encoder, pRsp->cacheLast) < 0) return -1;
2797 2798 2799
  if (tEncodeI32(&encoder, pRsp->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
C
Cary Xu 已提交
2800 2801
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
2802 2803 2804
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
  }
wmmhello's avatar
wmmhello 已提交
2805
  if (tEncodeI8(&encoder, pRsp->schemaless) < 0) return -1;
D
dapan1121 已提交
2806 2807 2808
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2809
  tEncoderClear(&encoder);
D
dapan1121 已提交
2810 2811 2812
  return tlen;
}

S
Shengliang Guan 已提交
2813
int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
H
Hongze Cheng 已提交
2814 2815
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2816 2817 2818

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfVgroups) < 0) return -1;
S
Shengliang Guan 已提交
2819 2820
  if (tDecodeI32(&decoder, &pRsp->numOfStables) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->buffer) < 0) return -1;
2821
  if (tDecodeI32(&decoder, &pRsp->cacheSize) < 0) return -1;
S
Shengliang Guan 已提交
2822 2823
  if (tDecodeI32(&decoder, &pRsp->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->pages) < 0) return -1;
D
dapan1121 已提交
2824 2825 2826 2827 2828 2829
  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;
2830
  if (tDecodeI32(&decoder, &pRsp->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
2831 2832 2833 2834
  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;
S
Shengliang Guan 已提交
2835
  if (tDecodeI8(&decoder, &pRsp->strict) < 0) return -1;
2836
  if (tDecodeI8(&decoder, &pRsp->cacheLast) < 0) return -1;
2837
  if (tDecodeI32(&decoder, &pRsp->numOfRetensions) < 0) return -1;
2838 2839 2840 2841 2842 2843
  if (pRsp->numOfRetensions > 0) {
    pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention));
    if (pRsp->pRetensions == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
2844
  }
D
dapan1121 已提交
2845

2846 2847
  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
    SRetention rentension = {0};
C
Cary Xu 已提交
2848 2849
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
2850 2851 2852 2853 2854 2855 2856
    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 已提交
2857
  if (tDecodeI8(&decoder, &pRsp->schemaless) < 0) return -1;
D
dapan1121 已提交
2858 2859
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
2860
  tDecoderClear(&decoder);
D
dapan1121 已提交
2861 2862 2863
  return 0;
}

S
Shengliang Guan 已提交
2864
int32_t tSerializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) {
H
Hongze Cheng 已提交
2865 2866
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2867 2868 2869 2870 2871 2872

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
2873
  tEncoderClear(&encoder);
D
dapan1121 已提交
2874 2875 2876
  return tlen;
}

S
Shengliang Guan 已提交
2877
int32_t tDeserializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) {
H
Hongze Cheng 已提交
2878 2879
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2880 2881 2882 2883 2884

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

H
Hongze Cheng 已提交
2885
  tDecoderClear(&decoder);
D
dapan1121 已提交
2886 2887 2888
  return 0;
}

S
Shengliang Guan 已提交
2889
int32_t tSerializeSUserIndexRsp(void *buf, int32_t bufLen, const SUserIndexRsp *pRsp) {
H
Hongze Cheng 已提交
2890 2891
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901

  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 已提交
2902
  tEncoderClear(&encoder);
D
dapan1121 已提交
2903 2904 2905
  return tlen;
}

S
Shengliang Guan 已提交
2906
int32_t tDeserializeSUserIndexRsp(void *buf, int32_t bufLen, SUserIndexRsp *pRsp) {
H
Hongze Cheng 已提交
2907 2908
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
2909 2910 2911 2912 2913 2914 2915 2916 2917

  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 已提交
2918
  tDecoderClear(&decoder);
D
dapan1121 已提交
2919 2920 2921
  return 0;
}

D
dapan1121 已提交
2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
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 已提交
2947
int32_t tSerializeSTableIndexInfo(SEncoder *pEncoder, STableIndexInfo *pInfo) {
D
dapan1121 已提交
2948 2949 2950 2951 2952 2953 2954
  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 已提交
2955
  if (tEncodeSEpSet(pEncoder, &pInfo->epSet) < 0) return -1;
D
dapan1121 已提交
2956 2957 2958 2959 2960 2961 2962 2963 2964
  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 已提交
2965 2966
  if (tEncodeCStr(&encoder, pRsp->tbName) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->dbFName) < 0) return -1;
D
dapan1121 已提交
2967
  if (tEncodeU64(&encoder, pRsp->suid) < 0) return -1;
D
dapan1121 已提交
2968
  if (tEncodeI32(&encoder, pRsp->version) < 0) return -1;
D
dapan1121 已提交
2969 2970 2971 2972
  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 已提交
2973
      STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pRsp->pIndex, i);
D
dapan1121 已提交
2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
      if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
    }
  }
  tEndEncode(&encoder);

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

2984 2985 2986 2987 2988 2989 2990
void tFreeSerializeSTableIndexRsp(STableIndexRsp *pRsp) {
  if (pRsp->pIndex != NULL) {
    taosArrayDestroy(pRsp->pIndex);
    pRsp->pIndex = NULL;
  }
}

D
dapan1121 已提交
2991 2992 2993 2994 2995 2996 2997 2998
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 已提交
2999
  if (tDecodeSEpSet(pDecoder, &pInfo->epSet) < 0) return -1;
D
dapan1121 已提交
3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
  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 已提交
3010 3011
  if (tDecodeCStrTo(&decoder, pRsp->tbName) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->dbFName) < 0) return -1;
D
dapan1121 已提交
3012
  if (tDecodeU64(&decoder, &pRsp->suid) < 0) return -1;
D
dapan1121 已提交
3013
  if (tDecodeI32(&decoder, &pRsp->version) < 0) return -1;
D
dapan1121 已提交
3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033
  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;
}

3034
void tFreeSTableIndexInfo(void *info) {
D
dapan1121 已提交
3035 3036 3037 3038
  if (NULL == info) {
    return;
  }

3039
  STableIndexInfo *pInfo = (STableIndexInfo *)info;
D
dapan1121 已提交
3040 3041 3042

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

X
Xiaoyu Wang 已提交
3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
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;
}

L
Liu Jicong 已提交
3069
int32_t tEncodeSVariablesInfo(SEncoder *pEncoder, SVariablesInfo *pInfo) {
D
dapan1121 已提交
3070 3071 3072 3073 3074
  if (tEncodeCStr(pEncoder, pInfo->name) < 0) return -1;
  if (tEncodeCStr(pEncoder, pInfo->value) < 0) return -1;
  return 0;
}

L
Liu Jicong 已提交
3075
int32_t tDecodeSVariablesInfo(SDecoder *pDecoder, SVariablesInfo *pInfo) {
D
dapan1121 已提交
3076 3077 3078 3079 3080
  if (tDecodeCStrTo(pDecoder, pInfo->name) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pInfo->value) < 0) return -1;
  return 0;
}

L
Liu Jicong 已提交
3081
int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *pRsp) {
D
dapan1121 已提交
3082 3083 3084 3085 3086 3087 3088
  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) {
L
Liu Jicong 已提交
3089
    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
D
dapan1121 已提交
3090 3091 3092 3093 3094 3095 3096 3097 3098
    if (tEncodeSVariablesInfo(&encoder, pInfo) < 0) return -1;
  }
  tEndEncode(&encoder);

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

L
Liu Jicong 已提交
3099
int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp *pRsp) {
D
dapan1121 已提交
3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120
  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;
}

L
Liu Jicong 已提交
3121
void tFreeSShowVariablesRsp(SShowVariablesRsp *pRsp) {
D
dapan1121 已提交
3122 3123 3124
  if (NULL == pRsp) {
    return;
  }
L
Liu Jicong 已提交
3125

D
dapan1121 已提交
3126 3127 3128
  taosArrayDestroy(pRsp->variables);
}

S
Shengliang Guan 已提交
3129
int32_t tSerializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
H
Hongze Cheng 已提交
3130 3131
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3132 3133 3134 3135 3136 3137

  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 已提交
3138
    if (tEncodeBinary(&encoder, pReq->payload, pReq->payloadLen) < 0) return -1;
S
Shengliang Guan 已提交
3139 3140 3141 3142
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3143
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3144 3145 3146 3147
  return tlen;
}

int32_t tDeserializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
H
Hongze Cheng 已提交
3148 3149
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3150 3151 3152 3153 3154 3155

  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) {
wafwerar's avatar
wafwerar 已提交
3156
    pReq->payload = taosMemoryMalloc(pReq->payloadLen);
S
Shengliang Guan 已提交
3157 3158 3159 3160 3161
    if (pReq->payload == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->payload) < 0) return -1;
  }

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3162
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3163 3164 3165
  return 0;
}

wafwerar's avatar
wafwerar 已提交
3166
void tFreeSShowReq(SShowReq *pReq) { taosMemoryFreeClear(pReq->payload); }
3167 3168

int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
H
Hongze Cheng 已提交
3169 3170
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
3171 3172 3173

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
H
Haojun Liao 已提交
3174 3175
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
3176
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
3177 3178 3179
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3180
  tEncoderClear(&encoder);
3181 3182 3183 3184
  return tlen;
}

int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
H
Hongze Cheng 已提交
3185 3186
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
3187 3188 3189

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
H
Haojun Liao 已提交
3190 3191
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
3192 3193
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;

3194
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3195
  tDecoderClear(&decoder);
3196 3197
  return 0;
}
S
Shengliang Guan 已提交
3198

H
Hongze Cheng 已提交
3199
static int32_t tEncodeSTableMetaRsp(SEncoder *pEncoder, STableMetaRsp *pRsp) {
S
Shengliang Guan 已提交
3200 3201 3202
  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 已提交
3203
  if (tEncodeI64(pEncoder, pRsp->dbId) < 0) return -1;
S
Shengliang Guan 已提交
3204 3205 3206 3207 3208 3209
  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 已提交
3210 3211
  if (tEncodeU64(pEncoder, pRsp->suid) < 0) return -1;
  if (tEncodeU64(pEncoder, pRsp->tuid) < 0) return -1;
S
Shengliang Guan 已提交
3212 3213 3214 3215 3216 3217 3218 3219 3220
  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 已提交
3221
static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
S
Shengliang Guan 已提交
3222 3223 3224
  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 已提交
3225
  if (tDecodeI64(pDecoder, &pRsp->dbId) < 0) return -1;
S
Shengliang Guan 已提交
3226 3227 3228 3229 3230 3231
  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 已提交
3232 3233
  if (tDecodeU64(pDecoder, &pRsp->suid) < 0) return -1;
  if (tDecodeU64(pDecoder, &pRsp->tuid) < 0) return -1;
S
Shengliang Guan 已提交
3234 3235 3236
  if (tDecodeI32(pDecoder, &pRsp->vgId) < 0) return -1;

  int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
3237 3238 3239
  if (totalCols > 0) {
    pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
    if (pRsp->pSchemas == NULL) return -1;
S
Shengliang Guan 已提交
3240

3241 3242 3243 3244 3245 3246
    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 已提交
3247 3248 3249 3250 3251 3252
  }

  return 0;
}

int32_t tSerializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *pRsp) {
H
Hongze Cheng 已提交
3253 3254
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3255 3256 3257 3258 3259 3260

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3261
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3262 3263 3264
  return tlen;
}

D
dapan1121 已提交
3265
int32_t tSerializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) {
H
Hongze Cheng 已提交
3266 3267
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3268 3269 3270

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

D
dapan1121 已提交
3271 3272 3273 3274
  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 已提交
3275 3276
    if (tEncodeSTableMetaRsp(&encoder, pMetaRsp) < 0) return -1;
  }
D
dapan1121 已提交
3277 3278

  int32_t numOfIndex = taosArrayGetSize(pRsp->pIndexRsp);
C
Cary Xu 已提交
3279
  if (tEncodeI32(&encoder, numOfIndex) < 0) return -1;
D
dapan1121 已提交
3280
  for (int32_t i = 0; i < numOfIndex; ++i) {
D
dapan1121 已提交
3281 3282 3283 3284 3285 3286 3287
    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 已提交
3288 3289 3290 3291
    for (int32_t i = 0; i < num; ++i) {
      STableIndexInfo *pInfo = (STableIndexInfo *)taosArrayGet(pIndexRsp->pIndex, i);
      if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
    }
D
dapan1121 已提交
3292 3293
  }

S
Shengliang Guan 已提交
3294 3295 3296
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3297
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3298 3299 3300 3301
  return tlen;
}

int32_t tDeserializeSTableMetaRsp(void *buf, int32_t bufLen, STableMetaRsp *pRsp) {
H
Hongze Cheng 已提交
3302 3303
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3304 3305 3306 3307 3308

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

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3309
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3310 3311 3312
  return 0;
}

D
dapan1121 已提交
3313
int32_t tDeserializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) {
H
Hongze Cheng 已提交
3314 3315
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3316 3317 3318

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

D
dapan1121 已提交
3319
  int32_t numOfMeta = 0;
D
dapan1121 已提交
3320 3321 3322
  if (tDecodeI32(&decoder, &numOfMeta) < 0) return -1;
  pRsp->pMetaRsp = taosArrayInit(numOfMeta, sizeof(STableMetaRsp));
  if (pRsp->pMetaRsp == NULL) {
S
Shengliang Guan 已提交
3323 3324 3325 3326
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

D
dapan1121 已提交
3327
  for (int32_t i = 0; i < numOfMeta; ++i) {
S
Shengliang Guan 已提交
3328 3329
    STableMetaRsp tableMetaRsp = {0};
    if (tDecodeSTableMetaRsp(&decoder, &tableMetaRsp) < 0) return -1;
D
dapan1121 已提交
3330 3331 3332
    taosArrayPush(pRsp->pMetaRsp, &tableMetaRsp);
  }

D
dapan1121 已提交
3333
  int32_t numOfIndex = 0;
D
dapan1121 已提交
3334 3335 3336 3337 3338 3339
  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 已提交
3340
  }
D
dapan1121 已提交
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362

  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 已提交
3363
  }
C
Cary Xu 已提交
3364

S
Shengliang Guan 已提交
3365 3366
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3367
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3368 3369 3370
  return 0;
}

3371
void tFreeSTableMetaRsp(void *pRsp) {
D
dapan1121 已提交
3372 3373 3374
  if (NULL == pRsp) {
    return;
  }
3375 3376

  taosMemoryFreeClear(((STableMetaRsp *)pRsp)->pSchemas);
D
dapan1121 已提交
3377
}
S
Shengliang Guan 已提交
3378

D
dapan1121 已提交
3379 3380 3381 3382 3383 3384 3385 3386 3387 3388
void tFreeSTableIndexRsp(void *info) {
  if (NULL == info) {
    return;
  }

  STableIndexRsp *pInfo = (STableIndexRsp *)info;

  taosArrayDestroyEx(pInfo->pIndex, tFreeSTableIndexInfo);
}

D
dapan1121 已提交
3389
void tFreeSSTbHbRsp(SSTbHbRsp *pRsp) {
D
dapan1121 已提交
3390 3391 3392
  int32_t numOfMeta = taosArrayGetSize(pRsp->pMetaRsp);
  for (int32_t i = 0; i < numOfMeta; ++i) {
    STableMetaRsp *pMetaRsp = taosArrayGet(pRsp->pMetaRsp, i);
S
Shengliang Guan 已提交
3393 3394 3395
    tFreeSTableMetaRsp(pMetaRsp);
  }

D
dapan1121 已提交
3396 3397 3398 3399 3400 3401 3402 3403 3404
  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 已提交
3405 3406 3407
}

int32_t tSerializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
H
Hongze Cheng 已提交
3408 3409
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3410 3411 3412 3413 3414 3415 3416

  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 已提交
3417
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3418 3419 3420 3421
  return tlen;
}

int32_t tDeserializeSShowRsp(void *buf, int32_t bufLen, SShowRsp *pRsp) {
H
Hongze Cheng 已提交
3422 3423
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3424 3425 3426 3427 3428 3429

  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 已提交
3430
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3431 3432 3433 3434 3435 3436 3437
  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 已提交
3438 3439 3440 3441
  if (buf != NULL) {
    buf = (char *)buf + headLen;
    bufLen -= headLen;
  }
S
Shengliang Guan 已提交
3442

H
Hongze Cheng 已提交
3443 3444
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3445 3446 3447 3448 3449 3450 3451

  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 已提交
3452
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3453 3454 3455 3456 3457 3458 3459 3460

  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 已提交
3461 3462 3463
}

int32_t tDeserializeSTableInfoReq(void *buf, int32_t bufLen, STableInfoReq *pReq) {
S
Shengliang Guan 已提交
3464 3465 3466 3467 3468
  int32_t headLen = sizeof(SMsgHead);

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

H
Hongze Cheng 已提交
3470 3471
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);
S
Shengliang Guan 已提交
3472 3473 3474 3475 3476 3477

  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 已提交
3478
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3479 3480
  return 0;
}
S
Shengliang Guan 已提交
3481

S
Shengliang Guan 已提交
3482
int32_t tSerializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *pReq) {
H
Hongze Cheng 已提交
3483 3484
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3485 3486 3487 3488 3489 3490 3491

  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 已提交
3492
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3493 3494 3495 3496
  return tlen;
}

int32_t tDeserializeSMDropTopicReq(void *buf, int32_t bufLen, SMDropTopicReq *pReq) {
H
Hongze Cheng 已提交
3497 3498
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3499 3500 3501 3502 3503 3504

  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 已提交
3505
  tDecoderClear(&decoder);
3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
  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);
S
Shengliang Guan 已提交
3535 3536
  return 0;
}
S
Shengliang Guan 已提交
3537

L
Liu Jicong 已提交
3538
int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTopicReq *pReq) {
H
Hongze Cheng 已提交
3539 3540
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3541 3542 3543 3544

  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 已提交
3545
  if (tEncodeI8(&encoder, pReq->subType) < 0) return -1;
L
Liu Jicong 已提交
3546
  if (tEncodeI8(&encoder, pReq->withMeta) < 0) return -1;
L
Liu Jicong 已提交
3547
  if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1;
3548 3549 3550 3551 3552 3553 3554 3555 3556
  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 已提交
3557 3558 3559 3560

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3561
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3562 3563 3564
  return tlen;
}

L
Liu Jicong 已提交
3565
int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicReq *pReq) {
S
Shengliang Guan 已提交
3566
  int32_t sqlLen = 0;
3567
  int32_t astLen = 0;
S
Shengliang Guan 已提交
3568

H
Hongze Cheng 已提交
3569 3570
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3571 3572 3573 3574

  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 已提交
3575
  if (tDecodeI8(&decoder, &pReq->subType) < 0) return -1;
L
Liu Jicong 已提交
3576
  if (tDecodeI8(&decoder, &pReq->withMeta) < 0) return -1;
L
Liu Jicong 已提交
3577
  if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1;
3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
  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 已提交
3589
  if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
3590
  if (sqlLen > 0) {
wafwerar's avatar
wafwerar 已提交
3591
    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
3592 3593 3594 3595
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }

S
Shengliang Guan 已提交
3596 3597
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3598
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3599 3600 3601
  return 0;
}

L
Liu Jicong 已提交
3602
void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
wafwerar's avatar
wafwerar 已提交
3603
  taosMemoryFreeClear(pReq->sql);
3604 3605 3606
  if (TOPIC_SUB_TYPE__COLUMN == pReq->subType) {
    taosMemoryFreeClear(pReq->ast);
  }
S
Shengliang Guan 已提交
3607 3608
}

L
Liu Jicong 已提交
3609
int32_t tSerializeSCMCreateTopicRsp(void *buf, int32_t bufLen, const SCMCreateTopicRsp *pRsp) {
H
Hongze Cheng 已提交
3610 3611
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3612 3613 3614 3615 3616 3617

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3618
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3619 3620 3621
  return tlen;
}

L
Liu Jicong 已提交
3622
int32_t tDeserializeSCMCreateTopicRsp(void *buf, int32_t bufLen, SCMCreateTopicRsp *pRsp) {
H
Hongze Cheng 已提交
3623 3624
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3625 3626 3627 3628 3629

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

H
Hongze Cheng 已提交
3630
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3631 3632
  return 0;
}
S
Shengliang Guan 已提交
3633 3634

int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
H
Hongze Cheng 已提交
3635 3636
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3637 3638

  if (tStartEncode(&encoder) < 0) return -1;
L
Liu Jicong 已提交
3639
  if (tEncodeI8(&encoder, pReq->connType) < 0) return -1;
S
Shengliang Guan 已提交
3640 3641 3642
  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 已提交
3643
  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
3644
  if (tEncodeCStrWithLen(&encoder, pReq->passwd, TSDB_PASSWORD_LEN) < 0) return -1;
S
Shengliang Guan 已提交
3645 3646 3647 3648
  if (tEncodeI64(&encoder, pReq->startTime) < 0) return -1;
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3649
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3650 3651 3652 3653
  return tlen;
}

int32_t tDeserializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
H
Hongze Cheng 已提交
3654 3655
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3656 3657

  if (tStartDecode(&decoder) < 0) return -1;
L
Liu Jicong 已提交
3658
  if (tDecodeI8(&decoder, &pReq->connType) < 0) return -1;
S
Shengliang Guan 已提交
3659 3660 3661
  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 已提交
3662 3663
  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->passwd) < 0) return -1;
S
Shengliang Guan 已提交
3664 3665 3666
  if (tDecodeI64(&decoder, &pReq->startTime) < 0) return -1;
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3667
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3668 3669 3670 3671
  return 0;
}

int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
H
Hongze Cheng 已提交
3672 3673
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3674 3675 3676 3677

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->acctId) < 0) return -1;
  if (tEncodeI64(&encoder, pRsp->clusterId) < 0) return -1;
D
dapan1121 已提交
3678
  if (tEncodeU32(&encoder, pRsp->connId) < 0) return -1;
D
dapan 已提交
3679
  if (tEncodeI32(&encoder, pRsp->dnodeNum) < 0) return -1;
S
Shengliang Guan 已提交
3680
  if (tEncodeI8(&encoder, pRsp->superUser) < 0) return -1;
3681
  if (tEncodeI8(&encoder, pRsp->sysInfo) < 0) return -1;
L
Liu Jicong 已提交
3682
  if (tEncodeI8(&encoder, pRsp->connType) < 0) return -1;
S
Shengliang Guan 已提交
3683
  if (tEncodeSEpSet(&encoder, &pRsp->epSet) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
3684
  if (tEncodeI32(&encoder, pRsp->svrTimestamp) < 0) return -1;
D
dapan1121 已提交
3685 3686
  if (tEncodeCStr(&encoder, pRsp->sVer) < 0) return -1;
  if (tEncodeCStr(&encoder, pRsp->sDetailVer) < 0) return -1;
S
Shengliang Guan 已提交
3687 3688 3689
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3690
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3691 3692 3693 3694
  return tlen;
}

int32_t tDeserializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
H
Hongze Cheng 已提交
3695 3696
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3697 3698 3699 3700

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->acctId) < 0) return -1;
  if (tDecodeI64(&decoder, &pRsp->clusterId) < 0) return -1;
D
dapan1121 已提交
3701
  if (tDecodeU32(&decoder, &pRsp->connId) < 0) return -1;
D
dapan 已提交
3702
  if (tDecodeI32(&decoder, &pRsp->dnodeNum) < 0) return -1;
S
Shengliang Guan 已提交
3703
  if (tDecodeI8(&decoder, &pRsp->superUser) < 0) return -1;
3704
  if (tDecodeI8(&decoder, &pRsp->sysInfo) < 0) return -1;
L
Liu Jicong 已提交
3705
  if (tDecodeI8(&decoder, &pRsp->connType) < 0) return -1;
S
Shengliang Guan 已提交
3706
  if (tDecodeSEpSet(&decoder, &pRsp->epSet) < 0) return -1;
dengyihao's avatar
dengyihao 已提交
3707
  if (tDecodeI32(&decoder, &pRsp->svrTimestamp) < 0) return -1;
D
dapan1121 已提交
3708 3709
  if (tDecodeCStrTo(&decoder, pRsp->sVer) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pRsp->sDetailVer) < 0) return -1;
S
Shengliang Guan 已提交
3710 3711
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3712
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3713 3714
  return 0;
}
S
Shengliang Guan 已提交
3715 3716

int32_t tSerializeSMTimerMsg(void *buf, int32_t bufLen, SMTimerReq *pReq) {
H
Hongze Cheng 已提交
3717 3718
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3719 3720 3721 3722 3723 3724

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3725
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3726 3727 3728 3729
  return tlen;
}

int32_t tDeserializeSMTimerMsg(void *buf, int32_t bufLen, SMTimerReq *pReq) {
H
Hongze Cheng 已提交
3730 3731
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3732 3733 3734 3735 3736

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

H
Hongze Cheng 已提交
3737
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3738 3739
  return 0;
}
S
Shengliang Guan 已提交
3740

H
Hongze Cheng 已提交
3741
int32_t tEncodeSReplica(SEncoder *pEncoder, SReplica *pReplica) {
S
Shengliang Guan 已提交
3742 3743 3744 3745 3746 3747
  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 已提交
3748
int32_t tDecodeSReplica(SDecoder *pDecoder, SReplica *pReplica) {
S
Shengliang Guan 已提交
3749 3750 3751 3752 3753 3754
  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;
}

S
Shengliang Guan 已提交
3755
int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pReq) {
H
Hongze Cheng 已提交
3756 3757
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3758 3759 3760 3761

  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 已提交
3762
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
S
Shengliang Guan 已提交
3763
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
S
Shengliang Guan 已提交
3764 3765 3766 3767
  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;
3768
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
3769 3770 3771 3772 3773 3774
  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;
3775
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
3776 3777 3778
  if (tEncodeU32(&encoder, pReq->hashBegin) < 0) return -1;
  if (tEncodeU32(&encoder, pReq->hashEnd) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->hashMethod) < 0) return -1;
S
Shengliang Guan 已提交
3779 3780 3781
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
S
Shengliang Guan 已提交
3782
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
3783
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
S
Shengliang Guan 已提交
3784 3785 3786 3787
  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 已提交
3788
    if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
S
Shengliang Guan 已提交
3789
  }
S
sma  
Shengliang Guan 已提交
3790 3791 3792
  if (tEncodeI32(&encoder, pReq->numOfRetensions) < 0) return -1;
  for (int32_t i = 0; i < pReq->numOfRetensions; ++i) {
    SRetention *pRetension = taosArrayGet(pReq->pRetensions, i);
C
Cary Xu 已提交
3793 3794
    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
3795 3796 3797
    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
  }
S
Shengliang Guan 已提交
3798 3799

  if (tEncodeI8(&encoder, pReq->isTsma) < 0) return -1;
C
Cary Xu 已提交
3800 3801 3802 3803
  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;
  }
S
Shengliang Guan 已提交
3804
  if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
L
Liu Jicong 已提交
3805
  if (tEncodeI64(&encoder, pReq->walRetentionSize) < 0) return -1;
S
Shengliang Guan 已提交
3806
  if (tEncodeI32(&encoder, pReq->walRollPeriod) < 0) return -1;
L
Liu Jicong 已提交
3807
  if (tEncodeI64(&encoder, pReq->walSegmentSize) < 0) return -1;
3808
  if (tEncodeI16(&encoder, pReq->sstTrigger) < 0) return -1;
3809 3810
  if (tEncodeI16(&encoder, pReq->hashPrefix) < 0) return -1;
  if (tEncodeI16(&encoder, pReq->hashSuffix) < 0) return -1;
3811
  if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1;
S
Shengliang Guan 已提交
3812 3813 3814
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
C
Cary Xu 已提交
3815

S
Shengliang Guan 已提交
3816 3817 3818
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3819
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3820 3821 3822 3823
  return tlen;
}

int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pReq) {
H
Hongze Cheng 已提交
3824 3825
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3826 3827 3828 3829

  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 已提交
3830
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
S
Shengliang Guan 已提交
3831
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
S
Shengliang Guan 已提交
3832 3833 3834 3835
  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;
3836
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
3837 3838 3839 3840 3841 3842
  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;
3843
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
D
dapan1121 已提交
3844 3845 3846
  if (tDecodeU32(&decoder, &pReq->hashBegin) < 0) return -1;
  if (tDecodeU32(&decoder, &pReq->hashEnd) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->hashMethod) < 0) return -1;
S
Shengliang Guan 已提交
3847 3848 3849
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
S
Shengliang Guan 已提交
3850
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
3851
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
S
Shengliang Guan 已提交
3852 3853 3854 3855
  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 已提交
3856
    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
S
Shengliang Guan 已提交
3857
  }
3858
  if (tDecodeI32(&decoder, &pReq->numOfRetensions) < 0) return -1;
S
sma  
Shengliang Guan 已提交
3859 3860 3861 3862 3863 3864 3865 3866
  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};
C
Cary Xu 已提交
3867 3868
    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
S
sma  
Shengliang Guan 已提交
3869 3870 3871 3872 3873 3874 3875 3876
    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;
    }
  }

S
Shengliang Guan 已提交
3877
  if (tDecodeI8(&decoder, &pReq->isTsma) < 0) return -1;
C
Cary Xu 已提交
3878
  if (pReq->isTsma) {
C
Cary Xu 已提交
3879
    if (tDecodeBinary(&decoder, (uint8_t **)&pReq->pTsma, NULL) < 0) return -1;
C
Cary Xu 已提交
3880
  }
S
Shengliang Guan 已提交
3881

S
Shengliang Guan 已提交
3882
  if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
L
Liu Jicong 已提交
3883
  if (tDecodeI64(&decoder, &pReq->walRetentionSize) < 0) return -1;
S
Shengliang Guan 已提交
3884
  if (tDecodeI32(&decoder, &pReq->walRollPeriod) < 0) return -1;
L
Liu Jicong 已提交
3885
  if (tDecodeI64(&decoder, &pReq->walSegmentSize) < 0) return -1;
3886
  if (tDecodeI16(&decoder, &pReq->sstTrigger) < 0) return -1;
3887 3888
  if (tDecodeI16(&decoder, &pReq->hashPrefix) < 0) return -1;
  if (tDecodeI16(&decoder, &pReq->hashSuffix) < 0) return -1;
3889
  if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1;
S
Shengliang Guan 已提交
3890 3891 3892
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
S
Shengliang Guan 已提交
3893

S
Shengliang Guan 已提交
3894
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
3895
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3896 3897 3898
  return 0;
}

S
sma  
Shengliang Guan 已提交
3899 3900 3901
int32_t tFreeSCreateVnodeReq(SCreateVnodeReq *pReq) {
  taosArrayDestroy(pReq->pRetensions);
  pReq->pRetensions = NULL;
3902
  return 0;
S
sma  
Shengliang Guan 已提交
3903 3904
}

S
Shengliang Guan 已提交
3905
int32_t tSerializeSDropVnodeReq(void *buf, int32_t bufLen, SDropVnodeReq *pReq) {
H
Hongze Cheng 已提交
3906 3907
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3908 3909 3910 3911

  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 已提交
3912
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
S
Shengliang Guan 已提交
3913
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
3914 3915 3916
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
S
Shengliang Guan 已提交
3917 3918 3919
  tEndEncode(&encoder);

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

int32_t tDeserializeSDropVnodeReq(void *buf, int32_t bufLen, SDropVnodeReq *pReq) {
H
Hongze Cheng 已提交
3925 3926
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3927 3928 3929 3930

  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 已提交
3931
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
S
Shengliang Guan 已提交
3932
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
3933 3934 3935
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
S
Shengliang Guan 已提交
3936 3937
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3938
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3939 3940 3941
  return 0;
}

S
Shengliang Guan 已提交
3942
int32_t tSerializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
H
Hongze Cheng 已提交
3943 3944
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3945 3946 3947 3948

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
3949 3950 3951
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
  }
S
Shengliang Guan 已提交
3952 3953 3954
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
3955
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
3956 3957 3958 3959
  return tlen;
}

int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
H
Hongze Cheng 已提交
3960 3961
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
3962 3963 3964 3965

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
S
Shengliang Guan 已提交
3966 3967 3968
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
S
Shengliang Guan 已提交
3969 3970
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
3971
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
3972 3973 3974
  return 0;
}

S
Shengliang Guan 已提交
3975
int32_t tSerializeSAlterVnodeConfigReq(void *buf, int32_t bufLen, SAlterVnodeConfigReq *pReq) {
H
Hongze Cheng 已提交
3976 3977
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
3978 3979 3980

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
S
Shengliang Guan 已提交
3981 3982 3983
  if (tEncodeI32(&encoder, pReq->buffer) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pageSize) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->pages) < 0) return -1;
3984
  if (tEncodeI32(&encoder, pReq->cacheLastSize) < 0) return -1;
3985
  if (tEncodeI32(&encoder, pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
3986 3987 3988
  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
3989
  if (tEncodeI32(&encoder, pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
3990 3991
  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
3992
  if (tEncodeI8(&encoder, pReq->cacheLast) < 0) return -1;
S
Shengliang Guan 已提交
3993 3994
  for (int32_t i = 0; i < 8; ++i) {
    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
S
Shengliang Guan 已提交
3995 3996 3997 3998
  }
  tEndEncode(&encoder);

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

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

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
S
Shengliang Guan 已提交
4009 4010 4011
  if (tDecodeI32(&decoder, &pReq->buffer) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pageSize) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->pages) < 0) return -1;
4012
  if (tDecodeI32(&decoder, &pReq->cacheLastSize) < 0) return -1;
S
Shengliang Guan 已提交
4013
  if (tDecodeI32(&decoder, &pReq->daysPerFile) < 0) return -1;
S
Shengliang Guan 已提交
4014 4015 4016
  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
4017
  if (tDecodeI32(&decoder, &pReq->walFsyncPeriod) < 0) return -1;
S
Shengliang Guan 已提交
4018 4019
  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
4020
  if (tDecodeI8(&decoder, &pReq->cacheLast) < 0) return -1;
S
Shengliang Guan 已提交
4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }

  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;
S
Shengliang Guan 已提交
4060
  if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
4061
  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
S
Shengliang Guan 已提交
4062 4063 4064 4065
  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
    SReplica *pReplica = &pReq->replicas[i];
    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
  }
S
Shengliang Guan 已提交
4066 4067 4068
  for (int32_t i = 0; i < 8; ++i) {
    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
  }
4069

S
Shengliang Guan 已提交
4070
  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4071
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4072 4073 4074
  return 0;
}

S
Shengliang Guan 已提交
4075
int32_t tSerializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
H
Hongze Cheng 已提交
4076 4077
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4078 4079

  if (tStartEncode(&encoder) < 0) return -1;
X
Xiaoyu Wang 已提交
4080
  if (tEncodeCStr(&encoder, pReq->queryStrId) < 0) return -1;
S
Shengliang Guan 已提交
4081 4082 4083
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4084
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4085 4086 4087 4088
  return tlen;
}

int32_t tDeserializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
H
Hongze Cheng 已提交
4089 4090
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4091 4092

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

H
Hongze Cheng 已提交
4096
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4097 4098 4099 4100
  return 0;
}

int32_t tSerializeSKillConnReq(void *buf, int32_t bufLen, SKillConnReq *pReq) {
H
Hongze Cheng 已提交
4101 4102
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4103 4104

  if (tStartEncode(&encoder) < 0) return -1;
D
dapan1121 已提交
4105
  if (tEncodeU32(&encoder, pReq->connId) < 0) return -1;
S
Shengliang Guan 已提交
4106 4107 4108
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4109
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4110 4111 4112 4113
  return tlen;
}

int32_t tDeserializeSKillConnReq(void *buf, int32_t bufLen, SKillConnReq *pReq) {
H
Hongze Cheng 已提交
4114 4115
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4116 4117

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

H
Hongze Cheng 已提交
4121
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4122
  return 0;
S
Shengliang Guan 已提交
4123 4124
}

S
Shengliang Guan 已提交
4125
int32_t tSerializeSKillTransReq(void *buf, int32_t bufLen, SKillTransReq *pReq) {
H
Hongze Cheng 已提交
4126 4127
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4128 4129 4130 4131 4132 4133

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

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4134
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4135 4136 4137 4138
  return tlen;
}

int32_t tDeserializeSKillTransReq(void *buf, int32_t bufLen, SKillTransReq *pReq) {
H
Hongze Cheng 已提交
4139 4140
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4141 4142 4143 4144 4145

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

H
Hongze Cheng 已提交
4146
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4147 4148 4149
  return 0;
}

X
Xiaoyu Wang 已提交
4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232
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;
}

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;
}

4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257
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;
}

S
Shengliang Guan 已提交
4258
int32_t tSerializeSDCreateMnodeReq(void *buf, int32_t bufLen, SDCreateMnodeReq *pReq) {
H
Hongze Cheng 已提交
4259 4260
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4261 4262 4263 4264 4265 4266 4267 4268 4269 4270

  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 已提交
4271
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4272 4273 4274 4275
  return tlen;
}

int32_t tDeserializeSDCreateMnodeReq(void *buf, int32_t bufLen, SDCreateMnodeReq *pReq) {
H
Hongze Cheng 已提交
4276 4277
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4278 4279 4280 4281 4282 4283 4284 4285 4286

  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 已提交
4287
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4288 4289 4290 4291
  return 0;
}

int32_t tSerializeSAuthReq(void *buf, int32_t bufLen, SAuthReq *pReq) {
H
Hongze Cheng 已提交
4292 4293
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4294 4295 4296 4297 4298 4299 4300 4301 4302 4303

  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 已提交
4304
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4305 4306 4307 4308
  return tlen;
}

int32_t tDeserializeSAuthReq(void *buf, int32_t bufLen, SAuthReq *pReq) {
H
Hongze Cheng 已提交
4309 4310
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4311 4312 4313 4314 4315 4316 4317 4318 4319

  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 已提交
4320
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4321 4322
  return 0;
}
L
Liu Jicong 已提交
4323

S
Shengliang Guan 已提交
4324
int32_t tSerializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
H
Hongze Cheng 已提交
4325 4326
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
S
Shengliang Guan 已提交
4327 4328 4329

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeI32(&encoder, pRsp->statusCode) < 0) return -1;
S
Shengliang Guan 已提交
4330
  if (tEncodeCStr(&encoder, pRsp->details) < 0) return -1;
S
Shengliang Guan 已提交
4331 4332 4333 4334

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4335
  tEncoderClear(&encoder);
S
Shengliang Guan 已提交
4336 4337 4338 4339
  return tlen;
}

int32_t tDeserializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
H
Hongze Cheng 已提交
4340 4341
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
S
Shengliang Guan 已提交
4342 4343 4344

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->statusCode) < 0) return -1;
S
Shengliang Guan 已提交
4345
  if (tDecodeCStrTo(&decoder, pRsp->details) < 0) return -1;
S
Shengliang Guan 已提交
4346 4347

  tEndDecode(&decoder);
H
Hongze Cheng 已提交
4348
  tDecoderClear(&decoder);
S
Shengliang Guan 已提交
4349 4350
  return 0;
}
H
Hongze Cheng 已提交
4351
int32_t tEncodeSMqOffset(SEncoder *encoder, const SMqOffset *pOffset) {
L
Liu Jicong 已提交
4352 4353 4354 4355 4356 4357 4358
  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 已提交
4359
int32_t tDecodeSMqOffset(SDecoder *decoder, SMqOffset *pOffset) {
L
Liu Jicong 已提交
4360 4361 4362 4363 4364 4365 4366
  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 已提交
4367
int32_t tEncodeSMqCMCommitOffsetReq(SEncoder *encoder, const SMqCMCommitOffsetReq *pReq) {
L
Liu Jicong 已提交
4368 4369 4370 4371 4372 4373 4374 4375 4376
  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 已提交
4377
int32_t tDecodeSMqCMCommitOffsetReq(SDecoder *decoder, SMqCMCommitOffsetReq *pReq) {
L
Liu Jicong 已提交
4378
  if (tStartDecode(decoder) < 0) return -1;
L
Liu Jicong 已提交
4379
  if (tDecodeI32(decoder, &pReq->num) < 0) return -1;
H
Hongze Cheng 已提交
4380
  pReq->offsets = (SMqOffset *)tDecoderMalloc(decoder, sizeof(SMqOffset) * pReq->num);
L
Liu Jicong 已提交
4381 4382 4383 4384
  if (pReq->offsets == NULL) return -1;
  for (int32_t i = 0; i < pReq->num; i++) {
    tDecodeSMqOffset(decoder, &pReq->offsets[i]);
  }
L
Liu Jicong 已提交
4385
  tEndDecode(decoder);
L
Liu Jicong 已提交
4386 4387
  return 0;
}
dengyihao's avatar
dengyihao 已提交
4388
int32_t tSerializeSExplainRsp(void *buf, int32_t bufLen, SExplainRsp *pRsp) {
H
Hongze Cheng 已提交
4389 4390
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
4391 4392 4393 4394 4395

  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];
4396 4397
    if (tEncodeDouble(&encoder, info->startupCost) < 0) return -1;
    if (tEncodeDouble(&encoder, info->totalCost) < 0) return -1;
D
dapan1121 已提交
4398
    if (tEncodeU64(&encoder, info->numOfRows) < 0) return -1;
4399 4400
    if (tEncodeU32(&encoder, info->verboseLen) < 0) return -1;
    if (tEncodeBinary(&encoder, info->verboseInfo, info->verboseLen) < 0) return -1;
D
dapan1121 已提交
4401 4402 4403 4404 4405
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4406
  tEncoderClear(&encoder);
D
dapan1121 已提交
4407 4408 4409
  return tlen;
}

dengyihao's avatar
dengyihao 已提交
4410
int32_t tDeserializeSExplainRsp(void *buf, int32_t bufLen, SExplainRsp *pRsp) {
H
Hongze Cheng 已提交
4411 4412
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
4413 4414 4415 4416

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeI32(&decoder, &pRsp->numOfPlans) < 0) return -1;
  if (pRsp->numOfPlans > 0) {
4417
    pRsp->subplanInfo = taosMemoryCalloc(pRsp->numOfPlans, sizeof(SExplainExecInfo));
D
dapan1121 已提交
4418 4419 4420
    if (pRsp->subplanInfo == NULL) return -1;
  }
  for (int32_t i = 0; i < pRsp->numOfPlans; ++i) {
4421 4422
    if (tDecodeDouble(&decoder, &pRsp->subplanInfo[i].startupCost) < 0) return -1;
    if (tDecodeDouble(&decoder, &pRsp->subplanInfo[i].totalCost) < 0) return -1;
D
dapan1121 已提交
4423
    if (tDecodeU64(&decoder, &pRsp->subplanInfo[i].numOfRows) < 0) return -1;
4424
    if (tDecodeU32(&decoder, &pRsp->subplanInfo[i].verboseLen) < 0) return -1;
4425
    if (tDecodeBinaryAlloc(&decoder, &pRsp->subplanInfo[i].verboseInfo, NULL) < 0) return -1;
D
dapan1121 已提交
4426 4427 4428 4429
  }

  tEndDecode(&decoder);

H
Hongze Cheng 已提交
4430
  tDecoderClear(&decoder);
D
dapan1121 已提交
4431 4432 4433
  return 0;
}

4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
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);
}

D
dapan1121 已提交
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498
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);
H
Hongze Cheng 已提交
4499

D
dapan1121 已提交
4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510
    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 已提交
4511
    if (tDecodeBinaryAlloc(&decoder, &msg.msg, NULL) < 0) return -1;
D
dapan1121 已提交
4512 4513
    if (NULL == taosArrayPush(pReq->pMsgs, &msg)) return -1;
  }
H
Hongze Cheng 已提交
4514

D
dapan1121 已提交
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 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555
  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);
H
Hongze Cheng 已提交
4556

D
dapan1121 已提交
4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571
    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;
  }
H
Hongze Cheng 已提交
4572

D
dapan1121 已提交
4573 4574 4575 4576 4577 4578
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604
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;
H
Hongze Cheng 已提交
4605

D
dapan1121 已提交
4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635
  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;
H
Hongze Cheng 已提交
4636

D
dapan1121 已提交
4637 4638 4639 4640 4641 4642
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665
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;
H
Hongze Cheng 已提交
4666
  if (tEncodeBinary(&encoder, (uint8_t *)pReq->msg, pReq->msgLen) < 0) return -1;
D
dapan1121 已提交
4667 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

  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;
H
Hongze Cheng 已提交
4706 4707
  if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, NULL) < 0) return -1;

D
dapan1121 已提交
4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

void tFreeSSubQueryMsg(SSubQueryMsg *pReq) {
  if (NULL == pReq) {
    return;
  }

  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->msg);
}

D
dapan1121 已提交
4723 4724 4725 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 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768
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;
H
Hongze Cheng 已提交
4769

D
dapan1121 已提交
4770 4771 4772 4773 4774 4775
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818
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);
D
dapan1121 已提交
4819
    pHead->vgId = htonl(pReq->head.vgId);
D
dapan1121 已提交
4820 4821 4822 4823 4824 4825 4826 4827 4828 4829
    pHead->contLen = htonl(tlen + headLen);
  }

  return tlen + headLen;
}

int32_t tDeserializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);

  SMsgHead *pHead = buf;
D
dapan1121 已提交
4830 4831
  pHead->vgId = pReq->head.vgId;
  pHead->contLen = pReq->head.contLen;
D
dapan1121 已提交
4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845

  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;
H
Hongze Cheng 已提交
4846

D
dapan1121 已提交
4847 4848 4849 4850 4851 4852
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900
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;
H
Hongze Cheng 已提交
4901

D
dapan1121 已提交
4902 4903 4904 4905 4906 4907
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937
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;
H
Hongze Cheng 已提交
4938

D
dapan1121 已提交
4939 4940 4941 4942 4943 4944
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
  return 0;
}

D
dapan1121 已提交
4945 4946 4947 4948 4949 4950 4951
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 已提交
4952 4953
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
4954 4955

  if (tStartEncode(&encoder) < 0) return -1;
L
Liu Jicong 已提交
4956 4957
  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->epId.nodeId) < 0) return -1;
D
dapan1121 已提交
4958
  if (tEncodeU16(&encoder, pReq->epId.ep.port) < 0) return -1;
L
Liu Jicong 已提交
4959
  if (tEncodeCStr(&encoder, pReq->epId.ep.fqdn) < 0) return -1;
D
dapan1121 已提交
4960 4961
  if (pReq->taskAction) {
    int32_t num = taosArrayGetSize(pReq->taskAction);
L
Liu Jicong 已提交
4962
    if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
4963 4964
    for (int32_t i = 0; i < num; ++i) {
      STaskAction *action = taosArrayGet(pReq->taskAction, i);
L
Liu Jicong 已提交
4965 4966 4967
      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 已提交
4968 4969
    }
  } else {
L
Liu Jicong 已提交
4970
    if (tEncodeI32(&encoder, 0) < 0) return -1;
D
dapan1121 已提交
4971 4972 4973 4974
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
4975
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
4976

D
dapan1121 已提交
4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992
  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 已提交
4993 4994
  SDecoder decoder = {0};
  tDecoderInit(&decoder, (char *)buf + headLen, bufLen - headLen);
D
dapan1121 已提交
4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017

  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 已提交
5018
  tDecoderClear(&decoder);
D
dapan1121 已提交
5019 5020 5021 5022 5023 5024
  return 0;
}

void tFreeSSchedulerHbReq(SSchedulerHbReq *pReq) { taosArrayDestroy(pReq->taskAction); }

int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
H
Hongze Cheng 已提交
5025 5026
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
D
dapan1121 已提交
5027 5028

  if (tStartEncode(&encoder) < 0) return -1;
L
Liu Jicong 已提交
5029
  if (tEncodeI32(&encoder, pRsp->epId.nodeId) < 0) return -1;
D
dapan1121 已提交
5030
  if (tEncodeU16(&encoder, pRsp->epId.ep.port) < 0) return -1;
L
Liu Jicong 已提交
5031
  if (tEncodeCStr(&encoder, pRsp->epId.ep.fqdn) < 0) return -1;
D
dapan1121 已提交
5032 5033
  if (pRsp->taskStatus) {
    int32_t num = taosArrayGetSize(pRsp->taskStatus);
L
Liu Jicong 已提交
5034
    if (tEncodeI32(&encoder, num) < 0) return -1;
D
dapan1121 已提交
5035 5036
    for (int32_t i = 0; i < num; ++i) {
      STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
L
Liu Jicong 已提交
5037 5038 5039
      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 已提交
5040
      if (tEncodeI32(&encoder, status->execId) < 0) return -1;
L
Liu Jicong 已提交
5041
      if (tEncodeI8(&encoder, status->status) < 0) return -1;
D
dapan1121 已提交
5042 5043
    }
  } else {
L
Liu Jicong 已提交
5044
    if (tEncodeI32(&encoder, 0) < 0) return -1;
D
dapan1121 已提交
5045 5046 5047 5048
  }
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5049
  tEncoderClear(&encoder);
D
dapan1121 已提交
5050 5051 5052 5053
  return tlen;
}

int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
H
Hongze Cheng 已提交
5054 5055
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
D
dapan1121 已提交
5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070

  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 已提交
5071
      if (tDecodeI32(&decoder, &status.execId) < 0) return -1;
D
dapan1121 已提交
5072 5073 5074 5075 5076 5077 5078 5079
      if (tDecodeI8(&decoder, &status.status) < 0) return -1;
      taosArrayPush(pRsp->taskStatus, &status);
    }
  } else {
    pRsp->taskStatus = NULL;
  }
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
5080
  tDecoderClear(&decoder);
D
dapan1121 已提交
5081 5082 5083 5084 5085
  return 0;
}

void tFreeSSchedulerHbRsp(SSchedulerHbRsp *pRsp) { taosArrayDestroy(pRsp->taskStatus); }

D
dapan 已提交
5086
int32_t tSerializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5087 5088
  // SEncoder encoder = {0};
  // tEncoderInit(&encoder, buf, bufLen);
D
dapan 已提交
5089

H
Hongze Cheng 已提交
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101
  // 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 已提交
5102

H
Hongze Cheng 已提交
5103
  // int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5104
  // tEncoderClear(&encoder);
H
Hongze Cheng 已提交
5105 5106
  // reture tlen;
  return 0;
D
dapan 已提交
5107 5108 5109
}

int32_t tDeserializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5110
  // SDecoder  decoder = {0};
H
Hongze Cheng 已提交
5111
  // int32_t num = 0;
H
Hongze Cheng 已提交
5112
  // tDecoderInit(&decoder, buf, bufLen);
D
dapan 已提交
5113

H
Hongze Cheng 已提交
5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127
  // 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 已提交
5128

H
Hongze Cheng 已提交
5129
  // tDecoderClear(&decoder);
D
dapan 已提交
5130 5131 5132
  return 0;
}

H
Hongze Cheng 已提交
5133
int tEncodeSVCreateTbBatchRsp(SEncoder *pCoder, const SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5134 5135 5136 5137 5138 5139 5140 5141 5142
  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 已提交
5143 5144
  }

H
Hongze Cheng 已提交
5145 5146 5147 5148 5149
  tEndEncode(pCoder);

  return 0;
}

H
Hongze Cheng 已提交
5150
int tDecodeSVCreateTbBatchRsp(SDecoder *pCoder, SVCreateTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5151 5152 5153
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
H
Hongze Cheng 已提交
5154
  pRsp->pRsps = (SVCreateTbRsp *)tDecoderMalloc(pCoder, sizeof(*pRsp->pRsps) * pRsp->nRsps);
H
Hongze Cheng 已提交
5155 5156 5157 5158 5159
  for (int32_t i = 0; i < pRsp->nRsps; i++) {
    if (tDecodeSVCreateTbRsp(pCoder, pRsp->pRsps + i) < 0) return -1;
  }

  tEndDecode(pCoder);
D
dapan 已提交
5160 5161 5162
  return 0;
}

5163 5164 5165 5166 5167
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 已提交
5168
  if (tEncodeI32(pCoder, pSma->dstVgId) < 0) return -1;
5169 5170 5171 5172 5173
  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;
C
Cary Xu 已提交
5174 5175
  if (tEncodeI64(pCoder, pSma->dstTbUid) < 0) return -1;
  if (tEncodeCStr(pCoder, pSma->dstTbName) < 0) return -1;
5176 5177 5178 5179 5180 5181 5182 5183 5184
  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;
  }
C
Cary Xu 已提交
5185

C
Cary Xu 已提交
5186 5187
  tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow);
  tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag);
C
Cary Xu 已提交
5188

5189 5190 5191
  return 0;
}

C
Cary Xu 已提交
5192
int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) {
5193 5194 5195 5196
  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;
C
Cary Xu 已提交
5197
  if (tDecodeI32(pCoder, &pSma->dstVgId) < 0) return -1;
C
Cary Xu 已提交
5198
  if (tDecodeCStrTo(pCoder, pSma->indexName) < 0) return -1;
5199 5200 5201 5202
  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;
C
Cary Xu 已提交
5203
  if (tDecodeI64(pCoder, &pSma->dstTbUid) < 0) return -1;
C
Cary Xu 已提交
5204 5205 5206 5207 5208 5209
  if (deepCopy) {
    if (tDecodeCStrAlloc(pCoder, &pSma->dstTbName) < 0) return -1;
  } else {
    if (tDecodeCStr(pCoder, &pSma->dstTbName) < 0) return -1;
  }

5210 5211 5212 5213
  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 已提交
5214 5215 5216 5217 5218
    if (deepCopy) {
      if (tDecodeCStrAlloc(pCoder, &pSma->expr) < 0) return -1;
    } else {
      if (tDecodeCStr(pCoder, &pSma->expr) < 0) return -1;
    }
5219 5220 5221 5222
  } else {
    pSma->expr = NULL;
  }
  if (pSma->tagsFilterLen > 0) {
C
Cary Xu 已提交
5223 5224 5225 5226 5227
    if (deepCopy) {
      if (tDecodeCStrAlloc(pCoder, &pSma->tagsFilter) < 0) return -1;
    } else {
      if (tDecodeCStr(pCoder, &pSma->tagsFilter) < 0) return -1;
    }
5228 5229 5230
  } else {
    pSma->tagsFilter = NULL;
  }
C
Cary Xu 已提交
5231 5232 5233
  // only needed in dstVgroup
  tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow);
  tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag);
5234 5235 5236 5237 5238 5239

  return 0;
}

int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;
C
Cary Xu 已提交
5240

5241
  tEncodeTSma(pCoder, pReq);
C
Cary Xu 已提交
5242

5243 5244
  tEndEncode(pCoder);
  return 0;
C
Cary Xu 已提交
5245
}
D
dapan1121 已提交
5246

5247 5248 5249
int32_t tDecodeSVCreateTSmaReq(SDecoder *pCoder, SVCreateTSmaReq *pReq) {
  if (tStartDecode(pCoder) < 0) return -1;

C
Cary Xu 已提交
5250
  tDecodeTSma(pCoder, pReq, false);
D
dapan1121 已提交
5251

5252 5253
  tEndDecode(pCoder);
  return 0;
C
Cary Xu 已提交
5254 5255
}

5256 5257
int32_t tEncodeSVDropTSmaReq(SEncoder *pCoder, const SVDropTSmaReq *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;
C
Cary Xu 已提交
5258

5259 5260
  if (tEncodeI64(pCoder, pReq->indexUid) < 0) return -1;
  if (tEncodeCStr(pCoder, pReq->indexName) < 0) return -1;
C
Cary Xu 已提交
5261

5262 5263
  tEndEncode(pCoder);
  return 0;
C
Cary Xu 已提交
5264 5265
}

5266 5267 5268 5269
int32_t tDecodeSVDropTSmaReq(SDecoder *pCoder, SVDropTSmaReq *pReq) {
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI64(pCoder, &pReq->indexUid) < 0) return -1;
C
Cary Xu 已提交
5270
  if (tDecodeCStrTo(pCoder, pReq->indexName) < 0) return -1;
5271 5272 5273

  tEndDecode(pCoder);
  return 0;
C
Cary Xu 已提交
5274
}
L
Liu Jicong 已提交
5275

D
dapan1121 已提交
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291
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;
5292
  if (tEncodeBinary(&encoder, pReq->msg, pReq->phyLen) < 0) return -1;
D
dapan1121 已提交
5293 5294 5295 5296
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
C
Cary Xu 已提交
5297

D
dapan1121 已提交
5298 5299 5300 5301
  if (buf != NULL) {
    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
    pHead->vgId = htonl(pReq->header.vgId);
    pHead->contLen = htonl(tlen + headLen);
C
Cary Xu 已提交
5302 5303
  }

D
dapan1121 已提交
5304
  return tlen + headLen;
C
Cary Xu 已提交
5305 5306
}

D
dapan1121 已提交
5307 5308
int32_t tDeserializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
  int32_t headLen = sizeof(SMsgHead);
C
Cary Xu 已提交
5309

D
dapan1121 已提交
5310 5311 5312
  SMsgHead *pHead = buf;
  pHead->vgId = pReq->header.vgId;
  pHead->contLen = pReq->header.contLen;
C
Cary Xu 已提交
5313

D
dapan1121 已提交
5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324
  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;
5325 5326 5327
  uint64_t msgLen = 0;
  if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, &msgLen) < 0) return -1;
  pReq->phyLen = msgLen;
D
dapan1121 已提交
5328 5329 5330 5331

  tEndDecode(&decoder);

  tDecoderClear(&decoder);
C
Cary Xu 已提交
5332 5333 5334
  return 0;
}

C
Cary Xu 已提交
5335
int32_t tEncodeSVDeleteRsp(SEncoder *pCoder, const SVDeleteRsp *pReq) {
C
Cary Xu 已提交
5336 5337 5338 5339 5340 5341 5342 5343
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI64(pCoder, pReq->affectedRows) < 0) return -1;

  tEndEncode(pCoder);
  return 0;
}

C
Cary Xu 已提交
5344
int32_t tDecodeSVDeleteRsp(SDecoder *pCoder, SVDeleteRsp *pReq) {
C
Cary Xu 已提交
5345 5346 5347 5348 5349 5350 5351 5352
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI64(pCoder, &pReq->affectedRows) < 0) return -1;

  tEndDecode(pCoder);
  return 0;
}

L
Liu Jicong 已提交
5353
int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {
L
Liu Jicong 已提交
5354 5355 5356 5357 5358
  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 已提交
5359 5360
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
L
Liu Jicong 已提交
5361 5362 5363

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
L
Liu Jicong 已提交
5364
  if (tEncodeCStr(&encoder, pReq->sourceDB) < 0) return -1;
L
Liu Jicong 已提交
5365
  if (tEncodeCStr(&encoder, pReq->targetStbFullName) < 0) return -1;
L
Liu Jicong 已提交
5366
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
5367
  if (tEncodeI8(&encoder, pReq->fillHistory) < 0) return -1;
L
Liu Jicong 已提交
5368 5369
  if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
  if (tEncodeI32(&encoder, astLen) < 0) return -1;
L
Liu Jicong 已提交
5370
  if (tEncodeI8(&encoder, pReq->triggerType) < 0) return -1;
5371
  if (tEncodeI64(&encoder, pReq->maxDelay) < 0) return -1;
L
Liu Jicong 已提交
5372
  if (tEncodeI64(&encoder, pReq->watermark) < 0) return -1;
5373
  if (tEncodeI8(&encoder, pReq->igExpired) < 0) return -1;
L
Liu Jicong 已提交
5374 5375
  if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
  if (astLen > 0 && tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
5376 5377 5378 5379 5380 5381 5382 5383
  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;
  }
L
Liu Jicong 已提交
5384

L
Liu Jicong 已提交
5385 5386 5387
  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
H
Hongze Cheng 已提交
5388
  tEncoderClear(&encoder);
L
Liu Jicong 已提交
5389 5390 5391 5392
  return tlen;
}

int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStreamReq *pReq) {
L
Liu Jicong 已提交
5393 5394 5395
  int32_t sqlLen = 0;
  int32_t astLen = 0;

H
Hongze Cheng 已提交
5396 5397
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);
L
Liu Jicong 已提交
5398 5399 5400

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
L
Liu Jicong 已提交
5401
  if (tDecodeCStrTo(&decoder, pReq->sourceDB) < 0) return -1;
L
Liu Jicong 已提交
5402
  if (tDecodeCStrTo(&decoder, pReq->targetStbFullName) < 0) return -1;
L
Liu Jicong 已提交
5403
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
5404
  if (tDecodeI8(&decoder, &pReq->fillHistory) < 0) return -1;
L
Liu Jicong 已提交
5405 5406
  if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
  if (tDecodeI32(&decoder, &astLen) < 0) return -1;
X
Xiaoyu Wang 已提交
5407
  if (tDecodeI8(&decoder, &pReq->triggerType) < 0) return -1;
5408
  if (tDecodeI64(&decoder, &pReq->maxDelay) < 0) return -1;
X
Xiaoyu Wang 已提交
5409
  if (tDecodeI64(&decoder, &pReq->watermark) < 0) return -1;
5410
  if (tDecodeI8(&decoder, &pReq->igExpired) < 0) return -1;
L
Liu Jicong 已提交
5411 5412

  if (sqlLen > 0) {
wafwerar's avatar
wafwerar 已提交
5413
    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
L
Liu Jicong 已提交
5414 5415 5416 5417 5418
    if (pReq->sql == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
  }

  if (astLen > 0) {
wafwerar's avatar
wafwerar 已提交
5419
    pReq->ast = taosMemoryCalloc(1, astLen + 1);
L
Liu Jicong 已提交
5420 5421 5422
    if (pReq->ast == NULL) return -1;
    if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
  }
5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444

  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;
      }
    }
  }

L
Liu Jicong 已提交
5445 5446
  tEndDecode(&decoder);

H
Hongze Cheng 已提交
5447
  tDecoderClear(&decoder);
L
Liu Jicong 已提交
5448 5449 5450
  return 0;
}

X
Xiaoyu Wang 已提交
5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479
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;
}

L
Liu Jicong 已提交
5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
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 已提交
5509
void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
X
Xiaoyu Wang 已提交
5510
  taosArrayDestroy(pReq->pTags);
wafwerar's avatar
wafwerar 已提交
5511 5512
  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->ast);
L
Liu Jicong 已提交
5513
}
C
Cary Xu 已提交
5514

H
Hongze Cheng 已提交
5515
int32_t tEncodeSRSmaParam(SEncoder *pCoder, const SRSmaParam *pRSmaParam) {
5516 5517 5518 5519 5520 5521 5522 5523 5524
  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 已提交
5525 5526 5527 5528 5529
  }

  return 0;
}

H
Hongze Cheng 已提交
5530
int32_t tDecodeSRSmaParam(SDecoder *pCoder, SRSmaParam *pRSmaParam) {
5531 5532 5533 5534 5535
  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) {
C
Cary Xu 已提交
5536
      if (tDecodeBinary(pCoder, (uint8_t **)&pRSmaParam->qmsg[i], NULL) < 0) return -1;  // qmsgLen contains len of '\0'
5537 5538 5539
    } else {
      pRSmaParam->qmsg[i] = NULL;
    }
C
Cary Xu 已提交
5540
  }
5541

C
Cary Xu 已提交
5542 5543 5544
  return 0;
}

H
Hongze Cheng 已提交
5545
int tEncodeSVCreateStbReq(SEncoder *pCoder, const SVCreateStbReq *pReq) {
H
Hongze Cheng 已提交
5546 5547 5548 5549 5550
  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;
5551
  if (tEncodeSSchemaWrapper(pCoder, &pReq->schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
5552
  if (tEncodeSSchemaWrapper(pCoder, &pReq->schemaTag) < 0) return -1;
C
Cary Xu 已提交
5553
  if (pReq->rollup) {
C
Cary Xu 已提交
5554
    if (tEncodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
C
Cary Xu 已提交
5555
  }
H
Hongze Cheng 已提交
5556

wmmhello's avatar
wmmhello 已提交
5557 5558 5559 5560 5561
  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 已提交
5562 5563 5564 5565
  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5566
int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
H
Hongze Cheng 已提交
5567 5568 5569 5570 5571
  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;
M
Minglei Jin 已提交
5572 5573
  if (tDecodeSSchemaWrapperEx(pCoder, &pReq->schemaRow) < 0) return -1;
  if (tDecodeSSchemaWrapperEx(pCoder, &pReq->schemaTag) < 0) return -1;
C
Cary Xu 已提交
5574
  if (pReq->rollup) {
C
Cary Xu 已提交
5575
    if (tDecodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
C
Cary Xu 已提交
5576
  }
H
Hongze Cheng 已提交
5577

wmmhello's avatar
wmmhello 已提交
5578 5579 5580 5581 5582
  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 已提交
5583 5584 5585
  tEndDecode(pCoder);
  return 0;
}
5586

H
Hongze Cheng 已提交
5587
int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
H
Hongze Cheng 已提交
5588 5589
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
5590
  if (tEncodeI32v(pCoder, pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
5591
  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
H
Hongze Cheng 已提交
5592 5593 5594 5595
  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 已提交
5596 5597 5598 5599
  if (tEncodeI32(pCoder, pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
    if (tEncodeCStr(pCoder, pReq->comment) < 0) return -1;
  }
H
Hongze Cheng 已提交
5600 5601

  if (pReq->type == TSDB_CHILD_TABLE) {
5602
    if (tEncodeCStr(pCoder, pReq->ctb.stbName) < 0) return -1;
5603
    if (tEncodeU8(pCoder, pReq->ctb.tagNum) < 0) return -1;
H
Hongze Cheng 已提交
5604
    if (tEncodeI64(pCoder, pReq->ctb.suid) < 0) return -1;
C
Cary Xu 已提交
5605
    if (tEncodeTag(pCoder, (const STag *)pReq->ctb.pTag) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
5606 5607
    int32_t len = taosArrayGetSize(pReq->ctb.tagName);
    if (tEncodeI32(pCoder, len) < 0) return -1;
L
Liu Jicong 已提交
5608 5609
    for (int32_t i = 0; i < len; i++) {
      char *name = taosArrayGet(pReq->ctb.tagName, i);
wmmhello's avatar
wmmhello 已提交
5610 5611
      if (tEncodeCStr(pCoder, name) < 0) return -1;
    }
H
Hongze Cheng 已提交
5612
  } else if (pReq->type == TSDB_NORMAL_TABLE) {
5613
    if (tEncodeSSchemaWrapper(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
5614 5615 5616 5617 5618 5619 5620 5621
  } else {
    ASSERT(0);
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5622
int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
H
Hongze Cheng 已提交
5623 5624
  if (tStartDecode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
5625
  if (tDecodeI32v(pCoder, &pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
5626
  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
H
Hongze Cheng 已提交
5627 5628 5629 5630
  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 已提交
5631 5632
  if (tDecodeI32(pCoder, &pReq->commentLen) < 0) return -1;
  if (pReq->commentLen > 0) {
wmmhello's avatar
wmmhello 已提交
5633
    pReq->comment = taosMemoryMalloc(pReq->commentLen + 1);
wmmhello's avatar
wmmhello 已提交
5634 5635 5636
    if (pReq->comment == NULL) return -1;
    if (tDecodeCStrTo(pCoder, pReq->comment) < 0) return -1;
  }
H
Hongze Cheng 已提交
5637 5638

  if (pReq->type == TSDB_CHILD_TABLE) {
5639
    if (tDecodeCStr(pCoder, &pReq->ctb.stbName) < 0) return -1;
5640
    if (tDecodeU8(pCoder, &pReq->ctb.tagNum) < 0) return -1;
H
Hongze Cheng 已提交
5641
    if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
C
Cary Xu 已提交
5642
    if (tDecodeTag(pCoder, (STag **)&pReq->ctb.pTag) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
5643 5644 5645
    int32_t len = 0;
    if (tDecodeI32(pCoder, &len) < 0) return -1;
    pReq->ctb.tagName = taosArrayInit(len, TSDB_COL_NAME_LEN);
L
Liu Jicong 已提交
5646 5647 5648
    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 已提交
5649 5650
      char *tmp = NULL;
      if (tDecodeCStr(pCoder, &tmp) < 0) return -1;
G
Ganlin Zhao 已提交
5651
      strncpy(name, tmp, TSDB_COL_NAME_LEN - 1);
wmmhello's avatar
wmmhello 已提交
5652 5653
      taosArrayPush(pReq->ctb.tagName, name);
    }
H
Hongze Cheng 已提交
5654
  } else if (pReq->type == TSDB_NORMAL_TABLE) {
5655
    if (tDecodeSSchemaWrapperEx(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
H
Hongze Cheng 已提交
5656 5657 5658 5659
  } else {
    ASSERT(0);
  }

H
Hongze Cheng 已提交
5660 5661 5662 5663
  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5664
int tEncodeSVCreateTbBatchReq(SEncoder *pCoder, const SVCreateTbBatchReq *pReq) {
H
Hongze Cheng 已提交
5665 5666
  int32_t nReq = taosArrayGetSize(pReq->pArray);

H
Hongze Cheng 已提交
5667 5668
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
5669 5670
  if (tEncodeI32v(pCoder, nReq) < 0) return -1;
  for (int iReq = 0; iReq < nReq; iReq++) {
H
Hongze Cheng 已提交
5671 5672 5673 5674 5675 5676 5677
    if (tEncodeSVCreateTbReq(pCoder, (SVCreateTbReq *)taosArrayGet(pReq->pArray, iReq)) < 0) return -1;
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5678
int tDecodeSVCreateTbBatchReq(SDecoder *pCoder, SVCreateTbBatchReq *pReq) {
H
Hongze Cheng 已提交
5679 5680 5681
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
H
Hongze Cheng 已提交
5682
  pReq->pReqs = (SVCreateTbReq *)tDecoderMalloc(pCoder, sizeof(SVCreateTbReq) * pReq->nReqs);
H
Hongze Cheng 已提交
5683 5684 5685 5686 5687
  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 已提交
5688 5689 5690 5691
  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5692
int tEncodeSVCreateTbRsp(SEncoder *pCoder, const SVCreateTbRsp *pRsp) {
H
Hongze Cheng 已提交
5693 5694 5695
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32(pCoder, pRsp->code) < 0) return -1;
5696 5697 5698 5699
  if (tEncodeI32(pCoder, pRsp->pMeta ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta) {
    if (tEncodeSTableMetaRsp(pCoder, pRsp->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
5700 5701 5702 5703 5704

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5705
int tDecodeSVCreateTbRsp(SDecoder *pCoder, SVCreateTbRsp *pRsp) {
H
Hongze Cheng 已提交
5706 5707 5708 5709
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32(pCoder, &pRsp->code) < 0) return -1;

5710 5711 5712 5713 5714 5715 5716 5717 5718
  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 已提交
5719

H
Hongze Cheng 已提交
5720 5721 5722 5723
  tEndDecode(pCoder);
  return 0;
}

L
Liu Jicong 已提交
5724
void tFreeSVCreateTbRsp(void *param) {
D
dapan1121 已提交
5725 5726 5727
  if (NULL == param) {
    return;
  }
L
Liu Jicong 已提交
5728 5729

  SVCreateTbRsp *pRsp = (SVCreateTbRsp *)param;
D
dapan1121 已提交
5730 5731 5732 5733
  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
5734 5735
}

H
Hongze Cheng 已提交
5736
// TDMT_VND_DROP_TABLE =================
H
Hongze Cheng 已提交
5737
static int32_t tEncodeSVDropTbReq(SEncoder *pCoder, const SVDropTbReq *pReq) {
H
Hongze Cheng 已提交
5738 5739 5740
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
5741
  if (tEncodeU64(pCoder, pReq->suid) < 0) return -1;
X
Xiaoyu Wang 已提交
5742
  if (tEncodeI8(pCoder, pReq->igNotExists) < 0) return -1;
H
Hongze Cheng 已提交
5743 5744 5745 5746 5747

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5748
static int32_t tDecodeSVDropTbReq(SDecoder *pCoder, SVDropTbReq *pReq) {
H
Hongze Cheng 已提交
5749 5750 5751
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
5752
  if (tDecodeU64(pCoder, &pReq->suid) < 0) return -1;
X
Xiaoyu Wang 已提交
5753
  if (tDecodeI8(pCoder, &pReq->igNotExists) < 0) return -1;
H
Hongze Cheng 已提交
5754 5755 5756 5757 5758

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5759
static int32_t tEncodeSVDropTbRsp(SEncoder *pCoder, const SVDropTbRsp *pReq) {
H
Hongze Cheng 已提交
5760 5761 5762 5763 5764 5765 5766 5767
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32(pCoder, pReq->code) < 0) return -1;

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5768
static int32_t tDecodeSVDropTbRsp(SDecoder *pCoder, SVDropTbRsp *pReq) {
H
Hongze Cheng 已提交
5769 5770 5771 5772 5773 5774 5775 5776
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32(pCoder, &pReq->code) < 0) return -1;

  tEndDecode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
5777
int32_t tEncodeSVDropTbBatchReq(SEncoder *pCoder, const SVDropTbBatchReq *pReq) {
H
Hongze Cheng 已提交
5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792
  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 已提交
5793
int32_t tDecodeSVDropTbBatchReq(SDecoder *pCoder, SVDropTbBatchReq *pReq) {
H
Hongze Cheng 已提交
5794 5795 5796
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
H
Hongze Cheng 已提交
5797
  pReq->pReqs = (SVDropTbReq *)tDecoderMalloc(pCoder, sizeof(SVDropTbReq) * pReq->nReqs);
H
Hongze Cheng 已提交
5798 5799 5800 5801 5802 5803 5804 5805 5806
  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 已提交
5807
int32_t tEncodeSVDropTbBatchRsp(SEncoder *pCoder, const SVDropTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819
  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 已提交
5820
int32_t tDecodeSVDropTbBatchRsp(SDecoder *pCoder, SVDropTbBatchRsp *pRsp) {
H
Hongze Cheng 已提交
5821 5822 5823
  if (tStartDecode(pCoder) < 0) return -1;

  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
H
Hongze Cheng 已提交
5824
  pRsp->pRsps = (SVDropTbRsp *)tDecoderMalloc(pCoder, sizeof(SVDropTbRsp) * pRsp->nRsps);
H
Hongze Cheng 已提交
5825 5826 5827 5828 5829 5830 5831 5832 5833
  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 已提交
5834
int32_t tEncodeSVDropStbReq(SEncoder *pCoder, const SVDropStbReq *pReq) {
H
Hongze Cheng 已提交
5835 5836 5837 5838 5839 5840 5841 5842 5843
  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 已提交
5844
int32_t tDecodeSVDropStbReq(SDecoder *pCoder, SVDropStbReq *pReq) {
H
Hongze Cheng 已提交
5845 5846 5847 5848 5849
  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 已提交
5850 5851
  tEndDecode(pCoder);
  return 0;
5852
}
H
Hongze Cheng 已提交
5853

H
Hongze Cheng 已提交
5854
static int32_t tEncodeSVSubmitBlk(SEncoder *pCoder, const SVSubmitBlk *pBlock, int32_t flags) {
H
Hongze Cheng 已提交
5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869
  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 已提交
5870
static int32_t tDecodeSVSubmitBlk(SDecoder *pCoder, SVSubmitBlk *pBlock, int32_t flags) {
H
Hongze Cheng 已提交
5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885
  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 已提交
5886
int32_t tEncodeSVSubmitReq(SEncoder *pCoder, const SVSubmitReq *pReq) {
H
Hongze Cheng 已提交
5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900
  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 已提交
5901
int32_t tDecodeSVSubmitReq(SDecoder *pCoder, SVSubmitReq *pReq) {
H
Hongze Cheng 已提交
5902 5903 5904 5905
  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 已提交
5906
  pReq->pBlocks = tDecoderMalloc(pCoder, sizeof(SVSubmitBlk) * pReq->nBlocks);
H
Hongze Cheng 已提交
5907 5908 5909 5910 5911 5912 5913
  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;
L
Liu Jicong 已提交
5914
}
H
Hongze Cheng 已提交
5915 5916 5917 5918

static int32_t tEncodeSSubmitBlkRsp(SEncoder *pEncoder, const SSubmitBlkRsp *pBlock) {
  if (tStartEncode(pEncoder) < 0) return -1;

H
Hongze Cheng 已提交
5919
  if (tEncodeI32(pEncoder, pBlock->code) < 0) return -1;
D
dapan1121 已提交
5920
  if (tEncodeI64(pEncoder, pBlock->uid) < 0) return -1;
D
dapan1121 已提交
5921 5922 5923 5924 5925
  if (pBlock->tblFName) {
    if (tEncodeCStr(pEncoder, pBlock->tblFName) < 0) return -1;
  } else {
    if (tEncodeCStr(pEncoder, "") < 0) return -1;
  }
H
Hongze Cheng 已提交
5926 5927
  if (tEncodeI32v(pEncoder, pBlock->numOfRows) < 0) return -1;
  if (tEncodeI32v(pEncoder, pBlock->affectedRows) < 0) return -1;
H
Hongze Cheng 已提交
5928
  if (tEncodeI64v(pEncoder, pBlock->sver) < 0) return -1;
5929 5930 5931 5932
  if (tEncodeI32(pEncoder, pBlock->pMeta ? 1 : 0) < 0) return -1;
  if (pBlock->pMeta) {
    if (tEncodeSTableMetaRsp(pEncoder, pBlock->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
5933 5934 5935 5936 5937 5938 5939 5940

  tEndEncode(pEncoder);
  return 0;
}

static int32_t tDecodeSSubmitBlkRsp(SDecoder *pDecoder, SSubmitBlkRsp *pBlock) {
  if (tStartDecode(pDecoder) < 0) return -1;

H
Hongze Cheng 已提交
5941
  if (tDecodeI32(pDecoder, &pBlock->code) < 0) return -1;
D
dapan1121 已提交
5942 5943 5944 5945
  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 已提交
5946 5947
  if (tDecodeI32v(pDecoder, &pBlock->numOfRows) < 0) return -1;
  if (tDecodeI32v(pDecoder, &pBlock->affectedRows) < 0) return -1;
H
Hongze Cheng 已提交
5948
  if (tDecodeI64v(pDecoder, &pBlock->sver) < 0) return -1;
L
Liu Jicong 已提交
5949

5950 5951 5952 5953 5954 5955 5956 5957 5958
  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 已提交
5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985

  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 已提交
5986
  pRsp->pBlocks = taosMemoryCalloc(pRsp->nBlocks, sizeof(*pRsp->pBlocks));
H
Hongze Cheng 已提交
5987 5988 5989 5990 5991
  if (pRsp->pBlocks == NULL) return -1;
  for (int32_t iBlock = 0; iBlock < pRsp->nBlocks; iBlock++) {
    if (tDecodeSSubmitBlkRsp(pDecoder, pRsp->pBlocks + iBlock) < 0) return -1;
  }

H
Hongze Cheng 已提交
5992
  tEndDecode(pDecoder);
D
dapan 已提交
5993
  tDecoderClear(pDecoder);
H
Hongze Cheng 已提交
5994 5995
  return 0;
}
D
dapan 已提交
5996

L
Liu Jicong 已提交
5997
void tFreeSSubmitBlkRsp(void *param) {
5998 5999 6000
  if (NULL == param) {
    return;
  }
L
Liu Jicong 已提交
6001 6002

  SSubmitBlkRsp *pRsp = (SSubmitBlkRsp *)param;
6003 6004 6005 6006 6007 6008 6009 6010

  taosMemoryFree(pRsp->tblFName);
  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
}

D
dapan 已提交
6011 6012 6013 6014 6015 6016 6017
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);
6018 6019
      tFreeSTableMetaRsp(sRsp->pMeta);
      taosMemoryFree(sRsp->pMeta);
D
dapan 已提交
6020 6021 6022 6023 6024 6025 6026
    }

    taosMemoryFree(pRsp->pBlocks);
  }

  taosMemoryFree(pRsp);
}
H
Hongze Cheng 已提交
6027 6028 6029 6030 6031 6032

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;
6033
  if (tEncodeI32(pEncoder, pReq->colId) < 0) return -1;
H
Hongze Cheng 已提交
6034 6035
  switch (pReq->action) {
    case TSDB_ALTER_TABLE_ADD_COLUMN:
H
fix  
Hongze Cheng 已提交
6036
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6037
      if (tEncodeI8(pEncoder, pReq->type) < 0) return -1;
H
Hongze Cheng 已提交
6038
      if (tEncodeI8(pEncoder, pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
6039 6040 6041
      if (tEncodeI32v(pEncoder, pReq->bytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_DROP_COLUMN:
H
fix  
Hongze Cheng 已提交
6042
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6043 6044
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
H
fix  
Hongze Cheng 已提交
6045
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
6046
      if (tEncodeI8(pEncoder, pReq->colModType) < 0) return -1;
H
Hongze Cheng 已提交
6047 6048 6049
      if (tEncodeI32v(pEncoder, pReq->colModBytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
H
fix  
Hongze Cheng 已提交
6050
      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6051 6052 6053 6054 6055
      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;
wmmhello's avatar
wmmhello 已提交
6056
      if (tEncodeI8(pEncoder, pReq->tagType) < 0) return -1;
H
Hongze Cheng 已提交
6057 6058 6059 6060 6061 6062 6063 6064 6065
      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 已提交
6066 6067
      if (tEncodeI32v(pEncoder, pReq->newCommentLen) < 0) return -1;
      if (pReq->newCommentLen > 0) {
H
Hongze Cheng 已提交
6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083
        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;
6084
  if (tDecodeI32(pDecoder, &pReq->colId) < 0) return -1;
H
Hongze Cheng 已提交
6085 6086
  switch (pReq->action) {
    case TSDB_ALTER_TABLE_ADD_COLUMN:
H
fix  
Hongze Cheng 已提交
6087
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6088
      if (tDecodeI8(pDecoder, &pReq->type) < 0) return -1;
H
Hongze Cheng 已提交
6089
      if (tDecodeI8(pDecoder, &pReq->flags) < 0) return -1;
H
Hongze Cheng 已提交
6090 6091 6092
      if (tDecodeI32v(pDecoder, &pReq->bytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_DROP_COLUMN:
H
fix  
Hongze Cheng 已提交
6093
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6094 6095
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
H
fix  
Hongze Cheng 已提交
6096
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
6097
      if (tDecodeI8(pDecoder, &pReq->colModType) < 0) return -1;
H
Hongze Cheng 已提交
6098 6099 6100
      if (tDecodeI32v(pDecoder, &pReq->colModBytes) < 0) return -1;
      break;
    case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
H
fix  
Hongze Cheng 已提交
6101
      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
H
Hongze Cheng 已提交
6102 6103 6104 6105 6106
      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;
wmmhello's avatar
wmmhello 已提交
6107
      if (tDecodeI8(pDecoder, &pReq->tagType) < 0) return -1;
H
Hongze Cheng 已提交
6108 6109 6110 6111 6112 6113 6114 6115 6116
      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 已提交
6117 6118
      if (tDecodeI32v(pDecoder, &pReq->newCommentLen) < 0) return -1;
      if (pReq->newCommentLen > 0) {
H
Hongze Cheng 已提交
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132
        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 已提交
6133 6134 6135 6136
  if (tEncodeI32(pEncoder, pRsp->pMeta ? 1 : 0) < 0) return -1;
  if (pRsp->pMeta) {
    if (tEncodeSTableMetaRsp(pEncoder, pRsp->pMeta) < 0) return -1;
  }
H
Hongze Cheng 已提交
6137 6138 6139 6140 6141
  tEndEncode(pEncoder);
  return 0;
}

int32_t tDecodeSVAlterTbRsp(SDecoder *pDecoder, SVAlterTbRsp *pRsp) {
D
dapan1121 已提交
6142
  int32_t meta = 0;
H
Hongze Cheng 已提交
6143 6144
  if (tStartDecode(pDecoder) < 0) return -1;
  if (tDecodeI32(pDecoder, &pRsp->code) < 0) return -1;
D
dapan1121 已提交
6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155
  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) {
C
Cary Xu 已提交
6156
  int32_t  meta = 0;
D
dapan1121 已提交
6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191
  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 已提交
6192 6193 6194
  tEndDecode(pDecoder);
  return 0;
}
D
dapan1121 已提交
6195 6196

int32_t tDeserializeSMAlterStbRsp(void *buf, int32_t bufLen, SMAlterStbRsp *pRsp) {
C
Cary Xu 已提交
6197
  int32_t  meta = 0;
D
dapan1121 已提交
6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212
  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;
}

C
Cary Xu 已提交
6213
void tFreeSMAlterStbRsp(SMAlterStbRsp *pRsp) {
D
dapan1121 已提交
6214 6215 6216 6217 6218 6219 6220 6221 6222
  if (NULL == pRsp) {
    return;
  }

  if (pRsp->pMeta) {
    taosMemoryFree(pRsp->pMeta->pSchemas);
    taosMemoryFree(pRsp->pMeta);
  }
}
6223

6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274
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);
  }
}

L
Liu Jicong 已提交
6275 6276
int32_t tEncodeSTqOffsetVal(SEncoder *pEncoder, const STqOffsetVal *pOffsetVal) {
  if (tEncodeI8(pEncoder, pOffsetVal->type) < 0) return -1;
wmmhello's avatar
wmmhello 已提交
6277
  if (pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_META) {
L
Liu Jicong 已提交
6278 6279 6280 6281 6282 6283
    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;
  } else if (pOffsetVal->type < 0) {
    // do nothing
6284 6285 6286 6287 6288 6289
  } else {
    ASSERT(0);
  }
  return 0;
}

L
Liu Jicong 已提交
6290 6291
int32_t tDecodeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffsetVal) {
  if (tDecodeI8(pDecoder, &pOffsetVal->type) < 0) return -1;
L
Liu Jicong 已提交
6292
  if (pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_META) {
L
Liu Jicong 已提交
6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312
    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 if (pOffsetVal->type < 0) {
    // do nothing
  } else {
    ASSERT(0);
  }
  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 已提交
6313
    snprintf(buf, maxLen, "offset(log) ver:%" PRId64, pVal->version);
L
Liu Jicong 已提交
6314
  } else if (pVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pVal->type == TMQ_OFFSET__SNAPSHOT_META) {
S
Shengliang Guan 已提交
6315
    snprintf(buf, maxLen, "offset(ss data) uid:%" PRId64 ", ts:%" PRId64, pVal->uid, pVal->ts);
6316 6317 6318
  } else {
    ASSERT(0);
  }
L
Liu Jicong 已提交
6319 6320 6321 6322 6323 6324 6325 6326 6327 6328
  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) {
wmmhello's avatar
wmmhello 已提交
6329
      return pLeft->uid == pRight->uid;
L
Liu Jicong 已提交
6330 6331 6332 6333 6334
    } else {
      ASSERT(0);
      /*ASSERT(pLeft->type == TMQ_OFFSET__RESET_NONE || pLeft->type == TMQ_OFFSET__RESET_EARLIEAST ||*/
      /*pLeft->type == TMQ_OFFSET__RESET_LATEST);*/
      /*return true;*/
L
Liu Jicong 已提交
6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347
    }
  }
  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;
6348 6349 6350
  if (tDecodeCStrTo(pDecoder, pOffset->subKey) < 0) return -1;
  return 0;
}
L
Liu Jicong 已提交
6351

6352
int32_t tEncodeSTqCheckInfo(SEncoder *pEncoder, const STqCheckInfo *pInfo) {
L
Liu Jicong 已提交
6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363
  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;
}

6364
int32_t tDecodeSTqCheckInfo(SDecoder *pDecoder, STqCheckInfo *pInfo) {
L
Liu Jicong 已提交
6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377
  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 已提交
6378
void tDeleteSTqCheckInfo(STqCheckInfo *pInfo) { taosArrayDestroy(pInfo->colIdList); }
L
Liu Jicong 已提交
6379

H
Hongze Cheng 已提交
6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391
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;

wmmhello's avatar
wmmhello 已提交
6392
  if (tEncodeCStr(pCoder, pRes->tableFName) < 0) return -1;
6393
  if (tEncodeCStr(pCoder, pRes->tsColName) < 0) return -1;
H
Hongze Cheng 已提交
6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404
  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;
wmmhello's avatar
wmmhello 已提交
6405
    if (pRes->uidList) taosArrayPush(pRes->uidList, &uid);
H
Hongze Cheng 已提交
6406 6407 6408 6409 6410
  }
  if (tDecodeI64(pCoder, &pRes->skey) < 0) return -1;
  if (tDecodeI64(pCoder, &pRes->ekey) < 0) return -1;
  if (tDecodeI64v(pCoder, &pRes->affectedRows) < 0) return -1;

wmmhello's avatar
wmmhello 已提交
6411
  if (tDecodeCStrTo(pCoder, pRes->tableFName) < 0) return -1;
6412
  if (tDecodeCStrTo(pCoder, pRes->tsColName) < 0) return -1;
H
Hongze Cheng 已提交
6413
  return 0;
6414
}
6415

L
Liu Jicong 已提交
6416
int32_t tEncodeSMqMetaRsp(SEncoder *pEncoder, const SMqMetaRsp *pRsp) {
6417
  if (tEncodeSTqOffsetVal(pEncoder, &pRsp->rspOffset) < 0) return -1;
L
Liu Jicong 已提交
6418 6419
  if (tEncodeI16(pEncoder, pRsp->resMsgType)) return -1;
  if (tEncodeBinary(pEncoder, pRsp->metaRsp, pRsp->metaRspLen)) return -1;
6420 6421 6422
  return 0;
}

L
Liu Jicong 已提交
6423
int32_t tDecodeSMqMetaRsp(SDecoder *pDecoder, SMqMetaRsp *pRsp) {
6424 6425
  if (tDecodeSTqOffsetVal(pDecoder, &pRsp->rspOffset) < 0) return -1;
  if (tDecodeI16(pDecoder, &pRsp->resMsgType) < 0) return -1;
L
Liu Jicong 已提交
6426
  if (tDecodeBinaryAlloc(pDecoder, &pRsp->metaRsp, (uint64_t *)&pRsp->metaRspLen) < 0) return -1;
6427 6428 6429
  return 0;
}

L
Liu Jicong 已提交
6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481
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 已提交
6482 6483 6484 6485 6486
        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
          taosMemoryFree(pSW);
          return -1;
        }

L
Liu Jicong 已提交
6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498
        taosArrayPush(pRsp->blockSchema, &pSW);
      }

      if (pRsp->withTbName) {
        char *tbName;
        if (tDecodeCStrAlloc(pDecoder, &tbName) < 0) return -1;
        taosArrayPush(pRsp->blockTbName, &tbName);
      }
    }
  }
  return 0;
}
6499

L
Liu Jicong 已提交
6500 6501
void tDeleteSMqDataRsp(SMqDataRsp *pRsp) {
  taosArrayDestroy(pRsp->blockDataLen);
L
Liu Jicong 已提交
6502
  pRsp->blockDataLen = NULL;
L
Liu Jicong 已提交
6503
  taosArrayDestroyP(pRsp->blockData, (FDelete)taosMemoryFree);
L
Liu Jicong 已提交
6504
  pRsp->blockData = NULL;
L
Liu Jicong 已提交
6505
  taosArrayDestroyP(pRsp->blockSchema, (FDelete)tDeleteSSchemaWrapper);
L
Liu Jicong 已提交
6506
  pRsp->blockSchema = NULL;
L
Liu Jicong 已提交
6507
  taosArrayDestroyP(pRsp->blockTbName, (FDelete)taosMemoryFree);
L
Liu Jicong 已提交
6508
  pRsp->blockTbName = NULL;
L
Liu Jicong 已提交
6509 6510
}

L
Liu Jicong 已提交
6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 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 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570
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 已提交
6571 6572 6573 6574
        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
          taosMemoryFree(pSW);
          return -1;
        }
L
Liu Jicong 已提交
6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599
        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;
}
6600 6601 6602

void tDeleteSTaosxRsp(STaosxRsp *pRsp) {
  taosArrayDestroy(pRsp->blockDataLen);
6603
  pRsp->blockDataLen = NULL;
6604
  taosArrayDestroyP(pRsp->blockData, (FDelete)taosMemoryFree);
6605
  pRsp->blockData = NULL;
6606
  taosArrayDestroyP(pRsp->blockSchema, (FDelete)tDeleteSSchemaWrapper);
6607
  pRsp->blockSchema = NULL;
6608
  taosArrayDestroyP(pRsp->blockTbName, (FDelete)taosMemoryFree);
6609
  pRsp->blockTbName = NULL;
6610 6611

  taosArrayDestroy(pRsp->createTableLen);
6612
  pRsp->createTableLen = NULL;
6613
  taosArrayDestroyP(pRsp->createTableReq, (FDelete)taosMemoryFree);
6614
  pRsp->createTableReq = NULL;
6615 6616
}

6617
int32_t tEncodeSSingleDeleteReq(SEncoder *pEncoder, const SSingleDeleteReq *pReq) {
6618
  if (tEncodeCStr(pEncoder, pReq->tbname) < 0) return -1;
6619 6620 6621 6622 6623
  if (tEncodeI64(pEncoder, pReq->ts) < 0) return -1;
  return 0;
}

int32_t tDecodeSSingleDeleteReq(SDecoder *pDecoder, SSingleDeleteReq *pReq) {
6624
  if (tDecodeCStrTo(pDecoder, pReq->tbname) < 0) return -1;
6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652
  if (tDecodeI64(pDecoder, &pReq->ts) < 0) return -1;
  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 已提交
6653

H
Hongze Cheng 已提交
6654
static int32_t tEncodeSSubmitTbData(SEncoder *pCoder, const SSubmitTbData *pSubmitTbData) {
H
Hongze Cheng 已提交
6655 6656
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
6657 6658 6659 6660 6661 6662 6663 6664 6665
  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 已提交
6666 6667 6668 6669
  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 已提交
6670 6671
  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
    ASSERT(0);  // TODO
H
Hongze Cheng 已提交
6672
  } else {
H
Hongze Cheng 已提交
6673 6674 6675 6676 6677 6678
    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 已提交
6679 6680 6681 6682 6683 6684 6685
    }
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6686
static int32_t tDecodeSSubmitTbData(SDecoder *pCoder, SSubmitTbData *pSubmitTbData) {
H
Hongze Cheng 已提交
6687 6688 6689 6690 6691 6692 6693
  int32_t code = 0;

  if (tStartDecode(pCoder) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709
  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 已提交
6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722
  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 已提交
6723 6724
  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
    ASSERT(0);  // TODO
H
Hongze Cheng 已提交
6725
  } else {
H
Hongze Cheng 已提交
6726 6727
    uint64_t nRow;
    if (tDecodeU64v(pCoder, &nRow) < 0) {
H
Hongze Cheng 已提交
6728 6729 6730 6731
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }

H
Hongze Cheng 已提交
6732
    pSubmitTbData->aRowP = taosArrayInit(nRow, sizeof(SRow *));
H
Hongze Cheng 已提交
6733 6734 6735 6736 6737
    if (pSubmitTbData->aRowP == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }

H
Hongze Cheng 已提交
6738
    for (int32_t iRow = 0; iRow < nRow; ++iRow) {
H
Hongze Cheng 已提交
6739
      SRow **ppRow = taosArrayReserve(pSubmitTbData->aRowP, 1);
H
Hongze Cheng 已提交
6740

H
Hongze Cheng 已提交
6741 6742
      *ppRow = (SRow *)(pCoder->data + pCoder->pos);
      pCoder->pos += (*ppRow)->len;
H
Hongze Cheng 已提交
6743 6744 6745 6746 6747 6748 6749
    }
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
H
Hongze Cheng 已提交
6750
    // TODO: clear
H
Hongze Cheng 已提交
6751 6752 6753 6754 6755 6756 6757
  }
  return 0;
}

int32_t tEncodeSSubmitReq2(SEncoder *pCoder, const SSubmitReq2 *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;

H
Hongze Cheng 已提交
6758 6759 6760
  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 已提交
6761 6762 6763 6764 6765 6766
  }

  tEndEncode(pCoder);
  return 0;
}

H
Hongze Cheng 已提交
6767
int32_t tDecodeSSubmitReq2(SDecoder *pCoder, SSubmitReq2 *pReq) {
H
Hongze Cheng 已提交
6768 6769
  int32_t code = 0;

H
Hongze Cheng 已提交
6770
  memset(pReq, 0, sizeof(*pReq));
H
Hongze Cheng 已提交
6771 6772 6773 6774 6775 6776 6777

  // decode
  if (tStartDecode(pCoder) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

H
Hongze Cheng 已提交
6778 6779
  uint64_t nSubmitTbData;
  if (tDecodeU64v(pCoder, &nSubmitTbData) < 0) {
H
Hongze Cheng 已提交
6780 6781 6782 6783 6784 6785 6786 6787 6788 6789
    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 已提交
6790 6791
  for (uint64_t i = 0; i < nSubmitTbData; i++) {
    if (tDecodeSSubmitTbData(pCoder, taosArrayReserve(pReq->aSubmitTbData, 1)) < 0) {
H
Hongze Cheng 已提交
6792 6793 6794 6795 6796 6797 6798 6799 6800
      code = TSDB_CODE_INVALID_MSG;
      goto _exit;
    }
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
H
Hongze Cheng 已提交
6801 6802 6803 6804
    if (pReq->aSubmitTbData) {
      // todo
      taosArrayDestroy(pReq->aSubmitTbData);
      pReq->aSubmitTbData = NULL;
H
Hongze Cheng 已提交
6805 6806
    }
  }
H
Hongze Cheng 已提交
6807
  return code;
H
Hongze Cheng 已提交
6808 6809
}

X
Xiaoyu Wang 已提交
6810
void destroySSubmitTbData(SSubmitTbData *pTbData) {
H
Hongze Cheng 已提交
6811 6812 6813 6814 6815
  // if (pTbData->isColFmt) {
  //   // todo
  // } else {
  //   taosArrayDestroyP(pTbData->aRowP, (FDelete)tRowDestroy);
  // }
X
Xiaoyu Wang 已提交
6816 6817
}

X
Xiaoyu Wang 已提交
6818
void tDestroySSubmitTbData(SSubmitTbData *pTbData) {
X
Xiaoyu Wang 已提交
6819 6820 6821 6822 6823
  if (NULL == pTbData) {
    return;
  }
  destroySSubmitTbData(pTbData);
  taosMemoryFree(pTbData);
X
Xiaoyu Wang 已提交
6824 6825
}

H
Hongze Cheng 已提交
6826 6827 6828
void tDestroySSubmitReq2(SSubmitReq2 *pReq) {
  if (NULL == pReq) return;

X
Xiaoyu Wang 已提交
6829
  taosArrayDestroyEx(pReq->aSubmitTbData, (FDelete)destroySSubmitTbData);
H
Hongze Cheng 已提交
6830 6831
  taosMemoryFree(pReq);
}
H
Hongze Cheng 已提交
6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932

int32_t tEncodeSSubmitRsp2(SEncoder *pCoder, const SSubmitRsp2 *pRsp) {
  if (tStartEncode(pCoder) < 0) return -1;

  if (tEncodeI32v(pCoder, pRsp->code) < 0) return -1;
  if (tEncodeI32v(pCoder, pRsp->affectedRows) < 0) return -1;
  if (tEncodeI32v(pCoder, taosArrayGetSize(pRsp->aCreateTbRsp)) < 0) return -1;
  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->code) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

  if (tDecodeI32v(pCoder, &pRsp->affectedRows) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

  int32_t nCreateTbRsp;
  if (tDecodeI32v(pCoder, &nCreateTbRsp) < 0) {
    code = TSDB_CODE_INVALID_MSG;
    goto _exit;
  }

  pRsp->aCreateTbRsp = taosArrayInit(nCreateTbRsp, sizeof(SVCreateTbRsp));
  if (pRsp->aCreateTbRsp == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

  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;
    }
  }

  tEndDecode(pCoder);

_exit:
  if (code) {
    if (pRsp->aCreateTbRsp) {
      taosArrayDestroyEx(pRsp->aCreateTbRsp, NULL /* todo */);
    }
  }
  return code;
}

int32_t tCreateSSubmitRsp2(SSubmitRsp2 **ppRsp) {
  int32_t code = 0;

  SSubmitRsp2 *pRsp = (SSubmitRsp2 *)taosMemoryCalloc(1, sizeof(*pRsp));
  if (pRsp == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

  pRsp->aCreateTbRsp = taosArrayInit(16, sizeof(SVCreateTbRsp));
  if (pRsp->aCreateTbRsp == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

_exit:
  if (code) {
    *ppRsp = NULL;
    if (pRsp) {
      if (pRsp->aCreateTbRsp) taosArrayDestroy(pRsp->aCreateTbRsp);
      taosMemoryFree(pRsp);
    }
  } else {
    *ppRsp = pRsp;
  }
  return code;
}

void tDestroySSubmitRsp2(SSubmitRsp2 *pRsp, int32_t flag) {
  if (pRsp) {
    taosArrayDestroyEx(pRsp->aCreateTbRsp, NULL /* TODO: set according to flag */);
    taosMemoryFree(pRsp);
  }
}