#4934

Committed 21 Jan 2026 06:06AM UTC coverage: 66.691% (+0.02%) from 66.671%

Build # #4934

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

 enh:stmt support interval opt (#34335)

Run Details

0 of 26 new or added lines in 3 files covered. (0.0%)

562 existing lines in 98 files now uncovered.

203203 of 304692 relevant lines covered (66.69%)

129902664.38 hits per line

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

67.3

/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 = 0;
  if (pArray == NULL || num < 0) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }
  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 taosArrayRemoveP(SArray* pArray, size_t index, void (*fp)(void*)){
  if (!(index < pArray->size)) {
    return;
  }

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

  void* p = taosArrayGetP(pArray, index);
  if (fp) {
    fp(p);
  }

  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(num == 0) {
    return;
  }
  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) {	2,147,483,647✔
26	if (elemSize == 0) {	2,147,483,647✔
27	terrno = TSDB_CODE_INVALID_PARA;	×
28	return NULL;	×
29	}
30
31	if (size < TARRAY_MIN_SIZE) {	2,147,483,647✔
32	size = TARRAY_MIN_SIZE;	2,147,483,647✔
33	}
34
35	SArray* pArray = taosMemoryMalloc(sizeof(SArray));	2,147,483,647✔
36	if (pArray == NULL) {	2,147,483,647✔
37	return NULL;	×
38	}
39
40	pArray->size = 0;	2,147,483,647✔
41	pArray->pData = taosMemoryCalloc(size, elemSize);	2,147,483,647✔
42	if (pArray->pData == NULL) {	2,147,483,647✔
43	taosMemoryFree(pArray);	×
44	return NULL;	×
45	}
46
47	pArray->capacity = size;	2,147,483,647✔
48	pArray->elemSize = elemSize;	2,147,483,647✔
49	return pArray;	2,147,483,647✔
50	}
51
52	SArray* taosArrayInit_s(size_t elemSize, size_t initialSize) {	286,477,396✔
53	SArray* pArray = taosMemoryMalloc(sizeof(SArray));	286,477,396✔
54	if (pArray == NULL) {	286,384,816✔
55	return NULL;	×
56	}
57
58	pArray->size = initialSize;	286,384,816✔
59	pArray->pData = taosMemoryCalloc(initialSize, elemSize);	286,399,504✔
60	if (pArray->pData == NULL) {	286,506,114✔
61	taosMemoryFree(pArray);	×
62	return NULL;	×
63	}
64
65	pArray->capacity = initialSize;	286,322,234✔
66	pArray->elemSize = elemSize;	286,430,687✔
67	return pArray;	286,460,274✔
68	}
69
70	static int32_t taosArrayResize(SArray* pArray) {	×
71	size_t size = pArray->capacity;	×
72	size = (size << 1u);	×
73
74	void* tmp = taosMemoryRealloc(pArray->pData, size * pArray->elemSize);	×
75	if (tmp == NULL) { // reallocate failed, the original buffer remains	×
76	return terrno;	×
77	}
78
79	pArray->pData = tmp;	×
80	pArray->capacity = size;	×
81
82	return 0;	×
83	}
84
85	int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {	2,147,483,647✔
86	if (newCap > pArray->capacity) {	2,147,483,647✔
87	float factor = BOUNDARY_BIG_FACTOR;	1,225,856,836✔
88	if (newCap * pArray->elemSize > BOUNDARY_SIZE) {	1,225,856,836✔
89	factor = BOUNDARY_SMALL_FACTOR;	×
90	}
91
92	size_t tsize = (pArray->capacity * factor);	1,225,863,996✔
93	while (newCap > tsize) {	1,242,236,837✔
94	size_t newSize = (tsize * factor);	16,376,632✔
95	tsize = (newSize == tsize) ? (tsize + 2) : newSize;	16,376,632✔
96	}
97
98	char* p = taosMemoryRealloc(pArray->pData, tsize * pArray->elemSize);	1,225,860,205✔
99	if (p == NULL) {	1,225,688,169✔
100	return terrno;	×
101	}
102
103	pArray->pData = p;	1,225,688,169✔
104	pArray->capacity = tsize;	1,225,713,339✔
105	}
106	return 0;	2,147,483,647✔
107	}
108
109	void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles) {	2,147,483,647✔
110	if (pData == NULL) {	2,147,483,647✔
111	terrno = TSDB_CODE_INVALID_PARA;	×
112	return NULL;	×
113	}
114
115	int32_t code = taosArrayEnsureCap(pArray, pArray->size + nEles);	2,147,483,647✔
116	if (code) {	2,147,483,647✔
117	terrno = code;	40✔
118	return NULL;	×
119	}
120
121	void* dst = TARRAY_GET_ELEM(pArray, pArray->size);	2,147,483,647✔
122	memcpy(dst, pData, pArray->elemSize * nEles);	2,147,483,647✔
123
124	pArray->size += nEles;	2,147,483,647✔
125	return dst;	2,147,483,647✔
126	}
127
128	void taosArrayRemoveDuplicate(SArray* pArray, __compar_fn_t comparFn, void (fp)(void)) {	66,516,446✔
129	size_t size = pArray->size;	66,516,446✔
130	if (size <= 1) {	66,523,664✔
131	return;	4,672,634✔
132	}
133
134	int32_t pos = 0;	61,851,030✔
135	for (int32_t i = 1; i < size; ++i) {	266,973,929✔
136	char* p1 = taosArrayGet(pArray, pos);	205,103,778✔
137	char* p2 = taosArrayGet(pArray, i);	205,113,225✔
138
139	if (comparFn(p1, p2) == 0) {	205,077,453✔
140	// do nothing
141	} else {
142	if (pos + 1 != i) {	204,895,174✔
143	void* p = taosArrayGet(pArray, pos + 1);	221,757✔
144	if (fp != NULL) {	221,757✔
145	fp(p);	×
146	}
147
148	taosArraySet(pArray, pos + 1, p2);	221,757✔
149	memset(TARRAY_GET_ELEM(pArray, i), 0, pArray->elemSize);	221,757✔
150	pos += 1;	221,757✔
151	} else {
152	pos += 1;	204,673,417✔
153	}
154	}
155	}
156
157	if (fp != NULL) {	61,870,151✔
158	for (int32_t i = pos + 1; i < pArray->size; ++i) {	2,963✔
159	void* p = taosArrayGet(pArray, i);	317✔
160	fp(p);	317✔
161	}
162	}
163
164	pArray->size = pos + 1;	61,870,151✔
165	}
166
167	void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {	122,102,035✔
168	if (pInput) {	122,102,035✔
169	return taosArrayAddBatch(pArray, pInput->pData, (int32_t)taosArrayGetSize(pInput));	120,959,867✔
170	} else {
171	terrno = TSDB_CODE_INVALID_PARA;	1,142,168✔
172	return NULL;	1,151,616✔
173	}
174	}
175
176	void* taosArrayReserve(SArray* pArray, int32_t num) {	2,147,483,647✔
177	int32_t code = 0;	2,147,483,647✔
178	if (pArray == NULL \|\| num < 0) {	2,147,483,647✔
UNCOV 179	terrno = TSDB_CODE_INVALID_PARA;	×
180	return NULL;	×
181	}
182	code = taosArrayEnsureCap(pArray, pArray->size + num);	2,147,483,647✔
183	if (code) {	2,147,483,647✔
UNCOV 184	terrno = code;	×
UNCOV 185	return NULL;	×
186	}
187
188	void* dst = TARRAY_GET_ELEM(pArray, pArray->size);	2,147,483,647✔
189	pArray->size += num;	2,147,483,647✔
190
191	memset(dst, 0, num * pArray->elemSize);	2,147,483,647✔
192
193	return dst;	2,147,483,647✔
194	}
195
196	void* taosArrayPop(SArray* pArray) {	2,147,483,647✔
197	if (pArray->size == 0) {	2,147,483,647✔
198	return NULL;	25,296,611✔
199	}
200
201	pArray->size -= 1;	2,147,483,647✔
202	return TARRAY_GET_ELEM(pArray, pArray->size);	2,147,483,647✔
203	}
204
205	void* taosArrayGet(const SArray* pArray, size_t index) {	2,147,483,647✔
206	if (NULL == pArray) {	2,147,483,647✔
UNCOV 207	terrno = TSDB_CODE_INVALID_PARA;	×
UNCOV 208	uError("failed to return value from array of null ptr");	×
UNCOV 209	return NULL;	×
210	}
211
212	if (index >= pArray->size) {	2,147,483,647✔
213	uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);	151,278✔
214	terrno = TSDB_CODE_OUT_OF_RANGE;	151,278✔
215	return NULL;	151,278✔
216	}
217
218	return TARRAY_GET_ELEM(pArray, index);	2,147,483,647✔
219	}
220
221	void* taosArrayGetP(const SArray* pArray, size_t index) {	2,147,483,647✔
222	void** p = taosArrayGet(pArray, index);	2,147,483,647✔
223	if (p == NULL) {	2,147,483,647✔
UNCOV 224	return NULL;	×
225	}
226	return *p;	2,147,483,647✔
227	}
228
229	void* taosArrayGetLast(const SArray* pArray) {	2,147,483,647✔
230	if (pArray->size == 0) {	2,147,483,647✔
231	terrno = TSDB_CODE_INVALID_PARA;	5,188,669✔
232	return NULL;	5,188,669✔
233	}
234
235	return TARRAY_GET_ELEM(pArray, pArray->size - 1);	2,147,483,647✔
236	}
237
238	size_t taosArrayGetSize(const SArray* pArray) {	2,147,483,647✔
239	if (pArray == NULL) {	2,147,483,647✔
240	return 0;	2,147,483,647✔
241	}
242	return TARRAY_SIZE(pArray);	2,147,483,647✔
243	}
244
245	void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {	2,147,483,647✔
246	if (pArray == NULL \|\| pData == NULL) {	2,147,483,647✔
247	terrno = TSDB_CODE_INVALID_PARA;	437✔
UNCOV 248	return NULL;	×
249	}
250
251	if (index >= pArray->size) {	2,147,483,647✔
252	return taosArrayPush(pArray, pData);	2,147,483,647✔
253	}
254
255	if (pArray->size >= pArray->capacity) {	6,544,390✔
UNCOV 256	int32_t ret = taosArrayResize(pArray);	×
UNCOV 257	if (ret < 0) {	×
UNCOV 258	terrno = ret;	×
UNCOV 259	return NULL;	×
260	}
261	}
262
263	void* dst = TARRAY_GET_ELEM(pArray, index);	6,542,680✔
264
265	int32_t remain = (int32_t)(pArray->size - index);	6,542,754✔
266	memmove((char)dst + pArray->elemSize, (char)dst, pArray->elemSize * remain);	6,542,754✔
267	memcpy(dst, pData, pArray->elemSize);	6,542,754✔
268
269	pArray->size += 1;	6,542,754✔
270
271	return dst;	6,542,828✔
272	}
273
274	void taosArraySet(SArray* pArray, size_t index, void* pData) {	2,147,483,647✔
275	if (index < pArray->size) {	2,147,483,647✔
276	memcpy(TARRAY_GET_ELEM(pArray, index), pData, pArray->elemSize);	2,147,483,647✔
277	}
278	}	2,147,483,647✔
279
280	void taosArrayPopFrontBatch(SArray* pArray, size_t cnt) {	5,359,219✔
281	if (cnt > pArray->size) {	5,359,219✔
UNCOV 282	cnt = pArray->size;	×
283	}
284
285	pArray->size = pArray->size - cnt;	5,359,219✔
286	if (pArray->size == 0 \|\| cnt == 0) {	5,359,219✔
287	return;	4,667,583✔
288	}
289	memmove(pArray->pData, (char)pArray->pData + cnt pArray->elemSize, pArray->size * pArray->elemSize);	691,150✔
290	}
291
292	void taosArrayPopTailBatch(SArray* pArray, size_t cnt) {	53,461,832✔
293	if (cnt >= pArray->size) {	53,461,832✔
294	cnt = pArray->size;	18,478,985✔
295	}
296
297	pArray->size = pArray->size - cnt;	53,463,677✔
298	}	53,461,041✔
299
300	void taosArrayRemove(SArray* pArray, size_t index) {	463,051,811✔
301	if (!(index < pArray->size)) {	463,051,811✔
UNCOV 302	return;	×
303	}
304
305	if (index == pArray->size - 1) {	463,053,271✔
306	void* t = taosArrayPop(pArray);	200,705,392✔
307	return;	200,706,268✔
308	}
309
310	size_t remain = pArray->size - index - 1;	262,348,223✔
311	memmove((char)pArray->pData + index pArray->elemSize, (char)pArray->pData + (index + 1) pArray->elemSize,	262,348,171✔
312	remain * pArray->elemSize);	262,349,047✔
313	pArray->size -= 1;	262,350,338✔
314	}
315
316	void taosArrayRemoveP(SArray* pArray, size_t index, void (fp)(void)){	×
317	if (!(index < pArray->size)) {	×
318	return;	×
319	}
320
321	if (index == pArray->size - 1) {	×
UNCOV 322	void** t = taosArrayPop(pArray);	×
UNCOV 323	if (fp && t!= NULL) {	×
324	fp(*t);	×
325	}
326	return;	×
327	}
328
329	void* p = taosArrayGetP(pArray, index);	×
330	if (fp) {	×
331	fp(p);	×
332	}
333
UNCOV 334	size_t remain = pArray->size - index - 1;	×
UNCOV 335	memmove((char)pArray->pData + index pArray->elemSize, (char)pArray->pData + (index + 1) pArray->elemSize,	×
UNCOV 336	remain * pArray->elemSize);	×
337	pArray->size -= 1;	×
338	}
339
340	void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp) {	48,599,283✔
341	if(num == 0) {	48,599,283✔
UNCOV 342	return;	×
343	}
344	if (index + num <= pArray->size) {	48,599,283✔
345	if (fp) {	48,597,585✔
346	for (int32_t i = 0; i < num; i++) {	126,408,276✔
347	fp(taosArrayGet(pArray, index + i));	77,811,847✔
348	}
349	}
350
351	memmove((char)pArray->pData + index pArray->elemSize, (char)pArray->pData + (index + num) pArray->elemSize,	48,594,149✔
352	(pArray->size - index - num) * pArray->elemSize);	48,594,656✔
353	pArray->size -= num;	48,587,574✔
354	}
355	}
356
UNCOV 357	SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {	×
358	if (elemSize <= 0) {	×
359	terrno = TSDB_CODE_INVALID_PARA;	×
360	return NULL;	×
361	}
362
UNCOV 363	SArray* pDst = taosArrayInit(size, elemSize);	×
364	if (pDst) {	×
UNCOV 365	memcpy(pDst->pData, src, elemSize * size);	×
UNCOV 366	pDst->size = size;	×
367	}
368
UNCOV 369	return pDst;	×
370	}
371
372	SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {	1,194,568,189✔
373	if (NULL == pSrc) {	1,194,568,189✔
374	terrno = TSDB_CODE_INVALID_PARA;	4,307,665✔
375	return NULL;	4,307,662✔
376	}
377
378	if (pSrc->size == 0) { // empty array list	1,190,260,524✔
379	return taosArrayInit(8, pSrc->elemSize);	90,598,920✔
380	}
381
382	SArray* dst = taosArrayInit(pSrc->size, pSrc->elemSize);	1,099,631,581✔
383
384	if (dst) {	1,099,461,831✔
385	if (fn == NULL) {	1,099,511,486✔
386	memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);	1,099,294,210✔
387	} else {
388	for (int32_t i = 0; i < pSrc->size; ++i) {	547,856✔
389	void* p = fn(taosArrayGetP(pSrc, i));	330,229✔
390	memcpy(((char)dst->pData) + i dst->elemSize, &p, dst->elemSize);	330,580✔
391	}
392	}
393
394	dst->size = pSrc->size;	1,099,717,458✔
395	}
396
397	return dst;	1,099,768,321✔
398	}
399
400	void taosArrayClear(SArray* pArray) {	2,147,483,647✔
401	if (pArray == NULL) return;	2,147,483,647✔
402	pArray->size = 0;	2,147,483,647✔
403	}
404
405	void taosArrayClearEx(SArray* pArray, void (fp)(void)) {	88,101,416✔
406	if (pArray == NULL) return;	88,101,416✔
407	if (fp == NULL) {	77,552,194✔
UNCOV 408	pArray->size = 0;	×
UNCOV 409	return;	×
410	}
411
412	for (int32_t i = 0; i < pArray->size; ++i) {	2,147,483,647✔
413	fp(TARRAY_GET_ELEM(pArray, i));	2,147,483,647✔
414	}
415
416	pArray->size = 0;	77,531,741✔
417	}
418	void taosArrayClearP(SArray* pArray, void (fp)(void)) {	3,857,730✔
419	// if (pArray == NULL) return;
420	// if (fp == NULL) {
421	// pArray->size = 0;
422	// return;
423	// }
424
425	// for (int32_t i = 0; i < pArray->size; ++i) {
426	// fp(TARRAY_GET_ELEM(pArray, i));
427	// }
428	if (pArray) {	3,857,730✔
429	if (NULL == fp) {	3,857,511✔
430	for (int32_t i = 0; i < pArray->size; i++) {	446,196✔
431	taosMemoryFree((void*)TARRAY_GET_ELEM(pArray, i));	1,154✔
432	}
433	} else {
434	for (int32_t i = 0; i < pArray->size; i++) {	9,884,202✔
435	fp((void*)TARRAY_GET_ELEM(pArray, i));	6,471,514✔
436	}
437	}
438	}
439	taosArrayClear(pArray);	3,857,949✔
440	}	3,857,694✔
441
442	void taosArrayDestroy(SArray* pArray) {	2,147,483,647✔
443	if (pArray) {	2,147,483,647✔
444	taosMemoryFree(pArray->pData);	2,147,483,647✔
445	taosMemoryFree(pArray);	2,147,483,647✔
446	}
447	}	2,147,483,647✔
448
449	void taosArrayDestroyP(SArray* pArray, FDelete fp) {	2,147,483,647✔
450	if (pArray) {	2,147,483,647✔
451	if (NULL == fp) {	852,160,602✔
452	for (int32_t i = 0; i < pArray->size; i++) {	1,618,871,578✔
453	taosMemoryFree((void*)TARRAY_GET_ELEM(pArray, i));	1,017,649,366✔
454	}
455	} else {
456	for (int32_t i = 0; i < pArray->size; i++) {	1,102,623,719✔
457	fp((void*)TARRAY_GET_ELEM(pArray, i));	852,597,709✔
458	}
459	}
460	taosArrayDestroy(pArray);	850,848,379✔
461	}
462	}	2,147,483,647✔
463
464	void taosArrayDestroyEx(SArray* pArray, FDelete fp) {	2,147,483,647✔
465	if (pArray == NULL) {	2,147,483,647✔
466	return;	2,147,483,647✔
467	}
468
469	if (fp == NULL) {	2,147,483,647✔
470	taosArrayDestroy(pArray);	156,100,634✔
471	return;	156,100,701✔
472	}
473
474	for (int32_t i = 0; i < pArray->size; ++i) {	2,147,483,647✔
475	fp(TARRAY_GET_ELEM(pArray, i));	2,147,483,647✔
476	}
477
478	taosArrayDestroy(pArray);	2,147,483,647✔
479	}
480
481	void taosArraySort(SArray* pArray, __compar_fn_t compar) {	1,100,887,531✔
482	taosSort(pArray->pData, pArray->size, pArray->elemSize, compar);	1,100,887,531✔
483	}	1,100,964,901✔
484
485	int32_t taosArrayMSort(SArray* pArray, __compar_fn_t compar) {	1,450,431✔
486	return taosMergeSort(pArray->pData, pArray->size, pArray->elemSize, compar);	1,450,431✔
487	}
488
489	void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {	1,376,331,118✔
490	return taosbsearch(key, pArray->pData, pArray->size, pArray->elemSize, comparFn, flags);	1,376,331,118✔
491	}
492
493	int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags) {	297,524,559✔
494	void* item = taosArraySearch(pArray, key, comparFn, flags);	297,524,559✔
495	return item == NULL ? -1 : (int32_t)((char)item - (char)pArray->pData) / pArray->elemSize;	297,511,324✔
496	}
497
498	#ifdef BUILD_NO_CALL
499	static int32_t taosArrayPartition(SArray* pArray, int32_t i, int32_t j, __ext_compar_fn_t fn, const void* userData) {
500	void* key = taosArrayGetP(pArray, i);
501	while (i < j) {
502	while (i < j && fn(taosArrayGetP(pArray, j), key, userData) >= 0) {
503	j--;
504	}
505	if (i < j) {
506	void* a = taosArrayGetP(pArray, j);
507	taosArraySet(pArray, i, &a);
508	}
509	while (i < j && fn(taosArrayGetP(pArray, i), key, userData) <= 0) {
510	i++;
511	}
512	if (i < j) {
513	void* a = taosArrayGetP(pArray, i);
514	taosArraySet(pArray, j, &a);
515	}
516	}
517	taosArraySet(pArray, i, &key);
518	return i;
519	}
520
521	static void taosArrayQuicksortImpl(SArray* pArray, int32_t low, int32_t high, __ext_compar_fn_t fn, const void* param) {
522	if (low < high) {
523	int32_t idx = taosArrayPartition(pArray, low, high, fn, param);
524	taosArrayQuicksortImpl(pArray, low, idx - 1, fn, param);
525	taosArrayQuicksortImpl(pArray, idx + 1, high, fn, param);
526	}
527	}
528
529	static void taosArrayQuickSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
530	if (pArray->size <= 1) {
531	return;
532	}
533	taosArrayQuicksortImpl(pArray, 0, (int32_t)(taosArrayGetSize(pArray) - 1), fn, param);
534	}
535
536	static void taosArrayInsertSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
537	if (pArray->size <= 1) {
538	return;
539	}
540
541	for (int32_t i = 1; i <= pArray->size - 1; ++i) {
542	for (int32_t j = i; j > 0; --j) {
543	if (fn(taosArrayGetP(pArray, j), taosArrayGetP(pArray, j - 1), param) == -1) {
544	void* a = taosArrayGetP(pArray, j);
545	void* b = taosArrayGetP(pArray, j - 1);
546	taosArraySet(pArray, j - 1, &a);
547	taosArraySet(pArray, j, &b);
548	} else {
549	break;
550	}
551	}
552	}
553	}
554	#endif
555
556	int32_t taosEncodeArray(void** buf, const SArray* pArray, FEncode encode) {	×
557	int32_t tlen = 0;	×
UNCOV 558	int32_t sz = pArray->size;	×
559	tlen += taosEncodeFixedI32(buf, sz);	×
UNCOV 560	for (int32_t i = 0; i < sz; i++) {	×
UNCOV 561	void* data = taosArrayGetP(pArray, i);	×
562	tlen += encode(buf, data);	×
563	}
564	return tlen;	×
565	}
566
567	void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz, int8_t sver) {	×
UNCOV 568	int32_t sz;	×
569	buf = taosDecodeFixedI32(buf, &sz);	×
570	pArray = taosArrayInit(sz, sizeof(void));	×
571	if (*pArray == NULL) {	×
572	return NULL;	×
573	}
UNCOV 574	for (int32_t i = 0; i < sz; i++) {	×
575	void* data = taosMemoryCalloc(1, dataSz);	×
UNCOV 576	if (data == NULL) {	×
577	return NULL;	×
578	}
579
UNCOV 580	buf = decode(buf, data, sver);	×
581
582	if (taosArrayPush(*pArray, &data) == NULL) {	×
UNCOV 583	taosMemoryFree(data);	×
UNCOV 584	return NULL;	×
585	}
586	}
587	return (void*)buf;	×
588	}
589
590	// todo remove it
591	// order array<type *>
592	int32_t taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* param) {	×
593	return taosqsort(pArray->pData, pArray->size, pArray->elemSize, param, fn);	×
594	}
595
UNCOV 596	void taosArraySwap(SArray* a, SArray* b) {	×
597	if (a == NULL \|\| b == NULL) return;	×
598	size_t t = a->size;	×
599	a->size = b->size;	×
UNCOV 600	b->size = t;	×
601
602	uint32_t cap = a->capacity;	×
603	a->capacity = b->capacity;	×
UNCOV 604	b->capacity = cap;	×
605
606	uint32_t elem = a->elemSize;	×
607	a->elemSize = b->elemSize;	×
UNCOV 608	b->elemSize = elem;	×
609
UNCOV 610	void* data = a->pData;	×
UNCOV 611	a->pData = b->pData;	×
UNCOV 612	b->pData = data;	×
613	}

taosdata / TDengine / #4934

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