taosdemo.c 264.7 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 19 20

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

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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
#ifdef LINUX
  #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
S
TD-1057  
Shengliang Guan 已提交
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 57
#define STMT_IFACE_ENABLED  1

58 59 60
#define REQ_EXTRA_BUF_LEN   1024
#define RESP_BUF_LEN        4096

S
slguan 已提交
61 62
extern char configDir[];

63 64 65 66
#define INSERT_JSON_NAME      "insert.json"
#define QUERY_JSON_NAME       "query.json"
#define SUBSCRIBE_JSON_NAME   "subscribe.json"

67 68
#define STR_INSERT_INTO     "INSERT INTO "

69 70 71 72 73 74
enum TEST_MODE {
    INSERT_TEST,            // 0
    QUERY_TEST,             // 1
    SUBSCRIBE_TEST,         // 2
    INVAID_TEST
};
75

76 77
#define MAX_RECORDS_PER_REQ     32766

78 79
#define HEAD_BUFF_LEN    1024*24  // 16*1024 + (192+32)*2 + insert into ..

80 81
#define MAX_SQL_SIZE       65536
#define BUFFER_SIZE        (65536*2)
82
#define COND_BUF_LEN        BUFFER_SIZE - 30
83 84
#define MAX_USERNAME_SIZE  64
#define MAX_PASSWORD_SIZE  64
85
#define MAX_DB_NAME_SIZE   64
86
#define MAX_HOSTNAME_SIZE  64
87
#define MAX_TB_NAME_SIZE   64
88
#define MAX_DATA_SIZE      (16*1024)+20     // max record len: 16*1024, timestamp string and ,('') need extra space
89 90 91 92 93 94 95 96 97 98
#define MAX_NUM_DATATYPE   10
#define OPT_ABORT          1 /* –abort */
#define STRING_LEN         60000
#define MAX_PREPARED_RAND  1000000
#define MAX_FILE_NAME_LEN  256

#define   MAX_SAMPLES_ONCE_FROM_FILE   10000
#define   MAX_NUM_DATATYPE 10

#define   MAX_DB_COUNT           8
99
#define   MAX_SUPER_TABLE_COUNT  200
100 101 102
#define   MAX_COLUMN_COUNT       1024
#define   MAX_TAG_COUNT          128

103
#define   MAX_QUERY_SQL_COUNT    100
104
#define   MAX_QUERY_SQL_LENGTH   1024
105 106

#define   MAX_DATABASE_COUNT     256
107
#define INPUT_BUF_LEN   256
108

109
#define DEFAULT_TIMESTAMP_STEP  1
110

111

112 113 114 115 116
typedef enum CREATE_SUB_TALBE_MOD_EN {
  PRE_CREATE_SUBTBL,
  AUTO_CREATE_SUBTBL,
  NO_CREATE_SUBTBL
} CREATE_SUB_TALBE_MOD_EN;
117

118 119
typedef enum TALBE_EXISTS_EN {
  TBL_NO_EXISTS,
120
  TBL_ALREADY_EXISTS,
121 122 123
  TBL_EXISTS_BUTT
} TALBE_EXISTS_EN;

124
enum enumSYNC_MODE {
125 126
  SYNC_MODE,
  ASYNC_MODE,
127 128
  MODE_BUT
};
129

S
Shuduo Sang 已提交
130
enum enum_TAOS_INTERFACE {
131 132 133
    TAOSC_IFACE,
    REST_IFACE,
    STMT_IFACE,
134 135 136
    INTERFACE_BUT
};

137 138 139 140 141 142
typedef enum enumQUERY_CLASS {
    SPECIFIED_CLASS,
    STABLE_CLASS,
    CLASS_BUT
} QUERY_CLASS;

S
Shuduo Sang 已提交
143
typedef enum enum_PROGRESSIVE_OR_INTERLACE {
144 145 146
    PROGRESSIVE_INSERT_MODE,
    INTERLACE_INSERT_MODE,
    INVALID_INSERT_MODE
147
} PROG_OR_INTERLACE_MODE;
148

149
typedef enum enumQUERY_TYPE {
150
  NO_INSERT_TYPE,
151
  INSERT_TYPE,
152
  QUERY_TYPE_BUT
153
} QUERY_TYPE;
154 155 156 157 158 159 160

enum _show_db_index {
  TSDB_SHOW_DB_NAME_INDEX,
  TSDB_SHOW_DB_CREATED_TIME_INDEX,
  TSDB_SHOW_DB_NTABLES_INDEX,
  TSDB_SHOW_DB_VGROUPS_INDEX,
  TSDB_SHOW_DB_REPLICA_INDEX,
161
  TSDB_SHOW_DB_QUORUM_INDEX,
162 163 164 165 166 167 168 169 170 171
  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,
172
  TSDB_SHOW_DB_PRECISION_INDEX,
173 174 175 176 177 178 179 180 181 182
  TSDB_SHOW_DB_UPDATE_INDEX,
  TSDB_SHOW_DB_STATUS_INDEX,
  TSDB_MAX_SHOW_DB
};

// -----------------------------------------SHOW TABLES CONFIGURE -------------------------------------
enum _show_stables_index {
  TSDB_SHOW_STABLES_NAME_INDEX,
  TSDB_SHOW_STABLES_CREATED_TIME_INDEX,
  TSDB_SHOW_STABLES_COLUMNS_INDEX,
183 184
  TSDB_SHOW_STABLES_METRIC_INDEX,
  TSDB_SHOW_STABLES_UID_INDEX,
185
  TSDB_SHOW_STABLES_TID_INDEX,
186
  TSDB_SHOW_STABLES_VGID_INDEX,
187
  TSDB_MAX_SHOW_STABLES
188 189
};

190 191 192 193 194 195 196 197 198 199 200 201 202 203
enum _describe_table_index {
  TSDB_DESCRIBE_METRIC_FIELD_INDEX,
  TSDB_DESCRIBE_METRIC_TYPE_INDEX,
  TSDB_DESCRIBE_METRIC_LENGTH_INDEX,
  TSDB_DESCRIBE_METRIC_NOTE_INDEX,
  TSDB_MAX_DESCRIBE_METRIC
};

typedef struct {
  char field[TSDB_COL_NAME_LEN + 1];
  char type[16];
  int length;
  char note[128];
} SColDes;
H
hzcheng 已提交
204 205

/* Used by main to communicate with parse_opt. */
206 207
static char *g_dupstr = NULL;

208 209
typedef struct SArguments_S {
  char *   metaFile;
210
  uint32_t test_mode;
211 212
  char *   host;
  uint16_t port;
S
Shuduo Sang 已提交
213
  uint16_t iface;
214 215 216 217 218 219 220
  char *   user;
  char *   password;
  char *   database;
  int      replica;
  char *   tb_prefix;
  char *   sqlFile;
  bool     use_metric;
221
  bool     drop_database;
222
  bool     insert_only;
223
  bool     answer_yes;
224
  bool     debug_print;
225
  bool     verbose_print;
226
  bool     performance_print;
227
  char *   output_file;
228
  bool     async_mode;
229
  char *   datatype[MAX_NUM_DATATYPE + 1];
230 231 232 233
  uint32_t len_of_binary;
  uint32_t num_of_CPR;
  uint32_t num_of_threads;
  uint64_t insert_interval;
234
  int64_t  query_times;
235 236
  uint32_t interlace_rows;
  uint32_t num_of_RPR;                  // num_of_records_per_req
237
  uint64_t max_sql_len;
238 239
  int64_t  num_of_tables;
  int64_t  num_of_DPT;
240
  int      abort;
241
  uint32_t disorderRatio;               // 0: no disorder, >0: x%
242
  int      disorderRange;               // ms or us by database precision
243
  uint32_t method_of_delete;
244
  char **  arg_list;
245 246
  uint64_t totalInsertRows;
  uint64_t totalAffectedRows;
247 248 249
} SArguments;

typedef struct SColumn_S {
250 251 252
  char      field[TSDB_COL_NAME_LEN + 1];
  char      dataType[MAX_TB_NAME_SIZE];
  uint32_t  dataLen;
253
  char      note[128];
254 255 256
} StrColumn;

typedef struct SSuperTable_S {
257
  char         sTblName[MAX_TB_NAME_SIZE+1];
258 259 260 261
  char         dataSource[MAX_TB_NAME_SIZE+1];  // rand_gen or sample
  char         childTblPrefix[MAX_TB_NAME_SIZE];
  char         insertMode[MAX_TB_NAME_SIZE];    // taosc, rest
  uint16_t     childTblExists;
262
  int64_t      childTblCount;
263 264
  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
265
  uint16_t     iface;                   // 0: taosc, 1: rest, 2: stmt
266
  int64_t      childTblLimit;
267
  uint64_t     childTblOffset;
268

269
//  int          multiThreadWriteOneTbl;  // 0: no, 1: yes
270
  uint32_t     interlaceRows;           //
271 272
  int          disorderRatio;           // 0: no disorder, >0: x%
  int          disorderRange;           // ms or us by database precision
273
  uint64_t     maxSqlLen;               //
274

275
  uint64_t     insertInterval;          // insert interval, will override global insert interval
276
  int64_t      insertRows;
277
  int64_t      timeStampStep;
278
  char         startTimestamp[MAX_TB_NAME_SIZE];
279
  char         sampleFormat[MAX_TB_NAME_SIZE];  // csv, json
280 281
  char         sampleFile[MAX_FILE_NAME_LEN+1];
  char         tagsFile[MAX_FILE_NAME_LEN+1];
282

283
  uint32_t     columnCount;
284
  StrColumn    columns[MAX_COLUMN_COUNT];
285
  uint32_t     tagCount;
286 287 288
  StrColumn    tags[MAX_TAG_COUNT];

  char*        childTblName;
289
  char*        colsOfCreateChildTable;
290 291
  uint64_t     lenOfOneRow;
  uint64_t     lenOfTagOfOneRow;
292 293 294 295 296

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

297
  uint32_t     tagSource;    // 0: rand, 1: tag sample
298
  char*        tagDataBuf;
299 300
  uint32_t     tagSampleCount;
  uint32_t     tagUsePos;
301

302
  // statistics
303 304
  uint64_t     totalInsertRows;
  uint64_t     totalAffectedRows;
305 306 307 308 309
} SSuperTable;

typedef struct {
  char     name[TSDB_DB_NAME_LEN + 1];
  char     create_time[32];
S
Shuduo Sang 已提交
310
  int64_t  ntables;
311
  int32_t  vgroups;
312 313
  int16_t  replica;
  int16_t  quorum;
314
  int16_t  days;
315 316 317 318 319 320 321 322 323 324 325 326 327 328
  char     keeplist[32];
  int32_t  cache; //MB
  int32_t  blocks;
  int32_t  minrows;
  int32_t  maxrows;
  int8_t   wallevel;
  int32_t  fsync;
  int8_t   comp;
  int8_t   cachelast;
  char     precision[8];   // time resolution
  int8_t   update;
  char     status[16];
} SDbInfo;

329
typedef struct SDbCfg_S {
330
//  int       maxtablesPerVnode;
331 332
  uint32_t  minRows;        // 0 means default
  uint32_t  maxRows;        // 0 means default
333 334
  int       comp;
  int       walLevel;
335
  int       cacheLast;
336
  int       fsync;
337 338 339 340 341 342 343
  int       replica;
  int       update;
  int       keep;
  int       days;
  int       cache;
  int       blocks;
  int       quorum;
344
  char      precision[MAX_TB_NAME_SIZE];
345 346 347 348
} SDbCfg;

typedef struct SDataBase_S {
  char         dbName[MAX_DB_NAME_SIZE];
349
  bool         drop;  // 0: use exists, 1: if exists, drop then new create
350
  SDbCfg       dbCfg;
351
  uint64_t     superTblCount;
352 353 354 355
  SSuperTable  superTbls[MAX_SUPER_TABLE_COUNT];
} SDataBase;

typedef struct SDbs_S {
356
  char         cfgDir[MAX_FILE_NAME_LEN+1];
357
  char         host[MAX_HOSTNAME_SIZE];
358 359
  struct sockaddr_in serv_addr;

360
  uint16_t     port;
361 362
  char         user[MAX_USERNAME_SIZE];
  char         password[MAX_PASSWORD_SIZE];
363
  char         resultFile[MAX_FILE_NAME_LEN+1];
364 365 366
  bool         use_metric;
  bool         insert_only;
  bool         do_aggreFunc;
367
  bool         asyncMode;
368

369 370 371
  uint32_t     threadCount;
  uint32_t     threadCountByCreateTbl;
  uint32_t     dbCount;
372 373 374
  SDataBase    db[MAX_DB_COUNT];

  // statistics
375 376
  uint64_t     totalInsertRows;
  uint64_t     totalAffectedRows;
377

378 379
} SDbs;

380
typedef struct SpecifiedQueryInfo_S {
381
  uint64_t     queryInterval;  // 0: unlimit  > 0   loop/s
382
  uint32_t     concurrent;
383
  int          sqlCount;
384
  uint32_t     asyncMode; // 0: sync, 1: async
385 386
  uint64_t     subscribeInterval; // ms
  uint64_t     queryTimes;
387
  bool         subscribeRestart;
388
  int          subscribeKeepProgress;
389
  char         sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
390
  char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
391
  int          resubAfterConsume[MAX_QUERY_SQL_COUNT];
392
  int          endAfterConsume[MAX_QUERY_SQL_COUNT];
393
  TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
394 395 396
  char         topic[MAX_QUERY_SQL_COUNT][32];
  int          consumed[MAX_QUERY_SQL_COUNT];
  TAOS_RES*    res[MAX_QUERY_SQL_COUNT];
397
  uint64_t     totalQueried;
398
} SpecifiedQueryInfo;
399

400
typedef struct SuperQueryInfo_S {
401
  char         sTblName[MAX_TB_NAME_SIZE+1];
402 403
  uint64_t     queryInterval;  // 0: unlimit  > 0   loop/s
  uint32_t     threadCnt;
404
  uint32_t     asyncMode; // 0: sync, 1: async
405
  uint64_t     subscribeInterval; // ms
406
  bool         subscribeRestart;
407
  int          subscribeKeepProgress;
408
  uint64_t     queryTimes;
409
  int64_t      childTblCount;
410
  char         childTblPrefix[MAX_TB_NAME_SIZE];
411
  int          sqlCount;
412
  char         sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
413
  char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
414
  int          resubAfterConsume;
415
  int          endAfterConsume;
416
  TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
417

418
  char*        childTblName;
419
  uint64_t     totalQueried;
420
} SuperQueryInfo;
421 422

typedef struct SQueryMetaInfo_S {
423
  char         cfgDir[MAX_FILE_NAME_LEN+1];
424
  char         host[MAX_HOSTNAME_SIZE];
425
  uint16_t     port;
426
  struct       sockaddr_in serv_addr;
427 428
  char         user[MAX_USERNAME_SIZE];
  char         password[MAX_PASSWORD_SIZE];
429
  char         dbName[MAX_DB_NAME_SIZE+1];
430
  char         queryMode[MAX_TB_NAME_SIZE];  // taosc, rest
431

432
  SpecifiedQueryInfo  specifiedQueryInfo;
433
  SuperQueryInfo      superQueryInfo;
434
  uint64_t     totalQueried;
435 436 437
} SQueryMetaInfo;

typedef struct SThreadInfo_S {
438
  TAOS *    taos;
439
  TAOS_STMT *stmt;
440 441 442
  int       threadID;
  char      db_name[MAX_DB_NAME_SIZE+1];
  uint32_t  time_precision;
443 444
  char      filePath[4096];
  FILE      *fp;
445 446 447
  char      tb_prefix[MAX_TB_NAME_SIZE];
  uint64_t  start_table_from;
  uint64_t  end_table_to;
S
Shuduo Sang 已提交
448
  int64_t   ntables;
449 450 451 452
  uint64_t  data_of_rate;
  int64_t   start_time;
  char*     cols;
  bool      use_metric;
453
  SSuperTable* superTblInfo;
S
Shuduo Sang 已提交
454
  char      *buffer;    // sql cmd buffer
455 456

  // for async insert
457 458
  tsem_t    lock_sem;
  int64_t   counter;
459 460
  uint64_t  st;
  uint64_t  et;
461
  uint64_t  lastTs;
462

463
  // sample data
464
  int64_t   samplePos;
465
  // statistics
466 467
  uint64_t  totalInsertRows;
  uint64_t  totalAffectedRows;
468 469

  // insert delay statistics
470 471 472 473 474
  uint64_t  cntDelay;
  uint64_t  totalDelay;
  uint64_t  avgDelay;
  uint64_t  maxDelay;
  uint64_t  minDelay;
475

476
  // seq of query or subscribe
477
  uint64_t  querySeq;   // sequence number of sql command
478
  TAOS_SUB*  tsub;
479

480 481
} threadInfo;

482
#ifdef WINDOWS
483 484
#define _CRT_RAND_S

485
#include <windows.h>
486 487 488 489 490
#include <winsock2.h>

typedef unsigned __int32 uint32_t;

#pragma comment ( lib, "ws2_32.lib" )
491 492
// Some old MinGW/CYGWIN distributions don't define this:
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
493 494
  #define ENABLE_VIRTUAL_TERMINAL_PROCESSING  0x0004
#endif // ENABLE_VIRTUAL_TERMINAL_PROCESSING
495 496 497 498

static HANDLE g_stdoutHandle;
static DWORD g_consoleMode;

499
static void setupForAnsiEscape(void) {
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
  DWORD mode = 0;
  g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);

  if(g_stdoutHandle == INVALID_HANDLE_VALUE) {
    exit(GetLastError());
  }

  if(!GetConsoleMode(g_stdoutHandle, &mode)) {
    exit(GetLastError());
  }

  g_consoleMode = mode;

  // Enable ANSI escape codes
  mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;

  if(!SetConsoleMode(g_stdoutHandle, mode)) {
    exit(GetLastError());
518
  }
519 520
}

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

  // Reset console mode
  if(!SetConsoleMode(g_stdoutHandle, g_consoleMode)) {
    exit(GetLastError());
  }
}
530

531
static int taosRandom()
532 533 534 535 536 537
{
    int number;
    rand_s(&number);

    return number;
}
538
#else   // Not windows
539
static void setupForAnsiEscape(void) {}
540

541
static void resetAfterAnsiEscape(void) {
542 543 544
  // Reset colors
  printf("\x1b[0m");
}
545

546 547
#include <time.h>

548
static int taosRandom()
549
{
550
  return rand();
551 552
}

553
#endif // ifdef Windows
554

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

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

int32_t  randint[MAX_PREPARED_RAND];
int64_t  randbigint[MAX_PREPARED_RAND];
float    randfloat[MAX_PREPARED_RAND];
double   randdouble[MAX_PREPARED_RAND];
570
char *aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
571 572
    "max(col0)", "min(col0)", "first(col0)", "last(col0)"};

573
SArguments g_args = {
574 575 576 577
                     NULL,            // metaFile
                     0,               // test_mode
                     "127.0.0.1",     // host
                     6030,            // port
S
Shuduo Sang 已提交
578
                     TAOSC_IFACE,     // iface
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
                     "root",          // user
                     #ifdef _TD_POWER_
                     "powerdb",      // password
                     #else
                     "taosdata",      // password
                     #endif
                     "test",          // database
                     1,               // replica
                     "t",             // 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
                     {
                     "INT",           // datatype
                     "INT",           // datatype
                     "INT",           // datatype
                     "INT",           // datatype
                     },
                     16,              // len_of_binary
                     4,               // num_of_CPR
                     10,              // num_of_connections/thread
                     0,               // insert_interval
                     1,               // query_times
                     0,               // interlace_rows;
                     30000,           // num_of_RPR
sangshuduo's avatar
sangshuduo 已提交
611
                     (1024*1024),         // max_sql_len
612 613 614 615 616 617 618
                     10000,           // num_of_tables
                     10000,           // num_of_DPT
                     0,               // abort
                     0,               // disorderRatio
                     1000,            // disorderRange
                     1,               // method_of_delete
                     NULL             // arg_list
619 620 621 622 623
};



static SDbs            g_Dbs;
624
static int64_t         g_totalChildTables = 0;
625 626 627
static SQueryMetaInfo  g_queryInfo;
static FILE *          g_fpOfInsertResult = NULL;

628 629 630 631
#if _MSC_VER <= 1900
#define __func__ __FUNCTION__
#endif

632
#define debugPrint(fmt, ...) \
633
    do { if (g_args.debug_print || g_args.verbose_print) \
634
      fprintf(stderr, "DEBG: "fmt, __VA_ARGS__); } while(0)
635

636
#define verbosePrint(fmt, ...) \
637 638
    do { if (g_args.verbose_print) \
        fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0)
639

640 641 642 643
#define performancePrint(fmt, ...) \
    do { if (g_args.performance_print) \
        fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0)

644 645 646 647
#define errorPrint(fmt, ...) \
    do { fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); } while(0)


648
///////////////////////////////////////////////////
H
hzcheng 已提交
649

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

652 653 654 655 656 657 658 659
#ifndef TAOSDEMO_COMMIT_SHA1
#define TAOSDEMO_COMMIT_SHA1 "unknown"
#endif

#ifndef TD_VERNUMBER
#define TD_VERNUMBER    "unknown"
#endif

660
#ifndef TAOSDEMO_STATUS
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
#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);
    }
}

678
static void printHelp() {
679
  char indent[10] = "        ";
680
  printf("%s%s%s%s\n", indent, "-f", indent,
681
          "The meta file to the execution procedure. Default is './meta.json'.");
682
  printf("%s%s%s%s\n", indent, "-u", indent,
683 684
          "The TDengine user name to use when connecting to the server. Default is 'root'.");
#ifdef _TD_POWER_
685
  printf("%s%s%s%s\n", indent, "-P", indent,
686
          "The password to use when connecting to the server. Default is 'powerdb'.");
687
  printf("%s%s%s%s\n", indent, "-c", indent,
688 689
          "Configuration directory. Default is '/etc/power/'.");
#else
690
  printf("%s%s%s%s\n", indent, "-P", indent,
691
          "The password to use when connecting to the server. Default is 'taosdata'.");
692
  printf("%s%s%s%s\n", indent, "-c", indent,
693
          "Configuration directory. Default is '/etc/taos/'.");
694
#endif
695
  printf("%s%s%s%s\n", indent, "-h", indent,
696
          "The host to connect to TDengine. Default is localhost.");
697
  printf("%s%s%s%s\n", indent, "-p", indent,
698
          "The TCP/IP port number to use for the connection. Default is 0.");
699
  printf("%s%s%s%s\n", indent, "-I", indent,
700
#if STMT_IFACE_ENABLED == 1
701
          "The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
702 703 704
#else
          "The interface (taosc, rest) taosdemo uses. Default is 'taosc'.");
#endif
705
  printf("%s%s%s%s\n", indent, "-d", indent,
706
          "Destination database. Default is 'test'.");
707
  printf("%s%s%s%s\n", indent, "-a", indent,
708
          "Set the replica parameters of the database, Default 1, min: 1, max: 3.");
709
  printf("%s%s%s%s\n", indent, "-m", indent,
710 711
          "Table prefix name. Default is 't'.");
  printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
712
  printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
713
  printf("%s%s%s%s\n", indent, "-o", indent,
714
          "Direct output to the named file. Default is './output.txt'.");
715
  printf("%s%s%s%s\n", indent, "-q", indent,
716
          "Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
717
  printf("%s%s%s%s\n", indent, "-b", indent,
sangshuduo's avatar
sangshuduo 已提交
718
          "The data_type of columns, default: INT,INT,INT,INT.");
719
  printf("%s%s%s%s\n", indent, "-w", indent,
720
          "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
721 722 723
  printf("%s%s%s%s%d\n", indent, "-l", indent,
          "The number of columns per record. Default is 4. Max values is ",
       MAX_NUM_DATATYPE);
724
  printf("%s%s%s%s\n", indent, "-T", indent,
725
          "The number of threads. Default is 10.");
726
  printf("%s%s%s%s\n", indent, "-i", indent,
727
          "The sleep time (ms) between insertion. Default is 0.");
728
  printf("%s%s%s%s\n", indent, "-r", indent,
729
          "The number of records per request. Default is 30000.");
730
  printf("%s%s%s%s\n", indent, "-t", indent,
731
          "The number of tables. Default is 10000.");
732
  printf("%s%s%s%s\n", indent, "-n", indent,
733 734 735
          "The number of records per table. Default is 10000.");
  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.");
736
  printf("%s%s%s%s\n", indent, "-O", indent,
737
          "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
738
  printf("%s%s%s%s\n", indent, "-R", indent,
739
          "Out of order data's range, ms, default is 1000.");
740
  printf("%s%s%s%s\n", indent, "-g", indent,
741
          "Print debug info.");
742
  printf("%s%s%s\n", indent, "-V, --version\t",
743
          "Print version info.");
744 745
  printf("%s%s%s%s\n", indent, "--help\t", indent,
          "Print command line arguments list info.");
746
/*    printf("%s%s%s%s\n", indent, "-D", indent,
747 748 749 750
          "if elete database if exists. 0: no, 1: yes, default is 1");
          */
}

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
static bool isStringNumber(char *input)
{
  int len = strlen(input);
  if (0 == len) {
    return false;
  }

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

  return true;
}

766
static void parse_args(int argc, char *argv[], SArguments *arguments) {
767 768 769 770 771

  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "-f") == 0) {
      arguments->metaFile = argv[++i];
    } else if (strcmp(argv[i], "-c") == 0) {
H
Haojun Liao 已提交
772 773 774 775 776
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-c need a valid path following!\n");
        exit(EXIT_FAILURE);
      }
777
      tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
778
    } else if (strcmp(argv[i], "-h") == 0) {
H
Haojun Liao 已提交
779 780 781 782 783
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-h need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
784 785
      arguments->host = argv[++i];
    } else if (strcmp(argv[i], "-p") == 0) {
786
      if ((argc == i+1) ||
787
        (!isStringNumber(argv[i+1]))) {
788 789 790 791
        printHelp();
        errorPrint("%s", "\n\t-p need a number following!\n");
        exit(EXIT_FAILURE);
      }
792
      arguments->port = atoi(argv[++i]);
793 794 795 796 797 798 799 800
    } 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")) {
S
Shuduo Sang 已提交
801
          arguments->iface = TAOSC_IFACE;
802
      } else if (0 == strcasecmp(argv[i], "rest")) {
S
Shuduo Sang 已提交
803
          arguments->iface = REST_IFACE;
804
#if STMT_IFACE_ENABLED == 1
805
      } else if (0 == strcasecmp(argv[i], "stmt")) {
S
Shuduo Sang 已提交
806
          arguments->iface = STMT_IFACE;
807
#endif
808 809 810 811
      } else {
        errorPrint("%s", "\n\t-I need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
812
    } else if (strcmp(argv[i], "-u") == 0) {
H
Haojun Liao 已提交
813 814 815 816 817
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-u need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
818 819
      arguments->user = argv[++i];
    } else if (strcmp(argv[i], "-P") == 0) {
H
Haojun Liao 已提交
820 821 822 823 824
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-P need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
825 826
      arguments->password = argv[++i];
    } else if (strcmp(argv[i], "-o") == 0) {
H
Haojun Liao 已提交
827 828 829 830 831
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-o need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
832 833
      arguments->output_file = argv[++i];
    } else if (strcmp(argv[i], "-s") == 0) {
H
Haojun Liao 已提交
834 835 836 837 838
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-s need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
839 840
      arguments->sqlFile = argv[++i];
    } else if (strcmp(argv[i], "-q") == 0) {
841 842
      if ((argc == i+1)
              || (!isStringNumber(argv[i+1]))) {
843
        printHelp();
844
        errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
845 846
        exit(EXIT_FAILURE);
      }
847
      arguments->async_mode = atoi(argv[++i]);
848
    } else if (strcmp(argv[i], "-T") == 0) {
849 850
      if ((argc == i+1)
              || (!isStringNumber(argv[i+1]))) {
851 852 853 854
        printHelp();
        errorPrint("%s", "\n\t-T need a number following!\n");
        exit(EXIT_FAILURE);
      }
855 856
      arguments->num_of_threads = atoi(argv[++i]);
    } else if (strcmp(argv[i], "-i") == 0) {
857 858
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
859 860 861 862
        printHelp();
        errorPrint("%s", "\n\t-i need a number following!\n");
        exit(EXIT_FAILURE);
      }
863
      arguments->insert_interval = atoi(argv[++i]);
864
    } else if (strcmp(argv[i], "-qt") == 0) {
865
      if ((argc == i+1)
866
              || (!isStringNumber(argv[i+1]))) {
H
Haojun Liao 已提交
867
        printHelp();
868
        errorPrint("%s", "\n\t-qt need a number following!\n");
H
Haojun Liao 已提交
869 870
        exit(EXIT_FAILURE);
      }
871
      arguments->query_times = atoi(argv[++i]);
872
    } else if (strcmp(argv[i], "-B") == 0) {
873 874
      if ((argc == i+1)
              || (!isStringNumber(argv[i+1]))) {
H
Haojun Liao 已提交
875 876 877 878
        printHelp();
        errorPrint("%s", "\n\t-B need a number following!\n");
        exit(EXIT_FAILURE);
      }
879
      arguments->interlace_rows = atoi(argv[++i]);
880
    } else if (strcmp(argv[i], "-r") == 0) {
881 882
      if ((argc == i+1)
              || (!isStringNumber(argv[i+1]))) {
883 884 885 886
        printHelp();
        errorPrint("%s", "\n\t-r need a number following!\n");
        exit(EXIT_FAILURE);
      }
887 888
      arguments->num_of_RPR = atoi(argv[++i]);
    } else if (strcmp(argv[i], "-t") == 0) {
889 890 891 892 893 894
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
        printHelp();
        errorPrint("%s", "\n\t-t need a number following!\n");
        exit(EXIT_FAILURE);
      }
895 896
      arguments->num_of_tables = atoi(argv[++i]);
    } else if (strcmp(argv[i], "-n") == 0) {
897 898 899 900 901 902
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
        printHelp();
        errorPrint("%s", "\n\t-n need a number following!\n");
        exit(EXIT_FAILURE);
      }
903 904
      arguments->num_of_DPT = atoi(argv[++i]);
    } else if (strcmp(argv[i], "-d") == 0) {
H
Haojun Liao 已提交
905 906 907 908 909
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-d need a valid string following!\n");
        exit(EXIT_FAILURE);
      }
910 911
      arguments->database = argv[++i];
    } else if (strcmp(argv[i], "-l") == 0) {
912 913 914 915 916 917
      if (argc == i+1) {
        if (!isStringNumber(argv[i+1])) {
            printHelp();
            errorPrint("%s", "\n\t-l need a number following!\n");
            exit(EXIT_FAILURE);
        }
918
      }
919
      arguments->num_of_CPR = atoi(argv[++i]);
920 921 922 923 924 925 926 927 928 929 930

      if (arguments->num_of_CPR > MAX_NUM_DATATYPE) {
          printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_DATATYPE);
          prompt();
          arguments->num_of_CPR = MAX_NUM_DATATYPE;
      }

      for (int col = arguments->num_of_CPR; col < MAX_NUM_DATATYPE; col++) {
          arguments->datatype[col] = NULL;
      }

931
    } else if (strcmp(argv[i], "-b") == 0) {
932 933 934 935 936
      if (argc == i+1) {
        printHelp();
        errorPrint("%s", "\n\t-b need valid string following!\n");
        exit(EXIT_FAILURE);
      }
937 938
      ++i;
      if (strstr(argv[i], ",") == NULL) {
939
        // only one col
940
        if (strcasecmp(argv[i], "INT")
941 942 943 944 945 946 947
                && 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")
948
                && strcasecmp(argv[i], "TIMESTAMP")
949
                && strcasecmp(argv[i], "NCHAR")) {
950
          printHelp();
951
          errorPrint("%s", "-b: Invalid data_type!\n");
952
          exit(EXIT_FAILURE);
953
        }
954
        arguments->datatype[0] = argv[i];
955
      } else {
956
        // more than one col
957
        int index = 0;
958 959
        g_dupstr = strdup(argv[i]);
        char *running = g_dupstr;
960
        char *token = strsep(&running, ",");
961
        while(token != NULL) {
962
          if (strcasecmp(token, "INT")
963 964 965 966 967 968 969
                  && strcasecmp(token, "FLOAT")
                  && strcasecmp(token, "TINYINT")
                  && strcasecmp(token, "BOOL")
                  && strcasecmp(token, "SMALLINT")
                  && strcasecmp(token, "BIGINT")
                  && strcasecmp(token, "DOUBLE")
                  && strcasecmp(token, "BINARY")
970
                  && strcasecmp(token, "TIMESTAMP")
971
                  && strcasecmp(token, "NCHAR")) {
972
            printHelp();
973
            free(g_dupstr);
974
            errorPrint("%s", "-b: Invalid data_type!\n");
975
            exit(EXIT_FAILURE);
H
hzcheng 已提交
976
          }
977
          arguments->datatype[index++] = token;
978 979
          token = strsep(&running, ",");
          if (index >= MAX_NUM_DATATYPE) break;
S
TD-1057  
Shengliang Guan 已提交
980
        }
981
        arguments->datatype[index] = NULL;
982
      }
983
    } else if (strcmp(argv[i], "-w") == 0) {
984
      if ((argc == i+1) ||
985
        (!isStringNumber(argv[i+1]))) {
986 987 988 989
        printHelp();
        errorPrint("%s", "\n\t-w need a number following!\n");
        exit(EXIT_FAILURE);
      }
990 991
      arguments->len_of_binary = atoi(argv[++i]);
    } else if (strcmp(argv[i], "-m") == 0) {
H
Haojun Liao 已提交
992
      if ((argc == i+1) ||
993
        (!isStringNumber(argv[i+1]))) {
H
Haojun Liao 已提交
994 995 996 997
        printHelp();
        errorPrint("%s", "\n\t-m need a number following!\n");
        exit(EXIT_FAILURE);
      }
998
      arguments->tb_prefix = argv[++i];
999 1000
    } else if (strcmp(argv[i], "-N") == 0) {
      arguments->use_metric = false;
1001
    } else if (strcmp(argv[i], "-x") == 0) {
1002
      arguments->insert_only = false;
1003
    } else if (strcmp(argv[i], "-y") == 0) {
1004
      arguments->answer_yes = true;
1005 1006
    } else if (strcmp(argv[i], "-g") == 0) {
      arguments->debug_print = true;
1007 1008
    } else if (strcmp(argv[i], "-gg") == 0) {
      arguments->verbose_print = true;
1009 1010
    } else if (strcmp(argv[i], "-pp") == 0) {
      arguments->performance_print = true;
1011
    } else if (strcmp(argv[i], "-O") == 0) {
1012 1013 1014 1015 1016 1017
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
        printHelp();
        errorPrint("%s", "\n\t-O need a number following!\n");
        exit(EXIT_FAILURE);
      }
1018

1019
      arguments->disorderRatio = atoi(argv[++i]);
1020

1021
      if (arguments->disorderRatio > 50) {
1022
        arguments->disorderRatio = 50;
1023
      }
1024

1025
      if (arguments->disorderRatio < 0) {
1026
        arguments->disorderRatio = 0;
1027
      }
1028

1029
    } else if (strcmp(argv[i], "-R") == 0) {
1030 1031 1032 1033 1034 1035
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
        printHelp();
        errorPrint("%s", "\n\t-R need a number following!\n");
        exit(EXIT_FAILURE);
      }
1036

1037
      arguments->disorderRange = atoi(argv[++i]);
1038 1039 1040
      if (arguments->disorderRange < 0)
        arguments->disorderRange = 1000;

1041
    } else if (strcmp(argv[i], "-a") == 0) {
1042 1043 1044 1045 1046 1047
      if ((argc == i+1) ||
        (!isStringNumber(argv[i+1]))) {
        printHelp();
        errorPrint("%s", "\n\t-a need a number following!\n");
        exit(EXIT_FAILURE);
      }
1048 1049 1050
      arguments->replica = atoi(argv[++i]);
      if (arguments->replica > 3 || arguments->replica < 1) {
          arguments->replica = 1;
1051
      }
1052 1053
    } else if (strcmp(argv[i], "-D") == 0) {
      arguments->method_of_delete = atoi(argv[++i]);
1054 1055 1056
      if (arguments->method_of_delete > 3) {
        errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
        exit(EXIT_FAILURE);
S
TD-1057  
Shengliang Guan 已提交
1057
      }
1058 1059 1060 1061
    } else if ((strcmp(argv[i], "--version") == 0) ||
        (strcmp(argv[i], "-V") == 0)){
      printVersion();
      exit(0);
1062 1063 1064 1065 1066
    } else if (strcmp(argv[i], "--help") == 0) {
      printHelp();
      exit(0);
    } else {
      printHelp();
1067
      errorPrint("%s", "ERROR: wrong options\n");
1068
      exit(EXIT_FAILURE);
S
TD-1057  
Shengliang Guan 已提交
1069 1070
    }
  }
1071

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
  int columnCount;
  for (columnCount = 0; columnCount < MAX_NUM_DATATYPE; columnCount ++) {
    if (g_args.datatype[columnCount] == NULL) {
      break;
    }
  }

  if (0 == columnCount) {
    perror("data type error!");
    exit(-1);
  }
  g_args.num_of_CPR = columnCount;

1085
  if (((arguments->debug_print) && (arguments->metaFile == NULL))
1086
          || arguments->verbose_print) {
1087
    printf("###################################################################\n");
1088
    printf("# meta file:                         %s\n", arguments->metaFile);
1089
    printf("# Server IP:                         %s:%hu\n",
1090 1091
            arguments->host == NULL ? "localhost" : arguments->host,
            arguments->port );
1092 1093
    printf("# User:                              %s\n", arguments->user);
    printf("# Password:                          %s\n", arguments->password);
1094 1095
    printf("# Use metric:                        %s\n",
            arguments->use_metric ? "true" : "false");
1096
    if (*(arguments->datatype)) {
1097 1098 1099 1100 1101 1102 1103
        printf("# Specified data type:               ");
        for (int i = 0; i < MAX_NUM_DATATYPE; i++)
            if (arguments->datatype[i])
               printf("%s,", arguments->datatype[i]);
            else
                break;
        printf("\n");
1104
    }
1105
    printf("# Insertion interval:                %"PRIu64"\n",
1106
            arguments->insert_interval);
1107
    printf("# Number of records per req:         %u\n",
1108
            arguments->num_of_RPR);
1109
    printf("# Max SQL length:                    %"PRIu64"\n",
1110
            arguments->max_sql_len);
1111
    printf("# Length of Binary:                  %d\n", arguments->len_of_binary);
1112
    printf("# Number of Threads:                 %d\n", arguments->num_of_threads);
1113
    printf("# Number of Tables:                  %"PRId64"\n",
1114
            arguments->num_of_tables);
1115
    printf("# Number of Data per Table:          %"PRId64"\n",
1116
            arguments->num_of_DPT);
1117 1118 1119 1120 1121
    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);
1122

1123 1124 1125 1126
    }
    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);
1127
    printf("# Print verbose info:                %d\n", arguments->verbose_print);
1128
    printf("###################################################################\n");
1129 1130

    prompt();
1131
  }
1132
}
H
hzcheng 已提交
1133

1134 1135
static bool getInfoFromJsonFile(char* file);
static void init_rand_data();
1136
static void tmfclose(FILE *fp) {
1137 1138 1139 1140
  if (NULL != fp) {
    fclose(fp);
  }
}
1141

1142
static void tmfree(char *buf) {
1143 1144
  if (NULL != buf) {
    free(buf);
H
Hui Li 已提交
1145
  }
1146
}
H
Hui Li 已提交
1147

1148
static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
1149 1150 1151
  int i;
  TAOS_RES *res = NULL;
  int32_t   code = -1;
1152

S
Shuduo Sang 已提交
1153
  for (i = 0; i < 5 /* retry */; i++) {
1154 1155 1156
    if (NULL != res) {
      taos_free_result(res);
      res = NULL;
H
hzcheng 已提交
1157
    }
1158

1159 1160 1161 1162
    res = taos_query(taos, command);
    code = taos_errno(res);
    if (0 == code) {
      break;
1163
    }
H
hzcheng 已提交
1164 1165
  }

1166
  verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
1167
  if (code != 0) {
1168
    if (!quiet) {
1169 1170
      errorPrint("Failed to execute %s, reason: %s\n",
              command, taos_errstr(res));
1171
    }
1172 1173 1174
    taos_free_result(res);
    //taos_close(taos);
    return -1;
1175
  }
H
hzcheng 已提交
1176

1177 1178 1179 1180
  if (INSERT_TYPE == type) {
    int affectedRows = taos_affected_rows(res);
    taos_free_result(res);
    return affectedRows;
H
hzcheng 已提交
1181
  }
1182

1183
  taos_free_result(res);
1184 1185
  return 0;
}
H
hzcheng 已提交
1186

1187
static void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo)
1188
{
1189 1190
  pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
  if (pThreadInfo->fp == NULL) {
1191 1192
      errorPrint(
              "%s() LN%d, failed to open result file: %s, result will not save to file\n",
1193
              __func__, __LINE__, pThreadInfo->filePath);
1194 1195 1196
      return;
  }

1197 1198 1199
  fprintf(pThreadInfo->fp, "%s", resultBuf);
  tmfclose(pThreadInfo->fp);
  pThreadInfo->fp = NULL;
1200 1201
}

1202
static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
1203 1204 1205 1206 1207
  TAOS_ROW    row = NULL;
  int         num_rows = 0;
  int         num_fields = taos_field_count(res);
  TAOS_FIELD *fields     = taos_fetch_fields(res);

1208 1209
  char* databuf = (char*) calloc(1, 100*1024*1024);
  if (databuf == NULL) {
1210 1211
    errorPrint("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
            __func__, __LINE__);
1212 1213
    return ;
  }
H
hzcheng 已提交
1214

1215
  int   totalLen = 0;
H
hzcheng 已提交
1216

1217
  // fetch the records row by row
1218
  while((row = taos_fetch_row(res))) {
1219
    if ((strlen(pThreadInfo->filePath) > 0)
1220
            && (totalLen >= 100*1024*1024 - 32000)) {
1221
        appendResultBufToFile(databuf, pThreadInfo);
1222 1223
        totalLen = 0;
        memset(databuf, 0, 100*1024*1024);
H
hzcheng 已提交
1224
    }
1225
    num_rows++;
J
jiaoqiyuan 已提交
1226
    char temp[16000] = {0};
1227 1228 1229 1230 1231
    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;
H
hzcheng 已提交
1232 1233
  }

1234
  verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
1235 1236 1237
          __func__, __LINE__, databuf, pThreadInfo->filePath);
  if (strlen(pThreadInfo->filePath) > 0) {
    appendResultBufToFile(databuf, pThreadInfo);
1238
  }
1239 1240
  free(databuf);
}
H
hzcheng 已提交
1241

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

1254
    fetchResult(res, pThreadInfo);
1255
    taos_free_result(res);
1256

1257 1258 1259
  } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
      int retCode = postProceSql(
              g_queryInfo.host, &(g_queryInfo.serv_addr), g_queryInfo.port,
1260
              command,
1261
              pThreadInfo);
1262 1263 1264 1265 1266 1267 1268 1269
      if (0 != retCode) {
        printf("====restful return fail, threadID[%d]\n", pThreadInfo->threadID);
      }

  } else {
      errorPrint("%s() LN%d, unknown query mode: %s\n",
        __func__, __LINE__, g_queryInfo.queryMode);
  }
1270
}
H
hzcheng 已提交
1271

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
static int32_t rand_bool(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randint[cursor] % 2;
}

static int32_t rand_tinyint(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randint[cursor] % 128;
}

static int32_t rand_smallint(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randint[cursor] % 32767;
}

static int32_t rand_int(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randint[cursor];
}

static int64_t rand_bigint(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randbigint[cursor];
}

static float rand_float(){
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
1311
  return randfloat[cursor];
1312 1313
}

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
#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)
{
  str[0] = 0;
  if (size > 0) {
    int n;
    for (n = 0; n < size; n++) {
      str[n] = charNum[n % 10];
    }
    str[n] = 0;
  }
}
#endif

1331
static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
1332

1333
static void rand_string(char *str, int size) {
1334 1335 1336 1337
  str[0] = 0;
  if (size > 0) {
    //--size;
    int n;
1338
    for (n = 0; n < size; n++) {
1339
      int key = abs(rand_tinyint()) % (int)(sizeof(charset) - 1);
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
      str[n] = charset[key];
    }
    str[n] = 0;
  }
}

static double rand_double() {
  static int cursor;
  cursor++;
  cursor = cursor % MAX_PREPARED_RAND;
  return randdouble[cursor];

}

static void init_rand_data() {
  for (int i = 0; i < MAX_PREPARED_RAND; i++){
1356 1357 1358 1359
    randint[i] = (int)(taosRandom() % 65535);
    randbigint[i] = (int64_t)(taosRandom() % 2147483648);
    randfloat[i] = (float)(taosRandom() / 1000.0);
    randdouble[i] = (double)(taosRandom() / 1000000.0);
1360 1361 1362
  }
}

1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
#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)

1383
static int printfInsertMeta() {
1384
    SHOW_PARSE_RESULT_START();
1385

1386
  printf("interface:                  \033[33m%s\033[0m\n",
S
Shuduo Sang 已提交
1387
          (g_args.iface==TAOSC_IFACE)?"taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
1388 1389
  printf("host:                       \033[33m%s:%u\033[0m\n",
          g_Dbs.host, g_Dbs.port);
1390 1391
  printf("user:                       \033[33m%s\033[0m\n", g_Dbs.user);
  printf("password:                   \033[33m%s\033[0m\n", g_Dbs.password);
1392
  printf("configDir:                  \033[33m%s\033[0m\n", configDir);
1393 1394
  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);
1395 1396
  printf("thread num of create table: \033[33m%d\033[0m\n",
          g_Dbs.threadCountByCreateTbl);
1397
  printf("top insert interval:        \033[33m%"PRIu64"\033[0m\n",
1398
          g_args.insert_interval);
1399
  printf("number of records per req:  \033[33m%u\033[0m\n",
1400
          g_args.num_of_RPR);
1401
  printf("max sql length:             \033[33m%"PRIu64"\033[0m\n",
1402
          g_args.max_sql_len);
1403 1404

  printf("database count:             \033[33m%d\033[0m\n", g_Dbs.dbCount);
1405

1406 1407
  for (int i = 0; i < g_Dbs.dbCount; i++) {
    printf("database[\033[33m%d\033[0m]:\n", i);
1408 1409
    printf("  database[%d] name:      \033[33m%s\033[0m\n",
            i, g_Dbs.db[i].dbName);
1410
    if (0 == g_Dbs.db[i].drop) {
1411 1412 1413
      printf("  drop:                  \033[33mno\033[0m\n");
    } else {
      printf("  drop:                  \033[33myes\033[0m\n");
1414 1415 1416
    }

    if (g_Dbs.db[i].dbCfg.blocks > 0) {
1417 1418
      printf("  blocks:                \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.blocks);
1419 1420
    }
    if (g_Dbs.db[i].dbCfg.cache > 0) {
1421 1422
      printf("  cache:                 \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.cache);
1423 1424
    }
    if (g_Dbs.db[i].dbCfg.days > 0) {
1425 1426
      printf("  days:                  \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.days);
1427 1428
    }
    if (g_Dbs.db[i].dbCfg.keep > 0) {
1429 1430
      printf("  keep:                  \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.keep);
1431 1432
    }
    if (g_Dbs.db[i].dbCfg.replica > 0) {
1433 1434
      printf("  replica:               \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.replica);
1435 1436
    }
    if (g_Dbs.db[i].dbCfg.update > 0) {
1437 1438
      printf("  update:                \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.update);
1439 1440
    }
    if (g_Dbs.db[i].dbCfg.minRows > 0) {
1441 1442
      printf("  minRows:               \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.minRows);
1443 1444
    }
    if (g_Dbs.db[i].dbCfg.maxRows > 0) {
1445 1446
      printf("  maxRows:               \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.maxRows);
1447 1448 1449 1450 1451
    }
    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) {
1452 1453
      printf("  walLevel:              \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.walLevel);
1454 1455
    }
    if (g_Dbs.db[i].dbCfg.fsync > 0) {
1456 1457
      printf("  fsync:                 \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.fsync);
1458 1459
    }
    if (g_Dbs.db[i].dbCfg.quorum > 0) {
1460 1461
      printf("  quorum:                \033[33m%d\033[0m\n",
              g_Dbs.db[i].dbCfg.quorum);
1462 1463
    }
    if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
1464
      if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
1465
              || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
1466
        printf("  precision:             \033[33m%s\033[0m\n",
1467
            g_Dbs.db[i].dbCfg.precision);
1468
      } else {
1469
        printf("\033[1m\033[40;31m  precision error:       %s\033[0m\n",
1470
                g_Dbs.db[i].dbCfg.precision);
1471
        return -1;
1472 1473 1474
      }
    }

1475
    printf("  super table count:     \033[33m%"PRIu64"\033[0m\n",
1476
        g_Dbs.db[i].superTblCount);
1477 1478
    for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
      printf("  super table[\033[33m%"PRIu64"\033[0m]:\n", j);
1479

1480
      printf("      stbName:           \033[33m%s\033[0m\n",
1481
          g_Dbs.db[i].superTbls[j].sTblName);
1482 1483 1484

      if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "no");
1485 1486
      } else if (AUTO_CREATE_SUBTBL ==
              g_Dbs.db[i].superTbls[j].autoCreateTable) {
1487 1488 1489 1490
        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "yes");
      } else {
        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "error");
      }
1491

1492 1493 1494 1495 1496 1497 1498
      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");
      }
1499

1500
      printf("      childTblCount:     \033[33m%"PRId64"\033[0m\n",
1501
              g_Dbs.db[i].superTbls[j].childTblCount);
1502
      printf("      childTblPrefix:    \033[33m%s\033[0m\n",
1503
              g_Dbs.db[i].superTbls[j].childTblPrefix);
1504
      printf("      dataSource:        \033[33m%s\033[0m\n",
1505
              g_Dbs.db[i].superTbls[j].dataSource);
1506 1507 1508
      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");
1509
      if (g_Dbs.db[i].superTbls[j].childTblLimit > 0) {
1510
        printf("      childTblLimit:     \033[33m%"PRId64"\033[0m\n",
1511
                g_Dbs.db[i].superTbls[j].childTblLimit);
1512
      }
1513
      if (g_Dbs.db[i].superTbls[j].childTblOffset > 0) {
1514
        printf("      childTblOffset:    \033[33m%"PRIu64"\033[0m\n",
1515
                g_Dbs.db[i].superTbls[j].childTblOffset);
1516
      }
1517
      printf("      insertRows:        \033[33m%"PRId64"\033[0m\n",
1518
              g_Dbs.db[i].superTbls[j].insertRows);
1519
/*
1520
      if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
1521
        printf("      multiThreadWriteOneTbl:  \033[33mno\033[0m\n");
1522
      }else {
1523
        printf("      multiThreadWriteOneTbl:  \033[33myes\033[0m\n");
1524
      }
1525
      */
1526
      printf("      interlaceRows:     \033[33m%u\033[0m\n",
1527
              g_Dbs.db[i].superTbls[j].interlaceRows);
1528 1529

      if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
1530
        printf("      stable insert interval:   \033[33m%"PRIu64"\033[0m\n",
1531
            g_Dbs.db[i].superTbls[j].insertInterval);
1532 1533
      }

1534
      printf("      disorderRange:     \033[33m%d\033[0m\n",
1535
              g_Dbs.db[i].superTbls[j].disorderRange);
1536
      printf("      disorderRatio:     \033[33m%d\033[0m\n",
1537
              g_Dbs.db[i].superTbls[j].disorderRatio);
1538
      printf("      maxSqlLen:         \033[33m%"PRIu64"\033[0m\n",
1539
              g_Dbs.db[i].superTbls[j].maxSqlLen);
1540
      printf("      timeStampStep:     \033[33m%"PRId64"\033[0m\n",
1541
              g_Dbs.db[i].superTbls[j].timeStampStep);
1542
      printf("      startTimestamp:    \033[33m%s\033[0m\n",
1543
              g_Dbs.db[i].superTbls[j].startTimestamp);
1544
      printf("      sampleFormat:      \033[33m%s\033[0m\n",
1545
              g_Dbs.db[i].superTbls[j].sampleFormat);
1546
      printf("      sampleFile:        \033[33m%s\033[0m\n",
1547
              g_Dbs.db[i].superTbls[j].sampleFile);
1548
      printf("      tagsFile:          \033[33m%s\033[0m\n",
1549
              g_Dbs.db[i].superTbls[j].tagsFile);
1550
      printf("      columnCount:       \033[33m%d\033[0m\n",
1551
              g_Dbs.db[i].superTbls[j].columnCount);
1552 1553
      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);
1554
        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
1555 1556 1557
                       "binary", 6))
                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
                       "nchar", 5))) {
1558
          printf("column[\033[33m%d\033[0m]:\033[33m%s(%d)\033[0m ", k,
1559 1560
                  g_Dbs.db[i].superTbls[j].columns[k].dataType,
                  g_Dbs.db[i].superTbls[j].columns[k].dataLen);
1561
        } else {
1562
          printf("column[%d]:\033[33m%s\033[0m ", k,
1563
                  g_Dbs.db[i].superTbls[j].columns[k].dataType);
1564 1565 1566
        }
      }
      printf("\n");
1567 1568

      printf("      tagCount:            \033[33m%d\033[0m\n        ",
1569
              g_Dbs.db[i].superTbls[j].tagCount);
1570 1571
      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);
1572
        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
1573 1574 1575
                        "binary", strlen("binary")))
                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
                        "nchar", strlen("nchar")))) {
1576
          printf("tag[%d]:\033[33m%s(%d)\033[0m ", k,
1577 1578
                  g_Dbs.db[i].superTbls[j].tags[k].dataType,
                  g_Dbs.db[i].superTbls[j].tags[k].dataLen);
1579
        } else {
1580
          printf("tag[%d]:\033[33m%s\033[0m ", k,
1581
                  g_Dbs.db[i].superTbls[j].tags[k].dataType);
1582
        }
1583 1584 1585 1586 1587
      }
      printf("\n");
    }
    printf("\n");
  }
1588 1589

  SHOW_PARSE_RESULT_END();
1590 1591

  return 0;
1592 1593 1594
}

static void printfInsertMetaToFile(FILE* fp) {
1595 1596

  SHOW_PARSE_RESULT_START_TO_FILE(fp);
1597

1598 1599
  fprintf(fp, "host:                       %s:%u\n", g_Dbs.host, g_Dbs.port);
  fprintf(fp, "user:                       %s\n", g_Dbs.user);
1600
  fprintf(fp, "configDir:                  %s\n", configDir);
1601 1602 1603
  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);
1604
  fprintf(fp, "number of records per req:  %u\n", g_args.num_of_RPR);
1605
  fprintf(fp, "max sql length:             %"PRIu64"\n", g_args.max_sql_len);
1606
  fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
1607

1608 1609
  for (int i = 0; i < g_Dbs.dbCount; i++) {
    fprintf(fp, "database[%d]:\n", i);
1610
    fprintf(fp, "  database[%d] name:       %s\n", i, g_Dbs.db[i].dbName);
1611
    if (0 == g_Dbs.db[i].drop) {
1612
      fprintf(fp, "  drop:                  no\n");
1613
    }else {
1614
      fprintf(fp, "  drop:                  yes\n");
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
    }

    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) {
1654
      if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
1655
              || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
1656 1657
        fprintf(fp, "  precision:             %s\n",
                g_Dbs.db[i].dbCfg.precision);
1658
      } else {
1659 1660
        fprintf(fp, "  precision error:       %s\n",
                g_Dbs.db[i].dbCfg.precision);
1661 1662 1663
      }
    }

1664 1665
    fprintf(fp, "  super table count:     %"PRIu64"\n",
            g_Dbs.db[i].superTblCount);
1666 1667
    for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
      fprintf(fp, "  super table[%d]:\n", j);
1668

1669 1670
      fprintf(fp, "      stbName:           %s\n",
              g_Dbs.db[i].superTbls[j].sTblName);
1671 1672 1673

      if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
        fprintf(fp, "      autoCreateTable:   %s\n",  "no");
1674 1675
      } else if (AUTO_CREATE_SUBTBL
              == g_Dbs.db[i].superTbls[j].autoCreateTable) {
1676 1677 1678 1679
        fprintf(fp, "      autoCreateTable:   %s\n",  "yes");
      } else {
        fprintf(fp, "      autoCreateTable:   %s\n",  "error");
      }
1680

1681 1682
      if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
        fprintf(fp, "      childTblExists:    %s\n",  "no");
1683 1684
      } else if (TBL_ALREADY_EXISTS
              == g_Dbs.db[i].superTbls[j].childTblExists) {
1685 1686 1687 1688
        fprintf(fp, "      childTblExists:    %s\n",  "yes");
      } else {
        fprintf(fp, "      childTblExists:    %s\n",  "error");
      }
1689

1690
      fprintf(fp, "      childTblCount:     %"PRId64"\n",
1691 1692 1693 1694 1695
              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);
1696 1697 1698
      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");
1699
      fprintf(fp, "      insertRows:        %"PRId64"\n",
1700
              g_Dbs.db[i].superTbls[j].insertRows);
1701
      fprintf(fp, "      interlace rows:    %u\n",
1702
              g_Dbs.db[i].superTbls[j].interlaceRows);
1703
      if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
1704
        fprintf(fp, "      stable insert interval:   %"PRIu64"\n",
1705
                g_Dbs.db[i].superTbls[j].insertInterval);
1706
      }
1707
/*
1708
      if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
1709
        fprintf(fp, "      multiThreadWriteOneTbl:  no\n");
1710
      }else {
1711
        fprintf(fp, "      multiThreadWriteOneTbl:  yes\n");
1712
      }
1713
      */
1714
      fprintf(fp, "      interlaceRows:     %u\n",
1715
              g_Dbs.db[i].superTbls[j].interlaceRows);
1716 1717 1718 1719
      fprintf(fp, "      disorderRange:     %d\n",
              g_Dbs.db[i].superTbls[j].disorderRange);
      fprintf(fp, "      disorderRatio:     %d\n",
              g_Dbs.db[i].superTbls[j].disorderRatio);
1720
      fprintf(fp, "      maxSqlLen:         %"PRIu64"\n",
1721
              g_Dbs.db[i].superTbls[j].maxSqlLen);
1722

1723 1724 1725 1726
      fprintf(fp, "      timeStampStep:     %"PRId64"\n",
              g_Dbs.db[i].superTbls[j].timeStampStep);
      fprintf(fp, "      startTimestamp:    %s\n",
              g_Dbs.db[i].superTbls[j].startTimestamp);
1727 1728 1729 1730 1731 1732
      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);
1733

1734 1735
      fprintf(fp, "      columnCount:       %d\n        ",
              g_Dbs.db[i].superTbls[j].columnCount);
1736 1737
      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);
1738
        if ((0 == strncasecmp(
1739 1740
                        g_Dbs.db[i].superTbls[j].columns[k].dataType,
                        "binary", strlen("binary")))
1741 1742
                || (0 == strncasecmp(
                        g_Dbs.db[i].superTbls[j].columns[k].dataType,
1743
                        "nchar", strlen("nchar")))) {
1744 1745 1746
          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);
1747
        } else {
1748 1749
          fprintf(fp, "column[%d]:%s ",
                  k, g_Dbs.db[i].superTbls[j].columns[k].dataType);
1750 1751 1752
        }
      }
      fprintf(fp, "\n");
1753 1754 1755

      fprintf(fp, "      tagCount:            %d\n        ",
              g_Dbs.db[i].superTbls[j].tagCount);
1756 1757
      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);
1758
        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
1759 1760 1761
                        "binary", strlen("binary")))
                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
                        "nchar", strlen("nchar")))) {
1762 1763
          fprintf(fp, "tag[%d]:%s(%d) ",
                  k, g_Dbs.db[i].superTbls[j].tags[k].dataType,
1764
                  g_Dbs.db[i].superTbls[j].tags[k].dataLen);
1765 1766
        } else {
          fprintf(fp, "tag[%d]:%s ", k, g_Dbs.db[i].superTbls[j].tags[k].dataType);
1767
        }
1768 1769 1770 1771 1772
      }
      fprintf(fp, "\n");
    }
    fprintf(fp, "\n");
  }
1773

1774
  SHOW_PARSE_RESULT_END_TO_FILE(fp);
1775 1776 1777
}

static void printfQueryMeta() {
1778

1779
  SHOW_PARSE_RESULT_START();
1780

1781
  printf("host:                    \033[33m%s:%u\033[0m\n",
1782
          g_queryInfo.host, g_queryInfo.port);
1783 1784 1785 1786
  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");
1787 1788 1789

  if ((SUBSCRIBE_TEST == g_args.test_mode) || (QUERY_TEST == g_args.test_mode)) {
    printf("specified table query info:                   \n");
1790
    printf("sqlCount:       \033[33m%d\033[0m\n",
1791
      g_queryInfo.specifiedQueryInfo.sqlCount);
1792 1793 1794
    if (g_queryInfo.specifiedQueryInfo.sqlCount > 0) {
      printf("specified tbl query times:\n");
      printf("                \033[33m%"PRIu64"\033[0m\n",
1795
      g_queryInfo.specifiedQueryInfo.queryTimes);
1796 1797 1798
      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);
1799
      printf("concurrent:     \033[33m%d\033[0m\n",
1800 1801
      g_queryInfo.specifiedQueryInfo.concurrent);
      printf("mod:            \033[33m%s\033[0m\n",
1802
        (g_queryInfo.specifiedQueryInfo.asyncMode)?"async":"sync");
1803
      printf("interval:       \033[33m%"PRIu64"\033[0m\n",
1804
        g_queryInfo.specifiedQueryInfo.subscribeInterval);
1805
      printf("restart:        \033[33m%d\033[0m\n",
1806
        g_queryInfo.specifiedQueryInfo.subscribeRestart);
1807
      printf("keepProgress:   \033[33m%d\033[0m\n",
1808
        g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
1809

1810 1811
      for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
        printf("  sql[%d]: \033[33m%s\033[0m\n",
1812 1813 1814 1815 1816 1817
            i, g_queryInfo.specifiedQueryInfo.sql[i]);
      }
      printf("\n");
    }

    printf("super table query info:\n");
1818
    printf("sqlCount:       \033[33m%d\033[0m\n",
1819 1820 1821 1822 1823 1824 1825
      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);
1826
      printf("childTblCount:  \033[33m%"PRId64"\033[0m\n",
1827 1828 1829 1830 1831 1832 1833
        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",
1834
        (g_queryInfo.superQueryInfo.asyncMode)?"async":"sync");
1835
      printf("interval:       \033[33m%"PRIu64"\033[0m\n",
1836
        g_queryInfo.superQueryInfo.subscribeInterval);
1837
      printf("restart:        \033[33m%d\033[0m\n",
1838
        g_queryInfo.superQueryInfo.subscribeRestart);
1839
      printf("keepProgress:   \033[33m%d\033[0m\n",
1840
        g_queryInfo.superQueryInfo.subscribeKeepProgress);
1841

1842 1843 1844 1845 1846 1847
      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");
    }
1848
  }
1849

1850
  SHOW_PARSE_RESULT_END();
1851 1852
}

1853
static char* formatTimestamp(char* buf, int64_t val, int precision) {
1854
  time_t tt;
1855 1856 1857
  if (precision == TSDB_TIME_PRECISION_NANO) {
    tt = (time_t)(val / 1000000000);
  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
    tt = (time_t)(val / 1000000);
  } else {
    tt = (time_t)(val / 1000);
  }

/* comment out as it make testcases like select_with_tags.sim fail.
  but in windows, this may cause the call to localtime crash if tt < 0,
  need to find a better solution.
  if (tt < 0) {
    tt = 0;
  }
  */

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

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

1878 1879 1880
  if (precision == TSDB_TIME_PRECISION_NANO) {
    sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
1881 1882 1883 1884 1885 1886 1887 1888
    sprintf(buf + pos, ".%06d", (int)(val % 1000000));
  } else {
    sprintf(buf + pos, ".%03d", (int)(val % 1000));
  }

  return buf;
}

1889
static void xDumpFieldToFile(FILE* fp, const char* val,
1890
        TAOS_FIELD* field, int32_t length, int precision) {
1891

1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
  if (val == NULL) {
    fprintf(fp, "%s", TSDB_DATA_NULL_STR);
    return;
  }

  char buf[TSDB_MAX_BYTES_PER_ROW];
  switch (field->type) {
    case TSDB_DATA_TYPE_BOOL:
      fprintf(fp, "%d", ((((int32_t)(*((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:
1927
      formatTimestamp(buf, *(int64_t*)val, precision);
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
      fprintf(fp, "'%s'", buf);
      break;
    default:
      break;
  }
}

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

  FILE* fp = fopen(fname, "at");
  if (fp == NULL) {
1943
    errorPrint("%s() LN%d, failed to open file: %s\n", __func__, __LINE__, fname);
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
    return -1;
  }

  int num_fields = taos_num_fields(tres);
  TAOS_FIELD *fields = taos_fetch_fields(tres);
  int precision = taos_result_precision(tres);

  for (int col = 0; col < num_fields; col++) {
    if (col > 0) {
      fprintf(fp, ",");
    }
    fprintf(fp, "%s", fields[col].name);
  }
  fputc('\n', fp);
1958

1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
  int numOfRows = 0;
  do {
    int32_t* length = taos_fetch_lengths(tres);
    for (int i = 0; i < num_fields; i++) {
      if (i > 0) {
        fputc(',', fp);
      }
      xDumpFieldToFile(fp, (const char*)row[i], fields +i, length[i], precision);
    }
    fputc('\n', fp);

    numOfRows++;
    row = taos_fetch_row(tres);
  } while( row != NULL);

  fclose(fp);

  return numOfRows;
}

1979 1980
static int getDbFromServer(TAOS * taos, SDbInfo** dbInfos) {
  TAOS_RES * res;
1981 1982
  TAOS_ROW row = NULL;
  int count = 0;
1983 1984

  res = taos_query(taos, "show databases;");
1985
  int32_t code = taos_errno(res);
1986

1987
  if (code != 0) {
1988
    errorPrint( "failed to run <show databases>, reason: %s\n", taos_errstr(res));
1989 1990 1991 1992 1993
    return -1;
  }

  TAOS_FIELD *fields = taos_fetch_fields(res);

1994
  while((row = taos_fetch_row(res)) != NULL) {
1995
    // sys database name : 'log'
1996
    if (strncasecmp(row[TSDB_SHOW_DB_NAME_INDEX], "log",
1997
                fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0) {
1998 1999
      continue;
    }
2000 2001 2002

    dbInfos[count] = (SDbInfo *)calloc(1, sizeof(SDbInfo));
    if (dbInfos[count] == NULL) {
2003
      errorPrint( "failed to allocate memory for some dbInfo[%d]\n", count);
2004 2005 2006
      return -1;
    }

2007
    tstrncpy(dbInfos[count]->name, (char *)row[TSDB_SHOW_DB_NAME_INDEX],
2008
            fields[TSDB_SHOW_DB_NAME_INDEX].bytes);
2009
    formatTimestamp(dbInfos[count]->create_time,
2010 2011
            *(int64_t*)row[TSDB_SHOW_DB_CREATED_TIME_INDEX],
            TSDB_TIME_PRECISION_MILLI);
S
Shuduo Sang 已提交
2012
    dbInfos[count]->ntables = *((int64_t *)row[TSDB_SHOW_DB_NTABLES_INDEX]);
2013
    dbInfos[count]->vgroups = *((int32_t *)row[TSDB_SHOW_DB_VGROUPS_INDEX]);
2014 2015
    dbInfos[count]->replica = *((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]);
    dbInfos[count]->quorum = *((int16_t *)row[TSDB_SHOW_DB_QUORUM_INDEX]);
2016
    dbInfos[count]->days = *((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]);
2017

2018
    tstrncpy(dbInfos[count]->keeplist, (char *)row[TSDB_SHOW_DB_KEEP_INDEX],
2019
            fields[TSDB_SHOW_DB_KEEP_INDEX].bytes);
2020 2021 2022 2023 2024 2025 2026
    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]));
2027
    dbInfos[count]->cachelast =
2028
      (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_CACHELAST_INDEX]));
2029

2030
    tstrncpy(dbInfos[count]->precision,
2031 2032
            (char *)row[TSDB_SHOW_DB_PRECISION_INDEX],
            fields[TSDB_SHOW_DB_PRECISION_INDEX].bytes);
2033
    dbInfos[count]->update = *((int8_t *)row[TSDB_SHOW_DB_UPDATE_INDEX]);
2034
    tstrncpy(dbInfos[count]->status, (char *)row[TSDB_SHOW_DB_STATUS_INDEX],
2035
            fields[TSDB_SHOW_DB_STATUS_INDEX].bytes);
2036

2037 2038
    count++;
    if (count > MAX_DATABASE_COUNT) {
2039
      errorPrint("%s() LN%d, The database count overflow than %d\n",
2040
         __func__, __LINE__, MAX_DATABASE_COUNT);
2041 2042 2043 2044 2045 2046 2047
      break;
    }
  }

  return count;
}

2048
static void printfDbInfoForQueryToFile(
2049
        char* filename, SDbInfo* dbInfos, int index) {
2050

2051
  if (filename[0] == 0)
2052
      return;
2053 2054 2055

  FILE *fp = fopen(filename, "at");
  if (fp == NULL) {
2056
    errorPrint( "failed to open file: %s\n", filename);
2057
    return;
2058 2059 2060 2061 2062
  }

  fprintf(fp, "================ database[%d] ================\n", index);
  fprintf(fp, "name: %s\n", dbInfos->name);
  fprintf(fp, "created_time: %s\n", dbInfos->create_time);
S
Shuduo Sang 已提交
2063
  fprintf(fp, "ntables: %"PRId64"\n", dbInfos->ntables);
2064
  fprintf(fp, "vgroups: %d\n", dbInfos->vgroups);
2065 2066
  fprintf(fp, "replica: %d\n", dbInfos->replica);
  fprintf(fp, "quorum: %d\n", dbInfos->quorum);
2067 2068
  fprintf(fp, "days: %d\n", dbInfos->days);
  fprintf(fp, "keep0,keep1,keep(D): %s\n", dbInfos->keeplist);
2069 2070 2071 2072 2073 2074 2075
  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);
2076 2077
  fprintf(fp, "cachelast: %d\n", dbInfos->cachelast);
  fprintf(fp, "precision: %s\n", dbInfos->precision);
2078
  fprintf(fp, "update: %d\n", dbInfos->update);
2079
  fprintf(fp, "status: %s\n", dbInfos->status);
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
  fprintf(fp, "\n");

  fclose(fp);
}

static void printfQuerySystemInfo(TAOS * taos) {
  char filename[MAX_QUERY_SQL_LENGTH+1] = {0};
  char buffer[MAX_QUERY_SQL_LENGTH+1] = {0};
  TAOS_RES* res;

  time_t t;
  struct tm* lt;
  time(&t);
  lt = localtime(&t);
2094
  snprintf(filename, MAX_QUERY_SQL_LENGTH, "querySystemInfo-%d-%d-%d %d:%d:%d",
2095 2096
          lt->tm_year+1900, lt->tm_mon, lt->tm_mday, lt->tm_hour, lt->tm_min,
          lt->tm_sec);
2097

2098 2099
  // show variables
  res = taos_query(taos, "show variables;");
2100
  //fetchResult(res, filename);
2101 2102 2103 2104 2105
  xDumpResultToFile(filename, res);

  // show dnodes
  res = taos_query(taos, "show dnodes;");
  xDumpResultToFile(filename, res);
2106
  //fetchResult(res, filename);
2107

2108 2109 2110 2111
  // show databases
  res = taos_query(taos, "show databases;");
  SDbInfo** dbInfos = (SDbInfo **)calloc(MAX_DATABASE_COUNT, sizeof(SDbInfo *));
  if (dbInfos == NULL) {
2112
    errorPrint("%s() LN%d, failed to allocate memory\n", __func__, __LINE__);
2113 2114 2115
    return;
  }
  int dbCount = getDbFromServer(taos, dbInfos);
2116
  if (dbCount <= 0) {
2117 2118
      free(dbInfos);
      return;
2119
  }
2120 2121

  for (int i = 0; i < dbCount; i++) {
2122
    // printf database info
2123
    printfDbInfoForQueryToFile(filename, dbInfos[i], i);
2124

2125 2126 2127 2128
    // show db.vgroups
    snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.vgroups;", dbInfos[i]->name);
    res = taos_query(taos, buffer);
    xDumpResultToFile(filename, res);
2129

2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
    // show db.stables
    snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.stables;", dbInfos[i]->name);
    res = taos_query(taos, buffer);
    xDumpResultToFile(filename, res);

    free(dbInfos[i]);
  }

  free(dbInfos);
}

2141
static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port,
2142
        char* sqlstr, threadInfo *pThreadInfo)
2143
{
2144
    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";
2145

2146
    char *url = "/rest/sql";
2147

2148 2149 2150 2151
    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;
2152

2153
    int req_buf_len = strlen(sqlstr) + REQ_EXTRA_BUF_LEN;
2154

2155 2156 2157 2158 2159
    request_buf = malloc(req_buf_len);
    if (NULL == request_buf) {
      errorPrint("%s", "ERROR, cannot allocate memory.\n");
      exit(EXIT_FAILURE);
    }
2160

2161 2162
    char userpass_buf[INPUT_BUF_LEN];
    int mod_table[] = {0, 2, 1};
2163

2164 2165 2166 2167 2168 2169 2170 2171
    static char base64[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
      'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
      'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
      'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
      'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
      'w', 'x', 'y', 'z', '0', '1', '2', '3',
      '4', '5', '6', '7', '8', '9', '+', '/'};
2172

2173 2174 2175 2176
    snprintf(userpass_buf, INPUT_BUF_LEN, "%s:%s",
        g_Dbs.user, g_Dbs.password);
    size_t userpass_buf_len = strlen(userpass_buf);
    size_t encoded_len = 4 * ((userpass_buf_len +2) / 3);
2177

2178
    char base64_buf[INPUT_BUF_LEN];
2179
#ifdef WINDOWS
2180
    WSADATA wsaData;
2181
    WSAStartup(MAKEWORD(2, 2), &wsaData);
2182 2183
    SOCKET sockfd;
#else
2184
    int sockfd;
2185
#endif
2186 2187
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
2188
#ifdef WINDOWS
2189
        errorPrint( "Could not create socket : %d" , WSAGetLastError());
2190
#endif
2191 2192 2193 2194
        debugPrint("%s() LN%d, sockfd=%d\n", __func__, __LINE__, sockfd);
        free(request_buf);
        ERROR_EXIT("ERROR opening socket");
    }
2195

2196
    int retConn = connect(sockfd, (struct sockaddr *)pServAddr, sizeof(struct sockaddr));
2197 2198 2199 2200 2201
    debugPrint("%s() LN%d connect() return %d\n", __func__, __LINE__, retConn);
    if (retConn < 0) {
        free(request_buf);
        ERROR_EXIT("ERROR connecting");
    }
2202

2203
    memset(base64_buf, 0, INPUT_BUF_LEN);
2204

2205 2206 2207 2208 2209 2210 2211 2212
    for (int n = 0, m = 0; n < userpass_buf_len;) {
      uint32_t oct_a = n < userpass_buf_len ?
        (unsigned char) userpass_buf[n++]:0;
      uint32_t oct_b = n < userpass_buf_len ?
        (unsigned char) userpass_buf[n++]:0;
      uint32_t oct_c = n < userpass_buf_len ?
        (unsigned char) userpass_buf[n++]:0;
      uint32_t triple = (oct_a << 0x10) + (oct_b << 0x08) + oct_c;
2213

2214 2215 2216 2217 2218
      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];
    }
2219

2220 2221
    for (int l = 0; l < mod_table[userpass_buf_len % 3]; l++)
      base64_buf[encoded_len - 1 - l] = '=';
2222

2223 2224 2225
    debugPrint("%s() LN%d: auth string base64 encoded: %s\n",
            __func__, __LINE__, base64_buf);
    char *auth = base64_buf;
2226

2227 2228 2229 2230 2231 2232 2233 2234 2235
    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);
2236

2237 2238 2239
    req_str_len = strlen(request_buf);
    sent = 0;
    do {
2240
#ifdef WINDOWS
2241
        bytes = send(sockfd, request_buf + sent, req_str_len - sent, 0);
2242
#else
2243
        bytes = write(sockfd, request_buf + sent, req_str_len - sent);
2244
#endif
2245 2246 2247 2248 2249 2250
        if (bytes < 0)
            ERROR_EXIT("ERROR writing message to socket");
        if (bytes == 0)
            break;
        sent+=bytes;
    } while(sent < req_str_len);
2251

2252 2253 2254 2255
    memset(response_buf, 0, RESP_BUF_LEN);
    resp_len = sizeof(response_buf) - 1;
    received = 0;
    do {
2256
#ifdef WINDOWS
2257
        bytes = recv(sockfd, response_buf + received, resp_len - received, 0);
2258
#else
2259
        bytes = read(sockfd, response_buf + received, resp_len - received);
2260
#endif
2261 2262 2263 2264 2265 2266 2267 2268
        if (bytes < 0) {
            free(request_buf);
            ERROR_EXIT("ERROR reading response from socket");
        }
        if (bytes == 0)
            break;
        received += bytes;
    } while(received < resp_len);
2269

2270 2271 2272 2273
    if (received == resp_len) {
        free(request_buf);
        ERROR_EXIT("ERROR storing complete response from socket");
    }
H
Haojun Liao 已提交
2274

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

2278 2279
    if (strlen(pThreadInfo->filePath) > 0) {
       appendResultBufToFile(response_buf, pThreadInfo);
2280 2281
    }

2282
    free(request_buf);
2283
#ifdef WINDOWS
2284
    closesocket(sockfd);
2285 2286
    WSACleanup();
#else
2287
    close(sockfd);
2288
#endif
2289

2290
    return 0;
2291 2292
}

2293
static char* getTagValueFromTagSample(SSuperTable* stbInfo, int tagUsePos) {
2294 2295
  char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
  if (NULL == dataBuf) {
2296
    errorPrint("%s() LN%d, calloc failed! size:%d\n",
2297
        __func__, __LINE__, TSDB_MAX_SQL_LEN+1);
2298 2299
    return NULL;
  }
2300

2301
  int    dataLen = 0;
2302
  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2303
          "(%s)", stbInfo->tagDataBuf + stbInfo->lenOfTagOfOneRow * tagUsePos);
2304

2305 2306 2307
  return dataBuf;
}

2308
static char* generateTagVaulesForStb(SSuperTable* stbInfo, int32_t tableSeq) {
2309 2310 2311 2312 2313 2314 2315 2316 2317
  char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
  if (NULL == dataBuf) {
    printf("calloc failed! size:%d\n", TSDB_MAX_SQL_LEN+1);
    return NULL;
  }

  int    dataLen = 0;
  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, "(");
  for (int i = 0; i < stbInfo->tagCount; i++) {
2318
    if ((0 == strncasecmp(stbInfo->tags[i].dataType, "binary", strlen("binary")))
2319
            || (0 == strncasecmp(stbInfo->tags[i].dataType, "nchar", strlen("nchar")))) {
2320
      if (stbInfo->tags[i].dataLen > TSDB_MAX_BINARY_LEN) {
2321
        printf("binary or nchar length overflow, max size:%u\n",
2322
                (uint32_t)TSDB_MAX_BINARY_LEN);
2323 2324 2325
        tmfree(dataBuf);
        return NULL;
      }
2326

2327 2328
      int tagBufLen = stbInfo->tags[i].dataLen + 1;
      char* buf = (char*)calloc(tagBufLen, 1);
2329 2330 2331 2332 2333
      if (NULL == buf) {
        printf("calloc failed! size:%d\n", stbInfo->tags[i].dataLen);
        tmfree(dataBuf);
        return NULL;
      }
2334 2335 2336 2337 2338 2339 2340

      if (tableSeq % 2) {
        tstrncpy(buf, "beijing", tagBufLen);
      } else {
        tstrncpy(buf, "shanghai", tagBufLen);
      }
      //rand_string(buf, stbInfo->tags[i].dataLen);
2341
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2342
              "\'%s\', ", buf);
2343
      tmfree(buf);
2344
    } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2345
                "int", strlen("int"))) {
2346
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2347
              "%d, ", tableSeq);
2348
    } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2349
                "bigint", strlen("bigint"))) {
2350
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2351
              "%"PRId64", ", rand_bigint());
2352
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2353
                "float", strlen("float"))) {
2354
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2355
              "%f, ", rand_float());
2356
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2357
                "double", strlen("double"))) {
2358
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2359
              "%f, ", rand_double());
2360
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2361
                "smallint", strlen("smallint"))) {
2362
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2363
              "%d, ", rand_smallint());
2364
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2365
                "tinyint", strlen("tinyint"))) {
2366
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2367
              "%d, ", rand_tinyint());
2368
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2369
                "bool", strlen("bool"))) {
2370
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2371
              "%d, ", rand_bool());
2372
    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
2373
                "timestamp", strlen("timestamp"))) {
2374
      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
2375
              "%"PRId64", ", rand_bigint());
2376 2377 2378 2379 2380 2381
    }  else {
      printf("No support data type: %s\n", stbInfo->tags[i].dataType);
      tmfree(dataBuf);
      return NULL;
    }
  }
2382

2383
  dataLen -= 2;
2384
  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, ")");
2385 2386 2387
  return dataBuf;
}

2388
static int calcRowLen(SSuperTable*  superTbls) {
2389 2390
  int colIndex;
  int  lenOfOneRow = 0;
2391

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

2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
    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)  {
      lenOfOneRow += 11;
    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
      lenOfOneRow += 21;
    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
      lenOfOneRow += 6;
    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
      lenOfOneRow += 4;
    } else if (strcasecmp(dataType, "BOOL") == 0)  {
      lenOfOneRow += 6;
    } else if (strcasecmp(dataType, "FLOAT") == 0) {
      lenOfOneRow += 22;
2411
    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2412
      lenOfOneRow += 42;
2413
    }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
      lenOfOneRow += 21;
    } 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;
2427

2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
    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)  {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 11;
    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 21;
    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 6;
    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 4;
    } else if (strcasecmp(dataType, "BOOL") == 0)  {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 6;
    } else if (strcasecmp(dataType, "FLOAT") == 0) {
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 22;
2444
    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2445 2446 2447 2448 2449 2450 2451 2452
      lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + 42;
    } else {
      printf("get error tag type : %s\n", dataType);
      exit(-1);
    }
  }

  superTbls->lenOfTagOfOneRow = lenOfTagOfOneRow;
2453

2454 2455 2456 2457
  return 0;
}


2458
static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
2459
        char* dbName, char* sTblName, char** childTblNameOfSuperTbl,
2460
        int64_t* childTblCountOfSuperTbl, int64_t limit, uint64_t offset) {
2461

2462
  char command[BUFFER_SIZE] = "\0";
2463 2464
  char limitBuf[100] = "\0";

2465
  TAOS_RES * res;
2466 2467 2468
  TAOS_ROW row = NULL;

  char* childTblName = *childTblNameOfSuperTbl;
2469 2470

  if (offset >= 0) {
2471
    snprintf(limitBuf, 100, " limit %"PRId64" offset %"PRIu64"",
2472
            limit, offset);
2473 2474
  }

2475
  //get all child table name use cmd: select tbname from superTblName;
2476
  snprintf(command, BUFFER_SIZE, "select tbname from %s.%s %s",
2477
          dbName, sTblName, limitBuf);
2478

2479
  res = taos_query(taos, command);
2480 2481 2482 2483
  int32_t code = taos_errno(res);
  if (code != 0) {
    taos_free_result(res);
    taos_close(taos);
2484
    errorPrint("%s() LN%d, failed to run command %s\n",
2485
           __func__, __LINE__, command);
2486 2487 2488
    exit(-1);
  }

2489 2490
  int64_t childTblCount = (limit < 0)?10000:limit;
  int64_t count = 0;
2491 2492 2493
  if (childTblName == NULL) {
    childTblName = (char*)calloc(1, childTblCount * TSDB_TABLE_NAME_LEN);
    if (NULL ==  childTblName) {
2494 2495 2496 2497
    taos_free_result(res);
        taos_close(taos);
        errorPrint("%s() LN%d, failed to allocate memory!\n", __func__, __LINE__);
        exit(-1);
2498 2499 2500
    }
  }

2501
  char* pTblName = childTblName;
2502
  while((row = taos_fetch_row(res)) != NULL) {
2503
    int32_t* len = taos_fetch_lengths(res);
2504
    tstrncpy(pTblName, (char *)row[0], len[0]+1);
2505 2506 2507
    //printf("==== sub table name: %s\n", pTblName);
    count++;
    if (count >= childTblCount - 1) {
2508
      char *tmp = realloc(childTblName,
2509
              (size_t)childTblCount*1.5*TSDB_TABLE_NAME_LEN+1);
2510 2511 2512
      if (tmp != NULL) {
        childTblName = tmp;
        childTblCount = (int)(childTblCount*1.5);
2513
        memset(childTblName + count*TSDB_TABLE_NAME_LEN, 0,
2514
                (size_t)((childTblCount-count)*TSDB_TABLE_NAME_LEN));
2515 2516
      } else {
        // exit, if allocate more memory failed
2517
        errorPrint("%s() LN%d, realloc fail for save child table name of %s.%s\n",
2518
               __func__, __LINE__, dbName, sTblName);
2519 2520 2521 2522 2523 2524
        tmfree(childTblName);
        taos_free_result(res);
        taos_close(taos);
        exit(-1);
      }
    }
2525
    pTblName = childTblName + count * TSDB_TABLE_NAME_LEN;
2526
  }
2527

2528 2529 2530 2531 2532 2533 2534
  *childTblCountOfSuperTbl = count;
  *childTblNameOfSuperTbl  = childTblName;

  taos_free_result(res);
  return 0;
}

2535
static int getAllChildNameOfSuperTable(TAOS * taos, char* dbName,
2536
        char* sTblName, char** childTblNameOfSuperTbl,
2537
        int64_t* childTblCountOfSuperTbl) {
2538

2539 2540
    return getChildNameOfSuperTableWithLimitAndOffset(taos, dbName, sTblName,
            childTblNameOfSuperTbl, childTblCountOfSuperTbl,
2541
            -1, 0);
2542 2543
}

2544
static int getSuperTableFromServer(TAOS * taos, char* dbName,
2545
        SSuperTable*  superTbls) {
2546

2547
  char command[BUFFER_SIZE] = "\0";
2548
  TAOS_RES * res;
2549 2550
  TAOS_ROW row = NULL;
  int count = 0;
2551

2552
  //get schema use cmd: describe superTblName;
2553
  snprintf(command, BUFFER_SIZE, "describe %s.%s", dbName, superTbls->sTblName);
2554
  res = taos_query(taos, command);
2555 2556 2557
  int32_t code = taos_errno(res);
  if (code != 0) {
    printf("failed to run command %s\n", command);
2558
    taos_free_result(res);
2559 2560 2561 2562 2563 2564
    return -1;
  }

  int tagIndex = 0;
  int columnIndex = 0;
  TAOS_FIELD *fields = taos_fetch_fields(res);
2565
  while((row = taos_fetch_row(res)) != NULL) {
2566 2567 2568
    if (0 == count) {
      count++;
      continue;
2569
    }
2570 2571

    if (strcmp((char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX], "TAG") == 0) {
2572
      tstrncpy(superTbls->tags[tagIndex].field,
2573 2574
              (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
              fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
2575
      tstrncpy(superTbls->tags[tagIndex].dataType,
2576 2577
              (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
              fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes);
2578 2579 2580
      superTbls->tags[tagIndex].dataLen =
          *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
      tstrncpy(superTbls->tags[tagIndex].note,
2581 2582
              (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
              fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes);
2583
      tagIndex++;
2584
    } else {
2585
      tstrncpy(superTbls->columns[columnIndex].field,
2586 2587
              (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
              fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
2588
      tstrncpy(superTbls->columns[columnIndex].dataType,
2589 2590
              (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
              fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes);
2591 2592 2593
      superTbls->columns[columnIndex].dataLen =
          *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
      tstrncpy(superTbls->columns[columnIndex].note,
2594 2595
              (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
              fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes);
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606
      columnIndex++;
    }
    count++;
  }

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

  calcRowLen(superTbls);

2607
/*
2608
  if (TBL_ALREADY_EXISTS == superTbls->childTblExists) {
2609
    //get all child table name use cmd: select tbname from superTblName;
2610 2611 2612
    int childTblCount = 10000;
    superTbls->childTblName = (char*)calloc(1, childTblCount * TSDB_TABLE_NAME_LEN);
    if (superTbls->childTblName == NULL) {
2613
      errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
2614 2615
      return -1;
    }
2616
    getAllChildNameOfSuperTable(taos, dbName,
2617 2618 2619
            superTbls->sTblName,
            &superTbls->childTblName,
            &superTbls->childTblCount);
2620
  }
2621
  */
2622 2623 2624
  return 0;
}

H
Haojun Liao 已提交
2625
static int createSuperTable(
2626 2627
        TAOS * taos, char* dbName,
        SSuperTable*  superTbl) {
H
Haojun Liao 已提交
2628

2629
  char command[BUFFER_SIZE] = "\0";
2630

2631 2632 2633 2634 2635
  char cols[STRING_LEN] = "\0";
  int colIndex;
  int len = 0;

  int  lenOfOneRow = 0;
2636 2637 2638

  if (superTbl->columnCount == 0) {
    errorPrint("%s() LN%d, super table column count is %d\n",
2639
            __func__, __LINE__, superTbl->columnCount);
2640 2641 2642 2643 2644
    return -1;
  }

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

2646
    if (strcasecmp(dataType, "BINARY") == 0) {
2647
      len += snprintf(cols + len, STRING_LEN - len,
2648 2649
          ", col%d %s(%d)", colIndex, "BINARY",
          superTbl->columns[colIndex].dataLen);
2650
      lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
2651
    } else if (strcasecmp(dataType, "NCHAR") == 0) {
2652
      len += snprintf(cols + len, STRING_LEN - len,
2653 2654
          ", col%d %s(%d)", colIndex, "NCHAR",
          superTbl->columns[colIndex].dataLen);
2655
      lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673
    } else if (strcasecmp(dataType, "INT") == 0)  {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "INT");
      lenOfOneRow += 11;
    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "BIGINT");
      lenOfOneRow += 21;
    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "SMALLINT");
      lenOfOneRow += 6;
    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "TINYINT");
      lenOfOneRow += 4;
    } else if (strcasecmp(dataType, "BOOL") == 0)  {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "BOOL");
      lenOfOneRow += 6;
    } else if (strcasecmp(dataType, "FLOAT") == 0) {
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "FLOAT");
      lenOfOneRow += 22;
2674
    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
2675 2676
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "DOUBLE");
      lenOfOneRow += 42;
2677
    }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
2678 2679 2680 2681
      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "TIMESTAMP");
      lenOfOneRow += 21;
    } else {
      taos_close(taos);
2682
      errorPrint("%s() LN%d, config error data type : %s\n",
2683
         __func__, __LINE__, dataType);
2684 2685 2686 2687
      exit(-1);
    }
  }

2688 2689
  superTbl->lenOfOneRow = lenOfOneRow + 20; // timestamp
  //printf("%s.%s column count:%d, column length:%d\n\n", g_Dbs.db[i].dbName, g_Dbs.db[i].superTbl[j].sTblName, g_Dbs.db[i].superTbl[j].columnCount, lenOfOneRow);
2690 2691

  // save for creating child table
2692 2693 2694
  superTbl->colsOfCreateChildTable = (char*)calloc(len+20, 1);
  if (NULL == superTbl->colsOfCreateChildTable) {
    errorPrint("%s() LN%d, Failed when calloc, size:%d",
2695
           __func__, __LINE__, len+1);
2696 2697 2698 2699
    taos_close(taos);
    exit(-1);
  }

2700
  snprintf(superTbl->colsOfCreateChildTable, len+20, "(ts timestamp%s)", cols);
2701
  verbosePrint("%s() LN%d: %s\n",
2702
      __func__, __LINE__, superTbl->colsOfCreateChildTable);
2703

2704 2705
  if (superTbl->tagCount == 0) {
    errorPrint("%s() LN%d, super table tag count is %d\n",
2706
            __func__, __LINE__, superTbl->tagCount);
2707 2708
    return -1;
  }
2709

2710 2711 2712
  char tags[STRING_LEN] = "\0";
  int tagIndex;
  len = 0;
2713

2714 2715 2716 2717
  int lenOfTagOfOneRow = 0;
  len += snprintf(tags + len, STRING_LEN - len, "(");
  for (tagIndex = 0; tagIndex < superTbl->tagCount; tagIndex++) {
    char* dataType = superTbl->tags[tagIndex].dataType;
2718

2719 2720
    if (strcasecmp(dataType, "BINARY") == 0) {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
2721
              "BINARY", superTbl->tags[tagIndex].dataLen);
2722 2723 2724
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
    } else if (strcasecmp(dataType, "NCHAR") == 0) {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
2725
              "NCHAR", superTbl->tags[tagIndex].dataLen);
2726 2727 2728
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
    } else if (strcasecmp(dataType, "INT") == 0)  {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2729
              "INT");
2730 2731 2732
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 11;
    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2733
              "BIGINT");
2734 2735 2736
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 21;
    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2737
              "SMALLINT");
2738 2739 2740
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2741
              "TINYINT");
2742 2743 2744
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 4;
    } else if (strcasecmp(dataType, "BOOL") == 0)  {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2745
              "BOOL");
2746 2747 2748
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
    } else if (strcasecmp(dataType, "FLOAT") == 0) {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2749
              "FLOAT");
2750 2751 2752
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 22;
    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
2753
              "DOUBLE");
2754 2755 2756
      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 42;
    } else {
      taos_close(taos);
2757
      errorPrint("%s() LN%d, config error tag type : %s\n",
2758
         __func__, __LINE__, dataType);
2759
      exit(-1);
2760 2761
    }
  }
2762 2763 2764 2765 2766 2767 2768

  len -= 2;
  len += snprintf(tags + len, STRING_LEN - len, ")");

  superTbl->lenOfTagOfOneRow = lenOfTagOfOneRow;

  snprintf(command, BUFFER_SIZE,
2769 2770
          "create table if not exists %s.%s (ts timestamp%s) tags %s",
          dbName, superTbl->sTblName, cols, tags);
2771
  if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
2772 2773 2774
      errorPrint( "create supertable %s failed!\n\n",
              superTbl->sTblName);
      return -1;
2775 2776
  }
  debugPrint("create supertable %s success!\n\n", superTbl->sTblName);
2777 2778 2779
  return 0;
}

2780
static int createDatabasesAndStables() {
2781 2782 2783 2784
  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) {
2785
    errorPrint( "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
2786
    return -1;
2787 2788 2789
  }
  char command[BUFFER_SIZE] = "\0";

2790
  for (int i = 0; i < g_Dbs.dbCount; i++) {
2791 2792
    if (g_Dbs.db[i].drop) {
      sprintf(command, "drop database if exists %s;", g_Dbs.db[i].dbName);
2793
      if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
2794 2795 2796 2797
        taos_close(taos);
        return -1;
      }

2798
      int dataLen = 0;
2799
      dataLen += snprintf(command + dataLen,
2800
          BUFFER_SIZE - dataLen, "create database if not exists %s", g_Dbs.db[i].dbName);
2801

2802 2803
      if (g_Dbs.db[i].dbCfg.blocks > 0) {
        dataLen += snprintf(command + dataLen,
2804
            BUFFER_SIZE - dataLen, " blocks %d", g_Dbs.db[i].dbCfg.blocks);
2805 2806 2807
      }
      if (g_Dbs.db[i].dbCfg.cache > 0) {
        dataLen += snprintf(command + dataLen,
2808
            BUFFER_SIZE - dataLen, " cache %d", g_Dbs.db[i].dbCfg.cache);
2809 2810 2811
      }
      if (g_Dbs.db[i].dbCfg.days > 0) {
        dataLen += snprintf(command + dataLen,
2812
            BUFFER_SIZE - dataLen, " days %d", g_Dbs.db[i].dbCfg.days);
2813 2814 2815
      }
      if (g_Dbs.db[i].dbCfg.keep > 0) {
        dataLen += snprintf(command + dataLen,
2816
            BUFFER_SIZE - dataLen, " keep %d", g_Dbs.db[i].dbCfg.keep);
2817 2818 2819
      }
      if (g_Dbs.db[i].dbCfg.quorum > 1) {
        dataLen += snprintf(command + dataLen,
2820
            BUFFER_SIZE - dataLen, " quorum %d", g_Dbs.db[i].dbCfg.quorum);
2821 2822 2823
      }
      if (g_Dbs.db[i].dbCfg.replica > 0) {
        dataLen += snprintf(command + dataLen,
2824
            BUFFER_SIZE - dataLen, " replica %d", g_Dbs.db[i].dbCfg.replica);
2825 2826 2827
      }
      if (g_Dbs.db[i].dbCfg.update > 0) {
        dataLen += snprintf(command + dataLen,
2828
            BUFFER_SIZE - dataLen, " update %d", g_Dbs.db[i].dbCfg.update);
2829 2830 2831 2832 2833 2834 2835
      }
      //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,
2836
            BUFFER_SIZE - dataLen, " minrows %d", g_Dbs.db[i].dbCfg.minRows);
2837 2838 2839
      }
      if (g_Dbs.db[i].dbCfg.maxRows > 0) {
        dataLen += snprintf(command + dataLen,
2840
            BUFFER_SIZE - dataLen, " maxrows %d", g_Dbs.db[i].dbCfg.maxRows);
2841 2842 2843
      }
      if (g_Dbs.db[i].dbCfg.comp > 0) {
        dataLen += snprintf(command + dataLen,
2844
            BUFFER_SIZE - dataLen, " comp %d", g_Dbs.db[i].dbCfg.comp);
2845 2846 2847
      }
      if (g_Dbs.db[i].dbCfg.walLevel > 0) {
        dataLen += snprintf(command + dataLen,
2848
            BUFFER_SIZE - dataLen, " wal %d", g_Dbs.db[i].dbCfg.walLevel);
2849 2850 2851
      }
      if (g_Dbs.db[i].dbCfg.cacheLast > 0) {
        dataLen += snprintf(command + dataLen,
2852
            BUFFER_SIZE - dataLen, " cachelast %d", g_Dbs.db[i].dbCfg.cacheLast);
2853 2854 2855
      }
      if (g_Dbs.db[i].dbCfg.fsync > 0) {
        dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
2856
                " fsync %d", g_Dbs.db[i].dbCfg.fsync);
2857 2858
      }
      if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", strlen("ms")))
2859 2860
              || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
                      "us", strlen("us")))) {
2861
        dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
2862
                " precision \'%s\';", g_Dbs.db[i].dbCfg.precision);
2863 2864 2865 2866 2867 2868 2869 2870
      }

      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);
2871 2872
    }

2873
    debugPrint("%s() LN%d supertbl count:%"PRIu64"\n",
2874
            __func__, __LINE__, g_Dbs.db[i].superTblCount);
2875 2876 2877

    int validStbCount = 0;

S
Shuduo Sang 已提交
2878
    for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
2879 2880 2881 2882 2883
      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);

      if ((ret != 0) || (g_Dbs.db[i].drop)) {
2884
        ret = createSuperTable(taos, g_Dbs.db[i].dbName,
2885
                &g_Dbs.db[i].superTbls[j]);
2886

2887
        if (0 != ret) {
S
Shuduo Sang 已提交
2888
          errorPrint("create super table %"PRIu64" failed!\n\n", j);
2889
          continue;
2890 2891 2892
        }
      }

2893
      ret = getSuperTableFromServer(taos, g_Dbs.db[i].dbName,
2894
                &g_Dbs.db[i].superTbls[j]);
2895 2896
      if (0 != ret) {
        errorPrint("\nget super table %s.%s info failed!\n\n",
2897
                g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].sTblName);
2898
        continue;
2899
      }
2900 2901

      validStbCount ++;
2902
    }
2903 2904

    g_Dbs.db[i].superTblCount = validStbCount;
2905 2906 2907 2908 2909 2910
  }

  taos_close(taos);
  return 0;
}

2911 2912
static void* createTable(void *sarg)
{
2913 2914
  threadInfo *pThreadInfo = (threadInfo *)sarg;
  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
2915

S
Shuduo Sang 已提交
2916
  uint64_t  lastPrintTime = taosGetTimestampMs();
2917

2918
  int buff_len;
2919
  buff_len = BUFFER_SIZE / 8;
2920

2921 2922
  pThreadInfo->buffer = calloc(buff_len, 1);
  if (pThreadInfo->buffer == NULL) {
2923
    errorPrint("%s() LN%d, Memory allocated failed!\n", __func__, __LINE__);
2924 2925
    exit(-1);
  }
2926 2927 2928

  int len = 0;
  int batchNum = 0;
2929

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

2934
  for (uint64_t i = pThreadInfo->start_table_from;
2935
          i <= pThreadInfo->end_table_to; i++) {
2936
    if (0 == g_Dbs.use_metric) {
2937
      snprintf(pThreadInfo->buffer, buff_len,
2938
              "create table if not exists %s.%s%"PRIu64" %s;",
2939 2940 2941
              pThreadInfo->db_name,
              g_args.tb_prefix, i,
              pThreadInfo->cols);
2942
    } else {
2943 2944
      if (superTblInfo == NULL) {
        errorPrint("%s() LN%d, use metric, but super table info is NULL\n",
2945
                  __func__, __LINE__);
2946
        free(pThreadInfo->buffer);
2947 2948 2949 2950
        exit(-1);
      } else {
        if (0 == len) {
          batchNum = 0;
2951 2952
          memset(pThreadInfo->buffer, 0, buff_len);
          len += snprintf(pThreadInfo->buffer + len,
2953
                  buff_len - len, "create table ");
2954 2955 2956
        }
        char* tagsValBuf = NULL;
        if (0 == superTblInfo->tagSource) {
2957
          tagsValBuf = generateTagVaulesForStb(superTblInfo, i);
2958 2959
        } else {
          tagsValBuf = getTagValueFromTagSample(
2960 2961
                  superTblInfo,
                  i % superTblInfo->tagSampleCount);
2962 2963
        }
        if (NULL == tagsValBuf) {
2964
          free(pThreadInfo->buffer);
2965 2966
          return NULL;
        }
2967
        len += snprintf(pThreadInfo->buffer + len,
2968
                buff_len - len,
2969
                "if not exists %s.%s%"PRIu64" using %s.%s tags %s ",
2970 2971 2972
                pThreadInfo->db_name, superTblInfo->childTblPrefix,
                i, pThreadInfo->db_name,
                superTblInfo->sTblName, tagsValBuf);
2973 2974 2975
        free(tagsValBuf);
        batchNum++;
        if ((batchNum < superTblInfo->batchCreateTableNum)
2976 2977
                && ((buff_len - len)
                    >= (superTblInfo->lenOfTagOfOneRow + 256))) {
2978 2979
          continue;
        }
2980 2981 2982 2983
      }
    }

    len = 0;
2984 2985 2986 2987
    if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
                NO_INSERT_TYPE, false)){
      errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
      free(pThreadInfo->buffer);
2988 2989 2990
      return NULL;
    }

S
Shuduo Sang 已提交
2991
    uint64_t  currentPrintTime = taosGetTimestampMs();
2992
    if (currentPrintTime - lastPrintTime > 30*1000) {
2993
      printf("thread[%d] already create %"PRIu64" - %"PRIu64" tables\n",
2994
              pThreadInfo->threadID, pThreadInfo->start_table_from, i);
2995 2996 2997
      lastPrintTime = currentPrintTime;
    }
  }
2998

2999
  if (0 != len) {
3000 3001 3002
    if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
                NO_INSERT_TYPE, false)) {
      errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
3003
    }
3004
  }
3005

3006
  free(pThreadInfo->buffer);
3007 3008 3009
  return NULL;
}

3010
static int startMultiThreadCreateChildTable(
3011
        char* cols, int threads, uint64_t tableFrom, int64_t ntables,
3012
        char* db_name, SSuperTable* superTblInfo) {
3013

3014
  pthread_t *pids = malloc(threads * sizeof(pthread_t));
3015
  threadInfo *infos = calloc(1, threads * sizeof(threadInfo));
3016 3017 3018 3019 3020 3021 3022 3023 3024 3025

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

  if (threads < 1) {
    threads = 1;
  }

S
Shuduo Sang 已提交
3026
  int64_t a = ntables / threads;
3027 3028 3029 3030 3031
  if (a < 1) {
    threads = ntables;
    a = 1;
  }

S
Shuduo Sang 已提交
3032
  int64_t b = 0;
3033
  b = ntables % threads;
3034

3035 3036 3037 3038 3039
  for (int64_t i = 0; i < threads; i++) {
    threadInfo *pThreadInfo = infos + i;
    pThreadInfo->threadID = i;
    tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
    pThreadInfo->superTblInfo = superTblInfo;
3040
    verbosePrint("%s() %d db_name: %s\n", __func__, __LINE__, db_name);
3041
    pThreadInfo->taos = taos_connect(
3042 3043 3044 3045 3046
            g_Dbs.host,
            g_Dbs.user,
            g_Dbs.password,
            db_name,
            g_Dbs.port);
3047
    if (pThreadInfo->taos == NULL) {
3048
      errorPrint( "%s() LN%d, Failed to connect to TDengine, reason:%s\n",
3049
         __func__, __LINE__, taos_errstr(NULL));
3050
      free(pids);
3051
      free(infos);
3052 3053
      return -1;
    }
3054

3055
    pThreadInfo->start_table_from = tableFrom;
3056
    pThreadInfo->ntables = i<b?a+1:a;
3057 3058
    pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
    tableFrom = pThreadInfo->end_table_to + 1;
3059 3060 3061 3062
    pThreadInfo->use_metric = true;
    pThreadInfo->cols = cols;
    pThreadInfo->minDelay = UINT64_MAX;
    pthread_create(pids + i, NULL, createTable, pThreadInfo);
3063
  }
3064

3065 3066 3067 3068 3069
  for (int i = 0; i < threads; i++) {
    pthread_join(pids[i], NULL);
  }

  for (int i = 0; i < threads; i++) {
3070 3071
    threadInfo *pThreadInfo = infos + i;
    taos_close(pThreadInfo->taos);
3072 3073 3074
  }

  free(pids);
3075
  free(infos);
3076 3077

  return 0;
3078 3079
}

3080
static void createChildTables() {
3081 3082
    char tblColsBuf[MAX_SQL_SIZE];
    int len;
3083

3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 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
    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++) {
                    if ((AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable)
                            || (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists)) {
                        continue;
                    }
                    verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
                          g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
                    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
            len = snprintf(tblColsBuf, MAX_SQL_SIZE, "(TS TIMESTAMP");
            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)) {
                    snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
                            ", COL%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
                } else {
                    snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
                            ", COL%d %s", j, g_args.datatype[j]);
                }
                len = strlen(tblColsBuf);
            }
3124

3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
            snprintf(tblColsBuf + len, MAX_SQL_SIZE - len, ")");

            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);
3137
        }
3138
    }
3139 3140 3141 3142 3143
}

/*
  Read 10000 lines at most. If more than 10000 lines, continue to read after using
*/
3144
static int readTagFromCsvFileToMem(SSuperTable  * superTblInfo) {
3145 3146 3147
  size_t  n = 0;
  ssize_t readLen = 0;
  char *  line = NULL;
3148

3149 3150
  FILE *fp = fopen(superTblInfo->tagsFile, "r");
  if (fp == NULL) {
3151
    printf("Failed to open tags file: %s, reason:%s\n",
3152
            superTblInfo->tagsFile, strerror(errno));
3153 3154 3155 3156 3157 3158 3159
    return -1;
  }

  if (superTblInfo->tagDataBuf) {
    free(superTblInfo->tagDataBuf);
    superTblInfo->tagDataBuf = NULL;
  }
3160

3161 3162 3163 3164 3165 3166 3167 3168 3169
  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));
    fclose(fp);
    return -1;
  }

3170
  while((readLen = tgetline(&line, &n, fp)) != -1) {
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
    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) {
3183
      char *tmp = realloc(tagDataBuf,
3184
              (size_t)tagCount*1.5*superTblInfo->lenOfTagOfOneRow);
3185 3186 3187
      if (tmp != NULL) {
        tagDataBuf = tmp;
        tagCount = (int)(tagCount*1.5);
3188
        memset(tagDataBuf + count*superTblInfo->lenOfTagOfOneRow,
3189
                0, (size_t)((tagCount-count)*superTblInfo->lenOfTagOfOneRow));
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
      } 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;
      }
    }
  }

  superTblInfo->tagDataBuf = tagDataBuf;
  superTblInfo->tagSampleCount = count;

  free(line);
  fclose(fp);
  return 0;
}

3209
#if 0
3210 3211 3212 3213
int readSampleFromJsonFileToMem(SSuperTable  * superTblInfo) {
  // TODO
  return 0;
}
3214
#endif
3215 3216 3217 3218

/*
  Read 10000 lines at most. If more than 10000 lines, continue to read after using
*/
3219
static int readSampleFromCsvFileToMem(
3220
        SSuperTable* superTblInfo) {
3221 3222 3223 3224
  size_t  n = 0;
  ssize_t readLen = 0;
  char *  line = NULL;
  int getRows = 0;
3225

3226 3227
  FILE*  fp = fopen(superTblInfo->sampleFile, "r");
  if (fp == NULL) {
3228 3229 3230
      errorPrint( "Failed to open sample file: %s, reason:%s\n",
              superTblInfo->sampleFile, strerror(errno));
      return -1;
3231
  }
3232

3233
  assert(superTblInfo->sampleDataBuf);
3234
  memset(superTblInfo->sampleDataBuf, 0,
3235
          MAX_SAMPLES_ONCE_FROM_FILE * superTblInfo->lenOfOneRow);
3236
  while(1) {
3237
    readLen = tgetline(&line, &n, fp);
3238 3239
    if (-1 == readLen) {
      if(0 != fseek(fp, 0, SEEK_SET)) {
3240
        errorPrint( "Failed to fseek file: %s, reason:%s\n",
3241
                superTblInfo->sampleFile, strerror(errno));
3242
        fclose(fp);
3243 3244 3245 3246
        return -1;
      }
      continue;
    }
3247

3248 3249 3250 3251 3252 3253 3254 3255 3256
    if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
      line[--readLen] = 0;
    }

    if (readLen == 0) {
      continue;
    }

    if (readLen > superTblInfo->lenOfOneRow) {
3257
      printf("sample row len[%d] overflow define schema len[%"PRIu64"], so discard this row\n",
3258
              (int32_t)readLen, superTblInfo->lenOfOneRow);
3259 3260 3261
      continue;
    }

3262
    memcpy(superTblInfo->sampleDataBuf + getRows * superTblInfo->lenOfOneRow,
3263
          line, readLen);
3264 3265 3266 3267 3268 3269 3270
    getRows++;

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

3271
  fclose(fp);
3272 3273 3274 3275
  tmfree(line);
  return 0;
}

3276
static bool getColumnAndTagTypeFromInsertJsonFile(
3277
        cJSON* stbInfo, SSuperTable* superTbls) {
3278
  bool  ret = false;
3279

3280
  // columns
3281 3282
  cJSON *columns = cJSON_GetObjectItem(stbInfo, "columns");
  if (columns && columns->type != cJSON_Array) {
3283
    printf("ERROR: failed to read json, columns not found\n");
3284 3285 3286 3287 3288 3289
    goto PARSE_OVER;
  } else if (NULL == columns) {
    superTbls->columnCount = 0;
    superTbls->tagCount    = 0;
    return true;
  }
3290

3291
  int columnSize = cJSON_GetArraySize(columns);
3292
  if ((columnSize + 1/* ts */) > MAX_COLUMN_COUNT) {
3293
    errorPrint("%s() LN%d, failed to read json, column size overflow, max column size is %d\n",
3294
            __func__, __LINE__, MAX_COLUMN_COUNT);
3295 3296 3297 3298 3299 3300
    goto PARSE_OVER;
  }

  int count = 1;
  int index = 0;
  StrColumn    columnCase;
3301

3302
  //superTbls->columnCount = columnSize;
3303 3304 3305 3306 3307 3308 3309
  for (int k = 0; k < columnSize; ++k) {
    cJSON* column = cJSON_GetArrayItem(columns, k);
    if (column == NULL) continue;

    count = 1;
    cJSON* countObj = cJSON_GetObjectItem(column, "count");
    if (countObj && countObj->type == cJSON_Number) {
3310
      count = countObj->valueint;
3311
    } else if (countObj && countObj->type != cJSON_Number) {
3312
      errorPrint("%s() LN%d, failed to read json, column count not found\n",
3313
          __func__, __LINE__);
3314 3315 3316 3317 3318
      goto PARSE_OVER;
    } else {
      count = 1;
    }

3319
    // column info
3320 3321
    memset(&columnCase, 0, sizeof(StrColumn));
    cJSON *dataType = cJSON_GetObjectItem(column, "type");
3322 3323 3324
    if (!dataType || dataType->type != cJSON_String
        || dataType->valuestring == NULL) {
      errorPrint("%s() LN%d: failed to read json, column type not found\n",
3325
          __func__, __LINE__);
3326 3327
      goto PARSE_OVER;
    }
3328 3329
    //tstrncpy(superTbls->columns[k].dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
    tstrncpy(columnCase.dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
3330

3331 3332
    cJSON* dataLen = cJSON_GetObjectItem(column, "len");
    if (dataLen && dataLen->type == cJSON_Number) {
3333
      columnCase.dataLen = dataLen->valueint;
3334
    } else if (dataLen && dataLen->type != cJSON_Number) {
3335
      debugPrint("%s() LN%d: failed to read json, column len not found\n",
3336
          __func__, __LINE__);
3337 3338 3339 3340
      goto PARSE_OVER;
    } else {
      columnCase.dataLen = 8;
    }
3341

3342
    for (int n = 0; n < count; ++n) {
3343
      tstrncpy(superTbls->columns[index].dataType,
3344
              columnCase.dataType, MAX_TB_NAME_SIZE);
3345
      superTbls->columns[index].dataLen = columnCase.dataLen;
3346 3347
      index++;
    }
3348
  }
3349

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

3356
  superTbls->columnCount = index;
3357

3358 3359
  count = 1;
  index = 0;
3360
  // tags
3361 3362
  cJSON *tags = cJSON_GetObjectItem(stbInfo, "tags");
  if (!tags || tags->type != cJSON_Array) {
3363
    errorPrint("%s() LN%d, failed to read json, tags not found\n",
3364
        __func__, __LINE__);
3365 3366
    goto PARSE_OVER;
  }
3367

3368 3369
  int tagSize = cJSON_GetArraySize(tags);
  if (tagSize > MAX_TAG_COUNT) {
3370
    errorPrint("%s() LN%d, failed to read json, tags size overflow, max tag size is %d\n",
3371
        __func__, __LINE__, MAX_TAG_COUNT);
3372 3373
    goto PARSE_OVER;
  }
3374 3375

  //superTbls->tagCount = tagSize;
3376 3377 3378
  for (int k = 0; k < tagSize; ++k) {
    cJSON* tag = cJSON_GetArrayItem(tags, k);
    if (tag == NULL) continue;
3379

3380 3381 3382
    count = 1;
    cJSON* countObj = cJSON_GetObjectItem(tag, "count");
    if (countObj && countObj->type == cJSON_Number) {
3383
      count = countObj->valueint;
3384
    } else if (countObj && countObj->type != cJSON_Number) {
3385
      printf("ERROR: failed to read json, column count not found\n");
3386 3387 3388 3389 3390
      goto PARSE_OVER;
    } else {
      count = 1;
    }

3391
    // column info
3392 3393
    memset(&columnCase, 0, sizeof(StrColumn));
    cJSON *dataType = cJSON_GetObjectItem(tag, "type");
3394 3395 3396
    if (!dataType || dataType->type != cJSON_String
        || dataType->valuestring == NULL) {
      errorPrint("%s() LN%d, failed to read json, tag type not found\n",
3397
          __func__, __LINE__);
3398 3399
      goto PARSE_OVER;
    }
3400
    tstrncpy(columnCase.dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
3401

3402 3403
    cJSON* dataLen = cJSON_GetObjectItem(tag, "len");
    if (dataLen && dataLen->type == cJSON_Number) {
3404
      columnCase.dataLen = dataLen->valueint;
3405
    } else if (dataLen && dataLen->type != cJSON_Number) {
3406
      errorPrint("%s() LN%d, failed to read json, column len not found\n",
3407
          __func__, __LINE__);
3408 3409 3410
      goto PARSE_OVER;
    } else {
      columnCase.dataLen = 0;
3411 3412
    }

3413
    for (int n = 0; n < count; ++n) {
3414
      tstrncpy(superTbls->tags[index].dataType, columnCase.dataType,
3415
          MAX_TB_NAME_SIZE);
3416
      superTbls->tags[index].dataLen = columnCase.dataLen;
3417 3418
      index++;
    }
3419
  }
3420 3421

  if (index > MAX_TAG_COUNT) {
3422
    errorPrint("%s() LN%d, failed to read json, tags size overflow, allowed max tag count is %d\n",
3423
        __func__, __LINE__, MAX_TAG_COUNT);
3424 3425 3426
    goto PARSE_OVER;
  }

3427 3428
  superTbls->tagCount = index;

3429 3430
  if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > MAX_COLUMN_COUNT) {
    errorPrint("%s() LN%d, columns + tags is more than allowed max columns count: %d\n",
3431
        __func__, __LINE__, MAX_COLUMN_COUNT);
3432 3433
    goto PARSE_OVER;
  }
3434 3435
  ret = true;

3436
PARSE_OVER:
3437 3438 3439 3440 3441 3442 3443 3444
  return ret;
}

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

  cJSON* cfgdir = cJSON_GetObjectItem(root, "cfgdir");
  if (cfgdir && cfgdir->type == cJSON_String && cfgdir->valuestring != NULL) {
3445
    tstrncpy(g_Dbs.cfgDir, cfgdir->valuestring, MAX_FILE_NAME_LEN);
3446 3447 3448 3449
  }

  cJSON* host = cJSON_GetObjectItem(root, "host");
  if (host && host->type == cJSON_String && host->valuestring != NULL) {
3450
    tstrncpy(g_Dbs.host, host->valuestring, MAX_HOSTNAME_SIZE);
3451
  } else if (!host) {
3452
    tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
3453
  } else {
3454
    printf("ERROR: failed to read json, host not found\n");
3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466
    goto PARSE_OVER;
  }

  cJSON* port = cJSON_GetObjectItem(root, "port");
  if (port && port->type == cJSON_Number) {
    g_Dbs.port = port->valueint;
  } else if (!port) {
    g_Dbs.port = 6030;
  }

  cJSON* user = cJSON_GetObjectItem(root, "user");
  if (user && user->type == cJSON_String && user->valuestring != NULL) {
3467
    tstrncpy(g_Dbs.user, user->valuestring, MAX_USERNAME_SIZE);
3468
  } else if (!user) {
3469
    tstrncpy(g_Dbs.user, "root", MAX_USERNAME_SIZE);
3470 3471 3472 3473
  }

  cJSON* password = cJSON_GetObjectItem(root, "password");
  if (password && password->type == cJSON_String && password->valuestring != NULL) {
3474
    tstrncpy(g_Dbs.password, password->valuestring, MAX_PASSWORD_SIZE);
3475
  } else if (!password) {
3476
    tstrncpy(g_Dbs.password, "taosdata", MAX_PASSWORD_SIZE);
3477 3478 3479 3480
  }

  cJSON* resultfile = cJSON_GetObjectItem(root, "result_file");
  if (resultfile && resultfile->type == cJSON_String && resultfile->valuestring != NULL) {
3481
    tstrncpy(g_Dbs.resultFile, resultfile->valuestring, MAX_FILE_NAME_LEN);
3482
  } else if (!resultfile) {
3483
    tstrncpy(g_Dbs.resultFile, "./insert_res.txt", MAX_FILE_NAME_LEN);
3484 3485 3486 3487 3488 3489 3490 3491
  }

  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;
  } else {
3492
    printf("ERROR: failed to read json, threads not found\n");
3493
    goto PARSE_OVER;
3494 3495
  }

3496 3497 3498 3499
  cJSON* threads2 = cJSON_GetObjectItem(root, "thread_count_create_tbl");
  if (threads2 && threads2->type == cJSON_Number) {
    g_Dbs.threadCountByCreateTbl = threads2->valueint;
  } else if (!threads2) {
sangshuduo's avatar
sangshuduo 已提交
3500
    g_Dbs.threadCountByCreateTbl = 1;
3501
  } else {
3502
    errorPrint("%s() LN%d, failed to read json, threads2 not found\n",
3503
            __func__, __LINE__);
3504
    goto PARSE_OVER;
3505
  }
3506

3507 3508
  cJSON* gInsertInterval = cJSON_GetObjectItem(root, "insert_interval");
  if (gInsertInterval && gInsertInterval->type == cJSON_Number) {
3509 3510 3511 3512 3513
    if (gInsertInterval->valueint <0) {
      errorPrint("%s() LN%d, failed to read json, insert interval input mistake\n",
            __func__, __LINE__);
      goto PARSE_OVER;
    }
3514 3515 3516 3517
    g_args.insert_interval = gInsertInterval->valueint;
  } else if (!gInsertInterval) {
    g_args.insert_interval = 0;
  } else {
3518
    errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
3519
        __func__, __LINE__);
3520 3521
    goto PARSE_OVER;
  }
3522

3523 3524
  cJSON* interlaceRows = cJSON_GetObjectItem(root, "interlace_rows");
  if (interlaceRows && interlaceRows->type == cJSON_Number) {
3525 3526 3527 3528 3529 3530
    if (interlaceRows->valueint < 0) {
      errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
        __func__, __LINE__);
      goto PARSE_OVER;

    }
3531 3532
    g_args.interlace_rows = interlaceRows->valueint;
  } else if (!interlaceRows) {
3533
    g_args.interlace_rows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
3534
  } else {
3535
    errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
3536
        __func__, __LINE__);
3537
    goto PARSE_OVER;
3538
  }
3539

3540 3541
  cJSON* maxSqlLen = cJSON_GetObjectItem(root, "max_sql_len");
  if (maxSqlLen && maxSqlLen->type == cJSON_Number) {
3542 3543 3544 3545 3546
    if (maxSqlLen->valueint < 0) {
      errorPrint("%s() LN%d, failed to read json, max_sql_len input mistake\n",
        __func__, __LINE__);
      goto PARSE_OVER;
    }
3547 3548
    g_args.max_sql_len = maxSqlLen->valueint;
  } else if (!maxSqlLen) {
sangshuduo's avatar
sangshuduo 已提交
3549
    g_args.max_sql_len = (1024*1024);
3550
  } else {
3551
    errorPrint("%s() LN%d, failed to read json, max_sql_len input mistake\n",
3552
        __func__, __LINE__);
3553 3554 3555 3556 3557
    goto PARSE_OVER;
  }

  cJSON* numRecPerReq = cJSON_GetObjectItem(root, "num_of_records_per_req");
  if (numRecPerReq && numRecPerReq->type == cJSON_Number) {
3558
    if (numRecPerReq->valueint <= 0) {
3559 3560 3561
      errorPrint("%s() LN%d, failed to read json, num_of_records_per_req input mistake\n",
        __func__, __LINE__);
      goto PARSE_OVER;
3562
    } else if (numRecPerReq->valueint > MAX_RECORDS_PER_REQ) {
3563 3564 3565 3566 3567
      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();
3568
      numRecPerReq->valueint = MAX_RECORDS_PER_REQ;
3569
    }
3570 3571
    g_args.num_of_RPR = numRecPerReq->valueint;
  } else if (!numRecPerReq) {
3572
    g_args.num_of_RPR = MAX_RECORDS_PER_REQ;
3573
  } else {
3574
    errorPrint("%s() LN%d, failed to read json, num_of_records_per_req not found\n",
3575
        __func__, __LINE__);
3576 3577 3578
    goto PARSE_OVER;
  }

3579
  cJSON *answerPrompt = cJSON_GetObjectItem(root, "confirm_parameter_prompt"); // yes, no,
3580
  if (answerPrompt
3581 3582
          && answerPrompt->type == cJSON_String
          && answerPrompt->valuestring != NULL) {
3583 3584 3585 3586 3587 3588 3589 3590
    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) {
3591
    g_args.answer_yes = true;   // default is no, mean answer_yes.
3592
  } else {
3593
    errorPrint("%s", "failed to read json, confirm_parameter_prompt input mistake\n");
3594
    goto PARSE_OVER;
3595
  }
3596

3597 3598
  // rows per table need be less than insert batch
  if (g_args.interlace_rows > g_args.num_of_RPR) {
3599
      printf("NOTICE: interlace rows value %u > num_of_records_per_req %u\n\n",
3600
              g_args.interlace_rows, g_args.num_of_RPR);
3601
      printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
3602 3603 3604 3605 3606
              g_args.num_of_RPR);
      prompt();
      g_args.interlace_rows = g_args.num_of_RPR;
  }

3607 3608
  cJSON* dbs = cJSON_GetObjectItem(root, "databases");
  if (!dbs || dbs->type != cJSON_Array) {
3609
    printf("ERROR: failed to read json, databases not found\n");
3610 3611 3612 3613 3614
    goto PARSE_OVER;
  }

  int dbSize = cJSON_GetArraySize(dbs);
  if (dbSize > MAX_DB_COUNT) {
3615
    errorPrint(
3616 3617
            "ERROR: failed to read json, databases size overflow, max database is %d\n",
            MAX_DB_COUNT);
3618 3619 3620 3621 3622 3623 3624 3625
    goto PARSE_OVER;
  }

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

3626
    // dbinfo
3627 3628
    cJSON *dbinfo = cJSON_GetObjectItem(dbinfos, "dbinfo");
    if (!dbinfo || dbinfo->type != cJSON_Object) {
3629
      printf("ERROR: failed to read json, dbinfo not found\n");
3630 3631
      goto PARSE_OVER;
    }
3632

3633 3634
    cJSON *dbName = cJSON_GetObjectItem(dbinfo, "name");
    if (!dbName || dbName->type != cJSON_String || dbName->valuestring == NULL) {
3635
      printf("ERROR: failed to read json, db name not found\n");
3636 3637
      goto PARSE_OVER;
    }
3638
    tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, MAX_DB_NAME_SIZE);
3639 3640 3641

    cJSON *drop = cJSON_GetObjectItem(dbinfo, "drop");
    if (drop && drop->type == cJSON_String && drop->valuestring != NULL) {
3642 3643
      if (0 == strncasecmp(drop->valuestring, "yes", strlen("yes"))) {
        g_Dbs.db[i].drop = true;
3644
      } else {
3645
        g_Dbs.db[i].drop = false;
3646
      }
3647
    } else if (!drop) {
3648
      g_Dbs.db[i].drop = g_args.drop_database;
3649
    } else {
3650
      errorPrint("%s() LN%d, failed to read json, drop input mistake\n",
3651
              __func__, __LINE__);
3652 3653 3654 3655
      goto PARSE_OVER;
    }

    cJSON *precision = cJSON_GetObjectItem(dbinfo, "precision");
3656
    if (precision && precision->type == cJSON_String
3657
            && precision->valuestring != NULL) {
3658
      tstrncpy(g_Dbs.db[i].dbCfg.precision, precision->valuestring,
3659
              MAX_DB_NAME_SIZE);
3660
    } else if (!precision) {
3661
      //tstrncpy(g_Dbs.db[i].dbCfg.precision, "ms", MAX_DB_NAME_SIZE);
3662 3663
      memset(g_Dbs.db[i].dbCfg.precision, 0, MAX_DB_NAME_SIZE);
    } else {
3664
      printf("ERROR: failed to read json, precision not found\n");
3665 3666 3667 3668 3669 3670 3671 3672 3673
      goto PARSE_OVER;
    }

    cJSON* update = cJSON_GetObjectItem(dbinfo, "update");
    if (update && update->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.update = update->valueint;
    } else if (!update) {
      g_Dbs.db[i].dbCfg.update = -1;
    } else {
3674
      printf("ERROR: failed to read json, update not found\n");
3675 3676 3677 3678 3679 3680 3681 3682 3683
      goto PARSE_OVER;
    }

    cJSON* replica = cJSON_GetObjectItem(dbinfo, "replica");
    if (replica && replica->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.replica = replica->valueint;
    } else if (!replica) {
      g_Dbs.db[i].dbCfg.replica = -1;
    } else {
3684
      printf("ERROR: failed to read json, replica not found\n");
3685 3686 3687 3688 3689 3690 3691 3692 3693
      goto PARSE_OVER;
    }

    cJSON* keep = cJSON_GetObjectItem(dbinfo, "keep");
    if (keep && keep->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.keep = keep->valueint;
    } else if (!keep) {
      g_Dbs.db[i].dbCfg.keep = -1;
    } else {
3694 3695
     printf("ERROR: failed to read json, keep not found\n");
     goto PARSE_OVER;
3696
    }
3697

3698 3699 3700 3701 3702 3703
    cJSON* days = cJSON_GetObjectItem(dbinfo, "days");
    if (days && days->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.days = days->valueint;
    } else if (!days) {
      g_Dbs.db[i].dbCfg.days = -1;
    } else {
3704 3705
     printf("ERROR: failed to read json, days not found\n");
     goto PARSE_OVER;
3706
    }
3707

3708 3709 3710 3711 3712 3713
    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 {
3714 3715
     printf("ERROR: failed to read json, cache not found\n");
     goto PARSE_OVER;
3716
    }
3717

3718 3719 3720 3721 3722 3723
    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 {
3724 3725
     printf("ERROR: failed to read json, block not found\n");
     goto PARSE_OVER;
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
    }

    //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) {
3742
      g_Dbs.db[i].dbCfg.minRows = 0;    // 0 means default
3743
    } else {
3744 3745
     printf("ERROR: failed to read json, minRows not found\n");
     goto PARSE_OVER;
3746 3747 3748 3749 3750 3751
    }

    cJSON* maxRows= cJSON_GetObjectItem(dbinfo, "maxRows");
    if (maxRows && maxRows->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.maxRows = maxRows->valueint;
    } else if (!maxRows) {
3752
      g_Dbs.db[i].dbCfg.maxRows = 0;    // 0 means default
3753
    } else {
3754 3755
     printf("ERROR: failed to read json, maxRows not found\n");
     goto PARSE_OVER;
3756 3757 3758 3759 3760 3761 3762 3763
    }

    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 {
3764 3765
     printf("ERROR: failed to read json, comp not found\n");
     goto PARSE_OVER;
3766 3767 3768 3769 3770 3771 3772 3773
    }

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

3778 3779 3780 3781 3782 3783
    cJSON* cacheLast= cJSON_GetObjectItem(dbinfo, "cachelast");
    if (cacheLast && cacheLast->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.cacheLast = cacheLast->valueint;
    } else if (!cacheLast) {
      g_Dbs.db[i].dbCfg.cacheLast = -1;
    } else {
3784 3785
     printf("ERROR: failed to read json, cacheLast not found\n");
     goto PARSE_OVER;
3786 3787
    }

3788 3789 3790 3791
    cJSON* quorum= cJSON_GetObjectItem(dbinfo, "quorum");
    if (quorum && quorum->type == cJSON_Number) {
      g_Dbs.db[i].dbCfg.quorum = quorum->valueint;
    } else if (!quorum) {
3792
      g_Dbs.db[i].dbCfg.quorum = 1;
3793
    } else {
3794 3795
     printf("failed to read json, quorum input mistake");
     goto PARSE_OVER;
3796 3797 3798 3799 3800 3801 3802 3803
    }

    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 {
3804
      errorPrint("%s() LN%d, failed to read json, fsync input mistake\n",
3805
              __func__, __LINE__);
3806
      goto PARSE_OVER;
3807
    }
3808

3809
    // super_talbes
3810 3811
    cJSON *stables = cJSON_GetObjectItem(dbinfos, "super_tables");
    if (!stables || stables->type != cJSON_Array) {
3812
      errorPrint("%s() LN%d, failed to read json, super_tables not found\n",
3813
              __func__, __LINE__);
3814
      goto PARSE_OVER;
3815 3816
    }

3817 3818
    int stbSize = cJSON_GetArraySize(stables);
    if (stbSize > MAX_SUPER_TABLE_COUNT) {
3819
      errorPrint(
3820 3821
              "%s() LN%d, failed to read json, supertable size overflow, max supertable is %d\n",
              __func__, __LINE__, MAX_SUPER_TABLE_COUNT);
3822 3823 3824 3825 3826 3827 3828
      goto PARSE_OVER;
    }

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

      // dbinfo
3831
      cJSON *stbName = cJSON_GetObjectItem(stbInfo, "name");
3832 3833
      if (!stbName || stbName->type != cJSON_String
              || stbName->valuestring == NULL) {
3834
        errorPrint("%s() LN%d, failed to read json, stb name not found\n",
3835
                __func__, __LINE__);
3836 3837
        goto PARSE_OVER;
      }
3838 3839
      tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
              MAX_TB_NAME_SIZE);
3840

3841 3842
      cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
      if (!prefix || prefix->type != cJSON_String || prefix->valuestring == NULL) {
3843
        printf("ERROR: failed to read json, childtable_prefix not found\n");
3844 3845
        goto PARSE_OVER;
      }
3846 3847
      tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring,
              MAX_DB_NAME_SIZE);
3848

3849
      cJSON *autoCreateTbl = cJSON_GetObjectItem(stbInfo, "auto_create_table");
3850
      if (autoCreateTbl
3851 3852
              && autoCreateTbl->type == cJSON_String
              && autoCreateTbl->valuestring != NULL) {
3853 3854 3855 3856 3857 3858 3859 3860
          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;
          }
3861
      } else if (!autoCreateTbl) {
3862
          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
3863
      } else {
3864 3865
          printf("ERROR: failed to read json, auto_create_table not found\n");
          goto PARSE_OVER;
3866
      }
3867

3868 3869 3870 3871
      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) {
3872
        g_Dbs.db[i].superTbls[j].batchCreateTableNum = 1000;
3873
      } else {
3874
        printf("ERROR: failed to read json, batch_create_tbl_num not found\n");
3875
        goto PARSE_OVER;
3876
      }
3877 3878

      cJSON *childTblExists = cJSON_GetObjectItem(stbInfo, "child_table_exists"); // yes, no
3879
      if (childTblExists
3880 3881
              && childTblExists->type == cJSON_String
              && childTblExists->valuestring != NULL) {
3882 3883
        if ((0 == strncasecmp(childTblExists->valuestring, "yes", 3))
            && (g_Dbs.db[i].drop == false)) {
3884
          g_Dbs.db[i].superTbls[j].childTblExists = TBL_ALREADY_EXISTS;
3885
        } else if ((0 == strncasecmp(childTblExists->valuestring, "no", 2)
3886
              || (g_Dbs.db[i].drop == true))) {
3887 3888 3889 3890 3891 3892 3893
          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 {
3894
        errorPrint("%s() LN%d, failed to read json, child_table_exists not found\n",
3895
                __func__, __LINE__);
3896 3897
        goto PARSE_OVER;
      }
3898

3899 3900 3901 3902
      if (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
      }

3903 3904
      cJSON* count = cJSON_GetObjectItem(stbInfo, "childtable_count");
      if (!count || count->type != cJSON_Number || 0 >= count->valueint) {
3905
        errorPrint("%s() LN%d, failed to read json, childtable_count input mistake\n",
3906
                __func__, __LINE__);
3907 3908 3909 3910 3911
        goto PARSE_OVER;
      }
      g_Dbs.db[i].superTbls[j].childTblCount = count->valueint;

      cJSON *dataSource = cJSON_GetObjectItem(stbInfo, "data_source");
3912
      if (dataSource && dataSource->type == cJSON_String
3913
              && dataSource->valuestring != NULL) {
3914
        tstrncpy(g_Dbs.db[i].superTbls[j].dataSource,
3915
                dataSource->valuestring, MAX_DB_NAME_SIZE);
3916
      } else if (!dataSource) {
3917
        tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand", MAX_DB_NAME_SIZE);
3918
      } else {
3919
        errorPrint("%s() LN%d, failed to read json, data_source not found\n",
3920
            __func__, __LINE__);
3921 3922 3923
        goto PARSE_OVER;
      }

3924 3925 3926 3927 3928 3929 3930
      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;
3931
#if STMT_IFACE_ENABLED == 1
3932 3933
        } else if (0 == strcasecmp(stbIface->valuestring, "stmt")) {
            g_Dbs.db[i].superTbls[j].iface= STMT_IFACE;
3934
#endif
3935 3936
        } else {
            errorPrint("%s() LN%d, failed to read json, insert_mode %s not recognized\n",
3937
                    __func__, __LINE__, stbIface->valuestring);
3938 3939
            goto PARSE_OVER;
        }
3940 3941
      } else if (!stbIface) {
        g_Dbs.db[i].superTbls[j].iface = TAOSC_IFACE;
3942
      } else {
3943
        errorPrint("%s", "failed to read json, insert_mode not found\n");
3944 3945 3946
        goto PARSE_OVER;
      }

3947
      cJSON* childTbl_limit = cJSON_GetObjectItem(stbInfo, "childtable_limit");
3948 3949
      if ((childTbl_limit) && (g_Dbs.db[i].drop != true)
          && (g_Dbs.db[i].superTbls[j].childTblExists == TBL_ALREADY_EXISTS)) {
3950
        if (childTbl_limit->type != cJSON_Number) {
3951 3952
            printf("ERROR: failed to read json, childtable_limit\n");
            goto PARSE_OVER;
3953 3954 3955
        }
        g_Dbs.db[i].superTbls[j].childTblLimit = childTbl_limit->valueint;
      } else {
3956
        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.
3957 3958 3959
      }

      cJSON* childTbl_offset = cJSON_GetObjectItem(stbInfo, "childtable_offset");
3960 3961
      if ((childTbl_offset) && (g_Dbs.db[i].drop != true)
          && (g_Dbs.db[i].superTbls[j].childTblExists == TBL_ALREADY_EXISTS)) {
3962 3963
        if ((childTbl_offset->type != cJSON_Number)
                || (0 > childTbl_offset->valueint)) {
3964 3965
            printf("ERROR: failed to read json, childtable_offset\n");
            goto PARSE_OVER;
3966 3967 3968 3969 3970 3971
        }
        g_Dbs.db[i].superTbls[j].childTblOffset = childTbl_offset->valueint;
      } else {
        g_Dbs.db[i].superTbls[j].childTblOffset = 0;
      }

3972 3973
      cJSON *ts = cJSON_GetObjectItem(stbInfo, "start_timestamp");
      if (ts && ts->type == cJSON_String && ts->valuestring != NULL) {
3974
        tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
3975
                ts->valuestring, MAX_DB_NAME_SIZE);
3976
      } else if (!ts) {
3977
        tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
3978
                "now", MAX_DB_NAME_SIZE);
3979
      } else {
3980
        printf("ERROR: failed to read json, start_timestamp not found\n");
3981 3982
        goto PARSE_OVER;
      }
3983

3984 3985 3986 3987
      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) {
3988
        g_Dbs.db[i].superTbls[j].timeStampStep = DEFAULT_TIMESTAMP_STEP;
3989
      } else {
3990
        printf("ERROR: failed to read json, timestamp_step not found\n");
3991 3992 3993 3994
        goto PARSE_OVER;
      }

      cJSON *sampleFormat = cJSON_GetObjectItem(stbInfo, "sample_format");
3995
      if (sampleFormat && sampleFormat->type
3996
              == cJSON_String && sampleFormat->valuestring != NULL) {
3997
        tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat,
3998
                sampleFormat->valuestring, MAX_DB_NAME_SIZE);
3999
      } else if (!sampleFormat) {
4000
        tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv", MAX_DB_NAME_SIZE);
4001
      } else {
4002
        printf("ERROR: failed to read json, sample_format not found\n");
4003
        goto PARSE_OVER;
4004
      }
4005

4006
      cJSON *sampleFile = cJSON_GetObjectItem(stbInfo, "sample_file");
4007 4008
      if (sampleFile && sampleFile->type == cJSON_String
          && sampleFile->valuestring != NULL) {
4009
        tstrncpy(g_Dbs.db[i].superTbls[j].sampleFile,
4010
                sampleFile->valuestring, MAX_FILE_NAME_LEN);
4011 4012 4013
      } else if (!sampleFile) {
        memset(g_Dbs.db[i].superTbls[j].sampleFile, 0, MAX_FILE_NAME_LEN);
      } else {
4014
        printf("ERROR: failed to read json, sample_file not found\n");
4015
        goto PARSE_OVER;
4016
      }
4017

4018
      cJSON *tagsFile = cJSON_GetObjectItem(stbInfo, "tags_file");
4019 4020
      if ((tagsFile && tagsFile->type == cJSON_String)
              && (tagsFile->valuestring != NULL)) {
4021
        tstrncpy(g_Dbs.db[i].superTbls[j].tagsFile,
4022
                tagsFile->valuestring, MAX_FILE_NAME_LEN);
4023 4024 4025 4026 4027 4028 4029 4030 4031
        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 {
4032
        printf("ERROR: failed to read json, tags_file not found\n");
4033 4034
        goto PARSE_OVER;
      }
4035

sangshuduo's avatar
sangshuduo 已提交
4036 4037 4038
      cJSON* stbMaxSqlLen = cJSON_GetObjectItem(stbInfo, "max_sql_len");
      if (stbMaxSqlLen && stbMaxSqlLen->type == cJSON_Number) {
        int32_t len = stbMaxSqlLen->valueint;
4039 4040
        if (len > TSDB_MAX_ALLOWED_SQL_LEN) {
          len = TSDB_MAX_ALLOWED_SQL_LEN;
4041 4042
        } else if (len < 5) {
          len = 5;
4043
        }
4044 4045
        g_Dbs.db[i].superTbls[j].maxSqlLen = len;
      } else if (!maxSqlLen) {
4046
        g_Dbs.db[i].superTbls[j].maxSqlLen = g_args.max_sql_len;
4047
      } else {
sangshuduo's avatar
sangshuduo 已提交
4048
        errorPrint("%s() LN%d, failed to read json, stbMaxSqlLen input mistake\n",
4049
            __func__, __LINE__);
4050
        goto PARSE_OVER;
4051
      }
4052
/*
4053 4054 4055 4056 4057
      cJSON *multiThreadWriteOneTbl =
          cJSON_GetObjectItem(stbInfo, "multi_thread_write_one_tbl"); // no , yes
      if (multiThreadWriteOneTbl
              && multiThreadWriteOneTbl->type == cJSON_String
              && multiThreadWriteOneTbl->valuestring != NULL) {
4058 4059 4060 4061
        if (0 == strncasecmp(multiThreadWriteOneTbl->valuestring, "yes", 3)) {
          g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 1;
        } else {
          g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 0;
4062
        }
4063 4064 4065
      } else if (!multiThreadWriteOneTbl) {
        g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 0;
      } else {
4066
        printf("ERROR: failed to read json, multiThreadWriteOneTbl not found\n");
4067 4068
        goto PARSE_OVER;
      }
4069
*/
sangshuduo's avatar
sangshuduo 已提交
4070 4071 4072
      cJSON* stbInterlaceRows = cJSON_GetObjectItem(stbInfo, "interlace_rows");
      if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
        if (stbInterlaceRows->valueint < 0) {
4073 4074 4075 4076
          errorPrint("%s() LN%d, failed to read json, interlace rows input mistake\n",
            __func__, __LINE__);
          goto PARSE_OVER;
        }
sangshuduo's avatar
sangshuduo 已提交
4077
        g_Dbs.db[i].superTbls[j].interlaceRows = stbInterlaceRows->valueint;
4078 4079
        // rows per table need be less than insert batch
        if (g_Dbs.db[i].superTbls[j].interlaceRows > g_args.num_of_RPR) {
4080
          printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > num_of_records_per_req %u\n\n",
4081 4082
                  i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
                  g_args.num_of_RPR);
4083
          printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
4084
                  g_args.num_of_RPR);
4085
          prompt();
4086 4087
          g_Dbs.db[i].superTbls[j].interlaceRows = g_args.num_of_RPR;
        }
sangshuduo's avatar
sangshuduo 已提交
4088
      } else if (!stbInterlaceRows) {
4089
        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
4090
      } else {
4091
        errorPrint(
4092 4093
                "%s() LN%d, failed to read json, interlace rows input mistake\n",
                __func__, __LINE__);
4094
        goto PARSE_OVER;
4095
      }
4096 4097 4098

      cJSON* disorderRatio = cJSON_GetObjectItem(stbInfo, "disorder_ratio");
      if (disorderRatio && disorderRatio->type == cJSON_Number) {
4099 4100 4101 4102 4103 4104
        if (disorderRatio->valueint > 50)
          disorderRatio->valueint = 50;

        if (disorderRatio->valueint < 0)
          disorderRatio->valueint = 0;

4105 4106 4107 4108
        g_Dbs.db[i].superTbls[j].disorderRatio = disorderRatio->valueint;
      } else if (!disorderRatio) {
        g_Dbs.db[i].superTbls[j].disorderRatio = 0;
      } else {
4109
        printf("ERROR: failed to read json, disorderRatio not found\n");
4110
        goto PARSE_OVER;
4111
      }
4112 4113 4114 4115 4116 4117 4118

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

4123 4124
      cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
      if (insertRows && insertRows->type == cJSON_Number) {
4125 4126 4127 4128 4129
        if (insertRows->valueint < 0) {
          errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
                __func__, __LINE__);
          goto PARSE_OVER;
        }
4130 4131 4132 4133
        g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
      } else if (!insertRows) {
        g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
      } else {
4134
        errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
4135
                __func__, __LINE__);
4136 4137 4138 4139 4140 4141
        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;
4142 4143 4144 4145 4146
        if (insertInterval->valueint < 0) {
          errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
                __func__, __LINE__);
          goto PARSE_OVER;
        }
4147
      } else if (!insertInterval) {
4148
        verbosePrint("%s() LN%d: stable insert interval be overrided by global %"PRIu64".\n",
4149
                __func__, __LINE__, g_args.insert_interval);
4150 4151
        g_Dbs.db[i].superTbls[j].insertInterval = g_args.insert_interval;
      } else {
4152
        errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
4153
                __func__, __LINE__);
4154 4155 4156
        goto PARSE_OVER;
      }

4157
      int retVal = getColumnAndTagTypeFromInsertJsonFile(
4158
              stbInfo, &g_Dbs.db[i].superTbls[j]);
4159 4160
      if (false == retVal) {
        goto PARSE_OVER;
4161 4162
      }
    }
4163 4164 4165 4166
  }

  ret = true;

4167
PARSE_OVER:
4168 4169 4170 4171 4172 4173 4174 4175
  return ret;
}

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

  cJSON* cfgdir = cJSON_GetObjectItem(root, "cfgdir");
  if (cfgdir && cfgdir->type == cJSON_String && cfgdir->valuestring != NULL) {
4176
    tstrncpy(g_queryInfo.cfgDir, cfgdir->valuestring, MAX_FILE_NAME_LEN);
4177 4178 4179 4180
  }

  cJSON* host = cJSON_GetObjectItem(root, "host");
  if (host && host->type == cJSON_String && host->valuestring != NULL) {
4181
    tstrncpy(g_queryInfo.host, host->valuestring, MAX_HOSTNAME_SIZE);
4182
  } else if (!host) {
4183
    tstrncpy(g_queryInfo.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
4184
  } else {
4185
    printf("ERROR: failed to read json, host not found\n");
4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
    goto PARSE_OVER;
  }

  cJSON* port = cJSON_GetObjectItem(root, "port");
  if (port && port->type == cJSON_Number) {
    g_queryInfo.port = port->valueint;
  } else if (!port) {
    g_queryInfo.port = 6030;
  }

  cJSON* user = cJSON_GetObjectItem(root, "user");
  if (user && user->type == cJSON_String && user->valuestring != NULL) {
4198
    tstrncpy(g_queryInfo.user, user->valuestring, MAX_USERNAME_SIZE);
4199
  } else if (!user) {
4200
    tstrncpy(g_queryInfo.user, "root", MAX_USERNAME_SIZE); ;
4201 4202 4203 4204
  }

  cJSON* password = cJSON_GetObjectItem(root, "password");
  if (password && password->type == cJSON_String && password->valuestring != NULL) {
4205
    tstrncpy(g_queryInfo.password, password->valuestring, MAX_PASSWORD_SIZE);
4206
  } else if (!password) {
4207
    tstrncpy(g_queryInfo.password, "taosdata", MAX_PASSWORD_SIZE);;
4208
  }
H
hzcheng 已提交
4209

4210
  cJSON *answerPrompt = cJSON_GetObjectItem(root, "confirm_parameter_prompt"); // yes, no,
4211
  if (answerPrompt && answerPrompt->type == cJSON_String
4212
          && answerPrompt->valuestring != NULL) {
4213 4214 4215 4216
    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;
H
hzcheng 已提交
4217
    } else {
4218
      g_args.answer_yes = false;
H
hzcheng 已提交
4219
    }
4220 4221 4222
  } else if (!answerPrompt) {
    g_args.answer_yes = false;
  } else {
4223
    printf("ERROR: failed to read json, confirm_parameter_prompt not found\n");
4224
    goto PARSE_OVER;
4225
  }
4226

4227 4228
  cJSON* gQueryTimes = cJSON_GetObjectItem(root, "query_times");
  if (gQueryTimes && gQueryTimes->type == cJSON_Number) {
4229
    if (gQueryTimes->valueint <= 0) {
4230 4231
      errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
        __func__, __LINE__);
4232 4233
      goto PARSE_OVER;
    }
4234 4235 4236 4237
    g_args.query_times = gQueryTimes->valueint;
  } else if (!gQueryTimes) {
    g_args.query_times = 1;
  } else {
4238
    errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
4239
        __func__, __LINE__);
4240 4241 4242
    goto PARSE_OVER;
  }

4243 4244
  cJSON* dbs = cJSON_GetObjectItem(root, "databases");
  if (dbs && dbs->type == cJSON_String && dbs->valuestring != NULL) {
4245
    tstrncpy(g_queryInfo.dbName, dbs->valuestring, MAX_DB_NAME_SIZE);
4246
  } else if (!dbs) {
4247
    printf("ERROR: failed to read json, databases not found\n");
4248
    goto PARSE_OVER;
H
hzcheng 已提交
4249
  }
4250 4251 4252

  cJSON* queryMode = cJSON_GetObjectItem(root, "query_mode");
  if (queryMode && queryMode->type == cJSON_String && queryMode->valuestring != NULL) {
4253
    tstrncpy(g_queryInfo.queryMode, queryMode->valuestring, MAX_TB_NAME_SIZE);
4254
  } else if (!queryMode) {
4255
    tstrncpy(g_queryInfo.queryMode, "taosc", MAX_TB_NAME_SIZE);
4256
  } else {
4257
    printf("ERROR: failed to read json, query_mode not found\n");
4258
    goto PARSE_OVER;
H
hzcheng 已提交
4259
  }
4260

4261
  // specified_table_query
4262 4263
  cJSON *specifiedQuery = cJSON_GetObjectItem(root, "specified_table_query");
  if (!specifiedQuery) {
4264
    g_queryInfo.specifiedQueryInfo.concurrent = 1;
4265 4266
    g_queryInfo.specifiedQueryInfo.sqlCount = 0;
  } else if (specifiedQuery->type != cJSON_Object) {
4267
    printf("ERROR: failed to read json, super_table_query not found\n");
4268
    goto PARSE_OVER;
4269
  } else {
4270 4271 4272 4273 4274
    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;
4275 4276
    }

4277
    cJSON* specifiedQueryTimes = cJSON_GetObjectItem(specifiedQuery,
4278
        "query_times");
4279
    if (specifiedQueryTimes && specifiedQueryTimes->type == cJSON_Number) {
4280
      if (specifiedQueryTimes->valueint <= 0) {
4281 4282
        errorPrint(
                "%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
4283
          __func__, __LINE__, specifiedQueryTimes->valueint);
4284 4285 4286
        goto PARSE_OVER;

      }
4287 4288 4289 4290
      g_queryInfo.specifiedQueryInfo.queryTimes = specifiedQueryTimes->valueint;
    } else if (!specifiedQueryTimes) {
      g_queryInfo.specifiedQueryInfo.queryTimes = g_args.query_times;
    } else {
4291
      errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
4292
          __func__, __LINE__);
4293
      goto PARSE_OVER;
4294
    }
4295

4296
    cJSON* concurrent = cJSON_GetObjectItem(specifiedQuery, "concurrent");
4297
    if (concurrent && concurrent->type == cJSON_Number) {
4298
      if (concurrent->valueint <= 0) {
4299
        errorPrint(
4300
                "%s() LN%d, query sqlCount %d or concurrent %d is not correct.\n",
4301 4302
              __func__, __LINE__,
              g_queryInfo.specifiedQueryInfo.sqlCount,
4303
              g_queryInfo.specifiedQueryInfo.concurrent);
4304 4305
        goto PARSE_OVER;
      }
4306
      g_queryInfo.specifiedQueryInfo.concurrent = concurrent->valueint;
4307
    } else if (!concurrent) {
4308
      g_queryInfo.specifiedQueryInfo.concurrent = 1;
4309
    }
4310

4311 4312 4313 4314 4315 4316 4317
    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;
4318
      } else {
4319
        errorPrint("%s() LN%d, failed to read json, async mode input error\n",
4320
            __func__, __LINE__);
4321 4322 4323
        goto PARSE_OVER;
      }
    } else {
4324
      g_queryInfo.specifiedQueryInfo.asyncMode = SYNC_MODE;
4325
    }
4326

4327
    cJSON* interval = cJSON_GetObjectItem(specifiedQuery, "interval");
4328
    if (interval && interval->type == cJSON_Number) {
4329
      g_queryInfo.specifiedQueryInfo.subscribeInterval = interval->valueint;
4330
    } else if (!interval) {
4331 4332
      //printf("failed to read json, subscribe interval no found\n");
      //goto PARSE_OVER;
4333
      g_queryInfo.specifiedQueryInfo.subscribeInterval = 10000;
4334
    }
4335

4336
    cJSON* restart = cJSON_GetObjectItem(specifiedQuery, "restart");
4337
    if (restart && restart->type == cJSON_String && restart->valuestring != NULL) {
4338
      if (0 == strcmp("yes", restart->valuestring)) {
4339
        g_queryInfo.specifiedQueryInfo.subscribeRestart = true;
4340
      } else if (0 == strcmp("no", restart->valuestring)) {
4341
        g_queryInfo.specifiedQueryInfo.subscribeRestart = false;
4342
      } else {
4343
        printf("ERROR: failed to read json, subscribe restart error\n");
4344 4345 4346
        goto PARSE_OVER;
      }
    } else {
4347
      g_queryInfo.specifiedQueryInfo.subscribeRestart = true;
4348
    }
4349

4350
    cJSON* keepProgress = cJSON_GetObjectItem(specifiedQuery, "keepProgress");
4351
    if (keepProgress
4352 4353
            && keepProgress->type == cJSON_String
            && keepProgress->valuestring != NULL) {
4354
      if (0 == strcmp("yes", keepProgress->valuestring)) {
4355
        g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 1;
4356
      } else if (0 == strcmp("no", keepProgress->valuestring)) {
4357
        g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
4358
      } else {
4359
        printf("ERROR: failed to read json, subscribe keepProgress error\n");
4360 4361 4362
        goto PARSE_OVER;
      }
    } else {
4363
      g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
4364 4365
    }

4366
    // sqls
4367 4368
    cJSON* specifiedSqls = cJSON_GetObjectItem(specifiedQuery, "sqls");
    if (!specifiedSqls) {
4369
      g_queryInfo.specifiedQueryInfo.sqlCount = 0;
4370
    } else if (specifiedSqls->type != cJSON_Array) {
4371
      errorPrint("%s() LN%d, failed to read json, super sqls not found\n",
4372
          __func__, __LINE__);
4373
      goto PARSE_OVER;
4374
    } else {
4375 4376 4377 4378 4379 4380 4381 4382
      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);
4383 4384
        goto PARSE_OVER;
      }
4385

4386
      g_queryInfo.specifiedQueryInfo.sqlCount = superSqlSize;
4387
      for (int j = 0; j < superSqlSize; ++j) {
4388
        cJSON* sql = cJSON_GetArrayItem(specifiedSqls, j);
4389
        if (sql == NULL) continue;
4390

4391 4392
        cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
        if (!sqlStr || sqlStr->type != cJSON_String || sqlStr->valuestring == NULL) {
4393
          printf("ERROR: failed to read json, sql not found\n");
4394 4395
          goto PARSE_OVER;
        }
4396 4397
        tstrncpy(g_queryInfo.specifiedQueryInfo.sql[j],
                sqlStr->valuestring, MAX_QUERY_SQL_LENGTH);
H
hzcheng 已提交
4398

4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409
        cJSON* endAfterConsume =
            cJSON_GetObjectItem(specifiedQuery, "endAfterConsume");
        if (endAfterConsume
                && endAfterConsume->type == cJSON_Number) {
            g_queryInfo.specifiedQueryInfo.endAfterConsume[j]
                = endAfterConsume->valueint;
        } else if (!endAfterConsume) {
            // default value is -1, which mean infinite loop
            g_queryInfo.specifiedQueryInfo.endAfterConsume[j] = -1;
        }

4410 4411
        cJSON* resubAfterConsume =
            cJSON_GetObjectItem(specifiedQuery, "resubAfterConsume");
4412 4413 4414
        if ((resubAfterConsume)
                && (resubAfterConsume->type == cJSON_Number)
                && (resubAfterConsume->valueint >= 0)) {
4415 4416 4417
            g_queryInfo.specifiedQueryInfo.resubAfterConsume[j]
                = resubAfterConsume->valueint;
        } else if (!resubAfterConsume) {
4418 4419
            // default value is -1, which mean do not resub
            g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] = -1;
4420 4421
        }

4422
        cJSON *result = cJSON_GetObjectItem(sql, "result");
4423 4424 4425 4426
        if ((NULL != result) && (result->type == cJSON_String)
                && (result->valuestring != NULL)) {
          tstrncpy(g_queryInfo.specifiedQueryInfo.result[j],
                  result->valuestring, MAX_FILE_NAME_LEN);
4427
        } else if (NULL == result) {
4428 4429
          memset(g_queryInfo.specifiedQueryInfo.result[j],
                  0, MAX_FILE_NAME_LEN);
4430
        } else {
4431
          printf("ERROR: failed to read json, super query result file not found\n");
4432
          goto PARSE_OVER;
4433
        }
4434 4435 4436
      }
    }
  }
4437

4438
  // super_table_query
4439 4440
  cJSON *superQuery = cJSON_GetObjectItem(root, "super_table_query");
  if (!superQuery) {
4441
    g_queryInfo.superQueryInfo.threadCnt = 1;
4442 4443
    g_queryInfo.superQueryInfo.sqlCount = 0;
  } else if (superQuery->type != cJSON_Object) {
4444
    printf("ERROR: failed to read json, sub_table_query not found\n");
4445 4446
    ret = true;
    goto PARSE_OVER;
H
hzcheng 已提交
4447
  } else {
4448
    cJSON* subrate = cJSON_GetObjectItem(superQuery, "query_interval");
4449
    if (subrate && subrate->type == cJSON_Number) {
4450
      g_queryInfo.superQueryInfo.queryInterval = subrate->valueint;
4451
    } else if (!subrate) {
4452
      g_queryInfo.superQueryInfo.queryInterval = 0;
4453 4454 4455 4456
    }

    cJSON* superQueryTimes = cJSON_GetObjectItem(superQuery, "query_times");
    if (superQueryTimes && superQueryTimes->type == cJSON_Number) {
4457 4458
      if (superQueryTimes->valueint <= 0) {
        errorPrint("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
4459
          __func__, __LINE__, superQueryTimes->valueint);
4460 4461
        goto PARSE_OVER;
      }
4462 4463 4464 4465
      g_queryInfo.superQueryInfo.queryTimes = superQueryTimes->valueint;
    } else if (!superQueryTimes) {
      g_queryInfo.superQueryInfo.queryTimes = g_args.query_times;
    } else {
4466
      errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
4467
          __func__, __LINE__);
4468
      goto PARSE_OVER;
4469
    }
4470

4471
    cJSON* threads = cJSON_GetObjectItem(superQuery, "threads");
4472
    if (threads && threads->type == cJSON_Number) {
4473 4474 4475 4476 4477 4478
      if (threads->valueint <= 0) {
        errorPrint("%s() LN%d, failed to read json, threads input mistake\n",
          __func__, __LINE__);
        goto PARSE_OVER;

      }
4479
      g_queryInfo.superQueryInfo.threadCnt = threads->valueint;
4480
    } else if (!threads) {
4481
      g_queryInfo.superQueryInfo.threadCnt = 1;
4482
    }
4483

4484
    //cJSON* subTblCnt = cJSON_GetObjectItem(superQuery, "childtable_count");
4485
    //if (subTblCnt && subTblCnt->type == cJSON_Number) {
4486
    //  g_queryInfo.superQueryInfo.childTblCount = subTblCnt->valueint;
4487
    //} else if (!subTblCnt) {
4488
    //  g_queryInfo.superQueryInfo.childTblCount = 0;
4489
    //}
4490

4491
    cJSON* stblname = cJSON_GetObjectItem(superQuery, "stblname");
4492 4493 4494
    if (stblname && stblname->type == cJSON_String
        && stblname->valuestring != NULL) {
      tstrncpy(g_queryInfo.superQueryInfo.sTblName, stblname->valuestring,
4495
          MAX_TB_NAME_SIZE);
4496
    } else {
4497
      errorPrint("%s() LN%d, failed to read json, super table name input error\n",
4498
          __func__, __LINE__);
4499 4500
      goto PARSE_OVER;
    }
4501

4502 4503 4504 4505 4506 4507 4508
    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;
4509
      } else {
4510
        errorPrint("%s() LN%d, failed to read json, async mode input error\n",
4511
            __func__, __LINE__);
4512 4513 4514
        goto PARSE_OVER;
      }
    } else {
4515
      g_queryInfo.superQueryInfo.asyncMode = SYNC_MODE;
4516
    }
4517

4518 4519 4520 4521 4522 4523 4524 4525 4526
    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) {
4527 4528
      //printf("failed to read json, subscribe interval no found\n");
      //goto PARSE_OVER;
4529
      g_queryInfo.superQueryInfo.subscribeInterval = 10000;
4530
    }
4531

4532
    cJSON* subrestart = cJSON_GetObjectItem(superQuery, "restart");
4533 4534
    if (subrestart && subrestart->type == cJSON_String
        && subrestart->valuestring != NULL) {
4535
      if (0 == strcmp("yes", subrestart->valuestring)) {
4536
        g_queryInfo.superQueryInfo.subscribeRestart = true;
4537
      } else if (0 == strcmp("no", subrestart->valuestring)) {
4538
        g_queryInfo.superQueryInfo.subscribeRestart = false;
4539
      } else {
4540
        printf("ERROR: failed to read json, subscribe restart error\n");
4541 4542 4543
        goto PARSE_OVER;
      }
    } else {
4544
      g_queryInfo.superQueryInfo.subscribeRestart = true;
4545
    }
4546

4547 4548 4549 4550 4551
    cJSON* superkeepProgress = cJSON_GetObjectItem(superQuery, "keepProgress");
    if (superkeepProgress &&
            superkeepProgress->type == cJSON_String
            && superkeepProgress->valuestring != NULL) {
      if (0 == strcmp("yes", superkeepProgress->valuestring)) {
4552
        g_queryInfo.superQueryInfo.subscribeKeepProgress = 1;
4553
      } else if (0 == strcmp("no", superkeepProgress->valuestring)) {
4554
        g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
4555
      } else {
4556
        printf("ERROR: failed to read json, subscribe super table keepProgress error\n");
4557 4558 4559
        goto PARSE_OVER;
      }
    } else {
4560
      g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
4561
    }
4562

4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573
    cJSON* superEndAfterConsume =
            cJSON_GetObjectItem(superQuery, "endAfterConsume");
    if (superEndAfterConsume
            && superEndAfterConsume->type == cJSON_Number) {
        g_queryInfo.superQueryInfo.endAfterConsume =
            superEndAfterConsume->valueint;
    } else if (!superEndAfterConsume) {
        // default value is -1, which mean do not resub
        g_queryInfo.superQueryInfo.endAfterConsume = -1;
    }

4574
    cJSON* superResubAfterConsume =
4575 4576 4577 4578 4579
            cJSON_GetObjectItem(superQuery, "resubAfterConsume");
    if ((superResubAfterConsume)
            && (superResubAfterConsume->type == cJSON_Number)
            && (superResubAfterConsume->valueint >= 0)) {
        g_queryInfo.superQueryInfo.resubAfterConsume =
4580 4581
            superResubAfterConsume->valueint;
    } else if (!superResubAfterConsume) {
4582
        // default value is -1, which mean do not resub
4583
        g_queryInfo.superQueryInfo.resubAfterConsume = -1;
4584 4585
    }

4586 4587 4588
    // supert table sqls
    cJSON* superSqls = cJSON_GetObjectItem(superQuery, "sqls");
    if (!superSqls) {
4589
      g_queryInfo.superQueryInfo.sqlCount = 0;
4590
    } else if (superSqls->type != cJSON_Array) {
4591
      errorPrint("%s() LN%d: failed to read json, super sqls not found\n",
4592
          __func__, __LINE__);
4593
      goto PARSE_OVER;
4594
    } else {
4595
      int superSqlSize = cJSON_GetArraySize(superSqls);
4596
      if (superSqlSize > MAX_QUERY_SQL_COUNT) {
4597
        errorPrint("%s() LN%d, failed to read json, query sql size overflow, max is %d\n",
4598
           __func__, __LINE__, MAX_QUERY_SQL_COUNT);
4599 4600
        goto PARSE_OVER;
      }
4601

4602
      g_queryInfo.superQueryInfo.sqlCount = superSqlSize;
4603
      for (int j = 0; j < superSqlSize; ++j) {
4604
        cJSON* sql = cJSON_GetArrayItem(superSqls, j);
4605
        if (sql == NULL) continue;
4606

4607
        cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
4608 4609 4610
        if (!sqlStr || sqlStr->type != cJSON_String
            || sqlStr->valuestring == NULL) {
          errorPrint("%s() LN%d, failed to read json, sql not found\n",
4611
              __func__, __LINE__);
4612 4613
          goto PARSE_OVER;
        }
4614
        tstrncpy(g_queryInfo.superQueryInfo.sql[j], sqlStr->valuestring,
4615
            MAX_QUERY_SQL_LENGTH);
4616 4617

        cJSON *result = cJSON_GetObjectItem(sql, "result");
4618 4619 4620
        if (result != NULL && result->type == cJSON_String
            && result->valuestring != NULL){
          tstrncpy(g_queryInfo.superQueryInfo.result[j],
4621
              result->valuestring, MAX_FILE_NAME_LEN);
4622
        } else if (NULL == result) {
4623
          memset(g_queryInfo.superQueryInfo.result[j], 0, MAX_FILE_NAME_LEN);
4624
        }  else {
4625
          errorPrint("%s() LN%d, failed to read json, sub query result file not found\n",
4626
              __func__, __LINE__);
4627
          goto PARSE_OVER;
4628
        }
4629 4630
      }
    }
H
hzcheng 已提交
4631 4632
  }

4633
  ret = true;
H
hzcheng 已提交
4634

4635
PARSE_OVER:
4636 4637
  return ret;
}
H
hzcheng 已提交
4638

4639
static bool getInfoFromJsonFile(char* file) {
4640
    debugPrint("%s %d %s\n", __func__, __LINE__, file);
4641

4642 4643 4644 4645 4646
  FILE *fp = fopen(file, "r");
  if (!fp) {
    printf("failed to read %s, reason:%s\n", file, strerror(errno));
    return false;
  }
H
Hui Li 已提交
4647

4648
  bool  ret = false;
4649
  int   maxLen = 6400000;
4650 4651 4652 4653 4654 4655 4656
  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
hzcheng 已提交
4657
  }
H
Hui Li 已提交
4658

4659 4660 4661
  content[len] = 0;
  cJSON* root = cJSON_Parse(content);
  if (root == NULL) {
4662
    printf("ERROR: failed to cjson parse %s, invalid json format\n", file);
4663 4664
    goto PARSE_OVER;
  }
H
Hui Li 已提交
4665

4666 4667 4668
  cJSON* filetype = cJSON_GetObjectItem(root, "filetype");
  if (filetype && filetype->type == cJSON_String && filetype->valuestring != NULL) {
    if (0 == strcasecmp("insert", filetype->valuestring)) {
4669
      g_args.test_mode = INSERT_TEST;
4670
    } else if (0 == strcasecmp("query", filetype->valuestring)) {
4671
      g_args.test_mode = QUERY_TEST;
4672
    } else if (0 == strcasecmp("subscribe", filetype->valuestring)) {
4673
      g_args.test_mode = SUBSCRIBE_TEST;
4674
    } else {
4675
      printf("ERROR: failed to read json, filetype not support\n");
4676 4677 4678
      goto PARSE_OVER;
    }
  } else if (!filetype) {
4679
    g_args.test_mode = INSERT_TEST;
4680
  } else {
4681
    printf("ERROR: failed to read json, filetype not found\n");
4682 4683
    goto PARSE_OVER;
  }
H
hzcheng 已提交
4684

4685
  if (INSERT_TEST == g_args.test_mode) {
4686
    ret = getMetaFromInsertJsonFile(root);
4687
  } else if ((QUERY_TEST == g_args.test_mode)
4688
          || (SUBSCRIBE_TEST == g_args.test_mode)) {
4689 4690
    ret = getMetaFromQueryJsonFile(root);
  } else {
4691
    errorPrint("%s() LN%d, input json file type error! please input correct file type: insert or query or subscribe\n",
4692
            __func__, __LINE__);
4693
    goto PARSE_OVER;
4694
  }
4695

4696
PARSE_OVER:
4697 4698
  free(content);
  cJSON_Delete(root);
H
hzcheng 已提交
4699
  fclose(fp);
4700 4701
  return ret;
}
H
hzcheng 已提交
4702

4703
static void prepareSampleData() {
4704
  for (int i = 0; i < g_Dbs.dbCount; i++) {
4705 4706 4707
    for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
      if (g_Dbs.db[i].superTbls[j].tagsFile[0] != 0) {
        (void)readTagFromCsvFileToMem(&g_Dbs.db[i].superTbls[j]);
S
Shuaiqiang Chang 已提交
4708
      }
4709 4710 4711 4712
    }
  }
}

4713
static void postFreeResource() {
4714
  tmfclose(g_fpOfInsertResult);
4715
  for (int i = 0; i < g_Dbs.dbCount; i++) {
S
Shuduo Sang 已提交
4716
    for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
4717 4718 4719
      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;
S
Shuaiqiang Chang 已提交
4720
      }
4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732
      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 已提交
4733
    }
4734 4735
  }
}
S
Shuaiqiang Chang 已提交
4736

4737 4738 4739
static int getRowDataFromSample(
        char* dataBuf, int64_t maxLen, int64_t timestamp,
      SSuperTable* superTblInfo, int64_t* sampleUsePos) {
4740
  if ((*sampleUsePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
4741
/*    int ret = readSampleFromCsvFileToMem(superTblInfo);
4742
    if (0 != ret) {
4743
      tmfree(superTblInfo->sampleDataBuf);
4744
      superTblInfo->sampleDataBuf = NULL;
4745 4746
      return -1;
    }
4747
*/
4748 4749
    *sampleUsePos = 0;
  }
S
Shuaiqiang Chang 已提交
4750

4751
  int    dataLen = 0;
4752

4753
  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
4754
          "(%" PRId64 ", ", timestamp);
4755
  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
4756
          "%s", superTblInfo->sampleDataBuf + superTblInfo->lenOfOneRow * (*sampleUsePos));
4757
  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen, ")");
S
Shuaiqiang Chang 已提交
4758

4759
  (*sampleUsePos)++;
4760

4761 4762
  return dataLen;
}
S
Shuaiqiang Chang 已提交
4763

4764 4765
static int64_t generateStbRowData(
        SSuperTable* stbInfo,
4766 4767
        char* recBuf, int64_t timestamp)
{
4768
  int64_t   dataLen = 0;
4769
  char  *pstr = recBuf;
4770
  int64_t maxLen = MAX_DATA_SIZE;
4771

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

4775
  for (int i = 0; i < stbInfo->columnCount; i++) {
4776 4777 4778 4779
    if ((0 == strncasecmp(stbInfo->columns[i].dataType,
                    "BINARY", strlen("BINARY")))
            || (0 == strncasecmp(stbInfo->columns[i].dataType,
                    "NCHAR", strlen("NCHAR")))) {
4780
      if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
4781
        errorPrint( "binary or nchar length overflow, max size:%u\n",
4782
                (uint32_t)TSDB_MAX_BINARY_LEN);
4783
        return -1;
4784
      }
4785

4786 4787
      char* buf = (char*)calloc(stbInfo->columns[i].dataLen+1, 1);
      if (NULL == buf) {
4788
        errorPrint( "calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
4789
        return -1;
4790 4791
      }
      rand_string(buf, stbInfo->columns[i].dataLen);
4792
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
4793
      tmfree(buf);
4794
    } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4795
                "INT", strlen("INT"))) {
4796
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4797
              "%d,", rand_int());
4798
    } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4799
                "BIGINT", strlen("BIGINT"))) {
4800
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4801
              "%"PRId64",", rand_bigint());
4802
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4803
                "FLOAT", strlen("FLOAT"))) {
4804
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4805
              "%f,", rand_float());
4806
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4807
                "DOUBLE", strlen("DOUBLE"))) {
4808
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4809
              "%f,", rand_double());
4810
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4811
                "SMALLINT", strlen("SMALLINT"))) {
4812
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4813
          "%d,", rand_smallint());
4814
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4815
          "TINYINT", strlen("TINYINT"))) {
4816
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4817
          "%d,", rand_tinyint());
4818
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4819
          "BOOL", strlen("BOOL"))) {
4820
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4821
          "%d,", rand_bool());
4822
    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
4823
          "TIMESTAMP", strlen("TIMESTAMP"))) {
4824
      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
4825
          "%"PRId64",", rand_bigint());
4826
    }  else {
4827
      errorPrint( "No support data type: %s\n", stbInfo->columns[i].dataType);
4828
      return -1;
4829
    }
S
Shuaiqiang Chang 已提交
4830
  }
4831

4832
  dataLen -= 1;
4833
  dataLen += snprintf(pstr + dataLen, maxLen - dataLen, ")");
4834

4835 4836 4837
  verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);

  return strlen(recBuf);
4838
}
S
Shuaiqiang Chang 已提交
4839

4840
static int64_t generateData(char *recBuf, char **data_type,
4841
        int64_t timestamp, int lenOfBinary) {
4842 4843
  memset(recBuf, 0, MAX_DATA_SIZE);
  char *pstr = recBuf;
4844 4845
  pstr += sprintf(pstr, "(%" PRId64, timestamp);

4846
  int columnCount = g_args.num_of_CPR;
4847

4848 4849
  for (int i = 0; i < columnCount; i++) {
    if (strcasecmp(data_type[i % columnCount], "TINYINT") == 0) {
4850
      pstr += sprintf(pstr, ",%d", rand_tinyint() );
4851
    } else if (strcasecmp(data_type[i % columnCount], "SMALLINT") == 0) {
4852
      pstr += sprintf(pstr, ",%d", rand_smallint());
4853
    } else if (strcasecmp(data_type[i % columnCount], "INT") == 0) {
4854
      pstr += sprintf(pstr, ",%d", rand_int());
4855
    } else if (strcasecmp(data_type[i % columnCount], "BIGINT") == 0) {
4856
      pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
4857
    } else if (strcasecmp(data_type[i % columnCount], "TIMESTAMP") == 0) {
4858
      pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
4859
    } else if (strcasecmp(data_type[i % columnCount], "FLOAT") == 0) {
4860
      pstr += sprintf(pstr, ",%10.4f", rand_float());
4861
    } else if (strcasecmp(data_type[i % columnCount], "DOUBLE") == 0) {
4862
      double t = rand_double();
4863
      pstr += sprintf(pstr, ",%20.8f", t);
4864
    } else if (strcasecmp(data_type[i % columnCount], "BOOL") == 0) {
4865
      bool b = rand_bool() & 1;
4866
      pstr += sprintf(pstr, ",%s", b ? "true" : "false");
4867
    } else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
4868 4869
      char *s = malloc(lenOfBinary);
      rand_string(s, lenOfBinary);
4870
      pstr += sprintf(pstr, ",\"%s\"", s);
4871
      free(s);
4872
    } else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
4873 4874
      char *s = malloc(lenOfBinary);
      rand_string(s, lenOfBinary);
4875
      pstr += sprintf(pstr, ",\"%s\"", s);
4876 4877 4878
      free(s);
    }

4879
    if (strlen(recBuf) > MAX_DATA_SIZE) {
4880 4881 4882 4883 4884 4885 4886
      perror("column length too long, abort");
      exit(-1);
    }
  }

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

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

4889
  return (int32_t)strlen(recBuf);
4890 4891
}

4892
static int prepareSampleDataForSTable(SSuperTable *superTblInfo) {
4893 4894
  char* sampleDataBuf = NULL;

4895
  sampleDataBuf = calloc(
4896
            superTblInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE, 1);
4897
  if (sampleDataBuf == NULL) {
4898
      errorPrint("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
4899 4900 4901 4902
              __func__, __LINE__,
              superTblInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE,
              strerror(errno));
      return -1;
4903
  }
4904

4905 4906 4907 4908
  superTblInfo->sampleDataBuf = sampleDataBuf;
  int ret = readSampleFromCsvFileToMem(superTblInfo);

  if (0 != ret) {
4909 4910 4911 4912 4913
      errorPrint("%s() LN%d, read sample from csv file failed.\n",
          __func__, __LINE__);
      tmfree(sampleDataBuf);
      superTblInfo->sampleDataBuf = NULL;
      return -1;
H
Hui Li 已提交
4914
  }
4915

4916 4917 4918
  return 0;
}

4919
static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
4920
{
4921 4922
    int32_t affectedRows;
    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
4923

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

4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946
    uint16_t iface;
    if (superTblInfo)
        iface = superTblInfo->iface;
    else
        iface = g_args.iface;

    debugPrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
            __func__, __LINE__,
            (g_args.iface==TAOSC_IFACE)?
            "taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");

    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,
4947
                        pThreadInfo->buffer, pThreadInfo)) {
4948 4949 4950 4951 4952 4953 4954 4955
                affectedRows = -1;
                printf("========restful return fail, threadID[%d]\n",
                        pThreadInfo->threadID);
            } else {
                affectedRows = k;
            }
            break;

4956
#if STMT_IFACE_ENABLED == 1
4957 4958 4959 4960 4961 4962 4963 4964 4965
        case STMT_IFACE:
            debugPrint("%s() LN%d, stmt=%p", __func__, __LINE__, pThreadInfo->stmt);
            if (0 != taos_stmt_execute(pThreadInfo->stmt)) {
                errorPrint("%s() LN%d, failied to execute insert statement\n",
                        __func__, __LINE__);
                exit(-1);
            }
            affectedRows = k;
            break;
4966
#endif
4967 4968 4969 4970 4971

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

4974
    return affectedRows;
4975 4976
}

4977 4978
static void getTableName(char *pTblName,
        threadInfo* pThreadInfo, uint64_t tableSeq)
4979
{
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998
    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);
        }
4999
    } else {
5000 5001
        snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
                g_args.tb_prefix, tableSeq);
5002 5003 5004
    }
}

5005
static int32_t generateDataTailWithoutStb(
5006
        uint32_t batch, char* buffer,
5007
        int64_t remainderBufLen, int64_t insertRows,
5008
        uint64_t recordFrom, int64_t startTime,
5009
        /* int64_t *pSamplePos, */int64_t *dataLen) {
5010

5011
  uint64_t len = 0;
5012 5013
  char *pstr = buffer;

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

5016
  int32_t k = 0;
5017
  for (k = 0; k < batch;) {
5018
    char data[MAX_DATA_SIZE];
5019 5020
    memset(data, 0, MAX_DATA_SIZE);

5021
    int64_t retLen = 0;
5022

5023 5024
    char **data_type = g_args.datatype;
    int lenOfBinary = g_args.len_of_binary;
5025

5026
    retLen = generateData(data, data_type,
5027
            startTime + getTSRandTail(
5028
                (int64_t) DEFAULT_TIMESTAMP_STEP, k,
5029 5030
                g_args.disorderRatio,
                g_args.disorderRange),
5031
            lenOfBinary);
5032

5033
    if (len > remainderBufLen)
5034
        break;
5035

5036 5037 5038 5039 5040
    pstr += sprintf(pstr, "%s", data);
    k++;
    len += retLen;
    remainderBufLen -= retLen;

5041
    verbosePrint("%s() LN%d len=%"PRIu64" k=%d \nbuffer=%s\n",
5042
            __func__, __LINE__, len, k, buffer);
5043

5044
    recordFrom ++;
5045

5046
    if (recordFrom >= insertRows) {
5047 5048 5049
      break;
    }
  }
5050

5051 5052 5053 5054
  *dataLen = len;
  return k;
}

5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071
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(
5072
        SSuperTable* superTblInfo,
5073
        uint32_t batch, char* buffer,
5074
        int64_t remainderBufLen, int64_t insertRows,
5075
        uint64_t recordFrom, int64_t startTime,
5076 5077 5078 5079 5080
        int64_t *pSamplePos, int64_t *dataLen) {
  uint64_t len = 0;

  char *pstr = buffer;

5081 5082 5083 5084 5085 5086
  bool tsRand;
  if (0 == strncasecmp(superTblInfo->dataSource, "rand", strlen("rand"))) {
      tsRand = true;
  } else {
      tsRand = false;
  }
5087
  verbosePrint("%s() LN%d batch=%u\n", __func__, __LINE__, batch);
5088

5089
  int32_t k = 0;
5090 5091 5092 5093 5094 5095
  for (k = 0; k < batch;) {
    char data[MAX_DATA_SIZE];
    memset(data, 0, MAX_DATA_SIZE);

    int64_t retLen = 0;

5096 5097 5098 5099 5100 5101 5102 5103 5104
    if (tsRand) {
        retLen = generateStbRowData(superTblInfo, data,
                startTime + getTSRandTail(
                    superTblInfo->timeStampStep, k,
                    superTblInfo->disorderRatio,
                    superTblInfo->disorderRange)
                );
    } else {
        retLen = getRowDataFromSample(
5105 5106 5107 5108 5109 5110
                  data,
                  remainderBufLen,
                  startTime + superTblInfo->timeStampStep * k,
                  superTblInfo,
                  pSamplePos);
    }
5111

5112
    if (retLen > remainderBufLen) {
5113
        break;
5114 5115
    }

5116 5117 5118 5119 5120
    pstr += snprintf(pstr , retLen + 1, "%s", data);
    k++;
    len += retLen;
    remainderBufLen -= retLen;

5121
    verbosePrint("%s() LN%d len=%"PRIu64" k=%u \nbuffer=%s\n",
5122
            __func__, __LINE__, len, k, buffer);
5123

5124
    recordFrom ++;
5125

5126
    if (recordFrom >= insertRows) {
5127
      break;
5128
    }
5129
  }
5130

5131 5132 5133
  *dataLen = len;
  return k;
}
5134

5135 5136 5137

static int generateSQLHeadWithoutStb(char *tableName,
        char *dbName,
5138
        char *buffer, int remainderBufLen)
5139 5140
{
  int len;
5141 5142 5143

  char headBuf[HEAD_BUFF_LEN];

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
  len = snprintf(
          headBuf,
          HEAD_BUFF_LEN,
          "%s.%s values",
          dbName,
          tableName);

  if (len > remainderBufLen)
    return -1;

  tstrncpy(buffer, headBuf, len + 1);

  return len;
}

static int generateStbSQLHead(
        SSuperTable* superTblInfo,
        char *tableName, int32_t tableSeq,
        char *dbName,
        char *buffer, int remainderBufLen)
{
  int len;

  char headBuf[HEAD_BUFF_LEN];

  if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) {
5170 5171
      char* tagsValBuf = NULL;
      if (0 == superTblInfo->tagSource) {
5172
            tagsValBuf = generateTagVaulesForStb(superTblInfo, tableSeq);
5173
      } else {
5174 5175 5176
            tagsValBuf = getTagValueFromTagSample(
                    superTblInfo,
                    tableSeq % superTblInfo->tagSampleCount);
5177 5178
      }
      if (NULL == tagsValBuf) {
5179
        errorPrint("%s() LN%d, tag buf failed to allocate  memory\n",
5180
            __func__, __LINE__);
5181 5182 5183
        return -1;
      }

5184 5185
      len = snprintf(
          headBuf,
5186 5187
                  HEAD_BUFF_LEN,
                  "%s.%s using %s.%s tags %s values",
5188
                  dbName,
5189
                  tableName,
5190
                  dbName,
5191 5192
                  superTblInfo->sTblName,
                  tagsValBuf);
5193 5194
      tmfree(tagsValBuf);
    } else if (TBL_ALREADY_EXISTS == superTblInfo->childTblExists) {
5195 5196
      len = snprintf(
          headBuf,
5197 5198
                  HEAD_BUFF_LEN,
                  "%s.%s values",
5199
                  dbName,
5200
                  tableName);
5201
    } else {
5202 5203
      len = snprintf(
          headBuf,
5204 5205
                  HEAD_BUFF_LEN,
                  "%s.%s values",
5206
                  dbName,
5207
                  tableName);
5208 5209
  }

5210 5211 5212 5213 5214
  if (len > remainderBufLen)
    return -1;

  tstrncpy(buffer, headBuf, len + 1);

5215 5216 5217
  return len;
}

5218
static int32_t generateStbInterlaceData(
5219
        SSuperTable *superTblInfo,
5220 5221 5222
        char *tableName, uint32_t batchPerTbl,
        uint64_t i,
        uint32_t batchPerTblTimes,
5223
        uint64_t tableSeq,
5224
        threadInfo *pThreadInfo, char *buffer,
5225
        int64_t insertRows,
5226
        int64_t startTime,
5227
        uint64_t *pRemainderBufLen)
5228
{
5229
  assert(buffer);
5230 5231
  char *pstr = buffer;

5232 5233 5234
  int headLen = generateStbSQLHead(
          superTblInfo,
          tableName, tableSeq, pThreadInfo->db_name,
5235
          pstr, *pRemainderBufLen);
5236 5237 5238 5239 5240

  if (headLen <= 0) {
    return 0;
  }
  // generate data buffer
5241
  verbosePrint("[%d] %s() LN%d i=%"PRIu64" buffer:\n%s\n",
5242
            pThreadInfo->threadID, __func__, __LINE__, i, buffer);
5243 5244 5245 5246

  pstr += headLen;
  *pRemainderBufLen -= headLen;

5247
  int64_t dataLen = 0;
5248

5249
  verbosePrint("[%d] %s() LN%d i=%"PRIu64" batchPerTblTimes=%u batchPerTbl = %u\n",
5250 5251
            pThreadInfo->threadID, __func__, __LINE__,
            i, batchPerTblTimes, batchPerTbl);
5252

5253
  if (0 == strncasecmp(superTblInfo->startTimestamp, "now", 3)) {
5254
      startTime = taosGetTimestamp(pThreadInfo->time_precision);
5255
  }
5256

5257
  int32_t k = generateStbDataTail(
5258 5259 5260 5261
            superTblInfo,
            batchPerTbl, pstr, *pRemainderBufLen, insertRows, 0,
            startTime,
            &(pThreadInfo->samplePos), &dataLen);
5262 5263 5264 5265

  if (k == batchPerTbl) {
    pstr += dataLen;
    *pRemainderBufLen -= dataLen;
5266
  } else {
5267
    debugPrint("%s() LN%d, generated data tail: %u, not equal batch per table: %u\n",
5268 5269 5270 5271 5272 5273 5274 5275 5276 5277
            __func__, __LINE__, k, batchPerTbl);
    pstr -= headLen;
    pstr[0] = '\0';
    k = 0;
  }

  return k;
}

static int64_t generateInterlaceDataWithoutStb(
5278
        char *tableName, uint32_t batch,
5279 5280 5281
        uint64_t tableSeq,
        char *dbName, char *buffer,
        int64_t insertRows,
5282
        int64_t startTime,
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300
        uint64_t *pRemainderBufLen)
{
  assert(buffer);
  char *pstr = buffer;

  int headLen = generateSQLHeadWithoutStb(
          tableName, dbName,
            pstr, *pRemainderBufLen);

  if (headLen <= 0) {
    return 0;
  }

  pstr += headLen;
  *pRemainderBufLen -= headLen;

  int64_t dataLen = 0;

5301 5302
  int32_t k = generateDataTailWithoutStb(
            batch, pstr, *pRemainderBufLen, insertRows, 0,
5303
            startTime,
5304
            &dataLen);
5305

5306
  if (k == batch) {
5307 5308 5309
    pstr += dataLen;
    *pRemainderBufLen -= dataLen;
  } else {
5310 5311
    debugPrint("%s() LN%d, generated data tail: %d, not equal batch per table: %u\n",
            __func__, __LINE__, k, batch);
5312 5313
    pstr -= headLen;
    pstr[0] = '\0';
5314
    k = 0;
5315 5316 5317 5318 5319
  }

  return k;
}

5320
#if STMT_IFACE_ENABLED == 1
5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462
static int32_t prepareStmtBindArrayByType(TAOS_BIND *bind,
        char *dataType, int32_t dataLen, char **ptr)
{
    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;
        rand_string(bind_binary, dataLen);

        bind->buffer_type = TSDB_DATA_TYPE_BINARY;
        bind->buffer_length = dataLen;
        bind->buffer = bind_binary;
        bind->length = &bind->buffer_length;
        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;
        rand_string(bind_nchar, dataLen);

        bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
        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;

        *bind_int = rand_int();
        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;

        *bind_bigint = rand_bigint();
        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;

        *bind_float = rand_float();
        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;

        *bind_double = rand_double();
        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;

        *bind_smallint = rand_smallint();
        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;

        *bind_tinyint = rand_tinyint();
        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;

        *bind_ts2 = rand_bigint();
        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 {
        errorPrint( "No support data type: %s\n",
                dataType);
        return -1;
    }

    return 0;
}

static int32_t prepareStmtWithoutStb(
5463
        TAOS_STMT *stmt,
5464 5465 5466 5467 5468
        char *tableName,
        uint32_t batch,
        int64_t insertRows,
        int64_t recordFrom,
        int64_t startTime)
5469
{
5470 5471 5472 5473 5474 5475 5476 5477
    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",
                tableName, ret, taos_errstr(NULL));
        return ret;
    }

    char **data_type = g_args.datatype;
5478

5479 5480 5481 5482 5483
    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;
5484 5485
    }

5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530
    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;
        *bind_ts = startTime + getTSRandTail(
                (int64_t)DEFAULT_TIMESTAMP_STEP, k,
                g_args.disorderRatio,
                g_args.disorderRange);
        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 ++) {
            bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * (i + 1)));
            if ( -1 == prepareStmtBindArrayByType(
                        bind,
                        data_type[i],
                        g_args.len_of_binary,
                        &ptr)) {
                return -1;
            }
        }
        taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
        // if msg > 3MB, break
        taos_stmt_add_batch(stmt);

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

5531
    free(bindArray);
5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545
    return k;
}

static int32_t prepareStbStmt(SSuperTable *stbInfo,
        TAOS_STMT *stmt,
        char *tableName, uint32_t batch,
        uint64_t insertRows,
        uint64_t recordFrom,
        int64_t startTime, char *buffer)
{
    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",
                tableName, ret, taos_errstr(NULL));
5546 5547 5548
        return ret;
    }

5549
    char *bindArray = malloc(sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
5550
    if (bindArray == NULL) {
5551 5552
        errorPrint("Failed to allocate %d bind params\n",
                (stbInfo->columnCount + 1));
5553 5554 5555 5556 5557 5558 5559 5560 5561
        return -1;
    }

    bool tsRand;
    if (0 == strncasecmp(stbInfo->dataSource, "rand", strlen("rand"))) {
        tsRand = true;
    } else {
        tsRand = false;
    }
5562 5563

    uint32_t k;
5564
    for (k = 0; k < batch;) {
5565
        /* columnCount + 1 (ts) */
5566 5567 5568 5569 5570
        char data[MAX_DATA_SIZE];
        memset(data, 0, MAX_DATA_SIZE);

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

5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592
        int64_t *bind_ts;

        bind_ts = (int64_t *)ptr;
        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
        if (tsRand) {
            *bind_ts = startTime + getTSRandTail(
                    stbInfo->timeStampStep, k,
                    stbInfo->disorderRatio,
                    stbInfo->disorderRange);
        } else {
            *bind_ts = startTime + stbInfo->timeStampStep * k;
        }
        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 < stbInfo->columnCount; i ++) {
            bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * (i + 1)));
5593 5594 5595 5596 5597 5598
            if ( -1 == prepareStmtBindArrayByType(
                        bind,
                        stbInfo->columns[i].dataType,
                        stbInfo->columns[i].dataLen,
                        &ptr)) {
                return -1;
5599 5600
            }
        }
5601
        taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
5602
        // if msg > 3MB, break
5603
        taos_stmt_add_batch(stmt);
5604

5605 5606 5607 5608 5609 5610
        k++;
        recordFrom ++;
        if (recordFrom >= insertRows) {
            break;
        }
    }
5611

5612
    free(bindArray);
5613 5614
    return k;
}
5615
#endif
5616 5617

static int32_t generateStbProgressiveData(
5618
        SSuperTable *superTblInfo,
5619
        char *tableName,
5620
        int64_t tableSeq,
5621
        char *dbName, char *buffer,
5622
        int64_t insertRows,
5623
        uint64_t recordFrom, int64_t startTime, int64_t *pSamplePos,
5624
        int64_t *pRemainderBufLen)
5625 5626
{
  assert(buffer != NULL);
5627
  char *pstr = buffer;
5628

5629
  memset(buffer, 0, *pRemainderBufLen);
5630

5631
  int64_t headLen = generateStbSQLHead(
5632
              superTblInfo,
5633
          tableName, tableSeq, dbName,
5634
          buffer, *pRemainderBufLen);
5635 5636 5637 5638

  if (headLen <= 0) {
    return 0;
  }
5639
  pstr += headLen;
5640
  *pRemainderBufLen -= headLen;
5641

5642
  int64_t dataLen;
5643

5644
  return generateStbDataTail(superTblInfo,
5645
          g_args.num_of_RPR, pstr, *pRemainderBufLen,
5646
          insertRows, recordFrom,
5647 5648
          startTime,
          pSamplePos, &dataLen);
5649 5650
}

5651
static int32_t generateProgressiveDataWithoutStb(
5652
        char *tableName,
5653
        /* int64_t tableSeq, */
5654 5655
        threadInfo *pThreadInfo, char *buffer,
        int64_t insertRows,
5656
        uint64_t recordFrom, int64_t startTime, /*int64_t *pSamplePos, */
5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676
        int64_t *pRemainderBufLen)
{
  assert(buffer != NULL);
  char *pstr = buffer;

  memset(buffer, 0, *pRemainderBufLen);

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

  if (headLen <= 0) {
    return 0;
  }
  pstr += headLen;
  *pRemainderBufLen -= headLen;

  int64_t dataLen;

  return generateDataTailWithoutStb(
5677
          g_args.num_of_RPR, pstr, *pRemainderBufLen, insertRows, recordFrom,
5678 5679
          startTime,
          /*pSamplePos, */&dataLen);
5680
}
5681

5682 5683
static void printStatPerThread(threadInfo *pThreadInfo)
{
5684
    fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
5685 5686 5687 5688 5689 5690
          pThreadInfo->threadID,
          pThreadInfo->totalInsertRows,
          pThreadInfo->totalAffectedRows,
          (double)(pThreadInfo->totalAffectedRows / (pThreadInfo->totalDelay/1000.0)));
}

5691
// sync write interlace data
5692
static void* syncWriteInterlace(threadInfo *pThreadInfo) {
5693
  debugPrint("[%d] %s() LN%d: ### interlace write\n",
5694 5695
         pThreadInfo->threadID, __func__, __LINE__);

5696
  int64_t insertRows;
5697
  uint32_t interlaceRows;
5698 5699 5700
  uint64_t maxSqlLen;
  int64_t nTimeStampStep;
  uint64_t insert_interval;
5701 5702

  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
5703

5704 5705 5706 5707 5708 5709 5710 5711 5712
  if (superTblInfo) {
    insertRows = superTblInfo->insertRows;

    if ((superTblInfo->interlaceRows == 0)
        && (g_args.interlace_rows > 0)) {
      interlaceRows = g_args.interlace_rows;
    } else {
      interlaceRows = superTblInfo->interlaceRows;
    }
5713 5714 5715
    maxSqlLen = superTblInfo->maxSqlLen;
    nTimeStampStep = superTblInfo->timeStampStep;
    insert_interval = superTblInfo->insertInterval;
5716 5717 5718
  } else {
    insertRows = g_args.num_of_DPT;
    interlaceRows = g_args.interlace_rows;
5719 5720 5721
    maxSqlLen = g_args.max_sql_len;
    nTimeStampStep = DEFAULT_TIMESTAMP_STEP;
    insert_interval = g_args.insert_interval;
5722
  }
5723

5724 5725 5726 5727 5728
  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);

5729
  if (interlaceRows > insertRows)
H
Haojun Liao 已提交
5730
    interlaceRows = insertRows;
5731

5732 5733
  if (interlaceRows > g_args.num_of_RPR)
    interlaceRows = g_args.num_of_RPR;
5734

5735 5736
  uint32_t batchPerTbl = interlaceRows;
  uint32_t batchPerTblTimes;
5737

5738 5739 5740
  if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
    batchPerTblTimes =
        g_args.num_of_RPR / interlaceRows;
5741
  } else {
5742
    batchPerTblTimes = 1;
5743 5744
  }

S
Shuduo Sang 已提交
5745 5746
  pThreadInfo->buffer = calloc(maxSqlLen, 1);
  if (NULL == pThreadInfo->buffer) {
5747
    errorPrint( "%s() LN%d, Failed to alloc %"PRIu64" Bytes, reason:%s\n",
5748
              __func__, __LINE__, maxSqlLen, strerror(errno));
5749 5750 5751 5752 5753 5754
    return NULL;
  }

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

5755 5756
  uint64_t st = 0;
  uint64_t et = UINT64_MAX;
5757

5758 5759 5760
  uint64_t lastPrintTime = taosGetTimestampMs();
  uint64_t startTs = taosGetTimestampMs();
  uint64_t endTs;
5761

5762
  uint64_t tableSeq = pThreadInfo->start_table_from;
5763 5764
  int64_t startTime = pThreadInfo->start_time;

5765
  uint64_t generatedRecPerTbl = 0;
5766
  bool flagSleep = true;
5767
  uint64_t sleepTimeTotal = 0;
5768

5769
  while(pThreadInfo->totalInsertRows < pThreadInfo->ntables * insertRows) {
5770
    if ((flagSleep) && (insert_interval)) {
5771 5772
        st = taosGetTimestampMs();
        flagSleep = false;
5773 5774
    }
    // generate data
S
Shuduo Sang 已提交
5775
    memset(pThreadInfo->buffer, 0, maxSqlLen);
5776
    uint64_t remainderBufLen = maxSqlLen;
5777

S
Shuduo Sang 已提交
5778
    char *pstr = pThreadInfo->buffer;
5779

5780 5781
    int len = snprintf(pstr,
            strlen(STR_INSERT_INTO) + 1, "%s", STR_INSERT_INTO);
5782 5783 5784
    pstr += len;
    remainderBufLen -= len;

5785
    uint32_t recOfBatch = 0;
5786

5787
    for (uint32_t i = 0; i < batchPerTblTimes; i ++) {
5788 5789
        char tableName[TSDB_TABLE_NAME_LEN];

5790
      getTableName(tableName, pThreadInfo, tableSeq);
5791 5792
      if (0 == strlen(tableName)) {
        errorPrint("[%d] %s() LN%d, getTableName return null\n",
5793
            pThreadInfo->threadID, __func__, __LINE__);
S
Shuduo Sang 已提交
5794
        free(pThreadInfo->buffer);
5795 5796
        return NULL;
      }
5797

5798
      uint64_t oldRemainderLen = remainderBufLen;
5799

5800
      int32_t generated;
5801
      if (superTblInfo) {
5802
          if (superTblInfo->iface == STMT_IFACE) {
5803
#if STMT_IFACE_ENABLED == 1
5804 5805 5806 5807 5808 5809 5810
              generated = prepareStbStmt(superTblInfo,
                      pThreadInfo->stmt,
                      tableName,
                      batchPerTbl,
                      insertRows, i,
                      startTime,
                      pThreadInfo->buffer);
5811 5812 5813
#else
              generated = -1;
#endif
5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824
          } else {
              generated = generateStbInterlaceData(
                      superTblInfo,
                      tableName, batchPerTbl, i,
                      batchPerTblTimes,
                      tableSeq,
                      pThreadInfo, pstr,
                      insertRows,
                      startTime,
                      &remainderBufLen);
          }
5825
      } else {
5826 5827 5828 5829 5830
          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);
5831
#if STMT_IFACE_ENABLED == 1
5832 5833 5834 5835 5836
              generated = prepareStmtWithoutStb(
                      pThreadInfo->stmt, tableName,
                      batchPerTbl,
                      insertRows, i,
                      startTime);
5837 5838 5839
#else
              generated = -1;
#endif
5840 5841 5842 5843 5844 5845 5846 5847 5848
          } else {
              generated = generateInterlaceDataWithoutStb(
                      tableName, batchPerTbl,
                      tableSeq,
                      pThreadInfo->db_name, pstr,
                      insertRows,
                      startTime,
                      &remainderBufLen);
          }
5849
      }
5850

5851
      debugPrint("[%d] %s() LN%d, generated records is %d\n",
5852
                  pThreadInfo->threadID, __func__, __LINE__, generated);
5853
      if (generated < 0) {
5854
        errorPrint("[%d] %s() LN%d, generated records is %d\n",
5855
                  pThreadInfo->threadID, __func__, __LINE__, generated);
5856
        goto free_of_interlace;
5857 5858
      } else if (generated == 0) {
        break;
5859 5860
      }

5861
      tableSeq ++;
5862
      recOfBatch += batchPerTbl;
5863

5864
      pstr += (oldRemainderLen - remainderBufLen);
5865
      pThreadInfo->totalInsertRows += batchPerTbl;
5866

5867
      verbosePrint("[%d] %s() LN%d batchPerTbl=%d recOfBatch=%d\n",
5868 5869
                pThreadInfo->threadID, __func__, __LINE__,
                batchPerTbl, recOfBatch);
5870

5871
      if (tableSeq == pThreadInfo->start_table_from + pThreadInfo->ntables) {
5872 5873 5874
            // turn to first table
            tableSeq = pThreadInfo->start_table_from;
            generatedRecPerTbl += batchPerTbl;
5875

5876 5877
            startTime = pThreadInfo->start_time
              + generatedRecPerTbl * nTimeStampStep;
5878

5879 5880 5881
            flagSleep = true;
            if (generatedRecPerTbl >= insertRows)
              break;
5882

5883
            int64_t remainRows = insertRows - generatedRecPerTbl;
5884 5885
            if ((remainRows > 0) && (batchPerTbl > remainRows))
              batchPerTbl = remainRows;
5886

5887 5888 5889
            if (pThreadInfo->ntables * batchPerTbl < g_args.num_of_RPR)
                break;
      }
5890

5891
      verbosePrint("[%d] %s() LN%d generatedRecPerTbl=%"PRId64" insertRows=%"PRId64"\n",
5892 5893
                pThreadInfo->threadID, __func__, __LINE__,
                generatedRecPerTbl, insertRows);
5894 5895

      if ((g_args.num_of_RPR - recOfBatch) < batchPerTbl)
5896 5897 5898
        break;
    }

5899
    verbosePrint("[%d] %s() LN%d recOfBatch=%d totalInsertRows=%"PRIu64"\n",
5900 5901
              pThreadInfo->threadID, __func__, __LINE__, recOfBatch,
              pThreadInfo->totalInsertRows);
5902
    verbosePrint("[%d] %s() LN%d, buffer=%s\n",
S
Shuduo Sang 已提交
5903
           pThreadInfo->threadID, __func__, __LINE__, pThreadInfo->buffer);
5904

5905
    startTs = taosGetTimestampMs();
5906

5907
    if (recOfBatch == 0) {
5908
      errorPrint("[%d] %s() LN%d try inserting records of batch is %d\n",
5909 5910 5911 5912 5913
              pThreadInfo->threadID, __func__, __LINE__,
              recOfBatch);
      errorPrint("%s\n", "\tPlease check if the batch or the buffer length is proper value!\n");
      goto free_of_interlace;
    }
S
Shuduo Sang 已提交
5914
    int64_t affectedRows = execInsert(pThreadInfo, recOfBatch);
5915

5916
    endTs = taosGetTimestampMs();
5917 5918
    uint64_t delay = endTs - startTs;
    performancePrint("%s() LN%d, insert execution time is %"PRIu64"ms\n",
5919
            __func__, __LINE__, delay);
5920 5921 5922
    verbosePrint("[%d] %s() LN%d affectedRows=%"PRId64"\n",
            pThreadInfo->threadID,
            __func__, __LINE__, affectedRows);
5923 5924 5925 5926 5927 5928

    if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
    if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
    pThreadInfo->cntDelay++;
    pThreadInfo->totalDelay += delay;

5929
    if (recOfBatch != affectedRows) {
5930
        errorPrint("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n%s\n",
5931
                pThreadInfo->threadID, __func__, __LINE__,
S
Shuduo Sang 已提交
5932
                recOfBatch, affectedRows, pThreadInfo->buffer);
5933
        goto free_of_interlace;
5934
    }
5935

5936
    pThreadInfo->totalAffectedRows += affectedRows;
5937

5938 5939
    int64_t  currentPrintTime = taosGetTimestampMs();
    if (currentPrintTime - lastPrintTime > 30*1000) {
5940
      printf("thread[%d] has currently inserted rows: %"PRIu64 ", affected rows: %"PRIu64 "\n",
5941 5942 5943
                    pThreadInfo->threadID,
                    pThreadInfo->totalInsertRows,
                    pThreadInfo->totalAffectedRows);
5944 5945
      lastPrintTime = currentPrintTime;
    }
5946

5947
    if ((insert_interval) && flagSleep) {
5948
      et = taosGetTimestampMs();
5949

5950
      if (insert_interval > (et - st) ) {
S
Shuduo Sang 已提交
5951 5952
        uint64_t sleepTime = insert_interval - (et -st);
        performancePrint("%s() LN%d sleep: %"PRId64" ms for insert interval\n",
5953
                    __func__, __LINE__, sleepTime);
5954 5955 5956
        taosMsleep(sleepTime); // ms
        sleepTimeTotal += insert_interval;
      }
5957
    }
5958 5959
  }

5960
free_of_interlace:
S
Shuduo Sang 已提交
5961
  tmfree(pThreadInfo->buffer);
5962
  printStatPerThread(pThreadInfo);
5963 5964 5965
  return NULL;
}

5966
// sync insertion progressive data
5967
static void* syncWriteProgressive(threadInfo *pThreadInfo) {
5968
  debugPrint("%s() LN%d: ### progressive write\n", __func__, __LINE__);
5969

5970
  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
5971
  uint64_t maxSqlLen = superTblInfo?superTblInfo->maxSqlLen:g_args.max_sql_len;
5972 5973 5974 5975 5976 5977
  int64_t timeStampStep =
      superTblInfo?superTblInfo->timeStampStep:DEFAULT_TIMESTAMP_STEP;
  int64_t insertRows =
        (superTblInfo)?superTblInfo->insertRows:g_args.num_of_DPT;
  verbosePrint("%s() LN%d insertRows=%"PRId64"\n",
            __func__, __LINE__, insertRows);
5978

S
Shuduo Sang 已提交
5979 5980
  pThreadInfo->buffer = calloc(maxSqlLen, 1);
  if (NULL == pThreadInfo->buffer) {
5981
    errorPrint( "Failed to alloc %"PRIu64" Bytes, reason:%s\n",
5982 5983
              maxSqlLen,
              strerror(errno));
5984 5985
    return NULL;
  }
5986

5987 5988 5989
  uint64_t lastPrintTime = taosGetTimestampMs();
  uint64_t startTs = taosGetTimestampMs();
  uint64_t endTs;
5990

5991 5992
  pThreadInfo->totalInsertRows = 0;
  pThreadInfo->totalAffectedRows = 0;
5993

5994
  pThreadInfo->samplePos = 0;
5995

5996 5997 5998
  for (uint64_t tableSeq = pThreadInfo->start_table_from;
          tableSeq <= pThreadInfo->end_table_to;
          tableSeq ++) {
5999
    int64_t start_time = pThreadInfo->start_time;
6000

6001
    for (uint64_t i = 0; i < insertRows;) {
6002 6003
      char tableName[TSDB_TABLE_NAME_LEN];
      getTableName(tableName, pThreadInfo, tableSeq);
6004
      verbosePrint("%s() LN%d: tid=%d seq=%"PRId64" tableName=%s\n",
6005 6006
             __func__, __LINE__,
             pThreadInfo->threadID, tableSeq, tableName);
6007

6008
      int64_t remainderBufLen = maxSqlLen;
S
Shuduo Sang 已提交
6009
      char *pstr = pThreadInfo->buffer;
6010

6011 6012
      int len = snprintf(pstr,
              strlen(STR_INSERT_INTO) + 1, "%s", STR_INSERT_INTO);
6013 6014 6015 6016

      pstr += len;
      remainderBufLen -= len;

6017
      int32_t generated;
6018
      if (superTblInfo) {
6019
          if (superTblInfo->iface == STMT_IFACE) {
6020
#if STMT_IFACE_ENABLED == 1
6021 6022
              generated = prepareStbStmt(
                      superTblInfo,
6023
                      pThreadInfo->stmt,
6024 6025
                      tableName,
                      g_args.num_of_RPR,
6026
                      insertRows, i, start_time, pstr);
6027 6028 6029
#else
              generated = -1;
#endif
6030 6031 6032 6033 6034 6035 6036 6037
          } else {
              generated = generateStbProgressiveData(
                      superTblInfo,
                      tableName, tableSeq, pThreadInfo->db_name, pstr,
                      insertRows, i, start_time,
                      &(pThreadInfo->samplePos),
                      &remainderBufLen);
          }
6038
      } else {
6039
          if (g_args.iface == STMT_IFACE) {
6040
#if STMT_IFACE_ENABLED == 1
6041 6042 6043 6044 6045 6046
              generated = prepareStmtWithoutStb(
                      pThreadInfo->stmt,
                      tableName,
                      g_args.num_of_RPR,
                      insertRows, i,
                      start_time);
6047 6048 6049
#else
              generated = -1;
#endif
6050 6051 6052 6053 6054 6055 6056 6057 6058
          } else {
              generated = generateProgressiveDataWithoutStb(
                      tableName,
                      /*  tableSeq, */
                      pThreadInfo, pstr, insertRows,
                      i, start_time,
                      /* &(pThreadInfo->samplePos), */
                      &remainderBufLen);
          }
6059
      }
6060 6061 6062
      if (generated > 0)
        i += generated;
      else
6063
        goto free_of_progressive;
6064

6065
      start_time +=  generated * timeStampStep;
6066
      pThreadInfo->totalInsertRows += generated;
6067

6068
      startTs = taosGetTimestampMs();
6069

6070
      int32_t affectedRows = execInsert(pThreadInfo, generated);
6071

6072
      endTs = taosGetTimestampMs();
6073
      uint64_t delay = endTs - startTs;
6074
      performancePrint("%s() LN%d, insert execution time is %"PRId64"ms\n",
6075
              __func__, __LINE__, delay);
6076
      verbosePrint("[%d] %s() LN%d affectedRows=%d\n",
6077 6078
            pThreadInfo->threadID,
            __func__, __LINE__, affectedRows);
6079

6080 6081 6082 6083
      if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
      if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
      pThreadInfo->cntDelay++;
      pThreadInfo->totalDelay += delay;
6084

6085
      if (affectedRows < 0) {
6086
        errorPrint("%s() LN%d, affected rows: %d\n",
6087 6088 6089
                __func__, __LINE__, affectedRows);
        goto free_of_progressive;
      }
6090 6091 6092

      pThreadInfo->totalAffectedRows += affectedRows;

6093 6094
      int64_t  currentPrintTime = taosGetTimestampMs();
      if (currentPrintTime - lastPrintTime > 30*1000) {
6095
        printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n",
6096 6097 6098
                    pThreadInfo->threadID,
                    pThreadInfo->totalInsertRows,
                    pThreadInfo->totalAffectedRows);
6099 6100 6101
        lastPrintTime = currentPrintTime;
      }

6102
      if (i >= insertRows)
6103 6104 6105
        break;
    }   // num_of_DPT

6106 6107
    if ((g_args.verbose_print) &&
      (tableSeq == pThreadInfo->ntables - 1) && (superTblInfo) &&
6108 6109
        (0 == strncasecmp(
                    superTblInfo->dataSource, "sample", strlen("sample")))) {
6110
          verbosePrint("%s() LN%d samplePos=%"PRId64"\n",
6111
                  __func__, __LINE__, pThreadInfo->samplePos);
6112
    }
6113
  } // tableSeq
6114

6115
free_of_progressive:
S
Shuduo Sang 已提交
6116
  tmfree(pThreadInfo->buffer);
6117
  printStatPerThread(pThreadInfo);
6118
  return NULL;
H
Hui Li 已提交
6119 6120
}

6121 6122
static void* syncWrite(void *sarg) {

6123 6124
  threadInfo *pThreadInfo = (threadInfo *)sarg;
  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6125

6126
  uint32_t interlaceRows;
6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137

  if (superTblInfo) {
    if ((superTblInfo->interlaceRows == 0)
        && (g_args.interlace_rows > 0)) {
      interlaceRows = g_args.interlace_rows;
    } else {
      interlaceRows = superTblInfo->interlaceRows;
    }
  } else {
    interlaceRows = g_args.interlace_rows;
  }
6138

6139
  if (interlaceRows > 0) {
6140
    // interlace mode
6141
    return syncWriteInterlace(pThreadInfo);
6142 6143
  } else {
    // progressive mode
6144
    return syncWriteProgressive(pThreadInfo);
6145 6146 6147
  }
}

6148
static void callBack(void *param, TAOS_RES *res, int code) {
6149 6150
  threadInfo* pThreadInfo = (threadInfo*)param;
  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6151

6152 6153
  int insert_interval =
      superTblInfo?superTblInfo->insertInterval:g_args.insert_interval;
6154
  if (insert_interval) {
6155 6156 6157
    pThreadInfo->et = taosGetTimestampMs();
    if ((pThreadInfo->et - pThreadInfo->st) < insert_interval) {
      taosMsleep(insert_interval - (pThreadInfo->et - pThreadInfo->st)); // ms
6158
    }
H
Hui Li 已提交
6159
  }
6160

6161
  char *buffer = calloc(1, pThreadInfo->superTblInfo->maxSqlLen);
6162
  char data[MAX_DATA_SIZE];
6163
  char *pstr = buffer;
6164 6165
  pstr += sprintf(pstr, "insert into %s.%s%"PRId64" values",
          pThreadInfo->db_name, pThreadInfo->tb_prefix,
6166
          pThreadInfo->start_table_from);
6167 6168 6169 6170 6171 6172 6173
//  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);
6174 6175 6176 6177
    free(buffer);
    taos_free_result(res);
    return;
  }
6178

6179
  for (int i = 0; i < g_args.num_of_RPR; i++) {
6180
    int rand_num = taosRandom() % 100;
6181
    if (0 != pThreadInfo->superTblInfo->disorderRatio
6182
            && rand_num < pThreadInfo->superTblInfo->disorderRatio) {
6183 6184 6185
      int64_t d = pThreadInfo->lastTs
          - (taosRandom() % pThreadInfo->superTblInfo->disorderRange + 1);
      generateStbRowData(pThreadInfo->superTblInfo, data, d);
6186
    } else {
6187 6188
      generateStbRowData(pThreadInfo->superTblInfo,
              data, pThreadInfo->lastTs += 1000);
H
Hui Li 已提交
6189
    }
6190
    pstr += sprintf(pstr, "%s", data);
6191
    pThreadInfo->counter++;
H
Hui Li 已提交
6192

6193
    if (pThreadInfo->counter >= pThreadInfo->superTblInfo->insertRows) {
6194
      break;
H
Hui Li 已提交
6195 6196
    }
  }
6197

6198
  if (insert_interval) {
6199
    pThreadInfo->st = taosGetTimestampMs();
6200
  }
6201
  taos_query_a(pThreadInfo->taos, buffer, callBack, pThreadInfo);
6202
  free(buffer);
H
Hui Li 已提交
6203

6204
  taos_free_result(res);
H
Hui Li 已提交
6205 6206
}

6207
static void *asyncWrite(void *sarg) {
6208 6209
  threadInfo *pThreadInfo = (threadInfo *)sarg;
  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
6210

6211 6212 6213
  pThreadInfo->st = 0;
  pThreadInfo->et = 0;
  pThreadInfo->lastTs = pThreadInfo->start_time;
6214

6215
  int insert_interval =
6216
      superTblInfo?superTblInfo->insertInterval:g_args.insert_interval;
6217
  if (insert_interval) {
6218
    pThreadInfo->st = taosGetTimestampMs();
H
Hui Li 已提交
6219
  }
6220
  taos_query_a(pThreadInfo->taos, "show databases", callBack, pThreadInfo);
6221

6222
  tsem_wait(&(pThreadInfo->lock_sem));
H
Hui Li 已提交
6223 6224 6225 6226

  return NULL;
}

6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252
static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *serv_addr)
{
  uint16_t rest_port = port + TSDB_PORT_HTTP;
  struct hostent *server = gethostbyname(host);
  if ((server == NULL) || (server->h_addr == NULL)) {
    errorPrint("%s", "ERROR, no such host");
    return -1;
  }

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

  memset(serv_addr, 0, sizeof(struct sockaddr_in));
  serv_addr->sin_family = AF_INET;
  serv_addr->sin_port = htons(rest_port);
#ifdef WINDOWS
  serv_addr->sin_addr.s_addr = inet_addr(host);
#else
  memcpy(&(serv_addr->sin_addr.s_addr), server->h_addr, server->h_length);
#endif
  return 0;
}

6253
static void startMultiThreadInsertData(int threads, char* db_name,
6254
        char* precision,SSuperTable* superTblInfo) {
6255

6256 6257 6258 6259
  int32_t timePrec = TSDB_TIME_PRECISION_MILLI;
  if (0 != precision[0]) {
    if (0 == strncasecmp(precision, "ms", 2)) {
      timePrec = TSDB_TIME_PRECISION_MILLI;
6260
    } else if (0 == strncasecmp(precision, "us", 2)) {
6261
      timePrec = TSDB_TIME_PRECISION_MICRO;
6262 6263 6264
    } else if (0 == strncasecmp(precision, "ns", 2)) {
      timePrec = TSDB_TIME_PRECISION_NANO;
    } else {
6265
      errorPrint("Not support precision: %s\n", precision);
6266 6267 6268 6269
      exit(-1);
    }
  }

6270
  int64_t start_time;
6271 6272
  if (superTblInfo) {
    if (0 == strncasecmp(superTblInfo->startTimestamp, "now", 3)) {
6273
        start_time = taosGetTimestamp(timePrec);
6274
    } else {
6275
      if (TSDB_CODE_SUCCESS != taosParseTime(
6276 6277 6278 6279 6280
        superTblInfo->startTimestamp,
        &start_time,
        strlen(superTblInfo->startTimestamp),
        timePrec, 0)) {
          ERROR_EXIT("failed to parse time!\n");
6281
      }
6282
    }
6283
  } else {
6284
     start_time = 1500000000000;
6285 6286
  }

6287
  int64_t start = taosGetTimestampMs();
6288

6289
  // read sample data from file first
6290
  if ((superTblInfo) && (0 == strncasecmp(superTblInfo->dataSource,
6291
              "sample", strlen("sample")))) {
6292
    if (0 != prepareSampleDataForSTable(superTblInfo)) {
6293
      errorPrint("%s() LN%d, prepare sample data for stable failed!\n",
6294
              __func__, __LINE__);
6295 6296 6297 6298
      exit(-1);
    }
  }

6299
  // read sample data from file first
6300
  if ((superTblInfo) && (0 == strncasecmp(superTblInfo->dataSource,
6301
              "sample", strlen("sample")))) {
6302
    if (0 != prepareSampleDataForSTable(superTblInfo)) {
6303
      errorPrint("%s() LN%d, prepare sample data for stable failed!\n",
6304
              __func__, __LINE__);
6305 6306 6307 6308
      exit(-1);
    }
  }

6309
  TAOS* taos0 = taos_connect(
6310 6311
              g_Dbs.host, g_Dbs.user,
              g_Dbs.password, db_name, g_Dbs.port);
6312
  if (NULL == taos0) {
6313
    errorPrint("%s() LN%d, connect to server fail , reason: %s\n",
6314
                __func__, __LINE__, taos_errstr(NULL));
6315 6316 6317
    exit(-1);
  }

S
Shuduo Sang 已提交
6318
  int64_t ntables = 0;
6319
  uint64_t tableFrom;
6320

6321
  if (superTblInfo) {
6322 6323
    int64_t limit;
    uint64_t offset;
6324

H
Haojun Liao 已提交
6325
    if ((NULL != g_args.sqlFile) && (superTblInfo->childTblExists == TBL_NO_EXISTS) &&
6326
            ((superTblInfo->childTblOffset != 0) || (superTblInfo->childTblLimit >= 0))) {
H
Haojun Liao 已提交
6327
      printf("WARNING: offset and limit will not be used since the child tables not exists!\n");
6328 6329
    }

6330
    if (superTblInfo->childTblExists == TBL_ALREADY_EXISTS) {
6331 6332
      if ((superTblInfo->childTblLimit < 0)
          || ((superTblInfo->childTblOffset + superTblInfo->childTblLimit)
6333
            > (superTblInfo->childTblCount))) {
6334 6335 6336 6337 6338 6339
        superTblInfo->childTblLimit =
            superTblInfo->childTblCount - superTblInfo->childTblOffset;
      }

      offset = superTblInfo->childTblOffset;
      limit = superTblInfo->childTblLimit;
6340
    } else {
6341 6342
      limit = superTblInfo->childTblCount;
      offset = 0;
6343 6344
    }

6345
    ntables = limit;
6346
    tableFrom = offset;
6347

6348 6349 6350 6351
    if ((superTblInfo->childTblExists != TBL_NO_EXISTS)
        && ((superTblInfo->childTblOffset + superTblInfo->childTblLimit )
            > superTblInfo->childTblCount)) {
      printf("WARNING: specified offset + limit > child table count!\n");
6352
      prompt();
6353 6354 6355
    }

    if ((superTblInfo->childTblExists != TBL_NO_EXISTS)
6356
            && (0 == superTblInfo->childTblLimit)) {
6357
      printf("WARNING: specified limit = 0, which cannot find table name to insert or query! \n");
6358
      prompt();
6359 6360
    }

6361
    superTblInfo->childTblName = (char*)calloc(1,
6362
        limit * TSDB_TABLE_NAME_LEN);
6363
    if (superTblInfo->childTblName == NULL) {
6364
      errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
6365
      taos_close(taos0);
6366 6367 6368
      exit(-1);
    }

6369
    int64_t childTblCount;
6370
    getChildNameOfSuperTableWithLimitAndOffset(
6371
        taos0,
6372 6373 6374 6375
        db_name, superTblInfo->sTblName,
        &superTblInfo->childTblName, &childTblCount,
        limit,
        offset);
6376 6377
  } else {
    ntables = g_args.num_of_tables;
6378
    tableFrom = 0;
6379
  }
6380

6381
  taos_close(taos0);
6382

S
Shuduo Sang 已提交
6383
  int64_t a = ntables / threads;
6384 6385 6386 6387 6388
  if (a < 1) {
    threads = ntables;
    a = 1;
  }

S
Shuduo Sang 已提交
6389
  int64_t b = 0;
6390 6391 6392 6393
  if (threads != 0) {
    b = ntables % threads;
  }

6394
  if ((superTblInfo)
6395 6396 6397
      && (superTblInfo->iface == REST_IFACE)) {
      if (convertHostToServAddr(
                  g_Dbs.host, g_Dbs.port, &(g_Dbs.serv_addr)) != 0) {
6398 6399
        exit(-1);
      }
6400 6401
  }

6402 6403 6404 6405 6406 6407 6408 6409 6410
  pthread_t *pids = malloc(threads * sizeof(pthread_t));
  assert(pids != NULL);

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

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

H
Hui Li 已提交
6411
  for (int i = 0; i < threads; i++) {
6412 6413 6414 6415 6416
    threadInfo *pThreadInfo = infos + i;
    pThreadInfo->threadID = i;
    tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
    pThreadInfo->time_precision = timePrec;
    pThreadInfo->superTblInfo = superTblInfo;
6417

6418 6419
    pThreadInfo->start_time = start_time;
    pThreadInfo->minDelay = UINT64_MAX;
6420

6421
    if ((NULL == superTblInfo) ||
6422 6423
            (superTblInfo->iface != REST_IFACE)) {
      //t_info->taos = taos;
6424
      pThreadInfo->taos = taos_connect(
6425 6426
              g_Dbs.host, g_Dbs.user,
              g_Dbs.password, db_name, g_Dbs.port);
6427
      if (NULL == pThreadInfo->taos) {
6428
        errorPrint(
6429 6430
                "%s() LN%d, connect to server fail from insert sub thread, reason: %s\n",
                __func__, __LINE__,
6431
                taos_errstr(NULL));
6432
        free(infos);
6433 6434
        exit(-1);
      }
6435

6436
#if STMT_IFACE_ENABLED == 1
6437 6438 6439 6440 6441 6442 6443 6444 6445 6446
      if ((g_args.iface == STMT_IFACE)
          || ((superTblInfo) && (superTblInfo->iface == STMT_IFACE))) {

          int columnCount;
          if (superTblInfo) {
              columnCount = superTblInfo->columnCount;
          } else {
              columnCount = g_args.num_of_CPR;
          }

6447 6448
        pThreadInfo->stmt = taos_stmt_init(pThreadInfo->taos);
        if (NULL == pThreadInfo->stmt) {
6449 6450 6451 6452 6453 6454 6455 6456
            errorPrint(
                "%s() LN%d, failed init stmt, reason: %s\n",
                __func__, __LINE__,
                taos_errstr(NULL));
            free(pids);
            free(infos);
            exit(-1);
        }
6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474

        char buffer[3000];
        char *pstr = buffer;
        pstr += sprintf(pstr, "INSERT INTO ? values(?");

        for (int col = 0; col < columnCount; col ++) {
            pstr += sprintf(pstr, ",?");
        }
        pstr += sprintf(pstr, ")");

        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",
                    ret, taos_errstr(NULL));
            free(pids);
            free(infos);
            exit(-1);
        }
6475
      }
6476
#endif
6477
    } else {
6478
      pThreadInfo->taos = NULL;
6479 6480
    }

6481
/*    if ((NULL == superTblInfo)
6482
            || (0 == superTblInfo->multiThreadWriteOneTbl)) {
6483
            */
6484
      pThreadInfo->start_table_from = tableFrom;
6485
      pThreadInfo->ntables = i<b?a+1:a;
6486 6487
      pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
      tableFrom = pThreadInfo->end_table_to + 1;
6488
/*    } else {
6489 6490 6491
      pThreadInfo->start_table_from = 0;
      pThreadInfo->ntables = superTblInfo->childTblCount;
      pThreadInfo->start_time = pThreadInfo->start_time + rand_int() % 10000 - rand_tinyint();
6492
    }
6493
*/
6494
    tsem_init(&(pThreadInfo->lock_sem), 0, 0);
6495
    if (ASYNC_MODE == g_Dbs.asyncMode) {
6496
      pthread_create(pids + i, NULL, asyncWrite, pThreadInfo);
6497
    } else {
6498
      pthread_create(pids + i, NULL, syncWrite, pThreadInfo);
6499
    }
H
Hui Li 已提交
6500
  }
6501

H
Hui Li 已提交
6502 6503 6504 6505
  for (int i = 0; i < threads; i++) {
    pthread_join(pids[i], NULL);
  }

6506 6507 6508 6509
  uint64_t totalDelay = 0;
  uint64_t maxDelay = 0;
  uint64_t minDelay = UINT64_MAX;
  uint64_t cntDelay = 1;
6510 6511
  double  avgDelay = 0;

H
Hui Li 已提交
6512
  for (int i = 0; i < threads; i++) {
6513
    threadInfo *pThreadInfo = infos + i;
6514

6515
    tsem_destroy(&(pThreadInfo->lock_sem));
6516

6517
#if STMT_IFACE_ENABLED == 1
6518 6519
    if (pThreadInfo->stmt) {
      taos_stmt_close(pThreadInfo->stmt);
6520
    }
6521
#endif
6522 6523
    tsem_destroy(&(pThreadInfo->lock_sem));
    taos_close(pThreadInfo->taos);
6524

6525
    debugPrint("%s() LN%d, [%d] totalInsert=%"PRIu64" totalAffected=%"PRIu64"\n",
6526
            __func__, __LINE__,
6527 6528
            pThreadInfo->threadID, pThreadInfo->totalInsertRows,
            pThreadInfo->totalAffectedRows);
6529
    if (superTblInfo) {
6530 6531
        superTblInfo->totalAffectedRows += pThreadInfo->totalAffectedRows;
        superTblInfo->totalInsertRows += pThreadInfo->totalInsertRows;
6532
    } else {
6533 6534
        g_args.totalAffectedRows += pThreadInfo->totalAffectedRows;
        g_args.totalInsertRows += pThreadInfo->totalInsertRows;
6535
    }
6536

6537 6538 6539 6540
    totalDelay  += pThreadInfo->totalDelay;
    cntDelay   += pThreadInfo->cntDelay;
    if (pThreadInfo->maxDelay > maxDelay) maxDelay = pThreadInfo->maxDelay;
    if (pThreadInfo->minDelay < minDelay) minDelay = pThreadInfo->minDelay;
H
Hui Li 已提交
6541
  }
6542
  cntDelay -= 1;
H
Hui Li 已提交
6543

6544
  if (cntDelay == 0)    cntDelay = 1;
6545 6546
  avgDelay = (double)totalDelay / cntDelay;

6547 6548
  int64_t end = taosGetTimestampMs();
  int64_t t = end - start;
6549 6550

  if (superTblInfo) {
6551
    fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
6552 6553 6554 6555
          t / 1000.0, superTblInfo->totalInsertRows,
          superTblInfo->totalAffectedRows,
          threads, db_name, superTblInfo->sTblName,
          (double)superTblInfo->totalInsertRows / (t / 1000.0));
6556 6557 6558 6559

    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",
6560 6561 6562 6563
          t / 1000.0, superTblInfo->totalInsertRows,
          superTblInfo->totalAffectedRows,
          threads, db_name, superTblInfo->sTblName,
          (double)superTblInfo->totalInsertRows / (t / 1000.0));
6564
    }
6565
  } else {
6566
    fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
6567 6568 6569 6570
          t / 1000.0, g_args.totalInsertRows,
          g_args.totalAffectedRows,
          threads, db_name,
          (double)g_args.totalInsertRows / (t / 1000.0));
6571 6572 6573
    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",
6574 6575 6576 6577
          t * 1000.0, g_args.totalInsertRows,
          g_args.totalAffectedRows,
          threads, db_name,
          (double)g_args.totalInsertRows / (t / 1000.0));
6578
    }
6579
  }
6580

6581
  fprintf(stderr, "insert delay, avg: %10.2fms, max: %"PRIu64"ms, min: %"PRIu64"ms\n\n",
6582
          avgDelay, maxDelay, minDelay);
6583 6584
  if (g_fpOfInsertResult) {
    fprintf(g_fpOfInsertResult, "insert delay, avg:%10.2fms, max: %"PRIu64"ms, min: %"PRIu64"ms\n\n",
6585
          avgDelay, maxDelay, minDelay);
6586
  }
6587

6588 6589
  //taos_close(taos);

H
Hui Li 已提交
6590
  free(pids);
6591
  free(infos);
H
Hui Li 已提交
6592 6593
}

6594
static void *readTable(void *sarg) {
6595
#if 1
6596 6597
  threadInfo *pThreadInfo = (threadInfo *)sarg;
  TAOS *taos = pThreadInfo->taos;
H
hzcheng 已提交
6598
  char command[BUFFER_SIZE] = "\0";
6599 6600 6601
  uint64_t sTime = pThreadInfo->start_time;
  char *tb_prefix = pThreadInfo->tb_prefix;
  FILE *fp = fopen(pThreadInfo->filePath, "a");
H
Hui Li 已提交
6602
  if (NULL == fp) {
6603
    errorPrint( "fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
H
Hui Li 已提交
6604 6605
    return NULL;
  }
6606

6607
  int64_t num_of_DPT;
6608 6609
/*  if (pThreadInfo->superTblInfo) {
    num_of_DPT = pThreadInfo->superTblInfo->insertRows; //  nrecords_per_table;
6610
  } else {
6611
  */
6612
      num_of_DPT = g_args.num_of_DPT;
6613
//  }
6614

6615
  int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
S
Shuduo Sang 已提交
6616
  int64_t totalData = num_of_DPT * num_of_tables;
6617
  bool do_aggreFunc = g_Dbs.do_aggreFunc;
H
hzcheng 已提交
6618 6619 6620 6621 6622

  int n = do_aggreFunc ? (sizeof(aggreFunc) / sizeof(aggreFunc[0])) : 2;
  if (!do_aggreFunc) {
    printf("\nThe first field is either Binary or Bool. Aggregation functions are not supported.\n");
  }
S
Shuduo Sang 已提交
6623
  printf("%"PRId64" records:\n", totalData);
H
hzcheng 已提交
6624 6625
  fprintf(fp, "| QFunctions |    QRecords    |   QSpeed(R/s)   |  QLatency(ms) |\n");

6626
  for (int j = 0; j < n; j++) {
H
hzcheng 已提交
6627
    double totalT = 0;
6628
    uint64_t count = 0;
6629 6630
    for (int64_t i = 0; i < num_of_tables; i++) {
      sprintf(command, "select %s from %s%"PRId64" where ts>= %" PRIu64,
6631
              aggreFunc[j], tb_prefix, i, sTime);
H
hzcheng 已提交
6632

6633
      double t = taosGetTimestampMs();
S
Shuaiqiang Chang 已提交
6634 6635
      TAOS_RES *pSql = taos_query(taos, command);
      int32_t code = taos_errno(pSql);
H
hzcheng 已提交
6636

S
Shuaiqiang Chang 已提交
6637
      if (code != 0) {
6638
        errorPrint( "Failed to query:%s\n", taos_errstr(pSql));
S
Shuaiqiang Chang 已提交
6639
        taos_free_result(pSql);
H
hzcheng 已提交
6640
        taos_close(taos);
6641
        fclose(fp);
6642
        return NULL;
H
hzcheng 已提交
6643 6644
      }

6645
      while(taos_fetch_row(pSql) != NULL) {
H
hzcheng 已提交
6646 6647 6648
        count++;
      }

6649
      t = taosGetTimestampMs() - t;
H
hzcheng 已提交
6650 6651
      totalT += t;

S
Shuaiqiang Chang 已提交
6652
      taos_free_result(pSql);
H
hzcheng 已提交
6653 6654
    }

6655
    fprintf(fp, "|%10s  |   %"PRId64"   |  %12.2f   |   %10.2f  |\n",
S
slguan 已提交
6656
            aggreFunc[j][0] == '*' ? "   *   " : aggreFunc[j], totalData,
H
hzcheng 已提交
6657
            (double)(num_of_tables * num_of_DPT) / totalT, totalT * 1000);
6658
    printf("select %10s took %.6f second(s)\n", aggreFunc[j], totalT * 1000);
H
hzcheng 已提交
6659 6660 6661
  }
  fprintf(fp, "\n");
  fclose(fp);
6662
#endif
H
hzcheng 已提交
6663 6664 6665
  return NULL;
}

6666
static void *readMetric(void *sarg) {
6667
#if 1
6668 6669
  threadInfo *pThreadInfo = (threadInfo *)sarg;
  TAOS *taos = pThreadInfo->taos;
H
hzcheng 已提交
6670
  char command[BUFFER_SIZE] = "\0";
6671
  FILE *fp = fopen(pThreadInfo->filePath, "a");
H
Hui Li 已提交
6672
  if (NULL == fp) {
6673
    printf("fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
H
Hui Li 已提交
6674 6675
    return NULL;
  }
6676

6677 6678
  int64_t num_of_DPT = pThreadInfo->superTblInfo->insertRows;
  int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
S
Shuduo Sang 已提交
6679
  int64_t totalData = num_of_DPT * num_of_tables;
6680
  bool do_aggreFunc = g_Dbs.do_aggreFunc;
H
hzcheng 已提交
6681 6682 6683 6684 6685

  int n = do_aggreFunc ? (sizeof(aggreFunc) / sizeof(aggreFunc[0])) : 2;
  if (!do_aggreFunc) {
    printf("\nThe first field is either Binary or Bool. Aggregation functions are not supported.\n");
  }
S
Shuduo Sang 已提交
6686 6687
  printf("%"PRId64" records:\n", totalData);
  fprintf(fp, "Querying On %"PRId64" records:\n", totalData);
H
hzcheng 已提交
6688 6689

  for (int j = 0; j < n; j++) {
6690
    char condition[COND_BUF_LEN] = "\0";
B
Bomin Zhang 已提交
6691
    char tempS[64] = "\0";
H
hzcheng 已提交
6692

6693
    int64_t m = 10 < num_of_tables ? 10 : num_of_tables;
H
hzcheng 已提交
6694

6695
    for (int64_t i = 1; i <= m; i++) {
H
hzcheng 已提交
6696
      if (i == 1) {
6697
        sprintf(tempS, "t1 = %"PRId64"", i);
H
hzcheng 已提交
6698
      } else {
6699
        sprintf(tempS, " or t1 = %"PRId64" ", i);
H
hzcheng 已提交
6700
      }
6701
      strncat(condition, tempS, COND_BUF_LEN - 1);
H
hzcheng 已提交
6702

L
liu0x54 已提交
6703
      sprintf(command, "select %s from meters where %s", aggreFunc[j], condition);
H
hzcheng 已提交
6704 6705 6706 6707

      printf("Where condition: %s\n", condition);
      fprintf(fp, "%s\n", command);

6708
      double t = taosGetTimestampMs();
H
hzcheng 已提交
6709

S
Shuaiqiang Chang 已提交
6710 6711 6712 6713
      TAOS_RES *pSql = taos_query(taos, command);
      int32_t code = taos_errno(pSql);

      if (code != 0) {
6714
        errorPrint( "Failed to query:%s\n", taos_errstr(pSql));
S
Shuaiqiang Chang 已提交
6715
        taos_free_result(pSql);
H
hzcheng 已提交
6716
        taos_close(taos);
6717
        fclose(fp);
6718
        return NULL;
H
hzcheng 已提交
6719 6720
      }
      int count = 0;
6721
      while(taos_fetch_row(pSql) != NULL) {
H
hzcheng 已提交
6722 6723
        count++;
      }
6724
      t = taosGetTimestampMs() - t;
H
hzcheng 已提交
6725

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

S
Shuaiqiang Chang 已提交
6730
      taos_free_result(pSql);
H
hzcheng 已提交
6731 6732 6733 6734
    }
    fprintf(fp, "\n");
  }
  fclose(fp);
6735
#endif
H
hzcheng 已提交
6736 6737 6738
  return NULL;
}

6739 6740 6741 6742 6743 6744 6745
static void prompt()
{
  if (!g_args.answer_yes) {
    printf("         Press enter key to continue or Ctrl-C to stop\n\n");
    (void)getchar();
  }
}
H
Hui Li 已提交
6746

6747
static int insertTestProcess() {
6748

6749 6750 6751
  setupForAnsiEscape();
  int ret = printfInsertMeta();
  resetAfterAnsiEscape();
6752

6753 6754 6755
  if (ret == -1)
    exit(EXIT_FAILURE);

6756
  debugPrint("%d result file: %s\n", __LINE__, g_Dbs.resultFile);
6757 6758
  g_fpOfInsertResult = fopen(g_Dbs.resultFile, "a");
  if (NULL == g_fpOfInsertResult) {
6759
    errorPrint( "Failed to open %s for save result\n", g_Dbs.resultFile);
6760 6761
    return -1;
  }
6762

6763 6764
  if (g_fpOfInsertResult)
    printfInsertMetaToFile(g_fpOfInsertResult);
6765

6766
  prompt();
6767

6768 6769 6770
  init_rand_data();

  // create database and super tables
6771
  if(createDatabasesAndStables() != 0) {
6772 6773
    if (g_fpOfInsertResult)
      fclose(g_fpOfInsertResult);
6774 6775
    return -1;
  }
6776 6777

  // pretreatement
6778
  prepareSampleData();
6779

6780 6781 6782 6783
  double start;
  double end;

  // create child tables
6784
  start = taosGetTimestampMs();
6785
  createChildTables();
6786
  end = taosGetTimestampMs();
6787

6788
  if (g_totalChildTables > 0) {
6789
    fprintf(stderr, "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
6790
            (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
6791 6792
    if (g_fpOfInsertResult) {
      fprintf(g_fpOfInsertResult,
6793
            "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
6794
            (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
6795
    }
6796
  }
6797

6798
  // create sub threads for inserting data
6799
  //start = taosGetTimestampMs();
6800
  for (int i = 0; i < g_Dbs.dbCount; i++) {
6801 6802
    if (g_Dbs.use_metric) {
      if (g_Dbs.db[i].superTblCount > 0) {
S
Shuduo Sang 已提交
6803
        for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
6804 6805 6806 6807 6808

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

          if (superTblInfo && (superTblInfo->insertRows > 0)) {
            startMultiThreadInsertData(
6809 6810 6811 6812
              g_Dbs.threadCount,
              g_Dbs.db[i].dbName,
              g_Dbs.db[i].dbCfg.precision,
              superTblInfo);
6813
          }
6814
        }
6815
      }
6816
    } else {
6817
        startMultiThreadInsertData(
6818 6819 6820
          g_Dbs.threadCount,
          g_Dbs.db[i].dbName,
          g_Dbs.db[i].dbCfg.precision,
6821
          NULL);
H
Hui Li 已提交
6822
    }
6823
  }
6824
  //end = taosGetTimestampMs();
6825

6826
  //int64_t    totalInsertRows = 0;
6827
  //int64_t    totalAffectedRows = 0;
6828
  //for (int i = 0; i < g_Dbs.dbCount; i++) {
6829
  //  for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
6830
  //  totalInsertRows+= g_Dbs.db[i].superTbls[j].totalInsertRows;
6831 6832
  //  totalAffectedRows += g_Dbs.db[i].superTbls[j].totalAffectedRows;
  //}
6833
  //printf("Spent %.4f seconds to insert rows: %"PRId64", affected rows: %"PRId64" with %d thread(s)\n\n", end - start, totalInsertRows, totalAffectedRows, g_Dbs.threadCount);
6834
  postFreeResource();
6835

6836 6837 6838
  return 0;
}

6839 6840
static void *specifiedTableQuery(void *sarg) {
  threadInfo *pThreadInfo = (threadInfo *)sarg;
6841

6842
  if (pThreadInfo->taos == NULL) {
6843 6844
    TAOS * taos = NULL;
    taos = taos_connect(g_queryInfo.host,
6845 6846 6847 6848
          g_queryInfo.user,
          g_queryInfo.password,
          NULL,
          g_queryInfo.port);
6849 6850
    if (taos == NULL) {
      errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
6851
            pThreadInfo->threadID, taos_errstr(NULL));
6852 6853
      return NULL;
    } else {
6854
      pThreadInfo->taos = taos;
6855 6856 6857
    }
  }

6858 6859
  char sqlStr[MAX_DB_NAME_SIZE + 5];
  sprintf(sqlStr, "use %s", g_queryInfo.dbName);
6860 6861
  if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
    taos_close(pThreadInfo->taos);
6862 6863 6864 6865
    errorPrint( "use database %s failed!\n\n",
                g_queryInfo.dbName);
    return NULL;
  }
6866

6867 6868
  uint64_t st = 0;
  uint64_t et = 0;
6869

6870
  uint64_t queryTimes = g_queryInfo.specifiedQueryInfo.queryTimes;
6871

6872 6873 6874
  uint64_t totalQueried = 0;
  uint64_t lastPrintTime = taosGetTimestampMs();
  uint64_t startTs = taosGetTimestampMs();
6875

6876
  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != '\0') {
6877
    sprintf(pThreadInfo->filePath, "%s-%d",
6878 6879 6880 6881
                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                pThreadInfo->threadID);
  }

6882
  while(queryTimes --) {
6883
    if (g_queryInfo.specifiedQueryInfo.queryInterval && (et - st) <
6884
            (int64_t)g_queryInfo.specifiedQueryInfo.queryInterval) {
6885
      taosMsleep(g_queryInfo.specifiedQueryInfo.queryInterval - (et - st)); // ms
6886 6887
    }

6888 6889 6890
    st = taosGetTimestampMs();

    selectAndGetResult(pThreadInfo,
6891
          g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq]);
6892

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

6897 6898
    totalQueried ++;
    g_queryInfo.specifiedQueryInfo.totalQueried ++;
6899

6900 6901
    uint64_t  currentPrintTime = taosGetTimestampMs();
    uint64_t  endTs = taosGetTimestampMs();
6902
    if (currentPrintTime - lastPrintTime > 30*1000) {
6903
      debugPrint("%s() LN%d, endTs=%"PRIu64"ms, startTs=%"PRIu64"ms\n",
6904
          __func__, __LINE__, endTs, startTs);
6905
      printf("thread[%d] has currently completed queries: %"PRIu64", QPS: %10.6f\n",
6906 6907
                    pThreadInfo->threadID,
                    totalQueried,
6908
                    (double)(totalQueried/((endTs-startTs)/1000.0)));
6909
      lastPrintTime = currentPrintTime;
6910
    }
H
Hui Li 已提交
6911
  }
6912 6913
  return NULL;
}
H
Hui Li 已提交
6914

6915
static void replaceChildTblName(char* inSql, char* outSql, int tblIndex) {
6916 6917
  char sourceString[32] = "xxxx";
  char subTblName[MAX_TB_NAME_SIZE*3];
6918 6919
  sprintf(subTblName, "%s.%s",
          g_queryInfo.dbName,
6920
          g_queryInfo.superQueryInfo.childTblName + tblIndex*TSDB_TABLE_NAME_LEN);
6921 6922

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

6924 6925
  char* pos = strstr(inSql, sourceString);
  if (0 == pos) {
6926
    return;
H
Hui Li 已提交
6927
  }
6928

6929
  tstrncpy(outSql, inSql, pos - inSql + 1);
6930
  //printf("1: %s\n", outSql);
6931
  strncat(outSql, subTblName, MAX_QUERY_SQL_LENGTH - 1);
6932
  //printf("2: %s\n", outSql);
6933
  strncat(outSql, pos+strlen(sourceString), MAX_QUERY_SQL_LENGTH - 1);
6934
  //printf("3: %s\n", outSql);
H
Hui Li 已提交
6935 6936
}

6937
static void *superTableQuery(void *sarg) {
6938
  char sqlstr[MAX_QUERY_SQL_LENGTH];
6939
  threadInfo *pThreadInfo = (threadInfo *)sarg;
6940

6941
  if (pThreadInfo->taos == NULL) {
6942 6943 6944 6945 6946 6947 6948 6949
    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",
6950
            pThreadInfo->threadID, taos_errstr(NULL));
6951 6952
      return NULL;
    } else {
6953
      pThreadInfo->taos = taos;
6954 6955 6956
    }
  }

6957 6958
  uint64_t st = 0;
  uint64_t et = (int64_t)g_queryInfo.superQueryInfo.queryInterval;
6959

6960 6961 6962
  uint64_t queryTimes = g_queryInfo.superQueryInfo.queryTimes;
  uint64_t totalQueried = 0;
  uint64_t  startTs = taosGetTimestampMs();
6963

6964
  uint64_t  lastPrintTime = taosGetTimestampMs();
6965
  while(queryTimes --) {
6966 6967 6968
    if (g_queryInfo.superQueryInfo.queryInterval
            && (et - st) < (int64_t)g_queryInfo.superQueryInfo.queryInterval) {
      taosMsleep(g_queryInfo.superQueryInfo.queryInterval - (et - st)); // ms
6969
      //printf("========sleep duration:%"PRId64 "========inserted rows:%d, table range:%d - %d\n", (1000 - (et - st)), i, pThreadInfo->start_table_from, pThreadInfo->end_table_to);
6970
    }
H
Hui Li 已提交
6971

6972
    st = taosGetTimestampMs();
6973
    for (int i = pThreadInfo->start_table_from; i <= pThreadInfo->end_table_to; i++) {
6974
      for (int j = 0; j < g_queryInfo.superQueryInfo.sqlCount; j++) {
6975
        memset(sqlstr,0,sizeof(sqlstr));
6976
        replaceChildTblName(g_queryInfo.superQueryInfo.sql[j], sqlstr, i);
6977
        if (g_queryInfo.superQueryInfo.result[j][0] != '\0') {
6978
          sprintf(pThreadInfo->filePath, "%s-%d",
6979
                  g_queryInfo.superQueryInfo.result[j],
6980
                  pThreadInfo->threadID);
6981
        }
6982
        selectAndGetResult(pThreadInfo, sqlstr);
6983 6984 6985 6986 6987 6988 6989

        totalQueried++;
        g_queryInfo.superQueryInfo.totalQueried ++;

        int64_t  currentPrintTime = taosGetTimestampMs();
        int64_t  endTs = taosGetTimestampMs();
        if (currentPrintTime - lastPrintTime > 30*1000) {
6990
          printf("thread[%d] has currently completed queries: %"PRIu64", QPS: %10.3f\n",
6991 6992
                    pThreadInfo->threadID,
                    totalQueried,
6993
                    (double)(totalQueried/((endTs-startTs)/1000.0)));
6994
          lastPrintTime = currentPrintTime;
6995
        }
6996
      }
H
Hui Li 已提交
6997
    }
6998
    et = taosGetTimestampMs();
6999
    printf("####thread[%"PRId64"] complete all sqls to allocate all sub-tables[%"PRIu64" - %"PRIu64"] once queries duration:%.4fs\n\n",
7000
            taosGetSelfPthreadId(),
7001 7002
            pThreadInfo->start_table_from,
            pThreadInfo->end_table_to,
7003
            (double)(et - st)/1000.0);
7004
  }
7005

7006 7007 7008
  return NULL;
}

7009
static int queryTestProcess() {
7010 7011 7012 7013

  setupForAnsiEscape();
  printfQueryMeta();
  resetAfterAnsiEscape();
7014 7015 7016 7017 7018 7019

  TAOS * taos = NULL;
  taos = taos_connect(g_queryInfo.host,
          g_queryInfo.user,
          g_queryInfo.password,
          NULL,
7020
          g_queryInfo.port);
7021
  if (taos == NULL) {
7022 7023
    errorPrint( "Failed to connect to TDengine, reason:%s\n",
            taos_errstr(NULL));
7024 7025 7026
    exit(-1);
  }

7027
  if (0 != g_queryInfo.superQueryInfo.sqlCount) {
7028 7029
    getAllChildNameOfSuperTable(taos,
            g_queryInfo.dbName,
7030 7031 7032
            g_queryInfo.superQueryInfo.sTblName,
            &g_queryInfo.superQueryInfo.childTblName,
            &g_queryInfo.superQueryInfo.childTblCount);
7033
  }
7034

7035
  prompt();
7036

7037 7038 7039
  if (g_args.debug_print || g_args.verbose_print) {
    printfQuerySystemInfo(taos);
  }
7040

7041 7042 7043 7044 7045 7046
  if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
    if (convertHostToServAddr(
        g_queryInfo.host, g_queryInfo.port, &g_queryInfo.serv_addr) != 0)
      exit(-1);
  }

7047 7048 7049
  pthread_t  *pids  = NULL;
  threadInfo *infos = NULL;
  //==== create sub threads for query from specify table
7050
  int nConcurrent = g_queryInfo.specifiedQueryInfo.concurrent;
7051
  uint64_t nSqlCount = g_queryInfo.specifiedQueryInfo.sqlCount;
7052

7053
  uint64_t startTs = taosGetTimestampMs();
7054

7055 7056 7057 7058 7059 7060
  if ((nSqlCount > 0) && (nConcurrent > 0)) {

    pids  = malloc(nConcurrent * nSqlCount * sizeof(pthread_t));
    infos = malloc(nConcurrent * nSqlCount * sizeof(threadInfo));

    if ((NULL == pids) || (NULL == infos)) {
7061
      taos_close(taos);
7062
      ERROR_EXIT("memory allocation failed for create threads\n");
7063
    }
7064

7065 7066 7067
    for (uint64_t i = 0; i < nSqlCount; i++) {
        for (int j = 0; j < nConcurrent; j++) {
            uint64_t seq = i * nConcurrent + j;
7068 7069 7070
            threadInfo *pThreadInfo = infos + seq;
            pThreadInfo->threadID = seq;
            pThreadInfo->querySeq = i;
7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084

            if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", 5)) {

                char sqlStr[MAX_TB_NAME_SIZE*2];
                sprintf(sqlStr, "use %s", g_queryInfo.dbName);
                if (0 != queryDbExec(taos, sqlStr, NO_INSERT_TYPE, false)) {
                    taos_close(taos);
                    free(infos);
                    free(pids);
                    errorPrint( "use database %s failed!\n\n",
                        g_queryInfo.dbName);
                    return -1;
                }
            }
7085

7086
            pThreadInfo->taos = NULL;// TODO: workaround to use separate taos connection;
7087

7088
            pthread_create(pids + seq, NULL, specifiedTableQuery,
7089
                pThreadInfo);
7090
        }
7091
    }
7092
  } else {
7093
    g_queryInfo.specifiedQueryInfo.concurrent = 0;
7094
  }
7095

7096 7097
  taos_close(taos);

7098 7099 7100
  pthread_t  *pidsOfSub  = NULL;
  threadInfo *infosOfSub = NULL;
  //==== create sub threads for query from all sub table of the super table
7101 7102 7103 7104
  if ((g_queryInfo.superQueryInfo.sqlCount > 0)
          && (g_queryInfo.superQueryInfo.threadCnt > 0)) {
    pidsOfSub  = malloc(g_queryInfo.superQueryInfo.threadCnt * sizeof(pthread_t));
    infosOfSub = malloc(g_queryInfo.superQueryInfo.threadCnt * sizeof(threadInfo));
7105 7106

    if ((NULL == pidsOfSub) || (NULL == infosOfSub)) {
7107 7108
      free(infos);
      free(pids);
7109

7110
      ERROR_EXIT("memory allocation failed for create threads\n");
7111
    }
7112

S
Shuduo Sang 已提交
7113
    int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
7114
    int threads = g_queryInfo.superQueryInfo.threadCnt;
7115

S
Shuduo Sang 已提交
7116
    int64_t a = ntables / threads;
7117 7118 7119 7120
    if (a < 1) {
      threads = ntables;
      a = 1;
    }
7121

S
Shuduo Sang 已提交
7122
    int64_t b = 0;
7123 7124 7125
    if (threads != 0) {
      b = ntables % threads;
    }
7126

7127
    uint64_t tableFrom = 0;
7128
    for (int i = 0; i < threads; i++) {
7129 7130
      threadInfo *pThreadInfo = infosOfSub + i;
      pThreadInfo->threadID = i;
7131

7132
      pThreadInfo->start_table_from = tableFrom;
7133
      pThreadInfo->ntables = i<b?a+1:a;
7134 7135
      pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
      tableFrom = pThreadInfo->end_table_to + 1;
7136 7137
      pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
      pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
7138 7139
    }

7140
    g_queryInfo.superQueryInfo.threadCnt = threads;
7141
  } else {
7142
    g_queryInfo.superQueryInfo.threadCnt = 0;
7143
  }
7144

7145 7146 7147 7148 7149 7150
  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);
      }
    }
7151
  }
S
Shuaiqiang Chang 已提交
7152

7153
  tmfree((char*)pids);
7154
  tmfree((char*)infos);
7155

7156
  for (int i = 0; i < g_queryInfo.superQueryInfo.threadCnt; i++) {
7157
    pthread_join(pidsOfSub[i], NULL);
H
hzcheng 已提交
7158
  }
H
Hui Li 已提交
7159

7160
  tmfree((char*)pidsOfSub);
7161
  tmfree((char*)infosOfSub);
7162

7163
//  taos_close(taos);// TODO: workaround to use separate taos connection;
7164
  uint64_t endTs = taosGetTimestampMs();
7165

7166
  uint64_t totalQueried = g_queryInfo.specifiedQueryInfo.totalQueried +
7167 7168
    g_queryInfo.superQueryInfo.totalQueried;

7169
  fprintf(stderr, "==== completed total queries: %"PRIu64", the QPS of all threads: %10.3f====\n",
7170
          totalQueried,
7171
          (double)(totalQueried/((endTs-startTs)/1000.0)));
7172 7173 7174
  return 0;
}

7175 7176 7177 7178 7179 7180 7181 7182 7183
static void stable_sub_callback(
        TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
  if (res == NULL || taos_errno(res) != 0) {
    errorPrint("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
           __func__, __LINE__, code, taos_errstr(res));
    return;
  }

  if (param)
7184
    fetchResult(res, (threadInfo *)param);
7185 7186 7187 7188 7189
  // tao_unscribe() will free result.
}

static void specified_sub_callback(
        TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
7190
  if (res == NULL || taos_errno(res) != 0) {
7191 7192
    errorPrint("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
           __func__, __LINE__, code, taos_errstr(res));
7193 7194
    return;
  }
7195

7196
  if (param)
7197
    fetchResult(res, (threadInfo *)param);
7198
  // tao_unscribe() will free result.
H
hzcheng 已提交
7199 7200
}

7201
static TAOS_SUB* subscribeImpl(
7202 7203 7204 7205
        QUERY_CLASS class,
        threadInfo *pThreadInfo,
        char *sql, char* topic, bool restart, uint64_t interval)
{
7206
  TAOS_SUB* tsub = NULL;
H
hzcheng 已提交
7207

7208 7209 7210 7211
  if ((SPECIFIED_CLASS == class)
          && (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode)) {
    tsub = taos_subscribe(
            pThreadInfo->taos,
7212
            restart,
7213
            topic, sql, specified_sub_callback, (void*)pThreadInfo,
7214
            g_queryInfo.specifiedQueryInfo.subscribeInterval);
7215 7216 7217 7218 7219 7220 7221
  } 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);
7222
  } else {
7223 7224
    tsub = taos_subscribe(
            pThreadInfo->taos,
7225
            restart,
7226
            topic, sql, NULL, NULL, interval);
7227
  }
7228

7229 7230 7231
  if (tsub == NULL) {
    printf("failed to create subscription. topic:%s, sql:%s\n", topic, sql);
    return NULL;
7232
  }
7233

7234 7235
  return tsub;
}
H
hzcheng 已提交
7236

7237 7238
static void *superSubscribe(void *sarg) {
  threadInfo *pThreadInfo = (threadInfo *)sarg;
7239
  char subSqlstr[MAX_QUERY_SQL_LENGTH];
7240
  TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT] = {0};
7241
  uint64_t tsubSeq;
H
hzcheng 已提交
7242

7243 7244
  if (pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
      errorPrint("The table number(%"PRId64") of the thread is more than max query sql count: %d\n",
7245 7246 7247 7248 7249
              pThreadInfo->ntables,
              MAX_QUERY_SQL_COUNT);
      exit(-1);
  }

7250
  if (pThreadInfo->taos == NULL) {
7251
    pThreadInfo->taos = taos_connect(g_queryInfo.host,
7252 7253 7254 7255
          g_queryInfo.user,
          g_queryInfo.password,
          g_queryInfo.dbName,
          g_queryInfo.port);
7256
    if (pThreadInfo->taos == NULL) {
7257
      errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
7258
            pThreadInfo->threadID, taos_errstr(NULL));
7259 7260 7261 7262
      return NULL;
    }
  }

7263 7264
  char sqlStr[MAX_TB_NAME_SIZE*2];
  sprintf(sqlStr, "use %s", g_queryInfo.dbName);
7265 7266
  if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
    taos_close(pThreadInfo->taos);
7267 7268
    errorPrint( "use database %s failed!\n\n",
                g_queryInfo.dbName);
7269 7270
    return NULL;
  }
7271

S
Shengliang Guan 已提交
7272 7273 7274
  char topic[32] = {0};
  for (uint64_t i = pThreadInfo->start_table_from;
          i <= pThreadInfo->end_table_to; i++) {
7275 7276

      tsubSeq = i - pThreadInfo->start_table_from;
7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288
      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) {
7289
        sprintf(pThreadInfo->filePath, "%s-%d",
7290 7291 7292 7293 7294 7295
                g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                pThreadInfo->threadID);
      }

      debugPrint("%s() LN%d, [%d] subSqlstr: %s\n",
              __func__, __LINE__, pThreadInfo->threadID, subSqlstr);
7296
      tsub[tsubSeq] = subscribeImpl(
7297 7298 7299 7300
              STABLE_CLASS,
              pThreadInfo, subSqlstr, topic,
              g_queryInfo.superQueryInfo.subscribeRestart,
              g_queryInfo.superQueryInfo.subscribeInterval);
7301
      if (NULL == tsub[tsubSeq]) {
7302
        taos_close(pThreadInfo->taos);
7303 7304
        return NULL;
      }
S
Shengliang Guan 已提交
7305
  }
7306 7307

  // start loop to consume result
7308 7309 7310 7311
  int consumed[MAX_QUERY_SQL_COUNT];
  for (int i = 0; i < MAX_QUERY_SQL_COUNT; i++) {
    consumed[i] = 0;
  }
7312
  TAOS_RES* res = NULL;
7313

7314 7315
  uint64_t st = 0, et = 0;

7316 7317 7318 7319
  while ((g_queryInfo.superQueryInfo.endAfterConsume == -1)
          || (g_queryInfo.superQueryInfo.endAfterConsume <
              consumed[pThreadInfo->end_table_to - pThreadInfo->start_table_from])) {

7320 7321
    for (uint64_t i = pThreadInfo->start_table_from;
            i <= pThreadInfo->end_table_to; i++) {
7322 7323 7324 7325
      tsubSeq = i - pThreadInfo->start_table_from;
      if (ASYNC_MODE == g_queryInfo.superQueryInfo.asyncMode) {
          continue;
      }
7326

7327 7328
      st = taosGetTimestampMs();
      performancePrint("st: %"PRIu64" et: %"PRIu64" st-et: %"PRIu64"\n", st, et, (st - et));
7329
      res = taos_consume(tsub[tsubSeq]);
7330 7331 7332
      et = taosGetTimestampMs();
      performancePrint("st: %"PRIu64" et: %"PRIu64" delta: %"PRIu64"\n", st, et, (et - st));

7333 7334
      if (res) {
          if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
7335
              sprintf(pThreadInfo->filePath, "%s-%d",
7336 7337
                      g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                      pThreadInfo->threadID);
7338
              fetchResult(res, pThreadInfo);
7339 7340
          }
          if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
7341
              sprintf(pThreadInfo->filePath, "%s-%d",
7342 7343
                      g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                      pThreadInfo->threadID);
7344
              fetchResult(res, pThreadInfo);
7345 7346 7347
          }
          consumed[tsubSeq] ++;

7348
          if ((g_queryInfo.superQueryInfo.resubAfterConsume != -1)
7349
                  && (consumed[tsubSeq] >=
7350
                      g_queryInfo.superQueryInfo.resubAfterConsume)) {
7351 7352 7353 7354
              printf("keepProgress:%d, resub super table query: %"PRIu64"\n",
                      g_queryInfo.superQueryInfo.subscribeKeepProgress,
                      pThreadInfo->querySeq);
              taos_unsubscribe(tsub[tsubSeq],
7355
                    g_queryInfo.superQueryInfo.subscribeKeepProgress);
7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368
              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;
              }
          }
      }
H
hzcheng 已提交
7369 7370
    }
  }
7371
  taos_free_result(res);
7372

S
Shengliang Guan 已提交
7373 7374
  for (uint64_t i = pThreadInfo->start_table_from;
          i <= pThreadInfo->end_table_to; i++) {
7375 7376
    tsubSeq = i - pThreadInfo->start_table_from;
    taos_unsubscribe(tsub[tsubSeq], 0);
7377
  }
7378

7379
  taos_close(pThreadInfo->taos);
H
hzcheng 已提交
7380 7381 7382
  return NULL;
}

7383 7384
static void *specifiedSubscribe(void *sarg) {
  threadInfo *pThreadInfo = (threadInfo *)sarg;
7385
//  TAOS_SUB*  tsub = NULL;
7386

7387
  if (pThreadInfo->taos == NULL) {
7388
    pThreadInfo->taos = taos_connect(g_queryInfo.host,
7389 7390 7391 7392
          g_queryInfo.user,
          g_queryInfo.password,
          g_queryInfo.dbName,
          g_queryInfo.port);
7393
    if (pThreadInfo->taos == NULL) {
7394
      errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
7395
            pThreadInfo->threadID, taos_errstr(NULL));
7396 7397 7398 7399
      return NULL;
    }
  }

7400 7401
  char sqlStr[MAX_TB_NAME_SIZE*2];
  sprintf(sqlStr, "use %s", g_queryInfo.dbName);
7402 7403
  if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
    taos_close(pThreadInfo->taos);
7404 7405
    return NULL;
  }
7406

7407 7408 7409 7410
  sprintf(g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
          "taosdemo-subscribe-%"PRIu64"-%d",
          pThreadInfo->querySeq,
          pThreadInfo->threadID);
7411
  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != '\0') {
7412
      sprintf(pThreadInfo->filePath, "%s-%d",
7413 7414 7415
                g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                pThreadInfo->threadID);
  }
7416 7417
  g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] = subscribeImpl(
          SPECIFIED_CLASS, pThreadInfo,
7418
          g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
7419
          g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
7420
          g_queryInfo.specifiedQueryInfo.subscribeRestart,
7421
          g_queryInfo.specifiedQueryInfo.subscribeInterval);
7422
  if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
7423 7424
      taos_close(pThreadInfo->taos);
      return NULL;
S
Shengliang Guan 已提交
7425
  }
7426

7427
  // start loop to consume result
7428

7429
  g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
7430 7431 7432 7433
  while((g_queryInfo.specifiedQueryInfo.endAfterConsume[pThreadInfo->querySeq] == -1)
          || (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] <
              g_queryInfo.specifiedQueryInfo.endAfterConsume[pThreadInfo->querySeq])) {

7434
      if (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode) {
7435 7436
        continue;
      }
7437

7438 7439 7440
      g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID] = taos_consume(
              g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]);
      if (g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]) {
7441 7442
          if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0]
                  != 0) {
7443
              sprintf(pThreadInfo->filePath, "%s-%d",
7444 7445
                      g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                      pThreadInfo->threadID);
7446 7447 7448
              fetchResult(
                      g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID],
                      pThreadInfo);
7449 7450
          }

7451
          g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] ++;
7452
          if ((g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq] != -1)
7453
                && (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] >=
7454 7455 7456 7457
                    g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
              printf("keepProgress:%d, resub specified query: %"PRIu64"\n",
                    g_queryInfo.specifiedQueryInfo.subscribeKeepProgress,
                    pThreadInfo->querySeq);
7458 7459
              g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
              taos_unsubscribe(g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID],
7460
                      g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
7461 7462 7463 7464 7465 7466 7467 7468
              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);
7469
              if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
7470 7471
                  taos_close(pThreadInfo->taos);
                  return NULL;
7472 7473
              }
          }
7474 7475
      }
  }
7476 7477
  taos_free_result(g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]);
  taos_unsubscribe(g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->querySeq], 0);
7478
  taos_close(pThreadInfo->taos);
7479

H
hzcheng 已提交
7480 7481 7482
  return NULL;
}

7483
static int subscribeTestProcess() {
7484
  setupForAnsiEscape();
7485
  printfQueryMeta();
7486
  resetAfterAnsiEscape();
7487

7488
  prompt();
7489

7490 7491 7492 7493 7494
  TAOS * taos = NULL;
  taos = taos_connect(g_queryInfo.host,
          g_queryInfo.user,
          g_queryInfo.password,
          g_queryInfo.dbName,
7495
          g_queryInfo.port);
7496
  if (taos == NULL) {
7497 7498
    errorPrint( "Failed to connect to TDengine, reason:%s\n",
            taos_errstr(NULL));
7499 7500 7501
    exit(-1);
  }

7502
  if (0 != g_queryInfo.superQueryInfo.sqlCount) {
7503 7504
    getAllChildNameOfSuperTable(taos,
            g_queryInfo.dbName,
7505 7506 7507
            g_queryInfo.superQueryInfo.sTblName,
            &g_queryInfo.superQueryInfo.childTblName,
            &g_queryInfo.superQueryInfo.childTblCount);
7508 7509
  }

7510 7511
  taos_close(taos); // TODO: workaround to use separate taos connection;

7512 7513
  pthread_t  *pids = NULL;
  threadInfo *infos = NULL;
7514 7515 7516 7517 7518

  pthread_t  *pidsOfStable  = NULL;
  threadInfo *infosOfStable = NULL;

  //==== create threads for query for specified table
S
Shengliang Guan 已提交
7519
  if (g_queryInfo.specifiedQueryInfo.sqlCount <= 0) {
7520
    debugPrint("%s() LN%d, sepcified query sqlCount %d.\n",
7521
              __func__, __LINE__,
S
Shengliang Guan 已提交
7522 7523 7524
              g_queryInfo.specifiedQueryInfo.sqlCount);
  } else {
    if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
7525
        errorPrint("%s() LN%d, sepcified query sqlCount %d.\n",
S
Shengliang Guan 已提交
7526 7527 7528 7529
              __func__, __LINE__,
              g_queryInfo.specifiedQueryInfo.sqlCount);
        exit(-1);
    }
7530

7531 7532 7533 7534 7535 7536 7537 7538
    pids  = malloc(
            g_queryInfo.specifiedQueryInfo.sqlCount *
            g_queryInfo.specifiedQueryInfo.concurrent *
            sizeof(pthread_t));
    infos = malloc(
            g_queryInfo.specifiedQueryInfo.sqlCount *
            g_queryInfo.specifiedQueryInfo.concurrent *
            sizeof(threadInfo));
S
Shengliang Guan 已提交
7539 7540 7541 7542
    if ((NULL == pids) || (NULL == infos)) {
        errorPrint("%s() LN%d, malloc failed for create threads\n", __func__, __LINE__);
        exit(-1);
    }
7543

7544 7545 7546
    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;
7547 7548 7549 7550 7551
            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);
7552
        }
S
Shengliang Guan 已提交
7553
    }
H
hzcheng 已提交
7554
  }
7555

7556 7557
  //==== create threads for super table query
  if (g_queryInfo.superQueryInfo.sqlCount <= 0) {
7558
    debugPrint("%s() LN%d, super table query sqlCount %d.\n",
7559 7560 7561 7562
              __func__, __LINE__,
              g_queryInfo.superQueryInfo.sqlCount);
  } else {
    if ((g_queryInfo.superQueryInfo.sqlCount > 0)
7563
          && (g_queryInfo.superQueryInfo.threadCnt > 0)) {
7564 7565 7566
        pidsOfStable  = malloc(
                g_queryInfo.superQueryInfo.sqlCount *
                g_queryInfo.superQueryInfo.threadCnt *
7567
            sizeof(pthread_t));
7568 7569 7570
        infosOfStable = malloc(
                g_queryInfo.superQueryInfo.sqlCount *
                g_queryInfo.superQueryInfo.threadCnt *
7571
            sizeof(threadInfo));
7572 7573
        if ((NULL == pidsOfStable) || (NULL == infosOfStable)) {
            errorPrint("%s() LN%d, malloc failed for create threads\n",
7574
              __func__, __LINE__);
7575 7576 7577
            // taos_close(taos);
            exit(-1);
        }
7578

7579 7580
        int64_t ntables = g_queryInfo.superQueryInfo.childTblCount;
        int threads = g_queryInfo.superQueryInfo.threadCnt;
7581

7582 7583 7584 7585 7586
        int64_t a = ntables / threads;
        if (a < 1) {
            threads = ntables;
            a = 1;
        }
7587

7588 7589 7590 7591
        int64_t b = 0;
        if (threads != 0) {
            b = ntables % threads;
        }
7592

7593
        for (uint64_t i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
7594
            uint64_t tableFrom = 0;
7595 7596
            for (int j = 0; j < threads; j++) {
                uint64_t seq = i * threads + j;
7597 7598 7599 7600
                threadInfo *pThreadInfo = infosOfStable + seq;
                pThreadInfo->threadID = seq;
                pThreadInfo->querySeq = i;

7601
                pThreadInfo->start_table_from = tableFrom;
7602
                pThreadInfo->ntables = j<b?a+1:a;
7603 7604
                pThreadInfo->end_table_to = j<b?tableFrom+a:tableFrom+a-1;
                tableFrom = pThreadInfo->end_table_to + 1;
7605
                pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
7606
                pthread_create(pidsOfStable + seq,
7607
                        NULL, superSubscribe, pThreadInfo);
7608 7609
            }
        }
7610

7611
        g_queryInfo.superQueryInfo.threadCnt = threads;
7612

7613 7614 7615 7616 7617 7618
        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);
            }
        }
7619
    }
H
hzcheng 已提交
7620
  }
7621

7622 7623 7624 7625 7626
  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);
    }
7627
  }
H
hzcheng 已提交
7628

7629
  tmfree((char*)pids);
7630
  tmfree((char*)infos);
H
hzcheng 已提交
7631

7632 7633
  tmfree((char*)pidsOfStable);
  tmfree((char*)infosOfStable);
7634
//   taos_close(taos);
7635
  return 0;
H
hzcheng 已提交
7636 7637
}

7638
static void initOfInsertMeta() {
7639
  memset(&g_Dbs, 0, sizeof(SDbs));
7640

7641
  // set default values
7642
  tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
7643
  g_Dbs.port = 6030;
7644 7645
  tstrncpy(g_Dbs.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
  tstrncpy(g_Dbs.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
7646
  g_Dbs.threadCount = 2;
7647 7648

  g_Dbs.use_metric = g_args.use_metric;
L
Liu Tao 已提交
7649 7650
}

7651
static void initOfQueryMeta() {
7652
  memset(&g_queryInfo, 0, sizeof(SQueryMetaInfo));
7653

7654
  // set default values
7655
  tstrncpy(g_queryInfo.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
7656
  g_queryInfo.port = 6030;
7657 7658
  tstrncpy(g_queryInfo.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
  tstrncpy(g_queryInfo.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
L
Liu Tao 已提交
7659 7660
}

7661
static void setParaFromArg(){
7662
  if (g_args.host) {
7663
    tstrncpy(g_Dbs.host, g_args.host, MAX_HOSTNAME_SIZE);
7664
  } else {
7665
    tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
7666
  }
L
Liu Tao 已提交
7667

7668
  if (g_args.user) {
7669
    tstrncpy(g_Dbs.user, g_args.user, MAX_USERNAME_SIZE);
7670
  }
7671 7672

  if (g_args.password) {
7673
    tstrncpy(g_Dbs.password, g_args.password, MAX_PASSWORD_SIZE);
7674 7675
  }

7676 7677
  if (g_args.port) {
    g_Dbs.port = g_args.port;
7678
  }
L
Liu Tao 已提交
7679

7680 7681 7682
  g_Dbs.threadCount = g_args.num_of_threads;
  g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;

7683
  g_Dbs.dbCount = 1;
7684
  g_Dbs.db[0].drop = true;
7685

7686
  tstrncpy(g_Dbs.db[0].dbName, g_args.database, MAX_DB_NAME_SIZE);
7687
  g_Dbs.db[0].dbCfg.replica = g_args.replica;
7688
  tstrncpy(g_Dbs.db[0].dbCfg.precision, "ms", MAX_DB_NAME_SIZE);
L
Liu Tao 已提交
7689

7690
  tstrncpy(g_Dbs.resultFile, g_args.output_file, MAX_FILE_NAME_LEN);
7691 7692 7693 7694 7695

  g_Dbs.use_metric = g_args.use_metric;
  g_Dbs.insert_only = g_args.insert_only;

  g_Dbs.do_aggreFunc = true;
L
Liu Tao 已提交
7696

7697 7698
  char dataString[STRING_LEN];
  char **data_type = g_args.datatype;
7699

7700
  memset(dataString, 0, STRING_LEN);
L
Liu Tao 已提交
7701

7702 7703
  if (strcasecmp(data_type[0], "BINARY") == 0
          || strcasecmp(data_type[0], "BOOL") == 0
7704
          || strcasecmp(data_type[0], "NCHAR") == 0 ) {
7705
    g_Dbs.do_aggreFunc = false;
L
Liu Tao 已提交
7706
  }
H
hzcheng 已提交
7707

7708 7709 7710 7711 7712
  if (g_args.use_metric) {
    g_Dbs.db[0].superTblCount = 1;
    tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", MAX_TB_NAME_SIZE);
    g_Dbs.db[0].superTbls[0].childTblCount = g_args.num_of_tables;
    g_Dbs.threadCount = g_args.num_of_threads;
7713
    g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
7714
    g_Dbs.asyncMode = g_args.async_mode;
7715

7716 7717 7718 7719
    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;
7720
    tstrncpy(g_Dbs.db[0].superTbls[0].childTblPrefix,
7721 7722
            g_args.tb_prefix, MAX_TB_NAME_SIZE);
    tstrncpy(g_Dbs.db[0].superTbls[0].dataSource, "rand", MAX_TB_NAME_SIZE);
7723
    g_Dbs.db[0].superTbls[0].iface = g_args.iface;
7724
    tstrncpy(g_Dbs.db[0].superTbls[0].startTimestamp,
7725
            "2017-07-14 10:40:00.000", MAX_TB_NAME_SIZE);
7726
    g_Dbs.db[0].superTbls[0].timeStampStep = DEFAULT_TIMESTAMP_STEP;
7727

7728
    g_Dbs.db[0].superTbls[0].insertRows = g_args.num_of_DPT;
7729
    g_Dbs.db[0].superTbls[0].maxSqlLen = g_args.max_sql_len;
7730

7731 7732 7733 7734 7735
    g_Dbs.db[0].superTbls[0].columnCount = 0;
    for (int i = 0; i < MAX_NUM_DATATYPE; i++) {
      if (data_type[i] == NULL) {
        break;
      }
7736

7737
      tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
7738
              data_type[i], MAX_TB_NAME_SIZE);
7739
      g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.len_of_binary;
7740 7741
      g_Dbs.db[0].superTbls[0].columnCount++;
    }
7742

7743 7744 7745
    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 {
7746 7747 7748 7749
      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,
                "INT", MAX_TB_NAME_SIZE);
7750
        g_Dbs.db[0].superTbls[0].columns[i].dataLen = 0;
7751 7752 7753
        g_Dbs.db[0].superTbls[0].columnCount++;
      }
    }
7754

7755 7756
    tstrncpy(g_Dbs.db[0].superTbls[0].tags[0].dataType,
            "INT", MAX_TB_NAME_SIZE);
7757
    g_Dbs.db[0].superTbls[0].tags[0].dataLen = 0;
7758

7759 7760
    tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType,
            "BINARY", MAX_TB_NAME_SIZE);
7761 7762
    g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.len_of_binary;
    g_Dbs.db[0].superTbls[0].tagCount = 2;
7763
  } else {
7764 7765
    g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
    g_Dbs.db[0].superTbls[0].tagCount = 0;
H
hzcheng 已提交
7766
  }
7767 7768 7769 7770 7771 7772
}

/* Function to do regular expression check */
static int regexMatch(const char *s, const char *reg, int cflags) {
  regex_t regex;
  char    msgbuf[100] = {0};
H
hzcheng 已提交
7773

7774 7775 7776
  /* Compile regular expression */
  if (regcomp(&regex, reg, cflags) != 0) {
    printf("Fail to compile regex\n");
H
Hui Li 已提交
7777 7778 7779
    exit(-1);
  }

7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803
  /* 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);
  }

  return 0;
}

static int isCommentLine(char *line) {
  if (line == NULL) return 1;

  return regexMatch(line, "^\\s*#.*", REG_EXTENDED);
}

7804
static void querySqlFile(TAOS* taos, char* sqlFile)
7805 7806 7807 7808 7809 7810
{
  FILE *fp = fopen(sqlFile, "r");
  if (fp == NULL) {
    printf("failed to open file %s, reason:%s\n", sqlFile, strerror(errno));
    return;
  }
7811

7812 7813 7814 7815 7816 7817
  int       read_len = 0;
  char *    cmd = calloc(1, MAX_SQL_SIZE);
  size_t    cmd_len = 0;
  char *    line = NULL;
  size_t    line_len = 0;

7818
  double t = taosGetTimestampMs();
7819

7820
  while((read_len = tgetline(&line, &line_len, fp)) != -1) {
7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832
    if (read_len >= MAX_SQL_SIZE) continue;
    line[--read_len] = '\0';

    if (read_len == 0 || isCommentLine(line)) {  // line starts with #
      continue;
    }

    if (line[read_len - 1] == '\\') {
      line[read_len - 1] = ' ';
      memcpy(cmd + cmd_len, line, read_len);
      cmd_len += read_len;
      continue;
7833
    }
7834 7835

    memcpy(cmd + cmd_len, line, read_len);
7836 7837 7838
    if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE, false)) {
        errorPrint("%s() LN%d, queryDbExec %s failed!\n",
               __func__, __LINE__, cmd);
7839 7840 7841 7842 7843
        tmfree(cmd);
        tmfree(line);
        tmfclose(fp);
        return;
    }
7844 7845
    memset(cmd, 0, MAX_SQL_SIZE);
    cmd_len = 0;
H
hzcheng 已提交
7846 7847
  }

7848
  t = taosGetTimestampMs() - t;
7849
  printf("run %s took %.6f second(s)\n\n", sqlFile, t);
7850

7851 7852 7853 7854
  tmfree(cmd);
  tmfree(line);
  tmfclose(fp);
  return;
H
hzcheng 已提交
7855 7856
}

7857
static void testMetaFile() {
7858
    if (INSERT_TEST == g_args.test_mode) {
7859 7860
      if (g_Dbs.cfgDir[0])
          taos_options(TSDB_OPTION_CONFIGDIR, g_Dbs.cfgDir);
7861

7862
      insertTestProcess();
7863

7864
    } else if (QUERY_TEST == g_args.test_mode) {
7865 7866
      if (g_queryInfo.cfgDir[0])
          taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
7867

7868
      queryTestProcess();
7869

7870
    } else if (SUBSCRIBE_TEST == g_args.test_mode) {
7871 7872
      if (g_queryInfo.cfgDir[0])
          taos_options(TSDB_OPTION_CONFIGDIR, g_queryInfo.cfgDir);
7873

7874
      subscribeTestProcess();
7875

7876 7877 7878
    }  else {
      ;
    }
7879
}
7880

7881
static void queryResult() {
7882
  // query data
7883

7884
  pthread_t read_id;
7885 7886 7887 7888
  threadInfo *pThreadInfo = malloc(sizeof(threadInfo));
  assert(pThreadInfo);
  pThreadInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
  pThreadInfo->start_table_from = 0;
7889

7890
  //pThreadInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
7891
  if (g_args.use_metric) {
7892 7893 7894 7895
    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,
7896 7897
          g_Dbs.db[0].superTbls[0].childTblPrefix, MAX_TB_NAME_SIZE);
  } else {
7898 7899 7900
    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, MAX_TB_NAME_SIZE);
7901 7902
  }

7903
  pThreadInfo->taos = taos_connect(
7904 7905 7906 7907 7908
          g_Dbs.host,
          g_Dbs.user,
          g_Dbs.password,
          g_Dbs.db[0].dbName,
          g_Dbs.port);
7909
  if (pThreadInfo->taos == NULL) {
7910 7911
    errorPrint( "Failed to connect to TDengine, reason:%s\n",
            taos_errstr(NULL));
7912
    free(pThreadInfo);
7913 7914 7915
    exit(-1);
  }

7916
  tstrncpy(pThreadInfo->filePath, g_Dbs.resultFile, MAX_FILE_NAME_LEN);
7917 7918

  if (!g_Dbs.use_metric) {
7919
    pthread_create(&read_id, NULL, readTable, pThreadInfo);
7920
  } else {
7921
    pthread_create(&read_id, NULL, readMetric, pThreadInfo);
7922 7923
  }
  pthread_join(read_id, NULL);
7924 7925
  taos_close(pThreadInfo->taos);
  free(pThreadInfo);
7926 7927
}

7928 7929
static void testCmdLine() {

7930 7931 7932 7933 7934 7935 7936 7937 7938 7939
  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);
  }

7940 7941
  g_args.test_mode = INSERT_TEST;
  insertTestProcess();
7942

7943
  if (false == g_Dbs.insert_only)
7944
    queryResult();
7945 7946
}

7947 7948 7949
int main(int argc, char *argv[]) {
  parse_args(argc, argv, &g_args);

7950
  debugPrint("meta file: %s\n", g_args.metaFile);
7951 7952 7953

  if (g_args.metaFile) {
    initOfInsertMeta();
7954
    initOfQueryMeta();
7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967

    if (false == getInfoFromJsonFile(g_args.metaFile)) {
      printf("Failed to read %s\n", g_args.metaFile);
      return 1;
    }

    testMetaFile();
  } else {
    memset(&g_Dbs, 0, sizeof(SDbs));
    setParaFromArg();

    if (NULL != g_args.sqlFile) {
      TAOS* qtaos = taos_connect(
7968 7969 7970 7971
          g_Dbs.host,
          g_Dbs.user,
          g_Dbs.password,
          g_Dbs.db[0].dbName,
7972
          g_Dbs.port);
7973
      querySqlFile(qtaos, g_args.sqlFile);
7974 7975 7976 7977 7978
      taos_close(qtaos);

    } else {
      testCmdLine();
    }
7979 7980 7981

    if (g_dupstr)
        free(g_dupstr);
H
hzcheng 已提交
7982
  }
7983 7984

  return 0;
H
hzcheng 已提交
7985
}
7986