taosdemo.c 313.3 KB
Newer Older
S
TD-1057  
Shengliang Guan 已提交
1
/*
H
hzcheng 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15
 * 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/>.
 */

16 17 18

/*
   when in some thread query return error, thread don't exit, but return, otherwise coredump in other thread.
19
   */
20

21
#include <stdint.h>
22
#include <taos.h>
S
slguan 已提交
23
#define _GNU_SOURCE
24 25
#define CURL_STATICLIB

S
TD-1057  
Shengliang Guan 已提交
26
#ifdef LINUX
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
#include <argp.h>
#include <inttypes.h>
#ifndef _ALPINE
#include <error.h>
#endif
#include <pthread.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>
#include <regex.h>
42
#else
43 44
#include <regex.h>
#include <stdio.h>
45
#endif
H
hzcheng 已提交
46

47
#include <assert.h>
48
#include <stdlib.h>
49 50
#include "cJSON.h"

51
#include "os.h"
H
hzcheng 已提交
52
#include "taos.h"
53
#include "taoserror.h"
H
Hui Li 已提交
54
#include "tutil.h"
S
slguan 已提交
55

56
#define STMT_IFACE_ENABLED  1
57
#define NANO_SECOND_ENABLED  1
58 59 60 61 62
#define SET_THREADNAME_ENABLED  1

#if SET_THREADNAME_ENABLED == 0
#define setThreadName(name)
#endif
63

64 65 66
#define REQ_EXTRA_BUF_LEN   1024
#define RESP_BUF_LEN        4096

S
slguan 已提交
67 68
extern char configDir[];

69 70
#define STR_INSERT_INTO     "INSERT INTO "

71 72
#define MAX_RECORDS_PER_REQ     32766

73
#define HEAD_BUFF_LEN       TSDB_MAX_COLUMNS*24  // 16*MAX_COLUMNS + (192+32)*2 + insert into ..
74

75
#define BUFFER_SIZE         TSDB_MAX_ALLOWED_SQL_LEN
76
#define COND_BUF_LEN        (BUFFER_SIZE - 30)
77
#define COL_BUFFER_LEN      ((TSDB_COL_NAME_LEN + 15) * TSDB_MAX_COLUMNS)
78 79
#define MAX_USERNAME_SIZE  64
#define MAX_PASSWORD_SIZE  64
80
#define MAX_HOSTNAME_SIZE  253      // https://man7.org/linux/man-pages/man7/hostname.7.html
81
#define MAX_TB_NAME_SIZE   64
82
#define MAX_DATA_SIZE      (16*TSDB_MAX_COLUMNS)+20     // max record len: 16*MAX_COLUMNS, timestamp string and ,('') need extra space
83
#define OPT_ABORT          1 /* –abort */
84
#define MAX_FILE_NAME_LEN  256              // max file name length on linux is 255.
85

86 87 88 89 90 91 92 93 94 95
#define MAX_PREPARED_RAND  1000000
#define INT_BUFF_LEN            11
#define BIGINT_BUFF_LEN         21
#define SMALLINT_BUFF_LEN       6
#define TINYINT_BUFF_LEN        4
#define BOOL_BUFF_LEN           6
#define FLOAT_BUFF_LEN          22
#define DOUBLE_BUFF_LEN         42
#define TIMESTAMP_BUFF_LEN      21

96 97
#define MAX_SAMPLES_ONCE_FROM_FILE   10000
#define MAX_NUM_COLUMNS        (TSDB_MAX_COLUMNS - 1)      // exclude first column timestamp
98

99 100
#define MAX_DB_COUNT            8
#define MAX_SUPER_TABLE_COUNT   200
101

102
#define MAX_QUERY_SQL_COUNT     100
103

104 105
#define MAX_DATABASE_COUNT      256
#define INPUT_BUF_LEN           256
106

107 108 109 110 111
#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)

112
#define DEFAULT_TIMESTAMP_STEP  1
113

114

115 116 117 118 119 120 121
enum TEST_MODE {
    INSERT_TEST,            // 0
    QUERY_TEST,             // 1
    SUBSCRIBE_TEST,         // 2
    INVAID_TEST
};

122
typedef enum CREATE_SUB_TALBE_MOD_EN {
123 124 125
    PRE_CREATE_SUBTBL,
    AUTO_CREATE_SUBTBL,
    NO_CREATE_SUBTBL
126
} CREATE_SUB_TALBE_MOD_EN;
127

128
typedef enum TALBE_EXISTS_EN {
129 130 131
    TBL_NO_EXISTS,
    TBL_ALREADY_EXISTS,
    TBL_EXISTS_BUTT
132 133
} TALBE_EXISTS_EN;

134
enum enumSYNC_MODE {
135 136 137
    SYNC_MODE,
    ASYNC_MODE,
    MODE_BUT
138
};
139

S
Shuduo Sang 已提交
140
enum enum_TAOS_INTERFACE {
141 142 143
    TAOSC_IFACE,
    REST_IFACE,
    STMT_IFACE,
144 145 146
    INTERFACE_BUT
};

147 148 149 150 151 152
typedef enum enumQUERY_CLASS {
    SPECIFIED_CLASS,
    STABLE_CLASS,
    CLASS_BUT
} QUERY_CLASS;

S
Shuduo Sang 已提交
153
typedef enum enum_PROGRESSIVE_OR_INTERLACE {
154 155 156
    PROGRESSIVE_INSERT_MODE,
    INTERLACE_INSERT_MODE,
    INVALID_INSERT_MODE
157
} PROG_OR_INTERLACE_MODE;
158

159
typedef enum enumQUERY_TYPE {
160 161 162
    NO_INSERT_TYPE,
    INSERT_TYPE,
    QUERY_TYPE_BUT
163
} QUERY_TYPE;
164 165

enum _show_db_index {
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
    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
186 187 188 189
};

// -----------------------------------------SHOW TABLES CONFIGURE -------------------------------------
enum _show_stables_index {
190 191 192 193 194 195 196 197
    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
198 199
};

200
enum _describe_table_index {
201 202 203 204 205
    TSDB_DESCRIBE_METRIC_FIELD_INDEX,
    TSDB_DESCRIBE_METRIC_TYPE_INDEX,
    TSDB_DESCRIBE_METRIC_LENGTH_INDEX,
    TSDB_DESCRIBE_METRIC_NOTE_INDEX,
    TSDB_MAX_DESCRIBE_METRIC
206 207
};

H
hzcheng 已提交
208
/* Used by main to communicate with parse_opt. */
209 210
static char *g_dupstr = NULL;

211
typedef struct SArguments_S {
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
    char *   metaFile;
    uint32_t test_mode;
    char *   host;
    uint16_t port;
    uint16_t iface;
    char *   user;
    char *   password;
    char *   database;
    int      replica;
    char *   tb_prefix;
    char *   sqlFile;
    bool     use_metric;
    bool     drop_database;
    bool     insert_only;
    bool     answer_yes;
    bool     debug_print;
    bool     verbose_print;
    bool     performance_print;
    char *   output_file;
    bool     async_mode;
232
    char *   datatype[MAX_NUM_COLUMNS + 1];
233 234 235 236
    uint32_t len_of_binary;
    uint32_t num_of_CPR;
    uint32_t num_of_threads;
    uint64_t insert_interval;
237
    uint64_t timestamp_step;
238 239 240 241 242 243 244 245
    int64_t  query_times;
    uint32_t interlace_rows;
    uint32_t num_of_RPR;                  // num_of_records_per_req
    uint64_t max_sql_len;
    int64_t  num_of_tables;
    int64_t  num_of_DPT;
    int      abort;
    uint32_t disorderRatio;               // 0: no disorder, >0: x%
246
    int      disorderRange;               // ms, us or ns. accordig to database precision
247 248 249 250 251
    uint32_t method_of_delete;
    char **  arg_list;
    uint64_t totalInsertRows;
    uint64_t totalAffectedRows;
    bool     demo_mode;                  // use default column name and semi-random data
252 253 254
} SArguments;

typedef struct SColumn_S {
255
    char      field[TSDB_COL_NAME_LEN];
256
    char      dataType[DATATYPE_BUFF_LEN];
257
    uint32_t  dataLen;
258
    char      note[NOTE_BUFF_LEN];
259 260 261
} StrColumn;

typedef struct SSuperTable_S {
262
    char         sTblName[TSDB_TABLE_NAME_LEN];
263 264
    char         dataSource[SMALL_BUFF_LEN];  // rand_gen or sample
    char         childTblPrefix[TBNAME_PREFIX_LEN];
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
    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];
283
    char         sampleFormat[SMALL_BUFF_LEN];  // csv, json
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
    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;
    char*        colsOfCreateChildTable;
    uint64_t     lenOfOneRow;
    uint64_t     lenOfTagOfOneRow;

    char*        sampleDataBuf;
    //int          sampleRowCount;
    //int          sampleUsePos;

    uint32_t     tagSource;    // 0: rand, 1: tag sample
    char*        tagDataBuf;
    uint32_t     tagSampleCount;
    uint32_t     tagUsePos;

    // statistics
    uint64_t     totalInsertRows;
    uint64_t     totalAffectedRows;
309 310 311
} SSuperTable;

typedef struct {
312 313 314 315 316 317 318
    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;
319
    char     keeplist[64];
320 321 322 323 324 325 326 327
    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;
328
    char     precision[SMALL_BUFF_LEN];   // time resolution
329 330
    int8_t   update;
    char     status[16];
331 332
} SDbInfo;

333
typedef struct SDbCfg_S {
334 335 336 337 338 339 340 341 342 343 344 345 346 347
    //  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;
348
    char      precision[SMALL_BUFF_LEN];
349 350 351
} SDbCfg;

typedef struct SDataBase_S {
352 353 354 355 356
    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[MAX_SUPER_TABLE_COUNT];
357 358 359
} SDataBase;

typedef struct SDbs_S {
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
    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[MAX_PASSWORD_SIZE];
    char        resultFile[MAX_FILE_NAME_LEN];
    bool        use_metric;
    bool        insert_only;
    bool        do_aggreFunc;
    bool        asyncMode;

    uint32_t    threadCount;
    uint32_t    threadCountByCreateTbl;
    uint32_t    dbCount;
    SDataBase   db[MAX_DB_COUNT];

    // statistics
    uint64_t    totalInsertRows;
    uint64_t    totalAffectedRows;
381

382 383
} SDbs;

384
typedef struct SpecifiedQueryInfo_S {
385 386 387 388 389 390 391 392
    uint64_t     queryInterval;  // 0: unlimit  > 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;
393
    char         sql[MAX_QUERY_SQL_COUNT][BUFFER_SIZE+1];
394 395 396 397 398 399 400 401
    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;
402
} SpecifiedQueryInfo;
403

404
typedef struct SuperQueryInfo_S {
405 406 407 408 409 410 411 412 413
    char         sTblName[TSDB_TABLE_NAME_LEN];
    uint64_t     queryInterval;  // 0: unlimit  > 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;
414
    char         childTblPrefix[TBNAME_PREFIX_LEN];    // 20 characters reserved for seq
415
    int          sqlCount;
416
    char         sql[MAX_QUERY_SQL_COUNT][BUFFER_SIZE+1];
417 418 419 420 421 422 423
    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;
424
} SuperQueryInfo;
425 426

typedef struct SQueryMetaInfo_S {
427 428 429 430 431 432 433
    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[MAX_PASSWORD_SIZE];
    char         dbName[TSDB_DB_NAME_LEN];
434
    char         queryMode[SMALL_BUFF_LEN];  // taosc, rest
435 436 437 438

    SpecifiedQueryInfo  specifiedQueryInfo;
    SuperQueryInfo      superQueryInfo;
    uint64_t     totalQueried;
439 440 441
} SQueryMetaInfo;

typedef struct SThreadInfo_S {
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
    TAOS *    taos;
    TAOS_STMT *stmt;
    int       threadID;
    char      db_name[TSDB_DB_NAME_LEN];
    uint32_t  time_precision;
    char      filePath[4096];
    FILE      *fp;
    char      tb_prefix[TSDB_TABLE_NAME_LEN];
    uint64_t  start_table_from;
    uint64_t  end_table_to;
    int64_t   ntables;
    uint64_t  data_of_rate;
    int64_t   start_time;
    char*     cols;
    bool      use_metric;
    SSuperTable* superTblInfo;
    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;
483

484 485
} threadInfo;

486
#ifdef WINDOWS
487 488
#define _CRT_RAND_S

489
#include <windows.h>
490 491 492 493 494
#include <winsock2.h>

typedef unsigned __int32 uint32_t;

#pragma comment ( lib, "ws2_32.lib" )
495 496
// Some old MinGW/CYGWIN distributions don't define this:
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
497
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING  0x0004
498
#endif // ENABLE_VIRTUAL_TERMINAL_PROCESSING
499 500 501 502

static HANDLE g_stdoutHandle;
static DWORD g_consoleMode;

503
static void setupForAnsiEscape(void) {
504 505
    DWORD mode = 0;
    g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
506

507 508 509
    if(g_stdoutHandle == INVALID_HANDLE_VALUE) {
        exit(GetLastError());
    }
510

511 512 513
    if(!GetConsoleMode(g_stdoutHandle, &mode)) {
        exit(GetLastError());
    }
514

515
    g_consoleMode = mode;
516

517 518
    // Enable ANSI escape codes
    mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
519

520 521 522
    if(!SetConsoleMode(g_stdoutHandle, mode)) {
        exit(GetLastError());
    }
523 524
}

525
static void resetAfterAnsiEscape(void) {
526 527
    // Reset colors
    printf("\x1b[0m");
528

529 530 531 532
    // Reset console mode
    if(!SetConsoleMode(g_stdoutHandle, g_consoleMode)) {
        exit(GetLastError());
    }
533
}
534

535
static int taosRandom()
536 537 538 539 540 541
{
    int number;
    rand_s(&number);

    return number;
}
542
#else   // Not windows
543
static void setupForAnsiEscape(void) {}
544

545
static void resetAfterAnsiEscape(void) {
546 547
    // Reset colors
    printf("\x1b[0m");
548
}
549

550 551
#include <time.h>

552
static int taosRandom()
553
{
554
    return rand();
555 556
}

557
#endif // ifdef Windows
558

559
static void prompt();
560
static int createDatabasesAndStables();
561
static void createChildTables();
562
static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet);
563
static int postProceSql(char *host, struct sockaddr_in *pServAddr,
564
        uint16_t port, char* sqlstr, threadInfo *pThreadInfo);
565 566
static int64_t getTSRandTail(int64_t timeStampStep, int32_t seq,
        int disorderRatio, int disorderRange);
567 568
static bool getInfoFromJsonFile(char* file);
static void init_rand_data();
569 570 571

/* ************ Global variables ************  */

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
int32_t  g_randint[MAX_PREPARED_RAND];
int64_t  g_randbigint[MAX_PREPARED_RAND];
float    g_randfloat[MAX_PREPARED_RAND];
double   g_randdouble[MAX_PREPARED_RAND];

char    *g_randbool_buff = NULL;
char    *g_randint_buff = NULL;
char    *g_rand_voltage_buff = NULL;
char    *g_randbigint_buff = NULL;
char    *g_randsmallint_buff = NULL;
char    *g_randtinyint_buff = NULL;
char    *g_randfloat_buff = NULL;
char    *g_rand_current_buff = NULL;
char    *g_rand_phase_buff = NULL;
char    *g_randdouble_buff = NULL;

char    *g_aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
589 590
    "max(col0)", "min(col0)", "first(col0)", "last(col0)"};

591 592
#define DEFAULT_DATATYPE_NUM    3

593
SArguments g_args = {
594 595 596 597
    NULL,            // metaFile
    0,               // test_mode
    "127.0.0.1",     // host
    6030,            // port
598
    INTERFACE_BUT,   // iface
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
    "root",          // user
#ifdef _TD_POWER_
    "powerdb",      // password
#elif (_TD_TQ_ == true)
    "tqueue",      // password
#else
    "taosdata",      // password
#endif
    "test",          // database
    1,               // replica
    "d",             // tb_prefix
    NULL,            // sqlFile
    true,            // use_metric
    true,            // drop_database
    true,            // insert_only
    false,           // debug_print
    false,           // verbose_print
    false,           // performance statistic print
    false,           // answer_yes;
    "./output.txt",  // output_file
    0,               // mode : sync or async
    {
        "FLOAT",         // datatype
        "INT",           // datatype
623
        "FLOAT",         // datatype. DEFAULT_DATATYPE_NUM is 3
624 625 626 627 628
    },
    16,              // len_of_binary
    4,               // num_of_CPR
    10,              // num_of_connections/thread
    0,               // insert_interval
629
    DEFAULT_TIMESTAMP_STEP, // timestamp_step
630 631 632 633 634 635 636 637 638 639 640 641 642 643
    1,               // query_times
    0,               // interlace_rows;
    30000,           // num_of_RPR
    (1024*1024),     // max_sql_len
    10000,           // num_of_tables
    10000,           // num_of_DPT
    0,               // abort
    0,               // disorderRatio
    1000,            // disorderRange
    1,               // method_of_delete
    NULL,            // arg_list
    0,               // totalInsertRows;
    0,               // totalAffectedRows;
    true,            // demo_mode;
644 645 646 647 648
};



static SDbs            g_Dbs;
649
static int64_t         g_totalChildTables = 0;
650 651 652
static SQueryMetaInfo  g_queryInfo;
static FILE *          g_fpOfInsertResult = NULL;

653 654 655 656
#if _MSC_VER <= 1900
#define __func__ __FUNCTION__
#endif

657
#define debugPrint(fmt, ...) \
658
    do { if (g_args.debug_print || g_args.verbose_print) \
659
        fprintf(stderr, "DEBG: "fmt, __VA_ARGS__); } while(0)
660

661
#define verbosePrint(fmt, ...) \
662 663
    do { if (g_args.verbose_print) \
        fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0)
664

665 666
#define performancePrint(fmt, ...) \
    do { if (g_args.performance_print) \
667
        fprintf(stderr, "PERF: "fmt, __VA_ARGS__); } while(0)
668

669
#define errorPrint(fmt, ...) \
670
    do { fprintf(stderr, " \033[31m"); fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); fprintf(stderr, " \033[0m"); } while(0)
671

672 673 674
// for strncpy buffer overflow
#define min(a, b) (((a) < (b)) ? (a) : (b))

675

676
///////////////////////////////////////////////////
H
hzcheng 已提交
677

678 679
static void ERROR_EXIT(const char *msg) { perror(msg); exit(-1); }

680 681 682 683 684 685 686 687
#ifndef TAOSDEMO_COMMIT_SHA1
#define TAOSDEMO_COMMIT_SHA1 "unknown"
#endif

#ifndef TD_VERNUMBER
#define TD_VERNUMBER    "unknown"
#endif

688
#ifndef TAOSDEMO_STATUS
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
#define TAOSDEMO_STATUS "unknown"
#endif

static 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 verison %s-%s\n",
                tdengine_ver, taosdemo_ver);
    } else {
        printf("taosdemo verison %s-%s, status:%s\n",
                tdengine_ver, taosdemo_ver, taosdemo_status);
    }
}

706
static void printHelp() {
707 708 709 710 711
    char indent[10] = "        ";
    printf("%s%s%s%s\n", indent, "-f", indent,
            "The meta file to the execution procedure. Default is './meta.json'.");
    printf("%s%s%s%s\n", indent, "-u", indent,
            "The TDengine user name to use when connecting to the server. Default is 'root'.");
712
#ifdef _TD_POWER_
713 714 715 716
    printf("%s%s%s%s\n", indent, "-P", indent,
            "The password to use when connecting to the server. Default is 'powerdb'.");
    printf("%s%s%s%s\n", indent, "-c", indent,
            "Configuration directory. Default is '/etc/power/'.");
717
#elif (_TD_TQ_ == true)
718 719 720 721
    printf("%s%s%s%s\n", indent, "-P", indent,
            "The password to use when connecting to the server. Default is 'tqueue'.");
    printf("%s%s%s%s\n", indent, "-c", indent,
            "Configuration directory. Default is '/etc/tq/'.");
722
#else
723 724 725 726
    printf("%s%s%s%s\n", indent, "-P", indent,
            "The password to use when connecting to the server. Default is 'taosdata'.");
    printf("%s%s%s%s\n", indent, "-c", indent,
            "Configuration directory. Default is '/etc/taos/'.");
727
#endif
728 729 730 731 732
    printf("%s%s%s%s\n", indent, "-h", indent,
            "The host to connect to TDengine. Default is localhost.");
    printf("%s%s%s%s\n", indent, "-p", indent,
            "The TCP/IP port number to use for the connection. Default is 0.");
    printf("%s%s%s%s\n", indent, "-I", indent,
733
#if STMT_IFACE_ENABLED == 1
734
            "The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
735
#else
736
    "The interface (taosc, rest) taosdemo uses. Default is 'taosc'.");
737
#endif
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
    printf("%s%s%s%s\n", indent, "-d", indent,
            "Destination database. Default is 'test'.");
    printf("%s%s%s%s\n", indent, "-a", indent,
            "Set the replica parameters of the database, Default 1, min: 1, max: 3.");
    printf("%s%s%s%s\n", indent, "-m", indent,
            "Table prefix name. Default is 'd'.");
    printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
    printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
    printf("%s%s%s%s\n", indent, "-o", indent,
            "Direct output to the named file. Default is './output.txt'.");
    printf("%s%s%s%s\n", indent, "-q", indent,
            "Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
    printf("%s%s%s%s\n", indent, "-b", indent,
            "The data_type of columns, default: FLOAT, INT, FLOAT.");
    printf("%s%s%s%s\n", indent, "-w", indent,
            "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
754 755 756 757 758 759 760
    printf("%s%s%s%s%d%s%d\n", indent, "-l", indent,
            "The number of columns per record. Default is ",
            DEFAULT_DATATYPE_NUM,
            ". Max values is ",
            MAX_NUM_COLUMNS);
    printf("%s%s%s%s\n", indent, indent, indent,
            "All of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
761 762 763 764
    printf("%s%s%s%s\n", indent, "-T", indent,
            "The number of threads. Default is 10.");
    printf("%s%s%s%s\n", indent, "-i", indent,
            "The sleep time (ms) between insertion. Default is 0.");
765 766
    printf("%s%s%s%s%d.\n", indent, "-S", indent,
            "The timestamp step between insertion. Default is ",
767
            DEFAULT_TIMESTAMP_STEP);
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
    printf("%s%s%s%s\n", indent, "-r", indent,
            "The number of records per request. Default is 30000.");
    printf("%s%s%s%s\n", indent, "-t", indent,
            "The number of tables. Default is 10000.");
    printf("%s%s%s%s\n", indent, "-n", indent,
            "The number of records per table. Default is 10000.");
    printf("%s%s%s%s\n", indent, "-M", indent,
            "The value of records generated are totally random.");
    printf("%s%s%s%s\n", indent, indent, indent,
            " The default is to simulate power equipment senario.");
    printf("%s%s%s%s\n", indent, "-x", indent, "Not insert only flag.");
    printf("%s%s%s%s\n", indent, "-y", indent, "Default input yes for prompt.");
    printf("%s%s%s%s\n", indent, "-O", indent,
            "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
    printf("%s%s%s%s\n", indent, "-R", indent,
            "Out of order data's range, ms, default is 1000.");
    printf("%s%s%s%s\n", indent, "-g", indent,
            "Print debug info.");
    printf("%s%s%s\n", indent, "-V, --version\t",
            "Print version info.");
    printf("%s%s%s%s\n", indent, "--help\t", indent,
            "Print command line arguments list info.");
    /*    printf("%s%s%s%s\n", indent, "-D", indent,
          "Delete database if exists. 0: no, 1: yes, default is 1");
792 793 794
          */
}

795 796
static bool isStringNumber(char *input)
{
797 798 799 800
    int len = strlen(input);
    if (0 == len) {
        return false;
    }
801

802 803 804 805
    for (int i = 0; i < len; i++) {
        if (!isdigit(input[i]))
            return false;
    }
806

807
    return true;
808 809
}

810
static void parse_args(int argc, char *argv[], SArguments *arguments) {
811

812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-f") == 0) {
            arguments->demo_mode = false;
            arguments->metaFile = argv[++i];
        } else if (strcmp(argv[i], "-c") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-c need a valid path following!\n");
                exit(EXIT_FAILURE);
            }
            tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
        } else if (strcmp(argv[i], "-h") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-h need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->host = argv[++i];
        } else if (strcmp(argv[i], "-p") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-p need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->port = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-I") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-I need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            ++i;
            if (0 == strcasecmp(argv[i], "taosc")) {
                arguments->iface = TAOSC_IFACE;
            } else if (0 == strcasecmp(argv[i], "rest")) {
                arguments->iface = REST_IFACE;
849
#if STMT_IFACE_ENABLED == 1
850 851
            } else if (0 == strcasecmp(argv[i], "stmt")) {
                arguments->iface = STMT_IFACE;
852
#endif
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
            } else {
                errorPrint("%s", "\n\t-I need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
        } else if (strcmp(argv[i], "-u") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-u need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->user = argv[++i];
        } else if (strcmp(argv[i], "-P") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-P need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->password = argv[++i];
        } else if (strcmp(argv[i], "-o") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-o need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->output_file = argv[++i];
        } else if (strcmp(argv[i], "-s") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-s need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->sqlFile = argv[++i];
        } else if (strcmp(argv[i], "-q") == 0) {
            if ((argc == i+1)
                    || (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
                exit(EXIT_FAILURE);
            }
            arguments->async_mode = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-T") == 0) {
            if ((argc == i+1)
                    || (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-T need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->num_of_threads = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-i") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-i need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->insert_interval = atoi(argv[++i]);
909 910 911 912 913 914 915 916
        } else if (strcmp(argv[i], "-S") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("\n\t%s%s", argv[i], " need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->timestamp_step = atoi(argv[++i]);
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
        } 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");
                exit(EXIT_FAILURE);
            }
            arguments->query_times = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-B") == 0) {
            if ((argc == i+1)
                    || (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-B need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->interlace_rows = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-r") == 0) {
            if ((argc == i+1)
                    || (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-r need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->num_of_RPR = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-t") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-t need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->num_of_tables = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-n") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-n need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->num_of_DPT = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-d") == 0) {
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-d need a valid string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->database = argv[++i];
        } else if (strcmp(argv[i], "-l") == 0) {
            arguments->demo_mode = false;
            if (argc == i+1) {
                if (!isStringNumber(argv[i+1])) {
                    printHelp();
                    errorPrint("%s", "\n\t-l need a number following!\n");
                    exit(EXIT_FAILURE);
                }
            }
            arguments->num_of_CPR = atoi(argv[++i]);
974

975 976
            if (arguments->num_of_CPR > MAX_NUM_COLUMNS) {
                printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_COLUMNS);
977
                prompt();
978
                arguments->num_of_CPR = MAX_NUM_COLUMNS;
979
            }
980

981 982 983 984
            for (int col = DEFAULT_DATATYPE_NUM; col < arguments->num_of_CPR; col ++) {
                arguments->datatype[col] = "INT";
            }
            for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
                arguments->datatype[col] = NULL;
            }
        } else if (strcmp(argv[i], "-b") == 0) {
            arguments->demo_mode = false;
            if (argc == i+1) {
                printHelp();
                errorPrint("%s", "\n\t-b need valid string following!\n");
                exit(EXIT_FAILURE);
            }
            ++i;
            if (strstr(argv[i], ",") == NULL) {
                // only one col
                if (strcasecmp(argv[i], "INT")
                        && strcasecmp(argv[i], "FLOAT")
                        && strcasecmp(argv[i], "TINYINT")
                        && strcasecmp(argv[i], "BOOL")
                        && strcasecmp(argv[i], "SMALLINT")
                        && strcasecmp(argv[i], "BIGINT")
                        && strcasecmp(argv[i], "DOUBLE")
                        && strcasecmp(argv[i], "BINARY")
                        && strcasecmp(argv[i], "TIMESTAMP")
                        && strcasecmp(argv[i], "NCHAR")) {
                    printHelp();
                    errorPrint("%s", "-b: Invalid data_type!\n");
                    exit(EXIT_FAILURE);
                }
                arguments->datatype[0] = argv[i];
            } else {
                // more than one col
                int index = 0;
                g_dupstr = strdup(argv[i]);
                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, "BINARY")
                            && strcasecmp(token, "TIMESTAMP")
                            && strcasecmp(token, "NCHAR")) {
                        printHelp();
                        free(g_dupstr);
                        errorPrint("%s", "-b: Invalid data_type!\n");
                        exit(EXIT_FAILURE);
                    }
                    arguments->datatype[index++] = token;
                    token = strsep(&running, ",");
1036
                    if (index >= MAX_NUM_COLUMNS) break;
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
                }
                arguments->datatype[index] = NULL;
            }
        } else if (strcmp(argv[i], "-w") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-w need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->len_of_binary = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-m") == 0) {
            if ((argc == i+1) ||
                    (isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->tb_prefix = argv[++i];
        } else if (strcmp(argv[i], "-N") == 0) {
            arguments->use_metric = false;
        } else if (strcmp(argv[i], "-M") == 0) {
            arguments->demo_mode = false;
        } else if (strcmp(argv[i], "-x") == 0) {
            arguments->insert_only = false;
        } else if (strcmp(argv[i], "-y") == 0) {
            arguments->answer_yes = true;
        } else if (strcmp(argv[i], "-g") == 0) {
            arguments->debug_print = true;
        } else if (strcmp(argv[i], "-gg") == 0) {
            arguments->verbose_print = true;
        } else if (strcmp(argv[i], "-pp") == 0) {
            arguments->performance_print = true;
        } else if (strcmp(argv[i], "-O") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-O need a number following!\n");
                exit(EXIT_FAILURE);
            }
1077

1078
            arguments->disorderRatio = atoi(argv[++i]);
1079

1080 1081 1082
            if (arguments->disorderRatio > 50) {
                arguments->disorderRatio = 50;
            }
1083

1084 1085 1086
            if (arguments->disorderRatio < 0) {
                arguments->disorderRatio = 0;
            }
1087

1088 1089 1090 1091 1092 1093 1094
        } else if (strcmp(argv[i], "-R") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-R need a number following!\n");
                exit(EXIT_FAILURE);
            }
1095

1096 1097 1098
            arguments->disorderRange = atoi(argv[++i]);
            if (arguments->disorderRange < 0)
                arguments->disorderRange = 1000;
1099

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
        } else if (strcmp(argv[i], "-a") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
                printHelp();
                errorPrint("%s", "\n\t-a need a number following!\n");
                exit(EXIT_FAILURE);
            }
            arguments->replica = atoi(argv[++i]);
            if (arguments->replica > 3 || 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 valud (0~3) number following!\n");
                exit(EXIT_FAILURE);
            }
        } else if ((strcmp(argv[i], "--version") == 0) ||
                (strcmp(argv[i], "-V") == 0)){
            printVersion();
            exit(0);
        } else if (strcmp(argv[i], "--help") == 0) {
            printHelp();
            exit(0);
        } else {
            printHelp();
            errorPrint("%s", "ERROR: wrong options\n");
            exit(EXIT_FAILURE);
        }
S
TD-1057  
Shengliang Guan 已提交
1129
    }
1130

1131
    int columnCount;
1132
    for (columnCount = 0; columnCount < MAX_NUM_COLUMNS; columnCount ++) {
1133 1134 1135
        if (g_args.datatype[columnCount] == NULL) {
            break;
        }
1136 1137
    }

1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
    if (0 == columnCount) {
        perror("data type error!");
        exit(-1);
    }
    g_args.num_of_CPR = columnCount;

    if (((arguments->debug_print) && (arguments->metaFile == NULL))
            || 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:               ");
1157
            for (int i = 0; i < MAX_NUM_COLUMNS; i++)
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
                if (arguments->datatype[i])
                    printf("%s,", arguments->datatype[i]);
                else
                    break;
            printf("\n");
        }
        printf("# Insertion interval:                %"PRIu64"\n",
                arguments->insert_interval);
        printf("# Number of records per req:         %u\n",
                arguments->num_of_RPR);
        printf("# Max SQL length:                    %"PRIu64"\n",
                arguments->max_sql_len);
        printf("# Length of Binary:                  %d\n", arguments->len_of_binary);
        printf("# Number of Threads:                 %d\n", arguments->num_of_threads);
        printf("# Number of Tables:                  %"PRId64"\n",
                arguments->num_of_tables);
        printf("# Number of Data per Table:          %"PRId64"\n",
                arguments->num_of_DPT);
        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();
1189
    }
1190
}
H
hzcheng 已提交
1191

1192
static void tmfclose(FILE *fp) {
1193 1194 1195
    if (NULL != fp) {
        fclose(fp);
    }
1196
}
1197

1198
static void tmfree(char *buf) {
1199 1200 1201
    if (NULL != buf) {
        free(buf);
    }
1202
}
H
Hui Li 已提交
1203

1204
static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
1205 1206 1207 1208 1209 1210 1211 1212 1213
    int i;
    TAOS_RES *res = NULL;
    int32_t   code = -1;

    for (i = 0; i < 5 /* retry */; i++) {
        if (NULL != res) {
            taos_free_result(res);
            res = NULL;
        }
1214

1215 1216 1217 1218 1219
        res = taos_query(taos, command);
        code = taos_errno(res);
        if (0 == code) {
            break;
        }
H
hzcheng 已提交
1220
    }
1221

1222 1223 1224 1225 1226 1227 1228 1229 1230
    verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
    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;
1231
    }
H
hzcheng 已提交
1232

1233 1234 1235 1236
    if (INSERT_TYPE == type) {
        int affectedRows = taos_affected_rows(res);
        taos_free_result(res);
        return affectedRows;
1237
    }
H
hzcheng 已提交
1238

1239
    taos_free_result(res);
1240
    return 0;
1241
}
H
hzcheng 已提交
1242

1243
static void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo)
1244
{
1245 1246 1247 1248 1249 1250 1251
    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;
    }
1252

1253 1254 1255
    fprintf(pThreadInfo->fp, "%s", resultBuf);
    tmfclose(pThreadInfo->fp);
    pThreadInfo->fp = NULL;
1256 1257
}

1258
static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
    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, 100*1024*1024);
    if (databuf == NULL) {
        errorPrint("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
                __func__, __LINE__);
        return ;
    }
H
hzcheng 已提交
1270

1271
    int64_t   totalLen = 0;
H
hzcheng 已提交
1272

1273 1274
    // fetch the records row by row
    while((row = taos_fetch_row(res))) {
1275
        if (totalLen >= (100*1024*1024 - HEAD_BUFF_LEN*2)) {
1276 1277 1278 1279 1280 1281
            if (strlen(pThreadInfo->filePath) > 0)
                appendResultBufToFile(databuf, pThreadInfo);
            totalLen = 0;
            memset(databuf, 0, 100*1024*1024);
        }
        num_rows++;
1282
        char  temp[HEAD_BUFF_LEN] = {0};
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
        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);
1298
}
H
hzcheng 已提交
1299

1300
static void selectAndGetResult(
1301 1302
        threadInfo *pThreadInfo, char *command)
{
1303 1304 1305 1306 1307 1308 1309 1310
    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;
        }
1311

1312 1313
        fetchResult(res, pThreadInfo);
        taos_free_result(res);
1314

1315 1316 1317 1318 1319 1320 1321 1322
    } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
        int retCode = postProceSql(
                g_queryInfo.host, &(g_queryInfo.serv_addr), g_queryInfo.port,
                command,
                pThreadInfo);
        if (0 != retCode) {
            printf("====restful return fail, threadID[%d]\n", pThreadInfo->threadID);
        }
1323

1324 1325 1326 1327
    } else {
        errorPrint("%s() LN%d, unknown query mode: %s\n",
                __func__, __LINE__, g_queryInfo.queryMode);
    }
1328
}
H
hzcheng 已提交
1329

1330 1331 1332 1333 1334 1335 1336
static char *rand_bool_str(){
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randbool_buff + (cursor * BOOL_BUFF_LEN);
}

1337
static int32_t rand_bool(){
1338 1339 1340
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1341
    return g_randint[cursor] % 2;
1342 1343
}

1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
static char *rand_tinyint_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randtinyint_buff + (cursor * TINYINT_BUFF_LEN);
}

static int32_t rand_tinyint()
{
1354 1355 1356
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1357 1358 1359 1360 1361 1362 1363 1364 1365
    return g_randint[cursor] % 128;
}

static char *rand_smallint_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randsmallint_buff + (cursor * SMALLINT_BUFF_LEN);
1366 1367
}

1368 1369
static int32_t rand_smallint()
{
1370 1371 1372
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1373
    return g_randint[cursor] % 32767;
1374 1375
}

1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
static char *rand_int_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randint_buff + (cursor * INT_BUFF_LEN);
}

static int32_t rand_int()
{
1386 1387 1388
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1389 1390 1391 1392 1393 1394 1395 1396 1397
    return g_randint[cursor];
}

static char *rand_bigint_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randbigint_buff + (cursor * BIGINT_BUFF_LEN);
1398 1399
}

1400 1401
static int64_t rand_bigint()
{
1402 1403 1404
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1405
    return g_randbigint[cursor];
1406 1407
}

1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
static char *rand_float_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randfloat_buff + (cursor * FLOAT_BUFF_LEN);
}

static float rand_float()
{
1418 1419 1420
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1421
    return g_randfloat[cursor];
1422 1423
}

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
static char *demo_current_float_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_rand_current_buff + (cursor * FLOAT_BUFF_LEN);
}

static float UNUSED_FUNC demo_current_float()
{
1434 1435 1436
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1437 1438 1439 1440 1441 1442 1443 1444 1445
    return (float)(9.8 + 0.04 * (g_randint[cursor] % 10) + g_randfloat[cursor]/1000000000);
}

static char *demo_voltage_int_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_rand_voltage_buff + (cursor * INT_BUFF_LEN);
1446 1447
}

1448 1449
static int32_t UNUSED_FUNC demo_voltage_int()
{
1450 1451 1452
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1453 1454 1455 1456 1457 1458 1459 1460
    return 215 + g_randint[cursor] % 10;
}

static char *demo_phase_float_str() {
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_rand_phase_buff + (cursor * FLOAT_BUFF_LEN);
1461 1462
}

1463
static float UNUSED_FUNC demo_phase_float(){
1464 1465 1466
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1467
    return (float)((115 + g_randint[cursor] % 10 + g_randfloat[cursor]/1000000000)/360);
1468 1469
}

1470 1471 1472 1473 1474 1475
#if 0
static const char charNum[] = "0123456789";

static void nonrand_string(char *, int) __attribute__ ((unused));   // reserve for debugging purpose
static void nonrand_string(char *str, int size)
{
1476 1477 1478 1479 1480 1481 1482 1483
    str[0] = 0;
    if (size > 0) {
        int n;
        for (n = 0; n < size; n++) {
            str[n] = charNum[n % 10];
        }
        str[n] = 0;
    }
1484 1485 1486
}
#endif

1487
static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
1488

1489
static void rand_string(char *str, int size) {
1490 1491 1492 1493 1494 1495 1496 1497 1498
    str[0] = 0;
    if (size > 0) {
        //--size;
        int n;
        for (n = 0; n < size; n++) {
            int key = abs(rand_tinyint()) % (int)(sizeof(charset) - 1);
            str[n] = charset[key];
        }
        str[n] = 0;
1499 1500 1501
    }
}

1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
static char *rand_double_str()
{
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randdouble_buff + (cursor * DOUBLE_BUFF_LEN);
}

static double rand_double()
{
1512 1513 1514
    static int cursor;
    cursor++;
    cursor = cursor % MAX_PREPARED_RAND;
1515
    return g_randdouble[cursor];
1516 1517 1518
}

static void init_rand_data() {
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540

    g_randint_buff = calloc(1, INT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randint_buff);
    g_rand_voltage_buff = calloc(1, INT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_rand_voltage_buff);
    g_randbigint_buff = calloc(1, BIGINT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randbigint_buff);
    g_randsmallint_buff = calloc(1, SMALLINT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randsmallint_buff);
    g_randtinyint_buff = calloc(1, TINYINT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randtinyint_buff);
    g_randbool_buff = calloc(1, BOOL_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randbool_buff);
    g_randfloat_buff = calloc(1, FLOAT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randfloat_buff);
    g_rand_current_buff = calloc(1, FLOAT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_rand_current_buff);
    g_rand_phase_buff = calloc(1, FLOAT_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_rand_phase_buff);
    g_randdouble_buff = calloc(1, DOUBLE_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randdouble_buff);

1541
    for (int i = 0; i < MAX_PREPARED_RAND; i++){
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
        g_randint[i] = (int)(taosRandom() % 65535);
        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] % 32767);
        sprintf(g_randtinyint_buff + i * TINYINT_BUFF_LEN, "%d",
                g_randint[i] % 128);

        g_randbigint[i] = (int64_t)(taosRandom() % 2147483648);
        sprintf(g_randbigint_buff + i * BIGINT_BUFF_LEN, "%"PRId64"",
                g_randbigint[i]);

        g_randfloat[i] = (float)(taosRandom() / 1000.0);
        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);
        sprintf(g_randdouble_buff + i * DOUBLE_BUFF_LEN, "%f",
                g_randdouble[i]);
1572
    }
1573 1574
}

1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
#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)

1595
static int printfInsertMeta() {
1596
    SHOW_PARSE_RESULT_START();
1597

1598 1599 1600 1601 1602
    if (g_args.demo_mode)
        printf("\ntaosdemo is simulating data generated by power equipments monitoring...\n\n");
    else
        printf("\ntaosdemo is simulating random data as you request..\n\n");

1603 1604 1605
    if (g_args.iface != INTERFACE_BUT) {
        // first time if no iface specified
        printf("interface:                  \033[33m%s\033[0m\n",
1606 1607
                (g_args.iface==TAOSC_IFACE)?"taosc":
                (g_args.iface==REST_IFACE)?"rest":"stmt");
1608 1609
    }

1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
    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.threadCountByCreateTbl);
    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.num_of_RPR);
    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);
1627

1628 1629 1630 1631 1632 1633 1634 1635 1636
    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[33mno\033[0m\n");
        } else {
            printf("  drop:                  \033[33myes\033[0m\n");
        }
1637

1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
        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))
1687 1688 1689 1690
#if NANO_SECOND_ENABLED == 1
                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))
#endif
                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2))) {
1691 1692 1693 1694 1695 1696 1697 1698
                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;
            }
        }
1699

1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
        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].sTblName);

            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");
            }
1716

1717 1718 1719 1720 1721 1722 1723
            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");
            }
1724

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
            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":"stmt");
            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[33mno\033[0m\n");
               }else {
               printf("      multiThreadWriteOneTbl:  \033[33myes\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);
            }
1758

1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
            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("      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[\033[33m%d\033[0m]:\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");
1810
        }
1811
        printf("\n");
1812
    }
1813

1814
    SHOW_PARSE_RESULT_END();
1815

1816
    return 0;
1817 1818 1819
}

static void printfInsertMetaToFile(FILE* fp) {
1820

1821
    SHOW_PARSE_RESULT_START_TO_FILE(fp);
1822

1823 1824 1825 1826 1827 1828 1829 1830 1831
    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.threadCountByCreateTbl);
    fprintf(fp, "number of records per req:  %u\n", g_args.num_of_RPR);
    fprintf(fp, "max sql length:             %"PRIu64"\n", g_args.max_sql_len);
    fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
1832

1833 1834 1835 1836 1837 1838 1839 1840
    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");
        }
1841

1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
        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))
1880 1881 1882
#if NANO_SECOND_ENABLED == 1
                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2))
#endif
1883 1884 1885 1886 1887 1888 1889 1890
                    || (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);
            }
        }
1891

1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
        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].sTblName);

            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");
            }
1908

1909 1910 1911 1912 1913 1914 1915 1916
            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");
            }
1917

1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
            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":"stmt");
            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");
1998
        }
1999
        fprintf(fp, "\n");
2000
    }
2001

2002
    SHOW_PARSE_RESULT_END_TO_FILE(fp);
2003 2004 2005
}

static void printfQueryMeta() {
2006

2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
    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.sTblName);
            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");
        }
2076
    }
2077

2078
    SHOW_PARSE_RESULT_END();
2079 2080
}

2081
static char* formatTimestamp(char* buf, int64_t val, int precision) {
2082
    time_t tt;
2083
    if (precision == TSDB_TIME_PRECISION_MICRO) {
2084
        tt = (time_t)(val / 1000000);
2085 2086 2087 2088
#if NANO_SECOND_ENABLED == 1
    } if (precision == TSDB_TIME_PRECISION_NANO) {
        tt = (time_t)(val / 1000000000);
#endif
2089 2090 2091
    } else {
        tt = (time_t)(val / 1000);
    }
2092

2093 2094 2095 2096 2097 2098 2099
    /* 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;
       }
       */
2100 2101

#ifdef WINDOWS
2102
    if (tt < 0) tt = 0;
2103 2104
#endif

2105 2106
    struct tm* ptm = localtime(&tt);
    size_t pos = strftime(buf, 32, "%Y-%m-%d %H:%M:%S", ptm);
2107

2108
    if (precision == TSDB_TIME_PRECISION_MICRO) {
2109
        sprintf(buf + pos, ".%06d", (int)(val % 1000000));
2110 2111 2112 2113
#if NANO_SECOND_ENABLED == 1
    } else if (precision == TSDB_TIME_PRECISION_NANO) {
        sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
#endif
2114 2115 2116
    } else {
        sprintf(buf + pos, ".%03d", (int)(val % 1000));
    }
2117

2118
    return buf;
2119 2120
}

2121
static void xDumpFieldToFile(FILE* fp, const char* val,
2122
        TAOS_FIELD* field, int32_t length, int precision) {
2123

2124 2125 2126 2127
    if (val == NULL) {
        fprintf(fp, "%s", TSDB_DATA_NULL_STR);
        return;
    }
2128

2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
    char buf[TSDB_MAX_BYTES_PER_ROW];
    switch (field->type) {
        case TSDB_DATA_TYPE_BOOL:
            fprintf(fp, "%d", ((((int32_t)(*((char *)val))) == 1) ? 1 : 0));
            break;
        case TSDB_DATA_TYPE_TINYINT:
            fprintf(fp, "%d", *((int8_t *)val));
            break;
        case TSDB_DATA_TYPE_SMALLINT:
            fprintf(fp, "%d", *((int16_t *)val));
            break;
        case TSDB_DATA_TYPE_INT:
            fprintf(fp, "%d", *((int32_t *)val));
            break;
        case TSDB_DATA_TYPE_BIGINT:
            fprintf(fp, "%" PRId64, *((int64_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;
    }
2165 2166 2167
}

static int xDumpResultToFile(const char* fname, TAOS_RES* tres) {
2168 2169 2170 2171
    TAOS_ROW row = taos_fetch_row(tres);
    if (row == NULL) {
        return 0;
    }
2172

2173 2174 2175 2176 2177 2178
    FILE* fp = fopen(fname, "at");
    if (fp == NULL) {
        errorPrint("%s() LN%d, failed to open file: %s\n",
                __func__, __LINE__, fname);
        return -1;
    }
2179

2180 2181 2182
    int num_fields = taos_num_fields(tres);
    TAOS_FIELD *fields = taos_fetch_fields(tres);
    int precision = taos_result_precision(tres);
2183

2184 2185 2186 2187 2188
    for (int col = 0; col < num_fields; col++) {
        if (col > 0) {
            fprintf(fp, ",");
        }
        fprintf(fp, "%s", fields[col].name);
2189 2190 2191
    }
    fputc('\n', fp);

2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206
    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);
2207

2208
    fclose(fp);
2209

2210
    return numOfRows;
2211 2212
}

2213
static int getDbFromServer(TAOS * taos, SDbInfo** dbInfos) {
2214 2215 2216
    TAOS_RES * res;
    TAOS_ROW row = NULL;
    int count = 0;
2217

2218 2219
    res = taos_query(taos, "show databases;");
    int32_t code = taos_errno(res);
2220

2221 2222 2223 2224
    if (code != 0) {
        errorPrint( "failed to run <show databases>, reason: %s\n",
                taos_errstr(res));
        return -1;
2225
    }
2226

2227
    TAOS_FIELD *fields = taos_fetch_fields(res);
2228

2229 2230 2231 2232 2233 2234
    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;
        }
2235

2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
        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;
        }
2278 2279
    }

2280
    return count;
2281 2282
}

2283
static void printfDbInfoForQueryToFile(
2284
        char* filename, SDbInfo* dbInfos, int index) {
2285

2286 2287
    if (filename[0] == 0)
        return;
2288

2289 2290 2291 2292 2293
    FILE *fp = fopen(filename, "at");
    if (fp == NULL) {
        errorPrint( "failed to open file: %s\n", filename);
        return;
    }
2294

2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315
    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");
2316

2317
    fclose(fp);
2318 2319 2320
}

static void printfQuerySystemInfo(TAOS * taos) {
2321 2322
    char filename[BUFFER_SIZE+1] = {0};
    char buffer[BUFFER_SIZE+1] = {0};
2323 2324 2325 2326 2327 2328
    TAOS_RES* res;

    time_t t;
    struct tm* lt;
    time(&t);
    lt = localtime(&t);
2329
    snprintf(filename, BUFFER_SIZE, "querySystemInfo-%d-%d-%d %d:%d:%d",
2330 2331 2332 2333 2334 2335
            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);
2336
    xDumpResultToFile(filename, res);
2337

2338 2339
    // show dnodes
    res = taos_query(taos, "show dnodes;");
2340
    xDumpResultToFile(filename, res);
2341
    //fetchResult(res, filename);
2342

2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360
    // 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
2361
        snprintf(buffer, BUFFER_SIZE, "show %s.vgroups;", dbInfos[i]->name);
2362 2363 2364 2365
        res = taos_query(taos, buffer);
        xDumpResultToFile(filename, res);

        // show db.stables
2366
        snprintf(buffer, BUFFER_SIZE, "show %s.stables;", dbInfos[i]->name);
2367 2368 2369 2370
        res = taos_query(taos, buffer);
        xDumpResultToFile(filename, res);
        free(dbInfos[i]);
    }
2371

2372
    free(dbInfos);
2373 2374
}

2375
static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port,
2376
        char* sqlstr, threadInfo *pThreadInfo)
2377
{
2378
    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";
2379

2380
    char *url = "/rest/sql";
2381

2382 2383 2384 2385
    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;
2386

2387
    int req_buf_len = strlen(sqlstr) + REQ_EXTRA_BUF_LEN;
2388

2389 2390
    request_buf = malloc(req_buf_len);
    if (NULL == request_buf) {
2391 2392
        errorPrint("%s", "ERROR, cannot allocate memory.\n");
        exit(EXIT_FAILURE);
2393
    }
2394

2395 2396
    char userpass_buf[INPUT_BUF_LEN];
    int mod_table[] = {0, 2, 1};
2397

2398
    static char base64[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
2399 2400 2401 2402 2403 2404 2405
        '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', '+', '/'};
2406

2407
    snprintf(userpass_buf, INPUT_BUF_LEN, "%s:%s",
2408
            g_Dbs.user, g_Dbs.password);
2409 2410
    size_t userpass_buf_len = strlen(userpass_buf);
    size_t encoded_len = 4 * ((userpass_buf_len +2) / 3);
2411

2412
    char base64_buf[INPUT_BUF_LEN];
2413
#ifdef WINDOWS
2414
    WSADATA wsaData;
2415
    WSAStartup(MAKEWORD(2, 2), &wsaData);
2416 2417
    SOCKET sockfd;
#else
2418
    int sockfd;
2419
#endif
2420 2421
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
2422
#ifdef WINDOWS
2423
        errorPrint( "Could not create socket : %d" , WSAGetLastError());
2424
#endif
2425 2426 2427 2428
        debugPrint("%s() LN%d, sockfd=%d\n", __func__, __LINE__, sockfd);
        free(request_buf);
        ERROR_EXIT("ERROR opening socket");
    }
2429

2430
    int retConn = connect(sockfd, (struct sockaddr *)pServAddr, sizeof(struct sockaddr));
2431 2432 2433 2434 2435
    debugPrint("%s() LN%d connect() return %d\n", __func__, __LINE__, retConn);
    if (retConn < 0) {
        free(request_buf);
        ERROR_EXIT("ERROR connecting");
    }
2436

2437
    memset(base64_buf, 0, INPUT_BUF_LEN);
2438

2439
    for (int n = 0, m = 0; n < userpass_buf_len;) {
2440 2441 2442 2443 2444 2445 2446
        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;
2447

2448 2449 2450 2451
        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];
2452
    }
2453

2454
    for (int l = 0; l < mod_table[userpass_buf_len % 3]; l++)
2455
        base64_buf[encoded_len - 1 - l] = '=';
2456

2457 2458 2459
    debugPrint("%s() LN%d: auth string base64 encoded: %s\n",
            __func__, __LINE__, base64_buf);
    char *auth = base64_buf;
2460

2461 2462 2463 2464 2465 2466 2467 2468 2469
    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("ERROR too long request");
    }
    verbosePrint("%s() LN%d: Request:\n%s\n", __func__, __LINE__, request_buf);
2470

2471 2472 2473
    req_str_len = strlen(request_buf);
    sent = 0;
    do {
2474
#ifdef WINDOWS
2475
        bytes = send(sockfd, request_buf + sent, req_str_len - sent, 0);
2476
#else
2477
        bytes = write(sockfd, request_buf + sent, req_str_len - sent);
2478
#endif
2479 2480 2481 2482 2483 2484
        if (bytes < 0)
            ERROR_EXIT("ERROR writing message to socket");
        if (bytes == 0)
            break;
        sent+=bytes;
    } while(sent < req_str_len);
2485

2486 2487 2488 2489
    memset(response_buf, 0, RESP_BUF_LEN);
    resp_len = sizeof(response_buf) - 1;
    received = 0;
    do {
2490
#ifdef WINDOWS
2491
        bytes = recv(sockfd, response_buf + received, resp_len - received, 0);
2492
#else
2493
        bytes = read(sockfd, response_buf + received, resp_len - received);
2494
#endif
2495 2496 2497 2498 2499 2500 2501 2502
        if (bytes < 0) {
            free(request_buf);
            ERROR_EXIT("ERROR reading response from socket");
        }
        if (bytes == 0)
            break;
        received += bytes;
    } while(received < resp_len);
2503

2504 2505 2506 2507
    if (received == resp_len) {
        free(request_buf);
        ERROR_EXIT("ERROR storing complete response from socket");
    }
H
Haojun Liao 已提交
2508

2509 2510
    response_buf[RESP_BUF_LEN - 1] = '\0';
    printf("Response:\n%s\n", response_buf);
H
Haojun Liao 已提交
2511

2512
    if (strlen(pThreadInfo->filePath) > 0) {
2513
        appendResultBufToFile(response_buf, pThreadInfo);
2514 2515
    }

2516
    free(request_buf);
2517
#ifdef WINDOWS
2518
    closesocket(sockfd);
2519 2520
    WSACleanup();
#else
2521
    close(sockfd);
2522
#endif
2523

2524
    return 0;
2525 2526
}

2527
static char* getTagValueFromTagSample(SSuperTable* stbInfo, int tagUsePos) {
2528 2529 2530 2531 2532 2533
    char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
    if (NULL == dataBuf) {
        errorPrint("%s() LN%d, calloc failed! size:%d\n",
                __func__, __LINE__, TSDB_MAX_SQL_LEN+1);
        return NULL;
    }
2534

2535 2536 2537
    int    dataLen = 0;
    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
            "(%s)", stbInfo->tagDataBuf + stbInfo->lenOfTagOfOneRow * tagUsePos);
2538

2539
    return dataBuf;
2540 2541
}

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
static char *generateBinaryNCharTagValues(int64_t tableSeq, uint32_t len)
{
    char* buf = (char*)calloc(len, 1);
    if (NULL == buf) {
        printf("calloc failed! size:%d\n", len);
        return NULL;
    }

    if (tableSeq % 2) {
        tstrncpy(buf, "beijing", len);
    } else {
        tstrncpy(buf, "shanghai", len);
    }
    //rand_string(buf, stbInfo->tags[i].dataLen);

    return buf;
}

static char* generateTagValuesForStb(SSuperTable* stbInfo, int64_t tableSeq) {
2561 2562 2563
    char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
    if (NULL == dataBuf) {
        printf("calloc failed! size:%d\n", TSDB_MAX_SQL_LEN+1);
2564
        return NULL;
2565
    }
2566

2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
    int    dataLen = 0;
    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, "(");
    for (int i = 0; i < stbInfo->tagCount; i++) {
        if ((0 == strncasecmp(stbInfo->tags[i].dataType,
                        "binary", strlen("binary")))
                || (0 == strncasecmp(stbInfo->tags[i].dataType,
                        "nchar", strlen("nchar")))) {
            if (stbInfo->tags[i].dataLen > TSDB_MAX_BINARY_LEN) {
                printf("binary or nchar length overflow, max size:%u\n",
                        (uint32_t)TSDB_MAX_BINARY_LEN);
                tmfree(dataBuf);
                return NULL;
            }
2580

2581 2582
            int32_t tagBufLen = stbInfo->tags[i].dataLen + 1;
            char *buf = generateBinaryNCharTagValues(tableSeq, tagBufLen);
2583 2584 2585 2586 2587
            if (NULL == buf) {
                tmfree(dataBuf);
                return NULL;
            }
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2588
                    "\'%s\',", buf);
2589 2590 2591
            tmfree(buf);
        } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "int", strlen("int"))) {
2592 2593 2594
            if ((g_args.demo_mode) && (i == 0)) {
                dataLen += snprintf(dataBuf + dataLen,
                        TSDB_MAX_SQL_LEN - dataLen,
2595
                        "%"PRId64",", tableSeq % 10);
2596 2597 2598
            } else {
                dataLen += snprintf(dataBuf + dataLen,
                        TSDB_MAX_SQL_LEN - dataLen,
2599
                        "%"PRId64",", tableSeq);
2600
            }
2601 2602 2603
        } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "bigint", strlen("bigint"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2604
                    "%"PRId64",", rand_bigint());
2605 2606 2607
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "float", strlen("float"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2608
                    "%f,", rand_float());
2609 2610 2611
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "double", strlen("double"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2612
                    "%f,", rand_double());
2613 2614 2615
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "smallint", strlen("smallint"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2616
                    "%d,", rand_smallint());
2617 2618 2619
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "tinyint", strlen("tinyint"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2620
                    "%d,", rand_tinyint());
2621 2622 2623
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "bool", strlen("bool"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2624
                    "%d,", rand_bool());
2625 2626 2627
        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                    "timestamp", strlen("timestamp"))) {
            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2628
                    "%"PRId64",", rand_bigint());
2629
        }  else {
2630
            errorPrint("No support data type: %s\n", stbInfo->tags[i].dataType);
2631 2632 2633
            tmfree(dataBuf);
            return NULL;
        }
2634
    }
2635

2636
    dataLen -= 1;
2637 2638
    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, ")");
    return dataBuf;
2639 2640
}

2641
static int calcRowLen(SSuperTable*  superTbls) {
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652
    int colIndex;
    int  lenOfOneRow = 0;

    for (colIndex = 0; colIndex < superTbls->columnCount; colIndex++) {
        char* dataType = superTbls->columns[colIndex].dataType;

        if (strcasecmp(dataType, "BINARY") == 0) {
            lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "NCHAR") == 0) {
            lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "INT") == 0)  {
2653
            lenOfOneRow += INT_BUFF_LEN;
2654
        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
2655
            lenOfOneRow += BIGINT_BUFF_LEN;
2656
        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
2657
            lenOfOneRow += SMALLINT_BUFF_LEN;
2658
        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
2659
            lenOfOneRow += TINYINT_BUFF_LEN;
2660
        } else if (strcasecmp(dataType, "BOOL") == 0)  {
2661
            lenOfOneRow += BOOL_BUFF_LEN;
2662
        } else if (strcasecmp(dataType, "FLOAT") == 0) {
2663
            lenOfOneRow += FLOAT_BUFF_LEN;
2664
        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2665
            lenOfOneRow += DOUBLE_BUFF_LEN;
2666
        }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
2667
            lenOfOneRow += TIMESTAMP_BUFF_LEN;
2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
        } else {
            printf("get error data type : %s\n", dataType);
            exit(-1);
        }
    }

    superTbls->lenOfOneRow = lenOfOneRow + 20; // timestamp

    int tagIndex;
    int lenOfTagOfOneRow = 0;
    for (tagIndex = 0; tagIndex < superTbls->tagCount; tagIndex++) {
        char* dataType = superTbls->tags[tagIndex].dataType;

        if (strcasecmp(dataType, "BINARY") == 0) {
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "NCHAR") == 0) {
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "INT") == 0)  {
2686
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + INT_BUFF_LEN;
2687
        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
2688
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + BIGINT_BUFF_LEN;
2689
        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
2690
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + SMALLINT_BUFF_LEN;
2691
        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
2692
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + TINYINT_BUFF_LEN;
2693
        } else if (strcasecmp(dataType, "BOOL") == 0)  {
2694
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + BOOL_BUFF_LEN;
2695
        } else if (strcasecmp(dataType, "FLOAT") == 0) {
2696
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + FLOAT_BUFF_LEN;
2697
        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2698
            lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + DOUBLE_BUFF_LEN;
2699 2700 2701 2702
        } else {
            printf("get error tag type : %s\n", dataType);
            exit(-1);
        }
2703 2704
    }

2705
    superTbls->lenOfTagOfOneRow = lenOfTagOfOneRow;
2706

2707
    return 0;
2708 2709 2710
}


2711
static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
2712
        char* dbName, char* sTblName, char** childTblNameOfSuperTbl,
2713
        int64_t* childTblCountOfSuperTbl, int64_t limit, uint64_t offset) {
2714

2715 2716
    char command[BUFFER_SIZE] = "\0";
    char limitBuf[100] = "\0";
2717

2718 2719
    TAOS_RES * res;
    TAOS_ROW row = NULL;
2720

2721
    char* childTblName = *childTblNameOfSuperTbl;
2722

2723 2724 2725 2726
    if (offset >= 0) {
        snprintf(limitBuf, 100, " limit %"PRId64" offset %"PRIu64"",
                limit, offset);
    }
2727

2728 2729 2730
    //get all child table name use cmd: select tbname from superTblName;
    snprintf(command, BUFFER_SIZE, "select tbname from %s.%s %s",
            dbName, sTblName, limitBuf);
2731

2732 2733 2734 2735
    res = taos_query(taos, command);
    int32_t code = taos_errno(res);
    if (code != 0) {
        taos_free_result(res);
2736
        taos_close(taos);
2737 2738
        errorPrint("%s() LN%d, failed to run command %s\n",
                __func__, __LINE__, command);
2739
        exit(-1);
2740
    }
2741

2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
    int64_t childTblCount = (limit < 0)?10000: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(-1);
        }
2752 2753
    }

2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785
    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(-1);
        }

        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
                errorPrint("%s() LN%d, realloc fail for save child table name of %s.%s\n",
                        __func__, __LINE__, dbName, sTblName);
                tmfree(childTblName);
                taos_free_result(res);
                taos_close(taos);
                exit(-1);
            }
        }
        pTblName = childTblName + count * TSDB_TABLE_NAME_LEN;
2786
    }
2787

2788 2789
    *childTblCountOfSuperTbl = count;
    *childTblNameOfSuperTbl  = childTblName;
2790

2791 2792
    taos_free_result(res);
    return 0;
2793 2794
}

2795
static int getAllChildNameOfSuperTable(TAOS * taos, char* dbName,
2796
        char* sTblName, char** childTblNameOfSuperTbl,
2797
        int64_t* childTblCountOfSuperTbl) {
2798

2799 2800
    return getChildNameOfSuperTableWithLimitAndOffset(taos, dbName, sTblName,
            childTblNameOfSuperTbl, childTblCountOfSuperTbl,
2801
            -1, 0);
2802 2803
}

2804
static int getSuperTableFromServer(TAOS * taos, char* dbName,
2805
        SSuperTable*  superTbls) {
2806

2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
    char command[BUFFER_SIZE] = "\0";
    TAOS_RES * res;
    TAOS_ROW row = NULL;
    int count = 0;

    //get schema use cmd: describe superTblName;
    snprintf(command, BUFFER_SIZE, "describe %s.%s", dbName, superTbls->sTblName);
    res = taos_query(taos, command);
    int32_t code = taos_errno(res);
    if (code != 0) {
        printf("failed to run command %s\n", command);
        taos_free_result(res);
        return -1;
    }

    int tagIndex = 0;
    int columnIndex = 0;
    TAOS_FIELD *fields = taos_fetch_fields(res);
    while((row = taos_fetch_row(res)) != NULL) {
        if (0 == count) {
            count++;
            continue;
        }

        if (strcmp((char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX], "TAG") == 0) {
            tstrncpy(superTbls->tags[tagIndex].field,
                    (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
                    fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
            tstrncpy(superTbls->tags[tagIndex].dataType,
                    (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
2837 2838
                    min(DATATYPE_BUFF_LEN,
                        fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes) + 1);
2839 2840 2841 2842
            superTbls->tags[tagIndex].dataLen =
                *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
            tstrncpy(superTbls->tags[tagIndex].note,
                    (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
2843 2844
                    min(NOTE_BUFF_LEN,
                        fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes) + 1);
2845 2846 2847 2848 2849 2850 2851
            tagIndex++;
        } else {
            tstrncpy(superTbls->columns[columnIndex].field,
                    (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
                    fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
            tstrncpy(superTbls->columns[columnIndex].dataType,
                    (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
2852 2853
                    min(DATATYPE_BUFF_LEN,
                        fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes) + 1);
2854 2855 2856 2857
            superTbls->columns[columnIndex].dataLen =
                *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
            tstrncpy(superTbls->columns[columnIndex].note,
                    (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
2858 2859
                    min(NOTE_BUFF_LEN,
                        fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes) + 1);
2860 2861 2862 2863 2864 2865 2866
            columnIndex++;
        }
        count++;
    }

    superTbls->columnCount = columnIndex;
    superTbls->tagCount    = tagIndex;
2867
    taos_free_result(res);
2868

2869 2870 2871 2872
    calcRowLen(superTbls);

    /*
       if (TBL_ALREADY_EXISTS == superTbls->childTblExists) {
2873
    //get all child table name use cmd: select tbname from superTblName;
2874 2875 2876
    int childTblCount = 10000;
    superTbls->childTblName = (char*)calloc(1, childTblCount * TSDB_TABLE_NAME_LEN);
    if (superTbls->childTblName == NULL) {
2877 2878
    errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
    return -1;
2879
    }
2880
    getAllChildNameOfSuperTable(taos, dbName,
2881 2882 2883 2884 2885 2886
    superTbls->sTblName,
    &superTbls->childTblName,
    &superTbls->childTblCount);
    }
    */
    return 0;
2887 2888
}

H
Haojun Liao 已提交
2889
static int createSuperTable(
2890 2891
        TAOS * taos, char* dbName,
        SSuperTable*  superTbl) {
H
Haojun Liao 已提交
2892

2893
    char command[BUFFER_SIZE] = "\0";
2894

2895
    char cols[COL_BUFFER_LEN] = "\0";
2896 2897
    int colIndex;
    int len = 0;
2898

2899
    int  lenOfOneRow = 0;
2900

2901 2902 2903 2904 2905
    if (superTbl->columnCount == 0) {
        errorPrint("%s() LN%d, super table column count is %d\n",
                __func__, __LINE__, superTbl->columnCount);
        return -1;
    }
2906

2907 2908 2909 2910
    for (colIndex = 0; colIndex < superTbl->columnCount; colIndex++) {
        char* dataType = superTbl->columns[colIndex].dataType;

        if (strcasecmp(dataType, "BINARY") == 0) {
2911
            len += snprintf(cols + len, COL_BUFFER_LEN - len,
2912
                    ",C%d %s(%d)", colIndex, "BINARY",
2913 2914 2915
                    superTbl->columns[colIndex].dataLen);
            lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "NCHAR") == 0) {
2916
            len += snprintf(cols + len, COL_BUFFER_LEN - len,
2917
                    ",C%d %s(%d)", colIndex, "NCHAR",
2918 2919 2920 2921
                    superTbl->columns[colIndex].dataLen);
            lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "INT") == 0)  {
            if ((g_args.demo_mode) && (colIndex == 1)) {
2922 2923
                len += snprintf(cols + len, COL_BUFFER_LEN - len,
                        ", VOLTAGE INT");
2924
            } else {
2925
                len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "INT");
2926
            }
2927
            lenOfOneRow += INT_BUFF_LEN;
2928
        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
2929
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
2930
                    colIndex, "BIGINT");
2931
            lenOfOneRow += BIGINT_BUFF_LEN;
2932
        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
2933
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
2934
                    colIndex, "SMALLINT");
2935
            lenOfOneRow += SMALLINT_BUFF_LEN;
2936
        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
2937
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "TINYINT");
2938
            lenOfOneRow += TINYINT_BUFF_LEN;
2939
        } else if (strcasecmp(dataType, "BOOL") == 0)  {
2940
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "BOOL");
2941
            lenOfOneRow += BOOL_BUFF_LEN;
2942 2943 2944
        } else if (strcasecmp(dataType, "FLOAT") == 0) {
            if (g_args.demo_mode) {
                if (colIndex == 0) {
2945
                    len += snprintf(cols + len, COL_BUFFER_LEN - len, ", CURRENT FLOAT");
2946
                } else if (colIndex == 2) {
2947
                    len += snprintf(cols + len, COL_BUFFER_LEN - len, ", PHASE FLOAT");
2948 2949
                }
            } else {
2950
                len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "FLOAT");
2951
            }
2952

2953
            lenOfOneRow += FLOAT_BUFF_LEN;
2954
        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2955
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
2956
                    colIndex, "DOUBLE");
2957
            lenOfOneRow += DOUBLE_BUFF_LEN;
2958
        }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
2959
            len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
2960
                    colIndex, "TIMESTAMP");
2961
            lenOfOneRow += TIMESTAMP_BUFF_LEN;
2962 2963 2964 2965 2966 2967
        } else {
            taos_close(taos);
            errorPrint("%s() LN%d, config error data type : %s\n",
                    __func__, __LINE__, dataType);
            exit(-1);
        }
2968 2969
    }

2970
    superTbl->lenOfOneRow = lenOfOneRow + 20; // timestamp
2971

2972 2973 2974 2975 2976 2977 2978 2979
    // save for creating child table
    superTbl->colsOfCreateChildTable = (char*)calloc(len+20, 1);
    if (NULL == superTbl->colsOfCreateChildTable) {
        errorPrint("%s() LN%d, Failed when calloc, size:%d",
                __func__, __LINE__, len+1);
        taos_close(taos);
        exit(-1);
    }
2980

2981 2982 2983
    snprintf(superTbl->colsOfCreateChildTable, len+20, "(ts timestamp%s)", cols);
    verbosePrint("%s() LN%d: %s\n",
            __func__, __LINE__, superTbl->colsOfCreateChildTable);
2984

2985 2986 2987 2988 2989
    if (superTbl->tagCount == 0) {
        errorPrint("%s() LN%d, super table tag count is %d\n",
                __func__, __LINE__, superTbl->tagCount);
        return -1;
    }
2990

2991
    char tags[TSDB_MAX_TAGS_LEN] = "\0";
2992 2993
    int tagIndex;
    len = 0;
2994

2995
    int lenOfTagOfOneRow = 0;
2996
    len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len, "(");
2997 2998 2999 3000
    for (tagIndex = 0; tagIndex < superTbl->tagCount; tagIndex++) {
        char* dataType = superTbl->tags[tagIndex].dataType;

        if (strcasecmp(dataType, "BINARY") == 0) {
3001
            if ((g_args.demo_mode) && (tagIndex == 1)) {
3002
                len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3003
                        "location BINARY(%d),",
3004 3005
                        superTbl->tags[tagIndex].dataLen);
            } else {
3006
                len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3007
                        "T%d %s(%d),", tagIndex, "BINARY",
3008
                        superTbl->tags[tagIndex].dataLen);
3009
            }
3010 3011
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "NCHAR") == 0) {
3012
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3013
                    "T%d %s(%d),", tagIndex,
3014 3015 3016
                    "NCHAR", superTbl->tags[tagIndex].dataLen);
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
        } else if (strcasecmp(dataType, "INT") == 0)  {
3017
            if ((g_args.demo_mode) && (tagIndex == 0)) {
3018 3019
                len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
                        "groupId INT, ");
3020
            } else {
3021
                len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3022
                        "T%d %s,", tagIndex, "INT");
3023
            }
3024
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + INT_BUFF_LEN;
3025
        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
3026
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3027
                    "T%d %s,", tagIndex, "BIGINT");
3028
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + BIGINT_BUFF_LEN;
3029
        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
3030
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3031
                    "T%d %s,", tagIndex, "SMALLINT");
3032
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + SMALLINT_BUFF_LEN;
3033
        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
3034
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3035
                    "T%d %s,", tagIndex, "TINYINT");
3036
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + TINYINT_BUFF_LEN;
3037
        } else if (strcasecmp(dataType, "BOOL") == 0)  {
3038
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3039
                    "T%d %s,", tagIndex, "BOOL");
3040
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + BOOL_BUFF_LEN;
3041
        } else if (strcasecmp(dataType, "FLOAT") == 0) {
3042
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3043
                    "T%d %s,", tagIndex, "FLOAT");
3044
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + FLOAT_BUFF_LEN;
3045
        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
3046
            len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len,
3047
                    "T%d %s,", tagIndex, "DOUBLE");
3048
            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + DOUBLE_BUFF_LEN;
3049 3050 3051 3052 3053 3054
        } else {
            taos_close(taos);
            errorPrint("%s() LN%d, config error tag type : %s\n",
                    __func__, __LINE__, dataType);
            exit(-1);
        }
3055
    }
3056

3057
    len -= 1;
3058
    len += snprintf(tags + len, TSDB_MAX_TAGS_LEN - len, ")");
3059

3060
    superTbl->lenOfTagOfOneRow = lenOfTagOfOneRow;
3061

3062 3063 3064 3065 3066 3067 3068 3069 3070 3071
    snprintf(command, BUFFER_SIZE,
            "create table if not exists %s.%s (ts timestamp%s) tags %s",
            dbName, superTbl->sTblName, cols, tags);
    if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
        errorPrint( "create supertable %s failed!\n\n",
                superTbl->sTblName);
        return -1;
    }
    debugPrint("create supertable %s success!\n\n", superTbl->sTblName);
    return 0;
3072 3073
}

3074
static int createDatabasesAndStables() {
3075 3076 3077 3078 3079
    TAOS * taos = NULL;
    int    ret = 0;
    taos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password, NULL, g_Dbs.port);
    if (taos == NULL) {
        errorPrint( "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
3080
        return -1;
3081 3082
    }
    char command[BUFFER_SIZE] = "\0";
3083

3084 3085 3086 3087 3088 3089 3090
    for (int i = 0; i < g_Dbs.dbCount; i++) {
        if (g_Dbs.db[i].drop) {
            sprintf(command, "drop database if exists %s;", g_Dbs.db[i].dbName);
            if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
                taos_close(taos);
                return -1;
            }
3091

3092 3093 3094
            int dataLen = 0;
            dataLen += snprintf(command + dataLen,
                    BUFFER_SIZE - dataLen, "create database if not exists %s", g_Dbs.db[i].dbName);
3095

3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161
            if (g_Dbs.db[i].dbCfg.blocks > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " blocks %d", g_Dbs.db[i].dbCfg.blocks);
            }
            if (g_Dbs.db[i].dbCfg.cache > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " cache %d", g_Dbs.db[i].dbCfg.cache);
            }
            if (g_Dbs.db[i].dbCfg.days > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " days %d", g_Dbs.db[i].dbCfg.days);
            }
            if (g_Dbs.db[i].dbCfg.keep > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " keep %d", g_Dbs.db[i].dbCfg.keep);
            }
            if (g_Dbs.db[i].dbCfg.quorum > 1) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " quorum %d", g_Dbs.db[i].dbCfg.quorum);
            }
            if (g_Dbs.db[i].dbCfg.replica > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " replica %d", g_Dbs.db[i].dbCfg.replica);
            }
            if (g_Dbs.db[i].dbCfg.update > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " update %d", g_Dbs.db[i].dbCfg.update);
            }
            //if (g_Dbs.db[i].dbCfg.maxtablesPerVnode > 0) {
            //  dataLen += snprintf(command + dataLen,
            //  BUFFER_SIZE - dataLen, "tables %d ", g_Dbs.db[i].dbCfg.maxtablesPerVnode);
            //}
            if (g_Dbs.db[i].dbCfg.minRows > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " minrows %d", g_Dbs.db[i].dbCfg.minRows);
            }
            if (g_Dbs.db[i].dbCfg.maxRows > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " maxrows %d", g_Dbs.db[i].dbCfg.maxRows);
            }
            if (g_Dbs.db[i].dbCfg.comp > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " comp %d", g_Dbs.db[i].dbCfg.comp);
            }
            if (g_Dbs.db[i].dbCfg.walLevel > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " wal %d", g_Dbs.db[i].dbCfg.walLevel);
            }
            if (g_Dbs.db[i].dbCfg.cacheLast > 0) {
                dataLen += snprintf(command + dataLen,
                        BUFFER_SIZE - dataLen, " cachelast %d", g_Dbs.db[i].dbCfg.cacheLast);
            }
            if (g_Dbs.db[i].dbCfg.fsync > 0) {
                dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
                        " fsync %d", g_Dbs.db[i].dbCfg.fsync);
            }
            if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", strlen("ms")))
#if NANO_SECOND_ENABLED == 1
                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
                            "ns", strlen("ns")))
#endif
                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
                            "us", strlen("us"))))  {
                dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
                        " precision \'%s\';", g_Dbs.db[i].dbCfg.precision);
            }
3162

3163 3164 3165 3166 3167 3168 3169
            if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
                taos_close(taos);
                errorPrint( "\ncreate database %s failed!\n\n", g_Dbs.db[i].dbName);
                return -1;
            }
            printf("\ncreate database %s success!\n\n", g_Dbs.db[i].dbName);
        }
3170

3171 3172
        debugPrint("%s() LN%d supertbl count:%"PRIu64"\n",
                __func__, __LINE__, g_Dbs.db[i].superTblCount);
3173

3174
        int validStbCount = 0;
3175

3176 3177 3178 3179
        for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
            sprintf(command, "describe %s.%s;", g_Dbs.db[i].dbName,
                    g_Dbs.db[i].superTbls[j].sTblName);
            ret = queryDbExec(taos, command, NO_INSERT_TYPE, true);
3180

3181 3182 3183
            if ((ret != 0) || (g_Dbs.db[i].drop)) {
                ret = createSuperTable(taos, g_Dbs.db[i].dbName,
                        &g_Dbs.db[i].superTbls[j]);
3184

3185 3186 3187 3188 3189
                if (0 != ret) {
                    errorPrint("create super table %"PRIu64" failed!\n\n", j);
                    continue;
                }
            }
3190

3191 3192 3193 3194 3195 3196 3197
            ret = getSuperTableFromServer(taos, g_Dbs.db[i].dbName,
                    &g_Dbs.db[i].superTbls[j]);
            if (0 != ret) {
                errorPrint("\nget super table %s.%s info failed!\n\n",
                        g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].sTblName);
                continue;
            }
3198

3199 3200
            validStbCount ++;
        }
3201

3202 3203 3204 3205 3206
        g_Dbs.db[i].superTblCount = validStbCount;
    }

    taos_close(taos);
    return 0;
3207 3208
}

3209 3210
static void* createTable(void *sarg)
{
3211 3212
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
3213

3214 3215
    setThreadName("createTable");

3216
    uint64_t  lastPrintTime = taosGetTimestampMs();
3217

3218
    int buff_len = BUFFER_SIZE;
3219

3220 3221 3222
    pThreadInfo->buffer = calloc(buff_len, 1);
    if (pThreadInfo->buffer == NULL) {
        errorPrint("%s() LN%d, Memory allocated failed!\n", __func__, __LINE__);
3223
        exit(-1);
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
    }

    int len = 0;
    int batchNum = 0;

    verbosePrint("%s() LN%d: Creating table from %"PRIu64" to %"PRIu64"\n",
            __func__, __LINE__,
            pThreadInfo->start_table_from, pThreadInfo->end_table_to);

    for (uint64_t i = pThreadInfo->start_table_from;
            i <= pThreadInfo->end_table_to; i++) {
        if (0 == g_Dbs.use_metric) {
            snprintf(pThreadInfo->buffer, buff_len,
                    "create table if not exists %s.%s%"PRIu64" %s;",
                    pThreadInfo->db_name,
                    g_args.tb_prefix, i,
                    pThreadInfo->cols);
3241
        } else {
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255
            if (superTblInfo == NULL) {
                errorPrint("%s() LN%d, use metric, but super table info is NULL\n",
                        __func__, __LINE__);
                free(pThreadInfo->buffer);
                exit(-1);
            } else {
                if (0 == len) {
                    batchNum = 0;
                    memset(pThreadInfo->buffer, 0, buff_len);
                    len += snprintf(pThreadInfo->buffer + len,
                            buff_len - len, "create table ");
                }
                char* tagsValBuf = NULL;
                if (0 == superTblInfo->tagSource) {
3256
                    tagsValBuf = generateTagValuesForStb(superTblInfo, i);
3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279
                } else {
                    tagsValBuf = getTagValueFromTagSample(
                            superTblInfo,
                            i % superTblInfo->tagSampleCount);
                }
                if (NULL == tagsValBuf) {
                    free(pThreadInfo->buffer);
                    return NULL;
                }
                len += snprintf(pThreadInfo->buffer + len,
                        buff_len - len,
                        "if not exists %s.%s%"PRIu64" using %s.%s tags %s ",
                        pThreadInfo->db_name, superTblInfo->childTblPrefix,
                        i, pThreadInfo->db_name,
                        superTblInfo->sTblName, tagsValBuf);
                free(tagsValBuf);
                batchNum++;
                if ((batchNum < superTblInfo->batchCreateTableNum)
                        && ((buff_len - len)
                            >= (superTblInfo->lenOfTagOfOneRow + 256))) {
                    continue;
                }
            }
3280
        }
3281

3282 3283 3284 3285 3286 3287 3288
        len = 0;
        if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
                    NO_INSERT_TYPE, false)){
            errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
            free(pThreadInfo->buffer);
            return NULL;
        }
3289

3290 3291 3292 3293 3294 3295
        uint64_t  currentPrintTime = taosGetTimestampMs();
        if (currentPrintTime - lastPrintTime > 30*1000) {
            printf("thread[%d] already create %"PRIu64" - %"PRIu64" tables\n",
                    pThreadInfo->threadID, pThreadInfo->start_table_from, i);
            lastPrintTime = currentPrintTime;
        }
3296
    }
3297

3298 3299 3300 3301 3302
    if (0 != len) {
        if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
                    NO_INSERT_TYPE, false)) {
            errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
        }
3303
    }
3304

3305 3306
    free(pThreadInfo->buffer);
    return NULL;
3307 3308
}

3309
static int startMultiThreadCreateChildTable(
3310
        char* cols, int threads, uint64_t tableFrom, int64_t ntables,
3311
        char* db_name, SSuperTable* superTblInfo) {
3312

3313 3314
    pthread_t *pids = calloc(1, threads * sizeof(pthread_t));
    threadInfo *infos = calloc(1, threads * sizeof(threadInfo));
3315

3316 3317 3318 3319
    if ((NULL == pids) || (NULL == infos)) {
        printf("malloc failed\n");
        exit(-1);
    }
3320

3321 3322 3323
    if (threads < 1) {
        threads = 1;
    }
3324

3325 3326 3327 3328
    int64_t a = ntables / threads;
    if (a < 1) {
        threads = ntables;
        a = 1;
3329
    }
3330

3331 3332
    int64_t b = 0;
    b = ntables % threads;
3333

3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352
    for (int64_t i = 0; i < threads; i++) {
        threadInfo *pThreadInfo = infos + i;
        pThreadInfo->threadID = i;
        tstrncpy(pThreadInfo->db_name, db_name, TSDB_DB_NAME_LEN);
        pThreadInfo->superTblInfo = superTblInfo;
        verbosePrint("%s() %d db_name: %s\n", __func__, __LINE__, db_name);
        pThreadInfo->taos = taos_connect(
                g_Dbs.host,
                g_Dbs.user,
                g_Dbs.password,
                db_name,
                g_Dbs.port);
        if (pThreadInfo->taos == NULL) {
            errorPrint( "%s() LN%d, Failed to connect to TDengine, reason:%s\n",
                    __func__, __LINE__, taos_errstr(NULL));
            free(pids);
            free(infos);
            return -1;
        }
3353

3354 3355 3356 3357 3358 3359 3360 3361 3362
        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->use_metric = true;
        pThreadInfo->cols = cols;
        pThreadInfo->minDelay = UINT64_MAX;
        pthread_create(pids + i, NULL, createTable, pThreadInfo);
    }
3363

3364 3365 3366
    for (int i = 0; i < threads; i++) {
        pthread_join(pids[i], NULL);
    }
3367

3368 3369 3370 3371 3372 3373 3374 3375 3376
    for (int i = 0; i < threads; i++) {
        threadInfo *pThreadInfo = infos + i;
        taos_close(pThreadInfo->taos);
    }

    free(pids);
    free(infos);

    return 0;
3377 3378
}

3379
static void createChildTables() {
3380
    char tblColsBuf[TSDB_MAX_BYTES_PER_ROW];
3381
    int len;
3382

3383 3384 3385 3386 3387
    for (int i = 0; i < g_Dbs.dbCount; i++) {
        if (g_Dbs.use_metric) {
            if (g_Dbs.db[i].superTblCount > 0) {
                // with super table
                for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
3388 3389 3390 3391
                    if ((AUTO_CREATE_SUBTBL
                                == g_Dbs.db[i].superTbls[j].autoCreateTable)
                            || (TBL_ALREADY_EXISTS
                                == g_Dbs.db[i].superTbls[j].childTblExists)) {
3392 3393 3394
                        continue;
                    }
                    verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
3395
                            g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411
                    uint64_t startFrom = 0;
                    g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;

                    verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
                            __func__, __LINE__, g_totalChildTables, startFrom);

                    startMultiThreadCreateChildTable(
                            g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
                            g_Dbs.threadCountByCreateTbl,
                            startFrom,
                            g_Dbs.db[i].superTbls[j].childTblCount,
                            g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
                }
            }
        } else {
            // normal table
3412
            len = snprintf(tblColsBuf, TSDB_MAX_BYTES_PER_ROW, "(TS TIMESTAMP");
3413 3414 3415 3416
            for (int j = 0; j < g_args.num_of_CPR; j++) {
                if ((strncasecmp(g_args.datatype[j], "BINARY", strlen("BINARY")) == 0)
                        || (strncasecmp(g_args.datatype[j],
                                "NCHAR", strlen("NCHAR")) == 0)) {
3417 3418
                    snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
                            ",C%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
3419
                } else {
3420 3421
                    snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
                            ",C%d %s", j, g_args.datatype[j]);
3422 3423 3424
                }
                len = strlen(tblColsBuf);
            }
3425

3426
            snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len, ")");
3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437

            verbosePrint("%s() LN%d: dbName: %s num of tb: %"PRId64" schema: %s\n",
                    __func__, __LINE__,
                    g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
            startMultiThreadCreateChildTable(
                    tblColsBuf,
                    g_Dbs.threadCountByCreateTbl,
                    0,
                    g_args.num_of_tables,
                    g_Dbs.db[i].dbName,
                    NULL);
3438
        }
3439
    }
3440 3441 3442
}

/*
3443 3444
   Read 10000 lines at most. If more than 10000 lines, continue to read after using
   */
3445
static int readTagFromCsvFileToMem(SSuperTable  * superTblInfo) {
3446 3447 3448
    size_t  n = 0;
    ssize_t readLen = 0;
    char *  line = NULL;
3449

3450 3451 3452 3453 3454
    FILE *fp = fopen(superTblInfo->tagsFile, "r");
    if (fp == NULL) {
        printf("Failed to open tags file: %s, reason:%s\n",
                superTblInfo->tagsFile, strerror(errno));
        return -1;
3455 3456
    }

3457 3458 3459
    if (superTblInfo->tagDataBuf) {
        free(superTblInfo->tagDataBuf);
        superTblInfo->tagDataBuf = NULL;
3460 3461
    }

3462 3463 3464 3465 3466
    int tagCount = 10000;
    int count = 0;
    char* tagDataBuf = calloc(1, superTblInfo->lenOfTagOfOneRow * tagCount);
    if (tagDataBuf == NULL) {
        printf("Failed to calloc, reason:%s\n", strerror(errno));
3467 3468 3469 3470
        fclose(fp);
        return -1;
    }

3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
    while((readLen = tgetline(&line, &n, fp)) != -1) {
        if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
            line[--readLen] = 0;
        }

        if (readLen == 0) {
            continue;
        }

        memcpy(tagDataBuf + count * superTblInfo->lenOfTagOfOneRow, line, readLen);
        count++;

        if (count >= tagCount - 1) {
            char *tmp = realloc(tagDataBuf,
                    (size_t)tagCount*1.5*superTblInfo->lenOfTagOfOneRow);
            if (tmp != NULL) {
                tagDataBuf = tmp;
                tagCount = (int)(tagCount*1.5);
                memset(tagDataBuf + count*superTblInfo->lenOfTagOfOneRow,
                        0, (size_t)((tagCount-count)*superTblInfo->lenOfTagOfOneRow));
            } else {
                // exit, if allocate more memory failed
                printf("realloc fail for save tag val from %s\n", superTblInfo->tagsFile);
                tmfree(tagDataBuf);
                free(line);
                fclose(fp);
                return -1;
            }
        }
    }
3501

3502 3503 3504 3505 3506 3507
    superTblInfo->tagDataBuf = tagDataBuf;
    superTblInfo->tagSampleCount = count;

    free(line);
    fclose(fp);
    return 0;
3508 3509 3510
}

/*
3511 3512
   Read 10000 lines at most. If more than 10000 lines, continue to read after using
   */
3513
static int readSampleFromCsvFileToMem(
3514
        SSuperTable* superTblInfo) {
3515 3516 3517 3518 3519 3520 3521 3522
    size_t  n = 0;
    ssize_t readLen = 0;
    char *  line = NULL;
    int getRows = 0;

    FILE*  fp = fopen(superTblInfo->sampleFile, "r");
    if (fp == NULL) {
        errorPrint( "Failed to open sample file: %s, reason:%s\n",
3523
                superTblInfo->sampleFile, strerror(errno));
3524 3525
        return -1;
    }
3526

3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540
    assert(superTblInfo->sampleDataBuf);
    memset(superTblInfo->sampleDataBuf, 0,
            MAX_SAMPLES_ONCE_FROM_FILE * superTblInfo->lenOfOneRow);
    while(1) {
        readLen = tgetline(&line, &n, fp);
        if (-1 == readLen) {
            if(0 != fseek(fp, 0, SEEK_SET)) {
                errorPrint( "Failed to fseek file: %s, reason:%s\n",
                        superTblInfo->sampleFile, strerror(errno));
                fclose(fp);
                return -1;
            }
            continue;
        }
3541

3542 3543 3544
        if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
            line[--readLen] = 0;
        }
3545

3546 3547 3548
        if (readLen == 0) {
            continue;
        }
3549

3550 3551 3552 3553 3554
        if (readLen > superTblInfo->lenOfOneRow) {
            printf("sample row len[%d] overflow define schema len[%"PRIu64"], so discard this row\n",
                    (int32_t)readLen, superTblInfo->lenOfOneRow);
            continue;
        }
3555

3556 3557 3558 3559 3560 3561 3562
        memcpy(superTblInfo->sampleDataBuf + getRows * superTblInfo->lenOfOneRow,
                line, readLen);
        getRows++;

        if (getRows == MAX_SAMPLES_ONCE_FROM_FILE) {
            break;
        }
3563 3564
    }

3565 3566 3567
    fclose(fp);
    tmfree(line);
    return 0;
3568 3569
}

3570
static bool getColumnAndTagTypeFromInsertJsonFile(
3571
        cJSON* stbInfo, SSuperTable* superTbls) {
3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583
    bool  ret = false;

    // columns
    cJSON *columns = cJSON_GetObjectItem(stbInfo, "columns");
    if (columns && columns->type != cJSON_Array) {
        printf("ERROR: failed to read json, columns not found\n");
        goto PARSE_OVER;
    } else if (NULL == columns) {
        superTbls->columnCount = 0;
        superTbls->tagCount    = 0;
        return true;
    }
3584

3585 3586 3587 3588 3589 3590
    int columnSize = cJSON_GetArraySize(columns);
    if ((columnSize + 1/* ts */) > TSDB_MAX_COLUMNS) {
        errorPrint("%s() LN%d, failed to read json, column size overflow, max column size is %d\n",
                __func__, __LINE__, TSDB_MAX_COLUMNS);
        goto PARSE_OVER;
    }
3591

3592 3593 3594
    int count = 1;
    int index = 0;
    StrColumn    columnCase;
3595

3596 3597 3598 3599
    //superTbls->columnCount = columnSize;
    for (int k = 0; k < columnSize; ++k) {
        cJSON* column = cJSON_GetArrayItem(columns, k);
        if (column == NULL) continue;
3600

3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
        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() LN%d, failed to read json, column count not found\n",
                    __func__, __LINE__);
            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() LN%d: failed to read json, column type not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
3622 3623 3624
        //tstrncpy(superTbls->columns[k].dataType, dataType->valuestring, DATATYPE_BUFF_LEN);
        tstrncpy(columnCase.dataType, dataType->valuestring,
                min(DATATYPE_BUFF_LEN, strlen(dataType->valuestring) + 1));
3625 3626 3627 3628 3629 3630 3631 3632 3633

        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 {
3634
            columnCase.dataLen = SMALL_BUFF_LEN;
3635 3636 3637 3638
        }

        for (int n = 0; n < count; ++n) {
            tstrncpy(superTbls->columns[index].dataType,
3639 3640
                    columnCase.dataType,
                    min(DATATYPE_BUFF_LEN, strlen(columnCase.dataType) + 1));
3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652
            superTbls->columns[index].dataLen = columnCase.dataLen;
            index++;
        }
    }

    if ((index + 1 /* ts */) > MAX_NUM_COLUMNS) {
        errorPrint("%s() LN%d, failed to read json, column size overflow, allowed max column size is %d\n",
                __func__, __LINE__, MAX_NUM_COLUMNS);
        goto PARSE_OVER;
    }

    superTbls->columnCount = index;
3653

3654
    count = 1;
3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668
    index = 0;
    // tags
    cJSON *tags = cJSON_GetObjectItem(stbInfo, "tags");
    if (!tags || tags->type != cJSON_Array) {
        errorPrint("%s() LN%d, failed to read json, tags not found\n",
                __func__, __LINE__);
        goto PARSE_OVER;
    }

    int tagSize = cJSON_GetArraySize(tags);
    if (tagSize > TSDB_MAX_TAGS) {
        errorPrint("%s() LN%d, failed to read json, tags size overflow, max tag size is %d\n",
                __func__, __LINE__, TSDB_MAX_TAGS);
        goto PARSE_OVER;
3669 3670
    }

3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695
    //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) {
            printf("ERROR: 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() LN%d, failed to read json, tag type not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
3696 3697
        tstrncpy(columnCase.dataType, dataType->valuestring,
                min(DATATYPE_BUFF_LEN, strlen(dataType->valuestring) + 1));
3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711

        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() LN%d, failed to read json, column len not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        } else {
            columnCase.dataLen = 0;
        }

        for (int n = 0; n < count; ++n) {
            tstrncpy(superTbls->tags[index].dataType, columnCase.dataType,
3712
                    min(DATATYPE_BUFF_LEN, strlen(columnCase.dataType) + 1));
3713 3714 3715
            superTbls->tags[index].dataLen = columnCase.dataLen;
            index++;
        }
3716
    }
3717

3718 3719 3720 3721 3722
    if (index > TSDB_MAX_TAGS) {
        errorPrint("%s() LN%d, failed to read json, tags size overflow, allowed max tag count is %d\n",
                __func__, __LINE__, TSDB_MAX_TAGS);
        goto PARSE_OVER;
    }
3723

3724
    superTbls->tagCount = index;
3725

3726 3727 3728 3729 3730 3731
    if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > TSDB_MAX_COLUMNS) {
        errorPrint("%s() LN%d, columns + tags is more than allowed max columns count: %d\n",
                __func__, __LINE__, TSDB_MAX_COLUMNS);
        goto PARSE_OVER;
    }
    ret = true;
3732

3733
PARSE_OVER:
3734
    return ret;
3735 3736 3737
}

static bool getMetaFromInsertJsonFile(cJSON* root) {
3738
    bool  ret = false;
3739

3740 3741 3742
    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);
3743
    }
3744

3745 3746 3747 3748 3749
    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);
3750
    } else {
3751 3752
        printf("ERROR: failed to read json, host not found\n");
        goto PARSE_OVER;
3753 3754
    }

3755 3756 3757 3758 3759
    cJSON* port = cJSON_GetObjectItem(root, "port");
    if (port && port->type == cJSON_Number) {
        g_Dbs.port = port->valueint;
    } else if (!port) {
        g_Dbs.port = 6030;
3760
    }
3761

3762 3763 3764 3765 3766
    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, "root", MAX_USERNAME_SIZE);
3767 3768
    }

3769 3770 3771 3772 3773
    cJSON* password = cJSON_GetObjectItem(root, "password");
    if (password && password->type == cJSON_String && password->valuestring != NULL) {
        tstrncpy(g_Dbs.password, password->valuestring, MAX_PASSWORD_SIZE);
    } else if (!password) {
        tstrncpy(g_Dbs.password, "taosdata", MAX_PASSWORD_SIZE);
3774 3775
    }

3776 3777 3778 3779 3780
    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, "./insert_res.txt", MAX_FILE_NAME_LEN);
3781 3782
    }

3783 3784 3785 3786 3787
    cJSON* threads = cJSON_GetObjectItem(root, "thread_count");
    if (threads && threads->type == cJSON_Number) {
        g_Dbs.threadCount = threads->valueint;
    } else if (!threads) {
        g_Dbs.threadCount = 1;
3788
    } else {
3789 3790
        printf("ERROR: failed to read json, threads not found\n");
        goto PARSE_OVER;
3791
    }
3792

3793 3794 3795 3796 3797
    cJSON* threads2 = cJSON_GetObjectItem(root, "thread_count_create_tbl");
    if (threads2 && threads2->type == cJSON_Number) {
        g_Dbs.threadCountByCreateTbl = threads2->valueint;
    } else if (!threads2) {
        g_Dbs.threadCountByCreateTbl = 1;
3798
    } else {
3799 3800 3801
        errorPrint("%s() LN%d, failed to read json, threads2 not found\n",
                __func__, __LINE__);
        goto PARSE_OVER;
3802
    }
3803

3804 3805 3806 3807 3808 3809 3810 3811 3812 3813
    cJSON* gInsertInterval = cJSON_GetObjectItem(root, "insert_interval");
    if (gInsertInterval && gInsertInterval->type == cJSON_Number) {
        if (gInsertInterval->valueint <0) {
            errorPrint("%s() LN%d, failed to read json, insert interval input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
        g_args.insert_interval = gInsertInterval->valueint;
    } else if (!gInsertInterval) {
        g_args.insert_interval = 0;
3814
    } else {
3815 3816 3817
        errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
                __func__, __LINE__);
        goto PARSE_OVER;
3818
    }
3819

3820 3821 3822 3823 3824 3825
    cJSON* interlaceRows = cJSON_GetObjectItem(root, "interlace_rows");
    if (interlaceRows && interlaceRows->type == cJSON_Number) {
        if (interlaceRows->valueint < 0) {
            errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
3826

3827 3828 3829 3830
        }
        g_args.interlace_rows = interlaceRows->valueint;
    } else if (!interlaceRows) {
        g_args.interlace_rows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
3831
    } else {
3832 3833 3834
        errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
                __func__, __LINE__);
        goto PARSE_OVER;
3835 3836
    }

3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
    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 = (1024*1024);
3847
    } else {
3848 3849 3850
        errorPrint("%s() LN%d, failed to read json, max_sql_len input mistake\n",
                __func__, __LINE__);
        goto PARSE_OVER;
3851 3852
    }

3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869
    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.num_of_RPR = numRecPerReq->valueint;
    } else if (!numRecPerReq) {
        g_args.num_of_RPR = MAX_RECORDS_PER_REQ;
3870
    } else {
3871 3872 3873
        errorPrint("%s() LN%d, failed to read json, num_of_records_per_req not found\n",
                __func__, __LINE__);
        goto PARSE_OVER;
3874 3875
    }

3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888
    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 = true;   // default is no, mean answer_yes.
3889
    } else {
3890 3891
        errorPrint("%s", "failed to read json, confirm_parameter_prompt input mistake\n");
        goto PARSE_OVER;
3892 3893
    }

3894 3895 3896 3897 3898 3899 3900 3901
    // rows per table need be less than insert batch
    if (g_args.interlace_rows > g_args.num_of_RPR) {
        printf("NOTICE: interlace rows value %u > num_of_records_per_req %u\n\n",
                g_args.interlace_rows, g_args.num_of_RPR);
        printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
                g_args.num_of_RPR);
        prompt();
        g_args.interlace_rows = g_args.num_of_RPR;
3902 3903
    }

3904 3905 3906 3907
    cJSON* dbs = cJSON_GetObjectItem(root, "databases");
    if (!dbs || dbs->type != cJSON_Array) {
        printf("ERROR: failed to read json, databases not found\n");
        goto PARSE_OVER;
3908
    }
3909

3910 3911 3912 3913 3914 3915
    int dbSize = cJSON_GetArraySize(dbs);
    if (dbSize > MAX_DB_COUNT) {
        errorPrint(
                "ERROR: failed to read json, databases size overflow, max database is %d\n",
                MAX_DB_COUNT);
        goto PARSE_OVER;
3916 3917
    }

3918 3919 3920 3921
    g_Dbs.dbCount = dbSize;
    for (int i = 0; i < dbSize; ++i) {
        cJSON* dbinfos = cJSON_GetArrayItem(dbs, i);
        if (dbinfos == NULL) continue;
3922

3923 3924 3925 3926 3927 3928
        // dbinfo
        cJSON *dbinfo = cJSON_GetObjectItem(dbinfos, "dbinfo");
        if (!dbinfo || dbinfo->type != cJSON_Object) {
            printf("ERROR: failed to read json, dbinfo not found\n");
            goto PARSE_OVER;
        }
3929

3930 3931 3932 3933 3934 3935
        cJSON *dbName = cJSON_GetObjectItem(dbinfo, "name");
        if (!dbName || dbName->type != cJSON_String || dbName->valuestring == NULL) {
            printf("ERROR: failed to read json, db name not found\n");
            goto PARSE_OVER;
        }
        tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, TSDB_DB_NAME_LEN);
3936

3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950
        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() LN%d, failed to read json, drop input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
3951

3952 3953 3954 3955
        cJSON *precision = cJSON_GetObjectItem(dbinfo, "precision");
        if (precision && precision->type == cJSON_String
                && precision->valuestring != NULL) {
            tstrncpy(g_Dbs.db[i].dbCfg.precision, precision->valuestring,
3956
                    SMALL_BUFF_LEN);
3957
        } else if (!precision) {
3958
            memset(g_Dbs.db[i].dbCfg.precision, 0, SMALL_BUFF_LEN);
3959 3960 3961 3962
        } else {
            printf("ERROR: failed to read json, precision not found\n");
            goto PARSE_OVER;
        }
3963

3964 3965 3966 3967 3968
        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;
3969
        } else {
3970 3971
            printf("ERROR: failed to read json, update not found\n");
            goto PARSE_OVER;
3972
        }
3973

3974 3975 3976 3977 3978 3979 3980 3981 3982
        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 {
            printf("ERROR: failed to read json, replica not found\n");
            goto PARSE_OVER;
        }
3983

3984 3985 3986 3987 3988 3989 3990 3991 3992
        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 {
            printf("ERROR: failed to read json, keep not found\n");
            goto PARSE_OVER;
        }
3993

3994 3995 3996 3997 3998
        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;
3999
        } else {
4000
            printf("ERROR: failed to read json, days not found\n");
4001 4002
            goto PARSE_OVER;
        }
4003

4004 4005 4006 4007 4008 4009 4010
        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 {
            printf("ERROR: failed to read json, cache not found\n");
4011
            goto PARSE_OVER;
4012 4013
        }

4014 4015 4016 4017 4018 4019 4020
        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 {
            printf("ERROR: failed to read json, block not found\n");
4021
            goto PARSE_OVER;
4022 4023
        }

4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042
        //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 {
            printf("ERROR: failed to read json, minRows not found\n");
            goto PARSE_OVER;
        }
4043

4044 4045 4046 4047 4048 4049 4050 4051 4052
        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 {
            printf("ERROR: failed to read json, maxRows not found\n");
            goto PARSE_OVER;
        }
4053

4054 4055 4056 4057 4058 4059 4060 4061 4062
        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 {
            printf("ERROR: failed to read json, comp not found\n");
            goto PARSE_OVER;
        }
4063

4064 4065 4066 4067 4068 4069 4070 4071 4072
        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 {
            printf("ERROR: failed to read json, walLevel not found\n");
            goto PARSE_OVER;
        }
4073

4074 4075 4076 4077 4078
        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;
4079
        } else {
4080 4081
            printf("ERROR: failed to read json, cacheLast not found\n");
            goto PARSE_OVER;
4082
        }
4083

4084 4085 4086 4087 4088
        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;
4089
        } else {
4090 4091
            printf("failed to read json, quorum input mistake");
            goto PARSE_OVER;
4092
        }
4093 4094 4095 4096 4097 4098 4099 4100 4101 4102

        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() LN%d, failed to read json, fsync input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
4103 4104
        }

4105 4106 4107 4108 4109 4110
        // super_talbes
        cJSON *stables = cJSON_GetObjectItem(dbinfos, "super_tables");
        if (!stables || stables->type != cJSON_Array) {
            errorPrint("%s() LN%d, failed to read json, super_tables not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
4111
        }
4112

4113 4114 4115 4116 4117 4118
        int stbSize = cJSON_GetArraySize(stables);
        if (stbSize > MAX_SUPER_TABLE_COUNT) {
            errorPrint(
                    "%s() LN%d, failed to read json, supertable size overflow, max supertable is %d\n",
                    __func__, __LINE__, MAX_SUPER_TABLE_COUNT);
            goto PARSE_OVER;
4119
        }
4120

4121 4122 4123 4124
        g_Dbs.db[i].superTblCount = stbSize;
        for (int j = 0; j < stbSize; ++j) {
            cJSON* stbInfo = cJSON_GetArrayItem(stables, j);
            if (stbInfo == NULL) continue;
4125

4126 4127 4128 4129 4130 4131 4132 4133 4134 4135
            // dbinfo
            cJSON *stbName = cJSON_GetObjectItem(stbInfo, "name");
            if (!stbName || stbName->type != cJSON_String
                    || stbName->valuestring == NULL) {
                errorPrint("%s() LN%d, failed to read json, stb name not found\n",
                        __func__, __LINE__);
                goto PARSE_OVER;
            }
            tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
                    TSDB_TABLE_NAME_LEN);
4136

4137 4138 4139 4140 4141 4142
            cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
            if (!prefix || prefix->type != cJSON_String || prefix->valuestring == NULL) {
                printf("ERROR: failed to read json, childtable_prefix not found\n");
                goto PARSE_OVER;
            }
            tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring,
4143
                    TBNAME_PREFIX_LEN);
4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162

            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 {
                printf("ERROR: failed to read json, auto_create_table not found\n");
                goto PARSE_OVER;
            }
4163

4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210
            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 = 1000;
            } else {
                printf("ERROR: 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() LN%d, failed to read json, child_table_exists not found\n",
                        __func__, __LINE__);
                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() LN%d, failed to read json, childtable_count input mistake\n",
                        __func__, __LINE__);
                goto PARSE_OVER;
            }
            g_Dbs.db[i].superTbls[j].childTblCount = count->valueint;

            cJSON *dataSource = cJSON_GetObjectItem(stbInfo, "data_source");
            if (dataSource && dataSource->type == cJSON_String
                    && dataSource->valuestring != NULL) {
                tstrncpy(g_Dbs.db[i].superTbls[j].dataSource,
4211 4212
                        dataSource->valuestring,
                        min(SMALL_BUFF_LEN, strlen(dataSource->valuestring) + 1));
4213
            } else if (!dataSource) {
4214 4215
                tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand",
                        min(SMALL_BUFF_LEN, strlen("rand") + 1));
4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285
            } else {
                errorPrint("%s() LN%d, failed to read json, data_source not found\n",
                        __func__, __LINE__);
                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;
#if STMT_IFACE_ENABLED == 1
                } else if (0 == strcasecmp(stbIface->valuestring, "stmt")) {
                    g_Dbs.db[i].superTbls[j].iface= STMT_IFACE;
#endif
                } else {
                    errorPrint("%s() LN%d, failed to read json, insert_mode %s not recognized\n",
                            __func__, __LINE__, 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) {
                    printf("ERROR: 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)) {
                    printf("ERROR: 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 {
                printf("ERROR: 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) {
4286
                g_Dbs.db[i].superTbls[j].timeStampStep = g_args.timestamp_step;
4287 4288 4289 4290 4291 4292 4293 4294 4295
            } else {
                printf("ERROR: 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,
4296 4297 4298
                        sampleFormat->valuestring,
                        min(SMALL_BUFF_LEN,
                            strlen(sampleFormat->valuestring) + 1));
4299
            } else if (!sampleFormat) {
4300 4301
                tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv",
                        SMALL_BUFF_LEN);
4302 4303 4304 4305 4306 4307 4308 4309 4310
            } else {
                printf("ERROR: 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,
4311 4312 4313
                        sampleFile->valuestring,
                        min(MAX_FILE_NAME_LEN,
                            strlen(sampleFile->valuestring) + 1));
4314
            } else if (!sampleFile) {
4315 4316
                memset(g_Dbs.db[i].superTbls[j].sampleFile, 0,
                        MAX_FILE_NAME_LEN);
4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459
            } else {
                printf("ERROR: failed to read json, sample_file 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 {
                printf("ERROR: 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() LN%d, failed to read json, stbMaxSqlLen input mistake\n",
                        __func__, __LINE__);
                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 {
               printf("ERROR: 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() LN%d, failed to read json, insert_rows input mistake\n",
                            __func__, __LINE__);
                    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() LN%d, failed to read json, insert_rows input mistake\n",
                        __func__, __LINE__);
                goto PARSE_OVER;
            }

            cJSON* stbInterlaceRows = cJSON_GetObjectItem(stbInfo, "interlace_rows");
            if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
                if (stbInterlaceRows->valueint < 0) {
                    errorPrint("%s() LN%d, failed to read json, interlace rows input mistake\n",
                            __func__, __LINE__);
                    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 = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
            } else {
                errorPrint(
                        "%s() LN%d, failed to read json, interlace rows input mistake\n",
                        __func__, __LINE__);
                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 {
                printf("ERROR: 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 = 1000;
            } else {
                printf("ERROR: 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() LN%d, failed to read json, insert_interval input mistake\n",
                            __func__, __LINE__);
                    goto PARSE_OVER;
                }
            } else if (!insertInterval) {
                verbosePrint("%s() LN%d: stable insert interval be overrided by global %"PRIu64".\n",
                        __func__, __LINE__, g_args.insert_interval);
                g_Dbs.db[i].superTbls[j].insertInterval = g_args.insert_interval;
            } else {
                errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
                        __func__, __LINE__);
                goto PARSE_OVER;
            }
4460

4461 4462 4463 4464 4465
            int retVal = getColumnAndTagTypeFromInsertJsonFile(
                    stbInfo, &g_Dbs.db[i].superTbls[j]);
            if (false == retVal) {
                goto PARSE_OVER;
            }
4466
        }
4467
    }
4468

4469
    ret = true;
4470

4471
PARSE_OVER:
4472
    return ret;
4473 4474 4475
}

static bool getMetaFromQueryJsonFile(cJSON* root) {
4476
    bool  ret = false;
4477

4478 4479 4480 4481
    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);
    }
H
hzcheng 已提交
4482

4483 4484 4485 4486 4487
    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, "127.0.0.1", MAX_HOSTNAME_SIZE);
H
hzcheng 已提交
4488
    } else {
4489 4490
        printf("ERROR: failed to read json, host not found\n");
        goto PARSE_OVER;
H
hzcheng 已提交
4491
    }
4492

4493 4494 4495 4496 4497
    cJSON* port = cJSON_GetObjectItem(root, "port");
    if (port && port->type == cJSON_Number) {
        g_queryInfo.port = port->valueint;
    } else if (!port) {
        g_queryInfo.port = 6030;
4498
    }
4499

4500 4501 4502 4503 4504
    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, "root", MAX_USERNAME_SIZE); ;
4505 4506
    }

4507 4508 4509 4510 4511 4512
    cJSON* password = cJSON_GetObjectItem(root, "password");
    if (password && password->type == cJSON_String && password->valuestring != NULL) {
        tstrncpy(g_queryInfo.password, password->valuestring, MAX_PASSWORD_SIZE);
    } else if (!password) {
        tstrncpy(g_queryInfo.password, "taosdata", MAX_PASSWORD_SIZE);;
    }
4513

4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525
    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;
4526
    } else {
4527 4528
        printf("ERROR: failed to read json, confirm_parameter_prompt not found\n");
        goto PARSE_OVER;
4529
    }
4530

4531 4532 4533 4534 4535 4536 4537 4538 4539 4540
    cJSON* gQueryTimes = cJSON_GetObjectItem(root, "query_times");
    if (gQueryTimes && gQueryTimes->type == cJSON_Number) {
        if (gQueryTimes->valueint <= 0) {
            errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
        g_args.query_times = gQueryTimes->valueint;
    } else if (!gQueryTimes) {
        g_args.query_times = 1;
4541
    } else {
4542 4543 4544
        errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
                __func__, __LINE__);
        goto PARSE_OVER;
4545
    }
4546

4547 4548 4549 4550 4551 4552
    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) {
        printf("ERROR: failed to read json, databases not found\n");
        goto PARSE_OVER;
4553
    }
4554

4555
    cJSON* queryMode = cJSON_GetObjectItem(root, "query_mode");
4556 4557 4558 4559 4560
    if (queryMode
            && queryMode->type == cJSON_String
            && queryMode->valuestring != NULL) {
        tstrncpy(g_queryInfo.queryMode, queryMode->valuestring,
                min(SMALL_BUFF_LEN, strlen(queryMode->valuestring) + 1));
4561
    } else if (!queryMode) {
4562 4563
        tstrncpy(g_queryInfo.queryMode, "taosc",
                min(SMALL_BUFF_LEN, strlen("taosc") + 1));
4564
    } else {
4565 4566
        printf("ERROR: failed to read json, query_mode not found\n");
        goto PARSE_OVER;
4567
    }
4568

4569 4570 4571 4572 4573 4574 4575
    // 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) {
        printf("ERROR: failed to read json, super_table_query not found\n");
4576 4577
        goto PARSE_OVER;
    } else {
4578 4579 4580 4581 4582 4583
        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;
        }
4584

4585 4586 4587 4588 4589 4590 4591 4592
        cJSON* specifiedQueryTimes = cJSON_GetObjectItem(specifiedQuery,
                "query_times");
        if (specifiedQueryTimes && specifiedQueryTimes->type == cJSON_Number) {
            if (specifiedQueryTimes->valueint <= 0) {
                errorPrint(
                        "%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
                        __func__, __LINE__, specifiedQueryTimes->valueint);
                goto PARSE_OVER;
4593

4594 4595 4596 4597
            }
            g_queryInfo.specifiedQueryInfo.queryTimes = specifiedQueryTimes->valueint;
        } else if (!specifiedQueryTimes) {
            g_queryInfo.specifiedQueryInfo.queryTimes = g_args.query_times;
4598
        } else {
4599 4600 4601
            errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
4602
        }
4603

4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617
        cJSON* concurrent = cJSON_GetObjectItem(specifiedQuery, "concurrent");
        if (concurrent && concurrent->type == cJSON_Number) {
            if (concurrent->valueint <= 0) {
                errorPrint(
                        "%s() LN%d, query sqlCount %d or concurrent %d is not correct.\n",
                        __func__, __LINE__,
                        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;
        }
4618

4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633
        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() LN%d, failed to read json, async mode input error\n",
                        __func__, __LINE__);
                goto PARSE_OVER;
            }
        } else {
            g_queryInfo.specifiedQueryInfo.asyncMode = SYNC_MODE;
        }
4634

4635 4636 4637 4638 4639 4640 4641 4642
        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 = 10000;
        }
4643

4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656
        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 {
                printf("ERROR: failed to read json, subscribe restart error\n");
                goto PARSE_OVER;
            }
        } else {
            g_queryInfo.specifiedQueryInfo.subscribeRestart = true;
        }
4657

4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672
        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 {
                printf("ERROR: failed to read json, subscribe keepProgress error\n");
                goto PARSE_OVER;
            }
        } else {
            g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
        }
4673

4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
        // sqls
        cJSON* specifiedSqls = cJSON_GetObjectItem(specifiedQuery, "sqls");
        if (!specifiedSqls) {
            g_queryInfo.specifiedQueryInfo.sqlCount = 0;
        } else if (specifiedSqls->type != cJSON_Array) {
            errorPrint("%s() LN%d, failed to read json, super sqls not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        } else {
            int superSqlSize = cJSON_GetArraySize(specifiedSqls);
            if (superSqlSize * g_queryInfo.specifiedQueryInfo.concurrent
                    > MAX_QUERY_SQL_COUNT) {
                errorPrint("%s() LN%d, failed to read json, query sql(%d) * concurrent(%d) overflow, max is %d\n",
                        __func__, __LINE__,
                        superSqlSize,
                        g_queryInfo.specifiedQueryInfo.concurrent,
                        MAX_QUERY_SQL_COUNT);
                goto PARSE_OVER;
            }
4693

4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704
            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) {
                    printf("ERROR: failed to read json, sql not found\n");
                    goto PARSE_OVER;
                }
                tstrncpy(g_queryInfo.specifiedQueryInfo.sql[j],
4705
                        sqlStr->valuestring, BUFFER_SIZE);
4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745

                // 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 {
                    printf("ERROR: failed to read json, super query result file not found\n");
                    goto PARSE_OVER;
                }
            }
        }
4746
    }
4747

4748 4749 4750 4751 4752 4753 4754 4755
    // 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) {
        printf("ERROR: failed to read json, sub_table_query not found\n");
        ret = true;
4756 4757
        goto PARSE_OVER;
    } else {
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779
        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("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
                        __func__, __LINE__, 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() LN%d, failed to read json, query_times input mistake\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        }
4780

4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873
        cJSON* threads = cJSON_GetObjectItem(superQuery, "threads");
        if (threads && threads->type == cJSON_Number) {
            if (threads->valueint <= 0) {
                errorPrint("%s() LN%d, failed to read json, threads input mistake\n",
                        __func__, __LINE__);
                goto PARSE_OVER;

            }
            g_queryInfo.superQueryInfo.threadCnt = threads->valueint;
        } else if (!threads) {
            g_queryInfo.superQueryInfo.threadCnt = 1;
        }

        //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.sTblName, stblname->valuestring,
                    TSDB_TABLE_NAME_LEN);
        } else {
            errorPrint("%s() LN%d, failed to read json, super table name input error\n",
                    __func__, __LINE__);
            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() LN%d, failed to read json, async mode input error\n",
                        __func__, __LINE__);
                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() LN%d, failed to read json, interval input mistake\n",
                        __func__, __LINE__);
                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 = 10000;
        }

        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 {
                printf("ERROR: 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 {
                printf("ERROR: 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
4874
        g_queryInfo.superQueryInfo.endAfterConsume = -1;
4875 4876 4877 4878 4879 4880 4881 4882 4883
        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;
4884

4885
        // default value is -1, which mean do not resub
4886
        g_queryInfo.superQueryInfo.resubAfterConsume = -1;
4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912
        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() LN%d: failed to read json, super sqls not found\n",
                    __func__, __LINE__);
            goto PARSE_OVER;
        } else {
            int superSqlSize = cJSON_GetArraySize(superSqls);
            if (superSqlSize > MAX_QUERY_SQL_COUNT) {
                errorPrint("%s() LN%d, failed to read json, query sql size overflow, max is %d\n",
                        __func__, __LINE__, MAX_QUERY_SQL_COUNT);
                goto PARSE_OVER;
            }
4913

4914 4915 4916 4917
            g_queryInfo.superQueryInfo.sqlCount = superSqlSize;
            for (int j = 0; j < superSqlSize; ++j) {
                cJSON* sql = cJSON_GetArrayItem(superSqls, j);
                if (sql == NULL) continue;
4918

4919 4920 4921 4922 4923 4924 4925 4926
                cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
                if (!sqlStr || sqlStr->type != cJSON_String
                        || sqlStr->valuestring == NULL) {
                    errorPrint("%s() LN%d, failed to read json, sql not found\n",
                            __func__, __LINE__);
                    goto PARSE_OVER;
                }
                tstrncpy(g_queryInfo.superQueryInfo.sql[j], sqlStr->valuestring,
4927
                        BUFFER_SIZE);
4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941

                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() LN%d, failed to read json, sub query result file not found\n",
                            __func__, __LINE__);
                    goto PARSE_OVER;
                }
            }
4942
        }
4943
    }
H
hzcheng 已提交
4944

4945
    ret = true;
H
hzcheng 已提交
4946

4947
PARSE_OVER:
4948
    return ret;
4949
}
H
hzcheng 已提交
4950

4951
static bool getInfoFromJsonFile(char* file) {
4952
    debugPrint("%s %d %s\n", __func__, __LINE__, file);
4953

4954 4955 4956 4957 4958
    FILE *fp = fopen(file, "r");
    if (!fp) {
        printf("failed to read %s, reason:%s\n", file, strerror(errno));
        return false;
    }
H
Hui Li 已提交
4959

4960 4961 4962 4963 4964 4965 4966 4967 4968 4969
    bool  ret = false;
    int   maxLen = 6400000;
    char *content = calloc(1, maxLen + 1);
    int   len = fread(content, 1, maxLen, fp);
    if (len <= 0) {
        free(content);
        fclose(fp);
        printf("failed to read %s, content is null", file);
        return false;
    }
H
Hui Li 已提交
4970

4971 4972 4973 4974 4975 4976
    content[len] = 0;
    cJSON* root = cJSON_Parse(content);
    if (root == NULL) {
        printf("ERROR: failed to cjson parse %s, invalid json format\n", file);
        goto PARSE_OVER;
    }
H
Hui Li 已提交
4977

4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
    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 {
            printf("ERROR: failed to read json, filetype not support\n");
            goto PARSE_OVER;
        }
    } else if (!filetype) {
        g_args.test_mode = INSERT_TEST;
4992
    } else {
4993 4994
        printf("ERROR: failed to read json, filetype not found\n");
        goto PARSE_OVER;
4995
    }
H
hzcheng 已提交
4996

4997 4998 4999 5000 5001 5002 5003 5004 5005 5006
    if (INSERT_TEST == g_args.test_mode) {
        ret = getMetaFromInsertJsonFile(root);
    } else if ((QUERY_TEST == g_args.test_mode)
            || (SUBSCRIBE_TEST == g_args.test_mode)) {
        ret = getMetaFromQueryJsonFile(root);
    } else {
        errorPrint("%s() LN%d, input json file type error! please input correct file type: insert or query or subscribe\n",
                __func__, __LINE__);
        goto PARSE_OVER;
    }
5007

5008
PARSE_OVER:
5009 5010 5011 5012
    free(content);
    cJSON_Delete(root);
    fclose(fp);
    return ret;
5013
}
H
hzcheng 已提交
5014

5015
static int prepareSampleData() {
5016 5017 5018 5019 5020 5021 5022
    for (int i = 0; i < g_Dbs.dbCount; i++) {
        for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
            if (g_Dbs.db[i].superTbls[j].tagsFile[0] != 0) {
                if (readTagFromCsvFileToMem(&g_Dbs.db[i].superTbls[j]) != 0) {
                    return -1;
                }
            }
5023
        }
5024
    }
5025

5026
    return 0;
5027 5028
}

5029
static void postFreeResource() {
5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049
    tmfclose(g_fpOfInsertResult);
    for (int i = 0; i < g_Dbs.dbCount; i++) {
        for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
            if (0 != g_Dbs.db[i].superTbls[j].colsOfCreateChildTable) {
                free(g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
                g_Dbs.db[i].superTbls[j].colsOfCreateChildTable = NULL;
            }
            if (0 != g_Dbs.db[i].superTbls[j].sampleDataBuf) {
                free(g_Dbs.db[i].superTbls[j].sampleDataBuf);
                g_Dbs.db[i].superTbls[j].sampleDataBuf = NULL;
            }
            if (0 != g_Dbs.db[i].superTbls[j].tagDataBuf) {
                free(g_Dbs.db[i].superTbls[j].tagDataBuf);
                g_Dbs.db[i].superTbls[j].tagDataBuf = NULL;
            }
            if (0 != g_Dbs.db[i].superTbls[j].childTblName) {
                free(g_Dbs.db[i].superTbls[j].childTblName);
                g_Dbs.db[i].superTbls[j].childTblName = NULL;
            }
        }
S
Shuaiqiang Chang 已提交
5050
    }
5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061

    tmfree(g_randbool_buff);
    tmfree(g_randint_buff);
    tmfree(g_rand_voltage_buff);
    tmfree(g_randbigint_buff);
    tmfree(g_randsmallint_buff);
    tmfree(g_randtinyint_buff);
    tmfree(g_randfloat_buff);
    tmfree(g_rand_current_buff);
    tmfree(g_rand_phase_buff);
    tmfree(g_randdouble_buff);
5062
}
S
Shuaiqiang Chang 已提交
5063

5064 5065
static int getRowDataFromSample(
        char* dataBuf, int64_t maxLen, int64_t timestamp,
5066
        SSuperTable* superTblInfo, int64_t* sampleUsePos)
5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091
{
    if ((*sampleUsePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
        /*    int ret = readSampleFromCsvFileToMem(superTblInfo);
              if (0 != ret) {
              tmfree(superTblInfo->sampleDataBuf);
              superTblInfo->sampleDataBuf = NULL;
              return -1;
              }
              */
        *sampleUsePos = 0;
    }

    int    dataLen = 0;

    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
            "(%" PRId64 ", ", timestamp);
    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
            "%s",
            superTblInfo->sampleDataBuf
            + superTblInfo->lenOfOneRow * (*sampleUsePos));
    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen, ")");

    (*sampleUsePos)++;

    return dataLen;
5092
}
S
Shuaiqiang Chang 已提交
5093

5094 5095
static int64_t generateStbRowData(
        SSuperTable* stbInfo,
5096 5097 5098
        char* recBuf,
        int64_t remainderBufLen,
        int64_t timestamp)
5099
{
5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116
    int64_t   dataLen = 0;
    char  *pstr = recBuf;
    int64_t maxLen = MAX_DATA_SIZE;

    dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
            "(%" PRId64 ",", timestamp);

    for (int i = 0; i < stbInfo->columnCount; i++) {
        if ((0 == strncasecmp(stbInfo->columns[i].dataType,
                        "BINARY", strlen("BINARY")))
                || (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "NCHAR", strlen("NCHAR")))) {
            if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
                errorPrint( "binary or nchar length overflow, max size:%u\n",
                        (uint32_t)TSDB_MAX_BINARY_LEN);
                return -1;
            }
5117

5118 5119 5120 5121 5122 5123 5124 5125
            char* buf = (char*)calloc(stbInfo->columns[i].dataLen+1, 1);
            if (NULL == buf) {
                errorPrint( "calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
                return -1;
            }
            rand_string(buf, stbInfo->columns[i].dataLen);
            dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
            tmfree(buf);
5126

5127 5128 5129 5130 5131 5132 5133
        } else {
            char *tmp;

            if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "INT", strlen("INT"))) {
                if ((g_args.demo_mode) && (i == 1)) {
                    tmp = demo_voltage_int_str();
5134
                } else {
5135
                    tmp = rand_int_str();
5136
                }
5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176
                tstrncpy(pstr + dataLen, tmp, INT_BUFF_LEN);
            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "BIGINT", strlen("BIGINT"))) {
                tmp = rand_bigint_str();
                tstrncpy(pstr + dataLen, tmp, BIGINT_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "FLOAT", strlen("FLOAT"))) {
                if (g_args.demo_mode) {
                    if (i == 0) {
                        tmp = demo_current_float_str();
                    } else {
                        tmp = demo_phase_float_str();
                    }
                } else {
                    tmp = rand_float_str();
                }
                tstrncpy(pstr + dataLen, tmp, FLOAT_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "DOUBLE", strlen("DOUBLE"))) {
                tmp = rand_double_str();
                tstrncpy(pstr + dataLen, tmp, DOUBLE_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "SMALLINT", strlen("SMALLINT"))) {
                tmp = rand_smallint_str();
                tstrncpy(pstr + dataLen, tmp, SMALLINT_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "TINYINT", strlen("TINYINT"))) {
                tmp = rand_tinyint_str();
                tstrncpy(pstr + dataLen, tmp, TINYINT_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "BOOL", strlen("BOOL"))) {
                tmp = rand_bool_str();
                tstrncpy(pstr + dataLen, tmp, BOOL_BUFF_LEN);
            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
                        "TIMESTAMP", strlen("TIMESTAMP"))) {
                tmp = rand_int_str();
                tstrncpy(pstr + dataLen, tmp, INT_BUFF_LEN);
            }  else {
                errorPrint( "Not support data type: %s\n", stbInfo->columns[i].dataType);
                return -1;
5177
            }
5178 5179 5180 5181

            dataLen += strlen(tmp);
            tstrncpy(pstr + dataLen, ",", 2);
            dataLen += 1;
5182
        }
5183

5184
        if (dataLen > (remainderBufLen - (DOUBLE_BUFF_LEN + 1)))
5185
            return 0;
5186
    }
5187

5188 5189
    dataLen -= 1;
    dataLen += snprintf(pstr + dataLen, maxLen - dataLen, ")");
5190

5191 5192
    verbosePrint("%s() LN%d, dataLen:%"PRId64"\n", __func__, __LINE__, dataLen);
    verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
5193

5194
    return strlen(recBuf);
5195
}
S
Shuaiqiang Chang 已提交
5196

5197
static int64_t generateData(char *recBuf, char **data_type,
5198
        int64_t timestamp, int lenOfBinary) {
5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244
    memset(recBuf, 0, MAX_DATA_SIZE);
    char *pstr = recBuf;
    pstr += sprintf(pstr, "(%" PRId64, timestamp);

    int columnCount = g_args.num_of_CPR;

    for (int i = 0; i < columnCount; i++) {
        if (strcasecmp(data_type[i % columnCount], "TINYINT") == 0) {
            pstr += sprintf(pstr, ",%d", rand_tinyint() );
        } else if (strcasecmp(data_type[i % columnCount], "SMALLINT") == 0) {
            pstr += sprintf(pstr, ",%d", rand_smallint());
        } else if (strcasecmp(data_type[i % columnCount], "INT") == 0) {
            pstr += sprintf(pstr, ",%d", rand_int());
        } else if (strcasecmp(data_type[i % columnCount], "BIGINT") == 0) {
            pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
        } else if (strcasecmp(data_type[i % columnCount], "TIMESTAMP") == 0) {
            pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
        } else if (strcasecmp(data_type[i % columnCount], "FLOAT") == 0) {
            pstr += sprintf(pstr, ",%10.4f", rand_float());
        } else if (strcasecmp(data_type[i % columnCount], "DOUBLE") == 0) {
            double t = rand_double();
            pstr += sprintf(pstr, ",%20.8f", t);
        } else if (strcasecmp(data_type[i % columnCount], "BOOL") == 0) {
            bool b = rand_bool() & 1;
            pstr += sprintf(pstr, ",%s", b ? "true" : "false");
        } else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
            char *s = malloc(lenOfBinary + 1);
            if (s == NULL) {
                errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
                        __func__, __LINE__, lenOfBinary + 1);
                exit(-1);
            }
            rand_string(s, lenOfBinary);
            pstr += sprintf(pstr, ",\"%s\"", s);
            free(s);
        } else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
            char *s = malloc(lenOfBinary + 1);
            if (s == NULL) {
                errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
                        __func__, __LINE__, lenOfBinary + 1);
                exit(-1);
            }
            rand_string(s, lenOfBinary);
            pstr += sprintf(pstr, ",\"%s\"", s);
            free(s);
        }
5245

5246 5247 5248 5249
        if (strlen(recBuf) > MAX_DATA_SIZE) {
            perror("column length too long, abort");
            exit(-1);
        }
5250 5251
    }

5252
    pstr += sprintf(pstr, ")");
5253

5254
    verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
5255

5256
    return (int32_t)strlen(recBuf);
5257 5258
}

5259
static int prepareSampleDataForSTable(SSuperTable *superTblInfo) {
5260
    char* sampleDataBuf = NULL;
5261

5262
    sampleDataBuf = calloc(
5263
            superTblInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE, 1);
5264 5265 5266 5267 5268 5269 5270
    if (sampleDataBuf == NULL) {
        errorPrint("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
                __func__, __LINE__,
                superTblInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE,
                strerror(errno));
        return -1;
    }
5271

5272 5273
    superTblInfo->sampleDataBuf = sampleDataBuf;
    int ret = readSampleFromCsvFileToMem(superTblInfo);
5274

5275 5276 5277 5278 5279 5280 5281
    if (0 != ret) {
        errorPrint("%s() LN%d, read sample from csv file failed.\n",
                __func__, __LINE__);
        tmfree(sampleDataBuf);
        superTblInfo->sampleDataBuf = NULL;
        return -1;
    }
5282

5283
    return 0;
5284 5285
}

5286
static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
5287
{
5288 5289
    int32_t affectedRows;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
5290

5291
    verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
S
Shuduo Sang 已提交
5292
            __func__, __LINE__, pThreadInfo->buffer);
S
Shuduo Sang 已提交
5293

5294 5295 5296
    uint16_t iface;
    if (superTblInfo)
        iface = superTblInfo->iface;
5297 5298 5299 5300 5301 5302
    else {
        if (g_args.iface == INTERFACE_BUT)
            iface = TAOSC_IFACE;
        else
            iface = g_args.iface;
    }
5303 5304 5305

    debugPrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
            __func__, __LINE__,
5306 5307
            (iface==TAOSC_IFACE)?
            "taosc":(iface==REST_IFACE)?"rest":"stmt");
5308 5309 5310 5311 5312 5313 5314 5315 5316 5317

    switch(iface) {
        case TAOSC_IFACE:
            affectedRows = queryDbExec(
                    pThreadInfo->taos,
                    pThreadInfo->buffer, INSERT_TYPE, false);
            break;

        case REST_IFACE:
            if (0 != postProceSql(g_Dbs.host, &g_Dbs.serv_addr, g_Dbs.port,
5318
                        pThreadInfo->buffer, pThreadInfo)) {
5319 5320 5321 5322 5323 5324 5325 5326
                affectedRows = -1;
                printf("========restful return fail, threadID[%d]\n",
                        pThreadInfo->threadID);
            } else {
                affectedRows = k;
            }
            break;

5327
#if STMT_IFACE_ENABLED == 1
5328
        case STMT_IFACE:
5329 5330
            debugPrint("%s() LN%d, stmt=%p",
                    __func__, __LINE__, pThreadInfo->stmt);
5331
            if (0 != taos_stmt_execute(pThreadInfo->stmt)) {
5332 5333
                errorPrint("%s() LN%d, failied to execute insert statement. reason: %s\n",
                        __func__, __LINE__, taos_stmt_errstr(pThreadInfo->stmt));
5334 5335

                fprintf(stderr, "\n\033[31m === Please reduce batch number if WAL size exceeds limit. ===\033[0m\n\n");
5336 5337 5338 5339
                exit(-1);
            }
            affectedRows = k;
            break;
5340
#endif
5341 5342 5343 5344 5345

        default:
            errorPrint("%s() LN%d: unknown insert mode: %d\n",
                    __func__, __LINE__, superTblInfo->iface);
            affectedRows = 0;
5346
    }
5347

5348
    return affectedRows;
5349 5350
}

5351 5352
static void getTableName(char *pTblName,
        threadInfo* pThreadInfo, uint64_t tableSeq)
5353
{
5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
    if (superTblInfo) {
        if (AUTO_CREATE_SUBTBL != superTblInfo->autoCreateTable) {
            if (superTblInfo->childTblLimit > 0) {
                snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
                        superTblInfo->childTblName +
                        (tableSeq - superTblInfo->childTblOffset) * TSDB_TABLE_NAME_LEN);
            } else {
                verbosePrint("[%d] %s() LN%d: from=%"PRIu64" count=%"PRId64" seq=%"PRIu64"\n",
                        pThreadInfo->threadID, __func__, __LINE__,
                        pThreadInfo->start_table_from,
                        pThreadInfo->ntables, tableSeq);
                snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
                        superTblInfo->childTblName + tableSeq * TSDB_TABLE_NAME_LEN);
            }
        } else {
            snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
                    superTblInfo->childTblPrefix, tableSeq);
        }
5373
    } else {
5374 5375
        snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
                g_args.tb_prefix, tableSeq);
5376 5377 5378
    }
}

5379
static int32_t generateDataTailWithoutStb(
5380
        uint32_t batch, char* buffer,
5381
        int64_t remainderBufLen, int64_t insertRows,
5382
        uint64_t recordFrom, int64_t startTime,
5383
        /* int64_t *pSamplePos, */int64_t *dataLen) {
5384

5385 5386
    uint64_t len = 0;
    char *pstr = buffer;
5387

5388
    verbosePrint("%s() LN%d batch=%d\n", __func__, __LINE__, batch);
5389

5390 5391
    int32_t k = 0;
    for (k = 0; k < batch;) {
5392
        char *data = pstr;
5393
        memset(data, 0, MAX_DATA_SIZE);
5394

5395
        int64_t retLen = 0;
5396

5397 5398
        char **data_type = g_args.datatype;
        int lenOfBinary = g_args.len_of_binary;
5399

5400 5401 5402
        if (g_args.disorderRatio) {
            retLen = generateData(data, data_type,
                    startTime + getTSRandTail(
5403
                        g_args.timestamp_step, k,
5404 5405 5406 5407 5408
                        g_args.disorderRatio,
                        g_args.disorderRange),
                    lenOfBinary);
        } else {
            retLen = generateData(data, data_type,
5409
                    startTime + g_args.timestamp_step * k,
5410 5411
                    lenOfBinary);
        }
5412

5413 5414
        if (len > remainderBufLen)
            break;
5415

5416
        pstr += retLen;
5417 5418 5419
        k++;
        len += retLen;
        remainderBufLen -= retLen;
5420

5421 5422
        verbosePrint("%s() LN%d len=%"PRIu64" k=%d \nbuffer=%s\n",
                __func__, __LINE__, len, k, buffer);
5423

5424
        recordFrom ++;
5425

5426 5427 5428
        if (recordFrom >= insertRows) {
            break;
        }
5429
    }
5430

5431 5432
    *dataLen = len;
    return k;
5433 5434
}

5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451
static int64_t getTSRandTail(int64_t timeStampStep, int32_t seq,
        int disorderRatio, int disorderRange)
{
    int64_t randTail = timeStampStep * seq;
    if (disorderRatio > 0) {
        int rand_num = taosRandom() % 100;
        if(rand_num < disorderRatio) {
            randTail = (randTail +
                    (taosRandom() % disorderRange + 1)) * (-1);
            debugPrint("rand data generated, back %"PRId64"\n", randTail);
        }
    }

    return randTail;
}

static int32_t generateStbDataTail(
5452
        SSuperTable* superTblInfo,
5453
        uint32_t batch, char* buffer,
5454
        int64_t remainderBufLen, int64_t insertRows,
5455
        uint64_t recordFrom, int64_t startTime,
5456
        int64_t *pSamplePos, int64_t *dataLen) {
5457
    uint64_t len = 0;
5458

5459
    char *pstr = buffer;
5460

5461 5462 5463 5464 5465 5466 5467 5468
    bool tsRand;
    if (0 == strncasecmp(superTblInfo->dataSource, "rand", strlen("rand"))) {
        tsRand = true;
    } else {
        tsRand = false;
    }
    verbosePrint("%s() LN%d batch=%u buflen=%"PRId64"\n",
            __func__, __LINE__, batch, remainderBufLen);
5469

5470 5471
    int32_t k;
    for (k = 0; k < batch;) {
5472
        char *data = pstr;
5473

5474
        int64_t lenOfRow = 0;
5475

5476 5477 5478
        if (tsRand) {
            if (superTblInfo->disorderRatio > 0) {
                lenOfRow = generateStbRowData(superTblInfo, data,
5479
                        remainderBufLen,
5480 5481 5482 5483 5484 5485 5486
                        startTime + getTSRandTail(
                            superTblInfo->timeStampStep, k,
                            superTblInfo->disorderRatio,
                            superTblInfo->disorderRange)
                        );
            } else {
                lenOfRow = generateStbRowData(superTblInfo, data,
5487
                        remainderBufLen,
5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498
                        startTime + superTblInfo->timeStampStep * k
                        );
            }
        } else {
            lenOfRow = getRowDataFromSample(
                    data,
                    (remainderBufLen < MAX_DATA_SIZE)?remainderBufLen:MAX_DATA_SIZE,
                    startTime + superTblInfo->timeStampStep * k,
                    superTblInfo,
                    pSamplePos);
        }
5499

5500 5501 5502 5503
        if (lenOfRow == 0) {
            data[0] = '\0';
            break;
        }
5504 5505 5506
        if ((lenOfRow + 1) > remainderBufLen) {
            break;
        }
5507

5508
        pstr += lenOfRow;
5509 5510 5511
        k++;
        len += lenOfRow;
        remainderBufLen -= lenOfRow;
5512

5513 5514
        verbosePrint("%s() LN%d len=%"PRIu64" k=%u \nbuffer=%s\n",
                __func__, __LINE__, len, k, buffer);
5515

5516
        recordFrom ++;
5517

5518 5519 5520
        if (recordFrom >= insertRows) {
            break;
        }
5521
    }
5522

5523 5524
    *dataLen = len;
    return k;
5525
}
5526

5527 5528 5529

static int generateSQLHeadWithoutStb(char *tableName,
        char *dbName,
5530
        char *buffer, int remainderBufLen)
5531
{
5532
    int len;
5533

5534
    char headBuf[HEAD_BUFF_LEN];
5535

5536 5537 5538 5539 5540 5541
    len = snprintf(
            headBuf,
            HEAD_BUFF_LEN,
            "%s.%s values",
            dbName,
            tableName);
5542

5543 5544
    if (len > remainderBufLen)
        return -1;
5545

5546
    tstrncpy(buffer, headBuf, len + 1);
5547

5548
    return len;
5549 5550 5551 5552
}

static int generateStbSQLHead(
        SSuperTable* superTblInfo,
5553
        char *tableName, int64_t tableSeq,
5554 5555 5556
        char *dbName,
        char *buffer, int remainderBufLen)
{
5557
    int len;
5558

5559
    char headBuf[HEAD_BUFF_LEN];
5560

5561 5562 5563
    if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) {
        char* tagsValBuf = NULL;
        if (0 == superTblInfo->tagSource) {
5564
            tagsValBuf = generateTagValuesForStb(superTblInfo, tableSeq);
5565
        } else {
5566 5567 5568
            tagsValBuf = getTagValueFromTagSample(
                    superTblInfo,
                    tableSeq % superTblInfo->tagSampleCount);
5569 5570 5571 5572 5573 5574
        }
        if (NULL == tagsValBuf) {
            errorPrint("%s() LN%d, tag buf failed to allocate  memory\n",
                    __func__, __LINE__);
            return -1;
        }
5575

5576 5577 5578 5579 5580 5581 5582 5583 5584 5585
        len = snprintf(
                headBuf,
                HEAD_BUFF_LEN,
                "%s.%s using %s.%s TAGS%s values",
                dbName,
                tableName,
                dbName,
                superTblInfo->sTblName,
                tagsValBuf);
        tmfree(tagsValBuf);
5586
    } else if (TBL_ALREADY_EXISTS == superTblInfo->childTblExists) {
5587 5588 5589 5590 5591 5592
        len = snprintf(
                headBuf,
                HEAD_BUFF_LEN,
                "%s.%s values",
                dbName,
                tableName);
5593
    } else {
5594 5595 5596 5597 5598 5599 5600
        len = snprintf(
                headBuf,
                HEAD_BUFF_LEN,
                "%s.%s values",
                dbName,
                tableName);
    }
5601

5602 5603
    if (len > remainderBufLen)
        return -1;
5604

5605
    tstrncpy(buffer, headBuf, len + 1);
5606

5607
    return len;
5608 5609
}

5610
static int32_t generateStbInterlaceData(
5611
        SSuperTable *superTblInfo,
5612 5613 5614
        char *tableName, uint32_t batchPerTbl,
        uint64_t i,
        uint32_t batchPerTblTimes,
5615
        uint64_t tableSeq,
5616
        threadInfo *pThreadInfo, char *buffer,
5617
        int64_t insertRows,
5618
        int64_t startTime,
5619
        uint64_t *pRemainderBufLen)
5620
{
5621 5622
    assert(buffer);
    char *pstr = buffer;
5623

5624 5625 5626 5627
    int headLen = generateStbSQLHead(
            superTblInfo,
            tableName, tableSeq, pThreadInfo->db_name,
            pstr, *pRemainderBufLen);
5628

5629 5630 5631 5632 5633
    if (headLen <= 0) {
        return 0;
    }
    // generate data buffer
    verbosePrint("[%d] %s() LN%d i=%"PRIu64" buffer:\n%s\n",
5634
            pThreadInfo->threadID, __func__, __LINE__, i, buffer);
5635

5636 5637
    pstr += headLen;
    *pRemainderBufLen -= headLen;
5638

5639
    int64_t dataLen = 0;
5640

5641
    verbosePrint("[%d] %s() LN%d i=%"PRIu64" batchPerTblTimes=%u batchPerTbl = %u\n",
5642 5643
            pThreadInfo->threadID, __func__, __LINE__,
            i, batchPerTblTimes, batchPerTbl);
5644

5645 5646 5647
    if (0 == strncasecmp(superTblInfo->startTimestamp, "now", 3)) {
        startTime = taosGetTimestamp(pThreadInfo->time_precision);
    }
5648

5649
    int32_t k = generateStbDataTail(
5650 5651 5652 5653
            superTblInfo,
            batchPerTbl, pstr, *pRemainderBufLen, insertRows, 0,
            startTime,
            &(pThreadInfo->samplePos), &dataLen);
5654

5655 5656 5657 5658 5659 5660 5661 5662 5663 5664
    if (k == batchPerTbl) {
        pstr += dataLen;
        *pRemainderBufLen -= dataLen;
    } else {
        debugPrint("%s() LN%d, generated data tail: %u, not equal batch per table: %u\n",
                __func__, __LINE__, k, batchPerTbl);
        pstr -= headLen;
        pstr[0] = '\0';
        k = 0;
    }
5665

5666
    return k;
5667 5668 5669
}

static int64_t generateInterlaceDataWithoutStb(
5670
        char *tableName, uint32_t batch,
5671 5672 5673
        uint64_t tableSeq,
        char *dbName, char *buffer,
        int64_t insertRows,
5674
        int64_t startTime,
5675 5676
        uint64_t *pRemainderBufLen)
{
5677 5678
    assert(buffer);
    char *pstr = buffer;
5679

5680 5681
    int headLen = generateSQLHeadWithoutStb(
            tableName, dbName,
5682 5683
            pstr, *pRemainderBufLen);

5684 5685 5686
    if (headLen <= 0) {
        return 0;
    }
5687

5688 5689
    pstr += headLen;
    *pRemainderBufLen -= headLen;
5690

5691
    int64_t dataLen = 0;
5692

5693
    int32_t k = generateDataTailWithoutStb(
5694
            batch, pstr, *pRemainderBufLen, insertRows, 0,
5695
            startTime,
5696
            &dataLen);
5697

5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709
    if (k == batch) {
        pstr += dataLen;
        *pRemainderBufLen -= dataLen;
    } else {
        debugPrint("%s() LN%d, generated data tail: %d, not equal batch per table: %u\n",
                __func__, __LINE__, k, batch);
        pstr -= headLen;
        pstr[0] = '\0';
        k = 0;
    }

    return k;
5710 5711
}

5712
#if STMT_IFACE_ENABLED == 1
5713
static int32_t prepareStmtBindArrayByType(TAOS_BIND *bind,
5714
        char *dataType, int32_t dataLen, char **ptr, char *value)
5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725
{
    if (0 == strncasecmp(dataType,
                "BINARY", strlen("BINARY"))) {
        if (dataLen > TSDB_MAX_BINARY_LEN) {
            errorPrint( "binary length overflow, max size:%u\n",
                    (uint32_t)TSDB_MAX_BINARY_LEN);
            return -1;
        }
        char *bind_binary = (char *)*ptr;

        bind->buffer_type = TSDB_DATA_TYPE_BINARY;
5726 5727 5728 5729 5730 5731 5732 5733
        if (value) {
            strncpy(bind_binary, value, strlen(value));
            bind->buffer_length = strlen(bind_binary);
        } else {
            rand_string(bind_binary, dataLen);
            bind->buffer_length = dataLen;
        }

5734
        bind->length = &bind->buffer_length;
5735
        bind->buffer = bind_binary;
5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    } else if (0 == strncasecmp(dataType,
                "NCHAR", strlen("NCHAR"))) {
        if (dataLen > TSDB_MAX_BINARY_LEN) {
            errorPrint( "nchar length overflow, max size:%u\n",
                    (uint32_t)TSDB_MAX_BINARY_LEN);
            return -1;
        }
        char *bind_nchar = (char *)*ptr;

        bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
5749 5750 5751 5752 5753 5754
        if (value) {
            strncpy(bind_nchar, value, strlen(value));
        } else {
            rand_string(bind_nchar, dataLen);
        }

5755 5756 5757 5758 5759 5760 5761 5762 5763 5764
        bind->buffer_length = strlen(bind_nchar);
        bind->buffer = bind_nchar;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    } else if (0 == strncasecmp(dataType,
                "INT", strlen("INT"))) {
        int32_t *bind_int = (int32_t *)*ptr;

5765 5766 5767 5768 5769
        if (value) {
            *bind_int = atoi(value);
        } else {
            *bind_int = rand_int();
        }
5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780
        bind->buffer_type = TSDB_DATA_TYPE_INT;
        bind->buffer_length = sizeof(int32_t);
        bind->buffer = bind_int;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    } else if (0 == strncasecmp(dataType,
                "BIGINT", strlen("BIGINT"))) {
        int64_t *bind_bigint = (int64_t *)*ptr;

5781 5782 5783 5784 5785
        if (value) {
            *bind_bigint = atoll(value);
        } else {
            *bind_bigint = rand_bigint();
        }
5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796
        bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
        bind->buffer_length = sizeof(int64_t);
        bind->buffer = bind_bigint;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "FLOAT", strlen("FLOAT"))) {
        float   *bind_float = (float *) *ptr;

5797 5798 5799 5800 5801
        if (value) {
            *bind_float = (float)atof(value);
        } else {
            *bind_float = rand_float();
        }
5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812
        bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
        bind->buffer_length = sizeof(float);
        bind->buffer = bind_float;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "DOUBLE", strlen("DOUBLE"))) {
        double  *bind_double = (double *)*ptr;

5813 5814 5815 5816 5817
        if (value) {
            *bind_double = atof(value);
        } else {
            *bind_double = rand_double();
        }
5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828
        bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
        bind->buffer_length = sizeof(double);
        bind->buffer = bind_double;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "SMALLINT", strlen("SMALLINT"))) {
        int16_t *bind_smallint = (int16_t *)*ptr;

5829 5830 5831 5832 5833
        if (value) {
            *bind_smallint = (int16_t)atoi(value);
        } else {
            *bind_smallint = rand_smallint();
        }
5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844
        bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
        bind->buffer_length = sizeof(int16_t);
        bind->buffer = bind_smallint;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "TINYINT", strlen("TINYINT"))) {
        int8_t  *bind_tinyint = (int8_t *)*ptr;

5845 5846 5847 5848 5849
        if (value) {
            *bind_tinyint = (int8_t)atoi(value);
        } else {
            *bind_tinyint = rand_tinyint();
        }
5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871
        bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
        bind->buffer_length = sizeof(int8_t);
        bind->buffer = bind_tinyint;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;
        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "BOOL", strlen("BOOL"))) {
        int8_t  *bind_bool = (int8_t *)*ptr;

        *bind_bool = rand_bool();
        bind->buffer_type = TSDB_DATA_TYPE_BOOL;
        bind->buffer_length = sizeof(int8_t);
        bind->buffer = bind_bool;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else if (0 == strncasecmp(dataType,
                "TIMESTAMP", strlen("TIMESTAMP"))) {
        int64_t *bind_ts2 = (int64_t *) *ptr;

5872 5873 5874 5875 5876
        if (value) {
            *bind_ts2 = atoll(value);
        } else {
            *bind_ts2 = rand_bigint();
        }
5877 5878 5879 5880 5881 5882 5883 5884
        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
        bind->buffer_length = sizeof(int64_t);
        bind->buffer = bind_ts2;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        *ptr += bind->buffer_length;
    }  else {
5885
        errorPrint( "No support data type: %s\n", dataType);
5886 5887 5888 5889 5890 5891 5892
        return -1;
    }

    return 0;
}

static int32_t prepareStmtWithoutStb(
5893
        TAOS_STMT *stmt,
5894 5895 5896 5897 5898
        char *tableName,
        uint32_t batch,
        int64_t insertRows,
        int64_t recordFrom,
        int64_t startTime)
5899
{
5900 5901 5902
    int ret = taos_stmt_set_tbname(stmt, tableName);
    if (ret != 0) {
        errorPrint("failed to execute taos_stmt_set_tbname(%s). return 0x%x. reason: %s\n",
5903
                tableName, ret, taos_stmt_errstr(stmt));
5904 5905 5906 5907
        return ret;
    }

    char **data_type = g_args.datatype;
5908

5909 5910 5911 5912 5913
    char *bindArray = malloc(sizeof(TAOS_BIND) * (g_args.num_of_CPR + 1));
    if (bindArray == NULL) {
        errorPrint("Failed to allocate %d bind params\n",
                (g_args.num_of_CPR + 1));
        return -1;
5914 5915
    }

5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928
    int32_t k = 0;
    for (k = 0; k < batch;) {
        /* columnCount + 1 (ts) */
        char data[MAX_DATA_SIZE];
        memset(data, 0, MAX_DATA_SIZE);

        char *ptr = data;
        TAOS_BIND *bind = (TAOS_BIND *)(bindArray + 0);

        int64_t *bind_ts;

        bind_ts = (int64_t *)ptr;
        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
5929 5930 5931

        if (g_args.disorderRatio) {
            *bind_ts = startTime + getTSRandTail(
5932
                    g_args.timestamp_step, k,
5933 5934 5935
                    g_args.disorderRatio,
                    g_args.disorderRange);
        } else {
5936
            *bind_ts = startTime + g_args.timestamp_step * k;
5937
        }
5938 5939 5940 5941 5942 5943 5944 5945
        bind->buffer_length = sizeof(int64_t);
        bind->buffer = bind_ts;
        bind->length = &bind->buffer_length;
        bind->is_null = NULL;

        ptr += bind->buffer_length;

        for (int i = 0; i < g_args.num_of_CPR; i ++) {
5946 5947
            bind = (TAOS_BIND *)((char *)bindArray
                    + (sizeof(TAOS_BIND) * (i + 1)));
5948 5949 5950 5951
            if ( -1 == prepareStmtBindArrayByType(
                        bind,
                        data_type[i],
                        g_args.len_of_binary,
5952
                        &ptr, NULL)) {
5953 5954 5955
                return -1;
            }
        }
5956 5957 5958 5959 5960
        if (0 != taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray)) {
            errorPrint("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
            break;
        }
5961
        // if msg > 3MB, break
5962 5963 5964 5965 5966
        if (0 != taos_stmt_add_batch(stmt)) {
            errorPrint("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
            break;
        }
5967 5968 5969 5970 5971 5972 5973 5974

        k++;
        recordFrom ++;
        if (recordFrom >= insertRows) {
            break;
        }
    }

5975
    free(bindArray);
5976 5977 5978
    return k;
}

5979 5980 5981 5982 5983
static int32_t prepareStbStmtBind(
        char *bindArray, SSuperTable *stbInfo, bool sourceRand,
        int64_t startTime, int32_t recSeq,
        bool isColumn)
{
5984
    char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.len_of_binary);
5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997
    if (bindBuffer == NULL) {
        errorPrint("%s() LN%d, Failed to allocate %d bind buffer\n",
                __func__, __LINE__, g_args.len_of_binary);
        return -1;
    }

    char data[MAX_DATA_SIZE];
    memset(data, 0, MAX_DATA_SIZE);
    char *ptr = data;

    TAOS_BIND *bind;

    if (isColumn) {
5998 5999
        int cursor = 0;

6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078
        for (int i = 0; i < stbInfo->columnCount + 1; i ++) {
            bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * i));

            if (i == 0) {
                int64_t *bind_ts;

                bind_ts = (int64_t *)ptr;
                bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
                if (stbInfo->disorderRatio) {
                    *bind_ts = startTime + getTSRandTail(
                            stbInfo->timeStampStep, recSeq,
                            stbInfo->disorderRatio,
                            stbInfo->disorderRange);
                } else {
                    *bind_ts = startTime + stbInfo->timeStampStep * recSeq;
                }
                bind->buffer_length = sizeof(int64_t);
                bind->buffer = bind_ts;
                bind->length = &bind->buffer_length;
                bind->is_null = NULL;

                ptr += bind->buffer_length;
            } else {

                if (sourceRand) {
                    if ( -1 == prepareStmtBindArrayByType(
                                bind,
                                stbInfo->columns[i-1].dataType,
                                stbInfo->columns[i-1].dataLen,
                                &ptr,
                                NULL)) {
                        free(bindBuffer);
                        return -1;
                    }
                } else {
                    char *restStr = stbInfo->sampleDataBuf + cursor;
                    int lengthOfRest = strlen(restStr);

                    int index = 0;
                    for (index = 0; index < lengthOfRest; index ++) {
                        if (restStr[index] == ',') {
                            break;
                        }
                    }

                    memset(bindBuffer, 0, g_args.len_of_binary);
                    strncpy(bindBuffer, restStr, index);
                    cursor += index + 1; // skip ',' too

                    if ( -1 == prepareStmtBindArrayByType(
                                bind,
                                stbInfo->columns[i-1].dataType,
                                stbInfo->columns[i-1].dataLen,
                                &ptr,
                                bindBuffer)) {
                        free(bindBuffer);
                        return -1;
                    }
                }
            }
        }
    } else {
        TAOS_BIND *tag;

        for (int t = 0; t < stbInfo->tagCount; t ++) {
            tag = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * t));
            if ( -1 == prepareStmtBindArrayByType(
                        tag,
                        stbInfo->tags[t].dataType,
                        stbInfo->tags[t].dataLen,
                        &ptr,
                        NULL)) {
                free(bindBuffer);
                return -1;
            }
        }

    }

6079
    free(bindBuffer);
6080 6081 6082
    return 0;
}

6083 6084
static int32_t prepareStbStmt(
        SSuperTable *stbInfo,
6085
        TAOS_STMT *stmt,
6086 6087 6088
        char *tableName,
        int64_t tableSeq,
        uint32_t batch,
6089 6090
        uint64_t insertRows,
        uint64_t recordFrom,
6091 6092
        int64_t startTime,
        int64_t *pSamplePos)
6093
{
6094
    int ret;
6095

6096
    bool sourceRand;
6097
    if (0 == strncasecmp(stbInfo->dataSource, "rand", strlen("rand"))) {
6098
        sourceRand = true;
6099
    } else {
6100 6101 6102
        sourceRand = false;     // from sample data file
    }

6103 6104
    if (AUTO_CREATE_SUBTBL == stbInfo->autoCreateTable) {
        char* tagsValBuf = NULL;
6105

6106 6107 6108 6109 6110 6111 6112 6113 6114 6115
        bool tagRand;
        if (0 == stbInfo->tagSource) {
            tagRand = true;
            tagsValBuf = generateTagValuesForStb(stbInfo, tableSeq);
        } else {
            tagRand = false;
            tagsValBuf = getTagValueFromTagSample(
                    stbInfo,
                    tableSeq % stbInfo->tagSampleCount);
        }
6116

6117 6118 6119 6120 6121
        if (NULL == tagsValBuf) {
            errorPrint("%s() LN%d, tag buf failed to allocate  memory\n",
                    __func__, __LINE__);
            return -1;
        }
6122

6123 6124 6125 6126 6127 6128 6129
        char *tagsArray = calloc(1, sizeof(TAOS_BIND) * stbInfo->tagCount);
        if (NULL == tagsArray) {
            tmfree(tagsValBuf);
            errorPrint("%s() LN%d, tag buf failed to allocate  memory\n",
                    __func__, __LINE__);
            return -1;
        }
6130

6131 6132
        if (-1 == prepareStbStmtBind(
                    tagsArray, stbInfo, tagRand, -1, -1, false /* is tag */)) {
6133 6134
            tmfree(tagsValBuf);
            tmfree(tagsArray);
6135
            return -1;
6136 6137
        }

6138
        ret = taos_stmt_set_tbname_tags(stmt, tableName, (TAOS_BIND *)tagsArray);
6139

6140
        tmfree(tagsValBuf);
6141
        tmfree(tagsArray);
6142 6143 6144 6145 6146 6147

        if (0 != ret) {
            errorPrint("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
            return -1;
        }
6148 6149
    } else {
        ret = taos_stmt_set_tbname(stmt, tableName);
6150 6151 6152 6153 6154
        if (0 != ret) {
            errorPrint("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
            return -1;
        }
6155
    }
6156

6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170
    char *bindArray = calloc(1, sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
    if (bindArray == NULL) {
        errorPrint("%s() LN%d, Failed to allocate %d bind params\n",
                __func__, __LINE__, (stbInfo->columnCount + 1));
        return -1;
    }

    uint32_t k;
    for (k = 0; k < batch;) {
        /* columnCount + 1 (ts) */
        if (-1 == prepareStbStmtBind(bindArray, stbInfo, sourceRand,
                    startTime, k, true /* is column */)) {
            free(bindArray);
            return -1;
6171
        }
6172 6173 6174 6175
        ret = taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
        if (0 != ret) {
            errorPrint("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
6176
            free(bindArray);
6177 6178
            return -1;
        }
6179
        // if msg > 3MB, break
6180 6181 6182 6183
        ret = taos_stmt_add_batch(stmt);
        if (0 != ret) {
            errorPrint("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
                    __func__, __LINE__, taos_stmt_errstr(stmt));
6184
            free(bindArray);
6185 6186
            return -1;
        }
6187

6188 6189
        k++;
        recordFrom ++;
6190 6191 6192 6193

        if (!sourceRand) {
            (*pSamplePos) ++;
        }
6194

6195 6196 6197 6198
        if (recordFrom >= insertRows) {
            break;
        }
    }
6199

6200
    free(bindArray);
6201 6202
    return k;
}
6203 6204 6205 6206

static int32_t prepareStbStmtInterlace(
        SSuperTable *stbInfo,
        TAOS_STMT *stmt,
6207 6208 6209
        char *tableName,
        int64_t tableSeq,
        uint32_t batch,
6210 6211 6212 6213 6214 6215 6216 6217 6218
        uint64_t insertRows,
        uint64_t recordFrom,
        int64_t startTime,
        int64_t *pSamplePos)
{
    return prepareStbStmt(
            stbInfo,
            stmt,
            tableName,
6219
            tableSeq,
6220
            batch,
6221 6222 6223 6224 6225 6226 6227
            insertRows, 0, startTime,
            pSamplePos);
}

static int32_t prepareStbStmtProgressive(
        SSuperTable *stbInfo,
        TAOS_STMT *stmt,
6228 6229 6230
        char *tableName,
        int64_t tableSeq,
        uint32_t batch,
6231 6232 6233 6234 6235 6236 6237 6238 6239
        uint64_t insertRows,
        uint64_t recordFrom,
        int64_t startTime,
        int64_t *pSamplePos)
{
    return prepareStbStmt(
            stbInfo,
            stmt,
            tableName,
6240
            tableSeq,
6241 6242 6243 6244 6245
            g_args.num_of_RPR,
            insertRows, recordFrom, startTime,
            pSamplePos);
}

6246
#endif
6247 6248

static int32_t generateStbProgressiveData(
6249
        SSuperTable *superTblInfo,
6250
        char *tableName,
6251
        int64_t tableSeq,
6252
        char *dbName, char *buffer,
6253
        int64_t insertRows,
6254
        uint64_t recordFrom, int64_t startTime, int64_t *pSamplePos,
6255
        int64_t *pRemainderBufLen)
6256
{
6257 6258
    assert(buffer != NULL);
    char *pstr = buffer;
6259

6260
    memset(pstr, 0, *pRemainderBufLen);
6261

6262 6263 6264 6265
    int64_t headLen = generateStbSQLHead(
            superTblInfo,
            tableName, tableSeq, dbName,
            buffer, *pRemainderBufLen);
6266

6267 6268 6269 6270 6271
    if (headLen <= 0) {
        return 0;
    }
    pstr += headLen;
    *pRemainderBufLen -= headLen;
6272

6273
    int64_t dataLen;
6274

6275 6276 6277 6278 6279
    return generateStbDataTail(superTblInfo,
            g_args.num_of_RPR, pstr, *pRemainderBufLen,
            insertRows, recordFrom,
            startTime,
            pSamplePos, &dataLen);
6280 6281
}

6282
static int32_t generateProgressiveDataWithoutStb(
6283
        char *tableName,
6284
        /* int64_t tableSeq, */
6285 6286
        threadInfo *pThreadInfo, char *buffer,
        int64_t insertRows,
6287
        uint64_t recordFrom, int64_t startTime, /*int64_t *pSamplePos, */
6288 6289
        int64_t *pRemainderBufLen)
{
6290 6291
    assert(buffer != NULL);
    char *pstr = buffer;
6292

6293
    memset(buffer, 0, *pRemainderBufLen);
6294

6295 6296 6297
    int64_t headLen = generateSQLHeadWithoutStb(
            tableName, pThreadInfo->db_name,
            buffer, *pRemainderBufLen);
6298

6299 6300 6301 6302 6303
    if (headLen <= 0) {
        return 0;
    }
    pstr += headLen;
    *pRemainderBufLen -= headLen;
6304

6305
    int64_t dataLen;
6306

6307 6308 6309 6310
    return generateDataTailWithoutStb(
            g_args.num_of_RPR, pstr, *pRemainderBufLen, insertRows, recordFrom,
            startTime,
            /*pSamplePos, */&dataLen);
6311
}
6312

6313 6314
static void printStatPerThread(threadInfo *pThreadInfo)
{
6315
    fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
6316 6317 6318
            pThreadInfo->threadID,
            pThreadInfo->totalInsertRows,
            pThreadInfo->totalAffectedRows,
6319 6320
            (pThreadInfo->totalDelay)?
            (double)(pThreadInfo->totalAffectedRows/((double)pThreadInfo->totalDelay/1000000.0)):
6321
            FLT_MAX);
6322 6323
}

6324
// sync write interlace data
6325
static void* syncWriteInterlace(threadInfo *pThreadInfo) {
6326 6327
    debugPrint("[%d] %s() LN%d: ### interlace write\n",
            pThreadInfo->threadID, __func__, __LINE__);
6328

6329 6330 6331 6332 6333
    int64_t insertRows;
    uint32_t interlaceRows;
    uint64_t maxSqlLen;
    int64_t nTimeStampStep;
    uint64_t insert_interval;
6334

6335
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6336

6337 6338
    if (superTblInfo) {
        insertRows = superTblInfo->insertRows;
6339

6340 6341 6342 6343 6344 6345 6346 6347 6348
        if ((superTblInfo->interlaceRows == 0)
                && (g_args.interlace_rows > 0)) {
            interlaceRows = g_args.interlace_rows;
        } else {
            interlaceRows = superTblInfo->interlaceRows;
        }
        maxSqlLen = superTblInfo->maxSqlLen;
        nTimeStampStep = superTblInfo->timeStampStep;
        insert_interval = superTblInfo->insertInterval;
6349
    } else {
6350 6351 6352
        insertRows = g_args.num_of_DPT;
        interlaceRows = g_args.interlace_rows;
        maxSqlLen = g_args.max_sql_len;
6353
        nTimeStampStep = g_args.timestamp_step;
6354
        insert_interval = g_args.insert_interval;
6355
    }
6356

6357 6358 6359 6360
    debugPrint("[%d] %s() LN%d: start_table_from=%"PRIu64" ntables=%"PRId64" insertRows=%"PRIu64"\n",
            pThreadInfo->threadID, __func__, __LINE__,
            pThreadInfo->start_table_from,
            pThreadInfo->ntables, insertRows);
6361

6362 6363
    if (interlaceRows > insertRows)
        interlaceRows = insertRows;
6364

6365 6366
    if (interlaceRows > g_args.num_of_RPR)
        interlaceRows = g_args.num_of_RPR;
6367

6368 6369
    uint32_t batchPerTbl = interlaceRows;
    uint32_t batchPerTblTimes;
6370

6371 6372 6373 6374 6375 6376
    if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
        batchPerTblTimes =
            g_args.num_of_RPR / interlaceRows;
    } else {
        batchPerTblTimes = 1;
    }
6377

6378 6379 6380 6381 6382 6383
    pThreadInfo->buffer = calloc(maxSqlLen, 1);
    if (NULL == pThreadInfo->buffer) {
        errorPrint( "%s() LN%d, Failed to alloc %"PRIu64" Bytes, reason:%s\n",
                __func__, __LINE__, maxSqlLen, strerror(errno));
        return NULL;
    }
6384

6385 6386
    pThreadInfo->totalInsertRows = 0;
    pThreadInfo->totalAffectedRows = 0;
6387

6388 6389
    uint64_t st = 0;
    uint64_t et = UINT64_MAX;
6390

6391 6392 6393
    uint64_t lastPrintTime = taosGetTimestampMs();
    uint64_t startTs = taosGetTimestampMs();
    uint64_t endTs;
6394

6395 6396
    uint64_t tableSeq = pThreadInfo->start_table_from;
    int64_t startTime = pThreadInfo->start_time;
6397

6398 6399 6400
    uint64_t generatedRecPerTbl = 0;
    bool flagSleep = true;
    uint64_t sleepTimeTotal = 0;
6401

6402 6403 6404 6405 6406 6407 6408 6409
    while(pThreadInfo->totalInsertRows < pThreadInfo->ntables * insertRows) {
        if ((flagSleep) && (insert_interval)) {
            st = taosGetTimestampMs();
            flagSleep = false;
        }
        // generate data
        memset(pThreadInfo->buffer, 0, maxSqlLen);
        uint64_t remainderBufLen = maxSqlLen;
6410

6411
        char *pstr = pThreadInfo->buffer;
6412

6413 6414 6415 6416
        int len = snprintf(pstr,
                strlen(STR_INSERT_INTO) + 1, "%s", STR_INSERT_INTO);
        pstr += len;
        remainderBufLen -= len;
6417

6418
        uint32_t recOfBatch = 0;
6419

6420 6421
        for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
            char tableName[TSDB_TABLE_NAME_LEN];
6422

6423 6424 6425 6426 6427 6428 6429
            getTableName(tableName, pThreadInfo, tableSeq);
            if (0 == strlen(tableName)) {
                errorPrint("[%d] %s() LN%d, getTableName return null\n",
                        pThreadInfo->threadID, __func__, __LINE__);
                free(pThreadInfo->buffer);
                return NULL;
            }
6430

6431
            uint64_t oldRemainderLen = remainderBufLen;
6432

6433 6434 6435
            int32_t generated;
            if (superTblInfo) {
                if (superTblInfo->iface == STMT_IFACE) {
6436
#if STMT_IFACE_ENABLED == 1
6437 6438 6439 6440
                    generated = prepareStbStmtInterlace(
                            superTblInfo,
                            pThreadInfo->stmt,
                            tableName,
6441
                            tableSeq,
6442 6443 6444 6445
                            batchPerTbl,
                            insertRows, i,
                            startTime,
                            &(pThreadInfo->samplePos));
6446
#else
6447
                    generated = -1;
6448
#endif
6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465
                } else {
                    generated = generateStbInterlaceData(
                            superTblInfo,
                            tableName, batchPerTbl, i,
                            batchPerTblTimes,
                            tableSeq,
                            pThreadInfo, pstr,
                            insertRows,
                            startTime,
                            &remainderBufLen);
                }
            } else {
                if (g_args.iface == STMT_IFACE) {
                    debugPrint("[%d] %s() LN%d, tableName:%s, batch:%d startTime:%"PRId64"\n",
                            pThreadInfo->threadID,
                            __func__, __LINE__,
                            tableName, batchPerTbl, startTime);
6466
#if STMT_IFACE_ENABLED == 1
6467 6468 6469 6470 6471
                    generated = prepareStmtWithoutStb(
                            pThreadInfo->stmt, tableName,
                            batchPerTbl,
                            insertRows, i,
                            startTime);
6472
#else
6473
                    generated = -1;
6474
#endif
6475 6476 6477 6478 6479 6480 6481 6482 6483 6484
                } else {
                    generated = generateInterlaceDataWithoutStb(
                            tableName, batchPerTbl,
                            tableSeq,
                            pThreadInfo->db_name, pstr,
                            insertRows,
                            startTime,
                            &remainderBufLen);
                }
            }
6485

6486 6487 6488 6489 6490 6491 6492 6493 6494
            debugPrint("[%d] %s() LN%d, generated records is %d\n",
                    pThreadInfo->threadID, __func__, __LINE__, generated);
            if (generated < 0) {
                errorPrint("[%d] %s() LN%d, generated records is %d\n",
                        pThreadInfo->threadID, __func__, __LINE__, generated);
                goto free_of_interlace;
            } else if (generated == 0) {
                break;
            }
6495

6496 6497
            tableSeq ++;
            recOfBatch += batchPerTbl;
6498

6499 6500
            pstr += (oldRemainderLen - remainderBufLen);
            pThreadInfo->totalInsertRows += batchPerTbl;
6501

6502 6503 6504
            verbosePrint("[%d] %s() LN%d batchPerTbl=%d recOfBatch=%d\n",
                    pThreadInfo->threadID, __func__, __LINE__,
                    batchPerTbl, recOfBatch);
6505

6506 6507 6508 6509
            if (tableSeq == pThreadInfo->start_table_from + pThreadInfo->ntables) {
                // turn to first table
                tableSeq = pThreadInfo->start_table_from;
                generatedRecPerTbl += batchPerTbl;
6510

6511 6512
                startTime = pThreadInfo->start_time
                    + generatedRecPerTbl * nTimeStampStep;
6513

6514 6515 6516
                flagSleep = true;
                if (generatedRecPerTbl >= insertRows)
                    break;
6517

6518 6519 6520
                int64_t remainRows = insertRows - generatedRecPerTbl;
                if ((remainRows > 0) && (batchPerTbl > remainRows))
                    batchPerTbl = remainRows;
6521

6522 6523 6524
                if (pThreadInfo->ntables * batchPerTbl < g_args.num_of_RPR)
                    break;
            }
6525

6526 6527 6528
            verbosePrint("[%d] %s() LN%d generatedRecPerTbl=%"PRId64" insertRows=%"PRId64"\n",
                    pThreadInfo->threadID, __func__, __LINE__,
                    generatedRecPerTbl, insertRows);
6529

6530 6531
            if ((g_args.num_of_RPR - recOfBatch) < batchPerTbl)
                break;
6532
        }
6533

6534 6535 6536 6537 6538 6539
        verbosePrint("[%d] %s() LN%d recOfBatch=%d totalInsertRows=%"PRIu64"\n",
                pThreadInfo->threadID, __func__, __LINE__, recOfBatch,
                pThreadInfo->totalInsertRows);
        verbosePrint("[%d] %s() LN%d, buffer=%s\n",
                pThreadInfo->threadID, __func__, __LINE__, pThreadInfo->buffer);

6540
        startTs = taosGetTimestampUs();
6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555

        if (recOfBatch == 0) {
            errorPrint("[%d] %s() LN%d Failed to insert records of batch %d\n",
                    pThreadInfo->threadID, __func__, __LINE__,
                    batchPerTbl);
            if (batchPerTbl > 0) {
                errorPrint("\tIf the batch is %d, the length of the SQL to insert a row must be less then %"PRId64"\n",
                        batchPerTbl, maxSqlLen / batchPerTbl);
            }
            errorPrint("\tPlease check if the buffer length(%"PRId64") or batch(%d) is set with proper value!\n",
                    maxSqlLen, batchPerTbl);
            goto free_of_interlace;
        }
        int64_t affectedRows = execInsert(pThreadInfo, recOfBatch);

6556
        endTs = taosGetTimestampUs();
6557
        uint64_t delay = endTs - startTs;
6558 6559
        performancePrint("%s() LN%d, insert execution time is %10.2f ms\n",
                __func__, __LINE__, delay / 1000.0);
6560 6561 6562
        verbosePrint("[%d] %s() LN%d affectedRows=%"PRId64"\n",
                pThreadInfo->threadID,
                __func__, __LINE__, affectedRows);
6563

6564 6565 6566 6567
        if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
        if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
        pThreadInfo->cntDelay++;
        pThreadInfo->totalDelay += delay;
6568

6569 6570 6571 6572 6573 6574
        if (recOfBatch != affectedRows) {
            errorPrint("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n%s\n",
                    pThreadInfo->threadID, __func__, __LINE__,
                    recOfBatch, affectedRows, pThreadInfo->buffer);
            goto free_of_interlace;
        }
6575

6576
        pThreadInfo->totalAffectedRows += affectedRows;
6577

6578 6579 6580
        int64_t  currentPrintTime = taosGetTimestampMs();
        if (currentPrintTime - lastPrintTime > 30*1000) {
            printf("thread[%d] has currently inserted rows: %"PRIu64 ", affected rows: %"PRIu64 "\n",
6581 6582 6583
                    pThreadInfo->threadID,
                    pThreadInfo->totalInsertRows,
                    pThreadInfo->totalAffectedRows);
6584 6585
            lastPrintTime = currentPrintTime;
        }
6586

6587 6588
        if ((insert_interval) && flagSleep) {
            et = taosGetTimestampMs();
6589

6590 6591 6592 6593 6594 6595 6596 6597
            if (insert_interval > (et - st) ) {
                uint64_t sleepTime = insert_interval - (et -st);
                performancePrint("%s() LN%d sleep: %"PRId64" ms for insert interval\n",
                        __func__, __LINE__, sleepTime);
                taosMsleep(sleepTime); // ms
                sleepTimeTotal += insert_interval;
            }
        }
6598
    }
6599

6600
free_of_interlace:
6601 6602 6603
    tmfree(pThreadInfo->buffer);
    printStatPerThread(pThreadInfo);
    return NULL;
6604 6605
}

6606
// sync insertion progressive data
6607
static void* syncWriteProgressive(threadInfo *pThreadInfo) {
6608
    debugPrint("%s() LN%d: ### progressive write\n", __func__, __LINE__);
6609

6610 6611 6612
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
    uint64_t maxSqlLen = superTblInfo?superTblInfo->maxSqlLen:g_args.max_sql_len;
    int64_t timeStampStep =
6613
        superTblInfo?superTblInfo->timeStampStep:g_args.timestamp_step;
6614
    int64_t insertRows =
6615
        (superTblInfo)?superTblInfo->insertRows:g_args.num_of_DPT;
6616
    verbosePrint("%s() LN%d insertRows=%"PRId64"\n",
6617
            __func__, __LINE__, insertRows);
6618

6619 6620 6621 6622 6623
    pThreadInfo->buffer = calloc(maxSqlLen, 1);
    if (NULL == pThreadInfo->buffer) {
        errorPrint( "Failed to alloc %"PRIu64" Bytes, reason:%s\n",
                maxSqlLen,
                strerror(errno));
6624
        return NULL;
6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652
    }

    uint64_t lastPrintTime = taosGetTimestampMs();
    uint64_t startTs = taosGetTimestampMs();
    uint64_t endTs;

    pThreadInfo->totalInsertRows = 0;
    pThreadInfo->totalAffectedRows = 0;

    pThreadInfo->samplePos = 0;

    for (uint64_t tableSeq = pThreadInfo->start_table_from;
            tableSeq <= pThreadInfo->end_table_to;
            tableSeq ++) {
        int64_t start_time = pThreadInfo->start_time;

        for (uint64_t i = 0; i < insertRows;) {
            char tableName[TSDB_TABLE_NAME_LEN];
            getTableName(tableName, pThreadInfo, tableSeq);
            verbosePrint("%s() LN%d: tid=%d seq=%"PRId64" tableName=%s\n",
                    __func__, __LINE__,
                    pThreadInfo->threadID, tableSeq, tableName);
            if (0 == strlen(tableName)) {
                errorPrint("[%d] %s() LN%d, getTableName return null\n",
                        pThreadInfo->threadID, __func__, __LINE__);
                free(pThreadInfo->buffer);
                return NULL;
            }
6653

6654
            int64_t remainderBufLen = maxSqlLen - 2000;
6655
            char *pstr = pThreadInfo->buffer;
6656

6657 6658
            int len = snprintf(pstr,
                    strlen(STR_INSERT_INTO) + 1, "%s", STR_INSERT_INTO);
6659

6660 6661
            pstr += len;
            remainderBufLen -= len;
6662

6663 6664 6665
            int32_t generated;
            if (superTblInfo) {
                if (superTblInfo->iface == STMT_IFACE) {
6666
#if STMT_IFACE_ENABLED == 1
6667 6668 6669 6670 6671 6672 6673 6674
                    generated = prepareStbStmtProgressive(
                            superTblInfo,
                            pThreadInfo->stmt,
                            tableName,
                            tableSeq,
                            g_args.num_of_RPR,
                            insertRows, i, start_time,
                            &(pThreadInfo->samplePos));
6675
#else
6676
                    generated = -1;
6677
#endif
6678 6679 6680 6681 6682 6683 6684 6685 6686 6687
                } else {
                    generated = generateStbProgressiveData(
                            superTblInfo,
                            tableName, tableSeq, pThreadInfo->db_name, pstr,
                            insertRows, i, start_time,
                            &(pThreadInfo->samplePos),
                            &remainderBufLen);
                }
            } else {
                if (g_args.iface == STMT_IFACE) {
6688
#if STMT_IFACE_ENABLED == 1
6689 6690 6691 6692 6693 6694
                    generated = prepareStmtWithoutStb(
                            pThreadInfo->stmt,
                            tableName,
                            g_args.num_of_RPR,
                            insertRows, i,
                            start_time);
6695
#else
6696
                    generated = -1;
6697
#endif
6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711
                } else {
                    generated = generateProgressiveDataWithoutStb(
                            tableName,
                            /*  tableSeq, */
                            pThreadInfo, pstr, insertRows,
                            i, start_time,
                            /* &(pThreadInfo->samplePos), */
                            &remainderBufLen);
                }
            }
            if (generated > 0)
                i += generated;
            else
                goto free_of_progressive;
6712

6713 6714
            start_time +=  generated * timeStampStep;
            pThreadInfo->totalInsertRows += generated;
6715

6716
            startTs = taosGetTimestampUs();
6717

6718
            int32_t affectedRows = execInsert(pThreadInfo, generated);
6719

6720
            endTs = taosGetTimestampUs();
6721
            uint64_t delay = endTs - startTs;
6722 6723
            performancePrint("%s() LN%d, insert execution time is %10.f ms\n",
                    __func__, __LINE__, delay/1000.0);
6724 6725 6726
            verbosePrint("[%d] %s() LN%d affectedRows=%d\n",
                    pThreadInfo->threadID,
                    __func__, __LINE__, affectedRows);
6727

6728 6729 6730 6731
            if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
            if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
            pThreadInfo->cntDelay++;
            pThreadInfo->totalDelay += delay;
6732

6733 6734 6735 6736 6737
            if (affectedRows < 0) {
                errorPrint("%s() LN%d, affected rows: %d\n",
                        __func__, __LINE__, affectedRows);
                goto free_of_progressive;
            }
6738

6739
            pThreadInfo->totalAffectedRows += affectedRows;
6740

6741 6742 6743 6744 6745 6746 6747 6748
            int64_t  currentPrintTime = taosGetTimestampMs();
            if (currentPrintTime - lastPrintTime > 30*1000) {
                printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n",
                        pThreadInfo->threadID,
                        pThreadInfo->totalInsertRows,
                        pThreadInfo->totalAffectedRows);
                lastPrintTime = currentPrintTime;
            }
6749

6750 6751 6752
            if (i >= insertRows)
                break;
        }   // num_of_DPT
6753

6754
        if ((g_args.verbose_print) &&
6755 6756 6757 6758
                (tableSeq == pThreadInfo->ntables - 1) && (superTblInfo)
                && (0 == strncasecmp(
                        superTblInfo->dataSource,
                        "sample", strlen("sample")))) {
6759 6760 6761 6762
            verbosePrint("%s() LN%d samplePos=%"PRId64"\n",
                    __func__, __LINE__, pThreadInfo->samplePos);
        }
    } // tableSeq
6763

6764
free_of_progressive:
6765 6766 6767
    tmfree(pThreadInfo->buffer);
    printStatPerThread(pThreadInfo);
    return NULL;
H
Hui Li 已提交
6768 6769
}

6770 6771
static void* syncWrite(void *sarg) {

6772 6773
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6774

6775 6776
    setThreadName("syncWrite");

6777
    uint32_t interlaceRows;
6778

6779 6780 6781 6782 6783 6784 6785
    if (superTblInfo) {
        if ((superTblInfo->interlaceRows == 0)
                && (g_args.interlace_rows > 0)) {
            interlaceRows = g_args.interlace_rows;
        } else {
            interlaceRows = superTblInfo->interlaceRows;
        }
6786
    } else {
6787
        interlaceRows = g_args.interlace_rows;
6788
    }
6789

6790 6791 6792 6793 6794 6795 6796
    if (interlaceRows > 0) {
        // interlace mode
        return syncWriteInterlace(pThreadInfo);
    } else {
        // progressive mode
        return syncWriteProgressive(pThreadInfo);
    }
6797 6798
}

6799
static void callBack(void *param, TAOS_RES *res, int code) {
6800 6801 6802 6803 6804 6805 6806 6807 6808 6809
    threadInfo* pThreadInfo = (threadInfo*)param;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;

    int insert_interval =
        superTblInfo?superTblInfo->insertInterval:g_args.insert_interval;
    if (insert_interval) {
        pThreadInfo->et = taosGetTimestampMs();
        if ((pThreadInfo->et - pThreadInfo->st) < insert_interval) {
            taosMsleep(insert_interval - (pThreadInfo->et - pThreadInfo->st)); // ms
        }
H
Hui Li 已提交
6810 6811
    }

6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827
    char *buffer = calloc(1, pThreadInfo->superTblInfo->maxSqlLen);
    char data[MAX_DATA_SIZE];
    char *pstr = buffer;
    pstr += sprintf(pstr, "insert into %s.%s%"PRId64" values",
            pThreadInfo->db_name, pThreadInfo->tb_prefix,
            pThreadInfo->start_table_from);
    //  if (pThreadInfo->counter >= pThreadInfo->superTblInfo->insertRows) {
    if (pThreadInfo->counter >= g_args.num_of_RPR) {
        pThreadInfo->start_table_from++;
        pThreadInfo->counter = 0;
    }
    if (pThreadInfo->start_table_from > pThreadInfo->end_table_to) {
        tsem_post(&pThreadInfo->lock_sem);
        free(buffer);
        taos_free_result(res);
        return;
H
Hui Li 已提交
6828
    }
6829

6830 6831 6832 6833 6834 6835
    for (int i = 0; i < g_args.num_of_RPR; i++) {
        int rand_num = taosRandom() % 100;
        if (0 != pThreadInfo->superTblInfo->disorderRatio
                && rand_num < pThreadInfo->superTblInfo->disorderRatio) {
            int64_t d = pThreadInfo->lastTs
                - (taosRandom() % pThreadInfo->superTblInfo->disorderRange + 1);
6836 6837 6838
            generateStbRowData(pThreadInfo->superTblInfo, data,
                    MAX_DATA_SIZE,
                    d);
6839 6840
        } else {
            generateStbRowData(pThreadInfo->superTblInfo,
6841 6842 6843
                    data,
                    MAX_DATA_SIZE,
                    pThreadInfo->lastTs += 1000);
6844 6845 6846
        }
        pstr += sprintf(pstr, "%s", data);
        pThreadInfo->counter++;
H
Hui Li 已提交
6847

6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859
        if (pThreadInfo->counter >= pThreadInfo->superTblInfo->insertRows) {
            break;
        }
    }

    if (insert_interval) {
        pThreadInfo->st = taosGetTimestampMs();
    }
    taos_query_a(pThreadInfo->taos, buffer, callBack, pThreadInfo);
    free(buffer);

    taos_free_result(res);
H
Hui Li 已提交
6860 6861
}

6862
static void *asyncWrite(void *sarg) {
6863 6864
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6865

6866
    setThreadName("asyncWrite");
6867

6868 6869 6870
    pThreadInfo->st = 0;
    pThreadInfo->et = 0;
    pThreadInfo->lastTs = pThreadInfo->start_time;
6871

6872 6873 6874 6875 6876 6877
    int insert_interval =
        superTblInfo?superTblInfo->insertInterval:g_args.insert_interval;
    if (insert_interval) {
        pThreadInfo->st = taosGetTimestampMs();
    }
    taos_query_a(pThreadInfo->taos, "show databases", callBack, pThreadInfo);
6878

6879
    tsem_wait(&(pThreadInfo->lock_sem));
H
Hui Li 已提交
6880

6881
    return NULL;
H
Hui Li 已提交
6882 6883
}

6884 6885
static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *serv_addr)
{
6886 6887 6888 6889 6890 6891
    uint16_t rest_port = port + TSDB_PORT_HTTP;
    struct hostent *server = gethostbyname(host);
    if ((server == NULL) || (server->h_addr == NULL)) {
        errorPrint("%s", "ERROR, no such host");
        return -1;
    }
6892

6893
    debugPrint("h_name: %s\nh_addr=%p\nh_addretype: %s\nh_length: %d\n",
6894 6895 6896 6897 6898
            server->h_name,
            server->h_addr,
            (server->h_addrtype == AF_INET)?"ipv4":"ipv6",
            server->h_length);

6899 6900 6901
    memset(serv_addr, 0, sizeof(struct sockaddr_in));
    serv_addr->sin_family = AF_INET;
    serv_addr->sin_port = htons(rest_port);
6902
#ifdef WINDOWS
6903
    serv_addr->sin_addr.s_addr = inet_addr(host);
6904
#else
6905
    memcpy(&(serv_addr->sin_addr.s_addr), server->h_addr, server->h_length);
6906
#endif
6907
    return 0;
6908 6909
}

6910
static void startMultiThreadInsertData(int threads, char* db_name,
6911
        char* precision, SSuperTable* superTblInfo) {
6912

6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926
    int32_t timePrec = TSDB_TIME_PRECISION_MILLI;
    if (0 != precision[0]) {
        if (0 == strncasecmp(precision, "ms", 2)) {
            timePrec = TSDB_TIME_PRECISION_MILLI;
        } else if (0 == strncasecmp(precision, "us", 2)) {
            timePrec = TSDB_TIME_PRECISION_MICRO;
#if NANO_SECOND_ENABLED == 1
        } else if (0 == strncasecmp(precision, "ns", 2)) {
            timePrec = TSDB_TIME_PRECISION_NANO;
#endif
        } else {
            errorPrint("Not support precision: %s\n", precision);
            exit(-1);
        }
6927 6928
    }

6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941
    int64_t start_time;
    if (superTblInfo) {
        if (0 == strncasecmp(superTblInfo->startTimestamp, "now", 3)) {
            start_time = taosGetTimestamp(timePrec);
        } else {
            if (TSDB_CODE_SUCCESS != taosParseTime(
                        superTblInfo->startTimestamp,
                        &start_time,
                        strlen(superTblInfo->startTimestamp),
                        timePrec, 0)) {
                ERROR_EXIT("failed to parse time!\n");
            }
        }
6942
    } else {
6943
        start_time = 1500000000000;
6944
    }
6945 6946
    debugPrint("%s() LN%d, start_time= %"PRId64"\n",
            __func__, __LINE__, start_time);
6947

6948
    int64_t start = taosGetTimestampMs();
6949

6950 6951 6952 6953 6954 6955 6956 6957
    // read sample data from file first
    if ((superTblInfo) && (0 == strncasecmp(superTblInfo->dataSource,
                    "sample", strlen("sample")))) {
        if (0 != prepareSampleDataForSTable(superTblInfo)) {
            errorPrint("%s() LN%d, prepare sample data for stable failed!\n",
                    __func__, __LINE__);
            exit(-1);
        }
6958 6959
    }

6960 6961 6962 6963 6964
    TAOS* taos0 = taos_connect(
            g_Dbs.host, g_Dbs.user,
            g_Dbs.password, db_name, g_Dbs.port);
    if (NULL == taos0) {
        errorPrint("%s() LN%d, connect to server fail , reason: %s\n",
6965
                __func__, __LINE__, taos_errstr(NULL));
6966 6967
        exit(-1);
    }
6968

6969 6970
    int64_t ntables = 0;
    uint64_t tableFrom;
6971

6972 6973 6974
    if (superTblInfo) {
        int64_t limit;
        uint64_t offset;
6975

6976 6977 6978 6979
        if ((NULL != g_args.sqlFile)
                && (superTblInfo->childTblExists == TBL_NO_EXISTS)
                && ((superTblInfo->childTblOffset != 0)
                    || (superTblInfo->childTblLimit >= 0))) {
6980 6981
            printf("WARNING: offset and limit will not be used since the child tables not exists!\n");
        }
6982

6983 6984
        if (superTblInfo->childTblExists == TBL_ALREADY_EXISTS) {
            if ((superTblInfo->childTblLimit < 0)
6985 6986
                    || ((superTblInfo->childTblOffset
                            + superTblInfo->childTblLimit)
6987 6988 6989 6990
                        > (superTblInfo->childTblCount))) {
                superTblInfo->childTblLimit =
                    superTblInfo->childTblCount - superTblInfo->childTblOffset;
            }
6991

6992 6993 6994 6995 6996 6997
            offset = superTblInfo->childTblOffset;
            limit = superTblInfo->childTblLimit;
        } else {
            limit = superTblInfo->childTblCount;
            offset = 0;
        }
6998

6999 7000
        ntables = limit;
        tableFrom = offset;
7001

7002 7003 7004 7005 7006 7007
        if ((superTblInfo->childTblExists != TBL_NO_EXISTS)
                && ((superTblInfo->childTblOffset + superTblInfo->childTblLimit )
                    > superTblInfo->childTblCount)) {
            printf("WARNING: specified offset + limit > child table count!\n");
            prompt();
        }
7008

7009 7010 7011 7012 7013
        if ((superTblInfo->childTblExists != TBL_NO_EXISTS)
                && (0 == superTblInfo->childTblLimit)) {
            printf("WARNING: specified limit = 0, which cannot find table name to insert or query! \n");
            prompt();
        }
7014

7015 7016 7017 7018 7019 7020 7021
        superTblInfo->childTblName = (char*)calloc(1,
                limit * TSDB_TABLE_NAME_LEN);
        if (superTblInfo->childTblName == NULL) {
            errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
            taos_close(taos0);
            exit(-1);
        }
7022

7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033
        int64_t childTblCount;
        getChildNameOfSuperTableWithLimitAndOffset(
                taos0,
                db_name, superTblInfo->sTblName,
                &superTblInfo->childTblName, &childTblCount,
                limit,
                offset);
    } else {
        ntables = g_args.num_of_tables;
        tableFrom = 0;
    }
7034

7035
    taos_close(taos0);
7036

7037 7038 7039 7040 7041
    int64_t a = ntables / threads;
    if (a < 1) {
        threads = ntables;
        a = 1;
    }
7042

7043 7044 7045 7046
    int64_t b = 0;
    if (threads != 0) {
        b = ntables % threads;
    }
7047

7048 7049 7050 7051 7052 7053 7054
    if ((superTblInfo)
            && (superTblInfo->iface == REST_IFACE)) {
        if (convertHostToServAddr(
                    g_Dbs.host, g_Dbs.port, &(g_Dbs.serv_addr)) != 0) {
            exit(-1);
        }
    }
7055

7056 7057
    pthread_t *pids = calloc(1, threads * sizeof(pthread_t));
    assert(pids != NULL);
7058

7059 7060
    threadInfo *infos = calloc(1, threads * sizeof(threadInfo));
    assert(infos != NULL);
7061

7062 7063
    memset(pids, 0, threads * sizeof(pthread_t));
    memset(infos, 0, threads * sizeof(threadInfo));
7064

7065 7066 7067
    for (int i = 0; i < threads; i++) {
        threadInfo *pThreadInfo = infos + i;
        pThreadInfo->threadID = i;
7068

7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089
        tstrncpy(pThreadInfo->db_name, db_name, TSDB_DB_NAME_LEN);
        pThreadInfo->time_precision = timePrec;
        pThreadInfo->superTblInfo = superTblInfo;

        pThreadInfo->start_time = start_time;
        pThreadInfo->minDelay = UINT64_MAX;

        if ((NULL == superTblInfo) ||
                (superTblInfo->iface != REST_IFACE)) {
            //t_info->taos = taos;
            pThreadInfo->taos = taos_connect(
                    g_Dbs.host, g_Dbs.user,
                    g_Dbs.password, db_name, g_Dbs.port);
            if (NULL == pThreadInfo->taos) {
                errorPrint(
                        "%s() LN%d, connect to server fail from insert sub thread, reason: %s\n",
                        __func__, __LINE__,
                        taos_errstr(NULL));
                free(infos);
                exit(-1);
            }
7090

7091 7092
#if STMT_IFACE_ENABLED == 1
            if ((g_args.iface == STMT_IFACE)
7093 7094
                    || ((superTblInfo)
                        && (superTblInfo->iface == STMT_IFACE))) {
7095

7096 7097 7098 7099 7100 7101
                int columnCount;
                if (superTblInfo) {
                    columnCount = superTblInfo->columnCount;
                } else {
                    columnCount = g_args.num_of_CPR;
                }
7102

7103 7104 7105 7106 7107 7108 7109 7110 7111 7112
                pThreadInfo->stmt = taos_stmt_init(pThreadInfo->taos);
                if (NULL == pThreadInfo->stmt) {
                    errorPrint(
                            "%s() LN%d, failed init stmt, reason: %s\n",
                            __func__, __LINE__,
                            taos_errstr(NULL));
                    free(pids);
                    free(infos);
                    exit(-1);
                }
7113

7114
                char buffer[BUFFER_SIZE];
7115
                char *pstr = buffer;
7116

7117 7118 7119
                if ((superTblInfo)
                        && (AUTO_CREATE_SUBTBL
                            == superTblInfo->autoCreateTable)) {
7120 7121
                    pstr += sprintf(pstr, "INSERT INTO ? USING %s TAGS(?",
                            superTblInfo->sTblName);
7122 7123
                    for (int tag = 0; tag < (superTblInfo->tagCount - 1);
                            tag ++ ) {
7124 7125 7126 7127 7128 7129
                        pstr += sprintf(pstr, ",?");
                    }
                    pstr += sprintf(pstr, ") VALUES(?");
                } else {
                    pstr += sprintf(pstr, "INSERT INTO ? VALUES(?");
                }
7130

7131 7132 7133 7134
                for (int col = 0; col < columnCount; col ++) {
                    pstr += sprintf(pstr, ",?");
                }
                pstr += sprintf(pstr, ")");
7135

7136 7137 7138 7139
                debugPrint("%s() LN%d, buffer: %s", __func__, __LINE__, buffer);
                int ret = taos_stmt_prepare(pThreadInfo->stmt, buffer, 0);
                if (ret != 0){
                    errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
7140
                            ret, taos_stmt_errstr(pThreadInfo->stmt));
7141 7142 7143 7144
                    free(pids);
                    free(infos);
                    exit(-1);
                }
7145
            }
7146
#endif
7147
        } else {
7148
            pThreadInfo->taos = NULL;
7149
        }
7150

7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168
        /*    if ((NULL == superTblInfo)
              || (0 == superTblInfo->multiThreadWriteOneTbl)) {
              */
        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;
        /*    } else {
              pThreadInfo->start_table_from = 0;
              pThreadInfo->ntables = superTblInfo->childTblCount;
              pThreadInfo->start_time = pThreadInfo->start_time + rand_int() % 10000 - rand_tinyint();
              }
              */
        tsem_init(&(pThreadInfo->lock_sem), 0, 0);
        if (ASYNC_MODE == g_Dbs.asyncMode) {
            pthread_create(pids + i, NULL, asyncWrite, pThreadInfo);
        } else {
            pthread_create(pids + i, NULL, syncWrite, pThreadInfo);
7169
        }
7170 7171
    }

7172 7173
    for (int i = 0; i < threads; i++) {
        pthread_join(pids[i], NULL);
7174
    }
H
Hui Li 已提交
7175

7176 7177 7178 7179 7180
    uint64_t totalDelay = 0;
    uint64_t maxDelay = 0;
    uint64_t minDelay = UINT64_MAX;
    uint64_t cntDelay = 1;
    double  avgDelay = 0;
7181

7182 7183
    for (int i = 0; i < threads; i++) {
        threadInfo *pThreadInfo = infos + i;
7184

7185
        tsem_destroy(&(pThreadInfo->lock_sem));
7186

7187
#if STMT_IFACE_ENABLED == 1
7188 7189 7190
        if (pThreadInfo->stmt) {
            taos_stmt_close(pThreadInfo->stmt);
        }
7191
#endif
7192 7193
        tsem_destroy(&(pThreadInfo->lock_sem));
        taos_close(pThreadInfo->taos);
7194

7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205
        debugPrint("%s() LN%d, [%d] totalInsert=%"PRIu64" totalAffected=%"PRIu64"\n",
                __func__, __LINE__,
                pThreadInfo->threadID, pThreadInfo->totalInsertRows,
                pThreadInfo->totalAffectedRows);
        if (superTblInfo) {
            superTblInfo->totalAffectedRows += pThreadInfo->totalAffectedRows;
            superTblInfo->totalInsertRows += pThreadInfo->totalInsertRows;
        } else {
            g_args.totalAffectedRows += pThreadInfo->totalAffectedRows;
            g_args.totalInsertRows += pThreadInfo->totalInsertRows;
        }
H
Hui Li 已提交
7206

7207 7208 7209 7210 7211 7212
        totalDelay  += pThreadInfo->totalDelay;
        cntDelay   += pThreadInfo->cntDelay;
        if (pThreadInfo->maxDelay > maxDelay) maxDelay = pThreadInfo->maxDelay;
        if (pThreadInfo->minDelay < minDelay) minDelay = pThreadInfo->minDelay;
    }
    cntDelay -= 1;
7213

7214 7215
    if (cntDelay == 0)    cntDelay = 1;
    avgDelay = (double)totalDelay / cntDelay;
7216

7217 7218
    int64_t end = taosGetTimestampMs();
    int64_t t = end - start;
7219

7220
    double tInMs = t/1000.0;
7221

7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254
    if (superTblInfo) {
        fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
                tInMs, superTblInfo->totalInsertRows,
                superTblInfo->totalAffectedRows,
                threads, db_name, superTblInfo->sTblName,
                (tInMs)?
                (double)(superTblInfo->totalInsertRows/tInMs):FLT_MAX);

        if (g_fpOfInsertResult) {
            fprintf(g_fpOfInsertResult,
                    "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
                    tInMs, superTblInfo->totalInsertRows,
                    superTblInfo->totalAffectedRows,
                    threads, db_name, superTblInfo->sTblName,
                    (tInMs)?
                    (double)(superTblInfo->totalInsertRows/tInMs):FLT_MAX);
        }
    } else {
        fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
                tInMs, g_args.totalInsertRows,
                g_args.totalAffectedRows,
                threads, db_name,
                (tInMs)?
                (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
        if (g_fpOfInsertResult) {
            fprintf(g_fpOfInsertResult,
                    "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
                    tInMs, g_args.totalInsertRows,
                    g_args.totalAffectedRows,
                    threads, db_name,
                    (tInMs)?
                    (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
        }
7255
    }
7256

7257 7258 7259 7260
    fprintf(stderr, "insert delay, avg: %10.2fms, max: %10.2fms, min: %10.2fms\n\n",
            (double)avgDelay/1000.0,
            (double)maxDelay/1000.0,
            (double)minDelay/1000.0);
7261
    if (g_fpOfInsertResult) {
7262 7263 7264 7265
        fprintf(g_fpOfInsertResult, "insert delay, avg:%10.2fms, max: %10.2fms, min: %10.2fms\n\n",
            (double)avgDelay/1000.0,
            (double)maxDelay/1000.0,
            (double)minDelay/1000.0);
7266
    }
7267

7268
    //taos_close(taos);
7269

7270 7271
    free(pids);
    free(infos);
H
Hui Li 已提交
7272 7273
}

7274
static void *readTable(void *sarg) {
7275
#if 1
7276 7277 7278 7279 7280 7281 7282 7283 7284
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    TAOS *taos = pThreadInfo->taos;
    setThreadName("readTable");
    char command[BUFFER_SIZE] = "\0";
    uint64_t sTime = 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));
7285
        return NULL;
7286
    }
H
hzcheng 已提交
7287

7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299
    int64_t num_of_DPT;
    /*  if (pThreadInfo->superTblInfo) {
        num_of_DPT = pThreadInfo->superTblInfo->insertRows; //  nrecords_per_table;
        } else {
        */
    num_of_DPT = g_args.num_of_DPT;
    //  }

    int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
    int64_t totalData = num_of_DPT * num_of_tables;
    bool do_aggreFunc = g_Dbs.do_aggreFunc;

7300
    int n = do_aggreFunc ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311
    if (!do_aggreFunc) {
        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 < num_of_tables; i++) {
            sprintf(command, "select %s from %s%"PRId64" where ts>= %" PRIu64,
7312
                    g_aggreFunc[j], tb_prefix, i, sTime);
7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324

            double t = taosGetTimestampMs();
            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);
                return NULL;
            }
H
hzcheng 已提交
7325

7326 7327 7328
            while(taos_fetch_row(pSql) != NULL) {
                count++;
            }
H
hzcheng 已提交
7329

7330 7331 7332 7333 7334
            t = taosGetTimestampMs() - t;
            totalT += t;

            taos_free_result(pSql);
        }
H
hzcheng 已提交
7335

7336
        fprintf(fp, "|%10s  |   %"PRId64"   |  %12.2f   |   %10.2f  |\n",
7337
                g_aggreFunc[j][0] == '*' ? "   *   " : g_aggreFunc[j], totalData,
7338
                (double)(num_of_tables * num_of_DPT) / totalT, totalT * 1000);
7339
        printf("select %10s took %.6f second(s)\n", g_aggreFunc[j], totalT * 1000);
7340 7341 7342
    }
    fprintf(fp, "\n");
    fclose(fp);
7343
#endif
7344
    return NULL;
H
hzcheng 已提交
7345 7346
}

7347
static void *readMetric(void *sarg) {
7348
#if 1
7349 7350 7351 7352 7353 7354 7355 7356 7357
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    TAOS *taos = pThreadInfo->taos;
    setThreadName("readMetric");
    char command[BUFFER_SIZE] = "\0";
    FILE *fp = fopen(pThreadInfo->filePath, "a");
    if (NULL == fp) {
        printf("fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
        return NULL;
    }
7358

7359 7360 7361 7362
    int64_t num_of_DPT = pThreadInfo->superTblInfo->insertRows;
    int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
    int64_t totalData = num_of_DPT * num_of_tables;
    bool do_aggreFunc = g_Dbs.do_aggreFunc;
H
hzcheng 已提交
7363

7364
    int n = do_aggreFunc ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
7365 7366 7367 7368 7369
    if (!do_aggreFunc) {
        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);
H
hzcheng 已提交
7370

7371 7372 7373
    for (int j = 0; j < n; j++) {
        char condition[COND_BUF_LEN] = "\0";
        char tempS[64] = "\0";
H
hzcheng 已提交
7374

7375
        int64_t m = 10 < num_of_tables ? 10 : num_of_tables;
H
hzcheng 已提交
7376

7377 7378 7379 7380 7381 7382 7383
        for (int64_t i = 1; i <= m; i++) {
            if (i == 1) {
                sprintf(tempS, "t1 = %"PRId64"", i);
            } else {
                sprintf(tempS, " or t1 = %"PRId64" ", i);
            }
            strncat(condition, tempS, COND_BUF_LEN - 1);
H
hzcheng 已提交
7384

7385
            sprintf(command, "select %s from meters where %s", g_aggreFunc[j], condition);
H
hzcheng 已提交
7386

7387 7388
            printf("Where condition: %s\n", condition);
            fprintf(fp, "%s\n", command);
H
hzcheng 已提交
7389

7390
            double t = taosGetTimestampMs();
H
hzcheng 已提交
7391

7392 7393
            TAOS_RES *pSql = taos_query(taos, command);
            int32_t code = taos_errno(pSql);
S
Shuaiqiang Chang 已提交
7394

7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406
            if (code != 0) {
                errorPrint( "Failed to query:%s\n", taos_errstr(pSql));
                taos_free_result(pSql);
                taos_close(taos);
                fclose(fp);
                return NULL;
            }
            int count = 0;
            while(taos_fetch_row(pSql) != NULL) {
                count++;
            }
            t = taosGetTimestampMs() - t;
H
hzcheng 已提交
7407

7408 7409
            fprintf(fp, "| Speed: %12.2f(per s) | Latency: %.4f(ms) |\n",
                    num_of_tables * num_of_DPT / (t * 1000.0), t);
7410
            printf("select %10s took %.6f second(s)\n\n", g_aggreFunc[j], t * 1000.0);
H
hzcheng 已提交
7411

7412 7413 7414
            taos_free_result(pSql);
        }
        fprintf(fp, "\n");
H
hzcheng 已提交
7415
    }
7416
    fclose(fp);
7417
#endif
7418
    return NULL;
H
hzcheng 已提交
7419 7420
}

7421 7422
static void prompt()
{
7423 7424 7425 7426
    if (!g_args.answer_yes) {
        printf("         Press enter key to continue or Ctrl-C to stop\n\n");
        (void)getchar();
    }
7427
}
H
Hui Li 已提交
7428

7429
static int insertTestProcess() {
7430

7431 7432 7433
    setupForAnsiEscape();
    int ret = printfInsertMeta();
    resetAfterAnsiEscape();
7434

7435 7436
    if (ret == -1)
        exit(EXIT_FAILURE);
7437

7438 7439 7440 7441 7442 7443
    debugPrint("%d result file: %s\n", __LINE__, g_Dbs.resultFile);
    g_fpOfInsertResult = fopen(g_Dbs.resultFile, "a");
    if (NULL == g_fpOfInsertResult) {
        errorPrint( "Failed to open %s for save result\n", g_Dbs.resultFile);
        return -1;
    }
7444

7445 7446
    if (g_fpOfInsertResult)
        printfInsertMetaToFile(g_fpOfInsertResult);
7447

7448
    prompt();
7449

7450
    init_rand_data();
7451

7452 7453 7454 7455 7456 7457
    // create database and super tables
    if(createDatabasesAndStables() != 0) {
        if (g_fpOfInsertResult)
            fclose(g_fpOfInsertResult);
        return -1;
    }
7458

7459 7460 7461 7462 7463 7464
    // pretreatement
    if (prepareSampleData() != 0) {
        if (g_fpOfInsertResult)
            fclose(g_fpOfInsertResult);
        return -1;
    }
7465

7466 7467
    double start;
    double end;
7468

7469 7470 7471 7472
    // create child tables
    start = taosGetTimestampMs();
    createChildTables();
    end = taosGetTimestampMs();
7473

7474 7475 7476 7477 7478 7479 7480 7481
    if (g_totalChildTables > 0) {
        fprintf(stderr, "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
                (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
        if (g_fpOfInsertResult) {
            fprintf(g_fpOfInsertResult,
                    "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
                    (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
        }
7482
    }
7483

7484 7485 7486 7487 7488 7489
    // create sub threads for inserting data
    //start = taosGetTimestampMs();
    for (int i = 0; i < g_Dbs.dbCount; i++) {
        if (g_Dbs.use_metric) {
            if (g_Dbs.db[i].superTblCount > 0) {
                for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
7490

7491
                    SSuperTable* superTblInfo = &g_Dbs.db[i].superTbls[j];
7492

7493 7494 7495 7496 7497 7498 7499 7500 7501 7502
                    if (superTblInfo && (superTblInfo->insertRows > 0)) {
                        startMultiThreadInsertData(
                                g_Dbs.threadCount,
                                g_Dbs.db[i].dbName,
                                g_Dbs.db[i].dbCfg.precision,
                                superTblInfo);
                    }
                }
            }
        } else {
7503
            startMultiThreadInsertData(
7504 7505 7506 7507
                    g_Dbs.threadCount,
                    g_Dbs.db[i].dbName,
                    g_Dbs.db[i].dbCfg.precision,
                    NULL);
7508
        }
H
Hui Li 已提交
7509
    }
7510
    //end = taosGetTimestampMs();
7511

7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522
    //int64_t    totalInsertRows = 0;
    //int64_t    totalAffectedRows = 0;
    //for (int i = 0; i < g_Dbs.dbCount; i++) {
    //  for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
    //  totalInsertRows+= g_Dbs.db[i].superTbls[j].totalInsertRows;
    //  totalAffectedRows += g_Dbs.db[i].superTbls[j].totalAffectedRows;
    //}
    //printf("Spent %.4f seconds to insert rows: %"PRId64", affected rows: %"PRId64" with %d thread(s)\n\n", end - start, totalInsertRows, totalAffectedRows, g_Dbs.threadCount);
    postFreeResource();

    return 0;
7523 7524
}

7525
static void *specifiedTableQuery(void *sarg) {
7526
    threadInfo *pThreadInfo = (threadInfo *)sarg;
7527

7528
    setThreadName("specTableQuery");
7529

7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543
    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;
        }
7544 7545
    }

7546 7547 7548 7549 7550
    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",
7551
                g_queryInfo.dbName);
7552 7553
        return NULL;
    }
7554

7555 7556
    uint64_t st = 0;
    uint64_t et = 0;
7557

7558
    uint64_t queryTimes = g_queryInfo.specifiedQueryInfo.queryTimes;
7559

7560 7561 7562
    uint64_t totalQueried = 0;
    uint64_t lastPrintTime = taosGetTimestampMs();
    uint64_t startTs = taosGetTimestampMs();
7563

7564 7565
    if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != '\0') {
        sprintf(pThreadInfo->filePath, "%s-%d",
7566 7567
                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                pThreadInfo->threadID);
7568 7569
    }

7570 7571 7572 7573 7574 7575 7576
    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();
7577

7578 7579
        selectAndGetResult(pThreadInfo,
                g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq]);
7580

7581 7582 7583
        et = taosGetTimestampMs();
        printf("=thread[%"PRId64"] use %s complete one sql, Spent %10.3f s\n",
                taosGetSelfPthreadId(), g_queryInfo.queryMode, (et - st)/1000.0);
7584

7585 7586
        totalQueried ++;
        g_queryInfo.specifiedQueryInfo.totalQueried ++;
7587

7588 7589 7590 7591 7592 7593
        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",
7594 7595
                    pThreadInfo->threadID,
                    totalQueried,
7596
                    (double)(totalQueried/((endTs-startTs)/1000.0)));
7597 7598
            lastPrintTime = currentPrintTime;
        }
7599
    }
7600
    return NULL;
7601
}
H
Hui Li 已提交
7602

7603
static void replaceChildTblName(char* inSql, char* outSql, int tblIndex) {
7604
    char sourceString[32] = "xxxx";
7605
    char subTblName[TSDB_TABLE_NAME_LEN];
7606 7607 7608
    sprintf(subTblName, "%s.%s",
            g_queryInfo.dbName,
            g_queryInfo.superQueryInfo.childTblName + tblIndex*TSDB_TABLE_NAME_LEN);
7609

7610
    //printf("inSql: %s\n", inSql);
7611

7612 7613 7614 7615 7616 7617 7618
    char* pos = strstr(inSql, sourceString);
    if (0 == pos) {
        return;
    }

    tstrncpy(outSql, inSql, pos - inSql + 1);
    //printf("1: %s\n", outSql);
7619
    strncat(outSql, subTblName, BUFFER_SIZE - 1);
7620
    //printf("2: %s\n", outSql);
7621
    strncat(outSql, pos+strlen(sourceString), BUFFER_SIZE - 1);
7622
    //printf("3: %s\n", outSql);
H
Hui Li 已提交
7623 7624
}

7625
static void *superTableQuery(void *sarg) {
7626
    char sqlstr[BUFFER_SIZE];
7627
    threadInfo *pThreadInfo = (threadInfo *)sarg;
7628

7629
    setThreadName("superTableQuery");
7630

7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644
    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;
        }
7645
    }
7646

7647 7648
    uint64_t st = 0;
    uint64_t et = (int64_t)g_queryInfo.superQueryInfo.queryInterval;
7649

7650 7651 7652
    uint64_t queryTimes = g_queryInfo.superQueryInfo.queryTimes;
    uint64_t totalQueried = 0;
    uint64_t  startTs = taosGetTimestampMs();
H
Hui Li 已提交
7653

7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672
    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,sizeof(sqlstr));
                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);
7673

7674 7675
                totalQueried++;
                g_queryInfo.superQueryInfo.totalQueried ++;
7676

7677 7678 7679 7680 7681 7682 7683 7684 7685 7686
                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;
                }
            }
7687
        }
7688 7689 7690 7691 7692 7693
        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);
H
Hui Li 已提交
7694
    }
7695

7696
    return NULL;
7697 7698
}

7699
static int queryTestProcess() {
7700

7701 7702 7703
    setupForAnsiEscape();
    printfQueryMeta();
    resetAfterAnsiEscape();
7704

7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715
    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(-1);
    }
7716

7717 7718 7719 7720 7721 7722 7723
    if (0 != g_queryInfo.superQueryInfo.sqlCount) {
        getAllChildNameOfSuperTable(taos,
                g_queryInfo.dbName,
                g_queryInfo.superQueryInfo.sTblName,
                &g_queryInfo.superQueryInfo.childTblName,
                &g_queryInfo.superQueryInfo.childTblCount);
    }
7724

7725
    prompt();
7726

7727 7728 7729
    if (g_args.debug_print || g_args.verbose_print) {
        printfQuerySystemInfo(taos);
    }
7730

7731 7732 7733 7734 7735
    if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
        if (convertHostToServAddr(
                    g_queryInfo.host, g_queryInfo.port, &g_queryInfo.serv_addr) != 0)
            exit(-1);
    }
7736

7737 7738 7739 7740 7741
    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;
7742

7743
    uint64_t startTs = taosGetTimestampMs();
7744

7745
    if ((nSqlCount > 0) && (nConcurrent > 0)) {
7746

7747 7748
        pids  = calloc(1, nConcurrent * nSqlCount * sizeof(pthread_t));
        infos = calloc(1, nConcurrent * nSqlCount * sizeof(threadInfo));
7749

7750 7751 7752 7753
        if ((NULL == pids) || (NULL == infos)) {
            taos_close(taos);
            ERROR_EXIT("memory allocation failed for create threads\n");
        }
7754

7755 7756 7757 7758 7759 7760 7761 7762 7763
        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)) {

7764 7765
                    char sqlStr[TSDB_DB_NAME_LEN + 5];
                    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
7766 7767 7768 7769 7770 7771 7772 7773
                    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;
                    }
7774
                }
7775

7776
                pThreadInfo->taos = NULL;// TODO: workaround to use separate taos connection;
7777

7778 7779 7780
                pthread_create(pids + seq, NULL, specifiedTableQuery,
                        pThreadInfo);
            }
7781
        }
7782 7783
    } else {
        g_queryInfo.specifiedQueryInfo.concurrent = 0;
7784 7785
    }

7786
    taos_close(taos);
7787

7788 7789 7790 7791 7792 7793 7794
    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));
7795

7796 7797 7798
        if ((NULL == pidsOfSub) || (NULL == infosOfSub)) {
            free(infos);
            free(pids);
7799

7800 7801
            ERROR_EXIT("memory allocation failed for create threads\n");
        }
7802

7803 7804
        int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
        int threads = g_queryInfo.superQueryInfo.threadCnt;
7805

7806 7807 7808 7809 7810
        int64_t a = ntables / threads;
        if (a < 1) {
            threads = ntables;
            a = 1;
        }
7811

7812 7813 7814 7815
        int64_t b = 0;
        if (threads != 0) {
            b = ntables % threads;
        }
7816

7817 7818 7819 7820
        uint64_t tableFrom = 0;
        for (int i = 0; i < threads; i++) {
            threadInfo *pThreadInfo = infosOfSub + i;
            pThreadInfo->threadID = i;
7821

7822 7823 7824 7825 7826 7827 7828
            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; // TODO: workaround to use separate taos connection;
            pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
        }
7829

7830 7831 7832 7833
        g_queryInfo.superQueryInfo.threadCnt = threads;
    } else {
        g_queryInfo.superQueryInfo.threadCnt = 0;
    }
7834

7835 7836 7837 7838 7839 7840
    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);
            }
        }
7841
    }
S
Shuaiqiang Chang 已提交
7842

7843 7844
    tmfree((char*)pids);
    tmfree((char*)infos);
7845

7846 7847 7848
    for (int i = 0; i < g_queryInfo.superQueryInfo.threadCnt; i++) {
        pthread_join(pidsOfSub[i], NULL);
    }
H
Hui Li 已提交
7849

7850 7851
    tmfree((char*)pidsOfSub);
    tmfree((char*)infosOfSub);
7852

7853 7854
    //  taos_close(taos);// TODO: workaround to use separate taos connection;
    uint64_t endTs = taosGetTimestampMs();
7855

7856 7857
    uint64_t totalQueried = g_queryInfo.specifiedQueryInfo.totalQueried +
        g_queryInfo.superQueryInfo.totalQueried;
7858

7859 7860 7861 7862
    fprintf(stderr, "==== completed total queries: %"PRIu64", the QPS of all threads: %10.3f====\n",
            totalQueried,
            (double)(totalQueried/((endTs-startTs)/1000.0)));
    return 0;
7863 7864
}

7865 7866
static void stable_sub_callback(
        TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
7867 7868 7869 7870 7871
    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;
    }
7872

7873 7874 7875
    if (param)
        fetchResult(res, (threadInfo *)param);
    // tao_unscribe() will free result.
7876 7877 7878 7879
}

static void specified_sub_callback(
        TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
7880 7881 7882 7883 7884
    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;
    }
7885

7886 7887 7888
    if (param)
        fetchResult(res, (threadInfo *)param);
    // tao_unscribe() will free result.
H
hzcheng 已提交
7889 7890
}

7891
static TAOS_SUB* subscribeImpl(
7892 7893 7894 7895
        QUERY_CLASS class,
        threadInfo *pThreadInfo,
        char *sql, char* topic, bool restart, uint64_t interval)
{
7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924
    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;
7925
}
H
hzcheng 已提交
7926

7927
static void *superSubscribe(void *sarg) {
7928
    threadInfo *pThreadInfo = (threadInfo *)sarg;
7929
    char subSqlstr[BUFFER_SIZE];
7930 7931 7932
    TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT] = {0};
    uint64_t tsubSeq;

7933 7934
    setThreadName("superSub");

7935 7936 7937 7938 7939
    if (pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
        errorPrint("The table number(%"PRId64") of the thread is more than max query sql count: %d\n",
                pThreadInfo->ntables, MAX_QUERY_SQL_COUNT);
        exit(-1);
    }
7940

7941
    if (pThreadInfo->taos == NULL) {
7942 7943 7944 7945 7946 7947 7948 7949 7950 7951
        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;
        }
7952 7953
    }

7954 7955
    char sqlStr[TSDB_DB_NAME_LEN + 5];
    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
7956 7957 7958
    if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
        taos_close(pThreadInfo->taos);
        errorPrint( "use database %s failed!\n\n",
7959
                g_queryInfo.dbName);
7960 7961
        return NULL;
    }
7962

7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982
    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, sizeof(subSqlstr));
        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);
        }
7983

7984
        verbosePrint("%s() LN%d, [%d] subSqlstr: %s\n",
7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995
                __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);
            return NULL;
        }
    }
7996

7997 7998 7999 8000 8001 8002
    // 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;
8003

8004
    uint64_t st = 0, et = 0;
8005

8006 8007 8008 8009
    while ((g_queryInfo.superQueryInfo.endAfterConsume == -1)
            || (g_queryInfo.superQueryInfo.endAfterConsume >
                consumed[pThreadInfo->end_table_to
                - pThreadInfo->start_table_from])) {
8010

8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065
        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);
                        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);
8066

8067 8068
    for (uint64_t i = pThreadInfo->start_table_from;
            i <= pThreadInfo->end_table_to; i++) {
8069 8070
        tsubSeq = i - pThreadInfo->start_table_from;
        taos_unsubscribe(tsub[tsubSeq], 0);
H
hzcheng 已提交
8071
    }
8072

8073 8074
    taos_close(pThreadInfo->taos);
    return NULL;
H
hzcheng 已提交
8075 8076
}

8077
static void *specifiedSubscribe(void *sarg) {
8078 8079
    threadInfo *pThreadInfo = (threadInfo *)sarg;
    //  TAOS_SUB*  tsub = NULL;
8080

8081
    setThreadName("specSub");
8082

8083
    if (pThreadInfo->taos == NULL) {
8084 8085 8086 8087 8088 8089 8090 8091 8092 8093
        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;
        }
8094 8095
    }

8096 8097
    char sqlStr[TSDB_DB_NAME_LEN + 5];
    sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108
    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",
8109 8110
                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                pThreadInfo->threadID);
8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123
    }
    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
8124

8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180
    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;
H
hzcheng 已提交
8181 8182
}

8183
static int subscribeTestProcess() {
8184 8185 8186 8187 8188 8189 8190 8191 8192 8193
    setupForAnsiEscape();
    printfQueryMeta();
    resetAfterAnsiEscape();

    prompt();

    TAOS * taos = NULL;
    taos = taos_connect(g_queryInfo.host,
            g_queryInfo.user,
            g_queryInfo.password,
8194
            g_queryInfo.dbName,
8195 8196 8197 8198
            g_queryInfo.port);
    if (taos == NULL) {
        errorPrint( "Failed to connect to TDengine, reason:%s\n",
                taos_errstr(NULL));
S
Shengliang Guan 已提交
8199 8200
        exit(-1);
    }
8201

8202 8203 8204 8205 8206 8207
    if (0 != g_queryInfo.superQueryInfo.sqlCount) {
        getAllChildNameOfSuperTable(taos,
                g_queryInfo.dbName,
                g_queryInfo.superQueryInfo.sTblName,
                &g_queryInfo.superQueryInfo.childTblName,
                &g_queryInfo.superQueryInfo.childTblCount);
S
Shengliang Guan 已提交
8208
    }
8209

8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228
    taos_close(taos); // TODO: 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, sepcified query sqlCount %d.\n",
                __func__, __LINE__,
                g_queryInfo.specifiedQueryInfo.sqlCount);
    } else {
        if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
            errorPrint("%s() LN%d, sepcified query sqlCount %d.\n",
                    __func__, __LINE__,
                    g_queryInfo.specifiedQueryInfo.sqlCount);
            exit(-1);
8229
        }
8230

8231
        pids  = calloc(
8232
                1,
8233 8234 8235 8236
                g_queryInfo.specifiedQueryInfo.sqlCount *
                g_queryInfo.specifiedQueryInfo.concurrent *
                sizeof(pthread_t));
        infos = calloc(
8237
                1,
8238 8239 8240 8241 8242
                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__);
8243 8244
            exit(-1);
        }
8245

8246 8247 8248 8249 8250 8251 8252 8253 8254
        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;  // TODO: workaround to use separate taos connection;
                pthread_create(pids + seq, NULL, specifiedSubscribe, pThreadInfo);
            }
8255
        }
8256
    }
8257

8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281
    //==== 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(-1);
            }
8282

8283 8284
            int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
            int threads = g_queryInfo.superQueryInfo.threadCnt;
8285

8286 8287 8288 8289
            int64_t a = ntables / threads;
            if (a < 1) {
                threads = ntables;
                a = 1;
8290
            }
8291

8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313
            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; // TODO: workaround to use separate taos connection;
                    pthread_create(pidsOfStable + seq,
                            NULL, superSubscribe, pThreadInfo);
                }
            }
8314

8315 8316 8317 8318 8319 8320 8321
            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);
                }
8322 8323
            }
        }
8324
    }
8325

8326 8327 8328 8329 8330
    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);
        }
8331
    }
H
hzcheng 已提交
8332

8333 8334
    tmfree((char*)pids);
    tmfree((char*)infos);
H
hzcheng 已提交
8335

8336 8337 8338 8339
    tmfree((char*)pidsOfStable);
    tmfree((char*)infosOfStable);
    //   taos_close(taos);
    return 0;
H
hzcheng 已提交
8340 8341
}

8342
static void initOfInsertMeta() {
8343
    memset(&g_Dbs, 0, sizeof(SDbs));
8344

8345 8346 8347 8348 8349 8350
    // set default values
    tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
    g_Dbs.port = 6030;
    tstrncpy(g_Dbs.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
    tstrncpy(g_Dbs.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
    g_Dbs.threadCount = 2;
8351

8352
    g_Dbs.use_metric = g_args.use_metric;
L
Liu Tao 已提交
8353 8354
}

8355
static void initOfQueryMeta() {
8356
    memset(&g_queryInfo, 0, sizeof(SQueryMetaInfo));
8357

8358 8359 8360 8361 8362
    // set default values
    tstrncpy(g_queryInfo.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
    g_queryInfo.port = 6030;
    tstrncpy(g_queryInfo.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
    tstrncpy(g_queryInfo.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
L
Liu Tao 已提交
8363 8364
}

8365
static void setParaFromArg() {
8366 8367 8368 8369 8370
    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);
    }
8371

8372 8373 8374
    if (g_args.user) {
        tstrncpy(g_Dbs.user, g_args.user, MAX_USERNAME_SIZE);
    }
8375

8376 8377 8378
    if (g_args.password) {
        tstrncpy(g_Dbs.password, g_args.password, MAX_PASSWORD_SIZE);
    }
L
Liu Tao 已提交
8379

8380 8381 8382
    if (g_args.port) {
        g_Dbs.port = g_args.port;
    }
8383

8384 8385
    g_Dbs.threadCount = g_args.num_of_threads;
    g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
8386

8387 8388
    g_Dbs.dbCount = 1;
    g_Dbs.db[0].drop = true;
L
Liu Tao 已提交
8389

8390 8391
    tstrncpy(g_Dbs.db[0].dbName, g_args.database, TSDB_DB_NAME_LEN);
    g_Dbs.db[0].dbCfg.replica = g_args.replica;
8392
    tstrncpy(g_Dbs.db[0].dbCfg.precision, "ms", SMALL_BUFF_LEN);
8393

8394
    tstrncpy(g_Dbs.resultFile, g_args.output_file, MAX_FILE_NAME_LEN);
8395

8396 8397
    g_Dbs.use_metric = g_args.use_metric;
    g_Dbs.insert_only = g_args.insert_only;
L
Liu Tao 已提交
8398

8399
    g_Dbs.do_aggreFunc = true;
8400

8401
    char dataString[TSDB_MAX_BYTES_PER_ROW];
8402
    char **data_type = g_args.datatype;
L
Liu Tao 已提交
8403

8404
    memset(dataString, 0, TSDB_MAX_BYTES_PER_ROW);
H
hzcheng 已提交
8405

8406 8407 8408 8409
    if (strcasecmp(data_type[0], "BINARY") == 0
            || strcasecmp(data_type[0], "BOOL") == 0
            || strcasecmp(data_type[0], "NCHAR") == 0 ) {
        g_Dbs.do_aggreFunc = false;
8410
    }
8411

8412 8413 8414 8415 8416 8417 8418
    if (g_args.use_metric) {
        g_Dbs.db[0].superTblCount = 1;
        tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", TSDB_TABLE_NAME_LEN);
        g_Dbs.db[0].superTbls[0].childTblCount = g_args.num_of_tables;
        g_Dbs.threadCount = g_args.num_of_threads;
        g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
        g_Dbs.asyncMode = g_args.async_mode;
8419

8420 8421 8422 8423 8424
        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,
8425 8426
                g_args.tb_prefix, TBNAME_PREFIX_LEN);
        tstrncpy(g_Dbs.db[0].superTbls[0].dataSource, "rand", SMALL_BUFF_LEN);
8427

8428 8429 8430 8431 8432 8433 8434
        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);
8435
        g_Dbs.db[0].superTbls[0].timeStampStep = g_args.timestamp_step;
8436

8437 8438
        g_Dbs.db[0].superTbls[0].insertRows = g_args.num_of_DPT;
        g_Dbs.db[0].superTbls[0].maxSqlLen = g_args.max_sql_len;
8439

8440 8441 8442 8443 8444
        g_Dbs.db[0].superTbls[0].columnCount = 0;
        for (int i = 0; i < MAX_NUM_COLUMNS; i++) {
            if (data_type[i] == NULL) {
                break;
            }
8445

8446
            tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
8447
                    data_type[i], min(DATATYPE_BUFF_LEN, strlen(data_type[i]) + 1));
8448 8449 8450 8451 8452 8453 8454 8455 8456 8457
            g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.len_of_binary;
            g_Dbs.db[0].superTbls[0].columnCount++;
        }

        if (g_Dbs.db[0].superTbls[0].columnCount > g_args.num_of_CPR) {
            g_Dbs.db[0].superTbls[0].columnCount = g_args.num_of_CPR;
        } else {
            for (int i = g_Dbs.db[0].superTbls[0].columnCount;
                    i < g_args.num_of_CPR; i++) {
                tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
8458
                        "INT", min(DATATYPE_BUFF_LEN, strlen("INT") + 1));
8459 8460 8461 8462 8463 8464
                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,
8465
                "INT", min(DATATYPE_BUFF_LEN, strlen("INT") + 1));
8466 8467 8468
        g_Dbs.db[0].superTbls[0].tags[0].dataLen = 0;

        tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType,
8469
                "BINARY", min(DATATYPE_BUFF_LEN, strlen("BINARY") + 1));
8470 8471 8472 8473 8474 8475
        g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.len_of_binary;
        g_Dbs.db[0].superTbls[0].tagCount = 2;
    } else {
        g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
        g_Dbs.db[0].superTbls[0].tagCount = 0;
    }
8476 8477 8478 8479
}

/* Function to do regular expression check */
static int regexMatch(const char *s, const char *reg, int cflags) {
8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503
    regex_t regex;
    char    msgbuf[100] = {0};

    /* Compile regular expression */
    if (regcomp(&regex, reg, cflags) != 0) {
        printf("Fail to compile regex\n");
        exit(-1);
    }

    /* 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));
        printf("Regex match failed: %s\n", msgbuf);
        regfree(&regex);
        exit(-1);
    }

8504 8505 8506 8507
    return 0;
}

static int isCommentLine(char *line) {
8508
    if (line == NULL) return 1;
8509

8510
    return regexMatch(line, "^\\s*#.*", REG_EXTENDED);
8511 8512
}

8513
static void querySqlFile(TAOS* taos, char* sqlFile)
8514
{
8515 8516 8517 8518 8519
    FILE *fp = fopen(sqlFile, "r");
    if (fp == NULL) {
        printf("failed to open file %s, reason:%s\n", sqlFile, strerror(errno));
        return;
    }
8520

8521 8522 8523 8524 8525
    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;
8526

8527
    double t = taosGetTimestampMs();
8528

8529 8530 8531
    while((read_len = tgetline(&line, &line_len, fp)) != -1) {
        if (read_len >= TSDB_MAX_BYTES_PER_ROW) continue;
        line[--read_len] = '\0';
8532

8533 8534 8535
        if (read_len == 0 || isCommentLine(line)) {  // line starts with #
            continue;
        }
8536

8537 8538 8539 8540 8541 8542
        if (line[read_len - 1] == '\\') {
            line[read_len - 1] = ' ';
            memcpy(cmd + cmd_len, line, read_len);
            cmd_len += read_len;
            continue;
        }
8543

8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554
        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;
8555
    }
H
hzcheng 已提交
8556

8557 8558
    t = taosGetTimestampMs() - t;
    printf("run %s took %.6f second(s)\n\n", sqlFile, t);
8559

8560 8561 8562 8563
    tmfree(cmd);
    tmfree(line);
    tmfclose(fp);
    return;
H
hzcheng 已提交
8564 8565
}

8566
static void testMetaFile() {
8567
    if (INSERT_TEST == g_args.test_mode) {
8568 8569
        if (g_Dbs.cfgDir[0])
            taos_options(TSDB_OPTION_CONFIGDIR, g_Dbs.cfgDir);
8570

8571
        insertTestProcess();
8572

8573
    } else if (QUERY_TEST == g_args.test_mode) {
8574 8575
        if (g_queryInfo.cfgDir[0])
            taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
8576

8577
        queryTestProcess();
8578

8579
    } else if (SUBSCRIBE_TEST == g_args.test_mode) {
8580 8581
        if (g_queryInfo.cfgDir[0])
            taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
8582

8583
        subscribeTestProcess();
8584

8585
    }  else {
8586
        ;
8587
    }
8588
}
8589

8590
static void queryResult() {
8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604
    // query data

    pthread_t read_id;
    threadInfo *pThreadInfo = calloc(1, sizeof(threadInfo));
    assert(pThreadInfo);
    pThreadInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
    pThreadInfo->start_table_from = 0;

    //pThreadInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
    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->superTblInfo = &g_Dbs.db[0].superTbls[0];
        tstrncpy(pThreadInfo->tb_prefix,
8605
                g_Dbs.db[0].superTbls[0].childTblPrefix, TBNAME_PREFIX_LEN);
8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633
    } else {
        pThreadInfo->ntables = g_args.num_of_tables;
        pThreadInfo->end_table_to = g_args.num_of_tables -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) {
        errorPrint( "Failed to connect to TDengine, reason:%s\n",
                taos_errstr(NULL));
        free(pThreadInfo);
        exit(-1);
    }

    tstrncpy(pThreadInfo->filePath, g_Dbs.resultFile, MAX_FILE_NAME_LEN);

    if (!g_Dbs.use_metric) {
        pthread_create(&read_id, NULL, readTable, pThreadInfo);
    } else {
        pthread_create(&read_id, NULL, readMetric, pThreadInfo);
    }
    pthread_join(read_id, NULL);
    taos_close(pThreadInfo->taos);
8634
    free(pThreadInfo);
8635 8636
}

8637 8638
static void testCmdLine() {

8639 8640 8641 8642 8643 8644 8645 8646
    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);
8647 8648
    }

8649 8650
    g_args.test_mode = INSERT_TEST;
    insertTestProcess();
8651

8652 8653
    if (false == g_Dbs.insert_only)
        queryResult();
8654 8655
}

8656
int main(int argc, char *argv[]) {
8657
    parse_args(argc, argv, &g_args);
8658

8659
    debugPrint("meta file: %s\n", g_args.metaFile);
8660

8661 8662 8663
    if (g_args.metaFile) {
        initOfInsertMeta();
        initOfQueryMeta();
8664

8665 8666 8667 8668
        if (false == getInfoFromJsonFile(g_args.metaFile)) {
            printf("Failed to read %s\n", g_args.metaFile);
            return 1;
        }
8669

8670
        testMetaFile();
8671
    } else {
8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683
        memset(&g_Dbs, 0, sizeof(SDbs));
        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);
8684

8685 8686 8687
        } else {
            testCmdLine();
        }
8688

8689 8690 8691 8692 8693
        if (g_dupstr)
            free(g_dupstr);
    }

    return 0;
H
hzcheng 已提交
8694
}
8695