#3655

Committed 14 Mar 2025 08:10AM UTC coverage: 59.532% (+22.6%) from 36.951%

Build # #3655

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat(keep): support keep on super table level. (#30097)

* Feat: support use keep while create super table.

* Test(keep): add test for create super table with keep option.

* Feat(keep): Add tmsg for create keep.

* Feat(keep): support alter table option keep.

* Fix(keep): Add baisc test for alter table option.

* Fix(keep): memory leek.

* Feat(keep): add keep to metaEntry&metaCache and fix earliestTs with stn keep.

* Test(keep): add some cases for select with stb keep.

* Fix: fix ci core while alter stb.

* Feat(keep): delete expired data in super table level.

* Feat: remove get stb keep while query.

* Fix : build error.

* Revert "Fix : build error."

This reverts commit 0ed66e4e8.

* Revert "Feat(keep): delete expired data in super table level."

This reverts commit 36330f6b4.

* Fix : build errors.

* Feat : support restart taosd.

* Fix : alter table comment problems.

* Test : add tests for super table keep.

* Fix: change sdb stb reserve size.

* Test: add more tests.

* Feat: Disable normal tables and sub tables from setting the keep parameter

* Fix: add more checks to avoid unknown address.

* Docs: Add docs for stable keep.

* Fix: some review changes.

* Fix: review errors.

Run Details

139898 of 302527 branches covered (46.24%)

Branch coverage included in aggregate %.

71 of 99 new or added lines in 12 files covered. (71.72%)

2746 existing lines in 57 files now uncovered.

220499 of 302857 relevant lines covered (72.81%)

5509252.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.69

/source/util/src/tarray.c

/*
 * 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/>.
 */

#define _DEFAULT_SOURCE
#include "tarray.h"
#include "tcoding.h"

// todo refactor API
#define BOUNDARY_SIZE         1024 * 1024 * 1024  // 1G
#define BOUNDARY_SMALL_FACTOR 1.2
#define BOUNDARY_BIG_FACTOR   2

SArray* taosArrayInit(size_t size, size_t elemSize) {
  if (elemSize == 0) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  if (size < TARRAY_MIN_SIZE) {
    size = TARRAY_MIN_SIZE;
  }

  SArray* pArray = taosMemoryMalloc(sizeof(SArray));
  if (pArray == NULL) {
    return NULL;
  }

  pArray->size = 0;
  pArray->pData = taosMemoryCalloc(size, elemSize);
  if (pArray->pData == NULL) {
    taosMemoryFree(pArray);
    return NULL;
  }

  pArray->capacity = size;
  pArray->elemSize = elemSize;
  return pArray;
}

SArray* taosArrayInit_s(size_t elemSize, size_t initialSize) {
  SArray* pArray = taosMemoryMalloc(sizeof(SArray));
  if (pArray == NULL) {
    return NULL;
  }

  pArray->size = initialSize;
  pArray->pData = taosMemoryCalloc(initialSize, elemSize);
  if (pArray->pData == NULL) {
    taosMemoryFree(pArray);
    return NULL;
  }

  pArray->capacity = initialSize;
  pArray->elemSize = elemSize;
  return pArray;
}

static int32_t taosArrayResize(SArray* pArray) {
  size_t size = pArray->capacity;
  size = (size << 1u);

  void* tmp = taosMemoryRealloc(pArray->pData, size * pArray->elemSize);
  if (tmp == NULL) {  // reallocate failed, the original buffer remains
    return terrno;
  }

  pArray->pData = tmp;
  pArray->capacity = size;

  return 0;
}

int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {
  if (newCap > pArray->capacity) {
    float factor = BOUNDARY_BIG_FACTOR;
    if (newCap * pArray->elemSize > BOUNDARY_SIZE) {
      factor = BOUNDARY_SMALL_FACTOR;
    }

    size_t tsize = (pArray->capacity * factor);
    while (newCap > tsize) {
      size_t newSize = (tsize * factor);
      tsize = (newSize == tsize) ? (tsize + 2) : newSize;
    }

    char* p = taosMemoryRealloc(pArray->pData, tsize * pArray->elemSize);
    if (p == NULL) {
      return terrno;
    }

    pArray->pData = p;
    pArray->capacity = tsize;
  }
  return 0;
}

void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles) {
  if (pData == NULL) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  int32_t code = taosArrayEnsureCap(pArray, pArray->size + nEles);
  if (code) {
    terrno = code;
    return NULL;
  }

  void* dst = TARRAY_GET_ELEM(pArray, pArray->size);
  memcpy(dst, pData, pArray->elemSize * nEles);

  pArray->size += nEles;
  return dst;
}

void taosArrayRemoveDuplicate(SArray* pArray, __compar_fn_t comparFn, void (*fp)(void*)) {
  size_t size = pArray->size;
  if (size <= 1) {
    return;
  }

  int32_t pos = 0;
  for (int32_t i = 1; i < size; ++i) {
    char* p1 = taosArrayGet(pArray, pos);
    char* p2 = taosArrayGet(pArray, i);

    if (comparFn(p1, p2) == 0) {
      // do nothing
    } else {
      if (pos + 1 != i) {
        void* p = taosArrayGet(pArray, pos + 1);
        if (fp != NULL) {
          fp(p);
        }

        taosArraySet(pArray, pos + 1, p2);
        memset(TARRAY_GET_ELEM(pArray, i), 0, pArray->elemSize);
        pos += 1;
      } else {
        pos += 1;
      }
    }
  }

  if (fp != NULL) {
    for (int32_t i = pos + 1; i < pArray->size; ++i) {
      void* p = taosArrayGet(pArray, i);
      fp(p);
    }
  }

  pArray->size = pos + 1;
}

void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
  if (pInput) {
    return taosArrayAddBatch(pArray, pInput->pData, (int32_t)taosArrayGetSize(pInput));
  } else {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }
}

void* taosArrayReserve(SArray* pArray, int32_t num) {
  int32_t code = taosArrayEnsureCap(pArray, pArray->size + num);
  if (code) {
    terrno = code;
    return NULL;
  }

  void* dst = TARRAY_GET_ELEM(pArray, pArray->size);
  pArray->size += num;

  memset(dst, 0, num * pArray->elemSize);

  return dst;
}

void* taosArrayPop(SArray* pArray) {
  if (pArray->size == 0) {
    return NULL;
  }

  pArray->size -= 1;
  return TARRAY_GET_ELEM(pArray, pArray->size);
}

void* taosArrayGet(const SArray* pArray, size_t index) {
  if (NULL == pArray) {
    terrno = TSDB_CODE_INVALID_PARA;
    uError("failed to return value from array of null ptr");
    return NULL;
  }

  if (index >= pArray->size) {
    uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);
    terrno = TSDB_CODE_OUT_OF_RANGE;
    return NULL;
  }

  return TARRAY_GET_ELEM(pArray, index);
}

void* taosArrayGetP(const SArray* pArray, size_t index) {
  void** p = taosArrayGet(pArray, index);
  if (p == NULL) {
    return NULL;
  }
  return *p;
}

void* taosArrayGetLast(const SArray* pArray) {
  if (pArray->size == 0) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  return TARRAY_GET_ELEM(pArray, pArray->size - 1);
}

size_t taosArrayGetSize(const SArray* pArray) {
  if (pArray == NULL) {
    return 0;
  }
  return TARRAY_SIZE(pArray);
}

void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
  if (pArray == NULL || pData == NULL) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  if (index >= pArray->size) {
    return taosArrayPush(pArray, pData);
  }

  if (pArray->size >= pArray->capacity) {
    int32_t ret = taosArrayResize(pArray);
    if (ret < 0) {
      terrno = ret;
      return NULL;
    }
  }

  void* dst = TARRAY_GET_ELEM(pArray, index);

  int32_t remain = (int32_t)(pArray->size - index);
  memmove((char*)dst + pArray->elemSize, (char*)dst, pArray->elemSize * remain);
  memcpy(dst, pData, pArray->elemSize);

  pArray->size += 1;

  return dst;
}

void taosArraySet(SArray* pArray, size_t index, void* pData) {
  if (index < pArray->size) {
    memcpy(TARRAY_GET_ELEM(pArray, index), pData, pArray->elemSize);
  }
}

void taosArrayPopFrontBatch(SArray* pArray, size_t cnt) {
  if (cnt > pArray->size) {
    cnt = pArray->size;
  }

  pArray->size = pArray->size - cnt;
  if (pArray->size == 0 || cnt == 0) {
    return;
  }
  memmove(pArray->pData, (char*)pArray->pData + cnt * pArray->elemSize, pArray->size * pArray->elemSize);
}

void taosArrayPopTailBatch(SArray* pArray, size_t cnt) {
  if (cnt >= pArray->size) {
    cnt = pArray->size;
  }

  pArray->size = pArray->size - cnt;
}

void taosArrayRemove(SArray* pArray, size_t index) {
  if (!(index < pArray->size)) {
    return;
  }

  if (index == pArray->size - 1) {
    void* t = taosArrayPop(pArray);
    return;
  }

  size_t remain = pArray->size - index - 1;
  memmove((char*)pArray->pData + index * pArray->elemSize, (char*)pArray->pData + (index + 1) * pArray->elemSize,
          remain * pArray->elemSize);
  pArray->size -= 1;
}

void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp) {
  if (index + num <= pArray->size) {
    if (fp) {
      for (int32_t i = 0; i < num; i++) {
        fp(taosArrayGet(pArray, index + i));
      }
    }

    memmove((char*)pArray->pData + index * pArray->elemSize, (char*)pArray->pData + (index + num) * pArray->elemSize,
            (pArray->size - index - num) * pArray->elemSize);
    pArray->size -= num;
  }
}

SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
  if (elemSize <= 0) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  SArray* pDst = taosArrayInit(size, elemSize);
  if (pDst) {
    memcpy(pDst->pData, src, elemSize * size);
    pDst->size = size;
  }

  return pDst;
}

SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
  if (NULL == pSrc) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }

  if (pSrc->size == 0) {  // empty array list
    return taosArrayInit(8, pSrc->elemSize);
  }

  SArray* dst = taosArrayInit(pSrc->size, pSrc->elemSize);

  if (dst) {
    if (fn == NULL) {
      memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
    } else {
      for (int32_t i = 0; i < pSrc->size; ++i) {
        void* p = fn(taosArrayGetP(pSrc, i));
        memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);
      }
    }

    dst->size = pSrc->size;
  }

  return dst;
}

void taosArrayClear(SArray* pArray) {
  if (pArray == NULL) return;
  pArray->size = 0;
}

void taosArrayClearEx(SArray* pArray, void (*fp)(void*)) {
  if (pArray == NULL) return;
  if (fp == NULL) {
    pArray->size = 0;
    return;
  }

  for (int32_t i = 0; i < pArray->size; ++i) {
    fp(TARRAY_GET_ELEM(pArray, i));
  }

  pArray->size = 0;
}
void taosArrayClearP(SArray* pArray, void (*fp)(void*)) {
  // if (pArray == NULL) return;
  // if (fp == NULL) {
  //   pArray->size = 0;
  //   return;
  // }

  // for (int32_t i = 0; i < pArray->size; ++i) {
  //   fp(TARRAY_GET_ELEM(pArray, i));
  // }
  if (pArray) {
    if (NULL == fp) {
      for (int32_t i = 0; i < pArray->size; i++) {
        taosMemoryFree(*(void**)TARRAY_GET_ELEM(pArray, i));
      }
    } else {
      for (int32_t i = 0; i < pArray->size; i++) {
        fp(*(void**)TARRAY_GET_ELEM(pArray, i));
      }
    }
  }
  taosArrayClear(pArray);
}

void taosArrayDestroy(SArray* pArray) {
  if (pArray) {
    taosMemoryFree(pArray->pData);
    taosMemoryFree(pArray);
  }
}

void taosArrayDestroyP(SArray* pArray, FDelete fp) {
  if (pArray) {
    if (NULL == fp) {
      for (int32_t i = 0; i < pArray->size; i++) {
        taosMemoryFree(*(void**)TARRAY_GET_ELEM(pArray, i));
      }
    } else {
      for (int32_t i = 0; i < pArray->size; i++) {
        fp(*(void**)TARRAY_GET_ELEM(pArray, i));
      }
    }
    taosArrayDestroy(pArray);
  }
}

void taosArrayDestroyEx(SArray* pArray, FDelete fp) {
  if (pArray == NULL) {
    return;
  }

  if (fp == NULL) {
    taosArrayDestroy(pArray);
    return;
  }

  for (int32_t i = 0; i < pArray->size; ++i) {
    fp(TARRAY_GET_ELEM(pArray, i));
  }

  taosArrayDestroy(pArray);
}

void taosArraySort(SArray* pArray, __compar_fn_t compar) {
  taosSort(pArray->pData, pArray->size, pArray->elemSize, compar);
}

int32_t taosArrayMSort(SArray* pArray, __compar_fn_t compar) {
  return taosMergeSort(pArray->pData, pArray->size, pArray->elemSize, compar);
}

void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {
  return taosbsearch(key, pArray->pData, pArray->size, pArray->elemSize, comparFn, flags);
}

int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {
  void* item = taosArraySearch(pArray, key, comparFn, flags);
  return item == NULL ? -1 : (int32_t)((char*)item - (char*)pArray->pData) / pArray->elemSize;
}

#ifdef BUILD_NO_CALL
static int32_t taosArrayPartition(SArray* pArray, int32_t i, int32_t j, __ext_compar_fn_t fn, const void* userData) {
  void* key = taosArrayGetP(pArray, i);
  while (i < j) {
    while (i < j && fn(taosArrayGetP(pArray, j), key, userData) >= 0) {
      j--;
    }
    if (i < j) {
      void* a = taosArrayGetP(pArray, j);
      taosArraySet(pArray, i, &a);
    }
    while (i < j && fn(taosArrayGetP(pArray, i), key, userData) <= 0) {
      i++;
    }
    if (i < j) {
      void* a = taosArrayGetP(pArray, i);
      taosArraySet(pArray, j, &a);
    }
  }
  taosArraySet(pArray, i, &key);
  return i;
}

static void taosArrayQuicksortImpl(SArray* pArray, int32_t low, int32_t high, __ext_compar_fn_t fn, const void* param) {
  if (low < high) {
    int32_t idx = taosArrayPartition(pArray, low, high, fn, param);
    taosArrayQuicksortImpl(pArray, low, idx - 1, fn, param);
    taosArrayQuicksortImpl(pArray, idx + 1, high, fn, param);
  }
}

static void taosArrayQuickSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
  if (pArray->size <= 1) {
    return;
  }
  taosArrayQuicksortImpl(pArray, 0, (int32_t)(taosArrayGetSize(pArray) - 1), fn, param);
}

static void taosArrayInsertSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
  if (pArray->size <= 1) {
    return;
  }

  for (int32_t i = 1; i <= pArray->size - 1; ++i) {
    for (int32_t j = i; j > 0; --j) {
      if (fn(taosArrayGetP(pArray, j), taosArrayGetP(pArray, j - 1), param) == -1) {
        void* a = taosArrayGetP(pArray, j);
        void* b = taosArrayGetP(pArray, j - 1);
        taosArraySet(pArray, j - 1, &a);
        taosArraySet(pArray, j, &b);
      } else {
        break;
      }
    }
  }
}
#endif

int32_t taosEncodeArray(void** buf, const SArray* pArray, FEncode encode) {
  int32_t tlen = 0;
  int32_t sz = pArray->size;
  tlen += taosEncodeFixedI32(buf, sz);
  for (int32_t i = 0; i < sz; i++) {
    void* data = taosArrayGetP(pArray, i);
    tlen += encode(buf, data);
  }
  return tlen;
}

void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz, int8_t sver) {
  int32_t sz;
  buf = taosDecodeFixedI32(buf, &sz);
  *pArray = taosArrayInit(sz, sizeof(void*));
  if (*pArray == NULL) {
    return NULL;
  }
  for (int32_t i = 0; i < sz; i++) {
    void* data = taosMemoryCalloc(1, dataSz);
    if (data == NULL) {
      return NULL;
    }

    buf = decode(buf, data, sver);

    if (taosArrayPush(*pArray, &data) == NULL) {
      taosMemoryFree(data);
      return NULL;
    }
  }
  return (void*)buf;
}

// todo remove it
// order array<type *>
int32_t taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
  return taosqsort(pArray->pData, pArray->size, pArray->elemSize, param, fn);
}

void taosArraySwap(SArray* a, SArray* b) {
  if (a == NULL || b == NULL) return;
  size_t t = a->size;
  a->size = b->size;
  b->size = t;

  uint32_t cap = a->capacity;
  a->capacity = b->capacity;
  b->capacity = cap;

  uint32_t elem = a->elemSize;
  a->elemSize = b->elemSize;
  b->elemSize = elem;

  void* data = a->pData;
  a->pData = b->pData;
  b->pData = data;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "tarray.h"
18	#include "tcoding.h"
19
20	// todo refactor API
21	#define BOUNDARY_SIZE 1024 * 1024 * 1024 // 1G
22	#define BOUNDARY_SMALL_FACTOR 1.2
23	#define BOUNDARY_BIG_FACTOR 2
24
25	SArray* taosArrayInit(size_t size, size_t elemSize) {	378,291,658✔
26	if (elemSize == 0) {	378,291,658✔
27	terrno = TSDB_CODE_INVALID_PARA;	1✔
28	return NULL;	1✔
29	}
30
31	if (size < TARRAY_MIN_SIZE) {	378,291,657✔
32	size = TARRAY_MIN_SIZE;	81,226,166✔
33	}
34
35	SArray* pArray = taosMemoryMalloc(sizeof(SArray));	378,291,657!
36	if (pArray == NULL) {	378,290,782!
37	return NULL;	×
38	}
39
40	pArray->size = 0;	378,290,782✔
41	pArray->pData = taosMemoryCalloc(size, elemSize);	378,290,782!
42	if (pArray->pData == NULL) {	378,366,964!
43	taosMemoryFree(pArray);	×
44	return NULL;	×
45	}
46
47	pArray->capacity = size;	378,366,964✔
48	pArray->elemSize = elemSize;	378,366,964✔
49	return pArray;	378,366,964✔
50	}
51
52	SArray* taosArrayInit_s(size_t elemSize, size_t initialSize) {	519,695✔
53	SArray* pArray = taosMemoryMalloc(sizeof(SArray));	519,695!
54	if (pArray == NULL) {	519,696!
55	return NULL;	×
56	}
57
58	pArray->size = initialSize;	519,696✔
59	pArray->pData = taosMemoryCalloc(initialSize, elemSize);	519,696!
60	if (pArray->pData == NULL) {	519,696!
61	taosMemoryFree(pArray);	×
62	return NULL;	×
63	}
64
65	pArray->capacity = initialSize;	519,696✔
66	pArray->elemSize = elemSize;	519,696✔
67	return pArray;	519,696✔
68	}
69
70	static int32_t taosArrayResize(SArray* pArray) {	14✔
71	size_t size = pArray->capacity;	14✔
72	size = (size << 1u);	14✔
73
74	void* tmp = taosMemoryRealloc(pArray->pData, size * pArray->elemSize);	14!
75	if (tmp == NULL) { // reallocate failed, the original buffer remains	14!
76	return terrno;	×
77	}
78
79	pArray->pData = tmp;	14✔
80	pArray->capacity = size;	14✔
81
82	return 0;	14✔
83	}
84
85	int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {	1,972,386,039✔
86	if (newCap > pArray->capacity) {	1,972,386,039✔
87	float factor = BOUNDARY_BIG_FACTOR;	6,671,787✔
88	if (newCap * pArray->elemSize > BOUNDARY_SIZE) {	6,671,787!
89	factor = BOUNDARY_SMALL_FACTOR;	×
90	}
91
92	size_t tsize = (pArray->capacity * factor);	6,671,787✔
93	while (newCap > tsize) {	6,762,441✔
94	size_t newSize = (tsize * factor);	90,654✔
95	tsize = (newSize == tsize) ? (tsize + 2) : newSize;	90,654!
96	}
97
98	char* p = taosMemoryRealloc(pArray->pData, tsize * pArray->elemSize);	6,671,787!
99	if (p == NULL) {	6,673,584!
100	return terrno;	×
101	}
102
103	pArray->pData = p;	6,673,584✔
104	pArray->capacity = tsize;	6,673,584✔
105	}
106	return 0;	1,972,387,836✔
107	}
108
109	void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles) {	1,743,251,342✔
110	if (pData == NULL) {	1,743,251,342✔
111	terrno = TSDB_CODE_INVALID_PARA;	1✔
112	return NULL;	1✔
113	}
114
115	int32_t code = taosArrayEnsureCap(pArray, pArray->size + nEles);	1,743,251,341✔
116	if (code) {	1,744,133,618!
117	terrno = code;	×
118	return NULL;	×
119	}
120
121	void* dst = TARRAY_GET_ELEM(pArray, pArray->size);	1,750,570,839✔
122	memcpy(dst, pData, pArray->elemSize * nEles);	1,750,570,839✔
123
124	pArray->size += nEles;	1,750,570,839✔
125	return dst;	1,750,570,839✔
126	}
127
128	void taosArrayRemoveDuplicate(SArray* pArray, __compar_fn_t comparFn, void (fp)(void)) {	51,001✔
129	size_t size = pArray->size;	51,001✔
130	if (size <= 1) {	51,001✔
131	return;	44,910✔
132	}
133
134	int32_t pos = 0;	6,091✔
135	for (int32_t i = 1; i < size; ++i) {	626,870✔
136	char* p1 = taosArrayGet(pArray, pos);	620,778✔
137	char* p2 = taosArrayGet(pArray, i);	620,778✔
138
139	if (comparFn(p1, p2) == 0) {	620,779✔
140	// do nothing
141	} else {
142	if (pos + 1 != i) {	523,861✔
143	void* p = taosArrayGet(pArray, pos + 1);	14,698✔
144	if (fp != NULL) {	14,698✔
145	fp(p);	3✔
146	}
147
148	taosArraySet(pArray, pos + 1, p2);	14,698✔
149	memset(TARRAY_GET_ELEM(pArray, i), 0, pArray->elemSize);	14,698✔
150	pos += 1;	14,698✔
151	} else {
152	pos += 1;	509,163✔
153	}
154	}
155	}
156
157	if (fp != NULL) {	6,092✔
158	for (int32_t i = pos + 1; i < pArray->size; ++i) {	101✔
159	void* p = taosArrayGet(pArray, i);	11✔
160	fp(p);	11✔
161	}
162	}
163
164	pArray->size = pos + 1;	6,137✔
165	}
166
167	void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {	303,276✔
168	if (pInput) {	303,276✔
169	return taosArrayAddBatch(pArray, pInput->pData, (int32_t)taosArrayGetSize(pInput));	300,715✔
170	} else {
171	terrno = TSDB_CODE_INVALID_PARA;	2,561✔
172	return NULL;	2,607✔
173	}
174	}
175
176	void* taosArrayReserve(SArray* pArray, int32_t num) {	229,010,075✔
177	int32_t code = taosArrayEnsureCap(pArray, pArray->size + num);	229,010,075✔
178	if (code) {	228,930,860!
179	terrno = code;	×
180	return NULL;	×
181	}
182
183	void* dst = TARRAY_GET_ELEM(pArray, pArray->size);	228,965,469✔
184	pArray->size += num;	228,965,469✔
185
186	memset(dst, 0, num * pArray->elemSize);	228,965,469✔
187
188	return dst;	228,965,469✔
189	}
190
191	void* taosArrayPop(SArray* pArray) {	18,429,787✔
192	if (pArray->size == 0) {	18,429,787✔
193	return NULL;	147,070✔
194	}
195
196	pArray->size -= 1;	18,282,717✔
197	return TARRAY_GET_ELEM(pArray, pArray->size);	18,282,717✔
198	}
199
200	void* taosArrayGet(const SArray* pArray, size_t index) {	2,147,483,647✔
201	if (NULL == pArray) {	2,147,483,647✔
202	terrno = TSDB_CODE_INVALID_PARA;	52✔
203	uError("failed to return value from array of null ptr");	52!
204	return NULL;	52✔
205	}
206
207	if (index >= pArray->size) {	2,147,483,647✔
208	uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);	1,409!
209	terrno = TSDB_CODE_OUT_OF_RANGE;	1,409✔
210	return NULL;	1,409✔
211	}
212
213	return TARRAY_GET_ELEM(pArray, index);	2,147,483,647✔
214	}
215
216	void* taosArrayGetP(const SArray* pArray, size_t index) {	347,571,046✔
217	void** p = taosArrayGet(pArray, index);	347,571,046✔
218	if (p == NULL) {	348,831,386✔
219	return NULL;	1✔
220	}
221	return *p;	348,831,385✔
222	}
223
224	void* taosArrayGetLast(const SArray* pArray) {	66,661,433✔
225	if (pArray->size == 0) {	66,661,433✔
226	terrno = TSDB_CODE_INVALID_PARA;	1✔
227	return NULL;	1✔
228	}
229
230	return TARRAY_GET_ELEM(pArray, pArray->size - 1);	66,661,432✔
231	}
232
233	size_t taosArrayGetSize(const SArray* pArray) {	2,147,483,647✔
234	if (pArray == NULL) {	2,147,483,647✔
235	return 0;	57,307,121✔
236	}
237	return TARRAY_SIZE(pArray);	2,147,483,647✔
238	}
239
240	void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {	8,302,886✔
241	if (pArray == NULL \|\| pData == NULL) {	8,302,886!
UNCOV 242	terrno = TSDB_CODE_INVALID_PARA;	×
243	return NULL;	1✔
244	}
245
246	if (index >= pArray->size) {	8,302,896✔
247	return taosArrayPush(pArray, pData);	8,302,200✔
248	}
249
250	if (pArray->size >= pArray->capacity) {	690✔
251	int32_t ret = taosArrayResize(pArray);	14✔
252	if (ret < 0) {	14!
253	terrno = ret;	×
254	return NULL;	×
255	}
256	}
257
258	void* dst = TARRAY_GET_ELEM(pArray, index);	690✔
259
260	int32_t remain = (int32_t)(pArray->size - index);	690✔
261	memmove((char)dst + pArray->elemSize, (char)dst, pArray->elemSize * remain);	690✔
262	memcpy(dst, pData, pArray->elemSize);	690✔
263
264	pArray->size += 1;	690✔
265
266	return dst;	690✔
267	}
268
269	void taosArraySet(SArray* pArray, size_t index, void* pData) {	18,045,928✔
270	if (index < pArray->size) {	18,045,928!
271	memcpy(TARRAY_GET_ELEM(pArray, index), pData, pArray->elemSize);	18,051,233✔
272	}
273	}	18,045,928✔
274
275	void taosArrayPopFrontBatch(SArray* pArray, size_t cnt) {	21,751✔
276	if (cnt > pArray->size) {	21,751✔
277	cnt = pArray->size;	1✔
278	}
279
280	pArray->size = pArray->size - cnt;	21,751✔
281	if (pArray->size == 0 \|\| cnt == 0) {	21,751✔
282	return;	21,710✔
283	}
284	memmove(pArray->pData, (char)pArray->pData + cnt pArray->elemSize, pArray->size * pArray->elemSize);	41✔
285	}
286
287	void taosArrayPopTailBatch(SArray* pArray, size_t cnt) {	98,982✔
288	if (cnt >= pArray->size) {	98,982✔
289	cnt = pArray->size;	63,526✔
290	}
291
292	pArray->size = pArray->size - cnt;	98,982✔
293	}	98,982✔
294
295	void taosArrayRemove(SArray* pArray, size_t index) {	3,171,508✔
296	if (!(index < pArray->size)) {	3,171,508!
297	return;	×
298	}
299
300	if (index == pArray->size - 1) {	3,171,508✔
301	void* t = taosArrayPop(pArray);	819,513✔
302	return;	819,500✔
303	}
304
305	size_t remain = pArray->size - index - 1;	2,351,995✔
306	memmove((char)pArray->pData + index pArray->elemSize, (char)pArray->pData + (index + 1) pArray->elemSize,	2,351,995✔
307	remain * pArray->elemSize);	2,351,995✔
308	pArray->size -= 1;	2,351,995✔
309	}
310
311	void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp) {	162,384✔
312	if (index + num <= pArray->size) {	162,384!
313	if (fp) {	162,389✔
314	for (int32_t i = 0; i < num; i++) {	321,619✔
315	fp(taosArrayGet(pArray, index + i));	161,196✔
316	}
317	}
318
319	memmove((char)pArray->pData + index pArray->elemSize, (char)pArray->pData + (index + num) pArray->elemSize,	162,394✔
320	(pArray->size - index - num) * pArray->elemSize);	162,394✔
321	pArray->size -= num;	162,394✔
322	}
323	}	162,389✔
324
325	SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {	1✔
326	if (elemSize <= 0) {	1!
327	terrno = TSDB_CODE_INVALID_PARA;	×
328	return NULL;	×
329	}
330
331	SArray* pDst = taosArrayInit(size, elemSize);	1✔
332	if (pDst) {	1!
333	memcpy(pDst->pData, src, elemSize * size);	1✔
334	pDst->size = size;	1✔
335	}
336
337	return pDst;	1✔
338	}
339
340	SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {	3,381,808✔
341	if (NULL == pSrc) {	3,381,808✔
342	terrno = TSDB_CODE_INVALID_PARA;	8,297✔
343	return NULL;	8,297✔
344	}
345
346	if (pSrc->size == 0) { // empty array list	3,373,511✔
347	return taosArrayInit(8, pSrc->elemSize);	53,057✔
348	}
349
350	SArray* dst = taosArrayInit(pSrc->size, pSrc->elemSize);	3,320,454✔
351
352	if (dst) {	3,320,666!
353	if (fn == NULL) {	3,320,678✔
354	memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);	3,319,312✔
355	} else {
356	for (int32_t i = 0; i < pSrc->size; ++i) {	3,746✔
357	void* p = fn(taosArrayGetP(pSrc, i));	2,333✔
358	memcpy(((char)dst->pData) + i dst->elemSize, &p, dst->elemSize);	2,380✔
359	}
360	}
361
362	dst->size = pSrc->size;	3,320,725✔
363	}
364
365	return dst;	3,320,713✔
366	}
367
368	void taosArrayClear(SArray* pArray) {	109,120,050✔
369	if (pArray == NULL) return;	109,120,050✔
370	pArray->size = 0;	92,796,021✔
371	}
372
373	void taosArrayClearEx(SArray* pArray, void (fp)(void)) {	3,909,550✔
374	if (pArray == NULL) return;	3,909,550!
375	if (fp == NULL) {	3,909,550✔
376	pArray->size = 0;	1✔
377	return;	1✔
378	}
379
380	for (int32_t i = 0; i < pArray->size; ++i) {	133,274,016✔
381	fp(TARRAY_GET_ELEM(pArray, i));	129,364,448✔
382	}
383
384	pArray->size = 0;	3,909,568✔
385	}
386	void taosArrayClearP(SArray* pArray, void (fp)(void)) {	405✔
387	// if (pArray == NULL) return;
388	// if (fp == NULL) {
389	// pArray->size = 0;
390	// return;
391	// }
392
393	// for (int32_t i = 0; i < pArray->size; ++i) {
394	// fp(TARRAY_GET_ELEM(pArray, i));
395	// }
396	if (pArray) {	405!
397	if (NULL == fp) {	405!
398	for (int32_t i = 0; i < pArray->size; i++) {	422✔
399	taosMemoryFree((void*)TARRAY_GET_ELEM(pArray, i));	17!
400	}
401	} else {
402	for (int32_t i = 0; i < pArray->size; i++) {	×
403	fp((void*)TARRAY_GET_ELEM(pArray, i));	×
404	}
405	}
406	}
407	taosArrayClear(pArray);	405✔
408	}	405✔
409
410	void taosArrayDestroy(SArray* pArray) {	661,203,063✔
411	if (pArray) {	661,203,063✔
412	taosMemoryFree(pArray->pData);	378,932,015!
413	taosMemoryFree(pArray);	378,989,045!
414	}
415	}	661,235,165✔
416
417	void taosArrayDestroyP(SArray* pArray, FDelete fp) {	156,802,311✔
418	if (pArray) {	156,802,311✔
419	if (NULL == fp) {	137,396,628✔
420	for (int32_t i = 0; i < pArray->size; i++) {	6,829,381✔
421	taosMemoryFree((void*)TARRAY_GET_ELEM(pArray, i));	2,137,978!
422	}
423	} else {
424	for (int32_t i = 0; i < pArray->size; i++) {	264,018,070✔
425	fp((void*)TARRAY_GET_ELEM(pArray, i));	131,312,614✔
426	}
427	}
428	taosArrayDestroy(pArray);	137,396,859✔
429	}
430	}	156,802,712✔
431
432	void taosArrayDestroyEx(SArray* pArray, FDelete fp) {	50,215,721✔
433	if (pArray == NULL) {	50,215,721✔
434	return;	27,475,934✔
435	}
436
437	if (fp == NULL) {	22,739,787✔
438	taosArrayDestroy(pArray);	412,117✔
439	return;	412,117✔
440	}
441
442	for (int32_t i = 0; i < pArray->size; ++i) {	94,863,571✔
443	fp(TARRAY_GET_ELEM(pArray, i));	72,536,204✔
444	}
445
446	taosArrayDestroy(pArray);	22,327,367✔
447	}
448
449	void taosArraySort(SArray* pArray, __compar_fn_t compar) {	3,981,731✔
450	taosSort(pArray->pData, pArray->size, pArray->elemSize, compar);	3,981,731✔
451	}	3,981,872✔
452
453	int32_t taosArrayMSort(SArray* pArray, __compar_fn_t compar) {	1,770✔
454	return taosMergeSort(pArray->pData, pArray->size, pArray->elemSize, compar);	1,770✔
455	}
456
457	void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {	5,337,696✔
458	return taosbsearch(key, pArray->pData, pArray->size, pArray->elemSize, comparFn, flags);	5,337,696✔
459	}
460
461	int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {	1,972,768✔
462	void* item = taosArraySearch(pArray, key, comparFn, flags);	1,972,768✔
463	return item == NULL ? -1 : (int32_t)((char)item - (char)pArray->pData) / pArray->elemSize;	1,973,233✔
464	}
465
466	#ifdef BUILD_NO_CALL
467	static int32_t taosArrayPartition(SArray* pArray, int32_t i, int32_t j, __ext_compar_fn_t fn, const void* userData) {
468	void* key = taosArrayGetP(pArray, i);
469	while (i < j) {
470	while (i < j && fn(taosArrayGetP(pArray, j), key, userData) >= 0) {
471	j--;
472	}
473	if (i < j) {
474	void* a = taosArrayGetP(pArray, j);
475	taosArraySet(pArray, i, &a);
476	}
477	while (i < j && fn(taosArrayGetP(pArray, i), key, userData) <= 0) {
478	i++;
479	}
480	if (i < j) {
481	void* a = taosArrayGetP(pArray, i);
482	taosArraySet(pArray, j, &a);
483	}
484	}
485	taosArraySet(pArray, i, &key);
486	return i;
487	}
488
489	static void taosArrayQuicksortImpl(SArray* pArray, int32_t low, int32_t high, __ext_compar_fn_t fn, const void* param) {
490	if (low < high) {
491	int32_t idx = taosArrayPartition(pArray, low, high, fn, param);
492	taosArrayQuicksortImpl(pArray, low, idx - 1, fn, param);
493	taosArrayQuicksortImpl(pArray, idx + 1, high, fn, param);
494	}
495	}
496
497	static void taosArrayQuickSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
498	if (pArray->size <= 1) {
499	return;
500	}
501	taosArrayQuicksortImpl(pArray, 0, (int32_t)(taosArrayGetSize(pArray) - 1), fn, param);
502	}
503
504	static void taosArrayInsertSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
505	if (pArray->size <= 1) {
506	return;
507	}
508
509	for (int32_t i = 1; i <= pArray->size - 1; ++i) {
510	for (int32_t j = i; j > 0; --j) {
511	if (fn(taosArrayGetP(pArray, j), taosArrayGetP(pArray, j - 1), param) == -1) {
512	void* a = taosArrayGetP(pArray, j);
513	void* b = taosArrayGetP(pArray, j - 1);
514	taosArraySet(pArray, j - 1, &a);
515	taosArraySet(pArray, j, &b);
516	} else {
517	break;
518	}
519	}
520	}
521	}
522	#endif
523
524	int32_t taosEncodeArray(void** buf, const SArray* pArray, FEncode encode) {	5,018✔
525	int32_t tlen = 0;	5,018✔
526	int32_t sz = pArray->size;	5,018✔
527	tlen += taosEncodeFixedI32(buf, sz);	5,018✔
528	for (int32_t i = 0; i < sz; i++) {	13,190✔
529	void* data = taosArrayGetP(pArray, i);	8,172✔
530	tlen += encode(buf, data);	8,172✔
531	}
532	return tlen;	5,018✔
533	}
534
535	void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz, int8_t sver) {	1,956!
536	int32_t sz;
537	buf = taosDecodeFixedI32(buf, &sz);	1,956✔
538	pArray = taosArrayInit(sz, sizeof(void));	1,956✔
539	if (*pArray == NULL) {	1,956!
540	return NULL;	×
541	}
542	for (int32_t i = 0; i < sz; i++) {	5,470✔
543	void* data = taosMemoryCalloc(1, dataSz);	3,514!
544	if (data == NULL) {	3,514!
545	return NULL;	×
546	}
547
548	buf = decode(buf, data, sver);	3,514✔
549
550	if (taosArrayPush(*pArray, &data) == NULL) {	7,028!
551	taosMemoryFree(data);	×
552	return NULL;	×
553	}
554	}
555	return (void*)buf;	1,956✔
556	}
557
558	// todo remove it
559	// order array<type *>
560	int32_t taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* param) {	1✔
561	return taosqsort(pArray->pData, pArray->size, pArray->elemSize, param, fn);	1✔
562	}
563
564	void taosArraySwap(SArray* a, SArray* b) {	24✔
565	if (a == NULL \|\| b == NULL) return;	24!
566	size_t t = a->size;	24✔
567	a->size = b->size;	24✔
568	b->size = t;	24✔
569
570	uint32_t cap = a->capacity;	24✔
571	a->capacity = b->capacity;	24✔
572	b->capacity = cap;	24✔
573
574	uint32_t elem = a->elemSize;	24✔
575	a->elemSize = b->elemSize;	24✔
576	b->elemSize = elem;	24✔
577
578	void* data = a->pData;	24✔
579	a->pData = b->pData;	24✔
580	b->pData = data;	24✔
581	}

taosdata / TDengine / #3655

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous