Hotfix/sangshuduo/td 7790 taosdump stb dump (#8083)

* [TD-7790]<fix>: taosdump stb dump memory leak.

* fix normal table belong stb be specified.

* merge avro feature code.

* merge avro feature code.

* fix buffer overflow issue.

src/kit/taosdump/taosdump.c

@@ -13,6 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <stdio.h>
+#include <pthread.h>
 #include <iconv.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ -26,6 +28,12 @@
 #include "tsdb.h"
 #include "tutil.h"
 
+#define AVRO_SUPPORT    0
+
+#if AVRO_SUPPORT == 1
+#include <avro.h>
+#endif
+
 #define TSDB_SUPPORT_NANOSECOND 1
 
 #define MAX_FILE_NAME_LEN       256             // max file name length on linux is 255
@@ -128,19 +136,23 @@ enum _describe_table_index {
     TSDB_MAX_DESCRIBE_METRIC
 };
 
-#define COL_NOTE_LEN    128
+#define COL_NOTE_LEN        4
+#define COL_TYPEBUF_LEN     16
+#define COL_VALUEBUF_LEN    32
 
 typedef struct {
-    char field[TSDB_COL_NAME_LEN + 1];
-    char type[16];
+    char field[TSDB_COL_NAME_LEN];
+    char type[COL_TYPEBUF_LEN];
     int length;
     char note[COL_NOTE_LEN];
-} SColDes;
+    char value[COL_VALUEBUF_LEN];
+    char *var_value;
+} ColDes;
 
 typedef struct {
     char name[TSDB_TABLE_NAME_LEN];
-    SColDes cols[];
-} STableDef;
+    ColDes cols[];
+} TableDef;
 
 extern char version[];
 
@@ -334,21 +346,17 @@ static int dumpOut();
 static int dumpIn();
 static void dumpCreateDbClause(SDbInfo *dbInfo, bool isDumpProperty,
         FILE *fp);
-//static int dumpDb(SDbInfo *dbInfo, FILE *fp, TAOS *taos);
-static int dumpStableClasuse(SDbInfo *dbInfo, char *table, FILE *fp);
-static int dumpCreateTableClause(STableDef *tableDes, int numOfCols,
+static int dumpCreateTableClause(TableDef *tableDes, int numOfCols,
         FILE *fp, char* dbName);
-static void dumpCreateMTableClause(STableDef *tableDes, char *stable,
-        int numOfCols, FILE *fp, char* dbName);
 static int getTableDes(
         char* dbName, char *table,
-        STableDef *stableDes, bool isSuperTable);
+        TableDef *stableDes, bool isSuperTable);
 static int64_t dumpTableData(FILE *fp, char *tbName,
         char* dbName,
         int precision,
         char *jsonAvroSchema);
 static int checkParam();
-static void taosFreeDbInfos();
+static void freeDbInfos();
 
 struct arguments g_args = {
     // connection option
@@ -615,6 +623,17 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     return 0;
 }
 
+static void freeTbDes(TableDef *tableDes)
+{
+    for (int i = 0; i < TSDB_MAX_COLUMNS; i ++) {
+        if (tableDes->cols[i].var_value) {
+            free(tableDes->cols[i].var_value);
+        }
+    }
+
+    free(tableDes);
+}
+
 static int queryDbImpl(TAOS *taos, char *command) {
     TAOS_RES *res = NULL;
     int32_t   code = -1;
@@ -694,7 +713,7 @@ static void parse_args(
                 exit(EXIT_FAILURE);
             }
             g_args.databases = true;
-        } else if (0 == strncmp(argv[i], "--version", strlen("--version")) || 
+        } else if (0 == strncmp(argv[i], "--version", strlen("--version")) ||
             0 == strncmp(argv[i], "-V", strlen("-V"))) {
                 printVersion();
                 exit(EXIT_SUCCESS);
@@ -773,7 +792,7 @@ static int getPrecisionByString(char *precision)
     return -1;
 }
 
-static void taosFreeDbInfos() {
+static void freeDbInfos() {
     if (g_dbInfos == NULL) return;
     for (int i = 0; i < g_args.dumpDbCount; i++)
         tfree(g_dbInfos[i]);
@@ -899,7 +918,6 @@ static int inDatabasesSeq(
 
             dbname = strsep(&running, ",");
         }
-
     }
 
     return -1;
@@ -965,10 +983,153 @@ static int getDumpDbCount()
     return count;
 }
 
-static int convertSchemaToAvroSchema(STableDef *stableDes, char **avroSchema)
+static void dumpCreateMTableClause(
+        char* dbName,
+        char *stable,
+        TableDef *tableDes,
+        int numOfCols,
+        FILE *fp
+        ) {
+    int counter = 0;
+    int count_temp = 0;
+
+    char* tmpBuf = (char *)malloc(COMMAND_SIZE);
+    if (tmpBuf == NULL) {
+        errorPrint("%s() LN%d, failed to allocate %d memory\n",
+               __func__, __LINE__, COMMAND_SIZE);
+        return;
+    }
+
+    char *pstr = NULL;
+    pstr = tmpBuf;
+
+    pstr += sprintf(tmpBuf,
+            "CREATE TABLE IF NOT EXISTS %s.%s USING %s.%s TAGS (",
+            dbName, tableDes->name, dbName, stable);
+
+    for (; counter < numOfCols; counter++) {
+        if (tableDes->cols[counter].note[0] != '\0') break;
+    }
+
+    assert(counter < numOfCols);
+    count_temp = counter;
+
+    for (; counter < numOfCols; counter++) {
+        if (counter != count_temp) {
+            if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 ||
+                    strcasecmp(tableDes->cols[counter].type, "nchar") == 0) {
+                //pstr += sprintf(pstr, ", \'%s\'", tableDes->cols[counter].note);
+                if (tableDes->cols[counter].var_value) {
+                    pstr += sprintf(pstr, ", %s",
+                            tableDes->cols[counter].var_value);
+                } else {
+                    pstr += sprintf(pstr, ", %s", tableDes->cols[counter].value);
+                }
+            } else {
+                pstr += sprintf(pstr, ", %s", tableDes->cols[counter].value);
+            }
+        } else {
+            if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 ||
+                    strcasecmp(tableDes->cols[counter].type, "nchar") == 0) {
+                //pstr += sprintf(pstr, "\'%s\'", tableDes->cols[counter].note);
+                if (tableDes->cols[counter].var_value) {
+                    pstr += sprintf(pstr, "%s", tableDes->cols[counter].var_value);
+                } else {
+                    pstr += sprintf(pstr, "%s", tableDes->cols[counter].value);
+                }
+            } else {
+                pstr += sprintf(pstr, "%s", tableDes->cols[counter].value);
+            }
+            /* pstr += sprintf(pstr, "%s", tableDes->cols[counter].note); */
+        }
+
+        /* if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 || strcasecmp(tableDes->cols[counter].type, "nchar")
+         * == 0) { */
+        /*     pstr += sprintf(pstr, "(%d)", tableDes->cols[counter].length); */
+        /* } */
+    }
+
+    pstr += sprintf(pstr, ");");
+
+    fprintf(fp, "%s\n", tmpBuf);
+    free(tmpBuf);
+}
+
+static int convertTbDesToAvroSchema(
+        char *dbName, char *tbName, TableDef *tableDes, int colCount,
+        char **avroSchema)
 {
     errorPrint("%s() LN%d TODO: covert table schema to avro schema\n",
             __func__, __LINE__);
+    // {
+    // "namesapce": "database name",
+    // "type": "record",
+    // "name": "table name",
+    // "fields": [
+    //      {
+    //      "name": "col0 name",
+    //      "type": "long"
+    //      },
+    //      {
+    //      "name": "col1 name",
+    //      "type": ["int", "null"]
+    //      },
+    //      {
+    //      "name": "col2 name",
+    //      "type": ["float", "null"]
+    //      },
+    //      ...
+    //      {
+    //      "name": "coln name",
+    //      "type": ["string", "null"]
+    //      }
+    // ]
+    // }
+    *avroSchema = (char *)calloc(1,
+            17 + TSDB_DB_NAME_LEN               /* dbname section */
+            + 17                                /* type: record */
+            + 11 + TSDB_TABLE_NAME_LEN          /* tbname section */
+            + 10                                /* fields section */
+            + (TSDB_COL_NAME_LEN + 11 + 16) * colCount + 4);    /* fields section */
+    if (*avroSchema == NULL) {
+        errorPrint("%s() LN%d, memory allocation failed!\n", __func__, __LINE__);
+        return -1;
+    }
+
+    char *pstr = *avroSchema;
+    pstr += sprintf(pstr,
+            "{\"namespace\": \"%s\", \"type\": \"record\", \"name\": \"%s\", \"fields\": [",
+            dbName, tbName);
+    for (int i = 0; i < colCount; i ++) {
+        if (0 == i) {
+            pstr += sprintf(pstr,
+                    "{\"name\": \"%s\", \"type\": \"%s\"",
+                    tableDes->cols[i].field, "long");
+        } else {
+            if (strcasecmp(tableDes->cols[i].type, "binary") == 0 ||
+                    strcasecmp(tableDes->cols[i].type, "nchar") == 0) {
+                pstr += sprintf(pstr,
+                    "{\"name\": \"%s\", \"type\": [\"%s\", \"null\"]",
+                    tableDes->cols[i].field, "string");
+            } else {
+                pstr += sprintf(pstr,
+                    "{\"name\": \"%s\", \"type\": [\"%s\", \"null\"]",
+                    tableDes->cols[i].field, tableDes->cols[i].type);
+            }
+        }
+        if ((i != (colCount -1))
+                && (strcmp(tableDes->cols[i + 1].note, "TAG") != 0)) {
+            pstr += sprintf(pstr, "},");
+        } else {
+            pstr += sprintf(pstr, "}");
+            break;
+        }
+    }
+
+    pstr += sprintf(pstr, "]}");
+
+    debugPrint("%s() LN%d, avroSchema: %s\n", __func__, __LINE__, *avroSchema);
+
     return 0;
 }
 
@@ -981,20 +1142,20 @@ static int64_t dumpNormalTable(
         ) {
     int colCount = 0;
 
-    STableDef *tableDes = (STableDef *)calloc(1, sizeof(STableDef)
-            + sizeof(SColDes) * TSDB_MAX_COLUMNS);
+    TableDef *tableDes = (TableDef *)calloc(1, sizeof(TableDef)
+            + sizeof(ColDes) * TSDB_MAX_COLUMNS);
 
     if (stable != NULL && stable[0] != '\0') {  // dump table schema which is created by using super table
         colCount = getTableDes(dbName, tbName, tableDes, false);
 
         if (colCount < 0) {
-            errorPrint("%s", "getTableDes() failed\n");
             free(tableDes);
             return -1;
         }
 
         // create child-table using super-table
-        dumpCreateMTableClause(tableDes, stable, colCount, fp, dbName);
+        dumpCreateMTableClause(dbName, stable, tableDes, colCount, fp);
+
     } else {  // dump table definition
         colCount = getTableDes(dbName, tbName, tableDes, false);
 
@@ -1009,7 +1170,11 @@ static int64_t dumpNormalTable(
 
     char *jsonAvroSchema = NULL;
     if (g_args.avro) {
-        convertSchemaToAvroSchema(tableDes, &jsonAvroSchema);
+        if (0 != convertTbDesToAvroSchema(
+                    dbName, tbName, tableDes, colCount, &jsonAvroSchema)) {
+            freeTbDes(tableDes);
+            return -1;
+        }
     }
 
     free(tableDes);
@@ -1370,6 +1535,34 @@ static int64_t dumpNtbOfStbByThreads(
     return records;
 }
 
+static int dumpStableClasuse(SDbInfo *dbInfo, char *stbName, FILE *fp)
+{
+    uint64_t sizeOfTableDes =
+        (uint64_t)(sizeof(TableDef) + sizeof(ColDes) * TSDB_MAX_COLUMNS);
+
+    TableDef *tableDes = (TableDef *)calloc(1, sizeOfTableDes);
+    if (NULL == tableDes) {
+        errorPrint("%s() LN%d, failed to allocate %"PRIu64" memory\n",
+                __func__, __LINE__, sizeOfTableDes);
+        exit(-1);
+    }
+
+    int colCount = getTableDes(dbInfo->name,
+            stbName, tableDes, true);
+
+    if (colCount < 0) {
+        free(tableDes);
+        errorPrint("%s() LN%d, failed to get stable[%s] schema\n",
+               __func__, __LINE__, stbName);
+        exit(-1);
+    }
+
+    dumpCreateTableClause(tableDes, colCount, fp, dbInfo->name);
+    free(tableDes);
+
+    return 0;
+}
+
 static int64_t dumpCreateSTableClauseOfDb(
         SDbInfo *dbInfo, FILE *fp)
 {
@@ -1714,7 +1907,7 @@ static int dumpOut() {
     /* Close the handle and return */
     fclose(fp);
     taos_free_result(result);
-    taosFreeDbInfos();
+    freeDbInfos();
     fprintf(stderr, "dump out rows: %" PRId64 "\n", g_totalDumpOutRows);
     return 0;
 
@@ -1722,14 +1915,14 @@ _exit_failure:
     fclose(fp);
     taos_close(taos);
     taos_free_result(result);
-    taosFreeDbInfos();
+    freeDbInfos();
     errorPrint("dump out rows: %" PRId64 "\n", g_totalDumpOutRows);
     return -1;
 }
 
 static int getTableDes(
         char* dbName, char *table,
-        STableDef *stableDes, bool isSuperTable) {
+        TableDef *tableDes, bool isSuperTable) {
     TAOS_ROW row = NULL;
     TAOS_RES* res = NULL;
     int colCount = 0;
@@ -1758,22 +1951,21 @@ static int getTableDes(
 
     TAOS_FIELD *fields = taos_fetch_fields(res);
 
-    tstrncpy(stableDes->name, table, TSDB_TABLE_NAME_LEN);
+    tstrncpy(tableDes->name, table, TSDB_TABLE_NAME_LEN);
     while ((row = taos_fetch_row(res)) != NULL) {
-        tstrncpy(stableDes->cols[colCount].field,
+        tstrncpy(tableDes->cols[colCount].field,
                 (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
                 min(TSDB_COL_NAME_LEN + 1,
                     fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes + 1));
-        tstrncpy(stableDes->cols[colCount].type,
+        tstrncpy(tableDes->cols[colCount].type,
                 (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
                 min(16, fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes + 1));
-        stableDes->cols[colCount].length =
+        tableDes->cols[colCount].length =
             *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
-        tstrncpy(stableDes->cols[colCount].note,
+        tstrncpy(tableDes->cols[colCount].note,
                 (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
                 min(COL_NOTE_LEN,
                     fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes + 1));
-
         colCount++;
     }
 
@@ -1786,10 +1978,10 @@ static int getTableDes(
 
     // if child-table have tag, using  select tagName from table to get tagValue
     for (int i = 0 ; i < colCount; i++) {
-        if (strcmp(stableDes->cols[i].note, "TAG") != 0) continue;
+        if (strcmp(tableDes->cols[i].note, "TAG") != 0) continue;
 
         sprintf(sqlstr, "select %s from %s.%s",
-                stableDes->cols[i].field, dbName, table);
+                tableDes->cols[i].field, dbName, table);
 
         res = taos_query(taos, sqlstr);
         code = taos_errno(res);
@@ -1813,7 +2005,7 @@ static int getTableDes(
         }
 
         if (row[TSDB_SHOW_TABLES_NAME_INDEX] == NULL) {
-            sprintf(stableDes->cols[i].note, "%s", "NULL");
+            sprintf(tableDes->cols[i].note, "%s", "NUL");
             taos_free_result(res);
             res = NULL;
             taos_close(taos);
@@ -1825,58 +2017,82 @@ static int getTableDes(
         //int32_t* length = taos_fetch_lengths(tmpResult);
         switch (fields[0].type) {
             case TSDB_DATA_TYPE_BOOL:
-                sprintf(stableDes->cols[i].note, "%d",
+                sprintf(tableDes->cols[i].value, "%d",
                         ((((int32_t)(*((char *)row[TSDB_SHOW_TABLES_NAME_INDEX]))) == 1) ? 1 : 0));
                 break;
             case TSDB_DATA_TYPE_TINYINT:
-                sprintf(stableDes->cols[i].note, "%d",
+                sprintf(tableDes->cols[i].value, "%d",
                         *((int8_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_SMALLINT:
-                sprintf(stableDes->cols[i].note, "%d", *((int16_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
+                sprintf(tableDes->cols[i].value, "%d",
+                        *((int16_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_INT:
-                sprintf(stableDes->cols[i].note, "%d", *((int32_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
+                sprintf(tableDes->cols[i].value, "%d",
+                        *((int32_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_BIGINT:
-                sprintf(stableDes->cols[i].note, "%" PRId64 "", *((int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
+                sprintf(tableDes->cols[i].value, "%" PRId64 "",
+                        *((int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_FLOAT:
-                sprintf(stableDes->cols[i].note, "%f", GET_FLOAT_VAL(row[TSDB_SHOW_TABLES_NAME_INDEX]));
+                sprintf(tableDes->cols[i].value, "%f",
+                        GET_FLOAT_VAL(row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_DOUBLE:
-                sprintf(stableDes->cols[i].note, "%f", GET_DOUBLE_VAL(row[TSDB_SHOW_TABLES_NAME_INDEX]));
+                sprintf(tableDes->cols[i].value, "%f",
+                        GET_DOUBLE_VAL(row[TSDB_SHOW_TABLES_NAME_INDEX]));
                 break;
             case TSDB_DATA_TYPE_BINARY:
-                {
-                    memset(stableDes->cols[i].note, 0, sizeof(stableDes->cols[i].note));
-                    stableDes->cols[i].note[0] = '\'';
-                    char tbuf[COL_NOTE_LEN];
-                    converStringToReadable((char *)row[TSDB_SHOW_TABLES_NAME_INDEX], length[0], tbuf, COL_NOTE_LEN);
-                    char* pstr = stpcpy(&(stableDes->cols[i].note[1]), tbuf);
-                    *(pstr++) = '\'';
-                    break;
+                memset(tableDes->cols[i].value, 0,
+                        sizeof(tableDes->cols[i].value));
+                int len = strlen((char *)row[0]);
+                // FIXME for long value
+                if (len < (COL_VALUEBUF_LEN - 2)) {
+                    tableDes->cols[i].value[0] = '\'';
+                    converStringToReadable(
+                            (char *)row[0],
+                            length[0],
+                            tableDes->cols[i].value + 1,
+                            len);
+                    tableDes->cols[i].value[len+1] = '\'';
+                } else {
+                    tableDes->cols[i].var_value = calloc(1, len + 2);
+                    if (tableDes->cols[i].var_value == NULL) {
+                        errorPrint("%s() LN%d, memory alalocation failed!\n",
+                                __func__, __LINE__);
+                        taos_free_result(res);
+                        return -1;
+                    }
+                    tableDes->cols[i].var_value[0] = '\'';
+                    converStringToReadable((char *)row[0],
+                            length[0],
+                            (char *)(tableDes->cols[i].var_value + 1), len);
+                    tableDes->cols[i].var_value[len+1] = '\'';
                 }
+                break;
+
             case TSDB_DATA_TYPE_NCHAR:
                 {
-                    memset(stableDes->cols[i].note, 0, sizeof(stableDes->cols[i].note));
+                    memset(tableDes->cols[i].value, 0, sizeof(tableDes->cols[i].note));
                     char tbuf[COL_NOTE_LEN-2];    // need reserve 2 bytes for ' '
                     convertNCharToReadable((char *)row[TSDB_SHOW_TABLES_NAME_INDEX], length[0], tbuf, COL_NOTE_LEN);
-                    sprintf(stableDes->cols[i].note, "\'%s\'", tbuf);
+                    sprintf(tableDes->cols[i].value, "\'%s\'", tbuf);
                     break;
                 }
             case TSDB_DATA_TYPE_TIMESTAMP:
-                sprintf(stableDes->cols[i].note, "%" PRId64 "", *(int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]);
+                sprintf(tableDes->cols[i].value, "%" PRId64 "", *(int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]);
 #if 0
                 if (!g_args.mysqlFlag) {
-                    sprintf(tableDes->cols[i].note, "%" PRId64 "", *(int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]);
+                    sprintf(tableDes->cols[i].value, "%" PRId64 "", *(int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]);
                 } else {
                     char buf[64] = "\0";
                     int64_t ts = *((int64_t *)row[TSDB_SHOW_TABLES_NAME_INDEX]);
                     time_t tt = (time_t)(ts / 1000);
                     struct tm *ptm = localtime(&tt);
                     strftime(buf, 64, "%y-%m-%d %H:%M:%S", ptm);
-                    sprintf(tableDes->cols[i].note, "\'%s.%03d\'", buf, (int)(ts % 1000));
+                    sprintf(tableDes->cols[i].value, "\'%s.%03d\'", buf, (int)(ts % 1000));
                 }
 #endif
                 break;
@@ -1913,35 +2129,7 @@ static void dumpCreateDbClause(
     fprintf(fp, "%s\n\n", sqlstr);
 }
 
-static int dumpStableClasuse(SDbInfo *dbInfo, char *stbName, FILE *fp)
-{
-    uint64_t sizeOfTableDes =
-        (uint64_t)(sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
-
-    STableDef *stableDes = (STableDef *)calloc(1, sizeOfTableDes);
-    if (NULL == stableDes) {
-        errorPrint("%s() LN%d, failed to allocate %"PRIu64" memory\n",
-                __func__, __LINE__, sizeOfTableDes);
-        exit(-1);
-    }
-
-    int colCount = getTableDes(dbInfo->name,
-            stbName, stableDes, true);
-
-    if (colCount < 0) {
-        free(stableDes);
-        errorPrint("%s() LN%d, failed to get stable[%s] schema\n",
-               __func__, __LINE__, stbName);
-        exit(-1);
-    }
-
-    dumpCreateTableClause(stableDes, colCount, fp, dbInfo->name);
-    free(stableDes);
-
-    return 0;
-}
-
-static int dumpCreateTableClause(STableDef *tableDes, int numOfCols,
+static int dumpCreateTableClause(TableDef *tableDes, int numOfCols,
         FILE *fp, char* dbName) {
     int counter = 0;
     int count_temp = 0;
@@ -1992,64 +2180,6 @@ static int dumpCreateTableClause(STableDef *tableDes, int numOfCols,
     return fprintf(fp, "%s\n\n", sqlstr);
 }
 
-static void dumpCreateMTableClause(STableDef *tableDes, char *stable,
-        int numOfCols, FILE *fp, char* dbName) {
-    int counter = 0;
-    int count_temp = 0;
-
-    char* tmpBuf = (char *)malloc(COMMAND_SIZE);
-    if (tmpBuf == NULL) {
-        errorPrint("%s() LN%d, failed to allocate %d memory\n",
-               __func__, __LINE__, COMMAND_SIZE);
-        return;
-    }
-
-    char *pstr = NULL;
-    pstr = tmpBuf;
-
-    pstr += sprintf(tmpBuf,
-            "CREATE TABLE IF NOT EXISTS %s.%s USING %s.%s TAGS (",
-            dbName, tableDes->name, dbName, stable);
-
-    for (; counter < numOfCols; counter++) {
-        if (tableDes->cols[counter].note[0] != '\0') break;
-    }
-
-    assert(counter < numOfCols);
-    count_temp = counter;
-
-    for (; counter < numOfCols; counter++) {
-        if (counter != count_temp) {
-            if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 ||
-                    strcasecmp(tableDes->cols[counter].type, "nchar") == 0) {
-                //pstr += sprintf(pstr, ", \'%s\'", tableDes->cols[counter].note);
-                pstr += sprintf(pstr, ", %s", tableDes->cols[counter].note);
-            } else {
-                pstr += sprintf(pstr, ", %s", tableDes->cols[counter].note);
-            }
-        } else {
-            if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 ||
-                    strcasecmp(tableDes->cols[counter].type, "nchar") == 0) {
-                //pstr += sprintf(pstr, "\'%s\'", tableDes->cols[counter].note);
-                pstr += sprintf(pstr, "%s", tableDes->cols[counter].note);
-            } else {
-                pstr += sprintf(pstr, "%s", tableDes->cols[counter].note);
-            }
-            /* pstr += sprintf(pstr, "%s", tableDes->cols[counter].note); */
-        }
-
-        /* if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 || strcasecmp(tableDes->cols[counter].type, "nchar")
-         * == 0) { */
-        /*     pstr += sprintf(pstr, "(%d)", tableDes->cols[counter].length); */
-        /* } */
-    }
-
-    pstr += sprintf(pstr, ");");
-
-    fprintf(fp, "%s\n", tmpBuf);
-    free(tmpBuf);
-}
-
 static int writeSchemaToAvro(char *jsonAvroSchema)
 {
     errorPrint("%s() LN%d, TODO: implement write schema to avro",
@@ -2146,10 +2276,7 @@ static int64_t writeResultToSql(TAOS_RES *res, FILE *fp, char *dbName, char *tbN
                 case TSDB_DATA_TYPE_BINARY:
                     {
                         char tbuf[COMMAND_SIZE] = {0};
-                        //*(pstr++) = '\'';
                         converStringToReadable((char *)row[col], length[col], tbuf, COMMAND_SIZE);
-                        //pstr = stpcpy(pstr, tbuf);
-                        //*(pstr++) = '\'';
                         curr_sqlstr_len += sprintf(pstr + curr_sqlstr_len, "\'%s\'", tbuf);
                         break;
                     }
@@ -2405,7 +2532,6 @@ static int converStringToReadable(char *str, int size, char *buf, int bufsize) {
 static int convertNCharToReadable(char *str, int size, char *buf, int bufsize) {
     char *pstr = str;
     char *pbuf = buf;
-    // TODO
     wchar_t wc;
     while (size > 0) {
         if (*pstr == '\0') break;