#3903

Committed 24 Apr 2025 11:36AM UTC coverage: 55.307% (+0.09%) from 55.213%

Build # #3903

Build Type

push

travis-ci

Committed by

happyguoxy

Commit Message

Sync branches at 2025-04-24 19:35

Run Details

175024 of 316459 relevant lines covered (55.31%)

1151858.11 hits per line

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

66.1

/tools/taos-tools/src/benchDataMix.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 MIT license 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.
 */

#include "bench.h"
#include "benchLog.h"
#include "benchDataMix.h"
#include <float.h>

#define VBOOL_CNT 3

int32_t inul = 20; // interval null count

#define SIGNED_RANDOM(type, high, format)  \
      {                                 \
        type max = high/2;              \
        type min = (max-1) * -1;        \
        type mid = RD(max);             \
        if(RD(50) == 0) {               \
            mid = max;                  \
        } else {                        \
            if(RD(50) == 0) mid = min;  \
        }                               \
        sprintf(val, format, mid);      \
      }                                 \

#define UNSIGNED_RANDOM(type, high, format)   \
      {                                 \
        type max = high;                \
        type min = 0;                   \
        type mid = RD(max);             \
        if(RD(50) == 0) {               \
            mid = max;                  \
        } else {                        \
            if(RD(50) == 0) mid = min;  \
        }                               \
        sprintf(val, format, mid);      \
      }                                 \


#define FLOAT_RANDOM(type, min, max)    \
      {                                 \
        type mid =  RD(100000000);   \
        mid += RD(1000000)/800001.1;    \
        if(RD(50) == 0) {               \
            mid = max;                  \
        } else {                        \
            if(RD(50) == 0) mid = min;  \
        }                               \
        sprintf(val, "%f", mid);        \
      }                                 \


// 32 ~ 126 + '\r' '\n' '\t' radom char
uint32_t genRadomString(char* val, uint32_t len, char* prefix) {
  uint32_t size = RD(len) ;
  if (size < 3) {
    strcpy(val, VAL_NULL);
    return sizeof(VAL_NULL);
  }

  val[0] = '\'';

  int32_t pos = 1;
  int32_t preLen = strlen(prefix);
  if(preLen > 0 && size > preLen + 3) {
    strcpy(&val[1], prefix);
    pos += preLen;
  }

  char spe[] = {'\\', '\r', '\n', '\t'};
  for (int32_t i = pos; i < size - 1; i++) {
    if (false) {
      val[i] = spe[RD(sizeof(spe))];
    } else {
      val[i] = 32 + RD(94);
    }
    if (val[i] == '\'' || val[i] == '\"' || val[i] == '%' || val[i] == '\\') {
      val[i] = 'x';
    }
  }

  val[size - 1] = '\'';
  // set string end
  val[size] = 0;
  return size;
}


// data row generate by randowm
uint32_t dataGenByField(Field* fd, char* pstr, uint32_t len, char* prefix, int64_t *k, char* nullVal) {
    uint32_t size = 0;
    int64_t  nowts= 0;
    char val[512] = {0};
    if( fd->fillNull && RD(inul) == 0 ) {
        size = sprintf(pstr + len, ",%s", nullVal);
        return size;
    }

    const char * format = ",%s";

    switch (fd->type) {    
    case TSDB_DATA_TYPE_BOOL:
        sprintf(val, "%d", tmpBool(fd));
        break;
    // timestamp    
    case TSDB_DATA_TYPE_TIMESTAMP:
        nowts = toolsGetTimestampMs();
        strcpy(val, "\'");
        toolsFormatTimestamp(val, nowts, TSDB_TIME_PRECISION_MILLI);
        strcat(val, "\'");
        break;
    // signed    
    case TSDB_DATA_TYPE_TINYINT:
        sprintf(val, "%d", tmpInt8Impl(fd, *k));
        break;        
    case TSDB_DATA_TYPE_SMALLINT:
        sprintf(val, "%d", tmpInt16Impl(fd, *k));
        break;
    case TSDB_DATA_TYPE_INT:
        sprintf(val, "%d", tmpInt32Impl(fd, 0, 0, *k));
        break;
    case TSDB_DATA_TYPE_BIGINT:
        sprintf(val, "%"PRId64, tmpInt64Impl(fd, 0, *k));
        break;
    // unsigned    
    case TSDB_DATA_TYPE_UTINYINT:
        sprintf(val, "%u", tmpUint8Impl(fd, *k));
        break;
    case TSDB_DATA_TYPE_USMALLINT:
        sprintf(val, "%u", tmpUint16Impl(fd, *k));
        break;
    case TSDB_DATA_TYPE_UINT:
        sprintf(val, "%u", tmpUint32Impl(fd, 0, 0, *k));
        break;
    case TSDB_DATA_TYPE_UBIGINT:
        sprintf(val, "%"PRIu64, tmpUint64Impl(fd, 0, *k));
        break;
    // float double
    case TSDB_DATA_TYPE_FLOAT:
        sprintf(val, "%f", tmpFloatImpl(fd, 0, 0, *k));
        break;
    case TSDB_DATA_TYPE_DOUBLE:
        sprintf(val, "%f", tmpDoubleImpl(fd, 0, *k));
        break;
    case TSDB_DATA_TYPE_DECIMAL: {
        Decimal128 dec = tmpDecimal128Impl(fd, 0, *k);
        decimal128ToString(&dec, fd->precision, fd->scale, val, sizeof(val));
        break;
    }
    case TSDB_DATA_TYPE_DECIMAL64: {
        Decimal64 dec = tmpDecimal64Impl(fd, 0, *k);
        decimal64ToString(&dec, fd->precision, fd->scale, val, sizeof(val));
        break;
    }
    // binary nchar
    case TSDB_DATA_TYPE_NCHAR:
    case TSDB_DATA_TYPE_BINARY:
    case TSDB_DATA_TYPE_VARBINARY:
        format = ",\'%s\'";
        tmpStr(val, 0, fd, *k);
        break;
    case TSDB_DATA_TYPE_GEOMETRY:
        tmpGeometry(val, 0, fd, 0);
        break;
    default:
        break;
    }

    size += sprintf(pstr + len, format, val);
    return size;
}


// data row generate by ts calc
uint32_t dataGenByCalcTs(Field* fd, char* pstr, uint32_t len, int64_t ts) {
    uint32_t size = 0;
    char val[512] = VAL_NULL;

    switch (fd->type) {    
    case TSDB_DATA_TYPE_BOOL:
        strcpy(val, (ts % 2 == 0) ? "true" : "false");
        break;
    // timestamp
    case TSDB_DATA_TYPE_TIMESTAMP:
        sprintf(val, "%" PRId64, ts);
        break;
    // signed    
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
        sprintf(val, "%d", (int32_t)(ts%100)); 
        break;
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
        sprintf(val, "%d", (int32_t)(ts%1000000)); 
        break;
    // unsigned    
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
        sprintf(val, "%u", (uint32_t)(ts%100)); 
        break;    
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
        sprintf(val, "%u", (uint32_t)(ts%1000000)); 
        break;
    // float double
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
        sprintf(val, "%u.%u", (uint32_t)(ts/10000), (uint32_t)(ts%10000)); 
        break;
    // binary nchar
    case TSDB_DATA_TYPE_BINARY:
    case TSDB_DATA_TYPE_VARBINARY:
    case TSDB_DATA_TYPE_NCHAR:
        sprintf(val, "%" PRId64, ts);
        break;
    default:
        break;
    }

    size += sprintf(pstr + len, ",%s", val);
    return size;
}

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 MIT license as published by the Free Software
6	* 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
13	#include "bench.h"
14	#include "benchLog.h"
15	#include "benchDataMix.h"
16	#include <float.h>
17
18	#define VBOOL_CNT 3
19
20	int32_t inul = 20; // interval null count
21
22	#define SIGNED_RANDOM(type, high, format) \
23	{ \
24	type max = high/2; \
25	type min = (max-1) * -1; \
26	type mid = RD(max); \
27	if(RD(50) == 0) { \
28	mid = max; \
29	} else { \
30	if(RD(50) == 0) mid = min; \
31	} \
32	sprintf(val, format, mid); \
33	} \
34
35	#define UNSIGNED_RANDOM(type, high, format) \
36	{ \
37	type max = high; \
38	type min = 0; \
39	type mid = RD(max); \
40	if(RD(50) == 0) { \
41	mid = max; \
42	} else { \
43	if(RD(50) == 0) mid = min; \
44	} \
45	sprintf(val, format, mid); \
46	} \
47
48
49	#define FLOAT_RANDOM(type, min, max) \
50	{ \
51	type mid = RD(100000000); \
52	mid += RD(1000000)/800001.1; \
53	if(RD(50) == 0) { \
54	mid = max; \
55	} else { \
56	if(RD(50) == 0) mid = min; \
57	} \
58	sprintf(val, "%f", mid); \
59	} \
60
61
62	// 32 ~ 126 + '\r' '\n' '\t' radom char
63	uint32_t genRadomString(char* val, uint32_t len, char* prefix) {	×
64	uint32_t size = RD(len) ;	×
65	if (size < 3) {	×
66	strcpy(val, VAL_NULL);	×
67	return sizeof(VAL_NULL);	×
68	}
69
70	val[0] = '\'';	×
71
72	int32_t pos = 1;	×
73	int32_t preLen = strlen(prefix);	×
74	if(preLen > 0 && size > preLen + 3) {	×
75	strcpy(&val[1], prefix);	×
76	pos += preLen;	×
77	}
78
79	char spe[] = {'\\', '\r', '\n', '\t'};	×
80	for (int32_t i = pos; i < size - 1; i++) {	×
81	if (false) {
82	val[i] = spe[RD(sizeof(spe))];
83	} else {
84	val[i] = 32 + RD(94);	×
85	}
86	if (val[i] == '\'' \|\| val[i] == '\"' \|\| val[i] == '%' \|\| val[i] == '\\') {	×
87	val[i] = 'x';	×
88	}
89	}
90
91	val[size - 1] = '\'';	×
92	// set string end
93	val[size] = 0;	×
94	return size;	×
95	}
96
97
98	// data row generate by randowm
99	uint32_t dataGenByField(Field* fd, char* pstr, uint32_t len, char* prefix, int64_t k, char nullVal) {	13,740,796✔
100	uint32_t size = 0;	13,740,796✔
101	int64_t nowts= 0;	13,740,796✔
102	char val[512] = {0};	13,740,796✔
103	if( fd->fillNull && RD(inul) == 0 ) {	13,740,796✔
104	size = sprintf(pstr + len, ",%s", nullVal);	613,307✔
105	return size;	613,307✔
106	}
107
108	const char * format = ",%s";	13,240,567✔
109
110	switch (fd->type) {	13,240,567✔
111	case TSDB_DATA_TYPE_BOOL:	969,407✔
112	sprintf(val, "%d", tmpBool(fd));	969,407✔
113	break;	969,392✔
114	// timestamp
115	case TSDB_DATA_TYPE_TIMESTAMP:	×
116	nowts = toolsGetTimestampMs();	×
117	strcpy(val, "\'");	×
118	toolsFormatTimestamp(val, nowts, TSDB_TIME_PRECISION_MILLI);	×
119	strcat(val, "\'");	×
120	break;	×
121	// signed
122	case TSDB_DATA_TYPE_TINYINT:	968,634✔
123	sprintf(val, "%d", tmpInt8Impl(fd, *k));	968,634✔
124	break;	968,886✔
125	case TSDB_DATA_TYPE_SMALLINT:	968,739✔
126	sprintf(val, "%d", tmpInt16Impl(fd, *k));	968,739✔
127	break;	967,987✔
128	case TSDB_DATA_TYPE_INT:	2,024,639✔
129	sprintf(val, "%d", tmpInt32Impl(fd, 0, 0, *k));	2,024,639✔
130	break;	2,020,241✔
131	case TSDB_DATA_TYPE_BIGINT:	969,271✔
132	sprintf(val, "%"PRId64, tmpInt64Impl(fd, 0, *k));	969,271✔
133	break;	968,951✔
134	// unsigned
135	case TSDB_DATA_TYPE_UTINYINT:	969,221✔
136	sprintf(val, "%u", tmpUint8Impl(fd, *k));	969,221✔
137	break;	968,846✔
138	case TSDB_DATA_TYPE_USMALLINT:	969,125✔
139	sprintf(val, "%u", tmpUint16Impl(fd, *k));	969,125✔
140	break;	968,993✔
141	case TSDB_DATA_TYPE_UINT:	968,505✔
142	sprintf(val, "%u", tmpUint32Impl(fd, 0, 0, *k));	968,505✔
143	break;	968,123✔
144	case TSDB_DATA_TYPE_UBIGINT:	968,764✔
145	sprintf(val, "%"PRIu64, tmpUint64Impl(fd, 0, *k));	968,764✔
146	break;	968,626✔
147	// float double
148	case TSDB_DATA_TYPE_FLOAT:	968,166✔
149	sprintf(val, "%f", tmpFloatImpl(fd, 0, 0, *k));	968,166✔
150	break;	968,117✔
151	case TSDB_DATA_TYPE_DOUBLE:	968,653✔
152	sprintf(val, "%f", tmpDoubleImpl(fd, 0, *k));	968,653✔
153	break;	968,610✔
154	case TSDB_DATA_TYPE_DECIMAL: {	×
155	Decimal128 dec = tmpDecimal128Impl(fd, 0, *k);	×
156	decimal128ToString(&dec, fd->precision, fd->scale, val, sizeof(val));	×
157	break;	×
158	}
159	case TSDB_DATA_TYPE_DECIMAL64: {	×
160	Decimal64 dec = tmpDecimal64Impl(fd, 0, *k);	×
161	decimal64ToString(&dec, fd->precision, fd->scale, val, sizeof(val));	×
162	break;	×
163	}
164	// binary nchar
165	case TSDB_DATA_TYPE_NCHAR:	1,935,608✔
166	case TSDB_DATA_TYPE_BINARY:
167	case TSDB_DATA_TYPE_VARBINARY:
168	format = ",\'%s\'";	1,935,608✔
169	tmpStr(val, 0, fd, *k);	1,935,608✔
170	break;	1,932,588✔
171	case TSDB_DATA_TYPE_GEOMETRY:	×
172	tmpGeometry(val, 0, fd, 0);	×
173	break;	×
174	default:	×
175	break;	×
176	}
177
178	size += sprintf(pstr + len, format, val);	13,204,822✔
179	return size;	13,204,822✔
180	}
181
182
183	// data row generate by ts calc
184	uint32_t dataGenByCalcTs(Field* fd, char* pstr, uint32_t len, int64_t ts) {	463,235✔
185	uint32_t size = 0;	463,235✔
186	char val[512] = VAL_NULL;	463,235✔
187
188	switch (fd->type) {	463,235✔
189	case TSDB_DATA_TYPE_BOOL:	35,496✔
190	strcpy(val, (ts % 2 == 0) ? "true" : "false");	35,496✔
191	break;	35,496✔
192	// timestamp
193	case TSDB_DATA_TYPE_TIMESTAMP:	4,000✔
194	sprintf(val, "%" PRId64, ts);	4,000✔
195	break;	4,000✔
196	// signed
197	case TSDB_DATA_TYPE_TINYINT:	70,959✔
198	case TSDB_DATA_TYPE_SMALLINT:
199	sprintf(val, "%d", (int32_t)(ts%100));	70,959✔
200	break;	70,959✔
201	case TSDB_DATA_TYPE_INT:	70,969✔
202	case TSDB_DATA_TYPE_BIGINT:
203	sprintf(val, "%d", (int32_t)(ts%1000000));	70,969✔
204	break;	70,969✔
205	// unsigned
206	case TSDB_DATA_TYPE_UTINYINT:	70,969✔
207	case TSDB_DATA_TYPE_USMALLINT:
208	sprintf(val, "%u", (uint32_t)(ts%100));	70,969✔
209	break;	70,969✔
210	case TSDB_DATA_TYPE_UINT:	70,973✔
211	case TSDB_DATA_TYPE_UBIGINT:
212	sprintf(val, "%u", (uint32_t)(ts%1000000));	70,973✔
213	break;	70,973✔
214	// float double
215	case TSDB_DATA_TYPE_FLOAT:	70,975✔
216	case TSDB_DATA_TYPE_DOUBLE:
217	sprintf(val, "%u.%u", (uint32_t)(ts/10000), (uint32_t)(ts%10000));	70,975✔
218	break;	70,975✔
219	// binary nchar
220	case TSDB_DATA_TYPE_BINARY:	70,967✔
221	case TSDB_DATA_TYPE_VARBINARY:
222	case TSDB_DATA_TYPE_NCHAR:
223	sprintf(val, "%" PRId64, ts);	70,967✔
224	break;	70,967✔
225	default:	×
226	break;	×
227	}
228
229	size += sprintf(pstr + len, ",%s", val);	463,235✔
230	return size;	463,235✔
231	}

taosdata / TDengine / #3903

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