#3531

Committed 19 Nov 2024 10:42AM UTC coverage: 60.213% (-0.006%) from 60.219%

Build # #3531

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #28777 from taosdata/fix/3.0/TD-32366

fix:TD-32366/stmt add geometry datatype check

Run Details

118529 of 252344 branches covered (46.97%)

Branch coverage included in aggregate %.

7 of 48 new or added lines in 3 files covered. (14.58%)

2282 existing lines in 115 files now uncovered.

199096 of 275161 relevant lines covered (72.36%)

6067577.83 hits per line

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

77.71

/source/util/src/tlist.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 "tlist.h"

void tdListInit(SList *list, int32_t eleSize) {
  TD_DLIST_INIT(list);
  listEleSize(list) = eleSize;
}

SList *tdListNew(int32_t eleSize) {
  SList *list = (SList *)taosMemoryMalloc(sizeof(SList));
  if (list == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  tdListInit(list, eleSize);
  return list;
}

void tdListEmpty(SList *list) {
  SListNode *node;
  while ((node = TD_DLIST_HEAD(list)) != NULL) {
    TD_DLIST_POP(list, node);
    taosMemoryFree(node);
  }
}

void *tdListFree(SList *list) {
  if (list) {
    tdListEmpty(list);
    taosMemoryFree(list);
  }

  return NULL;
}

void tdListEmptyP(SList *list, FDelete fp) {
  SListNode *node;
  while ((node = TD_DLIST_HEAD(list)) != NULL) {
    TD_DLIST_POP(list, node);
    fp(node->data);
    taosMemoryFree(node);
  }
}

void tdListFreeP(SList *list, FDelete fp) {
  if (list) {
    tdListEmptyP(list, fp);
    taosMemoryFree(list);
  }
}

void tdListPrependNode(SList *list, SListNode *node) { TD_DLIST_PREPEND(list, node); }

void tdListAppendNode(SList *list, SListNode *node) { TD_DLIST_APPEND(list, node); }

int32_t tdListPrepend(SList *list, void *data) {
  SListNode *node = (SListNode *)taosMemoryMalloc(sizeof(SListNode) + list->eleSize);
  if (node == NULL) {
    return terrno = TSDB_CODE_OUT_OF_MEMORY;
  }

  memcpy((void *)(node->data), data, list->eleSize);
  TD_DLIST_PREPEND(list, node);

  return 0;
}

int32_t tdListAppend(SList *list, const void *data) {
  SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
  if (node == NULL) {
    return terrno;
  }

  memcpy((void *)(node->data), data, list->eleSize);
  TD_DLIST_APPEND(list, node);

  return 0;
}
// return the node pointer
SListNode *tdListAdd(SList *list, const void *data) {
  SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
  if (node == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  memcpy((void *)(node->data), data, list->eleSize);
  TD_DLIST_APPEND(list, node);
  return node;
}

SListNode *tdListPopHead(SList *list) {
  SListNode *node;

  node = TD_DLIST_HEAD(list);

  if (node) {
    TD_DLIST_POP(list, node);
  }

  return node;
}

SListNode *tdListPopTail(SList *list) {
  SListNode *node;

  node = TD_DLIST_TAIL(list);
  if (node) {
    TD_DLIST_POP(list, node);
  }

  return node;
}

SListNode *tdListGetHead(SList *list) { return TD_DLIST_HEAD(list); }

SListNode *tdListGetTail(SList *list) { return TD_DLIST_TAIL(list); }

SListNode *tdListPopNode(SList *list, SListNode *node) {
  TD_DLIST_POP(list, node);
  return node;
}

// Move all node elements from src to dst, the dst is assumed as an empty list
void tdListMove(SList *src, SList *dst) {
  SListNode *node = NULL;
  while ((node = tdListPopHead(src)) != NULL) {
    tdListAppendNode(dst, node);
  }
}

void tdListDiscard(SList *list) {
  if (list) {
    listHead(list) = listTail(list) = NULL;
    listNEles(list) = 0;
  }
}

void tdListNodeGetData(SList *list, SListNode *node, void *target) { memcpy(target, node->data, listEleSize(list)); }

void tdListInitIter(SList *list, SListIter *pIter, TD_LIST_DIRECTION_T direction) {
  pIter->direction = direction;
  if (direction == TD_LIST_FORWARD) {
    pIter->next = listHead(list);
  } else {
    pIter->next = listTail(list);
  }
}

SListNode *tdListNext(SListIter *pIter) {
  SListNode *node = pIter->next;
  if (node == NULL) return NULL;
  if (pIter->direction == TD_LIST_FORWARD) {
    pIter->next = TD_DLIST_NODE_NEXT(node);
  } else {
    pIter->next = TD_DLIST_NODE_PREV(node);
  }

  return node;
}

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 "tlist.h"
18
19	void tdListInit(SList *list, int32_t eleSize) {	3,329,975✔
20	TD_DLIST_INIT(list);	3,329,975✔
21	listEleSize(list) = eleSize;	3,329,975✔
22	}	3,329,975✔
23
24	SList *tdListNew(int32_t eleSize) {	3,329,497✔
25	SList list = (SList )taosMemoryMalloc(sizeof(SList));	3,329,497✔
26	if (list == NULL) {	3,330,323!
27	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
28	return NULL;	×
29	}
30
31	tdListInit(list, eleSize);	3,330,323✔
32	return list;	3,330,053✔
33	}
34
35	void tdListEmpty(SList *list) {	3,359,178✔
36	SListNode *node;
37	while ((node = TD_DLIST_HEAD(list)) != NULL) {	11,397,301✔
38	TD_DLIST_POP(list, node);	8,038,115!
39	taosMemoryFree(node);	8,038,115✔
40	}
41	}	3,359,186✔
42
43	void tdListFree(SList list) {	3,406,953✔
44	if (list) {	3,406,953✔
45	tdListEmpty(list);	3,323,821✔
46	taosMemoryFree(list);	3,323,819✔
47	}
48
49	return NULL;	3,407,044✔
50	}
51
52	void tdListEmptyP(SList *list, FDelete fp) {	7,131✔
53	SListNode *node;
54	while ((node = TD_DLIST_HEAD(list)) != NULL) {	5,940,928✔
55	TD_DLIST_POP(list, node);	5,933,797!
56	fp(node->data);	5,933,797✔
57	taosMemoryFree(node);	5,937,875✔
58	}
59	}	7,131✔
60
61	void tdListFreeP(SList *list, FDelete fp) {	7,131✔
62	if (list) {	7,131!
63	tdListEmptyP(list, fp);	7,131✔
64	taosMemoryFree(list);	7,131✔
65	}
66	}	7,131✔
67
68	void tdListPrependNode(SList list, SListNode node) { TD_DLIST_PREPEND(list, node); }	318,286,015!
69
70	void tdListAppendNode(SList list, SListNode node) { TD_DLIST_APPEND(list, node); }	1,260,829✔
71
72	int32_t tdListPrepend(SList list, void data) {	9,895,123✔
73	SListNode node = (SListNode )taosMemoryMalloc(sizeof(SListNode) + list->eleSize);	9,895,123✔
74	if (node == NULL) {	9,898,395!
UNCOV 75	return terrno = TSDB_CODE_OUT_OF_MEMORY;	×
76	}
77
78	memcpy((void *)(node->data), data, list->eleSize);	9,898,726✔
79	TD_DLIST_PREPEND(list, node);	9,898,726✔
80
81	return 0;	9,898,726✔
82	}
83
84	int32_t tdListAppend(SList list, const void data) {	12,240,557✔
85	SListNode node = (SListNode )taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);	12,240,557✔
86	if (node == NULL) {	12,257,056!
UNCOV 87	return terrno;	×
88	}
89
90	memcpy((void *)(node->data), data, list->eleSize);	12,258,388✔
91	TD_DLIST_APPEND(list, node);	12,258,388✔
92
93	return 0;	12,258,388✔
94	}
95	// return the node pointer
96	SListNode tdListAdd(SList list, const void *data) {	509,062✔
97	SListNode node = (SListNode )taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);	509,062✔
98	if (node == NULL) {	509,062!
99	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
100	return NULL;	×
101	}
102
103	memcpy((void *)(node->data), data, list->eleSize);	509,062✔
104	TD_DLIST_APPEND(list, node);	509,062✔
105	return node;	509,062✔
106	}
107
108	SListNode tdListPopHead(SList list) {	6,703,825✔
109	SListNode *node;
110
111	node = TD_DLIST_HEAD(list);	6,703,825✔
112
113	if (node) {	6,703,825✔
114	TD_DLIST_POP(list, node);	591,452!
115	}
116
117	return node;	6,703,825✔
118	}
119
120	SListNode tdListPopTail(SList list) {	3,065✔
121	SListNode *node;
122
123	node = TD_DLIST_TAIL(list);	3,065✔
124	if (node) {	3,065!
125	TD_DLIST_POP(list, node);	3,065!
126	}
127
128	return node;	3,065✔
129	}
130
131	SListNode tdListGetHead(SList list) { return TD_DLIST_HEAD(list); }	9,895,846✔
132
133	SListNode tdListGetTail(SList list) { return TD_DLIST_TAIL(list); }	495✔
134
135	SListNode tdListPopNode(SList list, SListNode *node) {	326,536,014✔
136	TD_DLIST_POP(list, node);	326,536,014✔
137	return node;	326,536,014✔
138	}
139
140	// Move all node elements from src to dst, the dst is assumed as an empty list
141	void tdListMove(SList src, SList dst) {	×
142	SListNode *node = NULL;	×
143	while ((node = tdListPopHead(src)) != NULL) {	×
144	tdListAppendNode(dst, node);	×
145	}
146	}	×
147
148	void tdListDiscard(SList *list) {	×
149	if (list) {	×
150	listHead(list) = listTail(list) = NULL;	×
151	listNEles(list) = 0;	×
152	}
153	}	×
154
155	void tdListNodeGetData(SList list, SListNode node, void *target) { memcpy(target, node->data, listEleSize(list)); }	×
156
157	void tdListInitIter(SList list, SListIter pIter, TD_LIST_DIRECTION_T direction) {	1,849,503✔
158	pIter->direction = direction;	1,849,503✔
159	if (direction == TD_LIST_FORWARD) {	1,849,503✔
160	pIter->next = listHead(list);	7,329✔
161	} else {
162	pIter->next = listTail(list);	1,842,174✔
163	}
164	}	1,849,503✔
165
166	SListNode tdListNext(SListIter pIter) {	8,399,974✔
167	SListNode *node = pIter->next;	8,399,974✔
168	if (node == NULL) return NULL;	8,399,974✔
169	if (pIter->direction == TD_LIST_FORWARD) {	8,392,678✔
170	pIter->next = TD_DLIST_NODE_NEXT(node);	6,301,487✔
171	} else {
172	pIter->next = TD_DLIST_NODE_PREV(node);	2,091,191✔
173	}
174
175	return node;	8,392,678✔
176	}

taosdata / TDengine / #3531

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