taosdemo refactor split file

src/kit/taosdemo/CMakeLists.txt

@@ -2,6 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
+INCLUDE_DIRECTORIES(inc)
 
 FIND_PACKAGE(Git)
 IF (GIT_FOUND)
@@ -64,7 +65,7 @@ ELSE ()
 ENDIF ()
 
 IF (TD_LINUX)
-  AUX_SOURCE_DIRECTORY(. SRC)
+  AUX_SOURCE_DIRECTORY(./src SRC)
   ADD_EXECUTABLE(taosdemo ${SRC})
 
   IF (TD_SOMODE_STATIC)
@@ -73,7 +74,7 @@ IF (TD_LINUX)
       TARGET_LINK_LIBRARIES(taosdemo taos cJson ${LINK_JEMALLOC})
   ENDIF ()
 ELSEIF (TD_WINDOWS)
-  AUX_SOURCE_DIRECTORY(. SRC)
+  AUX_SOURCE_DIRECTORY(./src SRC)
   ADD_EXECUTABLE(taosdemo ${SRC})
   SET_SOURCE_FILES_PROPERTIES(./taosdemo.c PROPERTIES COMPILE_FLAGS -w)
   IF (TD_SOMODE_STATIC)
@@ -83,7 +84,7 @@ ELSEIF (TD_WINDOWS)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   # missing a few dependencies, such as <argp.h>
-  AUX_SOURCE_DIRECTORY(. SRC)
+  AUX_SOURCE_DIRECTORY(./src SRC)
   ADD_EXECUTABLE(taosdemo ${SRC})
   
   IF (TD_SOMODE_STATIC)

src/kit/taosdemo/inc/demo.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __DEMO__
+#define __DEMO__
+
+#include <stdint.h>
+#include <taos.h>
+#include <taoserror.h>
+#define _GNU_SOURCE
+#define CURL_STATICLIB
+
+#ifdef LINUX
+#include <argp.h>
+#include <inttypes.h>
+#ifndef _ALPINE
+#include <error.h>
+#endif
+#include <pthread.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#include <wordexp.h>
+#else
+#include <regex.h>
+#include <stdio.h>
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+
+// #include "os.h"
+#include "taos.h"
+#include "taoserror.h"
+#include "tutil.h"
+
+#define REQ_EXTRA_BUF_LEN 1024
+#define RESP_BUF_LEN 4096
+#define SQL_BUFF_LEN 1024
+
+extern char configDir[];
+
+#define STR_INSERT_INTO "INSERT INTO "
+
+#define MAX_RECORDS_PER_REQ 32766
+
+#define HEAD_BUFF_LEN \
+    TSDB_MAX_COLUMNS * 24  // 16*MAX_COLUMNS + (192+32)*2 + insert into ..
+
+#define BUFFER_SIZE TSDB_MAX_ALLOWED_SQL_LEN
+#define FETCH_BUFFER_SIZE 100 * TSDB_MAX_ALLOWED_SQL_LEN
+#define COND_BUF_LEN (BUFFER_SIZE - 30)
+#define COL_BUFFER_LEN ((TSDB_COL_NAME_LEN + 15) * TSDB_MAX_COLUMNS)
+
+#define MAX_USERNAME_SIZE 64
+#define MAX_HOSTNAME_SIZE \
+    253  // https://man7.org/linux/man-pages/man7/hostname.7.html
+#define MAX_TB_NAME_SIZE 64
+#define MAX_DATA_SIZE \
+    (16 * TSDB_MAX_COLUMNS) + 20  // max record len: 16*MAX_COLUMNS, timestamp
+                                  // string and ,('') need extra space
+#define OPT_ABORT 1               /* –abort */
+#define MAX_FILE_NAME_LEN 256     // max file name length on linux is 255.
+#define MAX_PATH_LEN 4096
+
+#define DEFAULT_START_TIME 1500000000000
+
+#define MAX_PREPARED_RAND 1000000
+#define INT_BUFF_LEN 12
+#define BIGINT_BUFF_LEN 21
+#define SMALLINT_BUFF_LEN 7
+#define TINYINT_BUFF_LEN 5
+#define BOOL_BUFF_LEN 6
+#define FLOAT_BUFF_LEN 22
+#define DOUBLE_BUFF_LEN 42
+#define TIMESTAMP_BUFF_LEN 21
+#define PRINT_STAT_INTERVAL 30 * 1000
+
+#define MAX_SAMPLES 10000
+#define MAX_NUM_COLUMNS \
+    (TSDB_MAX_COLUMNS - 1)  // exclude first column timestamp
+
+#define MAX_DB_COUNT 8
+#define MAX_SUPER_TABLE_COUNT 200
+
+#define MAX_QUERY_SQL_COUNT 100
+
+#define MAX_DATABASE_COUNT 256
+#define MAX_JSON_BUFF 6400000
+
+#define INPUT_BUF_LEN 256
+#define EXTRA_SQL_LEN 256
+#define TBNAME_PREFIX_LEN \
+    (TSDB_TABLE_NAME_LEN - 20)  // 20 characters reserved for seq
+#define SMALL_BUFF_LEN 8
+#define DATATYPE_BUFF_LEN (SMALL_BUFF_LEN * 3)
+#define NOTE_BUFF_LEN (SMALL_BUFF_LEN * 16)
+
+#define DEFAULT_NTHREADS 8
+#define DEFAULT_TIMESTAMP_STEP 1
+#define DEFAULT_INTERLACE_ROWS 0
+#define DEFAULT_DATATYPE_NUM 1
+#define DEFAULT_CHILDTABLES 10000
+#define DEFAULT_TEST_MODE 0
+#define DEFAULT_METAFILE NULL
+#define DEFAULT_SQLFILE NULL
+#define DEFAULT_HOST "localhost"
+#define DEFAULT_PORT 6030
+#define DEFAULT_IFACE INTERFACE_BUT
+#define DEFAULT_DATABASE "test"
+#define DEFAULT_REPLICA 1
+#define DEFAULT_TB_PREFIX "d"
+#define DEFAULT_ESCAPE_CHAR false
+#define DEFAULT_USE_METRIC true
+#define DEFAULT_DROP_DB true
+#define DEFAULT_AGGR_FUNC false
+#define DEFAULT_DEBUG false
+#define DEFAULT_VERBOSE false
+#define DEFAULT_PERF_STAT false
+#define DEFAULT_ANS_YES false
+#define DEFAULT_OUTPUT "./output.txt"
+#define DEFAULT_SYNC_MODE 0
+#define DEFAULT_DATA_TYPE \
+    { TSDB_DATA_TYPE_FLOAT, TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_FLOAT }
+#define DEFAULT_DATATYPE \
+    { "FLOAT", "INT", "FLOAT" }
+#define DEFAULT_BINWIDTH 64
+#define DEFAULT_COL_COUNT 4
+#define DEFAULT_LEN_ONE_ROW 76
+#define DEFAULT_INSERT_INTERVAL 0
+#define DEFAULT_QUERY_TIME 1
+#define DEFAULT_PREPARED_RAND 10000
+#define DEFAULT_REQ_PER_REQ 30000
+#define DEFAULT_INSERT_ROWS 10000
+#define DEFAULT_ABORT 0
+#define DEFAULT_RATIO 0
+#define DEFAULT_DISORDER_RANGE 1000
+#define DEFAULT_METHOD_DEL 1
+#define DEFAULT_TOTAL_INSERT 0
+#define DEFAULT_TOTAL_AFFECT 0
+#define DEFAULT_DEMO_MODE true
+#define DEFAULT_CREATE_BATCH 10
+#define DEFAULT_SUB_INTERVAL 10000
+#define DEFAULT_QUERY_INTERVAL 10000
+
+#define STMT_BIND_PARAM_BATCH 1
+
+#if _MSC_VER <= 1900
+#define __func__ __FUNCTION__
+#endif
+
+#define debugPrint(fmt, ...)                            \
+    do {                                                \
+        if (g_args.debug_print || g_args.verbose_print) \
+            fprintf(stderr, "DEBG: " fmt, __VA_ARGS__); \
+    } while (0)
+
+#define verbosePrint(fmt, ...)                                                \
+    do {                                                                      \
+        if (g_args.verbose_print) fprintf(stderr, "VERB: " fmt, __VA_ARGS__); \
+    } while (0)
+
+#define performancePrint(fmt, ...)                      \
+    do {                                                \
+        if (g_args.performance_print)                   \
+            fprintf(stderr, "PERF: " fmt, __VA_ARGS__); \
+    } while (0)
+
+#define errorPrint(fmt, ...)                         \
+    do {                                             \
+        fprintf(stderr, " \033[31m");                \
+        fprintf(stderr, "ERROR: " fmt, __VA_ARGS__); \
+        fprintf(stderr, " \033[0m");                 \
+    } while (0)
+
+enum TEST_MODE {
+    INSERT_TEST,     // 0
+    QUERY_TEST,      // 1
+    SUBSCRIBE_TEST,  // 2
+    INVAID_TEST
+};
+
+typedef enum CREATE_SUB_TABLE_MOD_EN {
+    PRE_CREATE_SUBTBL,
+    AUTO_CREATE_SUBTBL,
+    NO_CREATE_SUBTBL
+} CREATE_SUB_TABLE_MOD_EN;
+
+typedef enum TABLE_EXISTS_EN {
+    TBL_NO_EXISTS,
+    TBL_ALREADY_EXISTS,
+    TBL_EXISTS_BUTT
+} TABLE_EXISTS_EN;
+
+enum enumSYNC_MODE { SYNC_MODE, ASYNC_MODE, MODE_BUT };
+
+enum enum_TAOS_INTERFACE {
+    TAOSC_IFACE,
+    REST_IFACE,
+    STMT_IFACE,
+    SML_IFACE,
+    INTERFACE_BUT
+};
+
+typedef enum enumQUERY_CLASS {
+    SPECIFIED_CLASS,
+    STABLE_CLASS,
+    CLASS_BUT
+} QUERY_CLASS;
+
+typedef enum enum_PROGRESSIVE_OR_INTERLACE {
+    PROGRESSIVE_INSERT_MODE,
+    INTERLACE_INSERT_MODE,
+    INVALID_INSERT_MODE
+} PROG_OR_INTERLACE_MODE;
+
+typedef enum enumQUERY_TYPE {
+    NO_INSERT_TYPE,
+    INSERT_TYPE,
+    QUERY_TYPE_BUT
+} QUERY_TYPE;
+
+enum _show_db_index {
+    TSDB_SHOW_DB_NAME_INDEX,
+    TSDB_SHOW_DB_CREATED_TIME_INDEX,
+    TSDB_SHOW_DB_NTABLES_INDEX,
+    TSDB_SHOW_DB_VGROUPS_INDEX,
+    TSDB_SHOW_DB_REPLICA_INDEX,
+    TSDB_SHOW_DB_QUORUM_INDEX,
+    TSDB_SHOW_DB_DAYS_INDEX,
+    TSDB_SHOW_DB_KEEP_INDEX,
+    TSDB_SHOW_DB_CACHE_INDEX,
+    TSDB_SHOW_DB_BLOCKS_INDEX,
+    TSDB_SHOW_DB_MINROWS_INDEX,
+    TSDB_SHOW_DB_MAXROWS_INDEX,
+    TSDB_SHOW_DB_WALLEVEL_INDEX,
+    TSDB_SHOW_DB_FSYNC_INDEX,
+    TSDB_SHOW_DB_COMP_INDEX,
+    TSDB_SHOW_DB_CACHELAST_INDEX,
+    TSDB_SHOW_DB_PRECISION_INDEX,
+    TSDB_SHOW_DB_UPDATE_INDEX,
+    TSDB_SHOW_DB_STATUS_INDEX,
+    TSDB_MAX_SHOW_DB
+};
+
+// -----------------------------------------SHOW TABLES CONFIGURE
+// -------------------------------------
+enum _show_stables_index {
+    TSDB_SHOW_STABLES_NAME_INDEX,
+    TSDB_SHOW_STABLES_CREATED_TIME_INDEX,
+    TSDB_SHOW_STABLES_COLUMNS_INDEX,
+    TSDB_SHOW_STABLES_METRIC_INDEX,
+    TSDB_SHOW_STABLES_UID_INDEX,
+    TSDB_SHOW_STABLES_TID_INDEX,
+    TSDB_SHOW_STABLES_VGID_INDEX,
+    TSDB_MAX_SHOW_STABLES
+};
+
+enum _describe_table_index {
+    TSDB_DESCRIBE_METRIC_FIELD_INDEX,
+    TSDB_DESCRIBE_METRIC_TYPE_INDEX,
+    TSDB_DESCRIBE_METRIC_LENGTH_INDEX,
+    TSDB_DESCRIBE_METRIC_NOTE_INDEX,
+    TSDB_MAX_DESCRIBE_METRIC
+};
+
+typedef struct SArguments_S {
+    char *   metaFile;
+    uint32_t test_mode;
+    char *   host;
+    uint16_t port;
+    uint16_t iface;
+    char *   user;
+    char     password[SHELL_MAX_PASSWORD_LEN];
+    char *   database;
+    int      replica;
+    char *   tb_prefix;
+    bool     escapeChar;
+    char *   sqlFile;
+    bool     use_metric;
+    bool     drop_database;
+    bool     aggr_func;
+    bool     answer_yes;
+    bool     debug_print;
+    bool     verbose_print;
+    bool     performance_print;
+    char *   output_file;
+    bool     async_mode;
+    char     data_type[MAX_NUM_COLUMNS + 1];
+    char *   dataType[MAX_NUM_COLUMNS + 1];
+    uint32_t binwidth;
+    uint32_t columnCount;
+    uint64_t lenOfOneRow;
+    uint32_t nthreads;
+    uint64_t insert_interval;
+    uint64_t timestamp_step;
+    int64_t  query_times;
+    int64_t  prepared_rand;
+    uint32_t interlaceRows;
+    uint32_t reqPerReq;  // num_of_records_per_req
+    uint64_t max_sql_len;
+    int64_t  ntables;
+    int64_t  insertRows;
+    int      abort;
+    uint32_t disorderRatio;  // 0: no disorder, >0: x%
+    int      disorderRange;  // ms, us or ns. according to database precision
+    uint32_t method_of_delete;
+    uint64_t totalInsertRows;
+    uint64_t totalAffectedRows;
+    bool     demo_mode;  // use default column name and semi-random data
+} SArguments;
+
+typedef struct SColumn_S {
+    char     field[TSDB_COL_NAME_LEN];
+    char     data_type;
+    char     dataType[DATATYPE_BUFF_LEN];
+    uint32_t dataLen;
+    char     note[NOTE_BUFF_LEN];
+} StrColumn;
+
+typedef struct SSuperTable_S {
+    char     stbName[TSDB_TABLE_NAME_LEN];
+    char     dataSource[SMALL_BUFF_LEN];  // rand_gen or sample
+    char     childTblPrefix[TBNAME_PREFIX_LEN];
+    uint16_t childTblExists;
+    int64_t  childTblCount;
+    uint64_t batchCreateTableNum;  // 0: no batch,  > 0: batch table number in
+                                   // one sql
+    uint8_t  autoCreateTable;  // 0: create sub table, 1: auto create sub table
+    uint16_t iface;            // 0: taosc, 1: rest, 2: stmt
+    int64_t  childTblLimit;
+    uint64_t childTblOffset;
+
+    //  int          multiThreadWriteOneTbl;  // 0: no, 1: yes
+    uint32_t interlaceRows;  //
+    int      disorderRatio;  // 0: no disorder, >0: x%
+    int      disorderRange;  // ms, us or ns. according to database precision
+    uint64_t maxSqlLen;      //
+
+    uint64_t insertInterval;  // insert interval, will override global insert
+                              // interval
+    int64_t insertRows;
+    int64_t timeStampStep;
+    char    startTimestamp[MAX_TB_NAME_SIZE];
+    char    sampleFormat[SMALL_BUFF_LEN];  // csv, json
+    char    sampleFile[MAX_FILE_NAME_LEN];
+    char    tagsFile[MAX_FILE_NAME_LEN];
+
+    uint32_t  columnCount;
+    StrColumn columns[TSDB_MAX_COLUMNS];
+    uint32_t  tagCount;
+    StrColumn tags[TSDB_MAX_TAGS];
+
+    char *   childTblName;
+    bool     escapeChar;
+    char *   colsOfCreateChildTable;
+    uint64_t lenOfOneRow;
+    uint64_t lenOfTagOfOneRow;
+
+    char *sampleDataBuf;
+    bool  useSampleTs;
+
+    uint32_t tagSource;  // 0: rand, 1: tag sample
+    char *   tagDataBuf;
+    uint32_t tagSampleCount;
+    uint32_t tagUsePos;
+
+#if STMT_BIND_PARAM_BATCH == 1
+    // bind param batch
+    char *sampleBindBatchArray;
+#endif
+    // statistics
+    uint64_t totalInsertRows;
+    uint64_t totalAffectedRows;
+} SSuperTable;
+
+typedef struct {
+    char    name[TSDB_DB_NAME_LEN];
+    char    create_time[32];
+    int64_t ntables;
+    int32_t vgroups;
+    int16_t replica;
+    int16_t quorum;
+    int16_t days;
+    char    keeplist[64];
+    int32_t cache;  // MB
+    int32_t blocks;
+    int32_t minrows;
+    int32_t maxrows;
+    int8_t  wallevel;
+    int32_t fsync;
+    int8_t  comp;
+    int8_t  cachelast;
+    char    precision[SMALL_BUFF_LEN];  // time resolution
+    int8_t  update;
+    char    status[16];
+} SDbInfo;
+
+typedef struct SDbCfg_S {
+    //  int       maxtablesPerVnode;
+    uint32_t minRows;  // 0 means default
+    uint32_t maxRows;  // 0 means default
+    int      comp;
+    int      walLevel;
+    int      cacheLast;
+    int      fsync;
+    int      replica;
+    int      update;
+    int      keep;
+    int      days;
+    int      cache;
+    int      blocks;
+    int      quorum;
+    char     precision[SMALL_BUFF_LEN];
+} SDbCfg;
+
+typedef struct SDataBase_S {
+    char         dbName[TSDB_DB_NAME_LEN];
+    bool         drop;  // 0: use exists, 1: if exists, drop then new create
+    SDbCfg       dbCfg;
+    uint64_t     superTblCount;
+    SSuperTable *superTbls;
+} SDataBase;
+
+typedef struct SDbs_S {
+    char               cfgDir[MAX_FILE_NAME_LEN];
+    char               host[MAX_HOSTNAME_SIZE];
+    struct sockaddr_in serv_addr;
+
+    uint16_t port;
+    char     user[MAX_USERNAME_SIZE];
+    char     password[SHELL_MAX_PASSWORD_LEN];
+    char     resultFile[MAX_FILE_NAME_LEN];
+    bool     use_metric;
+    bool     aggr_func;
+    bool     asyncMode;
+
+    uint32_t threadCount;
+    uint32_t threadCountForCreateTbl;
+    uint32_t dbCount;
+    // statistics
+    uint64_t totalInsertRows;
+    uint64_t totalAffectedRows;
+
+    SDataBase *db;
+} SDbs;
+
+typedef struct SpecifiedQueryInfo_S {
+    uint64_t  queryInterval;  // 0: unlimited  > 0   loop/s
+    uint32_t  concurrent;
+    int       sqlCount;
+    uint32_t  asyncMode;          // 0: sync, 1: async
+    uint64_t  subscribeInterval;  // ms
+    uint64_t  queryTimes;
+    bool      subscribeRestart;
+    int       subscribeKeepProgress;
+    char      sql[MAX_QUERY_SQL_COUNT][BUFFER_SIZE + 1];
+    char      result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN];
+    int       resubAfterConsume[MAX_QUERY_SQL_COUNT];
+    int       endAfterConsume[MAX_QUERY_SQL_COUNT];
+    TAOS_SUB *tsub[MAX_QUERY_SQL_COUNT];
+    char      topic[MAX_QUERY_SQL_COUNT][32];
+    int       consumed[MAX_QUERY_SQL_COUNT];
+    TAOS_RES *res[MAX_QUERY_SQL_COUNT];
+    uint64_t  totalQueried;
+} SpecifiedQueryInfo;
+
+typedef struct SuperQueryInfo_S {
+    char     stbName[TSDB_TABLE_NAME_LEN];
+    uint64_t queryInterval;  // 0: unlimited  > 0   loop/s
+    uint32_t threadCnt;
+    uint32_t asyncMode;          // 0: sync, 1: async
+    uint64_t subscribeInterval;  // ms
+    bool     subscribeRestart;
+    int      subscribeKeepProgress;
+    uint64_t queryTimes;
+    int64_t  childTblCount;
+    char childTblPrefix[TBNAME_PREFIX_LEN];  // 20 characters reserved for seq
+    int  sqlCount;
+    char sql[MAX_QUERY_SQL_COUNT][BUFFER_SIZE + 1];
+    char result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN];
+    int  resubAfterConsume;
+    int  endAfterConsume;
+    TAOS_SUB *tsub[MAX_QUERY_SQL_COUNT];
+
+    char *   childTblName;
+    uint64_t totalQueried;
+} SuperQueryInfo;
+
+typedef struct SQueryMetaInfo_S {
+    char               cfgDir[MAX_FILE_NAME_LEN];
+    char               host[MAX_HOSTNAME_SIZE];
+    uint16_t           port;
+    struct sockaddr_in serv_addr;
+    char               user[MAX_USERNAME_SIZE];
+    char               password[SHELL_MAX_PASSWORD_LEN];
+    char               dbName[TSDB_DB_NAME_LEN];
+    char               queryMode[SMALL_BUFF_LEN];  // taosc, rest
+
+    SpecifiedQueryInfo specifiedQueryInfo;
+    SuperQueryInfo     superQueryInfo;
+    uint64_t           totalQueried;
+} SQueryMetaInfo;
+
+typedef struct SThreadInfo_S {
+    TAOS *     taos;
+    TAOS_STMT *stmt;
+    int64_t *  bind_ts;
+
+#if STMT_BIND_PARAM_BATCH == 1
+    int64_t *bind_ts_array;
+    char *   bindParams;
+    char *   is_null;
+#else
+    char *sampleBindArray;
+#endif
+
+    int          threadID;
+    char         db_name[TSDB_DB_NAME_LEN];
+    uint32_t     time_precision;
+    char         filePath[MAX_PATH_LEN];
+    FILE *       fp;
+    char         tb_prefix[TSDB_TABLE_NAME_LEN];
+    uint64_t     start_table_from;
+    uint64_t     end_table_to;
+    int64_t      ntables;
+    int64_t      tables_created;
+    uint64_t     data_of_rate;
+    int64_t      start_time;
+    char *       cols;
+    bool         use_metric;
+    SSuperTable *stbInfo;
+    char *       buffer;  // sql cmd buffer
+
+    // for async insert
+    tsem_t   lock_sem;
+    int64_t  counter;
+    uint64_t st;
+    uint64_t et;
+    uint64_t lastTs;
+
+    // sample data
+    int64_t samplePos;
+    // statistics
+    uint64_t totalInsertRows;
+    uint64_t totalAffectedRows;
+
+    // insert delay statistics
+    uint64_t cntDelay;
+    uint64_t totalDelay;
+    uint64_t avgDelay;
+    uint64_t maxDelay;
+    uint64_t minDelay;
+
+    // seq of query or subscribe
+    uint64_t  querySeq;  // sequence number of sql command
+    TAOS_SUB *tsub;
+
+    char **lines;
+    int    sockfd;
+} threadInfo;
+
+/* ************ Global variables ************  */
+extern char *         g_dupstr;
+extern char *         g_aggreFuncDemo[];
+extern char *         g_aggreFunc[];
+extern SArguments     g_args;
+extern SDbs           g_Dbs;
+extern int64_t        g_totalChildTables;
+extern int64_t        g_actualChildTables;
+extern SQueryMetaInfo g_queryInfo;
+extern FILE *         g_fpOfInsertResult;
+
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+
+/* ************ Function declares ************  */
+int   parse_args(int argc, char *argv[], SArguments *arguments);
+int   getInfoFromJsonFile(char *file);
+void  setupForAnsiEscape(void);
+int   taosRandom();
+int   testMetaFile();
+int   insertTestProcess();
+int   printfInsertMeta();
+void  printfInsertMetaToFile(FILE *fp);
+void  prompt();
+void  postFreeResource();
+void  setParaFromArg();
+void  printStatPerThread(threadInfo *pThreadInfo);
+void  tmfree(void *buf);
+void  tmfclose(FILE *fp);
+void  fetchResult(TAOS_RES *res, threadInfo *pThreadInfo);
+int   postProceSql(char *host, uint16_t port, char *sqlstr,
+                   threadInfo *pThreadInfo);
+void  appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo);
+int   queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet);
+int   regexMatch(const char *s, const char *reg, int cflags);
+int   convertHostToServAddr(char *host, uint16_t port,
+                            struct sockaddr_in *serv_addr);
+char *formatTimestamp(char *buf, int64_t val, int precision);
+int   getChildNameOfSuperTableWithLimitAndOffset(TAOS *taos, char *dbName,
+                                                 char *   stbName,
+                                                 char **  childTblNameOfSuperTbl,
+                                                 int64_t *childTblCountOfSuperTbl,
+                                                 int64_t limit, uint64_t offset,
+                                                 bool escapChar);
+void  errorWrongValue(char *program, char *wrong_arg, char *wrong_value);
+void  errorUnrecognized(char *program, char *wrong_arg);
+void  errorPrintReqArg(char *program, char *wrong_arg);
+void  errorPrintReqArg2(char *program, char *wrong_arg);
+void  errorPrintReqArg3(char *program, char *wrong_arg);
+bool  isStringNumber(char *input);
+void  printHelp();
+int   queryTestProcess();
+void  ERROR_EXIT(const char *msg);
+void  querySqlFile(TAOS *taos, char *sqlFile);
+void  printVersion();
+int   subscribeTestProcess();
+void  testCmdLine();
+int   isCommentLine(char *line);
+void  replaceChildTblName(char *inSql, char *outSql, int tblIndex);
+void  printfQueryMeta();
+int   getAllChildNameOfSuperTable(TAOS *taos, char *dbName, char *stbName,
+                                  char **  childTblNameOfSuperTbl,
+                                  int64_t *childTblCountOfSuperTbl);
+void  resetAfterAnsiEscape(void);
+void  printfQuerySystemInfo(TAOS *taos);
+#endif
\ No newline at end of file

src/kit/taosdemo/inc/demoData.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __DEMODATA__
+#define __DEMODATA__
+#include "demo.h"
+/***** Global variables ******/
+
+extern char *g_sampleDataBuf;
+#if STMT_BIND_PARAM_BATCH == 1
+// bind param batch
+extern char *g_sampleBindBatchArray;
+#endif
+extern int32_t * g_randint;
+extern uint32_t *g_randuint;
+extern int64_t * g_randbigint;
+extern uint64_t *g_randubigint;
+extern float *   g_randfloat;
+extern double *  g_randdouble;
+
+extern char *g_randbool_buff;
+extern char *g_randint_buff;
+extern char *g_randuint_buff;
+extern char *g_rand_voltage_buff;
+extern char *g_randbigint_buff;
+extern char *g_randubigint_buff;
+extern char *g_randsmallint_buff;
+extern char *g_randusmallint_buff;
+extern char *g_randtinyint_buff;
+extern char *g_randutinyint_buff;
+extern char *g_randfloat_buff;
+extern char *g_rand_current_buff;
+extern char *g_rand_phase_buff;
+extern char *g_randdouble_buff;
+/***** Declare functions *****/
+void                init_rand_data();
+char *              rand_bool_str();
+int32_t             rand_bool();
+char *              rand_tinyint_str();
+int32_t             rand_tinyint();
+char *              rand_utinyint_str();
+int32_t             rand_utinyint();
+char *              rand_smallint_str();
+int32_t             rand_smallint();
+char *              rand_usmallint_str();
+int32_t             rand_usmallint();
+char *              rand_int_str();
+int32_t             rand_int();
+char *              rand_uint_str();
+int32_t             rand_uint();
+char *              rand_bigint_str();
+int64_t             rand_bigint();
+char *              rand_ubigint_str();
+int64_t             rand_ubigint();
+char *              rand_float_str();
+float               rand_float();
+char *              demo_current_float_str();
+float UNUSED_FUNC   demo_current_float();
+char *              demo_voltage_int_str();
+int32_t UNUSED_FUNC demo_voltage_int();
+char *              demo_phase_float_str();
+float UNUSED_FUNC   demo_phase_float();
+void                rand_string(char *str, int size);
+char *              rand_double_str();
+double              rand_double();
+#endif
\ No newline at end of file

src/kit/taosdemo/src/demoCommand.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+#include "demoData.h"
+
+char *g_aggreFuncDemo[] = {"*",
+                           "count(*)",
+                           "avg(current)",
+                           "sum(current)",
+                           "max(current)",
+                           "min(current)",
+                           "first(current)",
+                           "last(current)"};
+char *g_aggreFunc[] = {"*",       "count(*)", "avg(C0)",   "sum(C0)",
+                       "max(C0)", "min(C0)",  "first(C0)", "last(C0)"};
+
+char *g_dupstr = NULL;
+
+int parse_args(int argc, char *argv[], SArguments *arguments) {
+    for (int i = 1; i < argc; i++) {
+        if ((0 == strncmp(argv[i], "-f", strlen("-f"))) ||
+            (0 == strncmp(argv[i], "--file", strlen("--file")))) {
+            arguments->demo_mode = false;
+
+            if (2 == strlen(argv[i])) {
+                if (i + 1 == argc) {
+                    errorPrintReqArg(argv[0], "f");
+                    return -1;
+                }
+                arguments->metaFile = argv[++i];
+            } else if (0 == strncmp(argv[i], "-f", strlen("-f"))) {
+                arguments->metaFile = (char *)(argv[i] + strlen("-f"));
+            } else if (strlen("--file") == strlen(argv[i])) {
+                if (i + 1 == argc) {
+                    errorPrintReqArg3(argv[0], "--file");
+                    return -1;
+                }
+                arguments->metaFile = argv[++i];
+            } else if (0 == strncmp(argv[i], "--file=", strlen("--file="))) {
+                arguments->metaFile = (char *)(argv[i] + strlen("--file="));
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-c", strlen("-c"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--config-dir", strlen("--config-dir")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "c");
+                    return -1;
+                }
+                tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
+            } else if (0 == strncmp(argv[i], "-c", strlen("-c"))) {
+                tstrncpy(configDir, (char *)(argv[i] + strlen("-c")),
+                         TSDB_FILENAME_LEN);
+            } else if (strlen("--config-dir") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--config-dir");
+                    return -1;
+                }
+                tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
+            } else if (0 == strncmp(argv[i],
+                                    "--config-dir=", strlen("--config-dir="))) {
+                tstrncpy(configDir, (char *)(argv[i] + strlen("--config-dir=")),
+                         TSDB_FILENAME_LEN);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-h", strlen("-h"))) ||
+                   (0 == strncmp(argv[i], "--host", strlen("--host")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "h");
+                    return -1;
+                }
+                arguments->host = argv[++i];
+            } else if (0 == strncmp(argv[i], "-h", strlen("-h"))) {
+                arguments->host = (char *)(argv[i] + strlen("-h"));
+            } else if (strlen("--host") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--host");
+                    return -1;
+                }
+                arguments->host = argv[++i];
+            } else if (0 == strncmp(argv[i], "--host=", strlen("--host="))) {
+                arguments->host = (char *)(argv[i] + strlen("--host="));
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if (strcmp(argv[i], "-PP") == 0) {
+            arguments->performance_print = true;
+        } else if ((0 == strncmp(argv[i], "-P", strlen("-P"))) ||
+                   (0 == strncmp(argv[i], "--port", strlen("--port")))) {
+            uint64_t port;
+            char     strPort[BIGINT_BUFF_LEN];
+
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "P");
+                    return -1;
+                } else if (isStringNumber(argv[i + 1])) {
+                    tstrncpy(strPort, argv[++i], BIGINT_BUFF_LEN);
+                } else {
+                    errorPrintReqArg2(argv[0], "P");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "--port=", strlen("--port="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--port=")))) {
+                    tstrncpy(strPort, (char *)(argv[i] + strlen("--port=")),
+                             BIGINT_BUFF_LEN);
+                } else {
+                    errorPrintReqArg2(argv[0], "--port");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-P", strlen("-P"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-P")))) {
+                    tstrncpy(strPort, (char *)(argv[i] + strlen("-P")),
+                             BIGINT_BUFF_LEN);
+                } else {
+                    errorPrintReqArg2(argv[0], "--port");
+                    return -1;
+                }
+            } else if (strlen("--port") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--port");
+                    return -1;
+                } else if (isStringNumber(argv[i + 1])) {
+                    tstrncpy(strPort, argv[++i], BIGINT_BUFF_LEN);
+                } else {
+                    errorPrintReqArg2(argv[0], "--port");
+                    return -1;
+                }
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            port = atoi(strPort);
+            if (port > 65535) {
+                errorWrongValue("taosdump", "-P or --port", strPort);
+                return -1;
+            }
+            arguments->port = (uint16_t)port;
+
+        } else if ((0 == strncmp(argv[i], "-I", strlen("-I"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--interface", strlen("--interface")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "I");
+                    return -1;
+                }
+                if (0 == strcasecmp(argv[i + 1], "taosc")) {
+                    arguments->iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "rest")) {
+                    arguments->iface = REST_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "stmt")) {
+                    arguments->iface = STMT_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "sml")) {
+                    arguments->iface = SML_IFACE;
+                } else {
+                    errorWrongValue(argv[0], "-I", argv[i + 1]);
+                    return -1;
+                }
+                i++;
+            } else if (0 == strncmp(argv[i],
+                                    "--interface=", strlen("--interface="))) {
+                if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")),
+                                    "taosc")) {
+                    arguments->iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp(
+                                    (char *)(argv[i] + strlen("--interface=")),
+                                    "rest")) {
+                    arguments->iface = REST_IFACE;
+                } else if (0 == strcasecmp(
+                                    (char *)(argv[i] + strlen("--interface=")),
+                                    "stmt")) {
+                    arguments->iface = STMT_IFACE;
+                } else if (0 == strcasecmp(
+                                    (char *)(argv[i] + strlen("--interface=")),
+                                    "sml")) {
+                    arguments->iface = SML_IFACE;
+                } else {
+                    errorPrintReqArg3(argv[0], "--interface");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-I", strlen("-I"))) {
+                if (0 ==
+                    strcasecmp((char *)(argv[i] + strlen("-I")), "taosc")) {
+                    arguments->iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp((char *)(argv[i] + strlen("-I")),
+                                           "rest")) {
+                    arguments->iface = REST_IFACE;
+                } else if (0 == strcasecmp((char *)(argv[i] + strlen("-I")),
+                                           "stmt")) {
+                    arguments->iface = STMT_IFACE;
+                } else if (0 == strcasecmp((char *)(argv[i] + strlen("-I")),
+                                           "sml")) {
+                    arguments->iface = SML_IFACE;
+                } else {
+                    errorWrongValue(argv[0], "-I",
+                                    (char *)(argv[i] + strlen("-I")));
+                    return -1;
+                }
+            } else if (strlen("--interface") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--interface");
+                    return -1;
+                }
+                if (0 == strcasecmp(argv[i + 1], "taosc")) {
+                    arguments->iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "rest")) {
+                    arguments->iface = REST_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "stmt")) {
+                    arguments->iface = STMT_IFACE;
+                } else if (0 == strcasecmp(argv[i + 1], "sml")) {
+                    arguments->iface = SML_IFACE;
+                } else {
+                    errorWrongValue(argv[0], "--interface", argv[i + 1]);
+                    return -1;
+                }
+                i++;
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-u", strlen("-u"))) ||
+                   (0 == strncmp(argv[i], "--user", strlen("--user")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "u");
+                    return -1;
+                }
+                arguments->user = argv[++i];
+            } else if (0 == strncmp(argv[i], "-u", strlen("-u"))) {
+                arguments->user = (char *)(argv[i++] + strlen("-u"));
+            } else if (0 == strncmp(argv[i], "--user=", strlen("--user="))) {
+                arguments->user = (char *)(argv[i++] + strlen("--user="));
+            } else if (strlen("--user") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--user");
+                    return -1;
+                }
+                arguments->user = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-p", strlen("-p"))) ||
+                   (0 == strcmp(argv[i], "--password"))) {
+            if ((strlen(argv[i]) == 2) ||
+                (0 == strcmp(argv[i], "--password"))) {
+                printf("Enter password: ");
+                taosSetConsoleEcho(false);
+                if (scanf("%s", arguments->password) > 1) {
+                    fprintf(stderr, "password read error!\n");
+                }
+                taosSetConsoleEcho(true);
+            } else {
+                tstrncpy(arguments->password, (char *)(argv[i] + 2),
+                         SHELL_MAX_PASSWORD_LEN);
+            }
+        } else if ((0 == strncmp(argv[i], "-o", strlen("-o"))) ||
+                   (0 == strncmp(argv[i], "--output", strlen("--output")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--output");
+                    return -1;
+                }
+                arguments->output_file = argv[++i];
+            } else if (0 ==
+                       strncmp(argv[i], "--output=", strlen("--output="))) {
+                arguments->output_file =
+                    (char *)(argv[i++] + strlen("--output="));
+            } else if (0 == strncmp(argv[i], "-o", strlen("-o"))) {
+                arguments->output_file = (char *)(argv[i++] + strlen("-o"));
+            } else if (strlen("--output") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--output");
+                    return -1;
+                }
+                arguments->output_file = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-s", strlen("-s"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--sql-file", strlen("--sql-file")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "s");
+                    return -1;
+                }
+                arguments->sqlFile = argv[++i];
+            } else if (0 ==
+                       strncmp(argv[i], "--sql-file=", strlen("--sql-file="))) {
+                arguments->sqlFile =
+                    (char *)(argv[i++] + strlen("--sql-file="));
+            } else if (0 == strncmp(argv[i], "-s", strlen("-s"))) {
+                arguments->sqlFile = (char *)(argv[i++] + strlen("-s"));
+            } else if (strlen("--sql-file") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--sql-file");
+                    return -1;
+                }
+                arguments->sqlFile = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-q", strlen("-q"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--query-mode", strlen("--query-mode")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "q");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "q");
+                    return -1;
+                }
+                arguments->async_mode = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i],
+                                    "--query-mode=", strlen("--query-mode="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--query-mode=")))) {
+                    arguments->async_mode =
+                        atoi((char *)(argv[i] + strlen("--query-mode=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--query-mode");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-q", strlen("-q"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-q")))) {
+                    arguments->async_mode =
+                        atoi((char *)(argv[i] + strlen("-q")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-q");
+                    return -1;
+                }
+            } else if (strlen("--query-mode") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--query-mode");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--query-mode");
+                    return -1;
+                }
+                arguments->async_mode = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-T", strlen("-T"))) ||
+                   (0 == strncmp(argv[i], "--threads", strlen("--threads")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "T");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "T");
+                    return -1;
+                }
+                arguments->nthreads = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--threads=", strlen("--threads="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--threads=")))) {
+                    arguments->nthreads =
+                        atoi((char *)(argv[i] + strlen("--threads=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--threads");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-T", strlen("-T"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-T")))) {
+                    arguments->nthreads =
+                        atoi((char *)(argv[i] + strlen("-T")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-T");
+                    return -1;
+                }
+            } else if (strlen("--threads") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--threads");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--threads");
+                    return -1;
+                }
+                arguments->nthreads = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-i", strlen("-i"))) ||
+                   (0 == strncmp(argv[i], "--insert-interval",
+                                 strlen("--insert-interval")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "i");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "i");
+                    return -1;
+                }
+                arguments->insert_interval = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i], "--insert-interval=",
+                                    strlen("--insert-interval="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--insert-interval=")))) {
+                    arguments->insert_interval =
+                        atoi((char *)(argv[i] + strlen("--insert-interval=")));
+                } else {
+                    errorPrintReqArg3(argv[0], "--insert-innterval");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-i", strlen("-i"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-i")))) {
+                    arguments->insert_interval =
+                        atoi((char *)(argv[i] + strlen("-i")));
+                } else {
+                    errorPrintReqArg3(argv[0], "-i");
+                    return -1;
+                }
+            } else if (strlen("--insert-interval") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--insert-interval");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--insert-interval");
+                    return -1;
+                }
+                arguments->insert_interval = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-S", strlen("-S"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--time-step", strlen("--time-step")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "S");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "S");
+                    return -1;
+                }
+                arguments->async_mode = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i],
+                                    "--time-step=", strlen("--time-step="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--time-step=")))) {
+                    arguments->async_mode =
+                        atoi((char *)(argv[i] + strlen("--time-step=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--time-step");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-S", strlen("-S"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-S")))) {
+                    arguments->async_mode =
+                        atoi((char *)(argv[i] + strlen("-S")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-S");
+                    return -1;
+                }
+            } else if (strlen("--time-step") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--time-step");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--time-step");
+                    return -1;
+                }
+                arguments->async_mode = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if (strcmp(argv[i], "-qt") == 0) {
+            if ((argc == i + 1) || (!isStringNumber(argv[i + 1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-qt need a number following!\n");
+                return -1;
+            }
+            arguments->query_times = atoi(argv[++i]);
+        } else if ((0 == strncmp(argv[i], "-B", strlen("-B"))) ||
+                   (0 == strncmp(argv[i], "--interlace-rows",
+                                 strlen("--interlace-rows")))) {
+            if (strlen("-B") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "B");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "B");
+                    return -1;
+                }
+                arguments->interlaceRows = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i], "--interlace-rows=",
+                                    strlen("--interlace-rows="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--interlace-rows=")))) {
+                    arguments->interlaceRows =
+                        atoi((char *)(argv[i] + strlen("--interlace-rows=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--interlace-rows");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-B", strlen("-B"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-B")))) {
+                    arguments->interlaceRows =
+                        atoi((char *)(argv[i] + strlen("-B")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-B");
+                    return -1;
+                }
+            } else if (strlen("--interlace-rows") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--interlace-rows");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--interlace-rows");
+                    return -1;
+                }
+                arguments->interlaceRows = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-r", strlen("-r"))) ||
+                   (0 == strncmp(argv[i], "--rec-per-req", 13))) {
+            if (strlen("-r") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "r");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "r");
+                    return -1;
+                }
+                arguments->reqPerReq = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i], "--rec-per-req=",
+                                    strlen("--rec-per-req="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--rec-per-req=")))) {
+                    arguments->reqPerReq =
+                        atoi((char *)(argv[i] + strlen("--rec-per-req=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--rec-per-req");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-r", strlen("-r"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-r")))) {
+                    arguments->reqPerReq =
+                        atoi((char *)(argv[i] + strlen("-r")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-r");
+                    return -1;
+                }
+            } else if (strlen("--rec-per-req") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--rec-per-req");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--rec-per-req");
+                    return -1;
+                }
+                arguments->reqPerReq = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-t", strlen("-t"))) ||
+                   (0 == strncmp(argv[i], "--tables", strlen("--tables")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "t");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "t");
+                    return -1;
+                }
+                arguments->ntables = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--tables=", strlen("--tables="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--tables=")))) {
+                    arguments->ntables =
+                        atoi((char *)(argv[i] + strlen("--tables=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--tables");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-t", strlen("-t"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-t")))) {
+                    arguments->ntables = atoi((char *)(argv[i] + strlen("-t")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-t");
+                    return -1;
+                }
+            } else if (strlen("--tables") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--tables");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--tables");
+                    return -1;
+                }
+                arguments->ntables = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            g_totalChildTables = arguments->ntables;
+        } else if ((0 == strncmp(argv[i], "-n", strlen("-n"))) ||
+                   (0 == strncmp(argv[i], "--records", strlen("--records")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "n");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "n");
+                    return -1;
+                }
+                arguments->insertRows = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--records=", strlen("--records="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--records=")))) {
+                    arguments->insertRows =
+                        atoi((char *)(argv[i] + strlen("--records=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--records");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-n", strlen("-n"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-n")))) {
+                    arguments->insertRows =
+                        atoi((char *)(argv[i] + strlen("-n")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-n");
+                    return -1;
+                }
+            } else if (strlen("--records") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--records");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--records");
+                    return -1;
+                }
+                arguments->insertRows = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-d", strlen("-d"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--database", strlen("--database")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "d");
+                    return -1;
+                }
+                arguments->database = argv[++i];
+            } else if (0 ==
+                       strncmp(argv[i], "--database=", strlen("--database="))) {
+                arguments->output_file =
+                    (char *)(argv[i] + strlen("--database="));
+            } else if (0 == strncmp(argv[i], "-d", strlen("-d"))) {
+                arguments->output_file = (char *)(argv[i] + strlen("-d"));
+            } else if (strlen("--database") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--database");
+                    return -1;
+                }
+                arguments->database = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-l", strlen("-l"))) ||
+                   (0 == strncmp(argv[i], "--columns", strlen("--columns")))) {
+            arguments->demo_mode = false;
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "l");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "l");
+                    return -1;
+                }
+                arguments->columnCount = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--columns=", strlen("--columns="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--columns=")))) {
+                    arguments->columnCount =
+                        atoi((char *)(argv[i] + strlen("--columns=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--columns");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-l", strlen("-l"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-l")))) {
+                    arguments->columnCount =
+                        atoi((char *)(argv[i] + strlen("-l")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-l");
+                    return -1;
+                }
+            } else if (strlen("--columns") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--columns");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--columns");
+                    return -1;
+                }
+                arguments->columnCount = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            if (arguments->columnCount > MAX_NUM_COLUMNS) {
+                printf("WARNING: max acceptable columns count is %d\n",
+                       MAX_NUM_COLUMNS);
+                prompt();
+                arguments->columnCount = MAX_NUM_COLUMNS;
+            }
+
+            for (int col = DEFAULT_DATATYPE_NUM; col < arguments->columnCount;
+                 col++) {
+                arguments->dataType[col] = "INT";
+                arguments->data_type[col] = TSDB_DATA_TYPE_INT;
+            }
+            for (int col = arguments->columnCount; col < MAX_NUM_COLUMNS;
+                 col++) {
+                arguments->dataType[col] = NULL;
+                arguments->data_type[col] = TSDB_DATA_TYPE_NULL;
+            }
+        } else if ((0 == strncmp(argv[i], "-b", strlen("-b"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--data-type", strlen("--data-type")))) {
+            arguments->demo_mode = false;
+
+            char *dataType;
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "b");
+                    return -1;
+                }
+                dataType = argv[++i];
+            } else if (0 == strncmp(argv[i],
+                                    "--data-type=", strlen("--data-type="))) {
+                dataType = (char *)(argv[i] + strlen("--data-type="));
+            } else if (0 == strncmp(argv[i], "-b", strlen("-b"))) {
+                dataType = (char *)(argv[i] + strlen("-b"));
+            } else if (strlen("--data-type") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--data-type");
+                    return -1;
+                }
+                dataType = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            if (strstr(dataType, ",") == NULL) {
+                // only one col
+                if (strcasecmp(dataType, "INT") &&
+                    strcasecmp(dataType, "FLOAT") &&
+                    strcasecmp(dataType, "TINYINT") &&
+                    strcasecmp(dataType, "BOOL") &&
+                    strcasecmp(dataType, "SMALLINT") &&
+                    strcasecmp(dataType, "BIGINT") &&
+                    strcasecmp(dataType, "DOUBLE") &&
+                    strcasecmp(dataType, "TIMESTAMP") &&
+                    !regexMatch(dataType,
+                                "^(NCHAR|BINARY)(\\([1-9][0-9]*\\))?$",
+                                REG_ICASE | REG_EXTENDED) &&
+                    strcasecmp(dataType, "UTINYINT") &&
+                    strcasecmp(dataType, "USMALLINT") &&
+                    strcasecmp(dataType, "UINT") &&
+                    strcasecmp(dataType, "UBIGINT")) {
+                    printHelp();
+                    errorPrint("%s", "-b: Invalid data_type!\n");
+                    return -1;
+                }
+                arguments->dataType[0] = dataType;
+                if (0 == strcasecmp(dataType, "INT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_INT;
+                } else if (0 == strcasecmp(dataType, "TINYINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_TINYINT;
+                } else if (0 == strcasecmp(dataType, "SMALLINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_SMALLINT;
+                } else if (0 == strcasecmp(dataType, "BIGINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_BIGINT;
+                } else if (0 == strcasecmp(dataType, "FLOAT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_FLOAT;
+                } else if (0 == strcasecmp(dataType, "DOUBLE")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_DOUBLE;
+                } else if (1 == regexMatch(dataType,
+                                           "^BINARY(\\([1-9][0-9]*\\))?$",
+                                           REG_ICASE | REG_EXTENDED)) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_BINARY;
+                } else if (1 == regexMatch(dataType,
+                                           "^NCHAR(\\([1-9][0-9]*\\))?$",
+                                           REG_ICASE | REG_EXTENDED)) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_NCHAR;
+                } else if (0 == strcasecmp(dataType, "BOOL")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_BOOL;
+                } else if (0 == strcasecmp(dataType, "TIMESTAMP")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_TIMESTAMP;
+                } else if (0 == strcasecmp(dataType, "UTINYINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_UTINYINT;
+                } else if (0 == strcasecmp(dataType, "USMALLINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_USMALLINT;
+                } else if (0 == strcasecmp(dataType, "UINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_UINT;
+                } else if (0 == strcasecmp(dataType, "UBIGINT")) {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_UBIGINT;
+                } else {
+                    arguments->data_type[0] = TSDB_DATA_TYPE_NULL;
+                }
+                arguments->dataType[1] = NULL;
+                arguments->data_type[1] = TSDB_DATA_TYPE_NULL;
+            } else {
+                // more than one col
+                int index = 0;
+                g_dupstr = strdup(dataType);
+                char *running = g_dupstr;
+                char *token = strsep(&running, ",");
+                while (token != NULL) {
+                    if (strcasecmp(token, "INT") &&
+                        strcasecmp(token, "FLOAT") &&
+                        strcasecmp(token, "TINYINT") &&
+                        strcasecmp(token, "BOOL") &&
+                        strcasecmp(token, "SMALLINT") &&
+                        strcasecmp(token, "BIGINT") &&
+                        strcasecmp(token, "DOUBLE") &&
+                        strcasecmp(token, "TIMESTAMP") &&
+                        !regexMatch(token,
+                                    "^(NCHAR|BINARY)(\\([1-9][0-9]*\\))?$",
+                                    REG_ICASE | REG_EXTENDED) &&
+                        strcasecmp(token, "UTINYINT") &&
+                        strcasecmp(token, "USMALLINT") &&
+                        strcasecmp(token, "UINT") &&
+                        strcasecmp(token, "UBIGINT")) {
+                        printHelp();
+                        free(g_dupstr);
+                        errorPrint("%s", "-b: Invalid data_type!\n");
+                        return -1;
+                    }
+
+                    if (0 == strcasecmp(token, "INT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_INT;
+                    } else if (0 == strcasecmp(token, "FLOAT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_FLOAT;
+                    } else if (0 == strcasecmp(token, "SMALLINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_SMALLINT;
+                    } else if (0 == strcasecmp(token, "BIGINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_BIGINT;
+                    } else if (0 == strcasecmp(token, "DOUBLE")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_DOUBLE;
+                    } else if (0 == strcasecmp(token, "TINYINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_TINYINT;
+                    } else if (1 == regexMatch(token,
+                                               "^BINARY(\\([1-9][0-9]*\\))?$",
+                                               REG_ICASE | REG_EXTENDED)) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_BINARY;
+                    } else if (1 == regexMatch(token,
+                                               "^NCHAR(\\([1-9][0-9]*\\))?$",
+                                               REG_ICASE | REG_EXTENDED)) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_NCHAR;
+                    } else if (0 == strcasecmp(token, "BOOL")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_BOOL;
+                    } else if (0 == strcasecmp(token, "TIMESTAMP")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_TIMESTAMP;
+                    } else if (0 == strcasecmp(token, "UTINYINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_UTINYINT;
+                    } else if (0 == strcasecmp(token, "USMALLINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_USMALLINT;
+                    } else if (0 == strcasecmp(token, "UINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_UINT;
+                    } else if (0 == strcasecmp(token, "UBIGINT")) {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_UBIGINT;
+                    } else {
+                        arguments->data_type[index] = TSDB_DATA_TYPE_NULL;
+                    }
+                    arguments->dataType[index] = token;
+                    index++;
+                    token = strsep(&running, ",");
+                    if (index >= MAX_NUM_COLUMNS) break;
+                }
+                arguments->dataType[index] = NULL;
+                arguments->data_type[index] = TSDB_DATA_TYPE_NULL;
+            }
+        } else if ((0 == strncmp(argv[i], "-w", strlen("-w"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--binwidth", strlen("--binwidth")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "w");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "w");
+                    return -1;
+                }
+                arguments->binwidth = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--binwidth=", strlen("--binwidth="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--binwidth=")))) {
+                    arguments->binwidth =
+                        atoi((char *)(argv[i] + strlen("--binwidth=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--binwidth");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-w", strlen("-w"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-w")))) {
+                    arguments->binwidth =
+                        atoi((char *)(argv[i] + strlen("-w")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-w");
+                    return -1;
+                }
+            } else if (strlen("--binwidth") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--binwidth");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--binwidth");
+                    return -1;
+                }
+                arguments->binwidth = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-m", strlen("-m"))) ||
+                   (0 == strncmp(argv[i], "--table-prefix",
+                                 strlen("--table-prefix")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "m");
+                    return -1;
+                }
+                arguments->tb_prefix = argv[++i];
+            } else if (0 == strncmp(argv[i], "--table-prefix=",
+                                    strlen("--table-prefix="))) {
+                arguments->tb_prefix =
+                    (char *)(argv[i] + strlen("--table-prefix="));
+            } else if (0 == strncmp(argv[i], "-m", strlen("-m"))) {
+                arguments->tb_prefix = (char *)(argv[i] + strlen("-m"));
+            } else if (strlen("--table-prefix") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--table-prefix");
+                    return -1;
+                }
+                arguments->tb_prefix = argv[++i];
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-E", strlen("-E"))) ||
+                   (0 == strncmp(argv[i], "--escape-character",
+                                 strlen("--escape-character")))) {
+            arguments->escapeChar = true;
+        } else if ((strcmp(argv[i], "-N") == 0) ||
+                   (0 == strcmp(argv[i], "--normal-table"))) {
+            arguments->demo_mode = false;
+            arguments->use_metric = false;
+        } else if ((strcmp(argv[i], "-M") == 0) ||
+                   (0 == strcmp(argv[i], "--random"))) {
+            arguments->demo_mode = false;
+        } else if ((strcmp(argv[i], "-x") == 0) ||
+                   (0 == strcmp(argv[i], "--aggr-func"))) {
+            arguments->aggr_func = true;
+        } else if ((strcmp(argv[i], "-y") == 0) ||
+                   (0 == strcmp(argv[i], "--answer-yes"))) {
+            arguments->answer_yes = true;
+        } else if ((strcmp(argv[i], "-g") == 0) ||
+                   (0 == strcmp(argv[i], "--debug"))) {
+            arguments->debug_print = true;
+        } else if (strcmp(argv[i], "-gg") == 0) {
+            arguments->verbose_print = true;
+        } else if ((0 == strncmp(argv[i], "-R", strlen("-R"))) ||
+                   (0 == strncmp(argv[i], "--disorder-range",
+                                 strlen("--disorder-range")))) {
+            if (strlen("-R") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "R");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "R");
+                    return -1;
+                }
+                arguments->disorderRange = atoi(argv[++i]);
+            } else if (0 == strncmp(argv[i], "--disorder-range=",
+                                    strlen("--disorder-range="))) {
+                if (isStringNumber(
+                        (char *)(argv[i] + strlen("--disorder-range=")))) {
+                    arguments->disorderRange =
+                        atoi((char *)(argv[i] + strlen("--disorder-range=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--disorder-range");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-R", strlen("-R"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-R")))) {
+                    arguments->disorderRange =
+                        atoi((char *)(argv[i] + strlen("-R")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-R");
+                    return -1;
+                }
+
+                if (arguments->disorderRange < 0) {
+                    errorPrint("Invalid disorder range %d, will be set to %d\n",
+                               arguments->disorderRange, 1000);
+                    arguments->disorderRange = 1000;
+                }
+            } else if (strlen("--disorder-range") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--disorder-range");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--disorder-range");
+                    return -1;
+                }
+                arguments->disorderRange = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+        } else if ((0 == strncmp(argv[i], "-O", strlen("-O"))) ||
+                   (0 ==
+                    strncmp(argv[i], "--disorder", strlen("--disorder")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "O");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "O");
+                    return -1;
+                }
+                arguments->disorderRatio = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--disorder=", strlen("--disorder="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--disorder=")))) {
+                    arguments->disorderRatio =
+                        atoi((char *)(argv[i] + strlen("--disorder=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--disorder");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-O", strlen("-O"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-O")))) {
+                    arguments->disorderRatio =
+                        atoi((char *)(argv[i] + strlen("-O")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-O");
+                    return -1;
+                }
+            } else if (strlen("--disorder") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--disorder");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--disorder");
+                    return -1;
+                }
+                arguments->disorderRatio = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            if (arguments->disorderRatio > 50) {
+                errorPrint("Invalid disorder ratio %d, will be set to %d\n",
+                           arguments->disorderRatio, 50);
+                arguments->disorderRatio = 50;
+            }
+        } else if ((0 == strncmp(argv[i], "-a", strlen("-a"))) ||
+                   (0 == strncmp(argv[i], "--replica", strlen("--replica")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg(argv[0], "a");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "a");
+                    return -1;
+                }
+                arguments->replica = atoi(argv[++i]);
+            } else if (0 ==
+                       strncmp(argv[i], "--replica=", strlen("--replica="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--replica=")))) {
+                    arguments->replica =
+                        atoi((char *)(argv[i] + strlen("--replica=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--replica");
+                    return -1;
+                }
+            } else if (0 == strncmp(argv[i], "-a", strlen("-a"))) {
+                if (isStringNumber((char *)(argv[i] + strlen("-a")))) {
+                    arguments->replica = atoi((char *)(argv[i] + strlen("-a")));
+                } else {
+                    errorPrintReqArg2(argv[0], "-a");
+                    return -1;
+                }
+            } else if (strlen("--replica") == strlen(argv[i])) {
+                if (argc == i + 1) {
+                    errorPrintReqArg3(argv[0], "--replica");
+                    return -1;
+                } else if (!isStringNumber(argv[i + 1])) {
+                    errorPrintReqArg2(argv[0], "--replica");
+                    return -1;
+                }
+                arguments->replica = atoi(argv[++i]);
+            } else {
+                errorUnrecognized(argv[0], argv[i]);
+                return -1;
+            }
+
+            if (arguments->replica > 3 || arguments->replica < 1) {
+                errorPrint("Invalid replica value %d, will be set to %d\n",
+                           arguments->replica, 1);
+                arguments->replica = 1;
+            }
+        } else if (strcmp(argv[i], "-D") == 0) {
+            arguments->method_of_delete = atoi(argv[++i]);
+            if (arguments->method_of_delete > 3) {
+                errorPrint("%s",
+                           "\n\t-D need a value (0~3) number following!\n");
+                return -1;
+            }
+        } else if ((strcmp(argv[i], "--version") == 0) ||
+                   (strcmp(argv[i], "-V") == 0)) {
+            printVersion();
+            return 0;
+        } else if ((strcmp(argv[i], "--help") == 0) ||
+                   (strcmp(argv[i], "-?") == 0)) {
+            printHelp();
+            return 0;
+        } else if (strcmp(argv[i], "--usage") == 0) {
+            printf(
+                "    Usage: taosdemo [-f JSONFILE] [-u USER] [-p PASSWORD] [-c CONFIG_DIR]\n\
+                    [-h HOST] [-P PORT] [-I INTERFACE] [-d DATABASE] [-a REPLICA]\n\
+                    [-m TABLEPREFIX] [-s SQLFILE] [-N] [-o OUTPUTFILE] [-q QUERYMODE]\n\
+                    [-b DATATYPES] [-w WIDTH_OF_BINARY] [-l COLUMNS] [-T THREADNUMBER]\n\
+                    [-i SLEEPTIME] [-S TIME_STEP] [-B INTERLACE_ROWS] [-t TABLES]\n\
+                    [-n RECORDS] [-M] [-x] [-y] [-O ORDERMODE] [-R RANGE] [-a REPLIcA][-g]\n\
+                    [--help] [--usage] [--version]\n");
+            return 0;
+        } else {
+            // to simulate argp_option output
+            if (strlen(argv[i]) > 2) {
+                if (0 == strncmp(argv[i], "--", 2)) {
+                    fprintf(stderr, "%s: unrecognized options '%s'\n", argv[0],
+                            argv[i]);
+                } else if (0 == strncmp(argv[i], "-", 1)) {
+                    char tmp[2] = {0};
+                    tstrncpy(tmp, argv[i] + 1, 2);
+                    fprintf(stderr, "%s: invalid options -- '%s'\n", argv[0],
+                            tmp);
+                } else {
+                    fprintf(stderr, "%s: Too many arguments\n", argv[0]);
+                }
+            } else {
+                fprintf(stderr, "%s invalid options -- '%s'\n", argv[0],
+                        (char *)((char *)argv[i]) + 1);
+            }
+            fprintf(stderr,
+                    "Try `taosdemo --help' or `taosdemo --usage' for more "
+                    "information.\n");
+            return -1;
+        }
+    }
+
+    int columnCount;
+    for (columnCount = 0; columnCount < MAX_NUM_COLUMNS; columnCount++) {
+        if (g_args.dataType[columnCount] == NULL) {
+            break;
+        }
+    }
+
+    if (0 == columnCount) {
+        errorPrint("%s", "data type error!\n");
+        return -1;
+    }
+    g_args.columnCount = columnCount;
+
+    g_args.lenOfOneRow = TIMESTAMP_BUFF_LEN;  // timestamp
+    for (int c = 0; c < g_args.columnCount; c++) {
+        switch (g_args.data_type[c]) {
+            case TSDB_DATA_TYPE_BINARY:
+                g_args.lenOfOneRow += g_args.binwidth + 3;
+                break;
+
+            case TSDB_DATA_TYPE_NCHAR:
+                g_args.lenOfOneRow += g_args.binwidth + 3;
+                break;
+
+            case TSDB_DATA_TYPE_INT:
+            case TSDB_DATA_TYPE_UINT:
+                g_args.lenOfOneRow += INT_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_BIGINT:
+            case TSDB_DATA_TYPE_UBIGINT:
+                g_args.lenOfOneRow += BIGINT_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_SMALLINT:
+            case TSDB_DATA_TYPE_USMALLINT:
+                g_args.lenOfOneRow += SMALLINT_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_TINYINT:
+            case TSDB_DATA_TYPE_UTINYINT:
+                g_args.lenOfOneRow += TINYINT_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_BOOL:
+                g_args.lenOfOneRow += BOOL_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_FLOAT:
+                g_args.lenOfOneRow += FLOAT_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_DOUBLE:
+                g_args.lenOfOneRow += DOUBLE_BUFF_LEN;
+                break;
+
+            case TSDB_DATA_TYPE_TIMESTAMP:
+                g_args.lenOfOneRow += TIMESTAMP_BUFF_LEN;
+                break;
+
+            default:
+                errorPrint("get error data type : %s\n", g_args.dataType[c]);
+                return -1;
+        }
+    }
+
+    if (((arguments->debug_print) && (NULL != arguments->metaFile)) ||
+        arguments->verbose_print) {
+        printf(
+            "##################################################################"
+            "#\n");
+        printf("# meta file:                         %s\n",
+               arguments->metaFile);
+        printf("# Server IP:                         %s:%hu\n",
+               arguments->host == NULL ? "localhost" : arguments->host,
+               arguments->port);
+        printf("# User:                              %s\n", arguments->user);
+        printf("# Password:                          %s\n",
+               arguments->password);
+        printf("# Use metric:                        %s\n",
+               arguments->use_metric ? "true" : "false");
+        if (*(arguments->dataType)) {
+            printf("# Specified data type:               ");
+            for (int c = 0; c < MAX_NUM_COLUMNS; c++)
+                if (arguments->dataType[c])
+                    printf("%s,", arguments->dataType[c]);
+                else
+                    break;
+            printf("\n");
+        }
+        printf("# Insertion interval:                %" PRIu64 "\n",
+               arguments->insert_interval);
+        printf("# Number of records per req:         %u\n",
+               arguments->reqPerReq);
+        printf("# Max SQL length:                    %" PRIu64 "\n",
+               arguments->max_sql_len);
+        printf("# Length of Binary:                  %d\n",
+               arguments->binwidth);
+        printf("# Number of Threads:                 %d\n",
+               arguments->nthreads);
+        printf("# Number of Tables:                  %" PRId64 "\n",
+               arguments->ntables);
+        printf("# Number of Data per Table:          %" PRId64 "\n",
+               arguments->insertRows);
+        printf("# Database name:                     %s\n",
+               arguments->database);
+        printf("# Table prefix:                      %s\n",
+               arguments->tb_prefix);
+        if (arguments->disorderRatio) {
+            printf("# Data order:                        %d\n",
+                   arguments->disorderRatio);
+            printf("# Data out of order rate:            %d\n",
+                   arguments->disorderRange);
+        }
+        printf("# Delete method:                     %d\n",
+               arguments->method_of_delete);
+        printf("# Answer yes when prompt:            %d\n",
+               arguments->answer_yes);
+        printf("# Print debug info:                  %d\n",
+               arguments->debug_print);
+        printf("# Print verbose info:                %d\n",
+               arguments->verbose_print);
+        printf(
+            "##################################################################"
+            "#\n");
+
+        prompt();
+    }
+    return 0;
+}
+void setParaFromArg() {
+    char type[20];
+    char length[20];
+    if (g_args.host) {
+        tstrncpy(g_Dbs.host, g_args.host, MAX_HOSTNAME_SIZE);
+    } else {
+        tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
+    }
+
+    if (g_args.user) {
+        tstrncpy(g_Dbs.user, g_args.user, MAX_USERNAME_SIZE);
+    }
+
+    tstrncpy(g_Dbs.password, g_args.password, SHELL_MAX_PASSWORD_LEN);
+
+    if (g_args.port) {
+        g_Dbs.port = g_args.port;
+    }
+
+    g_Dbs.threadCount = g_args.nthreads;
+    g_Dbs.threadCountForCreateTbl = g_args.nthreads;
+
+    g_Dbs.dbCount = 1;
+    g_Dbs.db[0].drop = true;
+
+    tstrncpy(g_Dbs.db[0].dbName, g_args.database, TSDB_DB_NAME_LEN);
+    g_Dbs.db[0].dbCfg.replica = g_args.replica;
+    tstrncpy(g_Dbs.db[0].dbCfg.precision, "ms", SMALL_BUFF_LEN);
+
+    tstrncpy(g_Dbs.resultFile, g_args.output_file, MAX_FILE_NAME_LEN);
+
+    g_Dbs.use_metric = g_args.use_metric;
+    g_args.prepared_rand = min(g_args.insertRows, MAX_PREPARED_RAND);
+    g_Dbs.aggr_func = g_args.aggr_func;
+
+    char   dataString[TSDB_MAX_BYTES_PER_ROW];
+    char * data_type = g_args.data_type;
+    char **dataType = g_args.dataType;
+
+    memset(dataString, 0, TSDB_MAX_BYTES_PER_ROW);
+
+    if ((data_type[0] == TSDB_DATA_TYPE_BINARY) ||
+        (data_type[0] == TSDB_DATA_TYPE_BOOL) ||
+        (data_type[0] == TSDB_DATA_TYPE_NCHAR)) {
+        g_Dbs.aggr_func = false;
+    }
+
+    if (g_args.use_metric) {
+        g_Dbs.db[0].superTblCount = 1;
+        tstrncpy(g_Dbs.db[0].superTbls[0].stbName, "meters",
+                 TSDB_TABLE_NAME_LEN);
+        g_Dbs.db[0].superTbls[0].childTblCount = g_args.ntables;
+        g_Dbs.db[0].superTbls[0].escapeChar = g_args.escapeChar;
+        g_Dbs.threadCount = g_args.nthreads;
+        g_Dbs.threadCountForCreateTbl = g_args.nthreads;
+        g_Dbs.asyncMode = g_args.async_mode;
+
+        g_Dbs.db[0].superTbls[0].autoCreateTable = PRE_CREATE_SUBTBL;
+        g_Dbs.db[0].superTbls[0].childTblExists = TBL_NO_EXISTS;
+        g_Dbs.db[0].superTbls[0].disorderRange = g_args.disorderRange;
+        g_Dbs.db[0].superTbls[0].disorderRatio = g_args.disorderRatio;
+        tstrncpy(g_Dbs.db[0].superTbls[0].childTblPrefix, g_args.tb_prefix,
+                 TBNAME_PREFIX_LEN);
+        tstrncpy(g_Dbs.db[0].superTbls[0].dataSource, "rand", SMALL_BUFF_LEN);
+
+        if (g_args.iface == INTERFACE_BUT) {
+            g_Dbs.db[0].superTbls[0].iface = TAOSC_IFACE;
+        } else {
+            g_Dbs.db[0].superTbls[0].iface = g_args.iface;
+        }
+        tstrncpy(g_Dbs.db[0].superTbls[0].startTimestamp,
+                 "2017-07-14 10:40:00.000", MAX_TB_NAME_SIZE);
+        g_Dbs.db[0].superTbls[0].timeStampStep = g_args.timestamp_step;
+
+        g_Dbs.db[0].superTbls[0].insertRows = g_args.insertRows;
+        g_Dbs.db[0].superTbls[0].maxSqlLen = g_args.max_sql_len;
+
+        g_Dbs.db[0].superTbls[0].columnCount = 0;
+        for (int i = 0; i < MAX_NUM_COLUMNS; i++) {
+            if (data_type[i] == TSDB_DATA_TYPE_NULL) {
+                break;
+            }
+
+            g_Dbs.db[0].superTbls[0].columns[i].data_type = data_type[i];
+            tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType, dataType[i],
+                     min(DATATYPE_BUFF_LEN, strlen(dataType[i]) + 1));
+            if (1 == regexMatch(dataType[i],
+                                "^(NCHAR|BINARY)(\\([1-9][0-9]*\\))$",
+                                REG_ICASE | REG_EXTENDED)) {
+                sscanf(dataType[i], "%[^(](%[^)]", type, length);
+                g_Dbs.db[0].superTbls[0].columns[i].dataLen = atoi(length);
+                tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType, type,
+                         min(DATATYPE_BUFF_LEN, strlen(type) + 1));
+            } else {
+                g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.binwidth;
+                tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
+                         dataType[i],
+                         min(DATATYPE_BUFF_LEN, strlen(dataType[i]) + 1));
+            }
+            g_Dbs.db[0].superTbls[0].columnCount++;
+        }
+
+        if (g_Dbs.db[0].superTbls[0].columnCount > g_args.columnCount) {
+            g_Dbs.db[0].superTbls[0].columnCount = g_args.columnCount;
+        } else {
+            for (int i = g_Dbs.db[0].superTbls[0].columnCount;
+                 i < g_args.columnCount; i++) {
+                g_Dbs.db[0].superTbls[0].columns[i].data_type =
+                    TSDB_DATA_TYPE_INT;
+                tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType, "INT",
+                         min(DATATYPE_BUFF_LEN, strlen("INT") + 1));
+                g_Dbs.db[0].superTbls[0].columns[i].dataLen = 0;
+                g_Dbs.db[0].superTbls[0].columnCount++;
+            }
+        }
+
+        tstrncpy(g_Dbs.db[0].superTbls[0].tags[0].dataType, "INT",
+                 min(DATATYPE_BUFF_LEN, strlen("INT") + 1));
+        g_Dbs.db[0].superTbls[0].tags[0].data_type = TSDB_DATA_TYPE_INT;
+        g_Dbs.db[0].superTbls[0].tags[0].dataLen = 0;
+
+        tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType, "BINARY",
+                 min(DATATYPE_BUFF_LEN, strlen("BINARY") + 1));
+        g_Dbs.db[0].superTbls[0].tags[1].data_type = TSDB_DATA_TYPE_BINARY;
+        g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.binwidth;
+        g_Dbs.db[0].superTbls[0].tagCount = 2;
+    } else {
+        g_Dbs.threadCountForCreateTbl = g_args.nthreads;
+        g_Dbs.db[0].superTbls[0].tagCount = 0;
+    }
+}
+
+void querySqlFile(TAOS *taos, char *sqlFile) {
+    FILE *fp = fopen(sqlFile, "r");
+    if (fp == NULL) {
+        printf("failed to open file %s, reason:%s\n", sqlFile, strerror(errno));
+        return;
+    }
+
+    int    read_len = 0;
+    char * cmd = calloc(1, TSDB_MAX_BYTES_PER_ROW);
+    size_t cmd_len = 0;
+    char * line = NULL;
+    size_t line_len = 0;
+
+    double t = taosGetTimestampMs();
+
+    while ((read_len = tgetline(&line, &line_len, fp)) != -1) {
+        if (read_len >= TSDB_MAX_BYTES_PER_ROW) continue;
+        line[--read_len] = '\0';
+
+        if (read_len == 0 || isCommentLine(line)) {  // line starts with #
+            continue;
+        }
+
+        if (line[read_len - 1] == '\\') {
+            line[read_len - 1] = ' ';
+            memcpy(cmd + cmd_len, line, read_len);
+            cmd_len += read_len;
+            continue;
+        }
+
+        memcpy(cmd + cmd_len, line, read_len);
+        if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE, false)) {
+            errorPrint("%s() LN%d, queryDbExec %s failed!\n", __func__,
+                       __LINE__, cmd);
+            tmfree(cmd);
+            tmfree(line);
+            tmfclose(fp);
+            return;
+        }
+        memset(cmd, 0, TSDB_MAX_BYTES_PER_ROW);
+        cmd_len = 0;
+    }
+
+    t = taosGetTimestampMs() - t;
+    printf("run %s took %.6f second(s)\n\n", sqlFile, t);
+
+    tmfree(cmd);
+    tmfree(line);
+    tmfclose(fp);
+    return;
+}
+
+void *queryStableAggrFunc(void *sarg) {
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+    TAOS *      taos = pThreadInfo->taos;
+    setThreadName("queryStableAggrFunc");
+    char *command = calloc(1, BUFFER_SIZE);
+    assert(command);
+
+    FILE *fp = fopen(pThreadInfo->filePath, "a");
+    if (NULL == fp) {
+        printf("fopen %s fail, reason:%s.\n", pThreadInfo->filePath,
+               strerror(errno));
+        free(command);
+        return NULL;
+    }
+
+    int64_t insertRows = pThreadInfo->stbInfo->insertRows;
+    int64_t ntables =
+        pThreadInfo->ntables;  // pThreadInfo->end_table_to -
+                               // pThreadInfo->start_table_from + 1;
+    int64_t totalData = insertRows * ntables;
+    bool    aggr_func = g_Dbs.aggr_func;
+
+    char **aggreFunc;
+    int    n;
+
+    if (g_args.demo_mode) {
+        aggreFunc = g_aggreFuncDemo;
+        n = aggr_func ? (sizeof(g_aggreFuncDemo) / sizeof(g_aggreFuncDemo[0]))
+                      : 2;
+    } else {
+        aggreFunc = g_aggreFunc;
+        n = aggr_func ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
+    }
+
+    if (!aggr_func) {
+        printf(
+            "\nThe first field is either Binary or Bool. Aggregation functions "
+            "are not supported.\n");
+    }
+
+    printf("%" PRId64 " records:\n", totalData);
+    fprintf(fp, "Querying On %" PRId64 " records:\n", totalData);
+
+    for (int j = 0; j < n; j++) {
+        char condition[COND_BUF_LEN] = "\0";
+        char tempS[64] = "\0";
+
+        int64_t m = 10 < ntables ? 10 : ntables;
+
+        for (int64_t i = 1; i <= m; i++) {
+            if (i == 1) {
+                if (g_args.demo_mode) {
+                    sprintf(tempS, "groupid = %" PRId64 "", i);
+                } else {
+                    sprintf(tempS, "t0 = %" PRId64 "", i);
+                }
+            } else {
+                if (g_args.demo_mode) {
+                    sprintf(tempS, " or groupid = %" PRId64 " ", i);
+                } else {
+                    sprintf(tempS, " or t0 = %" PRId64 " ", i);
+                }
+            }
+            strncat(condition, tempS, COND_BUF_LEN - 1);
+
+            sprintf(command, "SELECT %s FROM meters WHERE %s", aggreFunc[j],
+                    condition);
+
+            printf("Where condition: %s\n", condition);
+
+            debugPrint("%s() LN%d, sql command: %s\n", __func__, __LINE__,
+                       command);
+            fprintf(fp, "%s\n", command);
+
+            double t = taosGetTimestampUs();
+
+            TAOS_RES *pSql = taos_query(taos, command);
+            int32_t   code = taos_errno(pSql);
+
+            if (code != 0) {
+                errorPrint("Failed to query:%s\n", taos_errstr(pSql));
+                taos_free_result(pSql);
+                taos_close(taos);
+                fclose(fp);
+                free(command);
+                return NULL;
+            }
+            int count = 0;
+            while (taos_fetch_row(pSql) != NULL) {
+                count++;
+            }
+            t = taosGetTimestampUs() - t;
+
+            fprintf(fp, "| Speed: %12.2f(per s) | Latency: %.4f(ms) |\n",
+                    ntables * insertRows / (t / 1000), t);
+            printf("select %10s took %.6f second(s)\n\n", aggreFunc[j],
+                   t / 1000000);
+
+            taos_free_result(pSql);
+        }
+        fprintf(fp, "\n");
+    }
+    fclose(fp);
+    free(command);
+
+    return NULL;
+}
+
+void *queryNtableAggrFunc(void *sarg) {
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+    TAOS *      taos = pThreadInfo->taos;
+    setThreadName("queryNtableAggrFunc");
+    char *command = calloc(1, BUFFER_SIZE);
+    assert(command);
+
+    uint64_t startTime = pThreadInfo->start_time;
+    char *   tb_prefix = pThreadInfo->tb_prefix;
+    FILE *   fp = fopen(pThreadInfo->filePath, "a");
+    if (NULL == fp) {
+        errorPrint("fopen %s fail, reason:%s.\n", pThreadInfo->filePath,
+                   strerror(errno));
+        free(command);
+        return NULL;
+    }
+
+    int64_t insertRows;
+    /*  if (pThreadInfo->stbInfo) {
+        insertRows = pThreadInfo->stbInfo->insertRows; //  nrecords_per_table;
+        } else {
+        */
+    insertRows = g_args.insertRows;
+    //  }
+
+    int64_t ntables =
+        pThreadInfo->ntables;  // pThreadInfo->end_table_to -
+                               // pThreadInfo->start_table_from + 1;
+    int64_t totalData = insertRows * ntables;
+    bool    aggr_func = g_Dbs.aggr_func;
+
+    char **aggreFunc;
+    int    n;
+
+    if (g_args.demo_mode) {
+        aggreFunc = g_aggreFuncDemo;
+        n = aggr_func ? (sizeof(g_aggreFuncDemo) / sizeof(g_aggreFuncDemo[0]))
+                      : 2;
+    } else {
+        aggreFunc = g_aggreFunc;
+        n = aggr_func ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
+    }
+
+    if (!aggr_func) {
+        printf(
+            "\nThe first field is either Binary or Bool. Aggregation functions "
+            "are not supported.\n");
+    }
+    printf("%" PRId64 " records:\n", totalData);
+    fprintf(
+        fp,
+        "| QFunctions |    QRecords    |   QSpeed(R/s)   |  QLatency(ms) |\n");
+
+    for (int j = 0; j < n; j++) {
+        double   totalT = 0;
+        uint64_t count = 0;
+        for (int64_t i = 0; i < ntables; i++) {
+            sprintf(command, "SELECT %s FROM %s%" PRId64 " WHERE ts>= %" PRIu64,
+                    aggreFunc[j], tb_prefix, i, startTime);
+
+            double t = taosGetTimestampUs();
+            debugPrint("%s() LN%d, sql command: %s\n", __func__, __LINE__,
+                       command);
+            TAOS_RES *pSql = taos_query(taos, command);
+            int32_t   code = taos_errno(pSql);
+
+            if (code != 0) {
+                errorPrint("Failed to query:%s\n", taos_errstr(pSql));
+                taos_free_result(pSql);
+                taos_close(taos);
+                fclose(fp);
+                free(command);
+                return NULL;
+            }
+
+            while (taos_fetch_row(pSql) != NULL) {
+                count++;
+            }
+
+            t = taosGetTimestampUs() - t;
+            totalT += t;
+
+            taos_free_result(pSql);
+        }
+
+        fprintf(fp, "|%10s  |   %" PRId64 "   |  %12.2f   |   %10.2f  |\n",
+                aggreFunc[j][0] == '*' ? "   *   " : aggreFunc[j], totalData,
+                (double)(ntables * insertRows) / totalT, totalT / 1000000);
+        printf("select %10s took %.6f second(s)\n", aggreFunc[j],
+               totalT / 1000000);
+    }
+    fprintf(fp, "\n");
+    fclose(fp);
+    free(command);
+    return NULL;
+}
+
+void queryAggrFunc() {
+    // query data
+
+    pthread_t   read_id;
+    threadInfo *pThreadInfo = calloc(1, sizeof(threadInfo));
+    assert(pThreadInfo);
+    pThreadInfo->start_time = DEFAULT_START_TIME;  // 2017-07-14 10:40:00.000
+    pThreadInfo->start_table_from = 0;
+
+    if (g_args.use_metric) {
+        pThreadInfo->ntables = g_Dbs.db[0].superTbls[0].childTblCount;
+        pThreadInfo->end_table_to = g_Dbs.db[0].superTbls[0].childTblCount - 1;
+        pThreadInfo->stbInfo = &g_Dbs.db[0].superTbls[0];
+        tstrncpy(pThreadInfo->tb_prefix,
+                 g_Dbs.db[0].superTbls[0].childTblPrefix, TBNAME_PREFIX_LEN);
+    } else {
+        pThreadInfo->ntables = g_args.ntables;
+        pThreadInfo->end_table_to = g_args.ntables - 1;
+        tstrncpy(pThreadInfo->tb_prefix, g_args.tb_prefix, TSDB_TABLE_NAME_LEN);
+    }
+
+    pThreadInfo->taos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password,
+                                     g_Dbs.db[0].dbName, g_Dbs.port);
+    if (pThreadInfo->taos == NULL) {
+        free(pThreadInfo);
+        errorPrint("Failed to connect to TDengine, reason:%s\n",
+                   taos_errstr(NULL));
+        exit(EXIT_FAILURE);
+    }
+
+    tstrncpy(pThreadInfo->filePath, g_Dbs.resultFile, MAX_FILE_NAME_LEN);
+
+    if (!g_Dbs.use_metric) {
+        pthread_create(&read_id, NULL, queryNtableAggrFunc, pThreadInfo);
+    } else {
+        pthread_create(&read_id, NULL, queryStableAggrFunc, pThreadInfo);
+    }
+    pthread_join(read_id, NULL);
+    taos_close(pThreadInfo->taos);
+    free(pThreadInfo);
+}
+
+void testCmdLine() {
+    if (strlen(configDir)) {
+        wordexp_t full_path;
+        if (wordexp(configDir, &full_path, 0) != 0) {
+            errorPrint("Invalid path %s\n", configDir);
+            return;
+        }
+        taos_options(TSDB_OPTION_CONFIGDIR, full_path.we_wordv[0]);
+        wordfree(&full_path);
+    }
+
+    g_args.test_mode = INSERT_TEST;
+    insertTestProcess();
+
+    if (g_Dbs.aggr_func) {
+        queryAggrFunc();
+    }
+}
\ No newline at end of file

src/kit/taosdemo/src/demoData.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demoData.h"
+#include "demo.h"
+
+char *g_sampleDataBuf = NULL;
+#if STMT_BIND_PARAM_BATCH == 1
+char *g_sampleBindBatchArray = NULL;
+#endif
+int32_t * g_randint = NULL;
+uint32_t *g_randuint = NULL;
+int64_t * g_randbigint = NULL;
+uint64_t *g_randubigint = NULL;
+float *   g_randfloat = NULL;
+double *  g_randdouble = NULL;
+char *    g_randbool_buff = NULL;
+char *    g_randint_buff = NULL;
+char *    g_randuint_buff = NULL;
+char *    g_rand_voltage_buff = NULL;
+char *    g_randbigint_buff = NULL;
+char *    g_randubigint_buff = NULL;
+char *    g_randsmallint_buff = NULL;
+char *    g_randusmallint_buff = NULL;
+char *    g_randtinyint_buff = NULL;
+char *    g_randutinyint_buff = NULL;
+char *    g_randfloat_buff = NULL;
+char *    g_rand_current_buff = NULL;
+char *    g_rand_phase_buff = NULL;
+char *    g_randdouble_buff = NULL;
+
+const char charset[] =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+
+char *rand_bool_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randbool_buff + ((cursor % g_args.prepared_rand) * BOOL_BUFF_LEN);
+}
+
+int32_t rand_bool() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randint[cursor % g_args.prepared_rand] % TSDB_DATA_BOOL_NULL;
+}
+
+char *rand_tinyint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randtinyint_buff +
+           ((cursor % g_args.prepared_rand) * TINYINT_BUFF_LEN);
+}
+
+int32_t rand_tinyint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randint[cursor % g_args.prepared_rand] % TSDB_DATA_TINYINT_NULL;
+}
+
+char *rand_utinyint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randutinyint_buff +
+           ((cursor % g_args.prepared_rand) * TINYINT_BUFF_LEN);
+}
+
+int32_t rand_utinyint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randuint[cursor % g_args.prepared_rand] % TSDB_DATA_UTINYINT_NULL;
+}
+
+char *rand_smallint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randsmallint_buff +
+           ((cursor % g_args.prepared_rand) * SMALLINT_BUFF_LEN);
+}
+
+int32_t rand_smallint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randint[cursor % g_args.prepared_rand] % TSDB_DATA_SMALLINT_NULL;
+}
+
+char *rand_usmallint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randusmallint_buff +
+           ((cursor % g_args.prepared_rand) * SMALLINT_BUFF_LEN);
+}
+
+int32_t rand_usmallint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randuint[cursor % g_args.prepared_rand] % TSDB_DATA_USMALLINT_NULL;
+}
+
+char *rand_int_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randint_buff + ((cursor % g_args.prepared_rand) * INT_BUFF_LEN);
+}
+
+int32_t rand_int() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randint[cursor % g_args.prepared_rand];
+}
+
+char *rand_uint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randuint_buff + ((cursor % g_args.prepared_rand) * INT_BUFF_LEN);
+}
+
+int32_t rand_uint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randuint[cursor % g_args.prepared_rand];
+}
+
+char *rand_bigint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randbigint_buff +
+           ((cursor % g_args.prepared_rand) * BIGINT_BUFF_LEN);
+}
+
+int64_t rand_bigint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randbigint[cursor % g_args.prepared_rand];
+}
+
+char *rand_ubigint_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randubigint_buff +
+           ((cursor % g_args.prepared_rand) * BIGINT_BUFF_LEN);
+}
+
+int64_t rand_ubigint() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randubigint[cursor % g_args.prepared_rand];
+}
+
+char *rand_float_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randfloat_buff +
+           ((cursor % g_args.prepared_rand) * FLOAT_BUFF_LEN);
+}
+
+float rand_float() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randfloat[cursor % g_args.prepared_rand];
+}
+
+char *demo_current_float_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_rand_current_buff +
+           ((cursor % g_args.prepared_rand) * FLOAT_BUFF_LEN);
+}
+
+float UNUSED_FUNC demo_current_float() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return (float)(9.8 +
+                   0.04 * (g_randint[cursor % g_args.prepared_rand] % 10) +
+                   g_randfloat[cursor % g_args.prepared_rand] / 1000000000);
+}
+
+char *demo_voltage_int_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_rand_voltage_buff +
+           ((cursor % g_args.prepared_rand) * INT_BUFF_LEN);
+}
+
+int32_t UNUSED_FUNC demo_voltage_int() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return 215 + g_randint[cursor % g_args.prepared_rand] % 10;
+}
+
+char *demo_phase_float_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_rand_phase_buff +
+           ((cursor % g_args.prepared_rand) * FLOAT_BUFF_LEN);
+}
+
+float UNUSED_FUNC demo_phase_float() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return (float)((115 + g_randint[cursor % g_args.prepared_rand] % 10 +
+                    g_randfloat[cursor % g_args.prepared_rand] / 1000000000) /
+                   360);
+}
+
+void rand_string(char *str, int size) {
+    str[0] = 0;
+    if (size > 0) {
+        //--size;
+        int n;
+        for (n = 0; n < size; n++) {
+            int key = abs(taosRandom()) % (int)(sizeof(charset) - 1);
+            str[n] = charset[key];
+        }
+        str[n] = 0;
+    }
+}
+
+char *rand_double_str() {
+    static int cursor;
+    cursor++;
+    if (cursor > (g_args.prepared_rand - 1)) cursor = 0;
+    return g_randdouble_buff + (cursor * DOUBLE_BUFF_LEN);
+}
+
+double rand_double() {
+    static int cursor;
+    cursor++;
+    cursor = cursor % g_args.prepared_rand;
+    return g_randdouble[cursor];
+}
+
+void init_rand_data() {
+    g_randint_buff = calloc(1, INT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randint_buff);
+    g_rand_voltage_buff = calloc(1, INT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_rand_voltage_buff);
+    g_randbigint_buff = calloc(1, BIGINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randbigint_buff);
+    g_randsmallint_buff = calloc(1, SMALLINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randsmallint_buff);
+    g_randtinyint_buff = calloc(1, TINYINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randtinyint_buff);
+    g_randbool_buff = calloc(1, BOOL_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randbool_buff);
+    g_randfloat_buff = calloc(1, FLOAT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randfloat_buff);
+    g_rand_current_buff = calloc(1, FLOAT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_rand_current_buff);
+    g_rand_phase_buff = calloc(1, FLOAT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_rand_phase_buff);
+    g_randdouble_buff = calloc(1, DOUBLE_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randdouble_buff);
+    g_randuint_buff = calloc(1, INT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randuint_buff);
+    g_randutinyint_buff = calloc(1, TINYINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randutinyint_buff);
+    g_randusmallint_buff = calloc(1, SMALLINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randusmallint_buff);
+    g_randubigint_buff = calloc(1, BIGINT_BUFF_LEN * g_args.prepared_rand);
+    assert(g_randubigint_buff);
+    g_randint = calloc(1, sizeof(int32_t) * g_args.prepared_rand);
+    assert(g_randint);
+    g_randuint = calloc(1, sizeof(uint32_t) * g_args.prepared_rand);
+    assert(g_randuint);
+    g_randbigint = calloc(1, sizeof(int64_t) * g_args.prepared_rand);
+    assert(g_randbigint);
+    g_randubigint = calloc(1, sizeof(uint64_t) * g_args.prepared_rand);
+    assert(g_randubigint);
+    g_randfloat = calloc(1, sizeof(float) * g_args.prepared_rand);
+    assert(g_randfloat);
+    g_randdouble = calloc(1, sizeof(double) * g_args.prepared_rand);
+    assert(g_randdouble);
+
+    for (int i = 0; i < g_args.prepared_rand; i++) {
+        g_randint[i] = (int)(taosRandom() % RAND_MAX - (RAND_MAX >> 1));
+        g_randuint[i] = (int)(taosRandom());
+        sprintf(g_randint_buff + i * INT_BUFF_LEN, "%d", g_randint[i]);
+        sprintf(g_rand_voltage_buff + i * INT_BUFF_LEN, "%d",
+                215 + g_randint[i] % 10);
+
+        sprintf(g_randbool_buff + i * BOOL_BUFF_LEN, "%s",
+                ((g_randint[i] % 2) & 1) ? "true" : "false");
+        sprintf(g_randsmallint_buff + i * SMALLINT_BUFF_LEN, "%d",
+                g_randint[i] % 32768);
+        sprintf(g_randtinyint_buff + i * TINYINT_BUFF_LEN, "%d",
+                g_randint[i] % 128);
+        sprintf(g_randuint_buff + i * INT_BUFF_LEN, "%d", g_randuint[i]);
+        sprintf(g_randusmallint_buff + i * SMALLINT_BUFF_LEN, "%d",
+                g_randuint[i] % 65535);
+        sprintf(g_randutinyint_buff + i * TINYINT_BUFF_LEN, "%d",
+                g_randuint[i] % 255);
+
+        g_randbigint[i] = (int64_t)(taosRandom() % RAND_MAX - (RAND_MAX >> 1));
+        g_randubigint[i] = (uint64_t)(taosRandom());
+        sprintf(g_randbigint_buff + i * BIGINT_BUFF_LEN, "%" PRId64 "",
+                g_randbigint[i]);
+        sprintf(g_randubigint_buff + i * BIGINT_BUFF_LEN, "%" PRId64 "",
+                g_randubigint[i]);
+
+        g_randfloat[i] =
+            (float)(taosRandom() / 1000.0) * (taosRandom() % 2 > 0.5 ? 1 : -1);
+        sprintf(g_randfloat_buff + i * FLOAT_BUFF_LEN, "%f", g_randfloat[i]);
+        sprintf(g_rand_current_buff + i * FLOAT_BUFF_LEN, "%f",
+                (float)(9.8 + 0.04 * (g_randint[i] % 10) +
+                        g_randfloat[i] / 1000000000));
+        sprintf(
+            g_rand_phase_buff + i * FLOAT_BUFF_LEN, "%f",
+            (float)((115 + g_randint[i] % 10 + g_randfloat[i] / 1000000000) /
+                    360));
+
+        g_randdouble[i] = (double)(taosRandom() / 1000000.0) *
+                          (taosRandom() % 2 > 0.5 ? 1 : -1);
+        sprintf(g_randdouble_buff + i * DOUBLE_BUFF_LEN, "%f", g_randdouble[i]);
+    }
+}
\ No newline at end of file

src/kit/taosdemo/src/demoFile.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cJSON.h"
+#include "demo.h"
+
+int getColumnAndTagTypeFromInsertJsonFile(cJSON *      stbInfo,
+                                          SSuperTable *superTbls) {
+    int32_t code = -1;
+
+    // columns
+    cJSON *columns = cJSON_GetObjectItem(stbInfo, "columns");
+    if (columns && columns->type != cJSON_Array) {
+        errorPrint("%s", "failed to read json, columns not found\n");
+        goto PARSE_OVER;
+    } else if (NULL == columns) {
+        superTbls->columnCount = 0;
+        superTbls->tagCount = 0;
+        return 0;
+    }
+
+    int columnSize = cJSON_GetArraySize(columns);
+    if ((columnSize + 1 /* ts */) > TSDB_MAX_COLUMNS) {
+        errorPrint(
+            "failed to read json, column size overflow, max column size is "
+            "%d\n",
+            TSDB_MAX_COLUMNS);
+        goto PARSE_OVER;
+    }
+
+    int       count = 1;
+    int       index = 0;
+    StrColumn columnCase;
+
+    // superTbls->columnCount = columnSize;
+    for (int k = 0; k < columnSize; ++k) {
+        cJSON *column = cJSON_GetArrayItem(columns, k);
+        if (column == NULL) continue;
+
+        count = 1;
+        cJSON *countObj = cJSON_GetObjectItem(column, "count");
+        if (countObj && countObj->type == cJSON_Number) {
+            count = countObj->valueint;
+        } else if (countObj && countObj->type != cJSON_Number) {
+            errorPrint("%s", "failed to read json, column count not found\n");
+            goto PARSE_OVER;
+        } else {
+            count = 1;
+        }
+
+        // column info
+        memset(&columnCase, 0, sizeof(StrColumn));
+        cJSON *dataType = cJSON_GetObjectItem(column, "type");
+        if (!dataType || dataType->type != cJSON_String ||
+            dataType->valuestring == NULL) {
+            errorPrint("%s", "failed to read json, column type not found\n");
+            goto PARSE_OVER;
+        }
+        // tstrncpy(superTbls->columns[k].dataType, dataType->valuestring,
+        // DATATYPE_BUFF_LEN);
+        tstrncpy(columnCase.dataType, dataType->valuestring,
+                 min(DATATYPE_BUFF_LEN, strlen(dataType->valuestring) + 1));
+
+        cJSON *dataLen = cJSON_GetObjectItem(column, "len");
+        if (dataLen && dataLen->type == cJSON_Number) {
+            columnCase.dataLen = dataLen->valueint;
+        } else if (dataLen && dataLen->type != cJSON_Number) {
+            debugPrint("%s() LN%d: failed to read json, column len not found\n",
+                       __func__, __LINE__);
+            goto PARSE_OVER;
+        } else {
+            columnCase.dataLen = SMALL_BUFF_LEN;
+        }
+
+        for (int n = 0; n < count; ++n) {
+            tstrncpy(superTbls->columns[index].dataType, columnCase.dataType,
+                     min(DATATYPE_BUFF_LEN, strlen(columnCase.dataType) + 1));
+
+            superTbls->columns[index].dataLen = columnCase.dataLen;
+            index++;
+        }
+    }
+
+    if ((index + 1 /* ts */) > MAX_NUM_COLUMNS) {
+        errorPrint(
+            "failed to read json, column size overflow, allowed max column "
+            "size is %d\n",
+            MAX_NUM_COLUMNS);
+        goto PARSE_OVER;
+    }
+
+    superTbls->columnCount = index;
+
+    for (int c = 0; c < superTbls->columnCount; c++) {
+        if (0 ==
+            strncasecmp(superTbls->columns[c].dataType, "INT", strlen("INT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_INT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "TINYINT",
+                                    strlen("TINYINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_TINYINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "SMALLINT",
+                                    strlen("SMALLINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_SMALLINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "BIGINT",
+                                    strlen("BIGINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_BIGINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "FLOAT",
+                                    strlen("FLOAT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_FLOAT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "DOUBLE",
+                                    strlen("DOUBLE"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_DOUBLE;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "BINARY",
+                                    strlen("BINARY"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_BINARY;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "NCHAR",
+                                    strlen("NCHAR"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_NCHAR;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "BOOL",
+                                    strlen("BOOL"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_BOOL;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "TIMESTAMP",
+                                    strlen("TIMESTAMP"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "UTINYINT",
+                                    strlen("UTINYINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_UTINYINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "USMALLINT",
+                                    strlen("USMALLINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_USMALLINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "UINT",
+                                    strlen("UINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_UINT;
+        } else if (0 == strncasecmp(superTbls->columns[c].dataType, "UBIGINT",
+                                    strlen("UBIGINT"))) {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_UBIGINT;
+        } else {
+            superTbls->columns[c].data_type = TSDB_DATA_TYPE_NULL;
+        }
+    }
+
+    count = 1;
+    index = 0;
+    // tags
+    cJSON *tags = cJSON_GetObjectItem(stbInfo, "tags");
+    if (!tags || tags->type != cJSON_Array) {
+        errorPrint("%s", "failed to read json, tags not found\n");
+        goto PARSE_OVER;
+    }
+
+    int tagSize = cJSON_GetArraySize(tags);
+    if (tagSize > TSDB_MAX_TAGS) {
+        errorPrint(
+            "failed to read json, tags size overflow, max tag size is %d\n",
+            TSDB_MAX_TAGS);
+        goto PARSE_OVER;
+    }
+
+    // superTbls->tagCount = tagSize;
+    for (int k = 0; k < tagSize; ++k) {
+        cJSON *tag = cJSON_GetArrayItem(tags, k);
+        if (tag == NULL) continue;
+
+        count = 1;
+        cJSON *countObj = cJSON_GetObjectItem(tag, "count");
+        if (countObj && countObj->type == cJSON_Number) {
+            count = countObj->valueint;
+        } else if (countObj && countObj->type != cJSON_Number) {
+            errorPrint("%s", "failed to read json, column count not found\n");
+            goto PARSE_OVER;
+        } else {
+            count = 1;
+        }
+
+        // column info
+        memset(&columnCase, 0, sizeof(StrColumn));
+        cJSON *dataType = cJSON_GetObjectItem(tag, "type");
+        if (!dataType || dataType->type != cJSON_String ||
+            dataType->valuestring == NULL) {
+            errorPrint("%s", "failed to read json, tag type not found\n");
+            goto PARSE_OVER;
+        }
+        tstrncpy(columnCase.dataType, dataType->valuestring,
+                 min(DATATYPE_BUFF_LEN, strlen(dataType->valuestring) + 1));
+
+        cJSON *dataLen = cJSON_GetObjectItem(tag, "len");
+        if (dataLen && dataLen->type == cJSON_Number) {
+            columnCase.dataLen = dataLen->valueint;
+        } else if (dataLen && dataLen->type != cJSON_Number) {
+            errorPrint("%s", "failed to read json, column len not found\n");
+            goto PARSE_OVER;
+        } else {
+            columnCase.dataLen = 0;
+        }
+
+        for (int n = 0; n < count; ++n) {
+            tstrncpy(superTbls->tags[index].dataType, columnCase.dataType,
+                     min(DATATYPE_BUFF_LEN, strlen(columnCase.dataType) + 1));
+            superTbls->tags[index].dataLen = columnCase.dataLen;
+            index++;
+        }
+    }
+
+    if (index > TSDB_MAX_TAGS) {
+        errorPrint(
+            "failed to read json, tags size overflow, allowed max tag count is "
+            "%d\n",
+            TSDB_MAX_TAGS);
+        goto PARSE_OVER;
+    }
+
+    superTbls->tagCount = index;
+
+    for (int t = 0; t < superTbls->tagCount; t++) {
+        if (0 ==
+            strncasecmp(superTbls->tags[t].dataType, "INT", strlen("INT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_INT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "TINYINT",
+                                    strlen("TINYINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_TINYINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "SMALLINT",
+                                    strlen("SMALLINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_SMALLINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "BIGINT",
+                                    strlen("BIGINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_BIGINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "FLOAT",
+                                    strlen("FLOAT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_FLOAT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "DOUBLE",
+                                    strlen("DOUBLE"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_DOUBLE;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "BINARY",
+                                    strlen("BINARY"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_BINARY;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "NCHAR",
+                                    strlen("NCHAR"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_NCHAR;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "BOOL",
+                                    strlen("BOOL"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_BOOL;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "TIMESTAMP",
+                                    strlen("TIMESTAMP"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "UTINYINT",
+                                    strlen("UTINYINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_UTINYINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "USMALLINT",
+                                    strlen("USMALLINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_USMALLINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "UINT",
+                                    strlen("UINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_UINT;
+        } else if (0 == strncasecmp(superTbls->tags[t].dataType, "UBIGINT",
+                                    strlen("UBIGINT"))) {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_UBIGINT;
+        } else {
+            superTbls->tags[t].data_type = TSDB_DATA_TYPE_NULL;
+        }
+    }
+
+    if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) >
+        TSDB_MAX_COLUMNS) {
+        errorPrint(
+            "columns + tags is more than allowed max columns count: %d\n",
+            TSDB_MAX_COLUMNS);
+        goto PARSE_OVER;
+    }
+    code = 0;
+
+PARSE_OVER:
+    return code;
+}
+
+int getMetaFromInsertJsonFile(cJSON *root) {
+    int32_t code = -1;
+
+    cJSON *cfgdir = cJSON_GetObjectItem(root, "cfgdir");
+    if (cfgdir && cfgdir->type == cJSON_String && cfgdir->valuestring != NULL) {
+        tstrncpy(g_Dbs.cfgDir, cfgdir->valuestring, MAX_FILE_NAME_LEN);
+    }
+
+    cJSON *host = cJSON_GetObjectItem(root, "host");
+    if (host && host->type == cJSON_String && host->valuestring != NULL) {
+        tstrncpy(g_Dbs.host, host->valuestring, MAX_HOSTNAME_SIZE);
+    } else if (!host) {
+        tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
+    } else {
+        errorPrint("%s", "failed to read json, host not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *port = cJSON_GetObjectItem(root, "port");
+    if (port && port->type == cJSON_Number) {
+        g_Dbs.port = port->valueint;
+    } else if (!port) {
+        g_Dbs.port = DEFAULT_PORT;
+    }
+
+    cJSON *user = cJSON_GetObjectItem(root, "user");
+    if (user && user->type == cJSON_String && user->valuestring != NULL) {
+        tstrncpy(g_Dbs.user, user->valuestring, MAX_USERNAME_SIZE);
+    } else if (!user) {
+        tstrncpy(g_Dbs.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
+    }
+
+    cJSON *password = cJSON_GetObjectItem(root, "password");
+    if (password && password->type == cJSON_String &&
+        password->valuestring != NULL) {
+        tstrncpy(g_Dbs.password, password->valuestring, SHELL_MAX_PASSWORD_LEN);
+    } else if (!password) {
+        tstrncpy(g_Dbs.password, TSDB_DEFAULT_PASS, SHELL_MAX_PASSWORD_LEN);
+    }
+
+    cJSON *resultfile = cJSON_GetObjectItem(root, "result_file");
+    if (resultfile && resultfile->type == cJSON_String &&
+        resultfile->valuestring != NULL) {
+        tstrncpy(g_Dbs.resultFile, resultfile->valuestring, MAX_FILE_NAME_LEN);
+    } else if (!resultfile) {
+        tstrncpy(g_Dbs.resultFile, DEFAULT_OUTPUT, MAX_FILE_NAME_LEN);
+    }
+
+    cJSON *threads = cJSON_GetObjectItem(root, "thread_count");
+    if (threads && threads->type == cJSON_Number) {
+        g_Dbs.threadCount = threads->valueint;
+    } else if (!threads) {
+        g_Dbs.threadCount = DEFAULT_NTHREADS;
+    } else {
+        errorPrint("%s", "failed to read json, threads not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *threads2 = cJSON_GetObjectItem(root, "thread_count_create_tbl");
+    if (threads2 && threads2->type == cJSON_Number) {
+        g_Dbs.threadCountForCreateTbl = threads2->valueint;
+    } else if (!threads2) {
+        g_Dbs.threadCountForCreateTbl = DEFAULT_NTHREADS;
+    } else {
+        errorPrint("%s", "failed to read json, threads2 not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *gInsertInterval = cJSON_GetObjectItem(root, "insert_interval");
+    if (gInsertInterval && gInsertInterval->type == cJSON_Number) {
+        if (gInsertInterval->valueint < 0) {
+            errorPrint("%s",
+                       "failed to read json, insert interval input mistake\n");
+            goto PARSE_OVER;
+        }
+        g_args.insert_interval = gInsertInterval->valueint;
+    } else if (!gInsertInterval) {
+        g_args.insert_interval = DEFAULT_INSERT_INTERVAL;
+    } else {
+        errorPrint("%s",
+                   "failed to read json, insert_interval input mistake\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *interlaceRows = cJSON_GetObjectItem(root, "interlace_rows");
+    if (interlaceRows && interlaceRows->type == cJSON_Number) {
+        if (interlaceRows->valueint < 0) {
+            errorPrint("%s",
+                       "failed to read json, interlaceRows input mistake\n");
+            goto PARSE_OVER;
+        }
+        g_args.interlaceRows = interlaceRows->valueint;
+    } else if (!interlaceRows) {
+        g_args.interlaceRows =
+            DEFAULT_INTERLACE_ROWS;  // 0 means progressive mode, > 0 mean
+                                     // interlace mode. max value is less or equ
+                                     // num_of_records_per_req
+    } else {
+        errorPrint("%s", "failed to read json, interlaceRows input mistake\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *maxSqlLen = cJSON_GetObjectItem(root, "max_sql_len");
+    if (maxSqlLen && maxSqlLen->type == cJSON_Number) {
+        if (maxSqlLen->valueint < 0) {
+            errorPrint(
+                "%s() LN%d, failed to read json, max_sql_len input mistake\n",
+                __func__, __LINE__);
+            goto PARSE_OVER;
+        }
+        g_args.max_sql_len = maxSqlLen->valueint;
+    } else if (!maxSqlLen) {
+        g_args.max_sql_len = TSDB_MAX_ALLOWED_SQL_LEN;
+    } else {
+        errorPrint(
+            "%s() LN%d, failed to read json, max_sql_len input mistake\n",
+            __func__, __LINE__);
+        goto PARSE_OVER;
+    }
+
+    cJSON *numRecPerReq = cJSON_GetObjectItem(root, "num_of_records_per_req");
+    if (numRecPerReq && numRecPerReq->type == cJSON_Number) {
+        if (numRecPerReq->valueint <= 0) {
+            errorPrint(
+                "%s() LN%d, failed to read json, num_of_records_per_req input "
+                "mistake\n",
+                __func__, __LINE__);
+            goto PARSE_OVER;
+        } else if (numRecPerReq->valueint > MAX_RECORDS_PER_REQ) {
+            printf("NOTICE: number of records per request value %" PRIu64
+                   " > %d\n\n",
+                   numRecPerReq->valueint, MAX_RECORDS_PER_REQ);
+            printf(
+                "        number of records per request value will be set to "
+                "%d\n\n",
+                MAX_RECORDS_PER_REQ);
+            prompt();
+            numRecPerReq->valueint = MAX_RECORDS_PER_REQ;
+        }
+        g_args.reqPerReq = numRecPerReq->valueint;
+    } else if (!numRecPerReq) {
+        g_args.reqPerReq = MAX_RECORDS_PER_REQ;
+    } else {
+        errorPrint(
+            "%s() LN%d, failed to read json, num_of_records_per_req not "
+            "found\n",
+            __func__, __LINE__);
+        goto PARSE_OVER;
+    }
+
+    cJSON *prepareRand = cJSON_GetObjectItem(root, "prepared_rand");
+    if (prepareRand && prepareRand->type == cJSON_Number) {
+        if (prepareRand->valueint <= 0) {
+            errorPrint(
+                "%s() LN%d, failed to read json, prepared_rand input mistake\n",
+                __func__, __LINE__);
+            goto PARSE_OVER;
+        }
+        g_args.prepared_rand = prepareRand->valueint;
+    } else if (!prepareRand) {
+        g_args.prepared_rand = DEFAULT_PREPARED_RAND;
+    } else {
+        errorPrint("%s() LN%d, failed to read json, prepared_rand not found\n",
+                   __func__, __LINE__);
+        goto PARSE_OVER;
+    }
+
+    cJSON *answerPrompt =
+        cJSON_GetObjectItem(root, "confirm_parameter_prompt");  // yes, no,
+    if (answerPrompt && answerPrompt->type == cJSON_String &&
+        answerPrompt->valuestring != NULL) {
+        if (0 == strncasecmp(answerPrompt->valuestring, "yes", 3)) {
+            g_args.answer_yes = false;
+        } else if (0 == strncasecmp(answerPrompt->valuestring, "no", 2)) {
+            g_args.answer_yes = true;
+        } else {
+            g_args.answer_yes = DEFAULT_ANS_YES;
+        }
+    } else if (!answerPrompt) {
+        g_args.answer_yes = true;  // default is no, mean answer_yes.
+    } else {
+        errorPrint(
+            "%s",
+            "failed to read json, confirm_parameter_prompt input mistake\n");
+        goto PARSE_OVER;
+    }
+
+    // rows per table need be less than insert batch
+    if (g_args.interlaceRows > g_args.reqPerReq) {
+        printf(
+            "NOTICE: interlace rows value %u > num_of_records_per_req %u\n\n",
+            g_args.interlaceRows, g_args.reqPerReq);
+        printf(
+            "        interlace rows value will be set to "
+            "num_of_records_per_req %u\n\n",
+            g_args.reqPerReq);
+        prompt();
+        g_args.interlaceRows = g_args.reqPerReq;
+    }
+
+    cJSON *dbs = cJSON_GetObjectItem(root, "databases");
+    if (!dbs || dbs->type != cJSON_Array) {
+        errorPrint("%s", "failed to read json, databases not found\n");
+        goto PARSE_OVER;
+    }
+
+    int dbSize = cJSON_GetArraySize(dbs);
+    if (dbSize > MAX_DB_COUNT) {
+        errorPrint(
+            "failed to read json, databases size overflow, max database is "
+            "%d\n",
+            MAX_DB_COUNT);
+        goto PARSE_OVER;
+    }
+    g_Dbs.db = calloc(1, sizeof(SDataBase) * dbSize);
+    assert(g_Dbs.db);
+    g_Dbs.dbCount = dbSize;
+    for (int i = 0; i < dbSize; ++i) {
+        cJSON *dbinfos = cJSON_GetArrayItem(dbs, i);
+        if (dbinfos == NULL) continue;
+
+        // dbinfo
+        cJSON *dbinfo = cJSON_GetObjectItem(dbinfos, "dbinfo");
+        if (!dbinfo || dbinfo->type != cJSON_Object) {
+            errorPrint("%s", "failed to read json, dbinfo not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *dbName = cJSON_GetObjectItem(dbinfo, "name");
+        if (!dbName || dbName->type != cJSON_String ||
+            dbName->valuestring == NULL) {
+            errorPrint("%s", "failed to read json, db name not found\n");
+            goto PARSE_OVER;
+        }
+        tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, TSDB_DB_NAME_LEN);
+
+        cJSON *drop = cJSON_GetObjectItem(dbinfo, "drop");
+        if (drop && drop->type == cJSON_String && drop->valuestring != NULL) {
+            if (0 == strncasecmp(drop->valuestring, "yes", strlen("yes"))) {
+                g_Dbs.db[i].drop = true;
+            } else {
+                g_Dbs.db[i].drop = false;
+            }
+        } else if (!drop) {
+            g_Dbs.db[i].drop = g_args.drop_database;
+        } else {
+            errorPrint("%s", "failed to read json, drop input mistake\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *precision = cJSON_GetObjectItem(dbinfo, "precision");
+        if (precision && precision->type == cJSON_String &&
+            precision->valuestring != NULL) {
+            tstrncpy(g_Dbs.db[i].dbCfg.precision, precision->valuestring,
+                     SMALL_BUFF_LEN);
+        } else if (!precision) {
+            memset(g_Dbs.db[i].dbCfg.precision, 0, SMALL_BUFF_LEN);
+        } else {
+            errorPrint("%s", "failed to read json, precision not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *update = cJSON_GetObjectItem(dbinfo, "update");
+        if (update && update->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.update = update->valueint;
+        } else if (!update) {
+            g_Dbs.db[i].dbCfg.update = -1;
+        } else {
+            errorPrint("%s", "failed to read json, update not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *replica = cJSON_GetObjectItem(dbinfo, "replica");
+        if (replica && replica->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.replica = replica->valueint;
+        } else if (!replica) {
+            g_Dbs.db[i].dbCfg.replica = -1;
+        } else {
+            errorPrint("%s", "failed to read json, replica not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *keep = cJSON_GetObjectItem(dbinfo, "keep");
+        if (keep && keep->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.keep = keep->valueint;
+        } else if (!keep) {
+            g_Dbs.db[i].dbCfg.keep = -1;
+        } else {
+            errorPrint("%s", "failed to read json, keep not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *days = cJSON_GetObjectItem(dbinfo, "days");
+        if (days && days->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.days = days->valueint;
+        } else if (!days) {
+            g_Dbs.db[i].dbCfg.days = -1;
+        } else {
+            errorPrint("%s", "failed to read json, days not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *cache = cJSON_GetObjectItem(dbinfo, "cache");
+        if (cache && cache->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.cache = cache->valueint;
+        } else if (!cache) {
+            g_Dbs.db[i].dbCfg.cache = -1;
+        } else {
+            errorPrint("%s", "failed to read json, cache not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *blocks = cJSON_GetObjectItem(dbinfo, "blocks");
+        if (blocks && blocks->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.blocks = blocks->valueint;
+        } else if (!blocks) {
+            g_Dbs.db[i].dbCfg.blocks = -1;
+        } else {
+            errorPrint("%s", "failed to read json, block not found\n");
+            goto PARSE_OVER;
+        }
+
+        // cJSON* maxtablesPerVnode= cJSON_GetObjectItem(dbinfo,
+        // "maxtablesPerVnode"); if (maxtablesPerVnode &&
+        // maxtablesPerVnode->type
+        // == cJSON_Number) {
+        //  g_Dbs.db[i].dbCfg.maxtablesPerVnode = maxtablesPerVnode->valueint;
+        //} else if (!maxtablesPerVnode) {
+        //  g_Dbs.db[i].dbCfg.maxtablesPerVnode = TSDB_DEFAULT_TABLES;
+        //} else {
+        // printf("failed to read json, maxtablesPerVnode not found");
+        // goto PARSE_OVER;
+        //}
+
+        cJSON *minRows = cJSON_GetObjectItem(dbinfo, "minRows");
+        if (minRows && minRows->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.minRows = minRows->valueint;
+        } else if (!minRows) {
+            g_Dbs.db[i].dbCfg.minRows = 0;  // 0 means default
+        } else {
+            errorPrint("%s", "failed to read json, minRows not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *maxRows = cJSON_GetObjectItem(dbinfo, "maxRows");
+        if (maxRows && maxRows->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.maxRows = maxRows->valueint;
+        } else if (!maxRows) {
+            g_Dbs.db[i].dbCfg.maxRows = 0;  // 0 means default
+        } else {
+            errorPrint("%s", "failed to read json, maxRows not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *comp = cJSON_GetObjectItem(dbinfo, "comp");
+        if (comp && comp->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.comp = comp->valueint;
+        } else if (!comp) {
+            g_Dbs.db[i].dbCfg.comp = -1;
+        } else {
+            errorPrint("%s", "failed to read json, comp not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *walLevel = cJSON_GetObjectItem(dbinfo, "walLevel");
+        if (walLevel && walLevel->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.walLevel = walLevel->valueint;
+        } else if (!walLevel) {
+            g_Dbs.db[i].dbCfg.walLevel = -1;
+        } else {
+            errorPrint("%s", "failed to read json, walLevel not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *cacheLast = cJSON_GetObjectItem(dbinfo, "cachelast");
+        if (cacheLast && cacheLast->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.cacheLast = cacheLast->valueint;
+        } else if (!cacheLast) {
+            g_Dbs.db[i].dbCfg.cacheLast = -1;
+        } else {
+            errorPrint("%s", "failed to read json, cacheLast not found\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *quorum = cJSON_GetObjectItem(dbinfo, "quorum");
+        if (quorum && quorum->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.quorum = quorum->valueint;
+        } else if (!quorum) {
+            g_Dbs.db[i].dbCfg.quorum = 1;
+        } else {
+            printf("failed to read json, quorum input mistake");
+            goto PARSE_OVER;
+        }
+
+        cJSON *fsync = cJSON_GetObjectItem(dbinfo, "fsync");
+        if (fsync && fsync->type == cJSON_Number) {
+            g_Dbs.db[i].dbCfg.fsync = fsync->valueint;
+        } else if (!fsync) {
+            g_Dbs.db[i].dbCfg.fsync = -1;
+        } else {
+            errorPrint("%s", "failed to read json, fsync input mistake\n");
+            goto PARSE_OVER;
+        }
+
+        // super_tables
+        cJSON *stables = cJSON_GetObjectItem(dbinfos, "super_tables");
+        if (!stables || stables->type != cJSON_Array) {
+            errorPrint("%s", "failed to read json, super_tables not found\n");
+            goto PARSE_OVER;
+        }
+
+        int stbSize = cJSON_GetArraySize(stables);
+        if (stbSize > MAX_SUPER_TABLE_COUNT) {
+            errorPrint(
+                "failed to read json, supertable size overflow, max supertable "
+                "is %d\n",
+                MAX_SUPER_TABLE_COUNT);
+            goto PARSE_OVER;
+        }
+        g_Dbs.db[i].superTbls = calloc(1, stbSize * sizeof(SSuperTable));
+        assert(g_Dbs.db[i].superTbls);
+        g_Dbs.db[i].superTblCount = stbSize;
+        for (int j = 0; j < stbSize; ++j) {
+            cJSON *stbInfo = cJSON_GetArrayItem(stables, j);
+            if (stbInfo == NULL) continue;
+
+            // dbinfo
+            cJSON *stbName = cJSON_GetObjectItem(stbInfo, "name");
+            if (!stbName || stbName->type != cJSON_String ||
+                stbName->valuestring == NULL) {
+                errorPrint("%s", "failed to read json, stb name not found\n");
+                goto PARSE_OVER;
+            }
+            tstrncpy(g_Dbs.db[i].superTbls[j].stbName, stbName->valuestring,
+                     TSDB_TABLE_NAME_LEN);
+
+            cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
+            if (!prefix || prefix->type != cJSON_String ||
+                prefix->valuestring == NULL) {
+                errorPrint(
+                    "%s", "failed to read json, childtable_prefix not found\n");
+                goto PARSE_OVER;
+            }
+            tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix,
+                     prefix->valuestring, TBNAME_PREFIX_LEN);
+
+            cJSON *escapeChar =
+                cJSON_GetObjectItem(stbInfo, "escape_character");
+            if (escapeChar && escapeChar->type == cJSON_String &&
+                escapeChar->valuestring != NULL) {
+                if ((0 == strncasecmp(escapeChar->valuestring, "yes", 3))) {
+                    g_Dbs.db[i].superTbls[j].escapeChar = true;
+                } else if (0 == strncasecmp(escapeChar->valuestring, "no", 2)) {
+                    g_Dbs.db[i].superTbls[j].escapeChar = false;
+                } else {
+                    g_Dbs.db[i].superTbls[j].escapeChar = false;
+                }
+            } else if (!escapeChar) {
+                g_Dbs.db[i].superTbls[j].escapeChar = false;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, escape_character not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *autoCreateTbl =
+                cJSON_GetObjectItem(stbInfo, "auto_create_table");
+            if (autoCreateTbl && autoCreateTbl->type == cJSON_String &&
+                autoCreateTbl->valuestring != NULL) {
+                if ((0 == strncasecmp(autoCreateTbl->valuestring, "yes", 3)) &&
+                    (TBL_ALREADY_EXISTS !=
+                     g_Dbs.db[i].superTbls[j].childTblExists)) {
+                    g_Dbs.db[i].superTbls[j].autoCreateTable =
+                        AUTO_CREATE_SUBTBL;
+                } else if (0 ==
+                           strncasecmp(autoCreateTbl->valuestring, "no", 2)) {
+                    g_Dbs.db[i].superTbls[j].autoCreateTable =
+                        PRE_CREATE_SUBTBL;
+                } else {
+                    g_Dbs.db[i].superTbls[j].autoCreateTable =
+                        PRE_CREATE_SUBTBL;
+                }
+            } else if (!autoCreateTbl) {
+                g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+            } else {
+                errorPrint(
+                    "%s", "failed to read json, auto_create_table not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *batchCreateTbl =
+                cJSON_GetObjectItem(stbInfo, "batch_create_tbl_num");
+            if (batchCreateTbl && batchCreateTbl->type == cJSON_Number) {
+                g_Dbs.db[i].superTbls[j].batchCreateTableNum =
+                    batchCreateTbl->valueint;
+            } else if (!batchCreateTbl) {
+                g_Dbs.db[i].superTbls[j].batchCreateTableNum =
+                    DEFAULT_CREATE_BATCH;
+            } else {
+                errorPrint(
+                    "%s",
+                    "failed to read json, batch_create_tbl_num not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *childTblExists =
+                cJSON_GetObjectItem(stbInfo, "child_table_exists");  // yes, no
+            if (childTblExists && childTblExists->type == cJSON_String &&
+                childTblExists->valuestring != NULL) {
+                if ((0 == strncasecmp(childTblExists->valuestring, "yes", 3)) &&
+                    (g_Dbs.db[i].drop == false)) {
+                    g_Dbs.db[i].superTbls[j].childTblExists =
+                        TBL_ALREADY_EXISTS;
+                } else if ((0 == strncasecmp(childTblExists->valuestring, "no",
+                                             2) ||
+                            (g_Dbs.db[i].drop == true))) {
+                    g_Dbs.db[i].superTbls[j].childTblExists = TBL_NO_EXISTS;
+                } else {
+                    g_Dbs.db[i].superTbls[j].childTblExists = TBL_NO_EXISTS;
+                }
+            } else if (!childTblExists) {
+                g_Dbs.db[i].superTbls[j].childTblExists = TBL_NO_EXISTS;
+            } else {
+                errorPrint(
+                    "%s",
+                    "failed to read json, child_table_exists not found\n");
+                goto PARSE_OVER;
+            }
+
+            if (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+            }
+
+            cJSON *count = cJSON_GetObjectItem(stbInfo, "childtable_count");
+            if (!count || count->type != cJSON_Number || 0 >= count->valueint) {
+                errorPrint(
+                    "%s",
+                    "failed to read json, childtable_count input mistake\n");
+                goto PARSE_OVER;
+            }
+            g_Dbs.db[i].superTbls[j].childTblCount = count->valueint;
+            g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
+
+            cJSON *dataSource = cJSON_GetObjectItem(stbInfo, "data_source");
+            if (dataSource && dataSource->type == cJSON_String &&
+                dataSource->valuestring != NULL) {
+                tstrncpy(
+                    g_Dbs.db[i].superTbls[j].dataSource,
+                    dataSource->valuestring,
+                    min(SMALL_BUFF_LEN, strlen(dataSource->valuestring) + 1));
+            } else if (!dataSource) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand",
+                         min(SMALL_BUFF_LEN, strlen("rand") + 1));
+            } else {
+                errorPrint("%s",
+                           "failed to read json, data_source not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *stbIface = cJSON_GetObjectItem(
+                stbInfo, "insert_mode");  // taosc , rest, stmt
+            if (stbIface && stbIface->type == cJSON_String &&
+                stbIface->valuestring != NULL) {
+                if (0 == strcasecmp(stbIface->valuestring, "taosc")) {
+                    g_Dbs.db[i].superTbls[j].iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp(stbIface->valuestring, "rest")) {
+                    g_Dbs.db[i].superTbls[j].iface = REST_IFACE;
+                } else if (0 == strcasecmp(stbIface->valuestring, "stmt")) {
+                    g_Dbs.db[i].superTbls[j].iface = STMT_IFACE;
+                } else if (0 == strcasecmp(stbIface->valuestring, "sml")) {
+                    g_Dbs.db[i].superTbls[j].iface = SML_IFACE;
+                    g_args.iface = SML_IFACE;
+                } else {
+                    errorPrint(
+                        "failed to read json, insert_mode %s not recognized\n",
+                        stbIface->valuestring);
+                    goto PARSE_OVER;
+                }
+            } else if (!stbIface) {
+                g_Dbs.db[i].superTbls[j].iface = TAOSC_IFACE;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, insert_mode not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *childTbl_limit =
+                cJSON_GetObjectItem(stbInfo, "childtable_limit");
+            if ((childTbl_limit) && (g_Dbs.db[i].drop != true) &&
+                (g_Dbs.db[i].superTbls[j].childTblExists ==
+                 TBL_ALREADY_EXISTS)) {
+                if (childTbl_limit->type != cJSON_Number) {
+                    errorPrint("%s", "failed to read json, childtable_limit\n");
+                    goto PARSE_OVER;
+                }
+                g_Dbs.db[i].superTbls[j].childTblLimit =
+                    childTbl_limit->valueint;
+            } else {
+                g_Dbs.db[i].superTbls[j].childTblLimit =
+                    -1;  // select ... limit -1 means all query result, drop =
+                         // yes mean all table need recreate, limit value is
+                         // invalid.
+            }
+
+            cJSON *childTbl_offset =
+                cJSON_GetObjectItem(stbInfo, "childtable_offset");
+            if ((childTbl_offset) && (g_Dbs.db[i].drop != true) &&
+                (g_Dbs.db[i].superTbls[j].childTblExists ==
+                 TBL_ALREADY_EXISTS)) {
+                if ((childTbl_offset->type != cJSON_Number) ||
+                    (0 > childTbl_offset->valueint)) {
+                    errorPrint("%s",
+                               "failed to read json, childtable_offset\n");
+                    goto PARSE_OVER;
+                }
+                g_Dbs.db[i].superTbls[j].childTblOffset =
+                    childTbl_offset->valueint;
+            } else {
+                g_Dbs.db[i].superTbls[j].childTblOffset = 0;
+            }
+
+            cJSON *ts = cJSON_GetObjectItem(stbInfo, "start_timestamp");
+            if (ts && ts->type == cJSON_String && ts->valuestring != NULL) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
+                         ts->valuestring, TSDB_DB_NAME_LEN);
+            } else if (!ts) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp, "now",
+                         TSDB_DB_NAME_LEN);
+            } else {
+                errorPrint("%s",
+                           "failed to read json, start_timestamp not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *timestampStep =
+                cJSON_GetObjectItem(stbInfo, "timestamp_step");
+            if (timestampStep && timestampStep->type == cJSON_Number) {
+                g_Dbs.db[i].superTbls[j].timeStampStep =
+                    timestampStep->valueint;
+            } else if (!timestampStep) {
+                g_Dbs.db[i].superTbls[j].timeStampStep = g_args.timestamp_step;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, timestamp_step not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *sampleFormat = cJSON_GetObjectItem(stbInfo, "sample_format");
+            if (sampleFormat && sampleFormat->type == cJSON_String &&
+                sampleFormat->valuestring != NULL) {
+                tstrncpy(
+                    g_Dbs.db[i].superTbls[j].sampleFormat,
+                    sampleFormat->valuestring,
+                    min(SMALL_BUFF_LEN, strlen(sampleFormat->valuestring) + 1));
+            } else if (!sampleFormat) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv",
+                         SMALL_BUFF_LEN);
+            } else {
+                errorPrint("%s",
+                           "failed to read json, sample_format not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *sampleFile = cJSON_GetObjectItem(stbInfo, "sample_file");
+            if (sampleFile && sampleFile->type == cJSON_String &&
+                sampleFile->valuestring != NULL) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].sampleFile,
+                         sampleFile->valuestring,
+                         min(MAX_FILE_NAME_LEN,
+                             strlen(sampleFile->valuestring) + 1));
+            } else if (!sampleFile) {
+                memset(g_Dbs.db[i].superTbls[j].sampleFile, 0,
+                       MAX_FILE_NAME_LEN);
+            } else {
+                errorPrint("%s",
+                           "failed to read json, sample_file not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *useSampleTs = cJSON_GetObjectItem(stbInfo, "use_sample_ts");
+            if (useSampleTs && useSampleTs->type == cJSON_String &&
+                useSampleTs->valuestring != NULL) {
+                if (0 == strncasecmp(useSampleTs->valuestring, "yes", 3)) {
+                    g_Dbs.db[i].superTbls[j].useSampleTs = true;
+                } else if (0 ==
+                           strncasecmp(useSampleTs->valuestring, "no", 2)) {
+                    g_Dbs.db[i].superTbls[j].useSampleTs = false;
+                } else {
+                    g_Dbs.db[i].superTbls[j].useSampleTs = false;
+                }
+            } else if (!useSampleTs) {
+                g_Dbs.db[i].superTbls[j].useSampleTs = false;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, use_sample_ts not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *tagsFile = cJSON_GetObjectItem(stbInfo, "tags_file");
+            if ((tagsFile && tagsFile->type == cJSON_String) &&
+                (tagsFile->valuestring != NULL)) {
+                tstrncpy(g_Dbs.db[i].superTbls[j].tagsFile,
+                         tagsFile->valuestring, MAX_FILE_NAME_LEN);
+                if (0 == g_Dbs.db[i].superTbls[j].tagsFile[0]) {
+                    g_Dbs.db[i].superTbls[j].tagSource = 0;
+                } else {
+                    g_Dbs.db[i].superTbls[j].tagSource = 1;
+                }
+            } else if (!tagsFile) {
+                memset(g_Dbs.db[i].superTbls[j].tagsFile, 0, MAX_FILE_NAME_LEN);
+                g_Dbs.db[i].superTbls[j].tagSource = 0;
+            } else {
+                errorPrint("%s", "failed to read json, tags_file not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *stbMaxSqlLen = cJSON_GetObjectItem(stbInfo, "max_sql_len");
+            if (stbMaxSqlLen && stbMaxSqlLen->type == cJSON_Number) {
+                int32_t len = stbMaxSqlLen->valueint;
+                if (len > TSDB_MAX_ALLOWED_SQL_LEN) {
+                    len = TSDB_MAX_ALLOWED_SQL_LEN;
+                } else if (len < 5) {
+                    len = 5;
+                }
+                g_Dbs.db[i].superTbls[j].maxSqlLen = len;
+            } else if (!maxSqlLen) {
+                g_Dbs.db[i].superTbls[j].maxSqlLen = g_args.max_sql_len;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, stbMaxSqlLen input mistake\n");
+                goto PARSE_OVER;
+            }
+            /*
+               cJSON *multiThreadWriteOneTbl =
+               cJSON_GetObjectItem(stbInfo, "multi_thread_write_one_tbl"); // no
+               , yes if (multiThreadWriteOneTbl
+               && multiThreadWriteOneTbl->type == cJSON_String
+               && multiThreadWriteOneTbl->valuestring != NULL) {
+               if (0 == strncasecmp(multiThreadWriteOneTbl->valuestring, "yes",
+               3)) { g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 1; } else
+               { g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 0;
+               }
+               } else if (!multiThreadWriteOneTbl) {
+               g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 0;
+               } else {
+               errorPrint("%s", "failed to read json, multiThreadWriteOneTbl not
+               found\n"); goto PARSE_OVER;
+               }
+               */
+            cJSON *insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
+            if (insertRows && insertRows->type == cJSON_Number) {
+                if (insertRows->valueint < 0) {
+                    errorPrint(
+                        "%s",
+                        "failed to read json, insert_rows input mistake\n");
+                    goto PARSE_OVER;
+                }
+                g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
+            } else if (!insertRows) {
+                g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, insert_rows input mistake\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *stbInterlaceRows =
+                cJSON_GetObjectItem(stbInfo, "interlace_rows");
+            if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
+                if (stbInterlaceRows->valueint < 0) {
+                    errorPrint(
+                        "%s",
+                        "failed to read json, interlace rows input mistake\n");
+                    goto PARSE_OVER;
+                }
+                g_Dbs.db[i].superTbls[j].interlaceRows =
+                    stbInterlaceRows->valueint;
+
+                if (g_Dbs.db[i].superTbls[j].interlaceRows >
+                    g_Dbs.db[i].superTbls[j].insertRows) {
+                    printf(
+                        "NOTICE: db[%d].superTbl[%d]'s interlace rows value %u "
+                        "> insert_rows %" PRId64 "\n\n",
+                        i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
+                        g_Dbs.db[i].superTbls[j].insertRows);
+                    printf(
+                        "        interlace rows value will be set to "
+                        "insert_rows %" PRId64 "\n\n",
+                        g_Dbs.db[i].superTbls[j].insertRows);
+                    prompt();
+                    g_Dbs.db[i].superTbls[j].interlaceRows =
+                        g_Dbs.db[i].superTbls[j].insertRows;
+                }
+            } else if (!stbInterlaceRows) {
+                g_Dbs.db[i].superTbls[j].interlaceRows =
+                    g_args.interlaceRows;  // 0 means progressive mode, > 0 mean
+                                           // interlace mode. max value is less
+                                           // or equ num_of_records_per_req
+            } else {
+                errorPrint(
+                    "%s",
+                    "failed to read json, interlace rows input mistake\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *disorderRatio =
+                cJSON_GetObjectItem(stbInfo, "disorder_ratio");
+            if (disorderRatio && disorderRatio->type == cJSON_Number) {
+                if (disorderRatio->valueint > 50) disorderRatio->valueint = 50;
+
+                if (disorderRatio->valueint < 0) disorderRatio->valueint = 0;
+
+                g_Dbs.db[i].superTbls[j].disorderRatio =
+                    disorderRatio->valueint;
+            } else if (!disorderRatio) {
+                g_Dbs.db[i].superTbls[j].disorderRatio = 0;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, disorderRatio not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *disorderRange =
+                cJSON_GetObjectItem(stbInfo, "disorder_range");
+            if (disorderRange && disorderRange->type == cJSON_Number) {
+                g_Dbs.db[i].superTbls[j].disorderRange =
+                    disorderRange->valueint;
+            } else if (!disorderRange) {
+                g_Dbs.db[i].superTbls[j].disorderRange = DEFAULT_DISORDER_RANGE;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, disorderRange not found\n");
+                goto PARSE_OVER;
+            }
+
+            cJSON *insertInterval =
+                cJSON_GetObjectItem(stbInfo, "insert_interval");
+            if (insertInterval && insertInterval->type == cJSON_Number) {
+                g_Dbs.db[i].superTbls[j].insertInterval =
+                    insertInterval->valueint;
+                if (insertInterval->valueint < 0) {
+                    errorPrint(
+                        "%s",
+                        "failed to read json, insert_interval input mistake\n");
+                    goto PARSE_OVER;
+                }
+            } else if (!insertInterval) {
+                verbosePrint(
+                    "%s() LN%d: stable insert interval be overrode by global "
+                    "%" PRIu64 ".\n",
+                    __func__, __LINE__, g_args.insert_interval);
+                g_Dbs.db[i].superTbls[j].insertInterval =
+                    g_args.insert_interval;
+            } else {
+                errorPrint(
+                    "%s",
+                    "failed to read json, insert_interval input mistake\n");
+                goto PARSE_OVER;
+            }
+
+            int retVal = getColumnAndTagTypeFromInsertJsonFile(
+                stbInfo, &g_Dbs.db[i].superTbls[j]);
+            if (false == retVal) {
+                goto PARSE_OVER;
+            }
+        }
+    }
+
+    code = 0;
+
+PARSE_OVER:
+    return code;
+}
+int getMetaFromQueryJsonFile(cJSON *root) {
+    int32_t code = -1;
+
+    cJSON *cfgdir = cJSON_GetObjectItem(root, "cfgdir");
+    if (cfgdir && cfgdir->type == cJSON_String && cfgdir->valuestring != NULL) {
+        tstrncpy(g_queryInfo.cfgDir, cfgdir->valuestring, MAX_FILE_NAME_LEN);
+    }
+
+    cJSON *host = cJSON_GetObjectItem(root, "host");
+    if (host && host->type == cJSON_String && host->valuestring != NULL) {
+        tstrncpy(g_queryInfo.host, host->valuestring, MAX_HOSTNAME_SIZE);
+    } else if (!host) {
+        tstrncpy(g_queryInfo.host, DEFAULT_HOST, MAX_HOSTNAME_SIZE);
+    } else {
+        errorPrint("%s", "failed to read json, host not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *port = cJSON_GetObjectItem(root, "port");
+    if (port && port->type == cJSON_Number) {
+        g_queryInfo.port = port->valueint;
+    } else if (!port) {
+        g_queryInfo.port = DEFAULT_PORT;
+    }
+
+    cJSON *user = cJSON_GetObjectItem(root, "user");
+    if (user && user->type == cJSON_String && user->valuestring != NULL) {
+        tstrncpy(g_queryInfo.user, user->valuestring, MAX_USERNAME_SIZE);
+    } else if (!user) {
+        tstrncpy(g_queryInfo.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
+        ;
+    }
+
+    cJSON *password = cJSON_GetObjectItem(root, "password");
+    if (password && password->type == cJSON_String &&
+        password->valuestring != NULL) {
+        tstrncpy(g_queryInfo.password, password->valuestring,
+                 SHELL_MAX_PASSWORD_LEN);
+    } else if (!password) {
+        tstrncpy(g_queryInfo.password, TSDB_DEFAULT_PASS,
+                 SHELL_MAX_PASSWORD_LEN);
+        ;
+    }
+
+    cJSON *answerPrompt =
+        cJSON_GetObjectItem(root, "confirm_parameter_prompt");  // yes, no,
+    if (answerPrompt && answerPrompt->type == cJSON_String &&
+        answerPrompt->valuestring != NULL) {
+        if (0 == strncasecmp(answerPrompt->valuestring, "yes", 3)) {
+            g_args.answer_yes = false;
+        } else if (0 == strncasecmp(answerPrompt->valuestring, "no", 2)) {
+            g_args.answer_yes = true;
+        } else {
+            g_args.answer_yes = false;
+        }
+    } else if (!answerPrompt) {
+        g_args.answer_yes = false;
+    } else {
+        errorPrint("%s",
+                   "failed to read json, confirm_parameter_prompt not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *gQueryTimes = cJSON_GetObjectItem(root, "query_times");
+    if (gQueryTimes && gQueryTimes->type == cJSON_Number) {
+        if (gQueryTimes->valueint <= 0) {
+            errorPrint("%s()",
+                       "failed to read json, query_times input mistake\n");
+            goto PARSE_OVER;
+        }
+        g_args.query_times = gQueryTimes->valueint;
+    } else if (!gQueryTimes) {
+        g_args.query_times = DEFAULT_QUERY_TIME;
+    } else {
+        errorPrint("%s", "failed to read json, query_times input mistake\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *dbs = cJSON_GetObjectItem(root, "databases");
+    if (dbs && dbs->type == cJSON_String && dbs->valuestring != NULL) {
+        tstrncpy(g_queryInfo.dbName, dbs->valuestring, TSDB_DB_NAME_LEN);
+    } else if (!dbs) {
+        errorPrint("%s", "failed to read json, databases not found\n");
+        goto PARSE_OVER;
+    }
+
+    cJSON *queryMode = cJSON_GetObjectItem(root, "query_mode");
+    if (queryMode && queryMode->type == cJSON_String &&
+        queryMode->valuestring != NULL) {
+        tstrncpy(g_queryInfo.queryMode, queryMode->valuestring,
+                 min(SMALL_BUFF_LEN, strlen(queryMode->valuestring) + 1));
+    } else if (!queryMode) {
+        tstrncpy(g_queryInfo.queryMode, "taosc",
+                 min(SMALL_BUFF_LEN, strlen("taosc") + 1));
+    } else {
+        errorPrint("%s", "failed to read json, query_mode not found\n");
+        goto PARSE_OVER;
+    }
+
+    // specified_table_query
+    cJSON *specifiedQuery = cJSON_GetObjectItem(root, "specified_table_query");
+    if (!specifiedQuery) {
+        g_queryInfo.specifiedQueryInfo.concurrent = 1;
+        g_queryInfo.specifiedQueryInfo.sqlCount = 0;
+    } else if (specifiedQuery->type != cJSON_Object) {
+        errorPrint("%s", "failed to read json, super_table_query not found\n");
+        goto PARSE_OVER;
+    } else {
+        cJSON *queryInterval =
+            cJSON_GetObjectItem(specifiedQuery, "query_interval");
+        if (queryInterval && queryInterval->type == cJSON_Number) {
+            g_queryInfo.specifiedQueryInfo.queryInterval =
+                queryInterval->valueint;
+        } else if (!queryInterval) {
+            g_queryInfo.specifiedQueryInfo.queryInterval = 0;
+        }
+
+        cJSON *specifiedQueryTimes =
+            cJSON_GetObjectItem(specifiedQuery, "query_times");
+        if (specifiedQueryTimes && specifiedQueryTimes->type == cJSON_Number) {
+            if (specifiedQueryTimes->valueint <= 0) {
+                errorPrint("failed to read json, query_times: %" PRId64
+                           ", need be a valid (>0) number\n",
+                           specifiedQueryTimes->valueint);
+                goto PARSE_OVER;
+            }
+            g_queryInfo.specifiedQueryInfo.queryTimes =
+                specifiedQueryTimes->valueint;
+        } else if (!specifiedQueryTimes) {
+            g_queryInfo.specifiedQueryInfo.queryTimes = g_args.query_times;
+        } else {
+            errorPrint(
+                "%s() LN%d, failed to read json, query_times input mistake\n",
+                __func__, __LINE__);
+            goto PARSE_OVER;
+        }
+
+        cJSON *concurrent = cJSON_GetObjectItem(specifiedQuery, "concurrent");
+        if (concurrent && concurrent->type == cJSON_Number) {
+            if (concurrent->valueint <= 0) {
+                errorPrint(
+                    "query sqlCount %d or concurrent %d is not correct.\n",
+                    g_queryInfo.specifiedQueryInfo.sqlCount,
+                    g_queryInfo.specifiedQueryInfo.concurrent);
+                goto PARSE_OVER;
+            }
+            g_queryInfo.specifiedQueryInfo.concurrent = concurrent->valueint;
+        } else if (!concurrent) {
+            g_queryInfo.specifiedQueryInfo.concurrent = 1;
+        }
+
+        cJSON *specifiedAsyncMode = cJSON_GetObjectItem(specifiedQuery, "mode");
+        if (specifiedAsyncMode && specifiedAsyncMode->type == cJSON_String &&
+            specifiedAsyncMode->valuestring != NULL) {
+            if (0 == strcmp("sync", specifiedAsyncMode->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.asyncMode = SYNC_MODE;
+            } else if (0 == strcmp("async", specifiedAsyncMode->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.asyncMode = ASYNC_MODE;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, async mode input error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.specifiedQueryInfo.asyncMode = SYNC_MODE;
+        }
+
+        cJSON *interval = cJSON_GetObjectItem(specifiedQuery, "interval");
+        if (interval && interval->type == cJSON_Number) {
+            g_queryInfo.specifiedQueryInfo.subscribeInterval =
+                interval->valueint;
+        } else if (!interval) {
+            // printf("failed to read json, subscribe interval no found\n");
+            // goto PARSE_OVER;
+            g_queryInfo.specifiedQueryInfo.subscribeInterval =
+                DEFAULT_SUB_INTERVAL;
+        }
+
+        cJSON *restart = cJSON_GetObjectItem(specifiedQuery, "restart");
+        if (restart && restart->type == cJSON_String &&
+            restart->valuestring != NULL) {
+            if (0 == strcmp("yes", restart->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.subscribeRestart = true;
+            } else if (0 == strcmp("no", restart->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.subscribeRestart = false;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, subscribe restart error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.specifiedQueryInfo.subscribeRestart = true;
+        }
+
+        cJSON *keepProgress =
+            cJSON_GetObjectItem(specifiedQuery, "keepProgress");
+        if (keepProgress && keepProgress->type == cJSON_String &&
+            keepProgress->valuestring != NULL) {
+            if (0 == strcmp("yes", keepProgress->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 1;
+            } else if (0 == strcmp("no", keepProgress->valuestring)) {
+                g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
+            } else {
+                errorPrint(
+                    "%s",
+                    "failed to read json, subscribe keepProgress error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
+        }
+
+        // sqls
+        cJSON *specifiedSqls = cJSON_GetObjectItem(specifiedQuery, "sqls");
+        if (!specifiedSqls) {
+            g_queryInfo.specifiedQueryInfo.sqlCount = 0;
+        } else if (specifiedSqls->type != cJSON_Array) {
+            errorPrint("%s", "failed to read json, super sqls not found\n");
+            goto PARSE_OVER;
+        } else {
+            int superSqlSize = cJSON_GetArraySize(specifiedSqls);
+            if (superSqlSize * g_queryInfo.specifiedQueryInfo.concurrent >
+                MAX_QUERY_SQL_COUNT) {
+                errorPrint(
+                    "failed to read json, query sql(%d) * concurrent(%d) "
+                    "overflow, max is %d\n",
+                    superSqlSize, g_queryInfo.specifiedQueryInfo.concurrent,
+                    MAX_QUERY_SQL_COUNT);
+                goto PARSE_OVER;
+            }
+
+            g_queryInfo.specifiedQueryInfo.sqlCount = superSqlSize;
+            for (int j = 0; j < superSqlSize; ++j) {
+                cJSON *sql = cJSON_GetArrayItem(specifiedSqls, j);
+                if (sql == NULL) continue;
+
+                cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
+                if (!sqlStr || sqlStr->type != cJSON_String ||
+                    sqlStr->valuestring == NULL) {
+                    errorPrint("%s", "failed to read json, sql not found\n");
+                    goto PARSE_OVER;
+                }
+                tstrncpy(g_queryInfo.specifiedQueryInfo.sql[j],
+                         sqlStr->valuestring, BUFFER_SIZE);
+
+                // default value is -1, which mean infinite loop
+                g_queryInfo.specifiedQueryInfo.endAfterConsume[j] = -1;
+                cJSON *endAfterConsume =
+                    cJSON_GetObjectItem(specifiedQuery, "endAfterConsume");
+                if (endAfterConsume && endAfterConsume->type == cJSON_Number) {
+                    g_queryInfo.specifiedQueryInfo.endAfterConsume[j] =
+                        endAfterConsume->valueint;
+                }
+                if (g_queryInfo.specifiedQueryInfo.endAfterConsume[j] < -1)
+                    g_queryInfo.specifiedQueryInfo.endAfterConsume[j] = -1;
+
+                g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] = -1;
+                cJSON *resubAfterConsume =
+                    cJSON_GetObjectItem(specifiedQuery, "resubAfterConsume");
+                if ((resubAfterConsume) &&
+                    (resubAfterConsume->type == cJSON_Number) &&
+                    (resubAfterConsume->valueint >= 0)) {
+                    g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] =
+                        resubAfterConsume->valueint;
+                }
+
+                if (g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] < -1)
+                    g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] = -1;
+
+                cJSON *result = cJSON_GetObjectItem(sql, "result");
+                if ((NULL != result) && (result->type == cJSON_String) &&
+                    (result->valuestring != NULL)) {
+                    tstrncpy(g_queryInfo.specifiedQueryInfo.result[j],
+                             result->valuestring, MAX_FILE_NAME_LEN);
+                } else if (NULL == result) {
+                    memset(g_queryInfo.specifiedQueryInfo.result[j], 0,
+                           MAX_FILE_NAME_LEN);
+                } else {
+                    errorPrint("%s",
+                               "failed to read json, super query result file "
+                               "not found\n");
+                    goto PARSE_OVER;
+                }
+            }
+        }
+    }
+
+    // super_table_query
+    cJSON *superQuery = cJSON_GetObjectItem(root, "super_table_query");
+    if (!superQuery) {
+        g_queryInfo.superQueryInfo.threadCnt = 1;
+        g_queryInfo.superQueryInfo.sqlCount = 0;
+    } else if (superQuery->type != cJSON_Object) {
+        errorPrint("%s", "failed to read json, sub_table_query not found\n");
+        code = 0;
+        goto PARSE_OVER;
+    } else {
+        cJSON *subrate = cJSON_GetObjectItem(superQuery, "query_interval");
+        if (subrate && subrate->type == cJSON_Number) {
+            g_queryInfo.superQueryInfo.queryInterval = subrate->valueint;
+        } else if (!subrate) {
+            g_queryInfo.superQueryInfo.queryInterval = 0;
+        }
+
+        cJSON *superQueryTimes = cJSON_GetObjectItem(superQuery, "query_times");
+        if (superQueryTimes && superQueryTimes->type == cJSON_Number) {
+            if (superQueryTimes->valueint <= 0) {
+                errorPrint("failed to read json, query_times: %" PRId64
+                           ", need be a valid (>0) number\n",
+                           superQueryTimes->valueint);
+                goto PARSE_OVER;
+            }
+            g_queryInfo.superQueryInfo.queryTimes = superQueryTimes->valueint;
+        } else if (!superQueryTimes) {
+            g_queryInfo.superQueryInfo.queryTimes = g_args.query_times;
+        } else {
+            errorPrint("%s",
+                       "failed to read json, query_times input mistake\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *threads = cJSON_GetObjectItem(superQuery, "threads");
+        if (threads && threads->type == cJSON_Number) {
+            if (threads->valueint <= 0) {
+                errorPrint("%s",
+                           "failed to read json, threads input mistake\n");
+                goto PARSE_OVER;
+            }
+            g_queryInfo.superQueryInfo.threadCnt = threads->valueint;
+        } else if (!threads) {
+            g_queryInfo.superQueryInfo.threadCnt = DEFAULT_NTHREADS;
+        }
+
+        // cJSON* subTblCnt = cJSON_GetObjectItem(superQuery,
+        // "childtable_count"); if (subTblCnt && subTblCnt->type ==
+        // cJSON_Number)
+        // {
+        //  g_queryInfo.superQueryInfo.childTblCount = subTblCnt->valueint;
+        //} else if (!subTblCnt) {
+        //  g_queryInfo.superQueryInfo.childTblCount = 0;
+        //}
+
+        cJSON *stblname = cJSON_GetObjectItem(superQuery, "stblname");
+        if (stblname && stblname->type == cJSON_String &&
+            stblname->valuestring != NULL) {
+            tstrncpy(g_queryInfo.superQueryInfo.stbName, stblname->valuestring,
+                     TSDB_TABLE_NAME_LEN);
+        } else {
+            errorPrint("%s",
+                       "failed to read json, super table name input error\n");
+            goto PARSE_OVER;
+        }
+
+        cJSON *superAsyncMode = cJSON_GetObjectItem(superQuery, "mode");
+        if (superAsyncMode && superAsyncMode->type == cJSON_String &&
+            superAsyncMode->valuestring != NULL) {
+            if (0 == strcmp("sync", superAsyncMode->valuestring)) {
+                g_queryInfo.superQueryInfo.asyncMode = SYNC_MODE;
+            } else if (0 == strcmp("async", superAsyncMode->valuestring)) {
+                g_queryInfo.superQueryInfo.asyncMode = ASYNC_MODE;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, async mode input error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.superQueryInfo.asyncMode = SYNC_MODE;
+        }
+
+        cJSON *superInterval = cJSON_GetObjectItem(superQuery, "interval");
+        if (superInterval && superInterval->type == cJSON_Number) {
+            if (superInterval->valueint < 0) {
+                errorPrint("%s",
+                           "failed to read json, interval input mistake\n");
+                goto PARSE_OVER;
+            }
+            g_queryInfo.superQueryInfo.subscribeInterval =
+                superInterval->valueint;
+        } else if (!superInterval) {
+            // printf("failed to read json, subscribe interval no found\n");
+            // goto PARSE_OVER;
+            g_queryInfo.superQueryInfo.subscribeInterval =
+                DEFAULT_QUERY_INTERVAL;
+        }
+
+        cJSON *subrestart = cJSON_GetObjectItem(superQuery, "restart");
+        if (subrestart && subrestart->type == cJSON_String &&
+            subrestart->valuestring != NULL) {
+            if (0 == strcmp("yes", subrestart->valuestring)) {
+                g_queryInfo.superQueryInfo.subscribeRestart = true;
+            } else if (0 == strcmp("no", subrestart->valuestring)) {
+                g_queryInfo.superQueryInfo.subscribeRestart = false;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, subscribe restart error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.superQueryInfo.subscribeRestart = true;
+        }
+
+        cJSON *superkeepProgress =
+            cJSON_GetObjectItem(superQuery, "keepProgress");
+        if (superkeepProgress && superkeepProgress->type == cJSON_String &&
+            superkeepProgress->valuestring != NULL) {
+            if (0 == strcmp("yes", superkeepProgress->valuestring)) {
+                g_queryInfo.superQueryInfo.subscribeKeepProgress = 1;
+            } else if (0 == strcmp("no", superkeepProgress->valuestring)) {
+                g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
+            } else {
+                errorPrint("%s",
+                           "failed to read json, subscribe super table "
+                           "keepProgress error\n");
+                goto PARSE_OVER;
+            }
+        } else {
+            g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
+        }
+
+        // default value is -1, which mean do not resub
+        g_queryInfo.superQueryInfo.endAfterConsume = -1;
+        cJSON *superEndAfterConsume =
+            cJSON_GetObjectItem(superQuery, "endAfterConsume");
+        if (superEndAfterConsume &&
+            superEndAfterConsume->type == cJSON_Number) {
+            g_queryInfo.superQueryInfo.endAfterConsume =
+                superEndAfterConsume->valueint;
+        }
+        if (g_queryInfo.superQueryInfo.endAfterConsume < -1)
+            g_queryInfo.superQueryInfo.endAfterConsume = -1;
+
+        // default value is -1, which mean do not resub
+        g_queryInfo.superQueryInfo.resubAfterConsume = -1;
+        cJSON *superResubAfterConsume =
+            cJSON_GetObjectItem(superQuery, "resubAfterConsume");
+        if ((superResubAfterConsume) &&
+            (superResubAfterConsume->type == cJSON_Number) &&
+            (superResubAfterConsume->valueint >= 0)) {
+            g_queryInfo.superQueryInfo.resubAfterConsume =
+                superResubAfterConsume->valueint;
+        }
+        if (g_queryInfo.superQueryInfo.resubAfterConsume < -1)
+            g_queryInfo.superQueryInfo.resubAfterConsume = -1;
+
+        // supert table sqls
+        cJSON *superSqls = cJSON_GetObjectItem(superQuery, "sqls");
+        if (!superSqls) {
+            g_queryInfo.superQueryInfo.sqlCount = 0;
+        } else if (superSqls->type != cJSON_Array) {
+            errorPrint("%s", "failed to read json, super sqls not found\n");
+            goto PARSE_OVER;
+        } else {
+            int superSqlSize = cJSON_GetArraySize(superSqls);
+            if (superSqlSize > MAX_QUERY_SQL_COUNT) {
+                errorPrint(
+                    "failed to read json, query sql size overflow, max is %d\n",
+                    MAX_QUERY_SQL_COUNT);
+                goto PARSE_OVER;
+            }
+
+            g_queryInfo.superQueryInfo.sqlCount = superSqlSize;
+            for (int j = 0; j < superSqlSize; ++j) {
+                cJSON *sql = cJSON_GetArrayItem(superSqls, j);
+                if (sql == NULL) continue;
+
+                cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
+                if (!sqlStr || sqlStr->type != cJSON_String ||
+                    sqlStr->valuestring == NULL) {
+                    errorPrint("%s", "failed to read json, sql not found\n");
+                    goto PARSE_OVER;
+                }
+                tstrncpy(g_queryInfo.superQueryInfo.sql[j], sqlStr->valuestring,
+                         BUFFER_SIZE);
+
+                cJSON *result = cJSON_GetObjectItem(sql, "result");
+                if (result != NULL && result->type == cJSON_String &&
+                    result->valuestring != NULL) {
+                    tstrncpy(g_queryInfo.superQueryInfo.result[j],
+                             result->valuestring, MAX_FILE_NAME_LEN);
+                } else if (NULL == result) {
+                    memset(g_queryInfo.superQueryInfo.result[j], 0,
+                           MAX_FILE_NAME_LEN);
+                } else {
+                    errorPrint("%s",
+                               "failed to read json, sub query result file not "
+                               "found\n");
+                    goto PARSE_OVER;
+                }
+            }
+        }
+    }
+
+    code = 0;
+
+PARSE_OVER:
+    return code;
+}
+
+int getInfoFromJsonFile(char *file) {
+    debugPrint("%s %d %s\n", __func__, __LINE__, file);
+    int32_t code = -1;
+    FILE *  fp = fopen(file, "r");
+    if (!fp) {
+        errorPrint("failed to read %s, reason:%s\n", file, strerror(errno));
+        return code;
+    }
+
+    int   maxLen = MAX_JSON_BUFF;
+    char *content = calloc(1, maxLen + 1);
+    int   len = fread(content, 1, maxLen, fp);
+    if (len <= 0) {
+        free(content);
+        fclose(fp);
+        errorPrint("failed to read %s, content is null", file);
+        return code;
+    }
+
+    content[len] = 0;
+    cJSON *root = cJSON_Parse(content);
+    if (root == NULL) {
+        errorPrint("failed to cjson parse %s, invalid json format\n", file);
+        goto PARSE_OVER;
+    }
+
+    cJSON *filetype = cJSON_GetObjectItem(root, "filetype");
+    if (filetype && filetype->type == cJSON_String &&
+        filetype->valuestring != NULL) {
+        if (0 == strcasecmp("insert", filetype->valuestring)) {
+            g_args.test_mode = INSERT_TEST;
+        } else if (0 == strcasecmp("query", filetype->valuestring)) {
+            g_args.test_mode = QUERY_TEST;
+        } else if (0 == strcasecmp("subscribe", filetype->valuestring)) {
+            g_args.test_mode = SUBSCRIBE_TEST;
+        } else {
+            errorPrint("%s", "failed to read json, filetype not support\n");
+            goto PARSE_OVER;
+        }
+    } else if (!filetype) {
+        g_args.test_mode = INSERT_TEST;
+    } else {
+        errorPrint("%s", "failed to read json, filetype not found\n");
+        goto PARSE_OVER;
+    }
+
+    if (INSERT_TEST == g_args.test_mode) {
+        memset(&g_Dbs, 0, sizeof(SDbs));
+        g_Dbs.use_metric = g_args.use_metric;
+        code = getMetaFromInsertJsonFile(root);
+        if (code) {
+            errorPrint("%s() LN%d, getMetaFromInsertJsonFile() failed\n",
+                       __func__, __LINE__);
+            goto PARSE_OVER;
+        }
+
+    } else if ((QUERY_TEST == g_args.test_mode) ||
+               (SUBSCRIBE_TEST == g_args.test_mode)) {
+        memset(&g_queryInfo, 0, sizeof(SQueryMetaInfo));
+        code = getMetaFromQueryJsonFile(root);
+        if (code) {
+            errorPrint("%s() LN%d, getMetaFromQueryJsonFile() failed\n",
+                       __func__, __LINE__);
+            goto PARSE_OVER;
+        }
+    } else {
+        errorPrint("%s",
+                   "input json file type error! please input correct file "
+                   "type: insert or query or subscribe\n");
+        goto PARSE_OVER;
+    }
+PARSE_OVER:
+    free(content);
+    cJSON_Delete(root);
+    fclose(fp);
+    return code;
+}
+
+int testMetaFile() {
+    if (INSERT_TEST == g_args.test_mode) {
+        if (g_Dbs.cfgDir[0]) {
+            taos_options(TSDB_OPTION_CONFIGDIR, g_Dbs.cfgDir);
+        }
+        return insertTestProcess();
+
+    } else if (QUERY_TEST == g_args.test_mode) {
+        if (g_queryInfo.cfgDir[0]) {
+            taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
+        }
+        return queryTestProcess();
+
+    } else if (SUBSCRIBE_TEST == g_args.test_mode) {
+        if (g_queryInfo.cfgDir[0]) {
+            taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
+        }
+        return subscribeTestProcess();
+    } else {
+        errorPrint("%s() LN%d, unsupport test mode (%d)\n", __func__, __LINE__,
+                   g_args.test_mode);
+        return -1;
+    }
+    return 0;
+}
\ No newline at end of file

src/kit/taosdemo/src/demoMain.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+int64_t        g_totalChildTables = DEFAULT_CHILDTABLES;
+int64_t        g_actualChildTables = 0;
+FILE *         g_fpOfInsertResult = NULL;
+SDbs           g_Dbs;
+SQueryMetaInfo g_queryInfo;
+SArguments     g_args = {
+    DEFAULT_METAFILE,     // metaFile
+    DEFAULT_TEST_MODE,    // test_mode
+    DEFAULT_HOST,         // host
+    DEFAULT_PORT,         // port
+    DEFAULT_IFACE,        // iface
+    TSDB_DEFAULT_USER,    // user
+    TSDB_DEFAULT_PASS,    // password
+    DEFAULT_DATABASE,     // database
+    DEFAULT_REPLICA,      // replica
+    DEFAULT_TB_PREFIX,    // tb_prefix
+    DEFAULT_ESCAPE_CHAR,  // escapeChar
+    DEFAULT_SQLFILE,      // sqlFile
+    DEFAULT_USE_METRIC,   // use_metric
+    DEFAULT_DROP_DB,      // drop_database
+    DEFAULT_AGGR_FUNC,    // aggr_func
+    DEFAULT_DEBUG,        // debug_print
+    DEFAULT_VERBOSE,      // verbose_print
+    DEFAULT_PERF_STAT,    // performance statistic print
+    DEFAULT_ANS_YES,      // answer_yes;
+    DEFAULT_OUTPUT,       // output_file
+    DEFAULT_SYNC_MODE,    // mode : sync or async
+    DEFAULT_DATA_TYPE,    // data_type
+    DEFAULT_DATATYPE,     // dataType
+    DEFAULT_BINWIDTH,     // binwidth
+    DEFAULT_COL_COUNT,    // columnCount, timestamp + float + int + float
+    DEFAULT_LEN_ONE_ROW,  // lenOfOneRow
+    DEFAULT_NTHREADS,     // nthreads
+    DEFAULT_INSERT_INTERVAL,   // insert_interval
+    DEFAULT_TIMESTAMP_STEP,    // timestamp_step
+    DEFAULT_QUERY_TIME,        // query_times
+    DEFAULT_PREPARED_RAND,     // prepared_rand
+    DEFAULT_INTERLACE_ROWS,    // interlaceRows;
+    DEFAULT_REQ_PER_REQ,       // reqPerReq
+    TSDB_MAX_ALLOWED_SQL_LEN,  // max_sql_len
+    DEFAULT_CHILDTABLES,       // ntables
+    DEFAULT_INSERT_ROWS,       // insertRows
+    DEFAULT_ABORT,             // abort
+    DEFAULT_RATIO,             // disorderRatio
+    DEFAULT_DISORDER_RANGE,    // disorderRange
+    DEFAULT_METHOD_DEL,        // method_of_delete
+    DEFAULT_TOTAL_INSERT,      // totalInsertRows;
+    DEFAULT_TOTAL_AFFECT,      // totalAffectedRows;
+    DEFAULT_DEMO_MODE,         // demo_mode;
+};
+
+int main(int argc, char *argv[]) {
+    int32_t code = parse_args(argc, argv, &g_args);
+    if (code) {
+        errorPrint("%s() LN%d, parse_args() failed\n", __func__, __LINE__);
+        exit(EXIT_FAILURE);
+    }
+    debugPrint("meta file: %s\n", g_args.metaFile);
+
+    if (g_args.metaFile) {
+        g_totalChildTables = 0;
+
+        code = getInfoFromJsonFile(g_args.metaFile);
+        if (code) {
+            errorPrint("%s() LN%d, getInfoFromJsonFile(%s) failed\n", __func__,
+                       __LINE__, g_args.metaFile);
+            exit(EXIT_FAILURE);
+        }
+        code = testMetaFile();
+        if (code) {
+            errorPrint("%s() LN%d, testMetaFile() failed\n", __func__,
+                       __LINE__);
+            exit(EXIT_FAILURE);
+        }
+    } else {
+        memset(&g_Dbs, 0, sizeof(SDbs));
+        g_Dbs.db = calloc(1, sizeof(SDataBase));
+        assert(g_Dbs.db);
+        g_Dbs.db[0].superTbls = calloc(1, sizeof(SSuperTable));
+        assert(g_Dbs.db[0].superTbls);
+        setParaFromArg();
+
+        if (NULL != g_args.sqlFile) {
+            TAOS *qtaos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password,
+                                       g_Dbs.db[0].dbName, g_Dbs.port);
+            querySqlFile(qtaos, g_args.sqlFile);
+            taos_close(qtaos);
+
+        } else {
+            testCmdLine();
+        }
+
+        if (g_dupstr) free(g_dupstr);
+    }
+    postFreeResource();
+
+    return 0;
+}
\ No newline at end of file

src/kit/taosdemo/src/demoOutput.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+
+#define SHOW_PARSE_RESULT_START()                                           \
+    do {                                                                    \
+        if (g_args.metaFile)                                                \
+            printf(                                                         \
+                "\033[1m\033[40;32m================ %s parse result START " \
+                "================\033[0m\n",                                \
+                g_args.metaFile);                                           \
+    } while (0)
+
+#define SHOW_PARSE_RESULT_END()                                       \
+    do {                                                              \
+        if (g_args.metaFile)                                          \
+            printf(                                                   \
+                "\033[1m\033[40;32m================ %s parse result " \
+                "END================\033[0m\n",                       \
+                g_args.metaFile);                                     \
+    } while (0)
+
+#define SHOW_PARSE_RESULT_START_TO_FILE(fp)                               \
+    do {                                                                  \
+        if (g_args.metaFile)                                              \
+            fprintf(fp,                                                   \
+                    "\033[1m\033[40;32m================ %s parse result " \
+                    "START ================\033[0m\n",                    \
+                    g_args.metaFile);                                     \
+    } while (0)
+
+#define SHOW_PARSE_RESULT_END_TO_FILE(fp)                                 \
+    do {                                                                  \
+        if (g_args.metaFile)                                              \
+            fprintf(fp,                                                   \
+                    "\033[1m\033[40;32m================ %s parse result " \
+                    "END================\033[0m\n",                       \
+                    g_args.metaFile);                                     \
+    } while (0)
+
+int getDbFromServer(TAOS *taos, SDbInfo **dbInfos) {
+    TAOS_RES *res;
+    TAOS_ROW  row = NULL;
+    int       count = 0;
+
+    res = taos_query(taos, "show databases;");
+    int32_t code = taos_errno(res);
+
+    if (code != 0) {
+        errorPrint("failed to run <show databases>, reason: %s\n",
+                   taos_errstr(res));
+        return -1;
+    }
+
+    TAOS_FIELD *fields = taos_fetch_fields(res);
+
+    while ((row = taos_fetch_row(res)) != NULL) {
+        // sys database name : 'log'
+        if (strncasecmp(row[TSDB_SHOW_DB_NAME_INDEX], "log",
+                        fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0) {
+            continue;
+        }
+
+        dbInfos[count] = (SDbInfo *)calloc(1, sizeof(SDbInfo));
+        if (dbInfos[count] == NULL) {
+            errorPrint("failed to allocate memory for some dbInfo[%d]\n",
+                       count);
+            return -1;
+        }
+
+        tstrncpy(dbInfos[count]->name, (char *)row[TSDB_SHOW_DB_NAME_INDEX],
+                 fields[TSDB_SHOW_DB_NAME_INDEX].bytes);
+        formatTimestamp(dbInfos[count]->create_time,
+                        *(int64_t *)row[TSDB_SHOW_DB_CREATED_TIME_INDEX],
+                        TSDB_TIME_PRECISION_MILLI);
+        dbInfos[count]->ntables = *((int64_t *)row[TSDB_SHOW_DB_NTABLES_INDEX]);
+        dbInfos[count]->vgroups = *((int32_t *)row[TSDB_SHOW_DB_VGROUPS_INDEX]);
+        dbInfos[count]->replica = *((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]);
+        dbInfos[count]->quorum = *((int16_t *)row[TSDB_SHOW_DB_QUORUM_INDEX]);
+        dbInfos[count]->days = *((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]);
+
+        tstrncpy(dbInfos[count]->keeplist, (char *)row[TSDB_SHOW_DB_KEEP_INDEX],
+                 fields[TSDB_SHOW_DB_KEEP_INDEX].bytes);
+        dbInfos[count]->cache = *((int32_t *)row[TSDB_SHOW_DB_CACHE_INDEX]);
+        dbInfos[count]->blocks = *((int32_t *)row[TSDB_SHOW_DB_BLOCKS_INDEX]);
+        dbInfos[count]->minrows = *((int32_t *)row[TSDB_SHOW_DB_MINROWS_INDEX]);
+        dbInfos[count]->maxrows = *((int32_t *)row[TSDB_SHOW_DB_MAXROWS_INDEX]);
+        dbInfos[count]->wallevel =
+            *((int8_t *)row[TSDB_SHOW_DB_WALLEVEL_INDEX]);
+        dbInfos[count]->fsync = *((int32_t *)row[TSDB_SHOW_DB_FSYNC_INDEX]);
+        dbInfos[count]->comp =
+            (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_COMP_INDEX]));
+        dbInfos[count]->cachelast =
+            (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_CACHELAST_INDEX]));
+
+        tstrncpy(dbInfos[count]->precision,
+                 (char *)row[TSDB_SHOW_DB_PRECISION_INDEX],
+                 fields[TSDB_SHOW_DB_PRECISION_INDEX].bytes);
+        dbInfos[count]->update = *((int8_t *)row[TSDB_SHOW_DB_UPDATE_INDEX]);
+        tstrncpy(dbInfos[count]->status, (char *)row[TSDB_SHOW_DB_STATUS_INDEX],
+                 fields[TSDB_SHOW_DB_STATUS_INDEX].bytes);
+
+        count++;
+        if (count > MAX_DATABASE_COUNT) {
+            errorPrint("%s() LN%d, The database count overflow than %d\n",
+                       __func__, __LINE__, MAX_DATABASE_COUNT);
+            break;
+        }
+    }
+
+    return count;
+}
+
+void xDumpFieldToFile(FILE *fp, const char *val, TAOS_FIELD *field,
+                      int32_t length, int precision) {
+    if (val == NULL) {
+        fprintf(fp, "%s", TSDB_DATA_NULL_STR);
+        return;
+    }
+
+    char buf[TSDB_MAX_BYTES_PER_ROW];
+    switch (field->type) {
+        case TSDB_DATA_TYPE_BOOL:
+            fprintf(fp, "%d", ((((int32_t)(*((int8_t *)val))) == 1) ? 1 : 0));
+            break;
+
+        case TSDB_DATA_TYPE_TINYINT:
+            fprintf(fp, "%d", *((int8_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_UTINYINT:
+            fprintf(fp, "%d", *((uint8_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_SMALLINT:
+            fprintf(fp, "%d", *((int16_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_USMALLINT:
+            fprintf(fp, "%d", *((uint16_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_INT:
+            fprintf(fp, "%d", *((int32_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_UINT:
+            fprintf(fp, "%d", *((uint32_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_BIGINT:
+            fprintf(fp, "%" PRId64 "", *((int64_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_UBIGINT:
+            fprintf(fp, "%" PRId64 "", *((uint64_t *)val));
+            break;
+
+        case TSDB_DATA_TYPE_FLOAT:
+            fprintf(fp, "%.5f", GET_FLOAT_VAL(val));
+            break;
+
+        case TSDB_DATA_TYPE_DOUBLE:
+            fprintf(fp, "%.9f", GET_DOUBLE_VAL(val));
+            break;
+
+        case TSDB_DATA_TYPE_BINARY:
+        case TSDB_DATA_TYPE_NCHAR:
+            memcpy(buf, val, length);
+            buf[length] = 0;
+            fprintf(fp, "\'%s\'", buf);
+            break;
+
+        case TSDB_DATA_TYPE_TIMESTAMP:
+            formatTimestamp(buf, *(int64_t *)val, precision);
+            fprintf(fp, "'%s'", buf);
+            break;
+
+        default:
+            break;
+    }
+}
+
+int xDumpResultToFile(const char *fname, TAOS_RES *tres) {
+    TAOS_ROW row = taos_fetch_row(tres);
+    if (row == NULL) {
+        return 0;
+    }
+
+    FILE *fp = fopen(fname, "at");
+    if (fp == NULL) {
+        errorPrint("%s() LN%d, failed to open file: %s\n", __func__, __LINE__,
+                   fname);
+        return -1;
+    }
+
+    int         num_fields = taos_num_fields(tres);
+    TAOS_FIELD *fields = taos_fetch_fields(tres);
+    int         precision = taos_result_precision(tres);
+
+    for (int col = 0; col < num_fields; col++) {
+        if (col > 0) {
+            fprintf(fp, ",");
+        }
+        fprintf(fp, "%s", fields[col].name);
+    }
+    fputc('\n', fp);
+
+    int numOfRows = 0;
+    do {
+        int32_t *length = taos_fetch_lengths(tres);
+        for (int i = 0; i < num_fields; i++) {
+            if (i > 0) {
+                fputc(',', fp);
+            }
+            xDumpFieldToFile(fp, (const char *)row[i], fields + i, length[i],
+                             precision);
+        }
+        fputc('\n', fp);
+
+        numOfRows++;
+        row = taos_fetch_row(tres);
+    } while (row != NULL);
+
+    fclose(fp);
+
+    return numOfRows;
+}
+
+#ifndef TAOSDEMO_COMMIT_SHA1
+#define TAOSDEMO_COMMIT_SHA1 "unknown"
+#endif
+
+#ifndef TD_VERNUMBER
+#define TD_VERNUMBER "unknown"
+#endif
+
+#ifndef TAOSDEMO_STATUS
+#define TAOSDEMO_STATUS "unknown"
+#endif
+
+void printVersion() {
+    char tdengine_ver[] = TD_VERNUMBER;
+    char taosdemo_ver[] = TAOSDEMO_COMMIT_SHA1;
+    char taosdemo_status[] = TAOSDEMO_STATUS;
+
+    if (strlen(taosdemo_status) == 0) {
+        printf("taosdemo version %s-%s\n", tdengine_ver, taosdemo_ver);
+    } else {
+        printf("taosdemo version %s-%s, status:%s\n", tdengine_ver,
+               taosdemo_ver, taosdemo_status);
+    }
+}
+
+void printHelp() {
+    char indent[10] = "  ";
+    printf("%s\n\n", "Usage: taosdemo [OPTION...]");
+    printf("%s%s%s%s\n", indent, "-f, --file=FILE", "\t\t",
+           "The meta file to the execution procedure.");
+    printf("%s%s%s%s\n", indent, "-u, --user=USER", "\t\t",
+           "The user name to use when connecting to the server.");
+#ifdef _TD_POWER_
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+           "The password to use when connecting to the server. By default is "
+           "'powerdb'");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+           "Configuration directory. By default is '/etc/power/'.");
+#elif (_TD_TQ_ == true)
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+           "The password to use when connecting to the server. By default is "
+           "'tqueue'");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+           "Configuration directory. By default is '/etc/tq/'.");
+#elif (_TD_PRO_ == true)
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+           "The password to use when connecting to the server. By default is "
+           "'prodb'");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+           "Configuration directory. By default is '/etc/ProDB/'.");
+#else
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+           "The password to use when connecting to the server.");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+           "Configuration directory.");
+#endif
+    printf("%s%s%s%s\n", indent, "-h, --host=HOST", "\t\t",
+           "TDengine server FQDN to connect. The default host is localhost.");
+    printf("%s%s%s%s\n", indent, "-P, --port=PORT", "\t\t",
+           "The TCP/IP port number to use for the connection.");
+    printf("%s%s%s%s\n", indent, "-I, --interface=INTERFACE", "\t",
+           "The interface (taosc, rest, and stmt) taosdemo uses. By default "
+           "use 'taosc'.");
+    printf("%s%s%s%s\n", indent, "-d, --database=DATABASE", "\t",
+           "Destination database. By default is 'test'.");
+    printf("%s%s%s%s\n", indent, "-a, --replica=REPLICA", "\t\t",
+           "Set the replica parameters of the database, By default use 1, min: "
+           "1, max: 3.");
+    printf("%s%s%s%s\n", indent, "-m, --table-prefix=TABLEPREFIX", "\t",
+           "Table prefix name. By default use 'd'.");
+    printf("%s%s%s%s\n", indent, "-E, --escape-character", "\t",
+           "Use escape character for Both Stable and normmal table name");
+    printf("%s%s%s%s\n", indent, "-s, --sql-file=FILE", "\t\t",
+           "The select sql file.");
+    printf("%s%s%s%s\n", indent, "-N, --normal-table", "\t\t",
+           "Use normal table flag.");
+    printf("%s%s%s%s\n", indent, "-o, --output=FILE", "\t\t",
+           "Direct output to the named file. By default use './output.txt'.");
+    printf("%s%s%s%s\n", indent, "-q, --query-mode=MODE", "\t\t",
+           "Query mode -- 0: SYNC, 1: ASYNC. By default use SYNC.");
+    printf("%s%s%s%s\n", indent, "-b, --data-type=DATATYPE", "\t",
+           "The data_type of columns, By default use: FLOAT,INT,FLOAT. NCHAR "
+           "and BINARY can also use custom length. Eg: NCHAR(16),BINARY(8)");
+    printf("%s%s%s%s%d\n", indent, "-w, --binwidth=WIDTH", "\t\t",
+           "The width of data_type 'BINARY' or 'NCHAR'. By default use ",
+           g_args.binwidth);
+    printf("%s%s%s%s%d%s%d\n", indent, "-l, --columns=COLUMNS", "\t\t",
+           "The number of columns per record. Demo mode by default is ",
+           DEFAULT_DATATYPE_NUM, " (float, int, float). Max values is ",
+           MAX_NUM_COLUMNS);
+    printf("%s%s%s%s\n", indent, indent, indent,
+           "\t\t\t\tAll of the new column(s) type is INT. If use -b to specify "
+           "column type, -l will be ignored.");
+    printf("%s%s%s%s%d.\n", indent, "-T, --threads=NUMBER", "\t\t",
+           "The number of threads. By default use ", DEFAULT_NTHREADS);
+    printf("%s%s%s%s\n", indent, "-i, --insert-interval=NUMBER", "\t",
+           "The sleep time (ms) between insertion. By default is 0.");
+    printf("%s%s%s%s%d.\n", indent, "-S, --time-step=TIME_STEP", "\t",
+           "The timestamp step between insertion. By default is ",
+           DEFAULT_TIMESTAMP_STEP);
+    printf("%s%s%s%s%d.\n", indent, "-B, --interlace-rows=NUMBER", "\t",
+           "The interlace rows of insertion. By default is ",
+           DEFAULT_INTERLACE_ROWS);
+    printf("%s%s%s%s\n", indent, "-r, --rec-per-req=NUMBER", "\t",
+           "The number of records per request. By default is 30000.");
+    printf("%s%s%s%s\n", indent, "-t, --tables=NUMBER", "\t\t",
+           "The number of tables. By default is 10000.");
+    printf("%s%s%s%s\n", indent, "-n, --records=NUMBER", "\t\t",
+           "The number of records per table. By default is 10000.");
+    printf("%s%s%s%s\n", indent, "-M, --random", "\t\t\t",
+           "The value of records generated are totally random.");
+    printf("%s\n", "\t\t\t\tBy default to simulate power equipment scenario.");
+    printf("%s%s%s%s\n", indent, "-x, --aggr-func", "\t\t",
+           "Test aggregation functions after insertion.");
+    printf("%s%s%s%s\n", indent, "-y, --answer-yes", "\t\t",
+           "Input yes for prompt.");
+    printf("%s%s%s%s\n", indent, "-O, --disorder=NUMBER", "\t\t",
+           "Insert order mode--0: In order, 1 ~ 50: disorder ratio. By default "
+           "is in order.");
+    printf("%s%s%s%s\n", indent, "-R, --disorder-range=NUMBER", "\t",
+           "Out of order data's range. Unit is ms. By default is 1000.");
+    printf("%s%s%s%s\n", indent, "-g, --debug", "\t\t\t", "Print debug info.");
+    printf("%s%s%s%s\n", indent, "-?, --help\t", "\t\t", "Give this help list");
+    printf("%s%s%s%s\n", indent, "    --usage\t", "\t\t",
+           "Give a short usage message");
+    printf("%s%s\n", indent, "-V, --version\t\t\tPrint program version.");
+    /*    printf("%s%s%s%s\n", indent, "-D", indent,
+          "Delete database if exists. 0: no, 1: yes, default is 1");
+          */
+    printf(
+        "\nMandatory or optional arguments to long options are also mandatory or optional\n\
+for any corresponding short options.\n\
+\n\
+Report bugs to <support@taosdata.com>.\n");
+}
+
+int printfInsertMeta() {
+    setupForAnsiEscape();
+    SHOW_PARSE_RESULT_START();
+
+    if (g_args.demo_mode) {
+        printf(
+            "\ntaosdemo is simulating data generated by power equipment "
+            "monitoring...\n\n");
+    } else {
+        printf("\ntaosdemo is simulating random data as you request..\n\n");
+    }
+
+    if (g_args.iface != INTERFACE_BUT) {
+        // first time if no iface specified
+        printf("interface:                  \033[33m%s\033[0m\n",
+               (g_args.iface == TAOSC_IFACE)  ? "taosc"
+               : (g_args.iface == REST_IFACE) ? "rest"
+               : (g_args.iface == STMT_IFACE) ? "stmt"
+                                              : "sml");
+    }
+
+    printf("host:                       \033[33m%s:%u\033[0m\n", g_Dbs.host,
+           g_Dbs.port);
+    printf("user:                       \033[33m%s\033[0m\n", g_Dbs.user);
+    printf("password:                   \033[33m%s\033[0m\n", g_Dbs.password);
+    printf("configDir:                  \033[33m%s\033[0m\n", configDir);
+    printf("resultFile:                 \033[33m%s\033[0m\n", g_Dbs.resultFile);
+    printf("thread num of insert data:  \033[33m%d\033[0m\n",
+           g_Dbs.threadCount);
+    printf("thread num of create table: \033[33m%d\033[0m\n",
+           g_Dbs.threadCountForCreateTbl);
+    printf("top insert interval:        \033[33m%" PRIu64 "\033[0m\n",
+           g_args.insert_interval);
+    printf("number of records per req:  \033[33m%u\033[0m\n", g_args.reqPerReq);
+    printf("max sql length:             \033[33m%" PRIu64 "\033[0m\n",
+           g_args.max_sql_len);
+
+    printf("database count:             \033[33m%d\033[0m\n", g_Dbs.dbCount);
+
+    for (int i = 0; i < g_Dbs.dbCount; i++) {
+        printf("database[\033[33m%d\033[0m]:\n", i);
+        printf("  database[%d] name:      \033[33m%s\033[0m\n", i,
+               g_Dbs.db[i].dbName);
+        if (0 == g_Dbs.db[i].drop) {
+            printf("  drop:                  \033[33m no\033[0m\n");
+        } else {
+            printf("  drop:                  \033[33m yes\033[0m\n");
+        }
+
+        if (g_Dbs.db[i].dbCfg.blocks > 0) {
+            printf("  blocks:                \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.blocks);
+        }
+        if (g_Dbs.db[i].dbCfg.cache > 0) {
+            printf("  cache:                 \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.cache);
+        }
+        if (g_Dbs.db[i].dbCfg.days > 0) {
+            printf("  days:                  \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.days);
+        }
+        if (g_Dbs.db[i].dbCfg.keep > 0) {
+            printf("  keep:                  \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.keep);
+        }
+        if (g_Dbs.db[i].dbCfg.replica > 0) {
+            printf("  replica:               \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.replica);
+        }
+        if (g_Dbs.db[i].dbCfg.update > 0) {
+            printf("  update:                \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.update);
+        }
+        if (g_Dbs.db[i].dbCfg.minRows > 0) {
+            printf("  minRows:               \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.minRows);
+        }
+        if (g_Dbs.db[i].dbCfg.maxRows > 0) {
+            printf("  maxRows:               \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.maxRows);
+        }
+        if (g_Dbs.db[i].dbCfg.comp > 0) {
+            printf("  comp:                  \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.comp);
+        }
+        if (g_Dbs.db[i].dbCfg.walLevel > 0) {
+            printf("  walLevel:              \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.walLevel);
+        }
+        if (g_Dbs.db[i].dbCfg.fsync > 0) {
+            printf("  fsync:                 \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.fsync);
+        }
+        if (g_Dbs.db[i].dbCfg.quorum > 0) {
+            printf("  quorum:                \033[33m%d\033[0m\n",
+                   g_Dbs.db[i].dbCfg.quorum);
+        }
+        if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
+            if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2)) ||
+                (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2)) ||
+                (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2))) {
+                printf("  precision:             \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].dbCfg.precision);
+            } else {
+                printf("\033[1m\033[40;31m  precision error:       %s\033[0m\n",
+                       g_Dbs.db[i].dbCfg.precision);
+                return -1;
+            }
+        }
+
+        if (g_args.use_metric) {
+            printf("  super table count:     \033[33m%" PRIu64 "\033[0m\n",
+                   g_Dbs.db[i].superTblCount);
+            for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
+                printf("  super table[\033[33m%" PRIu64 "\033[0m]:\n", j);
+
+                printf("      stbName:           \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].stbName);
+
+                if (PRE_CREATE_SUBTBL ==
+                    g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                    printf("      autoCreateTable:   \033[33m%s\033[0m\n",
+                           "no");
+                } else if (AUTO_CREATE_SUBTBL ==
+                           g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                    printf("      autoCreateTable:   \033[33m%s\033[0m\n",
+                           "yes");
+                } else {
+                    printf("      autoCreateTable:   \033[33m%s\033[0m\n",
+                           "error");
+                }
+
+                if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                    printf("      childTblExists:    \033[33m%s\033[0m\n",
+                           "no");
+                } else if (TBL_ALREADY_EXISTS ==
+                           g_Dbs.db[i].superTbls[j].childTblExists) {
+                    printf("      childTblExists:    \033[33m%s\033[0m\n",
+                           "yes");
+                } else {
+                    printf("      childTblExists:    \033[33m%s\033[0m\n",
+                           "error");
+                }
+
+                printf("      childTblCount:     \033[33m%" PRId64 "\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].childTblCount);
+                printf("      childTblPrefix:    \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].childTblPrefix);
+                printf("      dataSource:        \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].dataSource);
+                printf("      iface:             \033[33m%s\033[0m\n",
+                       (g_Dbs.db[i].superTbls[j].iface == TAOSC_IFACE) ? "taosc"
+                       : (g_Dbs.db[i].superTbls[j].iface == REST_IFACE) ? "rest"
+                       : (g_Dbs.db[i].superTbls[j].iface == STMT_IFACE)
+                           ? "stmt"
+                           : "sml");
+                if (g_Dbs.db[i].superTbls[j].childTblLimit > 0) {
+                    printf("      childTblLimit:     \033[33m%" PRId64
+                           "\033[0m\n",
+                           g_Dbs.db[i].superTbls[j].childTblLimit);
+                }
+                if (g_Dbs.db[i].superTbls[j].childTblOffset > 0) {
+                    printf("      childTblOffset:    \033[33m%" PRIu64
+                           "\033[0m\n",
+                           g_Dbs.db[i].superTbls[j].childTblOffset);
+                }
+                printf("      insertRows:        \033[33m%" PRId64 "\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].insertRows);
+                /*
+                if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
+                printf("      multiThreadWriteOneTbl:  \033[33m no\033[0m\n");
+                }else {
+                printf("      multiThreadWriteOneTbl:  \033[33m yes\033[0m\n");
+                }
+                */
+                printf("      interlaceRows:     \033[33m%u\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].interlaceRows);
+
+                if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
+                    printf("      stable insert interval:   \033[33m%" PRIu64
+                           "\033[0m\n",
+                           g_Dbs.db[i].superTbls[j].insertInterval);
+                }
+
+                printf("      disorderRange:     \033[33m%d\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].disorderRange);
+                printf("      disorderRatio:     \033[33m%d\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].disorderRatio);
+                printf("      maxSqlLen:         \033[33m%" PRIu64 "\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].maxSqlLen);
+                printf("      timeStampStep:     \033[33m%" PRId64 "\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].timeStampStep);
+                printf("      startTimestamp:    \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].startTimestamp);
+                printf("      sampleFormat:      \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].sampleFormat);
+                printf("      sampleFile:        \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].sampleFile);
+                printf("      useSampleTs:       \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].useSampleTs
+                           ? "yes (warning: disorderRange/disorderRatio is "
+                             "disabled)"
+                           : "no");
+                printf("      tagsFile:          \033[33m%s\033[0m\n",
+                       g_Dbs.db[i].superTbls[j].tagsFile);
+                printf("      columnCount:       \033[33m%d\033[0m\n        ",
+                       g_Dbs.db[i].superTbls[j].columnCount);
+                for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
+                    // printf("dataType:%s, dataLen:%d\t",
+                    // g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                    // g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                    if ((0 == strncasecmp(
+                                  g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                  "binary", 6)) ||
+                        (0 == strncasecmp(
+                                  g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                  "nchar", 5))) {
+                        printf("column[%d]:\033[33m%s(%d)\033[0m ", k,
+                               g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                               g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                    } else {
+                        printf("column[%d]:\033[33m%s\033[0m ", k,
+                               g_Dbs.db[i].superTbls[j].columns[k].dataType);
+                    }
+                }
+                printf("\n");
+
+                printf("      tagCount:            \033[33m%d\033[0m\n        ",
+                       g_Dbs.db[i].superTbls[j].tagCount);
+                for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
+                    // printf("dataType:%s, dataLen:%d\t",
+                    // g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                    // g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                    if ((0 ==
+                         strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                     "binary", strlen("binary"))) ||
+                        (0 ==
+                         strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                     "nchar", strlen("nchar")))) {
+                        printf("tag[%d]:\033[33m%s(%d)\033[0m ", k,
+                               g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                               g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                    } else {
+                        printf("tag[%d]:\033[33m%s\033[0m ", k,
+                               g_Dbs.db[i].superTbls[j].tags[k].dataType);
+                    }
+                }
+                printf("\n");
+            }
+        } else {
+            printf("  childTblCount:     \033[33m%" PRId64 "\033[0m\n",
+                   g_args.ntables);
+            printf("  insertRows:        \033[33m%" PRId64 "\033[0m\n",
+                   g_args.insertRows);
+        }
+        printf("\n");
+    }
+
+    SHOW_PARSE_RESULT_END();
+    resetAfterAnsiEscape();
+    return 0;
+}
+
+void printfInsertMetaToFile(FILE *fp) {
+    SHOW_PARSE_RESULT_START_TO_FILE(fp);
+
+    fprintf(fp, "host:                       %s:%u\n", g_Dbs.host, g_Dbs.port);
+    fprintf(fp, "user:                       %s\n", g_Dbs.user);
+    fprintf(fp, "configDir:                  %s\n", configDir);
+    fprintf(fp, "resultFile:                 %s\n", g_Dbs.resultFile);
+    fprintf(fp, "thread num of insert data:  %d\n", g_Dbs.threadCount);
+    fprintf(fp, "thread num of create table: %d\n",
+            g_Dbs.threadCountForCreateTbl);
+    fprintf(fp, "number of records per req:  %u\n", g_args.reqPerReq);
+    fprintf(fp, "max sql length:             %" PRIu64 "\n",
+            g_args.max_sql_len);
+    fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
+
+    for (int i = 0; i < g_Dbs.dbCount; i++) {
+        fprintf(fp, "database[%d]:\n", i);
+        fprintf(fp, "  database[%d] name:       %s\n", i, g_Dbs.db[i].dbName);
+        if (0 == g_Dbs.db[i].drop) {
+            fprintf(fp, "  drop:                  no\n");
+        } else {
+            fprintf(fp, "  drop:                  yes\n");
+        }
+
+        if (g_Dbs.db[i].dbCfg.blocks > 0) {
+            fprintf(fp, "  blocks:                %d\n",
+                    g_Dbs.db[i].dbCfg.blocks);
+        }
+        if (g_Dbs.db[i].dbCfg.cache > 0) {
+            fprintf(fp, "  cache:                 %d\n",
+                    g_Dbs.db[i].dbCfg.cache);
+        }
+        if (g_Dbs.db[i].dbCfg.days > 0) {
+            fprintf(fp, "  days:                  %d\n",
+                    g_Dbs.db[i].dbCfg.days);
+        }
+        if (g_Dbs.db[i].dbCfg.keep > 0) {
+            fprintf(fp, "  keep:                  %d\n",
+                    g_Dbs.db[i].dbCfg.keep);
+        }
+        if (g_Dbs.db[i].dbCfg.replica > 0) {
+            fprintf(fp, "  replica:               %d\n",
+                    g_Dbs.db[i].dbCfg.replica);
+        }
+        if (g_Dbs.db[i].dbCfg.update > 0) {
+            fprintf(fp, "  update:                %d\n",
+                    g_Dbs.db[i].dbCfg.update);
+        }
+        if (g_Dbs.db[i].dbCfg.minRows > 0) {
+            fprintf(fp, "  minRows:               %d\n",
+                    g_Dbs.db[i].dbCfg.minRows);
+        }
+        if (g_Dbs.db[i].dbCfg.maxRows > 0) {
+            fprintf(fp, "  maxRows:               %d\n",
+                    g_Dbs.db[i].dbCfg.maxRows);
+        }
+        if (g_Dbs.db[i].dbCfg.comp > 0) {
+            fprintf(fp, "  comp:                  %d\n",
+                    g_Dbs.db[i].dbCfg.comp);
+        }
+        if (g_Dbs.db[i].dbCfg.walLevel > 0) {
+            fprintf(fp, "  walLevel:              %d\n",
+                    g_Dbs.db[i].dbCfg.walLevel);
+        }
+        if (g_Dbs.db[i].dbCfg.fsync > 0) {
+            fprintf(fp, "  fsync:                 %d\n",
+                    g_Dbs.db[i].dbCfg.fsync);
+        }
+        if (g_Dbs.db[i].dbCfg.quorum > 0) {
+            fprintf(fp, "  quorum:                %d\n",
+                    g_Dbs.db[i].dbCfg.quorum);
+        }
+        if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
+            if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2)) ||
+                (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2)) ||
+                (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
+                fprintf(fp, "  precision:             %s\n",
+                        g_Dbs.db[i].dbCfg.precision);
+            } else {
+                fprintf(fp, "  precision error:       %s\n",
+                        g_Dbs.db[i].dbCfg.precision);
+            }
+        }
+
+        fprintf(fp, "  super table count:     %" PRIu64 "\n",
+                g_Dbs.db[i].superTblCount);
+        for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
+            fprintf(fp, "  super table[%d]:\n", j);
+
+            fprintf(fp, "      stbName:           %s\n",
+                    g_Dbs.db[i].superTbls[j].stbName);
+
+            if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                fprintf(fp, "      autoCreateTable:   %s\n", "no");
+            } else if (AUTO_CREATE_SUBTBL ==
+                       g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                fprintf(fp, "      autoCreateTable:   %s\n", "yes");
+            } else {
+                fprintf(fp, "      autoCreateTable:   %s\n", "error");
+            }
+
+            if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                fprintf(fp, "      childTblExists:    %s\n", "no");
+            } else if (TBL_ALREADY_EXISTS ==
+                       g_Dbs.db[i].superTbls[j].childTblExists) {
+                fprintf(fp, "      childTblExists:    %s\n", "yes");
+            } else {
+                fprintf(fp, "      childTblExists:    %s\n", "error");
+            }
+
+            fprintf(fp, "      childTblCount:     %" PRId64 "\n",
+                    g_Dbs.db[i].superTbls[j].childTblCount);
+            fprintf(fp, "      childTblPrefix:    %s\n",
+                    g_Dbs.db[i].superTbls[j].childTblPrefix);
+            fprintf(fp, "      dataSource:        %s\n",
+                    g_Dbs.db[i].superTbls[j].dataSource);
+            fprintf(fp, "      iface:             %s\n",
+                    (g_Dbs.db[i].superTbls[j].iface == TAOSC_IFACE)  ? "taosc"
+                    : (g_Dbs.db[i].superTbls[j].iface == REST_IFACE) ? "rest"
+                    : (g_Dbs.db[i].superTbls[j].iface == STMT_IFACE) ? "stmt"
+                                                                     : "sml");
+            fprintf(fp, "      insertRows:        %" PRId64 "\n",
+                    g_Dbs.db[i].superTbls[j].insertRows);
+            fprintf(fp, "      interlace rows:    %u\n",
+                    g_Dbs.db[i].superTbls[j].interlaceRows);
+            if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
+                fprintf(fp, "      stable insert interval:   %" PRIu64 "\n",
+                        g_Dbs.db[i].superTbls[j].insertInterval);
+            }
+            /*
+               if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
+               fprintf(fp, "      multiThreadWriteOneTbl:  no\n");
+               }else {
+               fprintf(fp, "      multiThreadWriteOneTbl:  yes\n");
+               }
+               */
+            fprintf(fp, "      interlaceRows:     %u\n",
+                    g_Dbs.db[i].superTbls[j].interlaceRows);
+            fprintf(fp, "      disorderRange:     %d\n",
+                    g_Dbs.db[i].superTbls[j].disorderRange);
+            fprintf(fp, "      disorderRatio:     %d\n",
+                    g_Dbs.db[i].superTbls[j].disorderRatio);
+            fprintf(fp, "      maxSqlLen:         %" PRIu64 "\n",
+                    g_Dbs.db[i].superTbls[j].maxSqlLen);
+
+            fprintf(fp, "      timeStampStep:     %" PRId64 "\n",
+                    g_Dbs.db[i].superTbls[j].timeStampStep);
+            fprintf(fp, "      startTimestamp:    %s\n",
+                    g_Dbs.db[i].superTbls[j].startTimestamp);
+            fprintf(fp, "      sampleFormat:      %s\n",
+                    g_Dbs.db[i].superTbls[j].sampleFormat);
+            fprintf(fp, "      sampleFile:        %s\n",
+                    g_Dbs.db[i].superTbls[j].sampleFile);
+            fprintf(fp, "      tagsFile:          %s\n",
+                    g_Dbs.db[i].superTbls[j].tagsFile);
+
+            fprintf(fp, "      columnCount:       %d\n        ",
+                    g_Dbs.db[i].superTbls[j].columnCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
+                // printf("dataType:%s, dataLen:%d\t",
+                // g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                // g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                if ((0 ==
+                     strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                 "binary", strlen("binary"))) ||
+                    (0 ==
+                     strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                 "nchar", strlen("nchar")))) {
+                    fprintf(fp, "column[%d]:%s(%d) ", k,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                } else {
+                    fprintf(fp, "column[%d]:%s ", k,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataType);
+                }
+            }
+            fprintf(fp, "\n");
+
+            fprintf(fp, "      tagCount:            %d\n        ",
+                    g_Dbs.db[i].superTbls[j].tagCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
+                // printf("dataType:%s, dataLen:%d\t",
+                // g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                // g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                      "binary", strlen("binary"))) ||
+                    (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                      "nchar", strlen("nchar")))) {
+                    fprintf(fp, "tag[%d]:%s(%d) ", k,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                } else {
+                    fprintf(fp, "tag[%d]:%s ", k,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataType);
+                }
+            }
+            fprintf(fp, "\n");
+        }
+        fprintf(fp, "\n");
+    }
+
+    SHOW_PARSE_RESULT_END_TO_FILE(fp);
+}
+
+void printfQueryMeta() {
+    setupForAnsiEscape();
+    SHOW_PARSE_RESULT_START();
+
+    printf("host:                    \033[33m%s:%u\033[0m\n", g_queryInfo.host,
+           g_queryInfo.port);
+    printf("user:                    \033[33m%s\033[0m\n", g_queryInfo.user);
+    printf("database name:           \033[33m%s\033[0m\n", g_queryInfo.dbName);
+
+    printf("\n");
+
+    if ((SUBSCRIBE_TEST == g_args.test_mode) ||
+        (QUERY_TEST == g_args.test_mode)) {
+        printf("specified table query info:                   \n");
+        printf("sqlCount:       \033[33m%d\033[0m\n",
+               g_queryInfo.specifiedQueryInfo.sqlCount);
+        if (g_queryInfo.specifiedQueryInfo.sqlCount > 0) {
+            printf("specified tbl query times:\n");
+            printf("                \033[33m%" PRIu64 "\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.queryTimes);
+            printf("query interval: \033[33m%" PRIu64 " ms\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.queryInterval);
+            printf("top query times:\033[33m%" PRIu64 "\033[0m\n",
+                   g_args.query_times);
+            printf("concurrent:     \033[33m%d\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.concurrent);
+            printf(
+                "mod:            \033[33m%s\033[0m\n",
+                (g_queryInfo.specifiedQueryInfo.asyncMode) ? "async" : "sync");
+            printf("interval:       \033[33m%" PRIu64 "\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.subscribeInterval);
+            printf("restart:        \033[33m%d\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.subscribeRestart);
+            printf("keepProgress:   \033[33m%d\033[0m\n",
+                   g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
+
+            for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
+                printf("  sql[%d]: \033[33m%s\033[0m\n", i,
+                       g_queryInfo.specifiedQueryInfo.sql[i]);
+            }
+            printf("\n");
+        }
+
+        printf("super table query info:\n");
+        printf("sqlCount:       \033[33m%d\033[0m\n",
+               g_queryInfo.superQueryInfo.sqlCount);
+
+        if (g_queryInfo.superQueryInfo.sqlCount > 0) {
+            printf("query interval: \033[33m%" PRIu64 "\033[0m\n",
+                   g_queryInfo.superQueryInfo.queryInterval);
+            printf("threadCnt:      \033[33m%d\033[0m\n",
+                   g_queryInfo.superQueryInfo.threadCnt);
+            printf("childTblCount:  \033[33m%" PRId64 "\033[0m\n",
+                   g_queryInfo.superQueryInfo.childTblCount);
+            printf("stable name:    \033[33m%s\033[0m\n",
+                   g_queryInfo.superQueryInfo.stbName);
+            printf("stb query times:\033[33m%" PRIu64 "\033[0m\n",
+                   g_queryInfo.superQueryInfo.queryTimes);
+
+            printf("mod:            \033[33m%s\033[0m\n",
+                   (g_queryInfo.superQueryInfo.asyncMode) ? "async" : "sync");
+            printf("interval:       \033[33m%" PRIu64 "\033[0m\n",
+                   g_queryInfo.superQueryInfo.subscribeInterval);
+            printf("restart:        \033[33m%d\033[0m\n",
+                   g_queryInfo.superQueryInfo.subscribeRestart);
+            printf("keepProgress:   \033[33m%d\033[0m\n",
+                   g_queryInfo.superQueryInfo.subscribeKeepProgress);
+
+            for (int i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
+                printf("  sql[%d]: \033[33m%s\033[0m\n", i,
+                       g_queryInfo.superQueryInfo.sql[i]);
+            }
+            printf("\n");
+        }
+    }
+
+    SHOW_PARSE_RESULT_END();
+}
+
+void printfDbInfoForQueryToFile(char *filename, SDbInfo *dbInfos, int index) {
+    if (filename[0] == 0) return;
+
+    FILE *fp = fopen(filename, "at");
+    if (fp == NULL) {
+        errorPrint("failed to open file: %s\n", filename);
+        return;
+    }
+
+    fprintf(fp, "================ database[%d] ================\n", index);
+    fprintf(fp, "name: %s\n", dbInfos->name);
+    fprintf(fp, "created_time: %s\n", dbInfos->create_time);
+    fprintf(fp, "ntables: %" PRId64 "\n", dbInfos->ntables);
+    fprintf(fp, "vgroups: %d\n", dbInfos->vgroups);
+    fprintf(fp, "replica: %d\n", dbInfos->replica);
+    fprintf(fp, "quorum: %d\n", dbInfos->quorum);
+    fprintf(fp, "days: %d\n", dbInfos->days);
+    fprintf(fp, "keep0,keep1,keep(D): %s\n", dbInfos->keeplist);
+    fprintf(fp, "cache(MB): %d\n", dbInfos->cache);
+    fprintf(fp, "blocks: %d\n", dbInfos->blocks);
+    fprintf(fp, "minrows: %d\n", dbInfos->minrows);
+    fprintf(fp, "maxrows: %d\n", dbInfos->maxrows);
+    fprintf(fp, "wallevel: %d\n", dbInfos->wallevel);
+    fprintf(fp, "fsync: %d\n", dbInfos->fsync);
+    fprintf(fp, "comp: %d\n", dbInfos->comp);
+    fprintf(fp, "cachelast: %d\n", dbInfos->cachelast);
+    fprintf(fp, "precision: %s\n", dbInfos->precision);
+    fprintf(fp, "update: %d\n", dbInfos->update);
+    fprintf(fp, "status: %s\n", dbInfos->status);
+    fprintf(fp, "\n");
+
+    fclose(fp);
+}
+
+void printfQuerySystemInfo(TAOS *taos) {
+    char      filename[MAX_FILE_NAME_LEN] = {0};
+    char      buffer[SQL_BUFF_LEN] = {0};
+    TAOS_RES *res;
+
+    time_t     t;
+    struct tm *lt;
+    time(&t);
+    lt = localtime(&t);
+    snprintf(filename, MAX_FILE_NAME_LEN, "querySystemInfo-%d-%d-%d %d:%d:%d",
+             lt->tm_year + 1900, lt->tm_mon, lt->tm_mday, lt->tm_hour,
+             lt->tm_min, lt->tm_sec);
+
+    // show variables
+    res = taos_query(taos, "show variables;");
+    // fetchResult(res, filename);
+    xDumpResultToFile(filename, res);
+
+    // show dnodes
+    res = taos_query(taos, "show dnodes;");
+    xDumpResultToFile(filename, res);
+    // fetchResult(res, filename);
+
+    // show databases
+    res = taos_query(taos, "show databases;");
+    SDbInfo **dbInfos =
+        (SDbInfo **)calloc(MAX_DATABASE_COUNT, sizeof(SDbInfo *));
+    if (dbInfos == NULL) {
+        errorPrint("%s() LN%d, failed to allocate memory\n", __func__,
+                   __LINE__);
+        return;
+    }
+    int dbCount = getDbFromServer(taos, dbInfos);
+    if (dbCount <= 0) {
+        free(dbInfos);
+        return;
+    }
+
+    for (int i = 0; i < dbCount; i++) {
+        // printf database info
+        printfDbInfoForQueryToFile(filename, dbInfos[i], i);
+
+        // show db.vgroups
+        snprintf(buffer, SQL_BUFF_LEN, "show %s.vgroups;", dbInfos[i]->name);
+        res = taos_query(taos, buffer);
+        xDumpResultToFile(filename, res);
+
+        // show db.stables
+        snprintf(buffer, SQL_BUFF_LEN, "show %s.stables;", dbInfos[i]->name);
+        res = taos_query(taos, buffer);
+        xDumpResultToFile(filename, res);
+        free(dbInfos[i]);
+    }
+
+    free(dbInfos);
+    resetAfterAnsiEscape();
+}
\ No newline at end of file

src/kit/taosdemo/src/demoQuery.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+
+void selectAndGetResult(threadInfo *pThreadInfo, char *command) {
+    if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", strlen("taosc"))) {
+        TAOS_RES *res = taos_query(pThreadInfo->taos, command);
+        if (res == NULL || taos_errno(res) != 0) {
+            errorPrint("%s() LN%d, failed to execute sql:%s, reason:%s\n",
+                       __func__, __LINE__, command, taos_errstr(res));
+            taos_free_result(res);
+            return;
+        }
+
+        fetchResult(res, pThreadInfo);
+        taos_free_result(res);
+
+    } else if (0 ==
+               strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
+        int retCode = postProceSql(g_queryInfo.host, g_queryInfo.port, command,
+                                   pThreadInfo);
+        if (0 != retCode) {
+            printf("====restful return fail, threadID[%d]\n",
+                   pThreadInfo->threadID);
+        }
+
+    } else {
+        errorPrint("%s() LN%d, unknown query mode: %s\n", __func__, __LINE__,
+                   g_queryInfo.queryMode);
+    }
+}
+
+void *specifiedTableQuery(void *sarg) {
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+
+    setThreadName("specTableQuery");
+
+    if (pThreadInfo->taos == NULL) {
+        TAOS *taos = NULL;
+        taos = taos_connect(g_queryInfo.host, g_queryInfo.user,
+                            g_queryInfo.password, NULL, g_queryInfo.port);
+        if (taos == NULL) {
+            errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+                       pThreadInfo->threadID, taos_errstr(NULL));
+            return NULL;
+        } else {
+            pThreadInfo->taos = taos;
+        }
+    }
+
+    char sqlStr[TSDB_DB_NAME_LEN + 5];
+    sprintf(sqlStr, "use %s", g_queryInfo.dbName);
+    if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
+        taos_close(pThreadInfo->taos);
+        errorPrint("use database %s failed!\n\n", g_queryInfo.dbName);
+        return NULL;
+    }
+
+    uint64_t st = 0;
+    uint64_t et = 0;
+
+    uint64_t queryTimes = g_queryInfo.specifiedQueryInfo.queryTimes;
+
+    uint64_t totalQueried = 0;
+    uint64_t lastPrintTime = taosGetTimestampMs();
+    uint64_t startTs = taosGetTimestampMs();
+
+    if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] !=
+        '\0') {
+        sprintf(pThreadInfo->filePath, "%s-%d",
+                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
+                pThreadInfo->threadID);
+    }
+
+    while (queryTimes--) {
+        if (g_queryInfo.specifiedQueryInfo.queryInterval &&
+            (et - st) < (int64_t)g_queryInfo.specifiedQueryInfo.queryInterval) {
+            taosMsleep(g_queryInfo.specifiedQueryInfo.queryInterval -
+                       (et - st));  // ms
+        }
+
+        st = taosGetTimestampMs();
+
+        selectAndGetResult(
+            pThreadInfo,
+            g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq]);
+
+        et = taosGetTimestampMs();
+        printf("=thread[%" PRId64 "] use %s complete one sql, Spent %10.3f s\n",
+               taosGetSelfPthreadId(), g_queryInfo.queryMode,
+               (et - st) / 1000.0);
+
+        totalQueried++;
+        g_queryInfo.specifiedQueryInfo.totalQueried++;
+
+        uint64_t currentPrintTime = taosGetTimestampMs();
+        uint64_t endTs = taosGetTimestampMs();
+        if (currentPrintTime - lastPrintTime > 30 * 1000) {
+            debugPrint("%s() LN%d, endTs=%" PRIu64 " ms, startTs=%" PRIu64
+                       " ms\n",
+                       __func__, __LINE__, endTs, startTs);
+            printf("thread[%d] has currently completed queries: %" PRIu64
+                   ", QPS: %10.6f\n",
+                   pThreadInfo->threadID, totalQueried,
+                   (double)(totalQueried / ((endTs - startTs) / 1000.0)));
+            lastPrintTime = currentPrintTime;
+        }
+    }
+    return NULL;
+}
+
+void *superTableQuery(void *sarg) {
+    char *sqlstr = calloc(1, BUFFER_SIZE);
+    assert(sqlstr);
+
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+
+    setThreadName("superTableQuery");
+
+    if (pThreadInfo->taos == NULL) {
+        TAOS *taos = NULL;
+        taos = taos_connect(g_queryInfo.host, g_queryInfo.user,
+                            g_queryInfo.password, NULL, g_queryInfo.port);
+        if (taos == NULL) {
+            errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+                       pThreadInfo->threadID, taos_errstr(NULL));
+            free(sqlstr);
+            return NULL;
+        } else {
+            pThreadInfo->taos = taos;
+        }
+    }
+
+    uint64_t st = 0;
+    uint64_t et = (int64_t)g_queryInfo.superQueryInfo.queryInterval;
+
+    uint64_t queryTimes = g_queryInfo.superQueryInfo.queryTimes;
+    uint64_t totalQueried = 0;
+    uint64_t startTs = taosGetTimestampMs();
+
+    uint64_t lastPrintTime = taosGetTimestampMs();
+    while (queryTimes--) {
+        if (g_queryInfo.superQueryInfo.queryInterval &&
+            (et - st) < (int64_t)g_queryInfo.superQueryInfo.queryInterval) {
+            taosMsleep(g_queryInfo.superQueryInfo.queryInterval -
+                       (et - st));  // ms
+            // printf("========sleep duration:%"PRId64 "========inserted
+            // rows:%d, table range:%d - %d\n", (1000 - (et - st)), i,
+            // pThreadInfo->start_table_from, pThreadInfo->end_table_to);
+        }
+
+        st = taosGetTimestampMs();
+        for (int i = pThreadInfo->start_table_from;
+             i <= pThreadInfo->end_table_to; i++) {
+            for (int j = 0; j < g_queryInfo.superQueryInfo.sqlCount; j++) {
+                memset(sqlstr, 0, BUFFER_SIZE);
+                replaceChildTblName(g_queryInfo.superQueryInfo.sql[j], sqlstr,
+                                    i);
+                if (g_queryInfo.superQueryInfo.result[j][0] != '\0') {
+                    sprintf(pThreadInfo->filePath, "%s-%d",
+                            g_queryInfo.superQueryInfo.result[j],
+                            pThreadInfo->threadID);
+                }
+                selectAndGetResult(pThreadInfo, sqlstr);
+
+                totalQueried++;
+                g_queryInfo.superQueryInfo.totalQueried++;
+
+                int64_t currentPrintTime = taosGetTimestampMs();
+                int64_t endTs = taosGetTimestampMs();
+                if (currentPrintTime - lastPrintTime > 30 * 1000) {
+                    printf(
+                        "thread[%d] has currently completed queries: %" PRIu64
+                        ", QPS: %10.3f\n",
+                        pThreadInfo->threadID, totalQueried,
+                        (double)(totalQueried / ((endTs - startTs) / 1000.0)));
+                    lastPrintTime = currentPrintTime;
+                }
+            }
+        }
+        et = taosGetTimestampMs();
+        printf("####thread[%" PRId64
+               "] complete all sqls to allocate all sub-tables[%" PRIu64
+               " - %" PRIu64 "] once queries duration:%.4fs\n\n",
+               taosGetSelfPthreadId(), pThreadInfo->start_table_from,
+               pThreadInfo->end_table_to, (double)(et - st) / 1000.0);
+    }
+
+    free(sqlstr);
+    return NULL;
+}
+
+int queryTestProcess() {
+    printfQueryMeta();
+
+    TAOS *taos = NULL;
+    taos = taos_connect(g_queryInfo.host, g_queryInfo.user,
+                        g_queryInfo.password, NULL, g_queryInfo.port);
+    if (taos == NULL) {
+        errorPrint("Failed to connect to TDengine, reason:%s\n",
+                   taos_errstr(NULL));
+        exit(EXIT_FAILURE);
+    }
+
+    if (0 != g_queryInfo.superQueryInfo.sqlCount) {
+        getAllChildNameOfSuperTable(taos, g_queryInfo.dbName,
+                                    g_queryInfo.superQueryInfo.stbName,
+                                    &g_queryInfo.superQueryInfo.childTblName,
+                                    &g_queryInfo.superQueryInfo.childTblCount);
+    }
+
+    prompt();
+
+    if (g_args.debug_print || g_args.verbose_print) {
+        printfQuerySystemInfo(taos);
+    }
+
+    if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
+        if (convertHostToServAddr(g_queryInfo.host, g_queryInfo.port,
+                                  &g_queryInfo.serv_addr) != 0)
+            ERROR_EXIT("convert host to server address");
+    }
+
+    pthread_t * pids = NULL;
+    threadInfo *infos = NULL;
+    //==== create sub threads for query from specify table
+    int      nConcurrent = g_queryInfo.specifiedQueryInfo.concurrent;
+    uint64_t nSqlCount = g_queryInfo.specifiedQueryInfo.sqlCount;
+
+    uint64_t startTs = taosGetTimestampMs();
+
+    if ((nSqlCount > 0) && (nConcurrent > 0)) {
+        pids = calloc(1, nConcurrent * nSqlCount * sizeof(pthread_t));
+        infos = calloc(1, nConcurrent * nSqlCount * sizeof(threadInfo));
+
+        if ((NULL == pids) || (NULL == infos)) {
+            taos_close(taos);
+            ERROR_EXIT("memory allocation failed for create threads\n");
+        }
+
+        for (uint64_t i = 0; i < nSqlCount; i++) {
+            for (int j = 0; j < nConcurrent; j++) {
+                uint64_t    seq = i * nConcurrent + j;
+                threadInfo *pThreadInfo = infos + seq;
+                pThreadInfo->threadID = seq;
+                pThreadInfo->querySeq = i;
+
+                if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", 5)) {
+                    char sqlStr[TSDB_DB_NAME_LEN + 5];
+                    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
+                    if (0 != queryDbExec(taos, sqlStr, NO_INSERT_TYPE, false)) {
+                        taos_close(taos);
+                        free(infos);
+                        free(pids);
+                        errorPrint("use database %s failed!\n\n",
+                                   g_queryInfo.dbName);
+                        return -1;
+                    }
+                }
+
+                if (0 == strncasecmp(g_queryInfo.queryMode, "rest", 4)) {
+#ifdef WINDOWS
+                    WSADATA wsaData;
+                    WSAStartup(MAKEWORD(2, 2), &wsaData);
+                    SOCKET sockfd;
+#else
+                    int sockfd;
+#endif
+                    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+                    if (sockfd < 0) {
+#ifdef WINDOWS
+                        errorPrint("Could not create socket : %d",
+                                   WSAGetLastError());
+#endif
+                        debugPrint("%s() LN%d, sockfd=%d\n", __func__, __LINE__,
+                                   sockfd);
+                        ERROR_EXIT("opening socket");
+                    }
+
+                    int retConn = connect(
+                        sockfd, (struct sockaddr *)&(g_queryInfo.serv_addr),
+                        sizeof(struct sockaddr));
+                    debugPrint("%s() LN%d connect() return %d\n", __func__,
+                               __LINE__, retConn);
+                    if (retConn < 0) {
+                        ERROR_EXIT("connecting");
+                    }
+                    pThreadInfo->sockfd = sockfd;
+                }
+                pThreadInfo->taos =
+                    NULL;  // workaround to use separate taos connection;
+
+                pthread_create(pids + seq, NULL, specifiedTableQuery,
+                               pThreadInfo);
+            }
+        }
+    } else {
+        g_queryInfo.specifiedQueryInfo.concurrent = 0;
+    }
+
+    taos_close(taos);
+
+    pthread_t * pidsOfSub = NULL;
+    threadInfo *infosOfSub = NULL;
+    //==== create sub threads for query from all sub table of the super table
+    if ((g_queryInfo.superQueryInfo.sqlCount > 0) &&
+        (g_queryInfo.superQueryInfo.threadCnt > 0)) {
+        pidsOfSub =
+            calloc(1, g_queryInfo.superQueryInfo.threadCnt * sizeof(pthread_t));
+        infosOfSub = calloc(
+            1, g_queryInfo.superQueryInfo.threadCnt * sizeof(threadInfo));
+
+        if ((NULL == pidsOfSub) || (NULL == infosOfSub)) {
+            free(infos);
+            free(pids);
+
+            ERROR_EXIT("memory allocation failed for create threads\n");
+        }
+
+        int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
+        int     threads = g_queryInfo.superQueryInfo.threadCnt;
+
+        int64_t a = ntables / threads;
+        if (a < 1) {
+            threads = ntables;
+            a = 1;
+        }
+
+        int64_t b = 0;
+        if (threads != 0) {
+            b = ntables % threads;
+        }
+
+        uint64_t tableFrom = 0;
+        for (int i = 0; i < threads; i++) {
+            threadInfo *pThreadInfo = infosOfSub + i;
+            pThreadInfo->threadID = i;
+
+            pThreadInfo->start_table_from = tableFrom;
+            pThreadInfo->ntables = i < b ? a + 1 : a;
+            pThreadInfo->end_table_to =
+                i < b ? tableFrom + a : tableFrom + a - 1;
+            tableFrom = pThreadInfo->end_table_to + 1;
+            pThreadInfo->taos =
+                NULL;  // workaround to use separate taos connection;
+            if (0 == strncasecmp(g_queryInfo.queryMode, "rest", 4)) {
+#ifdef WINDOWS
+                WSADATA wsaData;
+                WSAStartup(MAKEWORD(2, 2), &wsaData);
+                SOCKET sockfd;
+#else
+                int sockfd;
+#endif
+                sockfd = socket(AF_INET, SOCK_STREAM, 0);
+                if (sockfd < 0) {
+#ifdef WINDOWS
+                    errorPrint("Could not create socket : %d",
+                               WSAGetLastError());
+#endif
+                    debugPrint("%s() LN%d, sockfd=%d\n", __func__, __LINE__,
+                               sockfd);
+                    ERROR_EXIT("opening socket");
+                }
+
+                int retConn =
+                    connect(sockfd, (struct sockaddr *)&(g_queryInfo.serv_addr),
+                            sizeof(struct sockaddr));
+                debugPrint("%s() LN%d connect() return %d\n", __func__,
+                           __LINE__, retConn);
+                if (retConn < 0) {
+                    ERROR_EXIT("connecting");
+                }
+                pThreadInfo->sockfd = sockfd;
+            }
+            pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
+        }
+
+        g_queryInfo.superQueryInfo.threadCnt = threads;
+    } else {
+        g_queryInfo.superQueryInfo.threadCnt = 0;
+    }
+
+    if ((nSqlCount > 0) && (nConcurrent > 0)) {
+        for (int i = 0; i < nConcurrent; i++) {
+            for (int j = 0; j < nSqlCount; j++) {
+                pthread_join(pids[i * nSqlCount + j], NULL);
+                if (0 == strncasecmp(g_queryInfo.queryMode, "rest", 4)) {
+                    threadInfo *pThreadInfo = infos + i * nSqlCount + j;
+#ifdef WINDOWS
+                    closesocket(pThreadInfo->sockfd);
+                    WSACleanup();
+#else
+                    close(pThreadInfo->sockfd);
+#endif
+                }
+            }
+        }
+    }
+
+    tmfree((char *)pids);
+    tmfree((char *)infos);
+
+    for (int i = 0; i < g_queryInfo.superQueryInfo.threadCnt; i++) {
+        pthread_join(pidsOfSub[i], NULL);
+        if (0 == strncasecmp(g_queryInfo.queryMode, "rest", 4)) {
+            threadInfo *pThreadInfo = infosOfSub + i;
+#ifdef WINDOWS
+            closesocket(pThreadInfo->sockfd);
+            WSACleanup();
+#else
+            close(pThreadInfo->sockfd);
+#endif
+        }
+    }
+
+    tmfree((char *)pidsOfSub);
+    tmfree((char *)infosOfSub);
+
+    //  taos_close(taos);// workaround to use separate taos connection;
+    uint64_t endTs = taosGetTimestampMs();
+
+    uint64_t totalQueried = g_queryInfo.specifiedQueryInfo.totalQueried +
+                            g_queryInfo.superQueryInfo.totalQueried;
+
+    fprintf(stderr,
+            "==== completed total queries: %" PRIu64
+            ", the QPS of all threads: %10.3f====\n",
+            totalQueried,
+            (double)(totalQueried / ((endTs - startTs) / 1000.0)));
+    return 0;
+}
\ No newline at end of file

src/kit/taosdemo/src/demoSubscribe.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+
+void stable_sub_callback(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code) {
+    if (res == NULL || taos_errno(res) != 0) {
+        errorPrint(
+            "%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
+            __func__, __LINE__, code, taos_errstr(res));
+        return;
+    }
+
+    if (param) fetchResult(res, (threadInfo *)param);
+    // tao_unsubscribe() will free result.
+}
+
+void specified_sub_callback(TAOS_SUB *tsub, TAOS_RES *res, void *param,
+                            int code) {
+    if (res == NULL || taos_errno(res) != 0) {
+        errorPrint(
+            "%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
+            __func__, __LINE__, code, taos_errstr(res));
+        return;
+    }
+
+    if (param) fetchResult(res, (threadInfo *)param);
+    // tao_unsubscribe() will free result.
+}
+
+TAOS_SUB *subscribeImpl(QUERY_CLASS class, threadInfo *pThreadInfo, char *sql,
+                        char *topic, bool restart, uint64_t interval) {
+    TAOS_SUB *tsub = NULL;
+
+    if ((SPECIFIED_CLASS == class) &&
+        (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode)) {
+        tsub = taos_subscribe(pThreadInfo->taos, restart, topic, sql,
+                              specified_sub_callback, (void *)pThreadInfo,
+                              g_queryInfo.specifiedQueryInfo.subscribeInterval);
+    } else if ((STABLE_CLASS == class) &&
+               (ASYNC_MODE == g_queryInfo.superQueryInfo.asyncMode)) {
+        tsub = taos_subscribe(pThreadInfo->taos, restart, topic, sql,
+                              stable_sub_callback, (void *)pThreadInfo,
+                              g_queryInfo.superQueryInfo.subscribeInterval);
+    } else {
+        tsub = taos_subscribe(pThreadInfo->taos, restart, topic, sql, NULL,
+                              NULL, interval);
+    }
+
+    if (tsub == NULL) {
+        errorPrint("failed to create subscription. topic:%s, sql:%s\n", topic,
+                   sql);
+        return NULL;
+    }
+
+    return tsub;
+}
+
+void *specifiedSubscribe(void *sarg) {
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+    //  TAOS_SUB*  tsub = NULL;
+
+    setThreadName("specSub");
+
+    if (pThreadInfo->taos == NULL) {
+        pThreadInfo->taos = taos_connect(g_queryInfo.host, g_queryInfo.user,
+                                         g_queryInfo.password,
+                                         g_queryInfo.dbName, g_queryInfo.port);
+        if (pThreadInfo->taos == NULL) {
+            errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+                       pThreadInfo->threadID, taos_errstr(NULL));
+            return NULL;
+        }
+    }
+
+    char sqlStr[TSDB_DB_NAME_LEN + 5];
+    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
+    if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
+        taos_close(pThreadInfo->taos);
+        return NULL;
+    }
+
+    sprintf(g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
+            "taosdemo-subscribe-%" PRIu64 "-%d", pThreadInfo->querySeq,
+            pThreadInfo->threadID);
+    if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] !=
+        '\0') {
+        sprintf(pThreadInfo->filePath, "%s-%d",
+                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
+                pThreadInfo->threadID);
+    }
+    g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] = subscribeImpl(
+        SPECIFIED_CLASS, pThreadInfo,
+        g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
+        g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
+        g_queryInfo.specifiedQueryInfo.subscribeRestart,
+        g_queryInfo.specifiedQueryInfo.subscribeInterval);
+    if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
+        taos_close(pThreadInfo->taos);
+        return NULL;
+    }
+
+    // start loop to consume result
+
+    g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
+    while ((g_queryInfo.specifiedQueryInfo
+                .endAfterConsume[pThreadInfo->querySeq] == -1) ||
+           (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] <
+            g_queryInfo.specifiedQueryInfo
+                .endAfterConsume[pThreadInfo->querySeq])) {
+        printf("consumed[%d]: %d, endAfterConsum[%" PRId64 "]: %d\n",
+               pThreadInfo->threadID,
+               g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID],
+               pThreadInfo->querySeq,
+               g_queryInfo.specifiedQueryInfo
+                   .endAfterConsume[pThreadInfo->querySeq]);
+        if (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode) {
+            continue;
+        }
+
+        g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID] =
+            taos_consume(
+                g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]);
+        if (g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]) {
+            if (g_queryInfo.specifiedQueryInfo
+                    .result[pThreadInfo->querySeq][0] != 0) {
+                sprintf(pThreadInfo->filePath, "%s-%d",
+                        g_queryInfo.specifiedQueryInfo
+                            .result[pThreadInfo->querySeq],
+                        pThreadInfo->threadID);
+            }
+            fetchResult(
+                g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID],
+                pThreadInfo);
+
+            g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID]++;
+            if ((g_queryInfo.specifiedQueryInfo
+                     .resubAfterConsume[pThreadInfo->querySeq] != -1) &&
+                (g_queryInfo.specifiedQueryInfo
+                     .consumed[pThreadInfo->threadID] >=
+                 g_queryInfo.specifiedQueryInfo
+                     .resubAfterConsume[pThreadInfo->querySeq])) {
+                printf("keepProgress:%d, resub specified query: %" PRIu64 "\n",
+                       g_queryInfo.specifiedQueryInfo.subscribeKeepProgress,
+                       pThreadInfo->querySeq);
+                g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] =
+                    0;
+                taos_unsubscribe(
+                    g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID],
+                    g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
+                g_queryInfo.specifiedQueryInfo
+                    .tsub[pThreadInfo->threadID] = subscribeImpl(
+                    SPECIFIED_CLASS, pThreadInfo,
+                    g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
+                    g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
+                    g_queryInfo.specifiedQueryInfo.subscribeRestart,
+                    g_queryInfo.specifiedQueryInfo.subscribeInterval);
+                if (NULL == g_queryInfo.specifiedQueryInfo
+                                .tsub[pThreadInfo->threadID]) {
+                    taos_close(pThreadInfo->taos);
+                    return NULL;
+                }
+            }
+        }
+    }
+    taos_free_result(g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]);
+    taos_close(pThreadInfo->taos);
+
+    return NULL;
+}
+
+static void *superSubscribe(void *sarg) {
+    threadInfo *pThreadInfo = (threadInfo *)sarg;
+    char *      subSqlStr = calloc(1, BUFFER_SIZE);
+    assert(subSqlStr);
+
+    TAOS_SUB *tsub[MAX_QUERY_SQL_COUNT] = {0};
+    uint64_t  tsubSeq;
+
+    setThreadName("superSub");
+
+    if (pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
+        free(subSqlStr);
+        errorPrint("The table number(%" PRId64
+                   ") of the thread is more than max query sql count: %d\n",
+                   pThreadInfo->ntables, MAX_QUERY_SQL_COUNT);
+        exit(EXIT_FAILURE);
+    }
+
+    if (pThreadInfo->taos == NULL) {
+        pThreadInfo->taos = taos_connect(g_queryInfo.host, g_queryInfo.user,
+                                         g_queryInfo.password,
+                                         g_queryInfo.dbName, g_queryInfo.port);
+        if (pThreadInfo->taos == NULL) {
+            errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+                       pThreadInfo->threadID, taos_errstr(NULL));
+            free(subSqlStr);
+            return NULL;
+        }
+    }
+
+    char sqlStr[TSDB_DB_NAME_LEN + 5];
+    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
+    if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
+        taos_close(pThreadInfo->taos);
+        errorPrint("use database %s failed!\n\n", g_queryInfo.dbName);
+        free(subSqlStr);
+        return NULL;
+    }
+
+    char topic[32] = {0};
+    for (uint64_t i = pThreadInfo->start_table_from;
+         i <= pThreadInfo->end_table_to; i++) {
+        tsubSeq = i - pThreadInfo->start_table_from;
+        verbosePrint("%s() LN%d, [%d], start=%" PRId64 " end=%" PRId64
+                     " i=%" PRIu64 "\n",
+                     __func__, __LINE__, pThreadInfo->threadID,
+                     pThreadInfo->start_table_from, pThreadInfo->end_table_to,
+                     i);
+        sprintf(topic, "taosdemo-subscribe-%" PRIu64 "-%" PRIu64 "", i,
+                pThreadInfo->querySeq);
+        memset(subSqlStr, 0, BUFFER_SIZE);
+        replaceChildTblName(
+            g_queryInfo.superQueryInfo.sql[pThreadInfo->querySeq], subSqlStr,
+            i);
+        if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
+            sprintf(pThreadInfo->filePath, "%s-%d",
+                    g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
+                    pThreadInfo->threadID);
+        }
+
+        verbosePrint("%s() LN%d, [%d] subSqlStr: %s\n", __func__, __LINE__,
+                     pThreadInfo->threadID, subSqlStr);
+        tsub[tsubSeq] =
+            subscribeImpl(STABLE_CLASS, pThreadInfo, subSqlStr, topic,
+                          g_queryInfo.superQueryInfo.subscribeRestart,
+                          g_queryInfo.superQueryInfo.subscribeInterval);
+        if (NULL == tsub[tsubSeq]) {
+            taos_close(pThreadInfo->taos);
+            free(subSqlStr);
+            return NULL;
+        }
+    }
+
+    // start loop to consume result
+    int consumed[MAX_QUERY_SQL_COUNT];
+    for (int i = 0; i < MAX_QUERY_SQL_COUNT; i++) {
+        consumed[i] = 0;
+    }
+    TAOS_RES *res = NULL;
+
+    uint64_t st = 0, et = 0;
+
+    while (
+        (g_queryInfo.superQueryInfo.endAfterConsume == -1) ||
+        (g_queryInfo.superQueryInfo.endAfterConsume >
+         consumed[pThreadInfo->end_table_to - pThreadInfo->start_table_from])) {
+        verbosePrint("super endAfterConsume: %d, consumed: %d\n",
+                     g_queryInfo.superQueryInfo.endAfterConsume,
+                     consumed[pThreadInfo->end_table_to -
+                              pThreadInfo->start_table_from]);
+        for (uint64_t i = pThreadInfo->start_table_from;
+             i <= pThreadInfo->end_table_to; i++) {
+            tsubSeq = i - pThreadInfo->start_table_from;
+            if (ASYNC_MODE == g_queryInfo.superQueryInfo.asyncMode) {
+                continue;
+            }
+
+            st = taosGetTimestampMs();
+            performancePrint("st: %" PRIu64 " et: %" PRIu64 " st-et: %" PRIu64
+                             "\n",
+                             st, et, (st - et));
+            res = taos_consume(tsub[tsubSeq]);
+            et = taosGetTimestampMs();
+            performancePrint("st: %" PRIu64 " et: %" PRIu64 " delta: %" PRIu64
+                             "\n",
+                             st, et, (et - st));
+
+            if (res) {
+                if (g_queryInfo.superQueryInfo
+                        .result[pThreadInfo->querySeq][0] != 0) {
+                    sprintf(pThreadInfo->filePath, "%s-%d",
+                            g_queryInfo.superQueryInfo
+                                .result[pThreadInfo->querySeq],
+                            pThreadInfo->threadID);
+                    fetchResult(res, pThreadInfo);
+                }
+                consumed[tsubSeq]++;
+
+                if ((g_queryInfo.superQueryInfo.resubAfterConsume != -1) &&
+                    (consumed[tsubSeq] >=
+                     g_queryInfo.superQueryInfo.resubAfterConsume)) {
+                    verbosePrint(
+                        "%s() LN%d, keepProgress:%d, resub super table query: "
+                        "%" PRIu64 "\n",
+                        __func__, __LINE__,
+                        g_queryInfo.superQueryInfo.subscribeKeepProgress,
+                        pThreadInfo->querySeq);
+                    taos_unsubscribe(
+                        tsub[tsubSeq],
+                        g_queryInfo.superQueryInfo.subscribeKeepProgress);
+                    consumed[tsubSeq] = 0;
+                    tsub[tsubSeq] = subscribeImpl(
+                        STABLE_CLASS, pThreadInfo, subSqlStr, topic,
+                        g_queryInfo.superQueryInfo.subscribeRestart,
+                        g_queryInfo.superQueryInfo.subscribeInterval);
+                    if (NULL == tsub[tsubSeq]) {
+                        taos_close(pThreadInfo->taos);
+                        free(subSqlStr);
+                        return NULL;
+                    }
+                }
+            }
+        }
+    }
+    verbosePrint(
+        "%s() LN%d, super endAfterConsume: %d, consumed: %d\n", __func__,
+        __LINE__, g_queryInfo.superQueryInfo.endAfterConsume,
+        consumed[pThreadInfo->end_table_to - pThreadInfo->start_table_from]);
+    taos_free_result(res);
+
+    for (uint64_t i = pThreadInfo->start_table_from;
+         i <= pThreadInfo->end_table_to; i++) {
+        tsubSeq = i - pThreadInfo->start_table_from;
+        taos_unsubscribe(tsub[tsubSeq], 0);
+    }
+
+    taos_close(pThreadInfo->taos);
+    free(subSqlStr);
+    return NULL;
+}
+
+int subscribeTestProcess() {
+    setupForAnsiEscape();
+    printfQueryMeta();
+    resetAfterAnsiEscape();
+
+    prompt();
+
+    TAOS *taos = NULL;
+    taos =
+        taos_connect(g_queryInfo.host, g_queryInfo.user, g_queryInfo.password,
+                     g_queryInfo.dbName, g_queryInfo.port);
+    if (taos == NULL) {
+        errorPrint("Failed to connect to TDengine, reason:%s\n",
+                   taos_errstr(NULL));
+        exit(EXIT_FAILURE);
+    }
+
+    if (0 != g_queryInfo.superQueryInfo.sqlCount) {
+        getAllChildNameOfSuperTable(taos, g_queryInfo.dbName,
+                                    g_queryInfo.superQueryInfo.stbName,
+                                    &g_queryInfo.superQueryInfo.childTblName,
+                                    &g_queryInfo.superQueryInfo.childTblCount);
+    }
+
+    taos_close(taos);  // workaround to use separate taos connection;
+
+    pthread_t * pids = NULL;
+    threadInfo *infos = NULL;
+
+    pthread_t * pidsOfStable = NULL;
+    threadInfo *infosOfStable = NULL;
+
+    //==== create threads for query for specified table
+    if (g_queryInfo.specifiedQueryInfo.sqlCount <= 0) {
+        debugPrint("%s() LN%d, specified query sqlCount %d.\n", __func__,
+                   __LINE__, g_queryInfo.specifiedQueryInfo.sqlCount);
+    } else {
+        if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
+            errorPrint("%s() LN%d, specified query sqlCount %d.\n", __func__,
+                       __LINE__, g_queryInfo.specifiedQueryInfo.sqlCount);
+            exit(EXIT_FAILURE);
+        }
+
+        pids = calloc(1, g_queryInfo.specifiedQueryInfo.sqlCount *
+                             g_queryInfo.specifiedQueryInfo.concurrent *
+                             sizeof(pthread_t));
+        infos = calloc(1, g_queryInfo.specifiedQueryInfo.sqlCount *
+                              g_queryInfo.specifiedQueryInfo.concurrent *
+                              sizeof(threadInfo));
+        if ((NULL == pids) || (NULL == infos)) {
+            errorPrint("%s() LN%d, malloc failed for create threads\n",
+                       __func__, __LINE__);
+            exit(EXIT_FAILURE);
+        }
+
+        for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
+            for (int j = 0; j < g_queryInfo.specifiedQueryInfo.concurrent;
+                 j++) {
+                uint64_t seq =
+                    i * g_queryInfo.specifiedQueryInfo.concurrent + j;
+                threadInfo *pThreadInfo = infos + seq;
+                pThreadInfo->threadID = seq;
+                pThreadInfo->querySeq = i;
+                pThreadInfo->taos =
+                    NULL;  // workaround to use separate taos connection;
+                pthread_create(pids + seq, NULL, specifiedSubscribe,
+                               pThreadInfo);
+            }
+        }
+    }
+
+    //==== create threads for super table query
+    if (g_queryInfo.superQueryInfo.sqlCount <= 0) {
+        debugPrint("%s() LN%d, super table query sqlCount %d.\n", __func__,
+                   __LINE__, g_queryInfo.superQueryInfo.sqlCount);
+    } else {
+        if ((g_queryInfo.superQueryInfo.sqlCount > 0) &&
+            (g_queryInfo.superQueryInfo.threadCnt > 0)) {
+            pidsOfStable = calloc(1, g_queryInfo.superQueryInfo.sqlCount *
+                                         g_queryInfo.superQueryInfo.threadCnt *
+                                         sizeof(pthread_t));
+            infosOfStable = calloc(1, g_queryInfo.superQueryInfo.sqlCount *
+                                          g_queryInfo.superQueryInfo.threadCnt *
+                                          sizeof(threadInfo));
+            if ((NULL == pidsOfStable) || (NULL == infosOfStable)) {
+                errorPrint("%s() LN%d, malloc failed for create threads\n",
+                           __func__, __LINE__);
+                // taos_close(taos);
+                exit(EXIT_FAILURE);
+            }
+
+            int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
+            int     threads = g_queryInfo.superQueryInfo.threadCnt;
+
+            int64_t a = ntables / threads;
+            if (a < 1) {
+                threads = ntables;
+                a = 1;
+            }
+
+            int64_t b = 0;
+            if (threads != 0) {
+                b = ntables % threads;
+            }
+
+            for (uint64_t i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
+                uint64_t tableFrom = 0;
+                for (int j = 0; j < threads; j++) {
+                    uint64_t    seq = i * threads + j;
+                    threadInfo *pThreadInfo = infosOfStable + seq;
+                    pThreadInfo->threadID = seq;
+                    pThreadInfo->querySeq = i;
+
+                    pThreadInfo->start_table_from = tableFrom;
+                    pThreadInfo->ntables = j < b ? a + 1 : a;
+                    pThreadInfo->end_table_to =
+                        j < b ? tableFrom + a : tableFrom + a - 1;
+                    tableFrom = pThreadInfo->end_table_to + 1;
+                    pThreadInfo->taos =
+                        NULL;  // workaround to use separate taos connection;
+                    pthread_create(pidsOfStable + seq, NULL, superSubscribe,
+                                   pThreadInfo);
+                }
+            }
+
+            g_queryInfo.superQueryInfo.threadCnt = threads;
+
+            for (int i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
+                for (int j = 0; j < threads; j++) {
+                    uint64_t seq = i * threads + j;
+                    pthread_join(pidsOfStable[seq], NULL);
+                }
+            }
+        }
+    }
+
+    for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
+        for (int j = 0; j < g_queryInfo.specifiedQueryInfo.concurrent; j++) {
+            uint64_t seq = i * g_queryInfo.specifiedQueryInfo.concurrent + j;
+            pthread_join(pids[seq], NULL);
+        }
+    }
+
+    tmfree((char *)pids);
+    tmfree((char *)infos);
+
+    tmfree((char *)pidsOfStable);
+    tmfree((char *)infosOfStable);
+    //   taos_close(taos);
+    return 0;
+}
\ No newline at end of file

src/kit/taosdemo/src/demoUtil.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "demo.h"
+
+void errorWrongValue(char *program, char *wrong_arg, char *wrong_value) {
+    fprintf(stderr, "%s %s: %s is an invalid value\n", program, wrong_arg,
+            wrong_value);
+    fprintf(
+        stderr,
+        "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+void errorUnrecognized(char *program, char *wrong_arg) {
+    fprintf(stderr, "%s: unrecognized options '%s'\n", program, wrong_arg);
+    fprintf(
+        stderr,
+        "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+void errorPrintReqArg(char *program, char *wrong_arg) {
+    fprintf(stderr, "%s: option requires an argument -- '%s'\n", program,
+            wrong_arg);
+    fprintf(
+        stderr,
+        "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+void errorPrintReqArg2(char *program, char *wrong_arg) {
+    fprintf(stderr, "%s: option requires a number argument '-%s'\n", program,
+            wrong_arg);
+    fprintf(
+        stderr,
+        "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+void errorPrintReqArg3(char *program, char *wrong_arg) {
+    fprintf(stderr, "%s: option '%s' requires an argument\n", program,
+            wrong_arg);
+    fprintf(
+        stderr,
+        "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+void tmfclose(FILE *fp) {
+    if (NULL != fp) {
+        fclose(fp);
+    }
+}
+
+void tmfree(void *buf) {
+    if (NULL != buf) {
+        free(buf);
+        buf = NULL;
+    }
+}
+
+void ERROR_EXIT(const char *msg) {
+    errorPrint("%s", msg);
+    exit(EXIT_FAILURE);
+}
+
+#ifdef WINDOWS
+#define _CRT_RAND_S
+
+#include <windows.h>
+#include <winsock2.h>
+
+typedef unsigned __int32 uint32_t;
+
+#pragma comment(lib, "ws2_32.lib")
+// Some old MinGW/CYGWIN distributions don't define this:
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif  // ENABLE_VIRTUAL_TERMINAL_PROCESSING
+
+HANDLE g_stdoutHandle;
+DWORD  g_consoleMode;
+
+void setupForAnsiEscape(void) {
+    DWORD mode = 0;
+    g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    if (g_stdoutHandle == INVALID_HANDLE_VALUE) {
+        exit(GetLastError());
+    }
+
+    if (!GetConsoleMode(g_stdoutHandle, &mode)) {
+        exit(GetLastError());
+    }
+
+    g_consoleMode = mode;
+
+    // Enable ANSI escape codes
+    mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+
+    if (!SetConsoleMode(g_stdoutHandle, mode)) {
+        exit(GetLastError());
+    }
+}
+
+void resetAfterAnsiEscape(void) {
+    // Reset colors
+    printf("\x1b[0m");
+
+    // Reset console mode
+    if (!SetConsoleMode(g_stdoutHandle, g_consoleMode)) {
+        exit(GetLastError());
+    }
+}
+
+int taosRandom() {
+    int number;
+    rand_s(&number);
+
+    return number;
+}
+#else  // Not windows
+void setupForAnsiEscape(void) {}
+
+void resetAfterAnsiEscape(void) {
+    // Reset colors
+    printf("\x1b[0m");
+}
+
+#include <time.h>
+
+int taosRandom() { return rand(); }
+
+#endif
+
+bool isStringNumber(char *input) {
+    int len = strlen(input);
+    if (0 == len) {
+        return false;
+    }
+
+    for (int i = 0; i < len; i++) {
+        if (!isdigit(input[i])) return false;
+    }
+
+    return true;
+}
+
+char *formatTimestamp(char *buf, int64_t val, int precision) {
+    time_t tt;
+    if (precision == TSDB_TIME_PRECISION_MICRO) {
+        tt = (time_t)(val / 1000000);
+    }
+    if (precision == TSDB_TIME_PRECISION_NANO) {
+        tt = (time_t)(val / 1000000000);
+    } else {
+        tt = (time_t)(val / 1000);
+    }
+
+    /* comment out as it make testcases like select_with_tags.sim fail.
+       but in windows, this may cause the call to localtime crash if tt < 0,
+       need to find a better solution.
+       if (tt < 0) {
+       tt = 0;
+       }
+       */
+
+#ifdef WINDOWS
+    if (tt < 0) tt = 0;
+#endif
+
+    struct tm *ptm = localtime(&tt);
+    size_t     pos = strftime(buf, 32, "%Y-%m-%d %H:%M:%S", ptm);
+
+    if (precision == TSDB_TIME_PRECISION_MICRO) {
+        sprintf(buf + pos, ".%06d", (int)(val % 1000000));
+    } else if (precision == TSDB_TIME_PRECISION_NANO) {
+        sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
+    } else {
+        sprintf(buf + pos, ".%03d", (int)(val % 1000));
+    }
+
+    return buf;
+}
+
+int getChildNameOfSuperTableWithLimitAndOffset(TAOS *taos, char *dbName,
+                                               char *   stbName,
+                                               char **  childTblNameOfSuperTbl,
+                                               int64_t *childTblCountOfSuperTbl,
+                                               int64_t limit, uint64_t offset,
+                                               bool escapChar) {
+    char command[SQL_BUFF_LEN] = "\0";
+    char limitBuf[100] = "\0";
+
+    TAOS_RES *res;
+    TAOS_ROW  row = NULL;
+
+    char *childTblName = *childTblNameOfSuperTbl;
+
+    snprintf(limitBuf, 100, " limit %" PRId64 " offset %" PRIu64 "", limit,
+             offset);
+
+    // get all child table name use cmd: select tbname from superTblName;
+    snprintf(command, SQL_BUFF_LEN,
+             escapChar ? "select tbname from %s.`%s` %s"
+                       : "select tbname from %s.%s %s",
+             dbName, stbName, limitBuf);
+
+    res = taos_query(taos, command);
+    int32_t code = taos_errno(res);
+    if (code != 0) {
+        taos_free_result(res);
+        taos_close(taos);
+        errorPrint("%s() LN%d, failed to run command %s, reason: %s\n",
+                   __func__, __LINE__, command, taos_errstr(res));
+        exit(EXIT_FAILURE);
+    }
+
+    int64_t childTblCount = (limit < 0) ? DEFAULT_CHILDTABLES : limit;
+    int64_t count = 0;
+    if (childTblName == NULL) {
+        childTblName = (char *)calloc(1, childTblCount * TSDB_TABLE_NAME_LEN);
+        if (NULL == childTblName) {
+            taos_free_result(res);
+            taos_close(taos);
+            errorPrint("%s() LN%d, failed to allocate memory!\n", __func__,
+                       __LINE__);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    char *pTblName = childTblName;
+    while ((row = taos_fetch_row(res)) != NULL) {
+        int32_t *len = taos_fetch_lengths(res);
+
+        if (0 == strlen((char *)row[0])) {
+            errorPrint("%s() LN%d, No.%" PRId64 " table return empty name\n",
+                       __func__, __LINE__, count);
+            exit(EXIT_FAILURE);
+        }
+
+        tstrncpy(pTblName, (char *)row[0], len[0] + 1);
+        // printf("==== sub table name: %s\n", pTblName);
+        count++;
+        if (count >= childTblCount - 1) {
+            char *tmp =
+                realloc(childTblName,
+                        (size_t)childTblCount * 1.5 * TSDB_TABLE_NAME_LEN + 1);
+            if (tmp != NULL) {
+                childTblName = tmp;
+                childTblCount = (int)(childTblCount * 1.5);
+                memset(childTblName + count * TSDB_TABLE_NAME_LEN, 0,
+                       (size_t)((childTblCount - count) * TSDB_TABLE_NAME_LEN));
+            } else {
+                // exit, if allocate more memory failed
+                tmfree(childTblName);
+                taos_free_result(res);
+                taos_close(taos);
+                errorPrint(
+                    "%s() LN%d, realloc fail for save child table name of "
+                    "%s.%s\n",
+                    __func__, __LINE__, dbName, stbName);
+                exit(EXIT_FAILURE);
+            }
+        }
+        pTblName = childTblName + count * TSDB_TABLE_NAME_LEN;
+    }
+
+    *childTblCountOfSuperTbl = count;
+    *childTblNameOfSuperTbl = childTblName;
+
+    taos_free_result(res);
+    return 0;
+}
+
+int getAllChildNameOfSuperTable(TAOS *taos, char *dbName, char *stbName,
+                                char **  childTblNameOfSuperTbl,
+                                int64_t *childTblCountOfSuperTbl) {
+    return getChildNameOfSuperTableWithLimitAndOffset(
+        taos, dbName, stbName, childTblNameOfSuperTbl, childTblCountOfSuperTbl,
+        -1, 0, false);
+}
+
+void printStatPerThread(threadInfo *pThreadInfo) {
+    if (0 == pThreadInfo->totalDelay) pThreadInfo->totalDelay = 1;
+
+    fprintf(stderr,
+            "====thread[%d] completed total inserted rows: %" PRIu64
+            ", total affected rows: %" PRIu64 ". %.2f records/second====\n",
+            pThreadInfo->threadID, pThreadInfo->totalInsertRows,
+            pThreadInfo->totalAffectedRows,
+            (double)(pThreadInfo->totalAffectedRows /
+                     ((double)pThreadInfo->totalDelay / 1000000.0)));
+}
+
+int convertHostToServAddr(char *host, uint16_t port,
+                          struct sockaddr_in *serv_addr) {
+    uint16_t        rest_port = port + TSDB_PORT_HTTP;
+    struct hostent *server = gethostbyname(host);
+    if ((server == NULL) || (server->h_addr == NULL)) {
+        errorPrint("%s", "no such host");
+        return -1;
+    }
+
+    debugPrint("h_name: %s\nh_addr=%p\nh_addretype: %s\nh_length: %d\n",
+               server->h_name, server->h_addr,
+               (server->h_addrtype == AF_INET) ? "ipv4" : "ipv6",
+               server->h_length);
+
+    memset(serv_addr, 0, sizeof(struct sockaddr_in));
+    serv_addr->sin_family = AF_INET;
+    serv_addr->sin_port = htons(rest_port);
+#ifdef WINDOWS
+    serv_addr->sin_addr.s_addr = inet_addr(host);
+#else
+    memcpy(&(serv_addr->sin_addr.s_addr), server->h_addr, server->h_length);
+#endif
+    return 0;
+}
+
+void prompt() {
+    if (!g_args.answer_yes) {
+        printf("         Press enter key to continue or Ctrl-C to stop\n\n");
+        (void)getchar();
+    }
+}
+
+void replaceChildTblName(char *inSql, char *outSql, int tblIndex) {
+    char sourceString[32] = "xxxx";
+    char subTblName[TSDB_TABLE_NAME_LEN];
+    sprintf(subTblName, "%s.%s", g_queryInfo.dbName,
+            g_queryInfo.superQueryInfo.childTblName +
+                tblIndex * TSDB_TABLE_NAME_LEN);
+
+    // printf("inSql: %s\n", inSql);
+
+    char *pos = strstr(inSql, sourceString);
+    if (0 == pos) {
+        return;
+    }
+
+    tstrncpy(outSql, inSql, pos - inSql + 1);
+    // printf("1: %s\n", outSql);
+    strncat(outSql, subTblName, BUFFER_SIZE - 1);
+    // printf("2: %s\n", outSql);
+    strncat(outSql, pos + strlen(sourceString), BUFFER_SIZE - 1);
+    // printf("3: %s\n", outSql);
+}
+
+int isCommentLine(char *line) {
+    if (line == NULL) return 1;
+
+    return regexMatch(line, "^\\s*#.*", REG_EXTENDED);
+}
+
+int regexMatch(const char *s, const char *reg, int cflags) {
+    regex_t regex;
+    char    msgbuf[100] = {0};
+
+    /* Compile regular expression */
+    if (regcomp(&regex, reg, cflags) != 0) {
+        ERROR_EXIT("Fail to compile regex\n");
+    }
+
+    /* Execute regular expression */
+    int reti = regexec(&regex, s, 0, NULL, 0);
+    if (!reti) {
+        regfree(&regex);
+        return 1;
+    } else if (reti == REG_NOMATCH) {
+        regfree(&regex);
+        return 0;
+    } else {
+        regerror(reti, &regex, msgbuf, sizeof(msgbuf));
+        regfree(&regex);
+        printf("Regex match failed: %s\n", msgbuf);
+        exit(EXIT_FAILURE);
+    }
+    return 0;
+}
+
+int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
+    verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
+
+    TAOS_RES *res = taos_query(taos, command);
+    int32_t   code = taos_errno(res);
+
+    if (code != 0) {
+        if (!quiet) {
+            errorPrint("Failed to execute <%s>, reason: %s\n", command,
+                       taos_errstr(res));
+        }
+        taos_free_result(res);
+        // taos_close(taos);
+        return -1;
+    }
+
+    if (INSERT_TYPE == type) {
+        int affectedRows = taos_affected_rows(res);
+        taos_free_result(res);
+        return affectedRows;
+    }
+
+    taos_free_result(res);
+    return 0;
+}
+
+void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo) {
+    pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
+    if (pThreadInfo->fp == NULL) {
+        errorPrint(
+            "%s() LN%d, failed to open result file: %s, result will not save "
+            "to file\n",
+            __func__, __LINE__, pThreadInfo->filePath);
+        return;
+    }
+
+    fprintf(pThreadInfo->fp, "%s", resultBuf);
+    tmfclose(pThreadInfo->fp);
+    pThreadInfo->fp = NULL;
+}
+
+int postProceSql(char *host, uint16_t port, char *sqlstr,
+                 threadInfo *pThreadInfo) {
+    char *req_fmt =
+        "POST %s HTTP/1.1\r\nHost: %s:%d\r\nAccept: */*\r\nAuthorization: "
+        "Basic %s\r\nContent-Length: %d\r\nContent-Type: "
+        "application/x-www-form-urlencoded\r\n\r\n%s";
+
+    char *url = "/rest/sql";
+
+    int      bytes, sent, received, req_str_len, resp_len;
+    char *   request_buf;
+    char     response_buf[RESP_BUF_LEN];
+    uint16_t rest_port = port + TSDB_PORT_HTTP;
+
+    int req_buf_len = strlen(sqlstr) + REQ_EXTRA_BUF_LEN;
+
+    request_buf = malloc(req_buf_len);
+    if (NULL == request_buf) {
+        errorPrint("%s", "cannot allocate memory.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    char userpass_buf[INPUT_BUF_LEN];
+    int  mod_table[] = {0, 2, 1};
+
+    static char base64[] = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
+
+    if (g_args.test_mode == INSERT_TEST) {
+        snprintf(userpass_buf, INPUT_BUF_LEN, "%s:%s", g_Dbs.user,
+                 g_Dbs.password);
+    } else {
+        snprintf(userpass_buf, INPUT_BUF_LEN, "%s:%s", g_queryInfo.user,
+                 g_queryInfo.password);
+    }
+
+    size_t userpass_buf_len = strlen(userpass_buf);
+    size_t encoded_len = 4 * ((userpass_buf_len + 2) / 3);
+
+    char base64_buf[INPUT_BUF_LEN];
+
+    memset(base64_buf, 0, INPUT_BUF_LEN);
+
+    for (int n = 0, m = 0; n < userpass_buf_len;) {
+        uint32_t oct_a =
+            n < userpass_buf_len ? (unsigned char)userpass_buf[n++] : 0;
+        uint32_t oct_b =
+            n < userpass_buf_len ? (unsigned char)userpass_buf[n++] : 0;
+        uint32_t oct_c =
+            n < userpass_buf_len ? (unsigned char)userpass_buf[n++] : 0;
+        uint32_t triple = (oct_a << 0x10) + (oct_b << 0x08) + oct_c;
+
+        base64_buf[m++] = base64[(triple >> 3 * 6) & 0x3f];
+        base64_buf[m++] = base64[(triple >> 2 * 6) & 0x3f];
+        base64_buf[m++] = base64[(triple >> 1 * 6) & 0x3f];
+        base64_buf[m++] = base64[(triple >> 0 * 6) & 0x3f];
+    }
+
+    for (int l = 0; l < mod_table[userpass_buf_len % 3]; l++)
+        base64_buf[encoded_len - 1 - l] = '=';
+
+    debugPrint("%s() LN%d: auth string base64 encoded: %s\n", __func__,
+               __LINE__, base64_buf);
+    char *auth = base64_buf;
+
+    int r = snprintf(request_buf, req_buf_len, req_fmt, url, host, rest_port,
+                     auth, strlen(sqlstr), sqlstr);
+    if (r >= req_buf_len) {
+        free(request_buf);
+        ERROR_EXIT("too long request");
+    }
+    verbosePrint("%s() LN%d: Request:\n%s\n", __func__, __LINE__, request_buf);
+
+    req_str_len = strlen(request_buf);
+    sent = 0;
+    do {
+#ifdef WINDOWS
+        bytes = send(pThreadInfo->sockfd, request_buf + sent,
+                     req_str_len - sent, 0);
+#else
+        bytes =
+            write(pThreadInfo->sockfd, request_buf + sent, req_str_len - sent);
+#endif
+        if (bytes < 0) ERROR_EXIT("writing message to socket");
+        if (bytes == 0) break;
+        sent += bytes;
+    } while (sent < req_str_len);
+
+    memset(response_buf, 0, RESP_BUF_LEN);
+    resp_len = sizeof(response_buf) - 1;
+    received = 0;
+
+    char resEncodingChunk[] = "Encoding: chunked";
+    char resHttp[] = "HTTP/1.1 ";
+    char resHttpOk[] = "HTTP/1.1 200 OK";
+
+    do {
+#ifdef WINDOWS
+        bytes = recv(pThreadInfo->sockfd, response_buf + received,
+                     resp_len - received, 0);
+#else
+        bytes = read(pThreadInfo->sockfd, response_buf + received,
+                     resp_len - received);
+#endif
+        verbosePrint("%s() LN%d: bytes:%d\n", __func__, __LINE__, bytes);
+        if (bytes < 0) {
+            free(request_buf);
+            ERROR_EXIT("reading response from socket");
+        }
+        if (bytes == 0) break;
+        received += bytes;
+
+        verbosePrint("%s() LN%d: received:%d resp_len:%d, response_buf:\n%s\n",
+                     __func__, __LINE__, received, resp_len, response_buf);
+
+        response_buf[RESP_BUF_LEN - 1] = '\0';
+        if (strlen(response_buf)) {
+            verbosePrint(
+                "%s() LN%d: received:%d resp_len:%d, response_buf:\n%s\n",
+                __func__, __LINE__, received, resp_len, response_buf);
+
+            if (((NULL != strstr(response_buf, resEncodingChunk)) &&
+                 (NULL != strstr(response_buf, resHttp))) ||
+                ((NULL != strstr(response_buf, resHttpOk)) &&
+                 (NULL != strstr(response_buf, "\"status\":")))) {
+                debugPrint(
+                    "%s() LN%d: received:%d resp_len:%d, response_buf:\n%s\n",
+                    __func__, __LINE__, received, resp_len, response_buf);
+                break;
+            }
+        }
+    } while (received < resp_len);
+
+    if (received == resp_len) {
+        free(request_buf);
+        ERROR_EXIT("storing complete response from socket");
+    }
+
+    if (strlen(pThreadInfo->filePath) > 0) {
+        appendResultBufToFile(response_buf, pThreadInfo);
+    }
+
+    free(request_buf);
+
+    if (NULL == strstr(response_buf, resHttpOk)) {
+        errorPrint("%s() LN%d, Response:\n%s\n", __func__, __LINE__,
+                   response_buf);
+        return -1;
+    }
+    return 0;
+}
+
+void fetchResult(TAOS_RES *res, threadInfo *pThreadInfo) {
+    TAOS_ROW    row = NULL;
+    int         num_rows = 0;
+    int         num_fields = taos_field_count(res);
+    TAOS_FIELD *fields = taos_fetch_fields(res);
+
+    char *databuf = (char *)calloc(1, FETCH_BUFFER_SIZE);
+    if (databuf == NULL) {
+        errorPrint(
+            "%s() LN%d, failed to malloc, warning: save result to file "
+            "slowly!\n",
+            __func__, __LINE__);
+        return;
+    }
+
+    int64_t totalLen = 0;
+
+    // fetch the records row by row
+    while ((row = taos_fetch_row(res))) {
+        if (totalLen >= (FETCH_BUFFER_SIZE - HEAD_BUFF_LEN * 2)) {
+            if (strlen(pThreadInfo->filePath) > 0)
+                appendResultBufToFile(databuf, pThreadInfo);
+            totalLen = 0;
+            memset(databuf, 0, FETCH_BUFFER_SIZE);
+        }
+        num_rows++;
+        char temp[HEAD_BUFF_LEN] = {0};
+        int  len = taos_print_row(temp, row, fields, num_fields);
+        len += sprintf(temp + len, "\n");
+        // printf("query result:%s\n", temp);
+        memcpy(databuf + totalLen, temp, len);
+        totalLen += len;
+        verbosePrint("%s() LN%d, totalLen: %" PRId64 "\n", __func__, __LINE__,
+                     totalLen);
+    }
+
+    verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n", __func__, __LINE__,
+                 databuf, pThreadInfo->filePath);
+    if (strlen(pThreadInfo->filePath) > 0) {
+        appendResultBufToFile(databuf, pThreadInfo);
+    }
+    free(databuf);
+}
\ No newline at end of file