refactor:fix warning in smltest.cpp

cmake/cmake.define

@@ -77,11 +77,11 @@ IF (TD_WINDOWS)
 ELSE ()
     IF (${SANITIZER} MATCHES "true")
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
 	MESSAGE(STATUS "Will compile with Address Sanitizer!")
     ELSE ()
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fpermissive -fPIC -gdwarf-2 -g3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3")
     ENDIF ()
 
     MESSAGE("System processor ID: ${CMAKE_SYSTEM_PROCESSOR}")

source/client/src/clientSml.c

@@ -138,14 +138,14 @@ typedef struct {
 } SSmlHandle;
 //=================================================================================================
 
-static uint64_t linesSmlHandleId = 0;
+static volatile int64_t linesSmlHandleId = 0;
 static const char* TS = "_ts";
 static const char* TAG = "_tagNone";
 
 //=================================================================================================
 
-static uint64_t smlGenId() {
-  uint64_t id;
+static int64_t smlGenId() {
+  int64_t id;
 
   do {
     id = atomic_add_fetch_64(&linesSmlHandleId, 1);
@@ -239,15 +239,13 @@ static int32_t smlApplySchemaAction(SSmlHandle* info, SSchemaAction* action) {
       TAOS_RES* res = taos_query(info->taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
       const char* errStr = taos_errstr(res);
-      char* begin = strstr(errStr, "duplicated column names");
-      bool tscDupColNames = (begin != NULL);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%"PRIx64" apply schema action. error: %s", info->id, errStr);
       }
       taos_free_result(res);
 
 //      if (code == TSDB_CODE_MND_FIELD_ALREADY_EXIST || code == TSDB_CODE_MND_TAG_ALREADY_EXIST || tscDupColNames) {
-      if (code == TSDB_CODE_MND_TAG_ALREADY_EXIST || tscDupColNames) {
+      if (code == TSDB_CODE_MND_TAG_ALREADY_EXIST) {
         TAOS_RES* res2 = taos_query(info->taos, "RESET QUERY CACHE");
         code = taos_errno(res2);
         if (code != TSDB_CODE_SUCCESS) {
@@ -265,15 +263,13 @@ static int32_t smlApplySchemaAction(SSmlHandle* info, SSchemaAction* action) {
       TAOS_RES* res = taos_query(info->taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
       const char* errStr = taos_errstr(res);
-      char* begin = strstr(errStr, "duplicated column names");
-      bool tscDupColNames = (begin != NULL);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%"PRIx64" apply schema action. error : %s", info->id, taos_errstr(res));
       }
       taos_free_result(res);
 
 //      if (code ==TSDB_CODE_MND_TAG_ALREADY_EXIST || code == TSDB_CODE_MND_FIELD_ALREAY_EXIST || tscDupColNames) {
-      if (code ==TSDB_CODE_MND_TAG_ALREADY_EXIST || tscDupColNames) {
+      if (code ==TSDB_CODE_MND_TAG_ALREADY_EXIST) {
         TAOS_RES* res2 = taos_query(info->taos, "RESET QUERY CACHE");
         code = taos_errno(res2);
         if (code != TSDB_CODE_SUCCESS) {
@@ -337,7 +333,7 @@ static int32_t smlApplySchemaAction(SSmlHandle* info, SSchemaAction* action) {
       SArray *cols = action->createSTable.fields;
 
       for(int i = 0; i < taosArrayGetSize(cols); i++){
-        SSmlKv *kv = taosArrayGetP(cols, i);
+        SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, i);
         smlBuildColumnDescription(kv, pos, freeBytes, &outBytes);
         pos += outBytes; freeBytes -= outBytes;
         *pos = ','; ++pos; --freeBytes;
@@ -350,7 +346,7 @@ static int32_t smlApplySchemaAction(SSmlHandle* info, SSchemaAction* action) {
 
       cols = action->createSTable.tags;
       for(int i = 0; i < taosArrayGetSize(cols); i++){
-        SSmlKv *kv = taosArrayGetP(cols, i);
+        SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, i);
         smlBuildColumnDescription(kv, pos, freeBytes, &outBytes);
         pos += outBytes; freeBytes -= outBytes;
         *pos = ','; ++pos; --freeBytes;
@@ -390,7 +386,7 @@ static int32_t smlApplySchemaAction(SSmlHandle* info, SSchemaAction* action) {
 static int32_t smlModifyDBSchemas(SSmlHandle* info) {
   int32_t code = 0;
 
-  SSmlSTableMeta** tableMetaSml = taosHashIterate(info->superTables, NULL);
+  SSmlSTableMeta** tableMetaSml = (SSmlSTableMeta**)taosHashIterate(info->superTables, NULL);
   while (tableMetaSml) {
     SSmlSTableMeta* sTableData = *tableMetaSml;
 
@@ -406,8 +402,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle* info) {
     code = catalogGetSTableMeta(info->pCatalog, info->taos->pAppInfo->pTransporter, &ep, &pName, &pTableMeta);
 
     if (code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_MND_INVALID_STB) {
-      SSchemaAction schemaAction = {0};
-      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      SSchemaAction schemaAction = {.action = SCHEMA_ACTION_CREATE_STABLE};
       memcpy(schemaAction.createSTable.sTableName, superTable, superTableLen);
       schemaAction.createSTable.tags = sTableData->tags;
       schemaAction.createSTable.fields = sTableData->cols;
@@ -430,7 +425,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle* info) {
     }
     sTableData->tableMeta = pTableMeta;
 
-    tableMetaSml = taosHashIterate(info->superTables, tableMetaSml);
+    tableMetaSml = (SSmlSTableMeta**)taosHashIterate(info->superTables, tableMetaSml);
   }
   return 0;
 }
@@ -996,7 +991,7 @@ static int32_t smlParseString(const char* sql, SSmlLineInfo *elements, SSmlMsgBu
 
 static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool isTag, SHashObj *dumplicateKey, SSmlMsgBuf *msg){
   if(isTag && len == 0){
-    SSmlKv *kv = taosMemoryCalloc(sizeof(SSmlKv), 1);
+    SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     kv->key = TAG;
     kv->keyLen = strlen(TAG);
     kv->value = TAG;
@@ -1053,7 +1048,7 @@ static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool is
     }
 
     // add kv to SSmlKv
-    SSmlKv *kv = taosMemoryCalloc(sizeof(SSmlKv), 1);
+    SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     kv->key = key;
     kv->keyLen = keyLen;
     kv->value = value;
@@ -1199,7 +1194,7 @@ static int32_t smlParseTS(SSmlHandle* info, const char* data, int32_t len, SArra
   if(ts == -1)  return TSDB_CODE_TSC_INVALID_TIME_STAMP;
 
   // add ts to
-  SSmlKv *kv = taosMemoryCalloc(sizeof(SSmlKv), 1);
+  SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
   if(!kv){
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -1259,12 +1254,12 @@ static int32_t smlParseTS(SSmlHandle* info, const char* data, int32_t len, SArra
 static bool smlUpdateMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols, SSmlMsgBuf *msg){
   if(tags){
     for (int i = 0; i < taosArrayGetSize(tags); ++i) {
-      SSmlKv *kv = taosArrayGetP(tags, i);
+      SSmlKv *kv = (SSmlKv *)taosArrayGetP(tags, i);
       ASSERT(kv->type == TSDB_DATA_TYPE_NCHAR);
 
-      uint8_t *index = taosHashGet(tableMeta->tagHash, kv->key, kv->keyLen);
+      uint8_t *index = (uint8_t *)taosHashGet(tableMeta->tagHash, kv->key, kv->keyLen);
       if(index){
-        SSmlKv **value = taosArrayGet(tableMeta->tags, *index);
+        SSmlKv **value = (SSmlKv **)taosArrayGet(tableMeta->tags, *index);
         ASSERT((*value)->type == TSDB_DATA_TYPE_NCHAR);
         if(kv->valueLen > (*value)->valueLen){    // tags type is nchar
           *value = kv;
@@ -1281,11 +1276,11 @@ static bool smlUpdateMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols,
 
   if(cols){
     for (int i = 1; i < taosArrayGetSize(cols); ++i) {  //jump timestamp
-      SSmlKv *kv = taosArrayGetP(cols, i);
+      SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, i);
 
-      int16_t *index = taosHashGet(tableMeta->fieldHash, kv->key, kv->keyLen);
+      int16_t *index = (int16_t *)taosHashGet(tableMeta->fieldHash, kv->key, kv->keyLen);
       if(index){
-        SSmlKv **value = taosArrayGet(tableMeta->cols, *index);
+        SSmlKv **value = (SSmlKv **)taosArrayGet(tableMeta->cols, *index);
         if(kv->type != (*value)->type){
           smlBuildInvalidDataMsg(msg, "the type is not the same like before", kv->key);
           return false;
@@ -1311,7 +1306,7 @@ static bool smlUpdateMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols,
 static void smlInsertMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols){
   if(tags){
     for (uint8_t i = 0; i < taosArrayGetSize(tags); ++i) {
-      SSmlKv *kv = taosArrayGetP(tags, i);
+      SSmlKv *kv = (SSmlKv *)taosArrayGetP(tags, i);
       taosArrayPush(tableMeta->tags, &kv);
       taosHashPut(tableMeta->tagHash, kv->key, kv->keyLen, &i, CHAR_BYTES);
     }
@@ -1319,7 +1314,7 @@ static void smlInsertMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols)
 
   if(cols){
     for (int16_t i = 0; i < taosArrayGetSize(cols); ++i) {
-      SSmlKv *kv = taosArrayGetP(cols, i);
+      SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, i);
       taosArrayPush(tableMeta->cols, &kv);
       taosHashPut(tableMeta->fieldHash, kv->key, kv->keyLen, &i, SHORT_BYTES);
     }
@@ -1327,7 +1322,7 @@ static void smlInsertMeta(SSmlSTableMeta* tableMeta, SArray *tags, SArray *cols)
 }
 
 static SSmlTableInfo* smlBuildTableInfo(bool format){
-  SSmlTableInfo *tag = taosMemoryCalloc(sizeof(SSmlTableInfo), 1);
+  SSmlTableInfo *tag = (SSmlTableInfo *)taosMemoryCalloc(sizeof(SSmlTableInfo), 1);
   if(!tag){
     return NULL;
   }
@@ -1354,7 +1349,7 @@ static SSmlTableInfo* smlBuildTableInfo(bool format){
   return tag;
 
 cleanup:
-  taosMemoryFreeClear(tag);
+  taosMemoryFree(tag);
   return NULL;
 }
 
@@ -1364,18 +1359,17 @@ static void smlDestroyBuildTableInfo(SSmlTableInfo *tag, bool format){
   }else{
     tag->cols = taosArrayInit(16, POINTER_BYTES);
     for(size_t i = 0; i < taosArrayGetSize(tag->cols); i++){
-      SHashObj *kvHash = taosArrayGetP(tag->cols, i);
-      void** p1 = taosHashIterate(kvHash, NULL);
+      SHashObj *kvHash = (SHashObj *)taosArrayGetP(tag->cols, i);
+      void** p1 = (void**)taosHashIterate(kvHash, NULL);
       while (p1) {
-        SSmlKv* kv = *p1;
-        taosMemoryFreeClear(kv);
-        p1 = taosHashIterate(kvHash, p1);
+        taosMemoryFree(*p1);
+        p1 = (void**)taosHashIterate(kvHash, p1);
       }
       taosHashCleanup(kvHash);
     }
   }
   taosArrayDestroy(tag->tags);
-  taosMemoryFreeClear(tag);
+  taosMemoryFree(tag);
 }
 
 static int32_t smlDealCols(SSmlTableInfo* oneTable, bool dataFormat, SArray *cols){
@@ -1390,7 +1384,7 @@ static int32_t smlDealCols(SSmlTableInfo* oneTable, bool dataFormat, SArray *col
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   for(size_t i = 0; i < taosArrayGetSize(cols); i++){
-    SSmlKv *kv = taosArrayGetP(cols, i);
+    SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, i);
     taosHashPut(kvHash, kv->key, kv->keyLen, &kv, POINTER_BYTES);   // todo key need escape, like \=, because find by schema name later
   }
   taosArrayPush(oneTable->cols, &kvHash);
@@ -1399,7 +1393,7 @@ static int32_t smlDealCols(SSmlTableInfo* oneTable, bool dataFormat, SArray *col
 }
 
 static SSmlSTableMeta* smlBuildSTableMeta(){
-  SSmlSTableMeta* meta = taosMemoryCalloc(sizeof(SSmlSTableMeta), 1);
+  SSmlSTableMeta* meta = (SSmlSTableMeta*)taosMemoryCalloc(sizeof(SSmlSTableMeta), 1);
   if(!meta){
     return NULL;
   }
@@ -1429,7 +1423,7 @@ static SSmlSTableMeta* smlBuildSTableMeta(){
   return meta;
 
 cleanup:
-  taosMemoryFreeClear(meta);
+  taosMemoryFree(meta);
   return NULL;
 }
 
@@ -1475,9 +1469,9 @@ static int32_t smlParseLine(SSmlHandle* info, const char* sql) {
     return TSDB_CODE_SML_INVALID_DATA;
   }
 
-  SSmlTableInfo **oneTable = taosHashGet(info->childTables, elements.measure, elements.measureTagsLen);
+  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashGet(info->childTables, elements.measure, elements.measureTagsLen);
   if(oneTable){
-    SSmlSTableMeta** tableMeta = taosHashGet(info->superTables, elements.measure, elements.measureLen);
+    SSmlSTableMeta** tableMeta = (SSmlSTableMeta**)taosHashGet(info->superTables, elements.measure, elements.measureLen);
     ASSERT(tableMeta);
     ret = smlUpdateMeta(*tableMeta, NULL, cols, &info->msgBuf);    // update meta cols
     if(!ret){
@@ -1516,7 +1510,7 @@ static int32_t smlParseLine(SSmlHandle* info, const char* sql) {
     buildChildTableName(&rName);
     tinfo->uid = rName.uid;
 
-    SSmlSTableMeta** tableMeta = taosHashGet(info->superTables, elements.measure, elements.measureLen);
+    SSmlSTableMeta** tableMeta = (SSmlSTableMeta**)taosHashGet(info->superTables, elements.measure, elements.measureLen);
     if(tableMeta){  // update meta
       ret = smlUpdateMeta(*tableMeta, tinfo->tags, cols, &info->msgBuf);
       if(!ret){
@@ -1545,20 +1539,18 @@ static void smlDestroyInfo(SSmlHandle* info){
   smlDestroyHandle(info->exec);
 
   // destroy info->childTables
-  void** p1 = taosHashIterate(info->childTables, NULL);
+  void** p1 = (void**)taosHashIterate(info->childTables, NULL);
   while (p1) {
-    SSmlTableInfo* oneTable = *p1;
-    smlDestroyBuildTableInfo(oneTable, info->dataFormat);
-    p1 = taosHashIterate(info->childTables, p1);
+    smlDestroyBuildTableInfo((SSmlTableInfo*)(*p1), info->dataFormat);
+    p1 = (void**)taosHashIterate(info->childTables, p1);
   }
   taosHashCleanup(info->childTables);
 
   // destroy info->superTables
-  p1 = taosHashIterate(info->superTables, NULL);
+  p1 = (void**)taosHashIterate(info->superTables, NULL);
   while (p1) {
-    SSmlSTableMeta* oneTable = *p1;
-    smlDestroySTableMeta(oneTable);
-    p1 = taosHashIterate(info->superTables, p1);
+    smlDestroySTableMeta((SSmlSTableMeta*)(*p1));
+    p1 = (void**)taosHashIterate(info->superTables, p1);
   }
   taosHashCleanup(info->superTables);
 
@@ -1571,13 +1563,13 @@ static void smlDestroyInfo(SSmlHandle* info){
 
 static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocolType protocol, int8_t precision, bool dataFormat){
   int32_t code = TSDB_CODE_SUCCESS;
-  SSmlHandle* info = taosMemoryCalloc(1, sizeof(SSmlHandle));
+  SSmlHandle* info = (SSmlHandle*)taosMemoryCalloc(1, sizeof(SSmlHandle));
   if (NULL == info) {
     return NULL;
   }
   info->id          = smlGenId();
 
-  info->pQuery      = taosMemoryCalloc(1, sizeof(SQuery));
+  info->pQuery      = (SQuery *)taosMemoryCalloc(1, sizeof(SQuery));
   if (NULL == info->pQuery) {
     uError("SML:0x%"PRIx64" create info->pQuery error", info->id);
     goto cleanup;
@@ -1592,7 +1584,7 @@ static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocol
   }
   ((SVnodeModifOpStmt*)(info->pQuery->pRoot))->payloadType = PAYLOAD_TYPE_KV;
 
-  info->taos        = taos;
+  info->taos        = (STscObj *)taos;
   code = catalogGetHandle(info->taos->pAppInfo->clusterId, &info->pCatalog);
   if(code != TSDB_CODE_SUCCESS){
     uError("SML:0x%"PRIx64" get catalog error %d", info->id, code);
@@ -1634,7 +1626,7 @@ cleanup:
 static int32_t smlInsertData(SSmlHandle* info) {
   int32_t code = TSDB_CODE_SUCCESS;
 
-  SSmlTableInfo** oneTable = taosHashIterate(info->childTables, NULL);
+  SSmlTableInfo** oneTable = (SSmlTableInfo**)taosHashIterate(info->childTables, NULL);
   while (oneTable) {
     SSmlTableInfo* tableData = *oneTable;
 
@@ -1650,7 +1642,7 @@ static int32_t smlInsertData(SSmlHandle* info) {
     }
     taosHashPut(info->pVgHash, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg));
 
-    SSmlSTableMeta** pMeta = taosHashGet(info->superTables, tableData->sTableName, tableData->sTableNameLen);
+    SSmlSTableMeta** pMeta = (SSmlSTableMeta** )taosHashGet(info->superTables, tableData->sTableName, tableData->sTableNameLen);
     ASSERT (NULL != pMeta && NULL != *pMeta);
 
     // use tablemeta of stable to save vgid and uid of child table
@@ -1662,7 +1654,7 @@ static int32_t smlInsertData(SSmlHandle* info) {
     if(code != TSDB_CODE_SUCCESS){
       return code;
     }
-    oneTable = taosHashIterate(info->childTables, oneTable);
+    oneTable = (SSmlTableInfo**)taosHashIterate(info->childTables, oneTable);
   }
 
   smlBuildOutput(info->exec, info->pVgHash);
@@ -1748,12 +1740,12 @@ cleanup:
  */
 
 TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision) {
-  SRequestObj* request = createRequest(taos, NULL, NULL, TSDB_SQL_INSERT);
+  SRequestObj* request = (SRequestObj*)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
   if(!request){
     return NULL;
   }
 
-  SSmlHandle* info = smlBuildSmlInfo(taos, request, protocol, precision, true);
+  SSmlHandle* info = smlBuildSmlInfo(taos, request, (SMLProtocolType)protocol, precision, true);
   if(!info){
     return (TAOS_RES*)request;
   }

source/client/test/smlTest.cpp

@@ -214,7 +214,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   msgBuf.len = 256;
 
   SArray *cols = taosArrayInit(16, POINTER_BYTES);
-  ASSERT_NE(cols, NULL);
+  ASSERT_NE(cols, nullptr);
   SHashObj *dumplicateKey = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
   const char *data =
@@ -226,7 +226,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   ASSERT_EQ(size, 19);
 
   // nchar
-  SSmlKv *kv = taosArrayGetP(cols, 0);
+  SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, 0);
   ASSERT_EQ(strncasecmp(kv->key, "cbin", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
@@ -235,7 +235,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   taosMemoryFree(kv);
 
   // nchar
-  kv = taosArrayGetP(cols, 3);
+  kv = (SSmlKv *)taosArrayGetP(cols, 3);
   ASSERT_EQ(strncasecmp(kv->key, "cf64", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
@@ -257,7 +257,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   ASSERT_EQ(size, 1);
 
   // nchar
-  kv = taosArrayGetP(cols, 0);
+  kv = (SSmlKv *)taosArrayGetP(cols, 0);
   ASSERT_EQ(strncasecmp(kv->key, TAG, strlen(TAG)), 0);
   ASSERT_EQ(kv->keyLen, strlen(TAG));
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
@@ -276,7 +276,7 @@ TEST(testCase, smlParseCols_Test) {
   msgBuf.len = 256;
 
   SArray *cols = taosArrayInit(16, POINTER_BYTES);
-  ASSERT_NE(cols, NULL);
+  ASSERT_NE(cols, nullptr);
 
   SHashObj *dumplicateKey = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
@@ -288,7 +288,7 @@ TEST(testCase, smlParseCols_Test) {
   ASSERT_EQ(size, 19);
 
   // binary
-  SSmlKv *kv = taosArrayGetP(cols, 0);
+  SSmlKv *kv = (SSmlKv *)taosArrayGetP(cols, 0);
   ASSERT_EQ(strncasecmp(kv->key, "cbin", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BINARY);
@@ -297,7 +297,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // nchar
-  kv = taosArrayGetP(cols, 1);
+  kv = (SSmlKv *)taosArrayGetP(cols, 1);
   ASSERT_EQ(strncasecmp(kv->key, "cnch", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
@@ -306,7 +306,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // bool
-  kv = taosArrayGetP(cols, 2);
+  kv = (SSmlKv *)taosArrayGetP(cols, 2);
   ASSERT_EQ(strncasecmp(kv->key, "cbool", 5), 0);
   ASSERT_EQ(kv->keyLen, 5);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BOOL);
@@ -315,7 +315,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // double
-  kv = taosArrayGetP(cols, 3);
+  kv = (SSmlKv *)taosArrayGetP(cols, 3);
   ASSERT_EQ(strncasecmp(kv->key, "cf64", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_DOUBLE);
@@ -325,7 +325,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // float
-  kv = taosArrayGetP(cols, 4);
+  kv = (SSmlKv *)taosArrayGetP(cols, 4);
   ASSERT_EQ(strncasecmp(kv->key, "cf32_", 5), 0);
   ASSERT_EQ(kv->keyLen, 5);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_FLOAT);
@@ -335,7 +335,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // float
-  kv = taosArrayGetP(cols, 5);
+  kv = (SSmlKv *)taosArrayGetP(cols, 5);
   ASSERT_EQ(strncasecmp(kv->key, "cf32", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_FLOAT);
@@ -345,7 +345,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // tiny int
-  kv = taosArrayGetP(cols, 6);
+  kv = (SSmlKv *)taosArrayGetP(cols, 6);
   ASSERT_EQ(strncasecmp(kv->key, "ci8", 3), 0);
   ASSERT_EQ(kv->keyLen, 3);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_TINYINT);
@@ -354,7 +354,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // unsigned tiny int
-  kv = taosArrayGetP(cols, 7);
+  kv = (SSmlKv *)taosArrayGetP(cols, 7);
   ASSERT_EQ(strncasecmp(kv->key, "cu8", 3), 0);
   ASSERT_EQ(kv->keyLen, 3);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_UTINYINT);
@@ -363,7 +363,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // small int
-  kv = taosArrayGetP(cols, 8);
+  kv = (SSmlKv *)taosArrayGetP(cols, 8);
   ASSERT_EQ(strncasecmp(kv->key, "ci16", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_SMALLINT);
@@ -372,7 +372,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // unsigned smallint
-  kv = taosArrayGetP(cols, 9);
+  kv = (SSmlKv *)taosArrayGetP(cols, 9);
   ASSERT_EQ(strncasecmp(kv->key, "cu16", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_USMALLINT);
@@ -381,7 +381,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // int
-  kv = taosArrayGetP(cols, 10);
+  kv = (SSmlKv *)taosArrayGetP(cols, 10);
   ASSERT_EQ(strncasecmp(kv->key, "ci32", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_INT);
@@ -390,7 +390,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // unsigned int
-  kv = taosArrayGetP(cols, 11);
+  kv = (SSmlKv *)taosArrayGetP(cols, 11);
   ASSERT_EQ(strncasecmp(kv->key, "cu32", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_UINT);
@@ -400,7 +400,7 @@ TEST(testCase, smlParseCols_Test) {
 
 
   // bigint
-  kv = taosArrayGetP(cols, 12);
+  kv = (SSmlKv *)taosArrayGetP(cols, 12);
   ASSERT_EQ(strncasecmp(kv->key, "ci64", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BIGINT);
@@ -409,7 +409,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // bigint
-  kv = taosArrayGetP(cols, 13);
+  kv = (SSmlKv *)taosArrayGetP(cols, 13);
   ASSERT_EQ(strncasecmp(kv->key, "ci", 2), 0);
   ASSERT_EQ(kv->keyLen, 2);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BIGINT);
@@ -418,7 +418,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // unsigned bigint
-  kv = taosArrayGetP(cols, 14);
+  kv = (SSmlKv *)taosArrayGetP(cols, 14);
   ASSERT_EQ(strncasecmp(kv->key, "cu64", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_UBIGINT);
@@ -427,7 +427,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // bool
-  kv = taosArrayGetP(cols, 15);
+  kv = (SSmlKv *)taosArrayGetP(cols, 15);
   ASSERT_EQ(strncasecmp(kv->key, "cbooltrue", 9), 0);
   ASSERT_EQ(kv->keyLen, 9);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BOOL);
@@ -437,7 +437,7 @@ TEST(testCase, smlParseCols_Test) {
 
 
   // bool
-  kv = taosArrayGetP(cols, 16);
+  kv = (SSmlKv *)taosArrayGetP(cols, 16);
   ASSERT_EQ(strncasecmp(kv->key, "cboolt", 6), 0);
   ASSERT_EQ(kv->keyLen, 6);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BOOL);
@@ -446,7 +446,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // bool
-  kv = taosArrayGetP(cols, 17);
+  kv = (SSmlKv *)taosArrayGetP(cols, 17);
   ASSERT_EQ(strncasecmp(kv->key, "cboolf", 6), 0);
   ASSERT_EQ(kv->keyLen, 6);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_BOOL);
@@ -455,7 +455,7 @@ TEST(testCase, smlParseCols_Test) {
   taosMemoryFree(kv);
 
   // nchar
-  kv = taosArrayGetP(cols, 18);
+  kv = (SSmlKv *)taosArrayGetP(cols, 18);
   ASSERT_EQ(strncasecmp(kv->key, "cnch_", 5), 0);
   ASSERT_EQ(kv->keyLen, 5);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
@@ -469,7 +469,7 @@ TEST(testCase, smlParseCols_Test) {
 
 TEST(testCase, smlParseLine_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  ASSERT_NE(taos, NULL);
+  ASSERT_NE(taos, nullptr);
 
   TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
   taos_free_result(pRes);
@@ -477,11 +477,11 @@ TEST(testCase, smlParseLine_Test) {
   pRes = taos_query(taos, "use sml_db");
   taos_free_result(pRes);
 
-  SRequestObj *request = createRequest(taos, NULL, NULL, TSDB_SQL_INSERT);
-  ASSERT_NE(request, NULL);
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
 
   SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
-  ASSERT_NE(info, NULL);
+  ASSERT_NE(info, nullptr);
 
   const char *sql[9] = {
     "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0 1451606400000000000",
@@ -494,7 +494,7 @@ TEST(testCase, smlParseLine_Test) {
     "readings,name=truck_2,fleet=North,driver=Derek,model=F-150 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=24.5208,longitude=28.09377,elevation=428,velocity=0,heading=304,grade=0,fuel_consumption=25 1451609400000000000",
     "readings,fleet=South,name=truck_0,driver=Trish,model=H-2,device_version=v2.3 fuel_consumption=25,grade=0 1451629400000000000"
   };
-  smlInsertLines(info, sql, 9);
+  smlInsertLines(info, (char**)sql, 9);
 //  for (int i = 0; i < 3; i++) {
 //    smlParseLine(info, sql[i]);
 //  }
@@ -502,7 +502,7 @@ TEST(testCase, smlParseLine_Test) {
 
 TEST(testCase, smlParseLine_error_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  ASSERT_NE(taos, NULL);
+  ASSERT_NE(taos, nullptr);
 
   TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
   taos_free_result(pRes);
@@ -510,17 +510,17 @@ TEST(testCase, smlParseLine_error_Test) {
   pRes = taos_query(taos, "use sml_db");
   taos_free_result(pRes);
 
-  SRequestObj *request = createRequest(taos, NULL, NULL, TSDB_SQL_INSERT);
-  ASSERT_NE(request, NULL);
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
 
   SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
-  ASSERT_NE(info, NULL);
+  ASSERT_NE(info, nullptr);
 
   const char *sql[2] = {
       "measure,t1=3 c1=8",
       "measure,t2=3 c1=8u8"
   };
-  int ret = smlInsertLines(info, sql, 2);
+  int ret = smlInsertLines(info, (char **)sql, 2);
   ASSERT_NE(ret, 0);
 }