// TAOS standard API example. The same syntax as MySQL, but only a subet // to compile: gcc -o prepare prepare.c -ltaos #include #include #include #include #include #include #include "../../../include/client/taos.h" #define FUNCTION_TEST_IDX 1 #define TIME_PRECISION_MILLI 0 #define TIME_PRECISION_MICRO 1 #define TIME_PRECISION_NANO 2 int32_t shortColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_INT}; int32_t fullColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_BOOL, TSDB_DATA_TYPE_TINYINT, TSDB_DATA_TYPE_UTINYINT, TSDB_DATA_TYPE_SMALLINT, TSDB_DATA_TYPE_USMALLINT, TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_UINT, TSDB_DATA_TYPE_BIGINT, TSDB_DATA_TYPE_UBIGINT, TSDB_DATA_TYPE_FLOAT, TSDB_DATA_TYPE_DOUBLE, TSDB_DATA_TYPE_BINARY, TSDB_DATA_TYPE_NCHAR}; int32_t bindColTypeList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_NCHAR}; int32_t optrIdxList[] = {5, 11}; typedef struct { char *oper; int32_t paramNum; bool enclose; } OperInfo; typedef struct { char *funcName; int32_t paramNum; } FuncInfo; typedef enum { BP_BIND_COL = 1, BP_BIND_TAG, } BP_BIND_TYPE; #define BP_BIND_TYPE_STR(t) (((t) == BP_BIND_COL) ? "column" : "tag") OperInfo operInfo[] = { {">", 2, false}, {">=", 2, false}, {"<", 2, false}, {"<=", 2, false}, {"=", 2, false}, {"<>", 2, false}, {"in", 2, true}, {"not in", 2, true}, {"like", 2, false}, {"not like", 2, false}, {"match", 2, false}, {"nmatch", 2, false}, }; int32_t operatorList[] = {0, 1, 2, 3, 4, 5, 6, 7}; int32_t varoperatorList[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; FuncInfo funcInfo[] = { {"count", 1}, {"sum", 1}, {"min", 1}, }; #define BP_STARTUP_TS 1591060628000 char *bpStbPrefix = "st"; char *bpTbPrefix = "t"; int32_t bpDefaultStbId = 1; int64_t bpTs; // char *operatorList[] = {">", ">=", "<", "<=", "=", "<>", "in", "not in"}; // char *varoperatorList[] = {">", ">=", "<", "<=", "=", "<>", "in", "not in", "like", "not like", "match", "nmatch"}; #define tListLen(x) (sizeof(x) / sizeof((x)[0])) #define IS_SIGNED_NUMERIC_TYPE(_t) ((_t) >= TSDB_DATA_TYPE_TINYINT && (_t) <= TSDB_DATA_TYPE_BIGINT) #define IS_UNSIGNED_NUMERIC_TYPE(_t) ((_t) >= TSDB_DATA_TYPE_UTINYINT && (_t) <= TSDB_DATA_TYPE_UBIGINT) #define IS_FLOAT_TYPE(_t) ((_t) == TSDB_DATA_TYPE_FLOAT || (_t) == TSDB_DATA_TYPE_DOUBLE) #define IS_NUMERIC_TYPE(_t) ((IS_SIGNED_NUMERIC_TYPE(_t)) || (IS_UNSIGNED_NUMERIC_TYPE(_t)) || (IS_FLOAT_TYPE(_t))) typedef struct { bool singleTbInsert; int32_t singleTbIdx; int64_t *tsData; bool *boolData; int8_t *tinyData; uint8_t *utinyData; int16_t *smallData; uint16_t *usmallData; int32_t *intData; uint32_t *uintData; int64_t *bigData; uint64_t *ubigData; float *floatData; double *doubleData; char *binaryData; char *isNull; int32_t *binaryLen; TAOS_STMT2_BIND *pBind; TAOS_STMT2_BIND *pTags; char *sql; int32_t *colTypes; int32_t colNum; } BindData; int32_t gVarCharSize = 10; int32_t gVarCharLen = 5; int32_t gExecLoopTimes = 1; // no change int32_t gFullColNum = tListLen(fullColList); int insertMBSETest1(TAOS_STMT2 *stmt, TAOS *taos); int insertMBSETest2(TAOS_STMT2 *stmt, TAOS *taos); int insertMBMETest1(TAOS_STMT2 *stmt, TAOS *taos); int insertMBMETest2(TAOS_STMT2 *stmt, TAOS *taos); int insertMBMETest3(TAOS_STMT2 *stmt, TAOS *taos); int insertMBMETest4(TAOS_STMT2 *stmt, TAOS *taos); int insertMPMETest1(TAOS_STMT2 *stmt, TAOS *taos); int insertAUTOTest1(TAOS_STMT2 *stmt, TAOS *taos); int insertAUTOTest2(TAOS_STMT2 *stmt, TAOS *taos); int insertAUTOTest3(TAOS_STMT2 *stmt, TAOS *taos); int queryColumnTest(TAOS_STMT2 *stmt, TAOS *taos); int queryMiscTest(TAOS_STMT2 *stmt, TAOS *taos); int insertNonExistsTb(TAOS_STMT2 *stmt, TAOS *taos); int insertVarLenErr(TAOS_STMT2 *stmt, TAOS *taos); int insertStbTest(TAOS_STMT2 *stmt, TAOS *taos); enum { TTYPE_INSERT = 1, TTYPE_INSERT_NG, TTYPE_QUERY, }; typedef struct { char caseDesc[128]; int32_t colNum; int32_t *colList; // full table column list int32_t testType; int32_t autoCreateTbl; bool duplicateValue; bool fullCol; int32_t (*runFn)(TAOS_STMT2 *, TAOS *); int32_t tblNum; int32_t rowNum; int32_t bindRowNum; int32_t bindColNum; // equal colNum in full column case int32_t bindTagNum; // equal colNum in full column case int32_t bindNullNum; int32_t runTimes; int32_t preCaseIdx; bool stbInsert; } CaseCfg; CaseCfg gCase[] = { {"insert:MBSE0-FULL", tListLen(shortColList), shortColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 1, 10, 10, 0, 0, 0, 1, -1, false}, {"insert:MBSE0-FULL", tListLen(shortColList), shortColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 10, 100, 10, 0, 0, 0, 1, -1, false}, {"insert:MBSE1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBSE1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest1, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBSE1-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest1, 10, 10, 2, 2, 0, 0, 1, -1, false}, {"insert:MBSE2-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBSETest2, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBSE2-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest2, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBSE2-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest2, 10, 10, 2, 2, 0, 0, 1, -1, false}, {"insert:MBME1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest1, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBME1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest1, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBME1-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest1, 10, 10, 2, 2, 0, 0, 1, -1, false}, // 11 {"insert:MBME2-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest2, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBME2-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest2, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBME2-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest2, 10, 10, 2, 2, 0, 0, 1, -1, false}, {"insert:MBME3-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest3, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBME3-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest3, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBME3-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest3, 10, 10, 2, 2, 0, 0, 1, -1, false}, {"insert:MBME4-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest4, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MBME4-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest4, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:MBME4-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest4, 10, 10, 2, 2, 0, 0, 1, -1, false}, {"insert:MPME1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMPMETest1, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:MPME1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMPMETest1, 10, 10, 2, 12, 0, 0, 1, -1, false}, {"insert:STBI-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertStbTest, 10, 10, 2, 0, 0, 0, 1, -1, true}, // 23 {"insert:AUTO1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 1, false, true, insertAUTOTest1, 10, 10, 2, 0, 0, 0, 1, -1, false}, {"insert:AUTO2-TBEXISTS", tListLen(fullColList), fullColList, TTYPE_INSERT, 3, false, true, insertAUTOTest2, 10, 10, 2, 0, 0, 0, 1, -1, false}, // {"insert:AUTO3-NTB", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, true, true, insertAUTOTest3, 10, 10, // 2, 0, 0, 0, 1, -1, false}, {"query:SUBT-COLUMN", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryColumnTest, 10, 10, 1, 3, 0, 0, 1, 2, false}, {"query:SUBT-MISC", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryMiscTest, 10, 10, 1, 3, 0, 0, 1, 2, false}, {"query:NG-TBNEXISTS", tListLen(fullColList), fullColList, TTYPE_INSERT_NG, 0, false, false, insertNonExistsTb, 10, 10, 1, 3, 0, 0, 1, -1, false}, {"query:NG-VARLENERR", tListLen(fullColList), fullColList, TTYPE_INSERT_NG, 0, false, true, insertVarLenErr, 10, 10, 1, 3, 0, 0, 1, -1, false}, // {"query:SUBT-COLUMN", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryColumnTest, 1, 10, // 1, 1, 0, 0, 1, 2, false}, // {"query:SUBT-MISC", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryMiscTest, 2, 10, 1, // 1, 0, 0, 1, 2, false}, }; CaseCfg *gCurCase = NULL; typedef struct { char caseCatalog[255]; int32_t bindNullNum; bool checkParamNum; bool printRes; bool printCreateTblSql; bool printQuerySql; bool printStmtSql; bool printVerbose; bool autoCreateTbl; bool numericParam; uint8_t precision; int32_t rowNum; // row num for one table int32_t bindColNum; int32_t bindTagNum; int32_t bindRowNum; // row num for once bind int32_t bindColTypeNum; int32_t *bindColTypeList; int32_t bindTagTypeNum; int32_t *bindTagTypeList; int32_t optrIdxListNum; int32_t *optrIdxList; int32_t funcIdxListNum; int32_t *funcIdxList; int32_t runTimes; int32_t caseIdx; // static case idx int32_t caseNum; // num in static case list int32_t caseRunIdx; // runtime case idx int32_t caseRunNum; // total run case num } CaseCtrl; #if 0 CaseCtrl gCaseCtrl = { .precision = TIME_PRECISION_MILLI, .bindNullNum = 0, .printCreateTblSql = true, .printQuerySql = true, .printStmtSql = true, .printVerbose = true, .printRes = true, .autoCreateTbl = false, .numericParam = false, .rowNum = 0, .bindColNum = 0, .bindTagNum = 0, .bindRowNum = 0, .bindColTypeNum = 0, .bindColTypeList = NULL, .bindTagTypeNum = 0, .bindTagTypeList = NULL, .optrIdxListNum = 0, .optrIdxList = NULL, .funcIdxListNum = 0, .funcIdxList = NULL, .checkParamNum = false, .runTimes = 0, .caseIdx = 20, .caseNum = 1, .caseRunIdx = -1, .caseRunNum = -1, }; #endif #if 1 CaseCtrl gCaseCtrl = { // default .precision = TIME_PRECISION_MILLI, .bindNullNum = 0, .printCreateTblSql = true, .printQuerySql = true, .printStmtSql = true, .printVerbose = false, .printRes = true, .autoCreateTbl = false, .numericParam = false, .rowNum = 0, .bindColNum = 0, .bindTagNum = 0, .bindRowNum = 0, .bindColTypeNum = 0, .bindColTypeList = NULL, .bindTagTypeNum = 0, .bindTagTypeList = NULL, .optrIdxListNum = 0, .optrIdxList = NULL, .funcIdxListNum = 0, .funcIdxList = NULL, .checkParamNum = false, .runTimes = 0, .caseIdx = -1, .caseNum = -1, .caseRunIdx = -1, .caseRunNum = -1, }; #endif #if 0 CaseCtrl gCaseCtrl = { // query case with specified col&oper .bindNullNum = 1, .printCreateTblSql = false, .printQuerySql = true, .printStmtSql = true, .rowNum = 0, .bindColNum = 0, .bindRowNum = 0, .optrIdxListNum = tListLen(optrIdxList), .optrIdxList = optrIdxList, .bindColTypeNum = tListLen(bindColTypeList), .bindColTypeList = bindColTypeList, .checkParamNum = false, .printRes = true, .runTimes = 0, .caseRunIdx = -1, .caseIdx = 5, .caseNum = 1, .caseRunNum = 1, }; #endif #if 0 CaseCtrl gCaseCtrl = { // query case with specified col&oper .bindNullNum = 0, .printCreateTblSql = true, .printQuerySql = true, .printStmtSql = true, .autoCreateTbl = true, .rowNum = 0, .bindColNum = 0, .bindTagNum = 0, .bindRowNum = 0, .bindColTypeNum = 0, .bindColTypeList = bindColTypeList, .optrIdxListNum = 0, .optrIdxList = optrIdxList, .checkParamNum = false, .printRes = true, .runTimes = 0, .caseRunIdx = -1, .optrIdxListNum = tListLen(optrIdxList), .optrIdxList = optrIdxList, .bindColTypeNum = tListLen(bindColTypeList), .bindColTypeList = bindColTypeList, .caseRunIdx = -1, .caseIdx = 24, .caseNum = 1, .caseRunNum = 1, }; #endif int32_t taosGetTimeOfDay(struct timeval *tv) { return gettimeofday(tv, NULL); } void *taosMemoryMalloc(uint64_t size) { return malloc(size); } void *taosMemoryCalloc(int32_t num, int32_t size) { return calloc(num, size); } void taosMemoryFree(const void *ptr) { if (ptr == NULL) return; return free((void *)ptr); } static int64_t taosGetTimestampMs() { struct timeval systemTime; taosGetTimeOfDay(&systemTime); return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_usec / 1000; } static int64_t taosGetTimestampUs() { struct timeval systemTime; taosGetTimeOfDay(&systemTime); return (int64_t)systemTime.tv_sec * 1000000LL + (int64_t)systemTime.tv_usec; } bool colExists(TAOS_STMT2_BIND *pBind, int32_t dataType) { int32_t i = 0; while (true) { if (0 == pBind[i].buffer_type) { return false; } if (pBind[i].buffer_type == dataType) { return true; } ++i; } } void generateInsertSQL(BindData *data) { int32_t len = 0; if (gCurCase->tblNum > 1) { if (data->singleTbInsert) { len = sprintf(data->sql, "insert into %s%d ", bpTbPrefix, data->singleTbIdx); } else { len = sprintf(data->sql, "insert into ? "); } } else { len = sprintf(data->sql, "insert into %s0 ", bpTbPrefix); } if (gCurCase->bindTagNum > 0) { len += sprintf(data->sql + len, "using %s%d ", bpStbPrefix, bpDefaultStbId); if (!gCurCase->fullCol) { len += sprintf(data->sql + len, "("); for (int c = 0; c < gCurCase->bindTagNum; ++c) { if (c) { len += sprintf(data->sql + len, ","); } switch (data->pTags[c].buffer_type) { case TSDB_DATA_TYPE_BOOL: len += sprintf(data->sql + len, "tbooldata"); break; case TSDB_DATA_TYPE_TINYINT: len += sprintf(data->sql + len, "ttinydata"); break; case TSDB_DATA_TYPE_SMALLINT: len += sprintf(data->sql + len, "tsmalldata"); break; case TSDB_DATA_TYPE_INT: len += sprintf(data->sql + len, "tintdata"); break; case TSDB_DATA_TYPE_BIGINT: len += sprintf(data->sql + len, "tbigdata"); break; case TSDB_DATA_TYPE_FLOAT: len += sprintf(data->sql + len, "tfloatdata"); break; case TSDB_DATA_TYPE_DOUBLE: len += sprintf(data->sql + len, "tdoubledata"); break; case TSDB_DATA_TYPE_VARCHAR: len += sprintf(data->sql + len, "tbinarydata"); break; case TSDB_DATA_TYPE_TIMESTAMP: len += sprintf(data->sql + len, "tts"); break; case TSDB_DATA_TYPE_NCHAR: len += sprintf(data->sql + len, "tnchardata"); break; case TSDB_DATA_TYPE_UTINYINT: len += sprintf(data->sql + len, "tutinydata"); break; case TSDB_DATA_TYPE_USMALLINT: len += sprintf(data->sql + len, "tusmalldata"); break; case TSDB_DATA_TYPE_UINT: len += sprintf(data->sql + len, "tuintdata"); break; case TSDB_DATA_TYPE_UBIGINT: len += sprintf(data->sql + len, "tubigdata"); break; default: printf("!!!invalid tag type:%d", data->pTags[c].buffer_type); exit(1); } } len += sprintf(data->sql + len, ") "); } len += sprintf(data->sql + len, "tags ("); for (int c = 0; c < gCurCase->bindTagNum; ++c) { if (c) { len += sprintf(data->sql + len, ","); } len += sprintf(data->sql + len, "?"); } len += sprintf(data->sql + len, ") "); } if (!gCurCase->fullCol) { len += sprintf(data->sql + len, "("); for (int c = 0; c < gCurCase->bindColNum; ++c) { if (c) { len += sprintf(data->sql + len, ","); } switch (data->pBind[c].buffer_type) { case TSDB_DATA_TYPE_BOOL: len += sprintf(data->sql + len, "booldata"); break; case TSDB_DATA_TYPE_TINYINT: len += sprintf(data->sql + len, "tinydata"); break; case TSDB_DATA_TYPE_SMALLINT: len += sprintf(data->sql + len, "smalldata"); break; case TSDB_DATA_TYPE_INT: len += sprintf(data->sql + len, "intdata"); break; case TSDB_DATA_TYPE_BIGINT: len += sprintf(data->sql + len, "bigdata"); break; case TSDB_DATA_TYPE_FLOAT: len += sprintf(data->sql + len, "floatdata"); break; case TSDB_DATA_TYPE_DOUBLE: len += sprintf(data->sql + len, "doubledata"); break; case TSDB_DATA_TYPE_VARCHAR: len += sprintf(data->sql + len, "binarydata"); break; case TSDB_DATA_TYPE_TIMESTAMP: len += sprintf(data->sql + len, "ts"); break; case TSDB_DATA_TYPE_NCHAR: len += sprintf(data->sql + len, "nchardata"); break; case TSDB_DATA_TYPE_UTINYINT: len += sprintf(data->sql + len, "utinydata"); break; case TSDB_DATA_TYPE_USMALLINT: len += sprintf(data->sql + len, "usmalldata"); break; case TSDB_DATA_TYPE_UINT: len += sprintf(data->sql + len, "uintdata"); break; case TSDB_DATA_TYPE_UBIGINT: len += sprintf(data->sql + len, "ubigdata"); break; default: printf("!!!invalid col type:%d", data->pBind[c].buffer_type); exit(1); } } len += sprintf(data->sql + len, ") "); } len += sprintf(data->sql + len, "values ("); for (int c = 0; c < gCurCase->bindColNum; ++c) { if (c) { len += sprintf(data->sql + len, ","); } len += sprintf(data->sql + len, "?"); } len += sprintf(data->sql + len, ")"); if (gCaseCtrl.printStmtSql) { printf("\tSQL: %s\n", data->sql); } } void bpAppendOperatorParam(BindData *data, int32_t *len, int32_t dataType, int32_t idx) { OperInfo *pInfo = NULL; if (gCaseCtrl.optrIdxListNum > 0) { pInfo = &operInfo[gCaseCtrl.optrIdxList[idx]]; } else { if (TSDB_DATA_TYPE_VARCHAR == dataType || TSDB_DATA_TYPE_NCHAR == dataType || TSDB_DATA_TYPE_GEOMETRY == dataType) { #if 1 pInfo = &operInfo[varoperatorList[rand() % tListLen(varoperatorList)]]; #else pInfo = &operInfo[11]; #endif } else { pInfo = &operInfo[operatorList[rand() % tListLen(operatorList)]]; } } switch (pInfo->paramNum) { case 2: if (pInfo->enclose) { *len += sprintf(data->sql + *len, " %s (?)", pInfo->oper); } else { *len += sprintf(data->sql + *len, " %s ?", pInfo->oper); } break; default: printf("!!!invalid operator paramNum:%d\n", pInfo->paramNum); exit(1); } } void bpAppendFunctionParam(BindData *data, int32_t *len, int32_t dataType, int32_t idx) { FuncInfo *pInfo = NULL; if (gCaseCtrl.funcIdxListNum > 0) { pInfo = &funcInfo[gCaseCtrl.funcIdxList[idx]]; } else { pInfo = &funcInfo[rand() % tListLen(funcInfo)]; } switch (pInfo->paramNum) { case 1: *len += sprintf(data->sql + *len, " %s(?)", pInfo->funcName); break; default: printf("!!!invalid function paramNum:%d\n", pInfo->paramNum); exit(1); } } int32_t bpAppendColumnName(BindData *data, int32_t type, int32_t len) { switch (type) { case TSDB_DATA_TYPE_BOOL: return sprintf(data->sql + len, "booldata"); break; case TSDB_DATA_TYPE_TINYINT: return sprintf(data->sql + len, "tinydata"); break; case TSDB_DATA_TYPE_SMALLINT: return sprintf(data->sql + len, "smalldata"); break; case TSDB_DATA_TYPE_INT: return sprintf(data->sql + len, "intdata"); break; case TSDB_DATA_TYPE_BIGINT: return sprintf(data->sql + len, "bigdata"); break; case TSDB_DATA_TYPE_FLOAT: return sprintf(data->sql + len, "floatdata"); break; case TSDB_DATA_TYPE_DOUBLE: return sprintf(data->sql + len, "doubledata"); break; case TSDB_DATA_TYPE_VARCHAR: return sprintf(data->sql + len, "binarydata"); break; case TSDB_DATA_TYPE_TIMESTAMP: return sprintf(data->sql + len, "ts"); break; case TSDB_DATA_TYPE_NCHAR: return sprintf(data->sql + len, "nchardata"); break; case TSDB_DATA_TYPE_UTINYINT: return sprintf(data->sql + len, "utinydata"); break; case TSDB_DATA_TYPE_USMALLINT: return sprintf(data->sql + len, "usmalldata"); break; case TSDB_DATA_TYPE_UINT: return sprintf(data->sql + len, "uintdata"); break; case TSDB_DATA_TYPE_UBIGINT: return sprintf(data->sql + len, "ubigdata"); break; default: printf("!!!invalid col type:%d", type); exit(1); } return 0; } void generateQueryCondSQL(BindData *data, int32_t tblIdx) { int32_t len = sprintf(data->sql, "select * from %s%d where ", bpTbPrefix, tblIdx); if (!gCurCase->fullCol) { for (int c = 0; c < gCurCase->bindColNum; ++c) { if (c) { len += sprintf(data->sql + len, " and "); } len += bpAppendColumnName(data, data->pBind[c].buffer_type, len); bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type, c); } } if (gCaseCtrl.printStmtSql) { printf("\tSTMT SQL: %s\n", data->sql); } } void bpGenerateConstInOpSQL(BindData *data, int32_t tblIdx) { int32_t len = 0; len = sprintf(data->sql, "select "); for (int c = 0; c < gCurCase->bindColNum; ++c) { if (c) { len += sprintf(data->sql + len, ", "); } len += bpAppendColumnName(data, data->pBind[c].buffer_type, len); bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type, c); } len += sprintf(data->sql + len, " from %s%d", bpTbPrefix, tblIdx); } void bpGenerateConstInFuncSQL(BindData *data, int32_t tblIdx) { int32_t len = 0; len = sprintf(data->sql, "select "); for (int c = 0; c < gCurCase->bindColNum; ++c) { if (c) { len += sprintf(data->sql + len, ", "); } bpAppendFunctionParam(data, &len, data->pBind[c].buffer_type, c); } len += sprintf(data->sql + len, " from %s%d", bpTbPrefix, tblIdx); } void generateQueryMiscSQL(BindData *data, int32_t tblIdx) { if (tblIdx == FUNCTION_TEST_IDX && gCurCase->bindNullNum <= 0) { bpGenerateConstInFuncSQL(data, tblIdx); } else { switch (tblIdx) { case 0: // TODO FILL TEST default: bpGenerateConstInOpSQL(data, tblIdx); break; } } if (gCaseCtrl.printStmtSql) { printf("\tSTMT SQL: %s\n", data->sql); } } void generateErrorSQL(BindData *data, int32_t tblIdx) { int32_t len = 0; data->sql = taosMemoryCalloc(1, 1024); switch (tblIdx) { case 0: len = sprintf(data->sql, "insert into %s%d values (?, 1)", bpTbPrefix, tblIdx); break; case 1: len = sprintf(data->sql, "select * from ?"); break; case 2: len = sprintf(data->sql, "select * from %s%d where ? = ?", bpTbPrefix, tblIdx); break; default: len = sprintf(data->sql, "select count(*) from %s%d group by ?", bpTbPrefix, tblIdx); break; } if (gCaseCtrl.printStmtSql) { printf("\tSTMT SQL: %s\n", data->sql); } } void generateColDataType(bool isQuery, BindData *data, int32_t bindIdx, int32_t colIdx, int32_t *dataType) { if (bindIdx < gCurCase->bindColNum) { if (gCaseCtrl.bindColTypeNum) { *dataType = gCaseCtrl.bindColTypeList[colIdx]; return; } else if (gCurCase->fullCol) { *dataType = gCurCase->colList[bindIdx]; return; } else if (gCaseCtrl.numericParam) { while (true) { *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; if (!IS_NUMERIC_TYPE(*dataType)) { continue; } break; } return; } else if (0 == colIdx && !isQuery) { *dataType = TSDB_DATA_TYPE_TIMESTAMP; return; } else { while (true) { #if 1 *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; #else if (!colExists(data->pBind, TSDB_DATA_TYPE_NCHAR)) { *dataType = TSDB_DATA_TYPE_NCHAR; } else { *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; } #endif if (*dataType == TSDB_DATA_TYPE_JSON || *dataType == TSDB_DATA_TYPE_DECIMAL || *dataType == TSDB_DATA_TYPE_BLOB || *dataType == TSDB_DATA_TYPE_MEDIUMBLOB || *dataType == TSDB_DATA_TYPE_VARBINARY || *dataType == TSDB_DATA_TYPE_GEOMETRY) { continue; } if (colExists(data->pBind, *dataType)) { continue; } break; } } } else { *dataType = data->pBind[bindIdx % gCurCase->bindColNum].buffer_type; } } void generateTagDataType(BindData *data, int32_t bindIdx, int32_t colIdx, int32_t *dataType) { if (bindIdx < gCurCase->bindTagNum) { if (gCaseCtrl.bindTagTypeNum) { *dataType = gCaseCtrl.bindTagTypeList[colIdx]; return; } else if (gCurCase->fullCol) { *dataType = gCurCase->colList[bindIdx]; return; } else { while (true) { *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; if (*dataType == TSDB_DATA_TYPE_JSON || *dataType == TSDB_DATA_TYPE_DECIMAL || *dataType == TSDB_DATA_TYPE_BLOB || *dataType == TSDB_DATA_TYPE_MEDIUMBLOB || *dataType == TSDB_DATA_TYPE_VARBINARY || *dataType == TSDB_DATA_TYPE_GEOMETRY) { continue; } if (colExists(data->pTags, *dataType)) { continue; } break; } } } else { *dataType = data->pTags[bindIdx % gCurCase->bindTagNum].buffer_type; } } int32_t prepareColData(bool isQuery, BP_BIND_TYPE bType, BindData *data, int32_t bindIdx, int32_t rowIdx, int32_t colIdx) { int32_t dataType = TSDB_DATA_TYPE_TIMESTAMP; TAOS_STMT2_BIND *pBase = NULL; if (bType == BP_BIND_TAG) { pBase = data->pTags; generateTagDataType(data, bindIdx, colIdx, &dataType); } else { pBase = data->pBind; generateColDataType(isQuery, data, bindIdx, colIdx, &dataType); } switch (dataType) { case TSDB_DATA_TYPE_BOOL: // pBase[bindIdx].buffer_length = sizeof(bool); pBase[bindIdx].buffer = data->boolData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_TINYINT: // pBase[bindIdx].buffer_length = sizeof(int8_t); pBase[bindIdx].buffer = data->tinyData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_SMALLINT: // pBase[bindIdx].buffer_length = sizeof(int16_t); pBase[bindIdx].buffer = data->smallData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_INT: // pBase[bindIdx].buffer_length = sizeof(int32_t); pBase[bindIdx].buffer = data->intData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_BIGINT: // pBase[bindIdx].buffer_length = sizeof(int64_t); pBase[bindIdx].buffer = data->bigData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_FLOAT: // pBase[bindIdx].buffer_length = sizeof(float); pBase[bindIdx].buffer = data->floatData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_DOUBLE: // pBase[bindIdx].buffer_length = sizeof(double); pBase[bindIdx].buffer = data->doubleData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_VARCHAR: case TSDB_DATA_TYPE_GEOMETRY: // pBase[bindIdx].buffer_length = gVarCharSize; // pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharSize; pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharLen; pBase[bindIdx].length = data->binaryLen; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_TIMESTAMP: // pBase[bindIdx].buffer_length = sizeof(int64_t); pBase[bindIdx].buffer = data->tsData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = NULL; break; case TSDB_DATA_TYPE_NCHAR: // pBase[bindIdx].buffer_length = gVarCharSize; // pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharSize; pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharLen; pBase[bindIdx].length = data->binaryLen; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_UTINYINT: // pBase[bindIdx].buffer_length = sizeof(uint8_t); pBase[bindIdx].buffer = data->utinyData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_USMALLINT: // pBase[bindIdx].buffer_length = sizeof(uint16_t); pBase[bindIdx].buffer = data->usmallData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_UINT: // pBase[bindIdx].buffer_length = sizeof(uint32_t); pBase[bindIdx].buffer = data->uintData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; case TSDB_DATA_TYPE_UBIGINT: // pBase[bindIdx].buffer_length = sizeof(uint64_t); pBase[bindIdx].buffer = data->ubigData + rowIdx; pBase[bindIdx].length = NULL; pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; break; default: printf("!!!invalid col type:%d", dataType); exit(1); } pBase[bindIdx].buffer_type = dataType; pBase[bindIdx].num = gCurCase->bindRowNum; if (bType == BP_BIND_TAG) { pBase[bindIdx].num = 1; } return 0; } int32_t prepareInsertData(BindData *data) { uint64_t allRowNum = gCurCase->rowNum * gCurCase->tblNum; data->colNum = 0; data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); data->sql = taosMemoryCalloc(1, 1024); data->pBind = taosMemoryCalloc((int32_t)(allRowNum / gCurCase->bindRowNum) * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); data->pTags = taosMemoryCalloc(gCurCase->tblNum * gCurCase->bindTagNum, sizeof(TAOS_STMT2_BIND)); data->tsData = taosMemoryMalloc(allRowNum * sizeof(int64_t)); data->boolData = taosMemoryMalloc(allRowNum * sizeof(bool)); data->tinyData = taosMemoryMalloc(allRowNum * sizeof(int8_t)); data->utinyData = taosMemoryMalloc(allRowNum * sizeof(uint8_t)); data->smallData = taosMemoryMalloc(allRowNum * sizeof(int16_t)); data->usmallData = taosMemoryMalloc(allRowNum * sizeof(uint16_t)); data->intData = taosMemoryMalloc(allRowNum * sizeof(int32_t)); data->uintData = taosMemoryMalloc(allRowNum * sizeof(uint32_t)); data->bigData = taosMemoryMalloc(allRowNum * sizeof(int64_t)); data->ubigData = taosMemoryMalloc(allRowNum * sizeof(uint64_t)); data->floatData = taosMemoryMalloc(allRowNum * sizeof(float)); data->doubleData = taosMemoryMalloc(allRowNum * sizeof(double)); data->binaryData = taosMemoryMalloc(allRowNum * gVarCharSize); data->binaryLen = taosMemoryMalloc(allRowNum * sizeof(int32_t)); if (gCurCase->bindNullNum) { data->isNull = taosMemoryCalloc((int32_t)allRowNum, sizeof(char)); } for (int32_t i = 0; i < allRowNum; ++i) { if (gCurCase->duplicateValue) { data->tsData[i] = bpTs; if (i % 2 == 1) { bpTs++; } } else { data->tsData[i] = bpTs++; } data->boolData[i] = (bool)(i % 2); data->tinyData[i] = (int8_t)i; data->utinyData[i] = (uint8_t)(i + 1); data->smallData[i] = (int16_t)i; data->usmallData[i] = (uint16_t)(i + 1); data->intData[i] = (int32_t)i; data->uintData[i] = (uint32_t)(i + 1); data->bigData[i] = (int64_t)i; data->ubigData[i] = (uint64_t)(i + 1); data->floatData[i] = (float)i; data->doubleData[i] = (double)(i + 1); // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); if (gCurCase->bindNullNum) { data->isNull[i] = (char)(i % 2); } data->binaryLen[i] = gVarCharLen; } for (int b = 0; b < (allRowNum / gCurCase->bindRowNum); b++) { for (int c = 0; c < gCurCase->bindColNum; ++c) { prepareColData(false, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); } } for (int b = 0; b < gCurCase->tblNum; b++) { for (int c = 0; c < gCurCase->bindTagNum; ++c) { prepareColData(false, BP_BIND_TAG, data, b * gCurCase->bindTagNum + c, b, c); } } generateInsertSQL(data); return 0; } int32_t prepareQueryCondData(BindData *data, int32_t tblIdx) { uint64_t bindNum = gCurCase->rowNum / gCurCase->bindRowNum; data->colNum = 0; data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); data->sql = taosMemoryCalloc(1, 1024); data->pBind = taosMemoryCalloc((int32_t)bindNum * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); data->tsData = taosMemoryMalloc(bindNum * sizeof(int64_t)); data->boolData = taosMemoryMalloc(bindNum * sizeof(bool)); data->tinyData = taosMemoryMalloc(bindNum * sizeof(int8_t)); data->utinyData = taosMemoryMalloc(bindNum * sizeof(uint8_t)); data->smallData = taosMemoryMalloc(bindNum * sizeof(int16_t)); data->usmallData = taosMemoryMalloc(bindNum * sizeof(uint16_t)); data->intData = taosMemoryMalloc(bindNum * sizeof(int32_t)); data->uintData = taosMemoryMalloc(bindNum * sizeof(uint32_t)); data->bigData = taosMemoryMalloc(bindNum * sizeof(int64_t)); data->ubigData = taosMemoryMalloc(bindNum * sizeof(uint64_t)); data->floatData = taosMemoryMalloc(bindNum * sizeof(float)); data->doubleData = taosMemoryMalloc(bindNum * sizeof(double)); data->binaryData = taosMemoryMalloc(bindNum * gVarCharSize); data->binaryLen = taosMemoryMalloc(bindNum * sizeof(int32_t)); if (gCurCase->bindNullNum) { data->isNull = taosMemoryCalloc((int32_t)bindNum, sizeof(char)); } for (int32_t i = 0; i < bindNum; ++i) { data->tsData[i] = bpTs + tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum; data->boolData[i] = (bool)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->tinyData[i] = (int8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->utinyData[i] = (uint8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->smallData[i] = (int16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->usmallData[i] = (uint16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->intData[i] = (int32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->uintData[i] = (uint32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->bigData[i] = (int64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->ubigData[i] = (uint64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->floatData[i] = (float)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->doubleData[i] = (double)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); if (gCurCase->bindNullNum) { data->isNull[i] = (char)(i % 2); } data->binaryLen[i] = gVarCharLen; } for (int b = 0; b < bindNum; b++) { for (int c = 0; c < gCurCase->bindColNum; ++c) { prepareColData(true, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); } } generateQueryCondSQL(data, tblIdx); return 0; } int32_t prepareQueryMiscData(BindData *data, int32_t tblIdx) { uint64_t bindNum = gCurCase->rowNum / gCurCase->bindRowNum; data->colNum = 0; data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); data->sql = taosMemoryCalloc(1, 1024); data->pBind = taosMemoryCalloc((int32_t)bindNum * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); data->tsData = taosMemoryMalloc(bindNum * sizeof(int64_t)); data->boolData = taosMemoryMalloc(bindNum * sizeof(bool)); data->tinyData = taosMemoryMalloc(bindNum * sizeof(int8_t)); data->utinyData = taosMemoryMalloc(bindNum * sizeof(uint8_t)); data->smallData = taosMemoryMalloc(bindNum * sizeof(int16_t)); data->usmallData = taosMemoryMalloc(bindNum * sizeof(uint16_t)); data->intData = taosMemoryMalloc(bindNum * sizeof(int32_t)); data->uintData = taosMemoryMalloc(bindNum * sizeof(uint32_t)); data->bigData = taosMemoryMalloc(bindNum * sizeof(int64_t)); data->ubigData = taosMemoryMalloc(bindNum * sizeof(uint64_t)); data->floatData = taosMemoryMalloc(bindNum * sizeof(float)); data->doubleData = taosMemoryMalloc(bindNum * sizeof(double)); data->binaryData = taosMemoryMalloc(bindNum * gVarCharSize); data->binaryLen = taosMemoryMalloc(bindNum * sizeof(int32_t)); if (gCurCase->bindNullNum) { data->isNull = taosMemoryCalloc((int32_t)bindNum, sizeof(char)); } for (int32_t i = 0; i < bindNum; ++i) { data->tsData[i] = bpTs + tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum; data->boolData[i] = (bool)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->tinyData[i] = (int8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->utinyData[i] = (uint8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->smallData[i] = (int16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->usmallData[i] = (uint16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->intData[i] = (int32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->uintData[i] = (uint32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->bigData[i] = (int64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->ubigData[i] = (uint64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->floatData[i] = (float)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); data->doubleData[i] = (double)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); if (gCurCase->bindNullNum) { data->isNull[i] = (char)(i % 2); } data->binaryLen[i] = gVarCharLen; } if (tblIdx == FUNCTION_TEST_IDX) { gCaseCtrl.numericParam = true; } else { gCaseCtrl.numericParam = false; } for (int b = 0; b < bindNum; b++) { for (int c = 0; c < gCurCase->bindColNum; ++c) { prepareColData(true, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); } } gCaseCtrl.numericParam = false; generateQueryMiscSQL(data, tblIdx); return 0; } void destroyData(BindData *data) { taosMemoryFree(data->tsData); taosMemoryFree(data->boolData); taosMemoryFree(data->tinyData); taosMemoryFree(data->utinyData); taosMemoryFree(data->smallData); taosMemoryFree(data->usmallData); taosMemoryFree(data->intData); taosMemoryFree(data->uintData); taosMemoryFree(data->bigData); taosMemoryFree(data->ubigData); taosMemoryFree(data->floatData); taosMemoryFree(data->doubleData); taosMemoryFree(data->binaryData); taosMemoryFree(data->binaryLen); taosMemoryFree(data->isNull); taosMemoryFree(data->pBind); taosMemoryFree(data->pTags); taosMemoryFree(data->colTypes); taosMemoryFree(data->sql); } void bpFetchRows(TAOS_RES *result, bool printr, int32_t *rows) { TAOS_ROW row; int num_fields = taos_num_fields(result); TAOS_FIELD *fields = taos_fetch_fields(result); char temp[256]; // fetch the records row by row while ((row = taos_fetch_row(result))) { (*rows)++; if (printr) { memset(temp, 0, sizeof(temp)); taos_print_row(temp, row, fields, num_fields); printf("\t[%s]\n", temp); } } } void bpExecQuery(TAOS *taos, char *sql, bool printr, int32_t *rows) { TAOS_RES *result = taos_query(taos, sql); int code = taos_errno(result); if (code != 0) { printf("!!!failed to query table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } bpFetchRows(result, printr, rows); taos_free_result(result); } int32_t bpAppendValueString(char *buf, int type, void *value, int32_t valueLen, int32_t *len) { switch (type) { case TSDB_DATA_TYPE_NULL: *len += sprintf(buf + *len, "null"); break; case TSDB_DATA_TYPE_BOOL: *len += sprintf(buf + *len, (*(bool *)value) ? "true" : "false"); break; case TSDB_DATA_TYPE_TINYINT: *len += sprintf(buf + *len, "%d", *(int8_t *)value); break; case TSDB_DATA_TYPE_SMALLINT: *len += sprintf(buf + *len, "%d", *(int16_t *)value); break; case TSDB_DATA_TYPE_INT: *len += sprintf(buf + *len, "%d", *(int32_t *)value); break; case TSDB_DATA_TYPE_BIGINT: case TSDB_DATA_TYPE_TIMESTAMP: *len += sprintf(buf + *len, "%ld", *(int64_t *)value); break; case TSDB_DATA_TYPE_FLOAT: *len += sprintf(buf + *len, "%e", *(float *)value); break; case TSDB_DATA_TYPE_DOUBLE: *len += sprintf(buf + *len, "%e", *(double *)value); break; case TSDB_DATA_TYPE_BINARY: case TSDB_DATA_TYPE_VARBINARY: case TSDB_DATA_TYPE_NCHAR: case TSDB_DATA_TYPE_GEOMETRY: buf[*len] = '\''; ++(*len); memcpy(buf + *len, value, valueLen); *len += valueLen; buf[*len] = '\''; ++(*len); break; case TSDB_DATA_TYPE_UTINYINT: *len += sprintf(buf + *len, "%d", *(uint8_t *)value); break; case TSDB_DATA_TYPE_USMALLINT: *len += sprintf(buf + *len, "%d", *(uint16_t *)value); break; case TSDB_DATA_TYPE_UINT: *len += sprintf(buf + *len, "%u", *(uint32_t *)value); break; case TSDB_DATA_TYPE_UBIGINT: *len += sprintf(buf + *len, "%lu", *(uint64_t *)value); break; default: printf("!!!invalid data type:%d\n", type); exit(1); } } static TAOS_STMT2 *st_stmt2_init(TAOS *taos, bool stb_insert) { TAOS_STMT2_OPTION option = {0}; if (stb_insert) { option.singleStbInsert = true; option.singleTableBindOnce = true; } return taos_stmt2_init(taos, &option); } static int st_stmt2_close(TAOS_STMT2 *stmt) { return taos_stmt2_close(stmt); } static char *st_stmt2_error(TAOS_STMT2 *stmt) { return taos_stmt2_error(stmt); } static int st_stmt2_prepare(TAOS_STMT2 *stmt, const char *sql, unsigned long length) { return taos_stmt2_prepare(stmt, sql, length); } static int st_stmt2_bind(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx) { return taos_stmt2_bind_param(stmt, bindv, col_idx); } static int st_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows) { return taos_stmt2_exec(stmt, affected_rows); } static int st_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) { return taos_stmt2_is_insert(stmt, insert); } // static int st_stmt2_num_params(TAOS_STMT2 *stmt, int *count) { // return taos_stmt2_get_fields(stmt, count, NULL); // } // static int st_stmt2_get_tag_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) { // return taos_stmt2_get_fields(stmt, count, fields); // } // static int st_stmt2_get_col_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_E **fields) { // return taos_stmt2_get_fields(stmt, TAOS_FIELD_COL, count, fields); // } static int st_stmt2_get_param(TAOS_STMT2 *stmt, int idx, int *type, int *bytes) { int32_t code = 0, nums = 0; TAOS_FIELD_ALL *fields = NULL; code = taos_stmt2_get_fields(stmt, &nums, &fields); if (code) { return code; } if (idx > nums) { taosMemoryFree(fields); return -1; } int i = 0; for (; i < nums; i++) { if (fields[i].field_type == TAOS_FIELD_COL) { idx--; } if (idx < 0) { break; } } *type = fields[i].type; *bytes = fields[i].bytes; taosMemoryFree(fields); return 0; } static int st_stmt2_set_tbname(TAOS_STMT2 *stmt, char *name) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.tbnames = &name; return taos_stmt2_bind_param(stmt, &bindv, -1); } static int st_stmt2_set_tags(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.tags = &tags; return taos_stmt2_bind_param(stmt, &bindv, -1); } static int st_stmt2_set_tbname_tags(TAOS_STMT2 *stmt, char *name, TAOS_STMT2_BIND *tags) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.tbnames = &name; bindv.tags = &tags; return taos_stmt2_bind_param(stmt, &bindv, -1); } static int st_stmt2_bind_param_batch(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.bind_cols = &bind; return taos_stmt2_bind_param(stmt, &bindv, -1); } static int st_stmt2_bind_single_param_batch(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int col_idx) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.bind_cols = &bind; return taos_stmt2_bind_param(stmt, &bindv, col_idx); } static int st_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind) { TAOS_STMT2_BINDV bindv = {0}; bindv.count = 1; bindv.bind_cols = &bind; return taos_stmt2_bind_param(stmt, &bindv, -1); } static int st_stmt2_add_batch(TAOS_STMT2 *stmt) { return 0; } static TAOS_RES *st_stmt2_use_result(TAOS_STMT2 *stmt) { return taos_stmt2_result(stmt); } void bpCheckIsInsert(TAOS_STMT2 *stmt, int32_t insert) { int32_t isInsert = 0; if (st_stmt2_is_insert(stmt, &isInsert)) { printf("!!!st_stmt2_is_insert error:%s\n", st_stmt2_error(stmt)); exit(1); } if (insert != isInsert) { printf("!!!is insert failed\n"); exit(1); } } void bpCheckParamNum(TAOS_STMT2 *stmt) { int32_t num = 0; if (taos_stmt2_get_fields(stmt, &num, NULL)) { printf("!!!taos_stmt2_get_fields error:%s\n", st_stmt2_error(stmt)); exit(1); } if (gCurCase->bindColNum != num) { printf("!!!is insert failed\n"); exit(1); } } void bpCheckAffectedRows(TAOS_STMT2 *stmt, int32_t times) { /* TODO: affected rows from exec int32_t rows = taos_stmt_affected_rows(stmt); int32_t insertNum = gCurCase->rowNum * gCurCase->tblNum * times; if (gCurCase->duplicateValue) { insertNum /= 2; } if (insertNum != rows) { printf("!!!affected rows %d mis-match with insert num %d\n", rows, insertNum); exit(1); } */ } void bpCheckQueryResult(TAOS_STMT2 *stmt, TAOS *taos, char *stmtSql, TAOS_STMT2_BIND *bind) { // query using sql char sql[1024]; int32_t len = 0; char *p = stmtSql; char *s = NULL; int32_t sqlResNum = 0; for (int32_t i = 0; true; ++i, p = s + 1) { s = strchr(p, '?'); if (NULL == s) { strcpy(&sql[len], p); break; } memcpy(&sql[len], p, (int64_t)s - (int64_t)p); len += (int32_t)((int64_t)s - (int64_t)p); if (bind[i].is_null && bind[i].is_null[0]) { bpAppendValueString(sql, TSDB_DATA_TYPE_NULL, NULL, 0, &len); continue; } bpAppendValueString(sql, bind[i].buffer_type, bind[i].buffer, (bind[i].length ? bind[i].length[0] : 0), &len); } if (gCaseCtrl.printQuerySql) { printf("\tQuery SQL: %s\n", sql); } bpExecQuery(taos, sql, gCaseCtrl.printRes, &sqlResNum); // query using stmt TAOS_RES *res = st_stmt2_use_result(stmt); int32_t stmtResNum = 0; bpFetchRows(res, gCaseCtrl.printRes, &stmtResNum); if (sqlResNum != stmtResNum) { printf("!!!sql res num %d mis-match stmt res num %d\n", sqlResNum, stmtResNum); exit(1); } printf("***sql res num match stmt res num %d\n", stmtResNum); } void bpCheckColTagFields(TAOS_STMT2 *stmt, int32_t fieldNum, TAOS_FIELD_ALL *pFields, int32_t expecteNum, TAOS_STMT2_BIND *pBind, BP_BIND_TYPE type) { int32_t code = 0; if (fieldNum != expecteNum) { printf("!!!%s field num %d mis-match expect num %d\n", BP_BIND_TYPE_STR(type), fieldNum, expecteNum); exit(1); } if (type == BP_BIND_COL) { if (pFields[0].precision != gCaseCtrl.precision) { printf("!!!db precision %d mis-match expect %d\n", pFields[0].precision, gCaseCtrl.precision); exit(1); } } for (int32_t i = 0; i < fieldNum; ++i) { if (pFields[i].field_type != type) { printf("!!!%s %dth field type %d mis-match expect type %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].field_type, TAOS_FIELD_TAG); exit(1); } if (pFields[i].type != pBind[i].buffer_type) { printf("!!!%s %dth field type %d mis-match expect type %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].type, pBind[i].buffer_type); exit(1); } if (pFields[i].type == TSDB_DATA_TYPE_BINARY || pFields[i].type == TSDB_DATA_TYPE_VARBINARY || pFields[i].type == TSDB_DATA_TYPE_GEOMETRY) { /* if (pFields[i].bytes != (pBind[i].buffer_length + 2)) { printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, (pBind[i].buffer_length + 2)); exit(1); } */ } else if (pFields[i].type == TSDB_DATA_TYPE_NCHAR) { /* if (pFields[i].bytes != (pBind[i].buffer_length * 4 + 2)) { printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, (pBind[i].buffer_length + 2)); exit(1); } */ /*} else if (pFields[i].bytes != pBind[i].buffer_length) { printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, pBind[i].buffer_length); exit(1);*/ } } if (type == BP_BIND_COL) { int fieldType = 0; int fieldBytes = 0; for (int32_t i = 0; i < fieldNum; ++i) { code = st_stmt2_get_param(stmt, i, &fieldType, &fieldBytes); if (code) { printf("!!!st_stmt2_get_param error:%s\n", st_stmt2_error(stmt)); exit(1); } if (pFields[i].type != fieldType) { printf("!!!%s %dth field type %d mis-match expect type %d\n", BP_BIND_TYPE_STR(type), i, fieldType, pFields[i].type); exit(1); } if (pFields[i].bytes != fieldBytes) { printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, fieldBytes, pFields[i].bytes); exit(1); } } } if (gCaseCtrl.printVerbose) { printf("%s fields check passed\n", BP_BIND_TYPE_STR(type)); } } void bpCheckTagFields(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *pBind) { int32_t code = 0; int fieldNum = 0; TAOS_FIELD_ALL *pFields = NULL; code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields); if (code != 0) { printf("!!!taos_stmt2_get_fields error:%s\n", st_stmt2_error(stmt)); exit(1); } int n = fieldNum; for (int i = 0; i < n; i++) { if (pFields[i].field_type != TAOS_FIELD_TAG) { fieldNum--; } } bpCheckColTagFields(stmt, fieldNum, pFields, gCurCase->bindTagNum, pBind, BP_BIND_TAG); taos_stmt2_free_fields(stmt, pFields); } void bpCheckColFields(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *pBind) { if (gCurCase->testType == TTYPE_QUERY) { return; } int32_t code = 0; int fieldNum = 0; TAOS_FIELD_ALL *pFields = NULL; TAOS_FIELD_ALL *pColFields = NULL; code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields); if (code != 0) { printf("!!!st_stmt2_get_col_fields error:%s\n", st_stmt2_error(stmt)); exit(1); } int n = fieldNum; pColFields = taosMemoryMalloc(fieldNum * sizeof(TAOS_FIELD_ALL)); int j = 0; for (int i = 0; i < n; i++) { if (pFields[i].field_type != TAOS_FIELD_COL) { fieldNum--; } else { pColFields[j++] = pFields[i]; } } bpCheckColTagFields(stmt, fieldNum, pColFields, gCurCase->bindColNum, pBind, BP_BIND_COL); taosMemoryFree(pFields); } void bpShowBindParam(TAOS_STMT2_BIND *bind, int32_t num) { for (int32_t i = 0; i < num; ++i) { TAOS_STMT2_BIND *b = &bind[i]; printf("Bind %d: type[%d],buf[%p],len[%d],null[%d],num[%d]\n", i, b->buffer_type, b->buffer, /*b->buffer_length,*/ b->length ? *b->length : 0, b->is_null ? *b->is_null : 0, b->num); } } int32_t bpBindParam(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, bool expectFail) { static int32_t n = 0; if (!expectFail) { bpCheckColFields(stmt, bind); } if (gCurCase->bindRowNum > 1) { if (0 == (n++ % 2) || gCurCase->stbInsert) { if (st_stmt2_bind_param_batch(stmt, bind)) { if (expectFail) return 0; printf("!!!st_stmt2_bind_param_batch error:%s\n", st_stmt2_error(stmt)); bpShowBindParam(bind, gCurCase->bindColNum); exit(1); } } else { for (int32_t i = 0; i < gCurCase->bindColNum; ++i) { if (st_stmt2_bind_single_param_batch(stmt, bind + i, i)) { if (expectFail) continue; printf("!!!st_stmt2_bind_single_param_batch %d error:%s\n", i, st_stmt2_error(stmt)); bpShowBindParam(bind, gCurCase->bindColNum); exit(1); } } } } else { if (0 == (n++ % 2)) { if (st_stmt2_bind_param_batch(stmt, bind)) { if (expectFail) return 0; printf("!!!st_stmt2_bind_param_batch error:%s\n", st_stmt2_error(stmt)); bpShowBindParam(bind, gCurCase->bindColNum); exit(1); } } else { if (st_stmt2_bind_param(stmt, bind)) { if (expectFail) return 0; printf("!!!st_stmt2_bind_param error:%s\n", st_stmt2_error(stmt)); bpShowBindParam(bind, gCurCase->bindColNum); exit(1); } } } return 0; } int32_t bpSetTableNameTags(BindData *data, int32_t tblIdx, char *tblName, TAOS_STMT2 *stmt) { int32_t code = 0; if (gCurCase->bindTagNum > 0) { if ((rand() % 2) == 0) { code = st_stmt2_set_tbname(stmt, tblName); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckTagFields(stmt, data->pTags + tblIdx * gCurCase->bindTagNum); return st_stmt2_set_tags(stmt, data->pTags + tblIdx * gCurCase->bindTagNum); } else { return st_stmt2_set_tbname_tags(stmt, tblName, data->pTags + tblIdx * gCurCase->bindTagNum); } } else { return st_stmt2_set_tbname(stmt, tblName); } } /* prepare [settbname [bind add]] exec */ int insertMBSETest1(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* prepare [settbname bind add] exec */ int insertMBSETest2(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t b = 0; b < bindTimes; ++b) { for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* prepare [settbname [bind add] exec] */ int insertMBMETest1(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* prepare [settbname [bind add exec]] */ int insertMBMETest2(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* prepare [settbname [settbname bind add exec]] */ int insertMBMETest3(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* prepare [settbname bind add exec] */ int insertMBMETest4(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t b = 0; b < bindTimes; ++b) { for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } } bpCheckIsInsert(stmt, 1); bpCheckAffectedRows(stmt, 1); destroyData(&data); return 0; } /* [prepare [settbname [bind add] exec]] */ int insertMPMETest1(TAOS_STMT2 *stmt, TAOS *taos) { int32_t loop = 0; while (gCurCase->bindColNum >= 2) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } bpCheckIsInsert(stmt, 1); destroyData(&data); gCurCase->bindColNum -= 2; gCurCase->fullCol = false; loop++; } bpCheckAffectedRows(stmt, loop); gExecLoopTimes = loop; return 0; } /* prepare [settbname [bind] exec] */ int insertStbTest(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } bpCheckIsInsert(stmt, 1); destroyData(&data); bpCheckAffectedRows(stmt, 1); return 0; } /* [prepare [settbnametag [bind add] exec]] */ int insertAUTOTest1(TAOS_STMT2 *stmt, TAOS *taos) { int32_t loop = 0; while (gCurCase->bindTagNum > 0 && gCurCase->bindColNum > 0) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname_tags error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } for (int32_t b = 0; b < bindTimes; ++b) { if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } bpCheckIsInsert(stmt, 1); destroyData(&data); gCurCase->bindColNum -= 2; gCurCase->bindTagNum -= 2; gCurCase->fullCol = false; loop++; } bpCheckAffectedRows(stmt, loop); gExecLoopTimes = loop; return 0; } /* [prepare [settbnametag [bind add exec]]] */ int insertAUTOTest2(TAOS_STMT2 *stmt, TAOS *taos) { int32_t loop = 0; while (gCurCase->bindTagNum > 0 && gCurCase->bindColNum > 0) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t b = 0; b < bindTimes; ++b) { for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { char buf[32]; sprintf(buf, "t%d", t); code = bpSetTableNameTags(&data, t, buf, stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname_tags error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } } bpCheckIsInsert(stmt, 1); destroyData(&data); gCurCase->bindColNum -= 2; gCurCase->bindTagNum -= 2; gCurCase->fullCol = false; loop++; } bpCheckAffectedRows(stmt, loop); gExecLoopTimes = loop; return 0; } /* normal table [prepare [bind add exec]] */ int insertAUTOTest3(TAOS_STMT2 *stmt, TAOS *taos) { int32_t loop = 0; while (gCurCase->bindColNum > 0) { BindData data = {0}; data.singleTbInsert = true; prepareInsertData(&data); int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { data.singleTbIdx = t; generateInsertSQL(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } for (int32_t b = 0; b < bindTimes; ++b) { bpCheckIsInsert(stmt, 1); if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { exit(1); } if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } } } bpCheckIsInsert(stmt, 1); destroyData(&data); gCurCase->bindColNum -= 2; gCurCase->fullCol = false; loop++; } bpCheckAffectedRows(stmt, loop); gExecLoopTimes = loop; return 0; } /* select * from table */ int queryColumnTest(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { memset(&data, 0, sizeof(data)); prepareQueryCondData(&data, t); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } for (int32_t n = 0; n < (gCurCase->rowNum / gCurCase->bindRowNum); ++n) { bpCheckIsInsert(stmt, 0); if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (bpBindParam(stmt, data.pBind + n * gCurCase->bindColNum, false)) { exit(1); } if (rand() % 2 == 0) { if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckQueryResult(stmt, taos, data.sql, data.pBind + n * gCurCase->bindColNum); } bpCheckIsInsert(stmt, 0); destroyData(&data); } return 0; } /* value in query sql */ int queryMiscTest(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { memset(&data, 0, sizeof(data)); prepareQueryMiscData(&data, t); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } for (int32_t n = 0; n < (gCurCase->rowNum / gCurCase->bindRowNum); ++n) { bpCheckIsInsert(stmt, 0); if (gCaseCtrl.checkParamNum) { bpCheckParamNum(stmt); } if (bpBindParam(stmt, data.pBind + n * gCurCase->bindColNum, false)) { exit(1); } if (rand() % 2 == 0) { if (st_stmt2_add_batch(stmt)) { printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); exit(1); } } if (st_stmt2_exec(stmt, NULL) != 0) { printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckQueryResult(stmt, taos, data.sql, data.pBind + n * gCurCase->bindColNum); } bpCheckIsInsert(stmt, 0); destroyData(&data); } return 0; } int insertNonExistsTb(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); char *buf = "tbnexist"; code = bpSetTableNameTags(&data, 0, buf, stmt); if (code == 0) { printf("!!!st_stmt2_set_tbname expected error not occurred\n"); exit(1); } if (0 == st_stmt2_bind_param_batch(stmt, data.pBind)) { printf("!!!st_stmt2_bind_param_batch expected error not occurred\n"); exit(1); } if (0 == st_stmt2_exec(stmt, NULL)) { printf("!!!st_stmt2_execute expected error not occurred\n"); exit(1); } destroyData(&data); return 0; } void bpAddWrongVarBuffLen(TAOS_STMT2_BIND *pBind) { for (int32_t i = 0; i < gCurCase->bindColNum; ++i) { if (pBind[i].buffer_type == TSDB_DATA_TYPE_BINARY || pBind[i].buffer_type == TSDB_DATA_TYPE_VARBINARY || pBind[i].buffer_type == TSDB_DATA_TYPE_NCHAR) { *pBind[i].length += 100; } } } int insertVarLenErr(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; prepareInsertData(&data); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); exit(1); } bpCheckIsInsert(stmt, 1); code = bpSetTableNameTags(&data, 0, "t0", stmt); if (code != 0) { printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); exit(1); } bpAddWrongVarBuffLen(data.pBind); if (bpBindParam(stmt, data.pBind, true)) { exit(1); } destroyData(&data); return 0; } int errorSQLTest1(TAOS_STMT2 *stmt, TAOS *taos) { BindData data = {0}; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { memset(&data, 0, sizeof(data)); generateErrorSQL(&data, t); int code = st_stmt2_prepare(stmt, data.sql, 0); if (code != 0) { printf("*st_stmt2_prepare error as expected, error:%s\n", st_stmt2_error(stmt)); } else { printf("!!!st_stmt2_prepare succeed, which should be error\n"); exit(1); } destroyData(&data); } return 0; } void prepareCheckResultImpl(TAOS *taos, char *tname, bool printr, int expected, bool silent) { if (TTYPE_INSERT_NG == gCurCase->testType) { return; } char sql[255] = "SELECT * FROM "; int32_t rows = 0; strcat(sql, tname); bpExecQuery(taos, sql, printr, &rows); if (rows == expected) { if (!silent) { printf("***%d rows are fetched as expected from %s\n", rows, tname); } } else { printf("!!!expect rows %d mis-match rows %d fetched from %s\n", expected, rows, tname); exit(1); } } void prepareCheckResult(TAOS *taos, bool silent) { char buf[32]; for (int32_t t = 0; t < gCurCase->tblNum; ++t) { if (gCurCase->tblNum > 1) { sprintf(buf, "%s%d", bpTbPrefix, t); } else { sprintf(buf, "%s%d", bpTbPrefix, 0); } prepareCheckResultImpl( taos, buf, gCaseCtrl.printRes, gCurCase->duplicateValue ? (gCurCase->rowNum * gExecLoopTimes / 2) : (gCurCase->rowNum * gExecLoopTimes), silent); } gExecLoopTimes = 1; } // 120table 60 record each table int sql_perf1(TAOS *taos) { char *sql[3000] = {0}; TAOS_RES *result; for (int i = 0; i < 3000; i++) { sql[i] = taosMemoryCalloc(1, 1048576); } int len = 0; int tss = 0; for (int l = 0; l < 3000; ++l) { len = sprintf(sql[l], "insert into "); for (int t = 0; t < 120; ++t) { len += sprintf(sql[l] + len, "m%d values ", t); for (int m = 0; m < 60; ++m) { len += sprintf(sql[l] + len, "(%d, %d, %d, %d, %d, %d, %f, %f, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", " "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\") ", tss++, m, m, m, m, m, m + 1.0, m + 1.0); } } } int64_t starttime = taosGetTimestampUs(); for (int i = 0; i < 3000; ++i) { result = taos_query(taos, sql[i]); int code = taos_errno(result); if (code != 0) { printf("%d failed to query table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } int64_t endtime = taosGetTimestampUs(); printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); for (int i = 0; i < 3000; i++) { taosMemoryFree(sql[i]); } return 0; } // one table 60 records one time int sql_perf_s1(TAOS *taos) { char **sql = calloc(1, sizeof(char *) * 360000); TAOS_RES *result; for (int i = 0; i < 360000; i++) { sql[i] = taosMemoryCalloc(1, 9000); } int len = 0; int tss = 0; int id = 0; for (int t = 0; t < 120; ++t) { for (int l = 0; l < 3000; ++l) { len = sprintf(sql[id], "insert into m%d values ", t); for (int m = 0; m < 60; ++m) { len += sprintf(sql[id] + len, "(%d, %d, %d, %d, %d, %d, %f, %f, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", " "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\") ", tss++, m, m, m, m, m, m + 1.0, m + 1.0); } if (len >= 9000) { printf("sql:%s,len:%d\n", sql[id], len); exit(1); } ++id; } } unsigned long long starttime = taosGetTimestampUs(); for (int i = 0; i < 360000; ++i) { result = taos_query(taos, sql[i]); int code = taos_errno(result); if (code != 0) { printf("failed to query table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } unsigned long long endtime = taosGetTimestampUs(); printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); for (int i = 0; i < 360000; i++) { taosMemoryFree(sql[i]); } taosMemoryFree(sql); return 0; } // small record size int sql_s_perf1(TAOS *taos) { char *sql[3000] = {0}; TAOS_RES *result; for (int i = 0; i < 3000; i++) { sql[i] = taosMemoryCalloc(1, 1048576); } int len = 0; int tss = 0; for (int l = 0; l < 3000; ++l) { len = sprintf(sql[l], "insert into "); for (int t = 0; t < 120; ++t) { len += sprintf(sql[l] + len, "m%d values ", t); for (int m = 0; m < 60; ++m) { len += sprintf(sql[l] + len, "(%d, %d) ", tss++, m % 2); } } } unsigned long long starttime = taosGetTimestampUs(); for (int i = 0; i < 3000; ++i) { result = taos_query(taos, sql[i]); int code = taos_errno(result); if (code != 0) { printf("failed to query table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } unsigned long long endtime = taosGetTimestampUs(); printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); for (int i = 0; i < 3000; i++) { taosMemoryFree(sql[i]); } return 0; } void generateCreateTableSQL(char *buf, int32_t tblIdx, int32_t colNum, int32_t *colList, int32_t tableType) { int32_t blen = 0; blen = sprintf(buf, "create table %s%d ", (1 == tableType ? bpStbPrefix : bpTbPrefix), tblIdx); if (tableType == 3) { blen += sprintf(buf + blen, "using %s%d", bpStbPrefix, bpDefaultStbId); } if (tableType == 0 || tableType == 1) { blen += sprintf(buf + blen, " ("); for (int c = 0; c < colNum; ++c) { if (c > 0) { blen += sprintf(buf + blen, ","); } switch (colList[c]) { case TSDB_DATA_TYPE_BOOL: blen += sprintf(buf + blen, "booldata bool"); break; case TSDB_DATA_TYPE_TINYINT: blen += sprintf(buf + blen, "tinydata tinyint"); break; case TSDB_DATA_TYPE_SMALLINT: blen += sprintf(buf + blen, "smalldata smallint"); break; case TSDB_DATA_TYPE_INT: blen += sprintf(buf + blen, "intdata int"); break; case TSDB_DATA_TYPE_BIGINT: blen += sprintf(buf + blen, "bigdata bigint"); break; case TSDB_DATA_TYPE_FLOAT: blen += sprintf(buf + blen, "floatdata float"); break; case TSDB_DATA_TYPE_DOUBLE: blen += sprintf(buf + blen, "doubledata double"); break; case TSDB_DATA_TYPE_VARCHAR: blen += sprintf(buf + blen, "binarydata binary(%d)", gVarCharSize); break; case TSDB_DATA_TYPE_TIMESTAMP: blen += sprintf(buf + blen, "ts timestamp"); break; case TSDB_DATA_TYPE_NCHAR: blen += sprintf(buf + blen, "nchardata nchar(%d)", gVarCharSize); break; case TSDB_DATA_TYPE_UTINYINT: blen += sprintf(buf + blen, "utinydata tinyint unsigned"); break; case TSDB_DATA_TYPE_USMALLINT: blen += sprintf(buf + blen, "usmalldata smallint unsigned"); break; case TSDB_DATA_TYPE_UINT: blen += sprintf(buf + blen, "uintdata int unsigned"); break; case TSDB_DATA_TYPE_UBIGINT: blen += sprintf(buf + blen, "ubigdata bigint unsigned"); break; default: printf("invalid col type:%d", colList[c]); exit(1); } } blen += sprintf(buf + blen, ")"); } if (1 == tableType) { blen += sprintf(buf + blen, " tags ("); for (int c = 0; c < colNum; ++c) { if (c > 0) { blen += sprintf(buf + blen, ","); } switch (colList[c]) { case TSDB_DATA_TYPE_BOOL: blen += sprintf(buf + blen, "tbooldata bool"); break; case TSDB_DATA_TYPE_TINYINT: blen += sprintf(buf + blen, "ttinydata tinyint"); break; case TSDB_DATA_TYPE_SMALLINT: blen += sprintf(buf + blen, "tsmalldata smallint"); break; case TSDB_DATA_TYPE_INT: blen += sprintf(buf + blen, "tintdata int"); break; case TSDB_DATA_TYPE_BIGINT: blen += sprintf(buf + blen, "tbigdata bigint"); break; case TSDB_DATA_TYPE_FLOAT: blen += sprintf(buf + blen, "tfloatdata float"); break; case TSDB_DATA_TYPE_DOUBLE: blen += sprintf(buf + blen, "tdoubledata double"); break; case TSDB_DATA_TYPE_VARCHAR: blen += sprintf(buf + blen, "tbinarydata binary(%d)", gVarCharSize); break; case TSDB_DATA_TYPE_TIMESTAMP: blen += sprintf(buf + blen, "tts timestamp"); break; case TSDB_DATA_TYPE_NCHAR: blen += sprintf(buf + blen, "tnchardata nchar(%d)", gVarCharSize); break; case TSDB_DATA_TYPE_UTINYINT: blen += sprintf(buf + blen, "tutinydata tinyint unsigned"); break; case TSDB_DATA_TYPE_USMALLINT: blen += sprintf(buf + blen, "tusmalldata smallint unsigned"); break; case TSDB_DATA_TYPE_UINT: blen += sprintf(buf + blen, "tuintdata int unsigned"); break; case TSDB_DATA_TYPE_UBIGINT: blen += sprintf(buf + blen, "tubigdata bigint unsigned"); break; default: printf("invalid col type:%d", colList[c]); exit(1); } } blen += sprintf(buf + blen, ")"); } if (3 == tableType) { blen += sprintf(buf + blen, " tags ("); for (int c = 0; c < colNum; ++c) { if (c > 0) { blen += sprintf(buf + blen, ","); } switch (colList[c]) { case TSDB_DATA_TYPE_BOOL: blen += sprintf(buf + blen, "%s", rand() % 2 ? "true" : "false"); break; case TSDB_DATA_TYPE_TINYINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_SMALLINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_INT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_BIGINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_FLOAT: blen += sprintf(buf + blen, "%f", rand() % 128); break; case TSDB_DATA_TYPE_DOUBLE: blen += sprintf(buf + blen, "%f", rand() % 128); break; case TSDB_DATA_TYPE_VARCHAR: blen += sprintf(buf + blen, "'var%d'", rand() % 128); break; case TSDB_DATA_TYPE_TIMESTAMP: blen += sprintf(buf + blen, "%lld", bpTs); break; case TSDB_DATA_TYPE_NCHAR: blen += sprintf(buf + blen, "'nch%d'", rand() % 128); break; case TSDB_DATA_TYPE_UTINYINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_USMALLINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_UINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; case TSDB_DATA_TYPE_UBIGINT: blen += sprintf(buf + blen, "%d", rand() % 128); break; default: printf("invalid col type:%d", colList[c]); exit(1); } } blen += sprintf(buf + blen, ")"); } if (gCaseCtrl.printCreateTblSql) { printf("\tCreate Table SQL:%s\n", buf); } } char *bpPrecisionStr(uint8_t precision) { switch (precision) { case TIME_PRECISION_MILLI: return "ms"; case TIME_PRECISION_MICRO: return "us"; case TIME_PRECISION_NANO: return "ns"; default: return "unknwon"; } } void bpSetStartupTs() { switch (gCaseCtrl.precision) { case TIME_PRECISION_MILLI: bpTs = BP_STARTUP_TS; break; case TIME_PRECISION_MICRO: bpTs = BP_STARTUP_TS * 1000; break; case TIME_PRECISION_NANO: bpTs = BP_STARTUP_TS * 1000000; break; default: bpTs = BP_STARTUP_TS; break; } } void prepare(TAOS *taos, int32_t colNum, int32_t *colList, int prepareStb) { TAOS_RES *result; int code; char createDbSql[128] = {0}; result = taos_query(taos, "drop database demo"); taos_free_result(result); sprintf(createDbSql, "create database demo keep 36500 precision \"%s\"", bpPrecisionStr(gCaseCtrl.precision)); printf("\tCreate Database SQL:%s\n", createDbSql); result = taos_query(taos, createDbSql); code = taos_errno(result); if (code != 0) { printf("!!!failed to create database, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); result = taos_query(taos, "use demo"); taos_free_result(result); if (0 == prepareStb) { // create table for (int i = 0; i < 10; i++) { char buf[1024]; generateCreateTableSQL(buf, i, colNum, colList, 0); result = taos_query(taos, buf); code = taos_errno(result); if (code != 0) { printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } } else { if (1 == prepareStb || 3 == prepareStb) { char buf[1024]; generateCreateTableSQL(buf, bpDefaultStbId, colNum, colList, 1); result = taos_query(taos, buf); code = taos_errno(result); if (code != 0) { printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } if (3 == prepareStb) { for (int i = 0; i < 10; i++) { char buf[1024]; generateCreateTableSQL(buf, i, colNum, colList, 3); result = taos_query(taos, buf); code = taos_errno(result); if (code != 0) { printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); taos_free_result(result); exit(1); } taos_free_result(result); } } } } int32_t runCase(TAOS *taos, int32_t caseIdx, int32_t caseRunIdx, bool silent) { TAOS_STMT2 *stmt = NULL; int64_t beginUs, endUs, totalUs; CaseCfg cfg = gCase[caseIdx]; CaseCfg cfgBk; gCurCase = &cfg; bpSetStartupTs(); if ((gCaseCtrl.bindColTypeNum || gCaseCtrl.bindColNum) && (gCurCase->colNum != gFullColNum)) { return 1; } if (gCurCase->preCaseIdx >= 0) { bool printRes = gCaseCtrl.printRes; bool printStmtSql = gCaseCtrl.printStmtSql; gCaseCtrl.printRes = false; gCaseCtrl.printStmtSql = false; runCase(taos, gCurCase->preCaseIdx, caseRunIdx, true); gCaseCtrl.printRes = printRes; gCaseCtrl.printStmtSql = printStmtSql; gCurCase = &cfg; } if (gCaseCtrl.runTimes) { gCurCase->runTimes = gCaseCtrl.runTimes; } if (gCaseCtrl.rowNum) { gCurCase->rowNum = gCaseCtrl.rowNum; } if (gCaseCtrl.autoCreateTbl) { if (gCurCase->testType == TTYPE_INSERT && gCurCase->tblNum > 1) { gCurCase->autoCreateTbl = 1; if (gCurCase->bindTagNum <= 0) { gCurCase->bindTagNum = gCurCase->colNum; } } else { return 1; } } if (gCurCase->fullCol) { gCurCase->bindColNum = gCurCase->colNum; if (gCurCase->autoCreateTbl) { gCurCase->bindTagNum = gCurCase->colNum; } } gCurCase->bindNullNum = gCaseCtrl.bindNullNum; if (gCaseCtrl.bindColNum) { gCurCase->bindColNum = gCaseCtrl.bindColNum; gCurCase->fullCol = false; } if (gCaseCtrl.bindTagNum) { gCurCase->bindTagNum = gCaseCtrl.bindTagNum; gCurCase->fullCol = false; } if (gCaseCtrl.bindRowNum) { gCurCase->bindRowNum = gCaseCtrl.bindRowNum; } if (gCaseCtrl.bindColTypeNum) { gCurCase->bindColNum = gCaseCtrl.bindColTypeNum; gCurCase->fullCol = false; } if (gCaseCtrl.bindTagTypeNum) { gCurCase->bindTagNum = gCaseCtrl.bindTagTypeNum; gCurCase->fullCol = false; } if (!silent) { printf("* Case %d - [%s]%s Begin *\n", caseRunIdx, gCaseCtrl.caseCatalog, gCurCase->caseDesc); } totalUs = 0; cfgBk = cfg; for (int32_t n = 0; n < gCurCase->runTimes; ++n) { if (gCurCase->preCaseIdx < 0) { prepare(taos, gCurCase->colNum, gCurCase->colList, gCurCase->autoCreateTbl); } beginUs = taosGetTimestampUs(); stmt = st_stmt2_init(taos, gCurCase->stbInsert); if (!stmt) { printf("!!!st_stmt2_init failed, error:%s\n", st_stmt2_error(stmt)); exit(1); } (*gCurCase->runFn)(stmt, taos); (void)st_stmt2_close(stmt); endUs = taosGetTimestampUs(); totalUs += (endUs - beginUs); prepareCheckResult(taos, silent); cfg = cfgBk; } if (!silent) { printf("* Case %d - [%s]%s [AvgTime:%.3fms] End *\n", caseRunIdx, gCaseCtrl.caseCatalog, gCurCase->caseDesc, ((double)totalUs) / 1000 / gCurCase->runTimes); } return 0; } void *runCaseList(TAOS *taos) { static int32_t caseRunIdx = 0; static int32_t caseRunNum = 0; int32_t caseNum = 0; int32_t caseIdx = (gCaseCtrl.caseIdx >= 0) ? gCaseCtrl.caseIdx : 0; for (int32_t i = caseIdx; i < sizeof(gCase) / sizeof(gCase[0]); ++i) { if (gCaseCtrl.caseNum > 0 && caseNum >= gCaseCtrl.caseNum) { break; } if (gCaseCtrl.caseRunNum > 0 && caseRunNum >= gCaseCtrl.caseRunNum) { break; } if (gCaseCtrl.caseRunIdx >= 0 && caseRunIdx < gCaseCtrl.caseRunIdx) { caseRunIdx++; continue; } if (runCase(taos, i, caseRunIdx, false)) { continue; } caseRunIdx++; caseNum++; caseRunNum++; } return NULL; } void runAll(TAOS *taos) { strcpy(gCaseCtrl.caseCatalog, "Default Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); runCaseList(taos); #if 1 strcpy(gCaseCtrl.caseCatalog, "Micro DB precision Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.precision = TIME_PRECISION_MICRO; runCaseList(taos); gCaseCtrl.precision = TIME_PRECISION_MILLI; strcpy(gCaseCtrl.caseCatalog, "Nano DB precision Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.precision = TIME_PRECISION_NANO; runCaseList(taos); gCaseCtrl.precision = TIME_PRECISION_MILLI; strcpy(gCaseCtrl.caseCatalog, "Auto Create Table Test"); gCaseCtrl.autoCreateTbl = true; printf("%s Begin\n", gCaseCtrl.caseCatalog); runCaseList(taos); gCaseCtrl.autoCreateTbl = false; strcpy(gCaseCtrl.caseCatalog, "Null Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.bindNullNum = 1; runCaseList(taos); gCaseCtrl.bindNullNum = 0; strcpy(gCaseCtrl.caseCatalog, "Bind Row Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.bindRowNum = 1; runCaseList(taos); gCaseCtrl.bindRowNum = 0; strcpy(gCaseCtrl.caseCatalog, "Row Num Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.rowNum = 1000; gCaseCtrl.printRes = false; runCaseList(taos); gCaseCtrl.rowNum = 0; gCaseCtrl.printRes = true; strcpy(gCaseCtrl.caseCatalog, "Runtimes Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.runTimes = 2; runCaseList(taos); gCaseCtrl.runTimes = 0; strcpy(gCaseCtrl.caseCatalog, "Check Param Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.checkParamNum = true; runCaseList(taos); gCaseCtrl.checkParamNum = false; strcpy(gCaseCtrl.caseCatalog, "Bind Col Num Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.bindColNum = 6; runCaseList(taos); gCaseCtrl.bindColNum = 0; #endif /* strcpy(gCaseCtrl.caseCatalog, "Bind Col Type Test"); printf("%s Begin\n", gCaseCtrl.caseCatalog); gCaseCtrl.bindColTypeNum = tListLen(bindColTypeList); gCaseCtrl.bindColTypeList = bindColTypeList; runCaseList(taos); */ printf("All Test End\n"); } int main(int argc, char *argv[]) { TAOS *taos = NULL; srand((unsigned int)time(NULL)); // connect to server if (argc < 2) { printf("please input server ip \n"); return 0; } taos = taos_connect(argv[1], "root", "taosdata", NULL, 0); if (taos == NULL) { printf("failed to connect to db, reason:%s\n", taos_errstr(taos)); exit(1); } runAll(taos); taos_close(taos); return 0; }