tsdbUtil.c 34.8 KB
Newer Older
H
Hongze Cheng 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * 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/>.
 */

#include "tsdb.h"

H
Hongze Cheng 已提交
18 19 20 21
#define TSDB_OFFSET_I32 ((uint8_t)0)
#define TSDB_OFFSET_I16 ((uint8_t)1)
#define TSDB_OFFSET_I8  ((uint8_t)2)

H
Hongze Cheng 已提交
22
// SMapData =======================================================================
H
Hongze Cheng 已提交
23 24 25 26 27
void tMapDataReset(SMapData *pMapData) {
  pMapData->flag = TSDB_OFFSET_I32;
  pMapData->nItem = 0;
  pMapData->nData = 0;
}
H
Hongze Cheng 已提交
28

H
Hongze Cheng 已提交
29
void tMapDataClear(SMapData *pMapData) {
H
Hongze Cheng 已提交
30 31 32 33 34 35
  if (pMapData->pBuf) {
    tsdbFree(pMapData->pBuf);
  } else {
    tsdbFree(pMapData->pOfst);
    tsdbFree(pMapData->pData);
  }
H
Hongze Cheng 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
}

int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)) {
  int32_t code = 0;
  int32_t offset = pMapData->nData;
  int32_t nItem = pMapData->nItem;

  pMapData->nItem++;
  pMapData->nData += tPutItemFn(NULL, pItem);

  // alloc
  code = tsdbRealloc(&pMapData->pOfst, sizeof(int32_t) * pMapData->nItem);
  if (code) goto _err;
  code = tsdbRealloc(&pMapData->pData, pMapData->nData);
  if (code) goto _err;

  // put
H
Hongze Cheng 已提交
53
  ASSERT(pMapData->flag == TSDB_OFFSET_I32);
H
Hongze Cheng 已提交
54 55 56 57 58 59 60
  ((int32_t *)pMapData->pOfst)[nItem] = offset;
  tPutItemFn(pMapData->pData + offset, pItem);

_err:
  return code;
}

H
Hongze Cheng 已提交
61
static FORCE_INLINE int32_t tMapDataGetOffset(SMapData *pMapData, int32_t idx) {
H
Hongze Cheng 已提交
62 63
  switch (pMapData->flag) {
    case TSDB_OFFSET_I8:
H
Hongze Cheng 已提交
64
      return ((int8_t *)pMapData->pOfst)[idx];
H
Hongze Cheng 已提交
65 66
      break;
    case TSDB_OFFSET_I16:
H
Hongze Cheng 已提交
67
      return ((int16_t *)pMapData->pOfst)[idx];
H
Hongze Cheng 已提交
68 69
      break;
    case TSDB_OFFSET_I32:
H
Hongze Cheng 已提交
70
      return ((int32_t *)pMapData->pOfst)[idx];
H
Hongze Cheng 已提交
71 72 73 74
      break;
    default:
      ASSERT(0);
  }
H
Hongze Cheng 已提交
75
}
H
Hongze Cheng 已提交
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *),
                       int32_t (*tItemCmprFn)(const void *, const void *), void *pItem) {
  int32_t code = 0;
  int32_t lidx = 0;
  int32_t ridx = pMapData->nItem - 1;
  int32_t midx;
  int32_t c;

  while (lidx <= ridx) {
    midx = (lidx + ridx) / 2;

    tMapDataGetItemByIdx(pMapData, midx, pItem, tGetItemFn);

    c = tItemCmprFn(pSearchItem, pItem);
    if (c == 0) {
      goto _exit;
    } else if (c < 0) {
      ridx = midx - 1;
    } else {
      lidx = midx + 1;
    }
  }

  code = TSDB_CODE_NOT_FOUND;

_exit:
  return code;
}
H
Hongze Cheng 已提交
104 105 106 107 108 109 110 111

int32_t tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) {
  int32_t code = 0;

  if (idx < 0 || idx >= pMapData->nItem) {
    code = TSDB_CODE_NOT_FOUND;
    goto _exit;
  }
H
Hongze Cheng 已提交
112

H
Hongze Cheng 已提交
113
  tGetItemFn(pMapData->pData + tMapDataGetOffset(pMapData, idx), pItem);
H
Hongze Cheng 已提交
114 115 116 117 118 119 120 121 122 123 124

_exit:
  return code;
}

int32_t tPutMapData(uint8_t *p, SMapData *pMapData) {
  int32_t n = 0;

  ASSERT(pMapData->flag == TSDB_OFFSET_I32);

  n += tPutI32v(p ? p + n : p, pMapData->nItem);
H
Hongze Cheng 已提交
125 126 127 128 129 130 131 132 133 134 135
  if (pMapData->nItem) {
    int32_t maxOffset = tMapDataGetOffset(pMapData, pMapData->nItem - 1);

    if (maxOffset <= INT8_MAX) {
      n += tPutU8(p ? p + n : p, TSDB_OFFSET_I8);
      if (p) {
        for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
          n += tPutI8(p + n, (int8_t)tMapDataGetOffset(pMapData, iItem));
        }
      } else {
        n = n + sizeof(int8_t) * pMapData->nItem;
H
Hongze Cheng 已提交
136
      }
H
Hongze Cheng 已提交
137 138 139 140 141 142 143 144
    } else if (maxOffset <= INT16_MAX) {
      n += tPutU8(p ? p + n : p, TSDB_OFFSET_I16);
      if (p) {
        for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
          n += tPutI16(p + n, (int16_t)tMapDataGetOffset(pMapData, iItem));
        }
      } else {
        n = n + sizeof(int16_t) * pMapData->nItem;
H
Hongze Cheng 已提交
145 146
      }
    } else {
H
Hongze Cheng 已提交
147 148 149 150 151 152 153
      n += tPutU8(p ? p + n : p, TSDB_OFFSET_I32);
      if (p) {
        for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
          n += tPutI32(p + n, tMapDataGetOffset(pMapData, iItem));
        }
      } else {
        n = n + sizeof(int32_t) * pMapData->nItem;
H
Hongze Cheng 已提交
154
      }
H
Hongze Cheng 已提交
155
    }
H
Hongze Cheng 已提交
156
    n += tPutBinary(p ? p + n : p, pMapData->pData, pMapData->nData);
H
Hongze Cheng 已提交
157 158 159 160 161 162 163 164 165
  }

  return n;
}

int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
  int32_t n = 0;

  n += tGetI32v(p + n, &pMapData->nItem);
H
Hongze Cheng 已提交
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
  if (pMapData->nItem) {
    n += tGetU8(p + n, &pMapData->flag);
    pMapData->pOfst = p + n;
    switch (pMapData->flag) {
      case TSDB_OFFSET_I8:
        n = n + sizeof(int8_t) * pMapData->nItem;
        break;
      case TSDB_OFFSET_I16:
        n = n + sizeof(int16_t) * pMapData->nItem;
        break;
      case TSDB_OFFSET_I32:
        n = n + sizeof(int32_t) * pMapData->nItem;
        break;

      default:
        ASSERT(0);
    }
    n += tGetBinary(p + n, &pMapData->pData, &pMapData->nData);
H
Hongze Cheng 已提交
184 185 186 187 188 189
  }

  return n;
}

// Memory =======================================================================
H
Hongze Cheng 已提交
190 191 192 193 194 195 196 197 198 199 200
int32_t tsdbRealloc(uint8_t **ppBuf, int64_t size) {
  int32_t  code = 0;
  int64_t  bsize = 0;
  uint8_t *pBuf;

  if (*ppBuf) {
    bsize = *(int64_t *)((*ppBuf) - sizeof(int64_t));
  }

  if (bsize >= size) goto _exit;

H
Hongze Cheng 已提交
201
  if (bsize == 0) bsize = 64;
H
Hongze Cheng 已提交
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
  while (bsize < size) {
    bsize *= 2;
  }

  pBuf = taosMemoryRealloc(*ppBuf ? (*ppBuf) - sizeof(int64_t) : *ppBuf, bsize + sizeof(int64_t));
  if (pBuf == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

  *(int64_t *)pBuf = bsize;
  *ppBuf = pBuf + sizeof(int64_t);

_exit:
  return code;
}

void tsdbFree(uint8_t *pBuf) {
  if (pBuf) {
    taosMemoryFree(pBuf - sizeof(int64_t));
  }
}

H
Hongze Cheng 已提交
225
// TABLEID =======================================================================
H
Hongze Cheng 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
int32_t tTABLEIDCmprFn(const void *p1, const void *p2) {
  TABLEID *pId1 = (TABLEID *)p1;
  TABLEID *pId2 = (TABLEID *)p2;

  if (pId1->suid < pId2->suid) {
    return -1;
  } else if (pId1->suid > pId2->suid) {
    return 1;
  }

  if (pId1->uid < pId2->uid) {
    return -1;
  } else if (pId1->uid > pId2->uid) {
    return 1;
  }

  return 0;
}

H
Hongze Cheng 已提交
245
// TSDBKEY =======================================================================
H
Hongze Cheng 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
int32_t tsdbKeyCmprFn(const void *p1, const void *p2) {
  TSDBKEY *pKey1 = (TSDBKEY *)p1;
  TSDBKEY *pKey2 = (TSDBKEY *)p2;

  if (pKey1->ts < pKey2->ts) {
    return -1;
  } else if (pKey1->ts > pKey2->ts) {
    return 1;
  }

  if (pKey1->version < pKey2->version) {
    return -1;
  } else if (pKey1->version > pKey2->version) {
    return 1;
  }

  return 0;
H
Hongze Cheng 已提交
263 264
}

H
Hongze Cheng 已提交
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
// TSDBKEY ======================================================
static FORCE_INLINE int32_t tPutTSDBKEY(uint8_t *p, TSDBKEY *pKey) {
  int32_t n = 0;

  n += tPutI64v(p ? p + n : p, pKey->version);
  n += tPutI64(p ? p + n : p, pKey->ts);

  return n;
}

static FORCE_INLINE int32_t tGetTSDBKEY(uint8_t *p, TSDBKEY *pKey) {
  int32_t n = 0;

  n += tGetI64v(p + n, &pKey->version);
  n += tGetI64(p + n, &pKey->ts);

  return n;
}

// SBlockIdx ======================================================
H
Hongze Cheng 已提交
285 286 287 288 289 290 291 292 293
void tBlockIdxReset(SBlockIdx *pBlockIdx) {
  pBlockIdx->minKey = TSKEY_MAX;
  pBlockIdx->maxKey = TSKEY_MIN;
  pBlockIdx->minVersion = VERSION_MAX;
  pBlockIdx->maxVersion = VERSION_MIN;
  pBlockIdx->offset = -1;
  pBlockIdx->size = -1;
}

H
Hongze Cheng 已提交
294 295 296 297 298 299
int32_t tPutBlockIdx(uint8_t *p, void *ph) {
  int32_t    n = 0;
  SBlockIdx *pBlockIdx = (SBlockIdx *)ph;

  n += tPutI64(p ? p + n : p, pBlockIdx->suid);
  n += tPutI64(p ? p + n : p, pBlockIdx->uid);
H
Hongze Cheng 已提交
300 301 302 303
  n += tPutI64(p ? p + n : p, pBlockIdx->minKey);
  n += tPutI64(p ? p + n : p, pBlockIdx->maxKey);
  n += tPutI64v(p ? p + n : p, pBlockIdx->minVersion);
  n += tPutI64v(p ? p + n : p, pBlockIdx->maxVersion);
H
Hongze Cheng 已提交
304 305
  n += tPutI64v(p ? p + n : p, pBlockIdx->offset);
  n += tPutI64v(p ? p + n : p, pBlockIdx->size);
H
Hongze Cheng 已提交
306 307 308 309

  return n;
}

H
Hongze Cheng 已提交
310 311 312
int32_t tGetBlockIdx(uint8_t *p, void *ph) {
  int32_t    n = 0;
  SBlockIdx *pBlockIdx = (SBlockIdx *)ph;
H
Hongze Cheng 已提交
313

H
Hongze Cheng 已提交
314 315
  n += tGetI64(p + n, &pBlockIdx->suid);
  n += tGetI64(p + n, &pBlockIdx->uid);
H
Hongze Cheng 已提交
316 317 318 319
  n += tGetI64(p + n, &pBlockIdx->minKey);
  n += tGetI64(p + n, &pBlockIdx->maxKey);
  n += tGetI64v(p + n, &pBlockIdx->minVersion);
  n += tGetI64v(p + n, &pBlockIdx->maxVersion);
H
Hongze Cheng 已提交
320 321
  n += tGetI64v(p + n, &pBlockIdx->offset);
  n += tGetI64v(p + n, &pBlockIdx->size);
H
Hongze Cheng 已提交
322 323 324 325

  return n;
}

326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
int32_t tCmprBlockIdx(void const *lhs, void const *rhs) {
  SBlockIdx *lBlockIdx = *(SBlockIdx **)lhs;
  SBlockIdx *rBlockIdx = *(SBlockIdx **)rhs;

  if (lBlockIdx->suid < lBlockIdx->suid) {
    return -1;
  } else if (lBlockIdx->suid > lBlockIdx->suid) {
    return 1;
  }

  if (lBlockIdx->uid < lBlockIdx->uid) {
    return -1;
  } else if (lBlockIdx->uid > lBlockIdx->uid) {
    return 1;
  }

  return 0;
}

H
Hongze Cheng 已提交
345
// SBlock ======================================================
H
Hongze Cheng 已提交
346
void tBlockReset(SBlock *pBlock) {
H
Hongze Cheng 已提交
347 348 349 350
  pBlock->minKey = TSDBKEY_MAX;
  pBlock->maxKey = TSDBKEY_MIN;
  pBlock->minVersion = VERSION_MAX;
  pBlock->maxVersion = VERSION_MIN;
H
Hongze Cheng 已提交
351 352
  pBlock->nRow = 0;
  pBlock->last = -1;
H
Hongze Cheng 已提交
353
  pBlock->hasDup = 0;
H
Hongze Cheng 已提交
354
  for (int8_t iSubBlock = 0; iSubBlock < TSDB_MAX_SUBBLOCKS; iSubBlock++) {
H
Hongze Cheng 已提交
355 356
    pBlock->aSubBlock[iSubBlock].nRow = 0;
    pBlock->aSubBlock[iSubBlock].cmprAlg = -1;
H
Hongze Cheng 已提交
357
    pBlock->aSubBlock[iSubBlock].offset = -1;
H
Hongze Cheng 已提交
358
    pBlock->aSubBlock[iSubBlock].vsize = -1;
H
Hongze Cheng 已提交
359 360 361 362 363 364 365 366 367 368 369 370 371
    pBlock->aSubBlock[iSubBlock].ksize = -1;
    pBlock->aSubBlock[iSubBlock].bsize = -1;
    tMapDataReset(&pBlock->aSubBlock->mBlockCol);
  }
  pBlock->nSubBlock = 0;
}

void tBlockClear(SBlock *pBlock) {
  for (int8_t iSubBlock = 0; iSubBlock < TSDB_MAX_SUBBLOCKS; iSubBlock++) {
    tMapDataClear(&pBlock->aSubBlock->mBlockCol);
  }
}

H
Hongze Cheng 已提交
372 373
int32_t tPutBlock(uint8_t *p, void *ph) {
  int32_t n = 0;
H
Hongze Cheng 已提交
374
  SBlock *pBlock = (SBlock *)ph;
H
Hongze Cheng 已提交
375

H
Hongze Cheng 已提交
376 377 378 379
  n += tPutTSDBKEY(p ? p + n : p, &pBlock->minKey);
  n += tPutTSDBKEY(p ? p + n : p, &pBlock->maxKey);
  n += tPutI64v(p ? p + n : p, pBlock->minVersion);
  n += tPutI64v(p ? p + n : p, pBlock->maxVersion);
H
Hongze Cheng 已提交
380 381 382 383 384
  n += tPutI32v(p ? p + n : p, pBlock->nRow);
  n += tPutI8(p ? p + n : p, pBlock->last);
  n += tPutI8(p ? p + n : p, pBlock->hasDup);
  n += tPutI8(p ? p + n : p, pBlock->nSubBlock);
  for (int8_t iSubBlock = 0; iSubBlock < pBlock->nSubBlock; iSubBlock++) {
H
Hongze Cheng 已提交
385 386
    n += tPutI64v(p ? p + n : p, pBlock->aSubBlock[iSubBlock].nRow);
    n += tPutI8(p ? p + n : p, pBlock->aSubBlock[iSubBlock].cmprAlg);
H
Hongze Cheng 已提交
387
    n += tPutI64v(p ? p + n : p, pBlock->aSubBlock[iSubBlock].offset);
H
Hongze Cheng 已提交
388
    n += tPutI64v(p ? p + n : p, pBlock->aSubBlock[iSubBlock].vsize);
H
Hongze Cheng 已提交
389 390 391 392 393
    n += tPutI64v(p ? p + n : p, pBlock->aSubBlock[iSubBlock].ksize);
    n += tPutI64v(p ? p + n : p, pBlock->aSubBlock[iSubBlock].bsize);
    n += tPutMapData(p ? p + n : p, &pBlock->aSubBlock[iSubBlock].mBlockCol);
  }

H
Hongze Cheng 已提交
394 395 396 397 398
  return n;
}

int32_t tGetBlock(uint8_t *p, void *ph) {
  int32_t n = 0;
H
Hongze Cheng 已提交
399
  SBlock *pBlock = (SBlock *)ph;
H
Hongze Cheng 已提交
400

H
Hongze Cheng 已提交
401 402 403 404
  n += tGetTSDBKEY(p + n, &pBlock->minKey);
  n += tGetTSDBKEY(p + n, &pBlock->maxKey);
  n += tGetI64v(p + n, &pBlock->minVersion);
  n += tGetI64v(p + n, &pBlock->maxVersion);
H
Hongze Cheng 已提交
405 406 407 408 409
  n += tGetI32v(p + n, &pBlock->nRow);
  n += tGetI8(p + n, &pBlock->last);
  n += tGetI8(p + n, &pBlock->hasDup);
  n += tGetI8(p + n, &pBlock->nSubBlock);
  for (int8_t iSubBlock = 0; iSubBlock < pBlock->nSubBlock; iSubBlock++) {
H
Hongze Cheng 已提交
410 411
    n += tGetI64v(p + n, &pBlock->aSubBlock[iSubBlock].nRow);
    n += tGetI8(p + n, &pBlock->aSubBlock[iSubBlock].cmprAlg);
H
Hongze Cheng 已提交
412
    n += tGetI64v(p + n, &pBlock->aSubBlock[iSubBlock].offset);
H
Hongze Cheng 已提交
413
    n += tGetI64v(p + n, &pBlock->aSubBlock[iSubBlock].vsize);
H
Hongze Cheng 已提交
414 415 416 417 418
    n += tGetI64v(p + n, &pBlock->aSubBlock[iSubBlock].ksize);
    n += tGetI64v(p + n, &pBlock->aSubBlock[iSubBlock].bsize);
    n += tGetMapData(p + n, &pBlock->aSubBlock[iSubBlock].mBlockCol);
  }

H
Hongze Cheng 已提交
419 420 421
  return n;
}

H
Hongze Cheng 已提交
422 423 424 425 426
int32_t tBlockCmprFn(const void *p1, const void *p2) {
  int32_t c;
  SBlock *pBlock1 = (SBlock *)p1;
  SBlock *pBlock2 = (SBlock *)p2;

H
Hongze Cheng 已提交
427
  if (tsdbKeyCmprFn(&pBlock1->maxKey, &pBlock2->minKey) < 0) {
H
Hongze Cheng 已提交
428
    return -1;
H
Hongze Cheng 已提交
429
  } else if (tsdbKeyCmprFn(&pBlock1->minKey, &pBlock2->maxKey) > 0) {
H
Hongze Cheng 已提交
430
    return 1;
H
Hongze Cheng 已提交
431 432 433 434 435
  }

  return 0;
}

H
Hongze Cheng 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448
// SBlockCol ======================================================
int32_t tPutBlockCol(uint8_t *p, void *ph) {
  int32_t    n = 0;
  SBlockCol *pBlockCol = (SBlockCol *)ph;

  ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE));

  n += tPutI16v(p ? p + n : p, pBlockCol->cid);
  n += tPutI8(p ? p + n : p, pBlockCol->type);
  n += tPutI8(p ? p + n : p, pBlockCol->flag);

  if (pBlockCol->flag != HAS_NULL) {
    n += tPutI64v(p ? p + n : p, pBlockCol->offset);
H
Hongze Cheng 已提交
449 450 451 452 453 454 455
    if (pBlockCol->flag != HAS_VALUE) {
      n += tPutI64v(p ? p + n : p, pBlockCol->bsize);
    }
    n += tPutI64v(p ? p + n : p, pBlockCol->csize);
    if (IS_VAR_DATA_TYPE(pBlockCol->type)) {
      n += tPutI64v(p ? p + n : p, pBlockCol->osize);
    }
H
Hongze Cheng 已提交
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
  }

  return n;
}

int32_t tGetBlockCol(uint8_t *p, void *ph) {
  int32_t    n = 0;
  SBlockCol *pBlockCol = (SBlockCol *)ph;

  n += tGetI16v(p + n, &pBlockCol->cid);
  n += tGetI8(p + n, &pBlockCol->type);
  n += tGetI8(p + n, &pBlockCol->flag);

  ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE));

  if (pBlockCol->flag != HAS_NULL) {
    n += tGetI64v(p + n, &pBlockCol->offset);
H
Hongze Cheng 已提交
473 474 475 476 477 478 479 480 481 482 483
    if (pBlockCol->flag != HAS_VALUE) {
      n += tGetI64v(p + n, &pBlockCol->bsize);
    } else {
      pBlockCol->bsize = 0;
    }
    n += tGetI64v(p + n, &pBlockCol->csize);
    if (IS_VAR_DATA_TYPE(pBlockCol->type)) {
      n += tGetI64v(p + n, &pBlockCol->osize);
    } else {
      pBlockCol->osize = -1;
    }
H
Hongze Cheng 已提交
484 485 486 487 488
  }

  return n;
}

H
Hongze Cheng 已提交
489
// SDelIdx ======================================================
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
int32_t tCmprDelIdx(void const *lhs, void const *rhs) {
  SDelIdx *lDelIdx = *(SDelIdx **)lhs;
  SDelIdx *rDelIdx = *(SDelIdx **)rhs;

  if (lDelIdx->suid < lDelIdx->suid) {
    return -1;
  } else if (lDelIdx->suid > lDelIdx->suid) {
    return 1;
  }

  if (lDelIdx->uid < lDelIdx->uid) {
    return -1;
  } else if (lDelIdx->uid > lDelIdx->uid) {
    return 1;
  }

  return 0;
}

H
Hongze Cheng 已提交
509 510 511 512 513 514 515 516 517 518 519 520
int32_t tPutDelIdx(uint8_t *p, void *ph) {
  SDelIdx *pDelIdx = (SDelIdx *)ph;
  int32_t  n = 0;

  n += tPutI64(p ? p + n : p, pDelIdx->suid);
  n += tPutI64(p ? p + n : p, pDelIdx->uid);
  n += tPutI64(p ? p + n : p, pDelIdx->minKey);
  n += tPutI64(p ? p + n : p, pDelIdx->maxKey);
  n += tPutI64v(p ? p + n : p, pDelIdx->minVersion);
  n += tPutI64v(p ? p + n : p, pDelIdx->maxVersion);
  n += tPutI64v(p ? p + n : p, pDelIdx->offset);
  n += tPutI64v(p ? p + n : p, pDelIdx->size);
H
Hongze Cheng 已提交
521 522 523 524

  return n;
}

H
Hongze Cheng 已提交
525 526 527
int32_t tGetDelIdx(uint8_t *p, void *ph) {
  SDelIdx *pDelIdx = (SDelIdx *)ph;
  int32_t  n = 0;
H
Hongze Cheng 已提交
528

H
Hongze Cheng 已提交
529 530 531 532 533 534 535 536
  n += tGetI64(p + n, &pDelIdx->suid);
  n += tGetI64(p + n, &pDelIdx->uid);
  n += tGetI64(p + n, &pDelIdx->minKey);
  n += tGetI64(p + n, &pDelIdx->maxKey);
  n += tGetI64v(p + n, &pDelIdx->minVersion);
  n += tGetI64v(p + n, &pDelIdx->maxVersion);
  n += tGetI64v(p + n, &pDelIdx->offset);
  n += tGetI64v(p + n, &pDelIdx->size);
H
Hongze Cheng 已提交
537 538 539 540

  return n;
}

H
Hongze Cheng 已提交
541
// SDelData ======================================================
H
Hongze Cheng 已提交
542 543 544 545 546 547 548
int32_t tPutDelData(uint8_t *p, void *ph) {
  SDelData *pDelData = (SDelData *)ph;
  int32_t   n = 0;

  n += tPutI64v(p ? p + n : p, pDelData->version);
  n += tPutI64(p ? p + n : p, pDelData->sKey);
  n += tPutI64(p ? p + n : p, pDelData->eKey);
H
Hongze Cheng 已提交
549 550 551 552

  return n;
}

H
Hongze Cheng 已提交
553 554 555
int32_t tGetDelData(uint8_t *p, void *ph) {
  SDelData *pDelData = (SDelData *)ph;
  int32_t   n = 0;
H
Hongze Cheng 已提交
556

H
Hongze Cheng 已提交
557 558 559
  n += tGetI64v(p + n, &pDelData->version);
  n += tGetI64(p + n, &pDelData->sKey);
  n += tGetI64(p + n, &pDelData->eKey);
H
Hongze Cheng 已提交
560 561

  return n;
H
Hongze Cheng 已提交
562 563
}

H
Hongze Cheng 已提交
564 565 566 567 568 569
int32_t tsdbKeyFid(TSKEY key, int32_t minutes, int8_t precision) {
  if (key < 0) {
    return (int)((key + 1) / tsTickPerMin[precision] / minutes - 1);
  } else {
    return (int)((key / tsTickPerMin[precision] / minutes));
  }
H
Hongze Cheng 已提交
570 571
}

H
Hongze Cheng 已提交
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
void tsdbFidKeyRange(int32_t fid, int32_t minutes, int8_t precision, TSKEY *minKey, TSKEY *maxKey) {
  *minKey = fid * minutes * tsTickPerMin[precision];
  *maxKey = *minKey + minutes * tsTickPerMin[precision] - 1;
}

// int tsdFidLevel(int fid, TSKEY now, minute) {
//   if (fid >= pRtn->maxFid) {
//     return 0;
//   } else if (fid >= pRtn->midFid) {
//     return 1;
//   } else if (fid >= pRtn->minFid) {
//     return 2;
//   } else {
//     return -1;
//   }
// }

H
Hongze Cheng 已提交
589 590
// TSDBROW ======================================================
void tsdbRowGetColVal(TSDBROW *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
H
Hongze Cheng 已提交
591 592 593
  STColumn *pTColumn = &pTSchema->columns[iCol];
  SValue    value;

H
Hongze Cheng 已提交
594 595
  ASSERT(iCol > 0);

H
Hongze Cheng 已提交
596
  if (pRow->type == 0) {
H
Hongze Cheng 已提交
597
    tTSRowGetVal(pRow->pTSRow, pTSchema, iCol, pColVal);
H
Hongze Cheng 已提交
598
  } else if (pRow->type == 1) {
H
Hongze Cheng 已提交
599
    SColData *pColData = &(SColData){.cid = pTColumn->colId};
H
Hongze Cheng 已提交
600
    void     *p = NULL;
H
Hongze Cheng 已提交
601

H
Hongze Cheng 已提交
602
    p = taosArraySearch(pRow->pBlockData->aColDataP, &pColData, tColDataPCmprFn, TD_EQ);
H
Hongze Cheng 已提交
603
    if (p) {
H
Hongze Cheng 已提交
604
      pColData = *(SColData **)p;
H
Hongze Cheng 已提交
605

H
Hongze Cheng 已提交
606 607 608
      ASSERT(pColData->type == pTColumn->type);

      tColDataGetValue(pColData, pRow->iRow, pColVal);
H
Hongze Cheng 已提交
609
    } else {
H
Hongze Cheng 已提交
610
      *pColVal = COL_VAL_NONE(pTColumn->colId, pTColumn->type);
H
Hongze Cheng 已提交
611 612 613 614
    }
  } else {
    ASSERT(0);
  }
H
Hongze Cheng 已提交
615 616
}

H
Hongze Cheng 已提交
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
int32_t tPutTSDBRow(uint8_t *p, TSDBROW *pRow) {
  int32_t n = 0;

  n += tPutI64(p, pRow->version);
  if (p) memcpy(p + n, pRow->pTSRow, pRow->pTSRow->len);
  n += pRow->pTSRow->len;

  return n;
}

int32_t tGetTSDBRow(uint8_t *p, TSDBROW *pRow) {
  int32_t n = 0;

  n += tGetI64(p, &pRow->version);
  pRow->pTSRow = (STSRow *)(p + n);
  n += pRow->pTSRow->len;

  return n;
}

H
Hongze Cheng 已提交
637 638 639 640
int32_t tsdbRowCmprFn(const void *p1, const void *p2) {
  return tsdbKeyCmprFn(&TSDBROW_KEY((TSDBROW *)p1), &TSDBROW_KEY((TSDBROW *)p2));
}

H
Hongze Cheng 已提交
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
// SRowIter ======================================================
void tRowIterInit(SRowIter *pIter, TSDBROW *pRow, STSchema *pTSchema) {
  pIter->pRow = pRow;
  if (pRow->type == 0) {
    ASSERT(pTSchema);
    pIter->pTSchema = pTSchema;
    pIter->i = 1;
  } else if (pRow->type == 1) {
    pIter->pTSchema = NULL;
    pIter->i = 0;
  } else {
    ASSERT(0);
  }
}

SColVal *tRowIterNext(SRowIter *pIter) {
  if (pIter->pRow->type == 0) {
    if (pIter->i < pIter->pTSchema->numOfCols) {
      tsdbRowGetColVal(pIter->pRow, pIter->pTSchema, pIter->i, &pIter->colVal);
      pIter->i++;

      return &pIter->colVal;
    }
  } else {
H
Hongze Cheng 已提交
665 666
    if (pIter->i < taosArrayGetSize(pIter->pRow->pBlockData->aColDataP)) {
      SColData *pColData = (SColData *)taosArrayGetP(pIter->pRow->pBlockData->aColDataP, pIter->i);
H
Hongze Cheng 已提交
667 668 669 670 671 672 673 674 675 676 677

      tColDataGetValue(pColData, pIter->pRow->iRow, &pIter->colVal);
      pIter->i++;

      return &pIter->colVal;
    }
  }

  return NULL;
}

H
Hongze Cheng 已提交
678 679 680
// SRowMerger ======================================================
int32_t tRowMergerInit(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) {
  int32_t   code = 0;
H
Hongze Cheng 已提交
681
  TSDBKEY   key = TSDBROW_KEY(pRow);
H
Hongze Cheng 已提交
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
  SColVal  *pColVal = &(SColVal){0};
  STColumn *pTColumn;

  pMerger->pTSchema = pTSchema;
  pMerger->version = key.version;

  pMerger->pArray = taosArrayInit(pTSchema->numOfCols, sizeof(SColVal));
  if (pMerger->pArray == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

  // ts
  pTColumn = &pTSchema->columns[0];

  ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);

  *pColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.ts = key.ts});
  if (taosArrayPush(pMerger->pArray, pColVal) == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }

  // other
  for (int16_t iCol = 1; iCol < pTSchema->numOfCols; iCol++) {
    tsdbRowGetColVal(pRow, pTSchema, iCol, pColVal);
    if (taosArrayPush(pMerger->pArray, pColVal) == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }
  }

_exit:
  return code;
}

void tRowMergerClear(SRowMerger *pMerger) { taosArrayDestroy(pMerger->pArray); }

int32_t tRowMerge(SRowMerger *pMerger, TSDBROW *pRow) {
  int32_t  code = 0;
H
Hongze Cheng 已提交
722
  TSDBKEY  key = TSDBROW_KEY(pRow);
H
Hongze Cheng 已提交
723 724 725 726 727 728 729 730
  SColVal *pColVal = &(SColVal){0};

  ASSERT(((SColVal *)pMerger->pArray->pData)->value.ts == key.ts);

  for (int32_t iCol = 1; iCol < pMerger->pTSchema->numOfCols; iCol++) {
    tsdbRowGetColVal(pRow, pMerger->pTSchema, iCol, pColVal);

    if (key.version > pMerger->version) {
H
Hongze Cheng 已提交
731 732 733
      if (!pColVal->isNone) {
        taosArraySet(pMerger->pArray, iCol, pColVal);
      }
H
Hongze Cheng 已提交
734
    } else if (key.version < pMerger->version) {
H
Hongze Cheng 已提交
735 736 737 738
      SColVal *tColVal = (SColVal *)taosArrayGet(pMerger->pArray, iCol);
      if (tColVal->isNone && !pColVal->isNone) {
        taosArraySet(pMerger->pArray, iCol, pColVal);
      }
H
Hongze Cheng 已提交
739 740 741 742 743 744 745 746 747 748 749 750 751
    } else {
      ASSERT(0);
    }
  }

  pMerger->version = key.version;

_exit:
  return code;
}

int32_t tRowMergerGetRow(SRowMerger *pMerger, STSRow **ppRow) {
  int32_t code = 0;
752 753 754

  code = tdSTSRowNew(pMerger->pArray, pMerger->pTSchema, ppRow);

H
Hongze Cheng 已提交
755 756 757
  return code;
}

H
Hongze Cheng 已提交
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
// delete skyline ======================================================
static int32_t tsdbMergeSkyline(SArray *aSkyline1, SArray *aSkyline2, SArray *aSkyline) {
  int32_t  code = 0;
  int32_t  i1 = 0;
  int32_t  n1 = taosArrayGetSize(aSkyline1);
  int32_t  i2 = 0;
  int32_t  n2 = taosArrayGetSize(aSkyline2);
  TSDBKEY *pSkyline1;
  TSDBKEY *pSkyline2;
  TSDBKEY  item;
  int64_t  version1 = 0;
  int64_t  version2 = 0;

  ASSERT(n1 > 0 && n2 > 0);

  taosArrayClear(aSkyline);

  while (i1 < n1 && i2 < n2) {
    pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1);
    pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2);

    if (pSkyline1->ts < pSkyline2->ts) {
      version1 = pSkyline1->version;
      i1++;
    } else if (pSkyline1->ts > pSkyline2->ts) {
      version2 = pSkyline2->version;
      i2++;
    } else {
      version1 = pSkyline1->version;
      version2 = pSkyline2->version;
      i1++;
      i2++;
    }

    item.ts = TMIN(pSkyline1->ts, pSkyline2->ts);
    item.version = TMAX(version1, version2);
    if (taosArrayPush(aSkyline, &item) == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }
  }

  while (i1 < n1) {
    pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1);
    item.ts = pSkyline1->ts;
    item.version = pSkyline1->version;
    if (taosArrayPush(aSkyline, &item) == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }
    i1++;
  }

  while (i2 < n2) {
    pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2);
    item.ts = pSkyline2->ts;
    item.version = pSkyline2->version;
    if (taosArrayPush(aSkyline, &item) == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _exit;
    }
    i2++;
  }

_exit:
  return code;
}
int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SArray *aSkyline) {
  int32_t   code = 0;
  SDelData *pDelData;
  int32_t   midx;

  taosArrayClear(aSkyline);
  if (sidx == eidx) {
    pDelData = (SDelData *)taosArrayGet(aDelData, sidx);
    taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version});
    taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0});
  } else {
    SArray *aSkyline1 = NULL;
    SArray *aSkyline2 = NULL;

    aSkyline1 = taosArrayInit(0, sizeof(TSDBKEY));
    aSkyline2 = taosArrayInit(0, sizeof(TSDBKEY));
    if (aSkyline1 == NULL || aSkyline2 == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _clear;
    }

    midx = (sidx + eidx) / 2;

    code = tsdbBuildDeleteSkyline(aDelData, sidx, midx, aSkyline1);
    if (code) goto _clear;

    code = tsdbBuildDeleteSkyline(aDelData, midx + 1, eidx, aSkyline2);
    if (code) goto _clear;

    code = tsdbMergeSkyline(aSkyline1, aSkyline2, aSkyline);

  _clear:
    taosArrayDestroy(aSkyline1);
    taosArrayDestroy(aSkyline2);
  }

H
Hongze Cheng 已提交
861 862 863
  return code;
}

H
Hongze Cheng 已提交
864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
// KEYINFO ======================================================
int32_t tPutKEYINFO(uint8_t *p, KEYINFO *pKeyInfo) {
  int32_t n = 0;

  n += tPutTSDBKEY(p ? p + n : p, &pKeyInfo->minKey);
  n += tPutTSDBKEY(p ? p + n : p, &pKeyInfo->maxKey);
  n += tPutI64v(p ? p + n : p, pKeyInfo->minVerion);
  n += tPutI64v(p ? p + n : p, pKeyInfo->maxVersion);

  return n;
}

int32_t tGetKEYINFO(uint8_t *p, KEYINFO *pKeyInfo) {
  int32_t n = 0;

  n += tGetTSDBKEY(p + n, &pKeyInfo->minKey);
  n += tGetTSDBKEY(p + n, &pKeyInfo->maxKey);
  n += tGetI64v(p + n, &pKeyInfo->minVerion);
  n += tGetI64v(p + n, &pKeyInfo->maxVersion);

  return n;
H
Hongze Cheng 已提交
885 886
}

H
Hongze Cheng 已提交
887
// SColData ========================================
H
Hongze Cheng 已提交
888 889 890
void tColDataReset(SColData *pColData, int16_t cid, int8_t type) {
  pColData->cid = cid;
  pColData->type = type;
H
Hongze Cheng 已提交
891 892 893
  pColData->nVal = 0;
  pColData->flag = 0;
  pColData->offsetValid = 0;
H
Hongze Cheng 已提交
894
  pColData->nData = 0;
H
Hongze Cheng 已提交
895 896
}

H
Hongze Cheng 已提交
897 898 899 900
void tColDataClear(void *ph) {
  SColData *pColData = (SColData *)ph;

  tsdbFree(pColData->pBitMap);
H
Hongze Cheng 已提交
901
  tsdbFree((uint8_t *)pColData->aOffset);
H
Hongze Cheng 已提交
902
  tsdbFree(pColData->pData);
H
Hongze Cheng 已提交
903 904 905 906
}

int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) {
  int32_t code = 0;
H
Hongze Cheng 已提交
907 908 909
  int64_t size;
  SValue  value = {0};
  SValue *pValue = &value;
H
Hongze Cheng 已提交
910

H
Hongze Cheng 已提交
911 912 913 914 915 916 917 918 919
  ASSERT(pColVal->cid == pColData->cid);
  ASSERT(pColVal->type == pColData->type);

  // realloc bitmap
  size = BIT2_SIZE(pColData->nVal + 1);
  code = tsdbRealloc(&pColData->pBitMap, size);
  if (code) goto _exit;

  // put value
H
Hongze Cheng 已提交
920
  if (pColVal->isNone) {
H
Hongze Cheng 已提交
921 922 923
    pColData->flag |= HAS_NONE;
    SET_BIT2(pColData->pBitMap, pColData->nVal, 0);
    if (IS_VAR_DATA_TYPE(pColData->type)) pValue = NULL;
H
Hongze Cheng 已提交
924
  } else if (pColVal->isNull) {
H
Hongze Cheng 已提交
925 926 927
    pColData->flag |= HAS_NULL;
    SET_BIT2(pColData->pBitMap, pColData->nVal, 1);
    if (IS_VAR_DATA_TYPE(pColData->type)) pValue = NULL;
H
Hongze Cheng 已提交
928
  } else {
H
Hongze Cheng 已提交
929 930 931 932 933 934 935 936 937 938
    pColData->flag |= HAS_VALUE;
    SET_BIT2(pColData->pBitMap, pColData->nVal, 2);
    pValue = &pColVal->value;
  }

  if (pValue) {
    code = tsdbRealloc(&pColData->pData, pColData->nData + tPutValue(NULL, &pColVal->value, pColVal->type));
    if (code) goto _exit;

    pColData->nData += tPutValue(pColData->pData + pColData->nData, &pColVal->value, pColVal->type);
H
Hongze Cheng 已提交
939 940
  }

H
Hongze Cheng 已提交
941 942 943 944
  pColData->nVal++;
  pColData->offsetValid = 0;

_exit:
H
Hongze Cheng 已提交
945 946 947
  return code;
}

H
Hongze Cheng 已提交
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) {
  int32_t code = 0;

  pColDataDest->cid = pColDataDest->cid;
  pColDataDest->type = pColDataDest->type;
  pColDataDest->offsetValid = 0;
  pColDataDest->nVal = pColDataSrc->nVal;
  pColDataDest->flag = pColDataSrc->flag;
  if (pColDataSrc->flag != HAS_NONE && pColDataSrc->flag != HAS_NULL && pColDataSrc->flag != HAS_VALUE) {
    code = tsdbRealloc(&pColDataDest->pBitMap, BIT2_SIZE(pColDataDest->nVal));
    if (code) goto _exit;

    memcpy(pColDataDest->pBitMap, pColDataSrc->pBitMap, BIT2_SIZE(pColDataSrc->nVal));
  }
  pColDataDest->nData = pColDataSrc->nData;
  code = tsdbRealloc(&pColDataDest->pData, pColDataSrc->nData);
  if (code) goto _exit;
  memcpy(pColDataDest->pData, pColDataSrc->pData, pColDataSrc->nData);

_exit:
  return code;
}

H
Hongze Cheng 已提交
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
static int32_t tColDataUpdateOffset(SColData *pColData) {
  int32_t code = 0;
  SValue  value;

  ASSERT(pColData->nVal > 0);
  ASSERT(pColData->flag);

  if (IS_VAR_DATA_TYPE(pColData->type) && (pColData->flag & HAS_VALUE)) {
    code = tsdbRealloc((uint8_t **)&pColData->aOffset, sizeof(int32_t) * pColData->nVal);
    if (code) goto _exit;

    int32_t offset = 0;
    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
      uint8_t v = GET_BIT2(pColData->pBitMap, iVal);
      if (v == 0 || v == 1) {
        pColData->aOffset[iVal] = -1;
      } else {
        pColData->aOffset[iVal] = offset;
        offset += tGetValue(pColData->pData + offset, &value, pColData->type);
      }
    }

    ASSERT(offset == pColData->nData);
    pColData->offsetValid = 1;
  }

_exit:
  return code;
}

int32_t tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal) {
  int32_t code = 0;

  ASSERT(iVal < pColData->nVal);
  ASSERT(pColData->flag);

  if (pColData->flag == HAS_NONE) {
    *pColVal = COL_VAL_NONE(pColData->cid, pColData->type);
    goto _exit;
  } else if (pColData->flag == HAS_NULL) {
    *pColVal = COL_VAL_NULL(pColData->cid, pColData->type);
    goto _exit;
  } else if (pColData->flag != HAS_VALUE) {
    uint8_t v = GET_BIT2(pColData->pBitMap, iVal);
    if (v == 0) {
      *pColVal = COL_VAL_NONE(pColData->cid, pColData->type);
      goto _exit;
    } else if (v == 1) {
      *pColVal = COL_VAL_NULL(pColData->cid, pColData->type);
      goto _exit;
    }
  }

  // get value
  SValue value;
  if (IS_VAR_DATA_TYPE(pColData->type)) {
    if (!pColData->offsetValid) {
      code = tColDataUpdateOffset(pColData);
      if (code) goto _exit;
    }
    tGetValue(pColData->pData + pColData->aOffset[iVal], &value, pColData->type);
  } else {
    tGetValue(pColData->pData + tDataTypes[pColData->type].bytes * iVal, &value, pColData->type);
  }
  *pColVal = COL_VAL_VALUE(pColData->cid, pColData->type, value);

_exit:
  return code;
H
Hongze Cheng 已提交
1039 1040
}

H
Hongze Cheng 已提交
1041 1042 1043 1044 1045
int32_t tColDataPCmprFn(const void *p1, const void *p2) {
  SColData *pColData1 = *(SColData **)p1;
  SColData *pColData2 = *(SColData **)p2;

  if (pColData1->cid < pColData2->cid) {
H
Hongze Cheng 已提交
1046
    return -1;
H
Hongze Cheng 已提交
1047
  } else if (pColData1->cid > pColData2->cid) {
H
Hongze Cheng 已提交
1048 1049 1050 1051 1052 1053
    return 1;
  }

  return 0;
}

H
Hongze Cheng 已提交
1054
// SBlockData ======================================================
H
Hongze Cheng 已提交
1055 1056
int32_t tBlockDataInit(SBlockData *pBlockData) {
  int32_t code = 0;
H
Hongze Cheng 已提交
1057

H
Hongze Cheng 已提交
1058 1059 1060 1061 1062
  pBlockData->nRow = 0;
  pBlockData->aVersion = NULL;
  pBlockData->aTSKEY = NULL;
  pBlockData->aColDataP = taosArrayInit(0, sizeof(SColData *));
  if (pBlockData->aColDataP == NULL) {
H
Hongze Cheng 已提交
1063 1064 1065 1066 1067
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }
  pBlockData->aColData = taosArrayInit(0, sizeof(SColData));
  if (pBlockData->aColData == NULL) {
H
Hongze Cheng 已提交
1068
    taosArrayDestroy(pBlockData->aColDataP);
H
Hongze Cheng 已提交
1069 1070 1071
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }
H
Hongze Cheng 已提交
1072 1073 1074 1075 1076

_exit:
  return code;
}

H
Hongze Cheng 已提交
1077 1078
void tBlockDataReset(SBlockData *pBlockData) {
  pBlockData->nRow = 0;
H
Hongze Cheng 已提交
1079
  taosArrayClear(pBlockData->aColDataP);
H
Hongze Cheng 已提交
1080
}
H
Hongze Cheng 已提交
1081

H
Hongze Cheng 已提交
1082 1083 1084
void tBlockDataClear(SBlockData *pBlockData) {
  tsdbFree((uint8_t *)pBlockData->aVersion);
  tsdbFree((uint8_t *)pBlockData->aTSKEY);
H
Hongze Cheng 已提交
1085
  taosArrayDestroy(pBlockData->aColDataP);
H
Hongze Cheng 已提交
1086 1087 1088
  taosArrayDestroyEx(pBlockData->aColData, tColDataClear);
}

H
Hongze Cheng 已提交
1089 1090
int32_t tBlockDataAddColData(SBlockData *pBlockData, int32_t iColData, SColData **ppColData) {
  int32_t   code = 0;
H
Hongze Cheng 已提交
1091 1092 1093 1094
  SColData *pColData = NULL;
  int32_t   idx = taosArrayGetSize(pBlockData->aColDataP);

  if (idx >= taosArrayGetSize(pBlockData->aColData)) {
H
Hongze Cheng 已提交
1095 1096 1097 1098
    if (taosArrayPush(pBlockData->aColData, &((SColData){0})) == NULL) {
      code = TSDB_CODE_OUT_OF_MEMORY;
      goto _err;
    }
H
Hongze Cheng 已提交
1099 1100 1101
  }
  pColData = (SColData *)taosArrayGet(pBlockData->aColData, idx);

H
Hongze Cheng 已提交
1102 1103 1104
  if (taosArrayInsert(pBlockData->aColDataP, iColData, &pColData) == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _err;
H
Hongze Cheng 已提交
1105 1106
  }

H
Hongze Cheng 已提交
1107 1108 1109 1110 1111 1112
  *ppColData = pColData;
  return code;

_err:
  *ppColData = NULL;
  return code;
H
Hongze Cheng 已提交
1113
}
H
Hongze Cheng 已提交
1114 1115 1116

int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema) {
  int32_t code = 0;
H
Hongze Cheng 已提交
1117

H
Hongze Cheng 已提交
1118
  // TSDBKEY
H
Hongze Cheng 已提交
1119 1120 1121 1122
  code = tsdbRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1));
  if (code) goto _err;
  code = tsdbRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1));
  if (code) goto _err;
H
Hongze Cheng 已提交
1123 1124
  pBlockData->aVersion[pBlockData->nRow] = TSDBROW_VERSION(pRow);
  pBlockData->aTSKEY[pBlockData->nRow] = TSDBROW_TS(pRow);
H
Hongze Cheng 已提交
1125

H
Hongze Cheng 已提交
1126 1127
  // OTHER
  int32_t   iColData = 0;
H
Hongze Cheng 已提交
1128
  SRowIter *pIter = &((SRowIter){0});
H
Hongze Cheng 已提交
1129 1130
  SColData *pColData;
  SColVal  *pColVal;
H
Hongze Cheng 已提交
1131

H
Hongze Cheng 已提交
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
  tRowIterInit(pIter, pRow, pTSchema);
  pColVal = tRowIterNext(pIter);
  pColData = (iColData < taosArrayGetSize(pBlockData->aColDataP))
                 ? (SColData *)taosArrayGetP(pBlockData->aColDataP, iColData)
                 : NULL;

  while (pColVal && pColData) {
    if (pColVal->cid == pColData->cid) {
      code = tColDataAppendValue(pColData, pColVal);
      if (code) goto _err;

      pColVal = tRowIterNext(pIter);
    } else if (pColVal->cid > pColData->cid) {
H
Hongze Cheng 已提交
1145
      code = tColDataAppendValue(pColData, &(COL_VAL_NONE(pColData->cid, pColData->type)));
H
Hongze Cheng 已提交
1146
      if (code) goto _err;
H
Hongze Cheng 已提交
1147
    } else {
H
Hongze Cheng 已提交
1148 1149 1150 1151 1152 1153 1154 1155
      code = tBlockDataAddColData(pBlockData, iColData, &pColData);
      if (code) goto _err;

      // append a NONE
      tColDataReset(pColData, pColVal->cid, pColVal->type);
      for (int32_t iRow = 0; iRow < pBlockData->nRow; iRow++) {
        code = tColDataAppendValue(pColData, &COL_VAL_NONE(pColVal->cid, pColVal->type));
        if (code) goto _err;
H
Hongze Cheng 已提交
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
      }

      code = tColDataAppendValue(pColData, pColVal);
      if (code) goto _err;

      pColVal = tRowIterNext(pIter);
    }

    pColData = ((++iColData) < taosArrayGetSize(pBlockData->aColDataP))
                   ? (SColData *)taosArrayGetP(pBlockData->aColDataP, iColData)
                   : NULL;
  }

  while (pColData) {
H
Hongze Cheng 已提交
1170
    code = tColDataAppendValue(pColData, &COL_VAL_NONE(pColData->cid, pColData->type));
H
Hongze Cheng 已提交
1171 1172 1173 1174 1175 1176 1177 1178
    if (code) goto _err;

    pColData = ((++iColData) < taosArrayGetSize(pBlockData->aColDataP))
                   ? (SColData *)taosArrayGetP(pBlockData->aColDataP, iColData)
                   : NULL;
  }

  while (pColVal) {
H
Hongze Cheng 已提交
1179 1180 1181 1182 1183 1184 1185
    code = tBlockDataAddColData(pBlockData, iColData, &pColData);
    if (code) goto _err;

    tColDataReset(pColData, pColVal->cid, pColVal->type);
    for (int32_t iRow = 0; iRow < pBlockData->nRow; iRow++) {
      code = tColDataAppendValue(pColData, &COL_VAL_NONE(pColVal->cid, pColVal->type));
      if (code) goto _err;
H
Hongze Cheng 已提交
1186
    }
H
Hongze Cheng 已提交
1187 1188 1189 1190 1191 1192

    code = tColDataAppendValue(pColData, pColVal);
    if (code) goto _err;

    iColData++;
    pColVal = tRowIterNext(pIter);
H
Hongze Cheng 已提交
1193
  }
H
Hongze Cheng 已提交
1194

H
Hongze Cheng 已提交
1195
  pBlockData->nRow++;
H
Hongze Cheng 已提交
1196
  return code;
H
Hongze Cheng 已提交
1197

H
Hongze Cheng 已提交
1198
_err:
H
Hongze Cheng 已提交
1199
  return code;
1200
}
H
Hongze Cheng 已提交
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281

int32_t tBlockDataMerge(SBlockData *pBlockData1, SBlockData *pBlockData2, SBlockData *pBlockData) {
  int32_t code = 0;

  tBlockDataReset(pBlockData);

  // loop to merge
  int32_t iRow1 = 0;
  int32_t nRow1 = pBlockData1->nRow;
  int32_t iRow2 = 0;
  int32_t nRow2 = pBlockData2->nRow;
  TSDBROW row1;
  TSDBROW row2;
  int32_t c;

  while (iRow1 < nRow1 && iRow2 < nRow2) {
    row1 = tsdbRowFromBlockData(pBlockData1, iRow1);
    row2 = tsdbRowFromBlockData(pBlockData2, iRow2);

    c = tsdbKeyCmprFn(&TSDBROW_KEY(&row1), &TSDBROW_KEY(&row2));
    if (c < 0) {
      code = tBlockDataAppendRow(pBlockData, &row1, NULL);
      if (code) goto _exit;
      iRow1++;
    } else if (c > 0) {
      code = tBlockDataAppendRow(pBlockData, &row2, NULL);
      if (code) goto _exit;
      iRow2++;
    } else {
      ASSERT(0);
    }
  }

  while (iRow1 < nRow1) {
    row1 = tsdbRowFromBlockData(pBlockData1, iRow1);
    code = tBlockDataAppendRow(pBlockData, &row1, NULL);
    if (code) goto _exit;
    iRow1++;
  }

  while (iRow2 < nRow2) {
    row2 = tsdbRowFromBlockData(pBlockData2, iRow2);
    code = tBlockDataAppendRow(pBlockData, &row2, NULL);
    if (code) goto _exit;
    iRow2++;
  }

_exit:
  return code;
}

int32_t tBlockDataCopy(SBlockData *pBlockDataSrc, SBlockData *pBlockDataDest) {
  int32_t   code = 0;
  SColData *pColDataSrc;
  SColData *pColDataDest;

  ASSERT(pBlockDataSrc->nRow > 0);

  tBlockDataReset(pBlockDataDest);

  pBlockDataDest->nRow = pBlockDataSrc->nRow;
  // TSDBKEY
  code = tsdbRealloc((uint8_t **)&pBlockDataDest->aVersion, sizeof(int64_t) * pBlockDataSrc->nRow);
  if (code) goto _exit;
  code = tsdbRealloc((uint8_t **)&pBlockDataDest->aTSKEY, sizeof(TSKEY) * pBlockDataSrc->nRow);
  if (code) goto _exit;
  memcpy(pBlockDataDest->aVersion, pBlockDataSrc->aVersion, sizeof(int64_t) * pBlockDataSrc->nRow);
  memcpy(pBlockDataDest->aTSKEY, pBlockDataSrc->aTSKEY, sizeof(TSKEY) * pBlockDataSrc->nRow);

  // other
  for (size_t iColData = 0; iColData < taosArrayGetSize(pBlockDataSrc->aColDataP); iColData++) {
    pColDataSrc = (SColData *)taosArrayGetP(pBlockDataSrc->aColDataP, iColData);
    code = tBlockDataAddColData(pBlockDataDest, iColData, &pColDataDest);
    if (code) goto _exit;

    code = tColDataCopy(pColDataSrc, pColDataDest);
    if (code) goto _exit;
  }

_exit:
  return code;
1282
}