feat(shell): add port to 3.0 buld ok

include/util/tthread.h

@@ -23,7 +23,7 @@ extern "C" {
 #endif
 
 TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param);
-bool       taosDestoryThread(TdThread* pthread);
+bool       taosDestroyThread(TdThread* pthread);
 bool       taosThreadRunning(TdThread* pthread);
 
 typedef void *(*ThreadFp)(void *param);

source/util/src/tthread.c

@@ -31,7 +31,7 @@ TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) {
   return pthread;
 }
 
-bool taosDestoryThread(TdThread* pthread) {
+bool taosDestroyThread(TdThread* pthread) {
   if (pthread == NULL) return false;
   if (taosThreadRunning(pthread)) {
     taosThreadCancel(*pthread);

tools/shell/inc/shellAuto.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SHELL_AUTO__
+#define __SHELL_AUTO__
+
+#define TAB_KEY 0x09
+
+// press tab key
+void pressTabKey(SShellCmd* cmd);
+
+// press othr key
+void pressOtherKey(char c);
+
+// init shell auto funciton , shell start call once 
+bool shellAutoInit();
+
+// set conn
+void shellSetConn(TAOS* conn);
+
+// exit shell auto funciton, shell exit call once
+void shellAutoExit();
+
+// callback autotab module
+void callbackAutoTab(char* sqlstr, TAOS* pSql, bool usedb);
+
+
+#endif

tools/shell/inc/shellInt.h

@@ -102,6 +102,16 @@ typedef struct {
 #endif
 } SShellObj;
 
+typedef struct {
+  char    *buffer;
+  char    *command;
+  uint32_t commandSize;
+  uint32_t bufferSize;
+  uint32_t cursorOffset;
+  uint32_t screenOffset;
+  uint32_t endOffset;
+} SShellCmd;
+
 // shellArguments.c
 int32_t shellParseArgs(int32_t argc, char* argv[]);
 

tools/shell/inc/tire.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __TRIE__
+#define __TRIE__
+
+// 
+// The prefix search tree is a efficient storage words and search words tree, it support 95 visible ascii code character
+//
+#define FIRST_ASCII 40   // first visiable char is '0'
+#define LAST_ASCII  122  // last visilbe char is 'z'
+
+// capacity save char is 95
+#define CHAR_CNT   (LAST_ASCII - FIRST_ASCII + 1)
+#define MAX_WORD_LEN 256 // max insert word length
+
+// define STire
+#define TIRE_TREE  0
+#define TIRE_LIST  1
+
+typedef struct STireNode {
+    struct STireNode** d;
+    bool   end; // record end flag  
+}STireNode;
+
+typedef struct StrName {
+    char * name;
+    struct StrName * next;
+}StrName;
+
+
+typedef struct STire {
+    char type;  // see define TIRE_
+    STireNode root;
+
+    StrName *  head;
+    StrName *  tail;
+
+    int count;      // all count 
+    int ref;
+}STire;
+
+typedef struct SMatchNode {
+    char* word;
+    struct SMatchNode* next;
+}SMatchNode;
+
+
+typedef struct SMatch {
+    SMatchNode* head;
+    SMatchNode* tail;  // append node to tail
+    int count;
+    char pre[MAX_WORD_LEN];
+}SMatch;
+
+
+// ----------- interface -------------
+
+// create prefix search tree, return value call freeTire to free 
+STire* createTire(char type);
+
+// destroy prefix search tree
+void freeTire(STire* tire);
+
+// add a new word 
+bool insertWord(STire* tire, char* word);
+
+// add a new word 
+bool deleteWord(STire* tire, char* word);
+
+// match prefix words, if match is not NULL , put all item to match and return match
+SMatch* matchPrefix(STire* tire, char* prefix, SMatch* match);
+
+// get all items from tires tree
+SMatch* enumAll(STire* tire);
+
+// free match result
+void freeMatch(SMatch* match);
+
+#endif

tools/shell/src/shellAuto.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define __USE_XOPEN
+
+#include "shellInt.h"
+#include "shellAuto.h"
+#include "tire.h"
+#include "tthread.h"
+
+//
+// ------------- define area  ---------------
+//
+#define UNION_ALL " union all "
+
+
+// extern function
+void  shellClearScreen(int32_t ecmd_pos, int32_t cursor_pos);
+void  shellGetPrevCharSize(const char *str, int32_t pos, int32_t *size, int32_t *width);
+void  shellShowOnScreen(SShellCmd *cmd);
+void  shellInsertChar(SShellCmd *cmd, char *c, int size);
+
+
+typedef struct SAutoPtr {
+  STire* p;
+  int ref;
+}SAutoPtr;
+
+typedef struct SWord{
+  int type ; // word type , see WT_ define
+  char * word;
+  int32_t len;
+  struct SWord * next;
+  bool free;  // if true need free
+}SWord;
+
+typedef struct {
+  char * source;
+  int32_t source_len; // valid data length in source
+  int32_t count;
+  SWord*  head;
+  // matched information
+  int32_t matchIndex;    // matched word index in words
+  int32_t matchLen;     // matched length at matched word
+}SWords;
+
+
+SWords shellCommands[] = {
+  {"alter database <db_name> <db_options> <anyword> <db_options> <anyword> <db_options> <anyword> <db_options> <anyword> <db_options> <anyword> <db_options> <anyword>", 0, 0, NULL},
+  {"alter dnode <dnode_id> balance ", 0, 0, NULL},
+  {"alter dnode <dnode_id> resetlog;", 0, 0, NULL},
+  {"alter dnode <dnode_id> debugFlag 141;", 0, 0, NULL},
+  {"alter dnode <dnode_id> monitor 1;", 0, 0, NULL},
+  {"alter table <tb_name> <tb_actions>", 0, 0, NULL},
+  {"alter table modify column", 0, 0, NULL},
+  {"alter local resetlog;", 0, 0, NULL},
+  {"alter local DebugFlag 143;", 0, 0, NULL},
+  {"alter local cDebugFlag 143;", 0, 0, NULL},
+  {"alter local uDebugFlag 143;", 0, 0, NULL},
+  {"alter local rpcDebugFlag 143;", 0, 0, NULL},
+  {"alter local tmrDebugFlag 143;", 0, 0, NULL},
+  {"alter topic", 0, 0, NULL},
+  {"alter user <user_name> pass", 0, 0, NULL},
+  {"alter user <user_name> privilege read", 0, 0, NULL},
+  {"alter user <user_name> privilege write", 0, 0, NULL},
+  {"create table <anyword> using <stb_name> tags(", 0, 0, NULL},
+  {"create database ", 0, 0, NULL},
+  {"create table <anyword> as ", 0, 0, NULL},
+  {"create dnode ", 0, 0, NULL},
+  {"create topic", 0, 0, NULL},
+  {"create function ", 0, 0, NULL},
+  {"create user <anyword> pass", 0, 0, NULL},
+  {"compact vnode in", 0, 0, NULL},
+  {"describe <all_table>", 0, 0, NULL},
+#ifdef TD_ENTERPRISE
+  {"delete from <all_table> where", 0, 0, NULL},
+#endif
+  {"drop database <db_name>", 0, 0, NULL},
+  {"drop table <all_table> ", 0, 0, NULL},
+  {"drop dnode <dnode_id>", 0, 0, NULL},
+  {"drop user <user_name> ;", 0, 0, NULL},
+  {"drop function", 0, 0, NULL},
+  {"drop topic", 0, 0, NULL},
+  {"kill connection", 0, 0, NULL},
+  {"kill query", 0, 0, NULL},
+  {"kill stream", 0, 0, NULL},
+  {"select * from <all_table> where ", 0, 0, NULL},
+  {"select _block_dist() from <all_table> \\G;", 0, 0, NULL},
+  {"select client_version();", 0, 0, NULL},
+  {"select current_user();", 0, 0, NULL},
+  {"select database;", 0, 0, NULL},
+  {"select server_version();", 0, 0, NULL},
+  {"set max_binary_display_width ", 0, 0, NULL},
+  {"show create database <db_name> \\G;", 0, 0, NULL},
+  {"show create stable <stb_name> \\G;", 0, 0, NULL},
+  {"show create table <tb_name> \\G;", 0, 0, NULL},
+  {"show connections;", 0, 0, NULL},
+  {"show databases;", 0, 0, NULL},
+  {"show dnodes;", 0, 0, NULL},
+  {"show functions;", 0, 0, NULL},
+  {"show modules;", 0, 0, NULL},
+  {"show mnodes;", 0, 0, NULL},
+  {"show queries;", 0, 0, NULL},
+  {"show stables;", 0, 0, NULL},
+  {"show stables like ", 0, 0, NULL},
+  {"show streams;", 0, 0, NULL},
+  {"show scores;", 0, 0, NULL},
+  {"show tables;", 0, 0, NULL},
+  {"show tables like", 0, 0, NULL},
+  {"show users;", 0, 0, NULL},
+  {"show variables;", 0, 0, NULL},
+  {"show vgroups;", 0, 0, NULL},
+  {"insert into <tb_name> values(", 0, 0, NULL},
+  {"insert into <tb_name> using <stb_name> tags(", 0, 0, NULL},
+  {"use <db_name>", 0, 0, NULL},
+  {"quit", 0, 0, NULL}
+};
+
+char * keywords[] = {
+  "and ",
+  "asc ",
+  "desc ",
+  "from ",
+  "fill(",
+  "limit ",
+  "where ",
+  "interval(",
+  "order by ",
+  "order by ",
+  "offset ",
+  "or ",
+  "group by ",
+  "now()",
+  "session(",
+  "sliding ",
+  "slimit ",
+  "soffset ",
+  "state_window(",
+  "today() ",
+  "union all select ",
+};
+
+char * functions[] = {
+  "count(",
+  "sum(",
+  "avg(",
+  "last(",
+  "last_row(",
+  "top(",
+  "interp(",
+  "max(",
+  "min(",
+  "now()",
+  "today()",
+  "percentile(",
+  "tail(",
+  "pow(",  
+  "abs(",
+  "atan(",
+  "acos(",
+  "asin(",
+  "apercentile(",
+  "bottom(",
+  "cast(",
+  "ceil(",
+  "char_length(",
+  "cos(",
+  "concat(",
+  "concat_ws(",
+  "csum(",
+  "diff(",
+  "derivative(",
+  "elapsed(",
+  "first(",
+  "floor(",
+  "hyperloglog(",
+  "histogram(",
+  "irate(",
+  "leastsquares(",
+  "length(",
+  "log(",
+  "lower(",
+  "ltrim(",
+  "mavg(",
+  "mode(",
+  "tan(",
+  "round(",
+  "rtrim(",
+  "sample(",
+  "sin(",
+  "spread(",
+  "substr(",
+  "statecount(",
+  "stateduration(",
+  "stddev(",
+  "sqrt(",
+  "timediff(",
+  "timezone(",
+  "timetruncate(",
+  "twa(",
+  "to_unixtimestamp(",
+  "unique(",
+  "upper(",
+};
+
+char * tb_actions[] = {
+  "add column",
+  "modify column",
+  "drop column",
+  "change tag",
+};
+
+char * db_options[] = {
+  "blocks",
+  "cachelast",
+  "comp",
+  "keep",
+  "replica",
+  "quorum",
+};
+
+char * data_types[] = {
+  "timestamp",
+  "int",
+  "float",
+  "double",
+  "binary(16)",
+  "nchar(16)",
+  "bigint",
+  "smallint",
+  "tinyint",
+  "bool",
+  "json"
+};
+
+char * key_tags[] = {
+  "tags("
+};
+
+
+//
+//  ------- gobal variant define ---------
+//
+int32_t firstMatchIndex = -1; // first match shellCommands index
+int32_t lastMatchIndex  = -1; // last match shellCommands index
+int32_t curMatchIndex   = -1; // current match shellCommands index
+int32_t lastWordBytes   = -1; // printShow last word length 
+bool    waitAutoFill    = false;
+
+
+//
+//   ----------- global var array define -----------
+//
+#define WT_VAR_DBNAME   0
+#define WT_VAR_STABLE   1
+#define WT_VAR_TABLE    2
+#define WT_VAR_DNODEID  3
+#define WT_VAR_USERNAME 4
+#define WT_VAR_ALLTABLE 5
+#define WT_VAR_FUNC     6
+#define WT_VAR_KEYWORD  7
+#define WT_VAR_TBACTION 8
+#define WT_VAR_DBOPTION 9
+#define WT_VAR_DATATYPE 10
+#define WT_VAR_KEYTAGS  11
+#define WT_VAR_ANYWORD  12
+#define WT_VAR_CNT      13
+
+#define WT_FROM_DB_MAX  4  // max get content from db
+#define WT_FROM_DB_CNT  (WT_FROM_DB_MAX + 1)
+
+#define WT_TEXT       0xFF
+
+char dbName[256] = ""; // save use database name;
+// tire array
+STire* tires[WT_VAR_CNT];
+TdThreadMutex tiresMutex;
+//save thread handle obtain var name from db server
+TdThread* threads[WT_FROM_DB_CNT];
+// obtain var name  with sql from server
+char varTypes[WT_VAR_CNT][64] = {
+  "<db_name>",
+  "<stb_name>",
+  "<tb_name>",
+  "<dnode_id>",
+  "<user_name>",
+  "<all_table>",
+  "<function>",
+  "<keyword>",
+  "<tb_actions>",
+  "<db_options>",
+  "<data_types>",
+  "<key_tags>",
+  "<anyword>"
+};
+
+char varSqls[WT_FROM_DB_CNT][64] = {
+  "show databases;",
+  "show stables;",
+  "show tables;",
+  "show dnodes;",
+  "show users;"
+};
+
+
+// var words current cursor, if user press any one key except tab, cursorVar can be reset to -1
+int cursorVar = -1;
+bool varMode = false; // enter var names list mode
+
+
+TAOS*    varCon    = NULL;
+SShellCmd* varCmd    = NULL;
+SMatch*  lastMatch = NULL; // save last match result 
+int      cntDel    = 0;   // delete byte count after next press tab
+
+
+// show auto tab introduction
+void printfIntroduction() {
+  printf("   *********************  How to Use TAB in TAOS Shell ******************************\n"); 
+  printf("   *   Taos shell supports pressing TAB key to complete word. You can try it.       *\n"); 
+  printf("   *   Press TAB key anywhere, You'll get surprise.                                 *\n");
+  printf("   *   KEYBOARD SHORTCUT:                                                           *\n");
+  printf("   *    [ TAB ]        ......  Complete the word or show help if no input           *\n");
+  printf("   *    [ Ctrl + A ]   ......  move cursor to [A]head of line                       *\n");
+  printf("   *    [ Ctrl + E ]   ......  move cursor to [E]nd of line                         *\n");
+  printf("   *    [ Ctrl + W ]   ......  move cursor to line of middle                        *\n");  
+  printf("   *    [ Ctrl + L ]   ......  clean screen                                         *\n");
+  printf("   *    [ Ctrl + K ]   ......  clean after cursor                                   *\n");
+  printf("   *    [ Ctrl + U ]   ......  clean before cursor                                  *\n");
+  printf("   *                                                                                *\n");
+  printf("   **********************************************************************************\n\n"); 
+}
+
+void showHelp() {
+  printf("\nThe following are supported commands for Taos shell:");
+  printf("\n\
+  ----- A ----- \n\
+    alter database <db_name> <db_options> \n\
+    alter dnode <dnode_id> balance \n\
+    alter dnode <dnode_id> resetlog;\n\
+    alter dnode <dnode_id> DebugFlag 143;\n\
+    alter dnode <dnode_id> monitor 1;\n\
+    alter table <tb_name> ADD COLUMN <field_name> <data_type>; \n\
+    alter table <tb_name> DROP COLUMN <field_name>; \n\
+    alter table <tb_name> MODIFY COLUMN <field_name> <data_type(length)>;\n\
+    alter local resetlog; \n\
+    alter local DebugFlag 143; \n\
+    alter topic <topic_name>\n\
+    alter user <user_name> pass\n\
+    alter user <user_name> privilege read ;\n\
+    alter user <user_name> privilege write ;\n\
+  ----- C ----- \n\
+    create table <tb_name> using <stb_name> tags ...\n\
+    create database <db_name>;\n\
+    create table <anyword> as ...\n\
+    create dnode <dnode_id>\n\
+    create topic <top_name>\n\
+    create function <function_name>\n\
+    create user <user_name> pass <password>;\n\
+    compact vnode in (vgid,vgid,vgid);\n\
+  ----- D ----- \n\
+    describe <all_table> ;\n\
+    delete from <all_table> where ... \n\
+    drop database <db_name>;\n\
+    drop table <all_table>;\n\
+    drop dnode <dnode_id>;\n\
+    drop function <function_id>;\n\
+    drop topic <topic_id>;\n\
+    drop user <user_name>;\n\
+  ----- K ----- \n\
+    kill connection <connection_id>; \n\
+    kill query <query_id>; \n\
+    kill stream <stream_id>; \n\
+  ----- S ----- \n\
+    select * from <all_table> where ... \n\
+    select _block_dist() from <all_table>;\n\
+    select client_version();\n\
+    select current_user();\n\
+    select database;\n\
+    select server_version();\n\
+    set max_binary_display_width <width>;  \n\
+    show create database <db_name>;\n\
+    show create stable <stb_name>;\n\
+    show create table <tb_name>;\n\
+    show connections;\n\
+    show databases;\n\
+    show dnodes;\n\
+    show functions;\n\
+    show modules;\n\
+    show mnodes;\n\
+    show queries;\n\
+    show stables;\n\
+    show stables like '<regular expression>';  note: regular expression only support '_' and '%%' match.\n\
+    show streams;\n\
+    show scores;\n\
+    show tables;\n\
+    show tables like '<regular expression>'; \n\
+    show users;\n\
+    show variables;\n\
+    show vgroups;\n\
+  ----- I ----- \n\
+    insert into <tb_name> values(...) ;\n\
+  ----- U ----- \n\
+    use <db_name>;");
+
+  printf("\n\n");
+  
+  //define in getDuration() function
+  printf("\
+  Timestamp expression Format:\n\
+    b - nanosecond \n\
+    u - microsecond \n\
+    a - millisecond \n\
+    s - second \n\
+    m - minute \n\
+    h - hour \n\
+    d - day \n\
+    w - week \n\
+    now - current time \n\
+  Example : \n\
+    select * from t1 where ts > now - 2w + 3d and ts <= now - 1w -2h ;\n");
+  printf("\n");
+}
+
+//
+//  -------------------  parse words --------------------------
+//
+
+#define SHELL_COMMAND_COUNT() (sizeof(shellCommands) / sizeof(SWords))
+
+// get at
+SWord * atWord(SWords * command, int32_t index) {
+  SWord * word = command->head;
+  for (int32_t i = 0; i < index; i++) {
+    if (word == NULL)
+      return NULL;
+    word = word->next;
+  }
+
+  return word;
+}
+
+#define MATCH_WORD(x) atWord(x, x->matchIndex)
+
+int wordType(const char* p, int32_t len) {
+  for (int i = 0; i < WT_VAR_CNT; i++) {
+    if (strncmp(p, varTypes[i], len) == 0)
+        return i;
+  }
+  return WT_TEXT;
+}
+
+// add word
+SWord * addWord(const char* p, int32_t len, bool pattern) {
+  SWord* word = (SWord *) taosMemoryMalloc(sizeof(SWord));
+  memset(word, 0, sizeof(SWord));
+  word->word = (char* )p;
+  word->len  = len;
+
+  // check format
+  if (pattern) {
+    word->type = wordType(p, len);
+  } else {
+    word->type = WT_TEXT;
+  }
+
+  return word;
+}
+
+// parse one command
+void parseCommand(SWords * command, bool pattern) {
+  char * p = command->source;
+  int32_t start = 0;
+  int32_t size  = command->source_len > 0 ? command->source_len : strlen(p);
+
+  bool lastBlank = false;
+  for (int i = 0; i <= size; i++) {
+    if (p[i] == ' ' || i == size) {
+      // check continue blank like '    '
+      if (p[i] == ' ') {
+        if (lastBlank) {
+          start ++;
+          continue;
+        }
+        if (i == 0) { // first blank
+          lastBlank = true;
+          start ++;
+          continue;
+        }
+        lastBlank = true;
+      } 
+
+      // found split or string end , append word
+      if (command->head == NULL) {
+        command->head = addWord(p + start, i - start, pattern);
+        command->count = 1;
+      } else {
+        SWord * word = command->head;
+        while (word->next) {
+          word = word->next;
+        }
+        word->next = addWord(p + start, i - start, pattern);
+        command->count ++;
+      }
+      start = i + 1;
+    } else {
+      lastBlank = false;
+    }
+  }
+}
+
+// free SShellCmd
+void freeCommand(SWords * command) {
+  SWord * word = command->head;
+  if (word == NULL) {
+    return ;
+  }
+
+  // loop 
+  while (word->next) {
+    SWord * tmp = word;
+    word = word->next;
+    // if malloc need free
+    if(tmp->free && tmp->word)
+      taosMemoryFree(tmp->word);
+    taosMemoryFree(tmp);
+  }
+
+  // if malloc need free
+  if(word->free && word->word)
+    taosMemoryFree(word->word);
+  taosMemoryFree(word);
+}
+
+void GenerateVarType(int type, char** p, int count) {
+  STire* tire = createTire(TIRE_LIST);
+  for (int i = 0; i < count; i++) {
+    insertWord(tire, p[i]);
+  }
+
+  taosThreadMutexLock(&tiresMutex);
+  tires[type] = tire;
+  taosThreadMutexUnlock(&tiresMutex);
+}
+
+//
+//  -------------------- shell auto ----------------
+//
+
+
+// init shell auto funciton , shell start call once 
+bool shellAutoInit() {
+  // command
+  int32_t count = SHELL_COMMAND_COUNT();
+  for (int32_t i = 0; i < count; i ++) {
+    parseCommand(shellCommands + i, true);
+  }
+
+  // tires
+  memset(tires, 0, sizeof(STire*) * WT_VAR_CNT);
+  taosThreadMutexInit(&tiresMutex, NULL);
+
+  // threads
+  memset(threads, 0, sizeof(TdThread*) * WT_FROM_DB_CNT);
+
+  // generate varType
+  GenerateVarType(WT_VAR_FUNC,     functions,  sizeof(functions)  /sizeof(char *));
+  GenerateVarType(WT_VAR_KEYWORD,  keywords,   sizeof(keywords)   /sizeof(char *));
+  GenerateVarType(WT_VAR_DBOPTION, db_options, sizeof(db_options) /sizeof(char *));
+  GenerateVarType(WT_VAR_TBACTION, tb_actions, sizeof(tb_actions) /sizeof(char *));
+  GenerateVarType(WT_VAR_DATATYPE, data_types, sizeof(data_types) /sizeof(char *));
+  GenerateVarType(WT_VAR_KEYTAGS,  key_tags,   sizeof(key_tags)   /sizeof(char *));
+
+  printfIntroduction();
+
+  return true;
+}
+
+// set conn
+void shellSetConn(TAOS* conn) {
+  varCon = conn;
+}
+
+// exit shell auto funciton, shell exit call once
+void shellAutoExit() {
+  // free command
+  int32_t count = SHELL_COMMAND_COUNT();
+  for (int32_t i = 0; i < count; i ++) {
+    freeCommand(shellCommands + i);
+  }
+
+  // free tires
+  taosThreadMutexLock(&tiresMutex);
+  for (int32_t i = 0; i < WT_VAR_CNT; i++) {
+    if (tires[i]) {
+      freeTire(tires[i]);
+      tires[i] = NULL;
+    } 
+  }
+  taosThreadMutexUnlock(&tiresMutex);
+  // destory
+  taosThreadMutexDestroy(&tiresMutex);
+
+  // free threads
+  for (int32_t i = 0; i < WT_VAR_CNT; i++) {
+    if (threads[i]) {
+      taosDestroyThread(threads[i]);
+      threads[i] = NULL;
+    }
+  }
+
+  // free lastMatch
+  if (lastMatch) {
+    freeMatch(lastMatch);
+    lastMatch = NULL;
+  }
+}
+
+//
+//  -------------------  auto ptr for tires --------------------------
+//
+bool setNewAuotPtr(int type, STire* pNew) {
+  if (pNew == NULL)
+    return false;
+
+  taosThreadMutexLock(&tiresMutex);
+  STire* pOld = tires[type];
+  if (pOld != NULL) {
+    // previous have value, release self ref count
+    if (--pOld->ref == 0) {
+      freeTire(pOld);
+    }
+  }
+
+  // set new
+  tires[type] = pNew;
+  tires[type]->ref = 1;
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return true;
+}
+
+// get ptr
+STire* getAutoPtr(int type) {
+  if (tires[type] == NULL) {
+    return NULL;
+  }
+
+  taosThreadMutexLock(&tiresMutex);
+  tires[type]->ref++;
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return tires[type];
+}
+
+// put back tire to tires[type], if tire not equal tires[type].p, need free tire
+void putBackAutoPtr(int type, STire* tire) {
+  if (tire == NULL) {
+    return ;
+  }
+
+  taosThreadMutexLock(&tiresMutex);
+  if (tires[type] != tire) {
+    //update by out,  can't put back , so free
+    if (--tire->ref == 1) {
+      // support multi thread getAuotPtr
+      freeTire(tire);
+    }
+    
+  } else {
+    tires[type]->ref--;
+    assert(tires[type]->ref > 0);
+  }
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return ;
+}
+
+
+
+//
+//  -------------------  var Word --------------------------
+//
+
+#define MAX_CACHED_CNT 100000 // max cached rows 10w
+// write sql result to var name, return write rows cnt
+int writeVarNames(int type, TAOS_RES* tres) {
+  // fetch row 
+  TAOS_ROW row = taos_fetch_row(tres);
+  if (row == NULL) {
+    return 0;
+  }
+
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
+  // create new tires
+  char tireType = type == WT_VAR_TABLE ? TIRE_TREE : TIRE_LIST;
+  STire* tire = createTire(tireType);
+
+  // enum rows
+  char name[1024];
+  int numOfRows = 0;
+  do {
+    int32_t* lengths = taos_fetch_lengths(tres);
+    int32_t bytes = lengths[0];
+    if(fields[0].type == TSDB_DATA_TYPE_SMALLINT) {
+      sprintf(name,"%d", *(int16_t*)row[0]);
+    } else {
+      memcpy(name, row[0], bytes);
+    }
+    
+    name[bytes] = 0;  //set string end 
+    // insert to tire
+    insertWord(tire, name);
+
+    if (++numOfRows > MAX_CACHED_CNT ) {
+      break;
+    }
+
+    row = taos_fetch_row(tres);
+  } while (row != NULL);
+
+  // replace old tire
+  setNewAuotPtr(type, tire);
+
+  return numOfRows;
+}
+
+bool firstMatchCommand(TAOS * con, SShellCmd * cmd);
+//
+//  thread obtain var thread from db server 
+//
+void* varObtainThread(void* param) {
+  int type = *(int* )param;
+  taosMemoryFree(param);
+
+  if (varCon == NULL || type > WT_FROM_DB_MAX) {
+    return NULL;
+  }
+
+  TAOS_RES* pSql = taos_query(varCon, varSqls[type]);
+  if (taos_errno(pSql)) {
+    taos_free_result(pSql);
+    return NULL;
+  }
+
+  // write var names from pSql
+  int cnt = writeVarNames(type, pSql);
+
+  // free sql
+  taos_free_result(pSql);
+
+  // check need call auto tab 
+  if (cnt > 0 && waitAutoFill) {
+    // press tab key by program
+    firstMatchCommand(varCon, varCmd);
+  }
+
+  return NULL;
+}
+
+// only match next one word from all match words, return valuue must free by caller
+char* matchNextPrefix(STire* tire, char* pre) {
+  SMatch* match = NULL;
+
+  // re-use last result
+  if (lastMatch) {
+    if (strcmp(pre, lastMatch->pre) == 0) {
+      // same pre
+      match = lastMatch;
+    }
+  }
+
+  if (match == NULL) {
+    // not same with last result
+    if (pre[0] == 0) {
+      // EMPTY PRE
+      match = enumAll(tire);
+    } else {
+      // NOT EMPTY
+      match = matchPrefix(tire, pre, NULL);
+    }
+    
+    // save to lastMatch
+    if (match) {
+      if (lastMatch)
+        freeMatch(lastMatch);
+      lastMatch = match;
+    }
+  }
+
+  // check valid
+  if (match == NULL || match->head == NULL) {
+    // no one matched
+    return false;
+  }
+
+  if (cursorVar == -1) {
+    // first
+    cursorVar = 0;
+    return strdup(match->head->word);    
+  }
+
+  // according to cursorVar , calculate next one
+  int i = 0;
+  SMatchNode* item = match->head;
+  while (item) {
+    if (i == cursorVar + 1) {
+      // found next position ok
+      if (item->next == NULL) {
+        // match last item, reset cursorVar to head
+        cursorVar = -1;
+      } else {
+        cursorVar = i;
+      }
+
+      return strdup(item->word);
+    }
+
+    // check end item
+    if (item->next == NULL) {
+      // if cursorVar > var list count, return last and reset cursorVar
+      cursorVar = -1;
+
+      return strdup(item->word);
+    }
+
+    // move next
+    item = item->next;
+    i++;
+  }
+
+  return NULL;
+}
+
+// search pre word from tire tree, return value must free by caller
+char* tireSearchWord(int type, char* pre) {
+  if (type == WT_TEXT) {
+    return NULL;
+  }
+
+  if(type > WT_FROM_DB_MAX) {
+    // NOT FROM DB , tires[type] alwary not null
+    STire* tire = tires[type];
+    if (tire == NULL)
+      return NULL;
+    return  matchNextPrefix(tire, pre);
+  }
+
+  // TYPE CONTEXT GET FROM DB
+  taosThreadMutexLock(&tiresMutex);
+
+  // check need obtain from server
+  if (tires[type] == NULL) {
+    waitAutoFill = true;
+    // need async obtain var names from db sever
+    if (threads[type] != NULL) {
+      if (taosThreadRunning(threads[type])) {
+        // thread running , need not obtain again, return 
+        taosThreadMutexUnlock(&tiresMutex);
+        return NULL;
+      }
+      // destroy previous thread handle for new create thread handle
+      taosDestroyThread(threads[type]);
+      threads[type] = NULL;
+    }
+  
+    // create new
+    void * param = taosMemoryMalloc(sizeof(int));
+    *((int* )param) = type;
+    threads[type] = taosCreateThread(varObtainThread, param);
+    taosThreadMutexUnlock(&tiresMutex);
+    return NULL;
+  }
+  taosThreadMutexUnlock(&tiresMutex);
+
+  // can obtain var names from local
+  STire* tire = getAutoPtr(type);
+  if (tire == NULL) {
+    return NULL;
+  }
+
+  char* str = matchNextPrefix(tire, pre);
+  // used finish, put back pointer to autoptr array
+  putBackAutoPtr(type, tire);
+
+  return str;
+}
+
+// match var word, word1 is pattern , word2 is input from shell 
+bool matchVarWord(SWord* word1, SWord* word2) {
+  // search input word from tire tree 
+  char pre[512];
+  memcpy(pre, word2->word, word2->len);
+  pre[word2->len] = 0;
+
+  char* str = NULL;
+  if (word1->type == WT_VAR_ALLTABLE) {
+    // ALL_TABLE
+    str = tireSearchWord(WT_VAR_STABLE, pre);
+    if (str == NULL) {
+      str = tireSearchWord(WT_VAR_TABLE, pre);
+      if(str == NULL)
+        return false;
+    }
+  } else {
+    // OTHER
+    str = tireSearchWord(word1->type, pre);
+    if (str == NULL) {
+      // not found or word1->type variable list not obtain from server, return not match
+      return false;
+    }
+  }
+
+  // free previous malloc
+  if(word1->free && word1->word) {
+    taosMemoryFree(word1->word);
+  }
+
+  // save
+  word1->word = str;
+  word1->len  = strlen(str);
+  word1->free = true; // need free
+  
+  return true;
+}
+
+//
+//  -------------------  match words --------------------------
+//
+
+
+// compare command cmd1 come from shellCommands , cmd2 come from user input
+int32_t compareCommand(SWords * cmd1, SWords * cmd2) {
+  SWord * word1 = cmd1->head;
+  SWord * word2 = cmd2->head;
+
+  if (word1 == NULL || word2 == NULL) {
+    return -1;
+  }
+
+  for (int32_t i = 0; i < cmd1->count; i++) {
+    if (word1->type == WT_TEXT) {
+      // WT_TEXT match
+      if (word1->len == word2->len) {
+        if (strncasecmp(word1->word, word2->word, word1->len) != 0)
+          return -1; 
+      } else if (word1->len < word2->len) {
+        return -1;
+      } else {
+        // word1->len > word2->len
+        if (strncasecmp(word1->word, word2->word, word2->len) == 0) {
+          cmd1->matchIndex = i;
+          cmd1->matchLen = word2->len;
+          return i;
+        } else {
+          return -1;
+        }
+      }
+    } else {
+      // WT_VAR auto match any one word
+      if (word2->next == NULL) { // input words last one
+        if (matchVarWord(word1, word2)) {
+          cmd1->matchIndex = i;
+          cmd1->matchLen = word2->len;
+          varMode = true;
+          return i;
+        }
+        return -1;
+      }
+    }
+
+    // move next
+    word1 = word1->next;
+    word2 = word2->next;
+    if (word1 == NULL || word2 == NULL) {
+      return -1;
+    }
+  }
+
+  return -1;
+}
+
+// match command
+SWords * matchCommand(SWords * input, bool continueSearch) {
+  int32_t count = SHELL_COMMAND_COUNT();
+  for (int32_t i = 0; i < count; i ++) {
+    SWords * shellCommand = shellCommands + i;
+    if (continueSearch && lastMatchIndex != -1 && i <= lastMatchIndex) {
+      // new match must greate than lastMatchIndex
+      if (varMode && i == lastMatchIndex) {
+        // do nothing, var match on lastMatchIndex
+      } else {
+        continue;
+      }
+    }
+
+    // command is large
+    if (input->count > shellCommand->count ) {
+      continue;
+    }
+
+    // compare
+    int32_t index = compareCommand(shellCommand, input);
+    if (index != -1) {
+      if (firstMatchIndex == -1)
+        firstMatchIndex = i;
+      curMatchIndex = i;
+      return &shellCommands[i];
+    }
+  }
+
+  // not match
+  return NULL;
+}
+
+//
+//  -------------------  print screen --------------------------
+//
+
+// delete char count
+void deleteCount(SShellCmd * cmd, int count) {
+  int size = 0;
+  int width = 0;
+  int prompt_size = 6;
+  shellClearScreen(cmd->endOffset + prompt_size, cmd->screenOffset + prompt_size);
+
+  // loop delete
+  while (--count >= 0 && cmd->cursorOffset > 0) {
+    shellGetPrevCharSize(cmd->command, cmd->cursorOffset, &size, &width);
+    memmove(cmd->command + cmd->cursorOffset - size, cmd->command + cmd->cursorOffset,
+            cmd->commandSize - cmd->cursorOffset);
+    cmd->commandSize -= size;
+    cmd->cursorOffset -= size;
+    cmd->screenOffset -= width;
+    cmd->endOffset -= width;
+  }
+}
+
+// show screen
+void printScreen(TAOS * con, SShellCmd * cmd, SWords * match) {
+  // modify SShellCmd
+  if (firstMatchIndex == -1 || curMatchIndex == -1) {
+    // no match
+    return ;
+  }
+
+  // first tab press 
+  const char * str = NULL;
+  int strLen = 0; 
+
+  if (firstMatchIndex == curMatchIndex && lastWordBytes == -1) {
+    // first press tab
+    SWord * word = MATCH_WORD(match);
+    str = word->word + match->matchLen;
+    strLen = word->len - match->matchLen;
+    lastMatchIndex = firstMatchIndex;
+    lastWordBytes = word->len;
+  } else {
+    if (lastWordBytes == -1)
+      return ;
+    deleteCount(cmd, lastWordBytes);
+
+    SWord * word = MATCH_WORD(match);
+    str = word->word;
+    strLen = word->len;
+    // set current to last
+    lastMatchIndex = curMatchIndex;
+    lastWordBytes = word->len;
+  }
+  
+  // insert new
+  shellInsertChar(cmd, (char *)str, strLen);
+}
+
+
+// main key press tab , matched return true else false
+bool firstMatchCommand(TAOS * con, SShellCmd * cmd) {
+  // parse command
+  SWords* input = (SWords *)taosMemoryMalloc(sizeof(SWords));
+  memset(input, 0, sizeof(SWords));
+  input->source = cmd->command;
+  input->source_len = cmd->commandSize;
+  parseCommand(input, false);
+
+  // if have many , default match first, if press tab again , switch to next
+  curMatchIndex  = -1;
+  lastMatchIndex = -1;
+  SWords * match = matchCommand(input, true);
+  if (match == NULL) {
+    // not match , nothing to do
+    freeCommand(input);
+    taosMemoryFree(input);
+    return false;
+  }
+
+  // print to screen
+  printScreen(con, cmd, match);
+  freeCommand(input);
+  taosMemoryFree(input);
+  return true;
+}
+
+// create input source
+void createInputFromFirst(SWords* input, SWords * firstMatch) {
+  //
+  // if next pressTabKey , input context come from firstMatch, set matched length with source_len
+  //
+  input->source = (char*)taosMemoryMalloc(1024);
+  memset((void* )input->source, 0, 1024);
+
+  SWord * word = firstMatch->head;
+
+  // source_len = full match word->len + half match with firstMatch->matchLen  
+  for (int i = 0; i < firstMatch->matchIndex && word; i++) {
+    // combine source from each word
+    strncpy(input->source + input->source_len, word->word, word->len);
+    strcat(input->source, " "); // append blank splite
+    input->source_len += word->len + 1; // 1 is blank length
+    // move next
+    word = word->next;
+  }
+  // appand half matched word for last
+  if (word) {
+    strncpy(input->source + input->source_len, word->word, firstMatch->matchLen);
+    input->source_len += firstMatch->matchLen;
+  }
+}
+
+// user press Tabkey again is named next , matched return true else false
+bool nextMatchCommand(TAOS * con, SShellCmd * cmd, SWords * firstMatch) {
+  if (firstMatch == NULL || firstMatch->head == NULL) {
+    return false;
+  }
+  SWords* input = (SWords *)taosMemoryMalloc(sizeof(SWords));
+  memset(input, 0, sizeof(SWords));
+
+  // create input from firstMatch
+  createInputFromFirst(input, firstMatch);
+
+  // parse input
+  parseCommand(input, false);
+
+  // if have many , default match first, if press tab again , switch to next
+  SWords * match = matchCommand(input, true);
+  if (match == NULL) {
+    // if not match , reset all index
+    firstMatchIndex = -1;
+    curMatchIndex   = -1;
+    match = matchCommand(input, false);
+    if (match == NULL) {
+      freeCommand(input);
+      if (input->source)
+        taosMemoryFree(input->source);
+      taosMemoryFree(input);
+      return false;
+    }
+  }
+
+  // print to screen
+  printScreen(con, cmd, match);
+
+  // free
+  if (input->source) {
+    taosMemoryFree(input->source);
+    input->source = NULL;
+  }
+  freeCommand(input);
+  taosMemoryFree(input);
+
+  return true;
+}
+
+// fill with type
+bool fillWithType(TAOS * con, SShellCmd * cmd, char* pre, int type) {
+  // get type
+  STire* tire = tires[type];
+  char* str = matchNextPrefix(tire, pre);
+  if (str == NULL) {
+    return false;
+  }
+
+  // need insert part string
+  char * part = str + strlen(pre);
+
+  // show
+  int count = strlen(part);
+  shellInsertChar(cmd, part, count);
+  cntDel = count; // next press tab delete current append count
+
+  taosMemoryFree(str);
+  return true;
+}
+
+// fill with type
+bool fillTableName(TAOS * con, SShellCmd * cmd, char* pre) {
+  // search stable and table
+  char * str = tireSearchWord(WT_VAR_STABLE, pre);
+  if (str == NULL) {
+    str = tireSearchWord(WT_VAR_TABLE, pre);
+    if(str == NULL)
+      return false;
+  }
+
+  // need insert part string
+  char * part = str + strlen(pre); 
+
+  // delete autofill count last append
+  if(cntDel > 0) {
+    deleteCount(cmd, cntDel);
+    cntDel = 0;
+  }
+
+  // show
+  int count = strlen(part);
+  shellInsertChar(cmd, part, count);
+  cntDel = count; // next press tab delete current append count
+  
+  taosMemoryFree(str);
+  return true;
+}
+
+//
+// find last word from sql select clause
+//  example :
+//  1 select cou -> press tab  select count(
+//  2 select count(*),su -> select count(*), sum(
+//  3 select count(*), su -> select count(*), sum(
+//
+char * lastWord(char * p) {
+  // get near from end revert find ' ' and ',' 
+  char * p1 = strrchr(p, ' ');
+  char * p2 = strrchr(p, ',');
+
+  if (p1 && p2) {
+    return MAX(p1, p2) + 1;
+  } else if (p1) {
+    return p1 + 1;
+  } else if(p2) {
+    return p2 + 1;
+  } else {
+    return p;
+  } 
+}
+
+bool fieldsInputEnd(char* sql) {
+  // not in '()'
+  char* p1 = strrchr(sql, '(');
+  char* p2 = strrchr(sql, ')');
+  if (p1 && p2 == NULL) {
+    // like select count( '  '
+    return false;
+  } else if (p1 && p2 && p1 > p2) {
+    // like select sum(age), count( ' '
+    return false;
+  }
+
+  // not in ','
+  char * p3 = strrchr(sql, ',');
+  char * p = p3;
+  // like select ts, age,'    ' 
+  if (p) {
+    ++p;
+    bool allBlank = true; // after last ','  all char is blank
+    int  cnt = 0; // blank count , like '    ' as one blank
+    char * plast = NULL; // last blank position
+    while(*p) {
+      if (*p == ' ') {
+        plast = p;
+        cnt ++;
+      } else {
+        allBlank = false;
+      }
+      ++p;
+    }
+
+    // any one word is not blank
+    if(allBlank) {
+      return false;
+    }
+
+    // like 'select count(*),sum(age) fr' need return true
+    if (plast && plast > p3 && p2 > p1 && plast > p2 && p1 > p3) {
+      return true;
+    }
+
+    // if last char not ' ', then not end field, like 'select count(*), su' can fill sum(
+    if(sql[strlen(sql)-1] != ' ' && cnt <= 1) {
+      return false;
+    }
+  }
+
+  char * p4 = strrchr(sql, ' ');
+  if(p4 == NULL) {
+    // only one word
+    return false;
+  }
+
+  return true;
+}
+
+// need insert from
+bool needInsertFrom(char * sql, int len) {
+  // last is blank 
+  if(sql[len-1] != ' ') {
+    // insert from keyword
+    return false;
+  }
+
+  //  select fields input is end
+  if (!fieldsInputEnd(sql)) {
+    return false;
+  }
+
+  // can insert from keyword
+  return true;
+}
+
+bool matchSelectQuery(TAOS * con, SShellCmd * cmd) {
+  // if continue press Tab , delete bytes by previous autofill
+  if (cntDel > 0) {
+    deleteCount(cmd, cntDel);
+    cntDel = 0;
+  }
+
+  // match select ...
+  int len = cmd->commandSize;
+  char * p = cmd->command;
+
+  // remove prefix blank
+  while (p[0] == ' ' && len > 0) {
+    p++;
+    len--;
+  }
+
+  // special range
+  if(len < 7 || len > 512) {
+    return false;
+  }
+
+  // select and from 
+  if(strncasecmp(p, "select ", 7) != 0) {
+    // not select query clause
+    return false;
+  }
+  p += 7;
+  len -= 7;
+
+  char* ps = p = strndup(p, len);
+
+  // union all
+  char * p1;
+  do {
+    p1 = strstr(p, UNION_ALL);
+    if(p1) {
+      p = p1 + strlen(UNION_ALL);
+    }
+  } while (p1);
+
+  char * from = strstr(p, " from ");
+  //last word , maybe empty string or some letters of a string
+  char * last = lastWord(p);
+  bool ret = false;
+  if (from == NULL) {
+    bool fieldEnd = fieldsInputEnd(p);
+    // cheeck fields input end then insert from keyword
+    if (fieldEnd && p[len-1] == ' ') {
+      shellInsertChar(cmd, "from", 4);
+      taosMemoryFree(ps);
+      return true;
+    }
+
+    // fill funciton
+    if(fieldEnd) {
+      // fields is end , need match keyword
+      ret = fillWithType(con, cmd, last, WT_VAR_KEYWORD);
+    } else {
+      ret = fillWithType(con, cmd, last, WT_VAR_FUNC);
+    }
+    
+    taosMemoryFree(ps);
+    return ret;
+  }
+
+  // have from
+  char * blank = strstr(from + 6, " ");
+  if (blank == NULL) {
+    // no table name, need fill
+    ret = fillTableName(con, cmd, last);
+  } else {
+    ret = fillWithType(con, cmd, last, WT_VAR_KEYWORD);
+  }
+
+  taosMemoryFree(ps);
+  return ret;
+}
+
+// if is input create fields or tags area, return true
+bool isCreateFieldsArea(char * p) {
+  char * left  = strrchr(p, '(');
+  if (left == NULL) {
+    // like 'create table st'
+    return false;
+  }
+
+  char * right = strrchr(p, ')');
+  if(right == NULL) {
+    // like 'create table st( '
+    return true;
+  }
+
+  if (left > right) {
+    // like 'create table st( ts timestamp, age int) tags(area '
+    return true;
+  }
+
+  return false;
+}
+
+bool matchCreateTable(TAOS * con, SShellCmd * cmd) {
+  // if continue press Tab , delete bytes by previous autofill
+  if (cntDel > 0) {
+    deleteCount(cmd, cntDel);
+    cntDel = 0;
+  }
+
+  // match select ...
+  int len = cmd->commandSize;
+  char * p = cmd->command;
+
+  // remove prefix blank
+  while (p[0] == ' ' && len > 0) {
+    p++;
+    len--;
+  }
+
+  // special range
+  if(len < 7 || len > 1024) {
+    return false;
+  }
+
+  // select and from 
+  if(strncasecmp(p, "create table ", 13) != 0) {
+    // not select query clause
+    return false;
+  }
+  p += 13;
+  len -= 13;
+
+  char* ps = strndup(p, len);
+  bool ret = false;
+  char * last = lastWord(ps);
+
+  // check in create fields or tags input area
+  if (isCreateFieldsArea(ps)) {
+    ret = fillWithType(con, cmd, last, WT_VAR_DATATYPE);
+  }
+
+  // tags
+  if (!ret) {
+    // find only one ')' , can insert tags
+    char * p1 = strchr(ps, ')');
+    if (p1) {
+      if(strchr(p1 + 1, ')') == NULL && strstr(p1 + 1, "tags") == NULL) {
+        // can insert tags keyword
+        ret = fillWithType(con, cmd, last, WT_VAR_KEYTAGS);
+      }
+    }
+  }
+
+  taosMemoryFree(ps);
+  return ret;
+}
+
+bool matchOther(TAOS * con, SShellCmd * cmd) {
+  int len = cmd->commandSize;
+  char* p = cmd->command;
+
+  if (p[len - 1] == '\\') {
+    // append '\G'
+    char a[] = "G;";
+    shellInsertChar(cmd, a, 2);
+    return true;
+  }
+  
+  return false;
+}
+
+
+// main key press tab
+void pressTabKey(SShellCmd * cmd) {
+  // check 
+  if (cmd->commandSize == 0) { 
+    // empty
+    showHelp();
+    shellShowOnScreen(cmd);
+    return ;
+  } 
+
+  // save connection to global
+  varCmd = cmd;
+  bool matched = false;
+
+  // manual match like create table st( ...
+  matched = matchCreateTable(varCon, cmd);
+  if (matched)
+    return ;
+
+  // shellCommands match 
+  if (firstMatchIndex == -1) {
+    matched = firstMatchCommand(varCon, cmd);
+  } else {
+    matched = nextMatchCommand(varCon, cmd, &shellCommands[firstMatchIndex]);
+  }
+  if (matched)
+    return ;
+
+  // NOT MATCHED ANYONE
+  // match other like '\G' ...
+  matched = matchOther(varCon, cmd);
+  if (matched)
+    return ;
+
+  // manual match like select * from ...
+  matched = matchSelectQuery(varCon, cmd);
+  if (matched)
+    return ;
+
+  return ;
+}
+
+// press othr key
+void pressOtherKey(char c) {
+  // reset global variant
+  firstMatchIndex = -1;
+  lastMatchIndex  = -1;
+  curMatchIndex   = -1;
+  lastWordBytes   = -1;
+
+  // var names
+  cursorVar    = -1;
+  varMode      = false;
+  waitAutoFill = false;
+  cntDel       = 0;
+
+  if (lastMatch) {
+    freeMatch(lastMatch);
+    lastMatch = NULL;
+  }
+}
+
+// put name into name, return name length
+int getWordName(char* p, char * name, int nameLen) {
+  //remove prefix blank
+  while (*p == ' ') {
+    p++;
+  }
+
+  // get databases name;
+  int i = 0;
+  while(p[i] != 0 && i < nameLen - 1) {
+    name[i] = p[i]; 
+    i++;
+    if(p[i] == ' ' || p[i] == ';'|| p[i] == '(') {
+      // name end
+      break;
+    }
+  }
+  name[i] = 0;
+
+  return i;
+}
+
+// deal use db, if have  'use' return true
+bool dealUseDB(char * sql) {
+  // check use keyword 
+  if(strncasecmp(sql, "use ", 4) != 0) {
+    return false;
+  }
+  
+  char db[256];
+  char *p = sql + 4;
+  if (getWordName(p, db, sizeof(db)) == 0) {
+    // no name , return 
+    return true;
+  }
+
+  //  dbName is previous use open db name
+  if (strcasecmp(db, dbName) == 0) {
+    // same , no need switch 
+    return true;
+  }
+
+  // switch new db
+  taosThreadMutexLock(&tiresMutex);
+  // STABLE set null
+  STire* tire = tires[WT_VAR_STABLE];
+  tires[WT_VAR_STABLE] = NULL;
+  if(tire) {
+    freeTire(tire);
+  }
+  // TABLE set null
+  tire = tires[WT_VAR_TABLE];
+  tires[WT_VAR_TABLE] = NULL;
+  if(tire) {
+    freeTire(tire);
+  }
+  // save
+  strcpy(dbName, db);
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return true;
+}
+
+// deal create, if have 'create' return true
+bool dealCreateCommand(char * sql) {
+  // check keyword 
+  if(strncasecmp(sql, "create ", 7) != 0) {
+    return false;
+  }
+  
+  char name[1024];
+  char *p = sql + 7;
+  if (getWordName(p, name, sizeof(name)) == 0) {
+    // no name , return 
+    return true;
+  }
+
+  int type = -1;
+  //  dbName is previous use open db name
+  if (strcasecmp(name, "database") == 0) {
+    type = WT_VAR_DBNAME;
+  } else if (strcasecmp(name, "table") == 0) {
+    if(strstr(sql, " tags") != NULL && strstr(sql, " using ") == NULL)
+      type = WT_VAR_STABLE;
+    else
+      type = WT_VAR_TABLE;
+  } else if (strcasecmp(name, "user") == 0) {
+    type = WT_VAR_USERNAME;
+  } else {
+    // no match , return 
+    return true;
+  }
+
+  // move next
+  p += strlen(name);
+
+  // get next word , that is table name
+  if (getWordName(p, name, sizeof(name)) == 0) {
+    // no name , return 
+    return true;
+  }
+
+  // switch new db
+  taosThreadMutexLock(&tiresMutex);
+  // STABLE set null
+  STire* tire = tires[type];
+  if(tire) {
+    insertWord(tire, name);
+  }
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return true;
+}
+
+// deal create, if have 'drop' return true
+bool dealDropCommand(char * sql) {
+  // check keyword 
+  if(strncasecmp(sql, "drop ", 5) != 0) {
+    return false;
+  }
+  
+  char name[1024];
+  char *p = sql + 5;
+  if (getWordName(p, name, sizeof(name)) == 0) {
+    // no name , return 
+    return true;
+  }
+
+  int type = -1;
+  //  dbName is previous use open db name
+  if (strcasecmp(name, "database") == 0) {
+    type = WT_VAR_DBNAME;
+  } else if (strcasecmp(name, "table") == 0) {
+    type = WT_VAR_ALLTABLE;
+  } else if (strcasecmp(name, "dnode") == 0) {
+    type = WT_VAR_DNODEID;
+  } else if (strcasecmp(name, "user") == 0) {
+    type = WT_VAR_USERNAME;
+  } else {
+    // no match , return 
+    return true;
+  }
+
+  // move next
+  p += strlen(name);
+
+  // get next word , that is table name
+  if (getWordName(p, name, sizeof(name)) == 0) {
+    // no name , return 
+    return true;
+  }
+
+  // switch new db
+  taosThreadMutexLock(&tiresMutex);
+  // STABLE set null
+  if(type == WT_VAR_ALLTABLE)  {
+    bool del = false;
+    // del in stable
+    STire* tire = tires[WT_VAR_STABLE];
+    if(tire)
+      del = deleteWord(tire, name);
+    // del in table
+    if(!del) {
+      tire = tires[WT_VAR_TABLE];
+      if(tire)
+        del = deleteWord(tire, name);
+    }
+  } else {
+    // OTHER TYPE
+    STire* tire = tires[type];
+    if(tire)
+      deleteWord(tire, name);
+  }
+  taosThreadMutexUnlock(&tiresMutex);
+
+  return true;
+}
+
+// callback autotab module after shell sql execute
+void callbackAutoTab(char* sqlstr, TAOS* pSql, bool usedb) {
+  char *  sql = sqlstr;
+  // remove prefix blank
+  while (*sql == ' ') {
+    sql++;
+  }
+
+  if(dealUseDB(sql)) {
+    // change to new db
+    return ;
+  }
+
+  // create command add name to autotab
+  if(dealCreateCommand(sql)) {
+    return ;
+  }
+
+  // drop command remove name from autotab
+  if(dealDropCommand(sql)) {
+    return ;
+  }
+
+  return ;
+}

tools/shell/src/shellCommand.c

@@ -15,6 +15,7 @@
 
 #define __USE_XOPEN
 #include "shellInt.h"
+#include "shellAuto.h"
 
 #define LEFT  1
 #define RIGHT 2
@@ -23,20 +24,11 @@
 #define PSIZE shell.info.promptSize
 #define SHELL_INPUT_MAX_COMMAND_SIZE 10000
 
-typedef struct {
-  char    *buffer;
-  char    *command;
-  uint32_t commandSize;
-  uint32_t bufferSize;
-  uint32_t cursorOffset;
-  uint32_t screenOffset;
-  uint32_t endOffset;
-} SShellCmd;
 
 static int32_t shellCountPrefixOnes(uint8_t c);
-static void    shellGetPrevCharSize(const char *str, int32_t pos, int32_t *size, int32_t *width);
+
 static void    shellGetNextCharSize(const char *str, int32_t pos, int32_t *size, int32_t *width);
-static void    shellInsertChar(SShellCmd *cmd, char *c, int size);
+
 static void    shellBackspaceChar(SShellCmd *cmd);
 static void    shellClearLineBefore(SShellCmd *cmd);
 static void    shellClearLineAfter(SShellCmd *cmd);
@@ -51,8 +43,10 @@ static void    shellUpdateBuffer(SShellCmd *cmd);
 static int32_t shellIsReadyGo(SShellCmd *cmd);
 static void    shellGetMbSizeInfo(const char *str, int32_t *size, int32_t *width);
 static void    shellResetCommand(SShellCmd *cmd, const char s[]);
-static void    shellClearScreen(int32_t ecmd_pos, int32_t cursor_pos);
-static void    shellShowOnScreen(SShellCmd *cmd);
+void           shellClearScreen(int32_t ecmd_pos, int32_t cursor_pos);
+void           shellShowOnScreen(SShellCmd *cmd);
+void           shellGetPrevCharSize(const char *str, int32_t pos, int32_t *size, int32_t *width);
+void           shellInsertChar(SShellCmd *cmd, char *c, int size);
 
 int32_t shellCountPrefixOnes(uint8_t c) {
   uint8_t mask = 127;
@@ -107,8 +101,11 @@ void shellInsertChar(SShellCmd *cmd, char *c, int32_t size) {
   /* update the values */
   cmd->commandSize += size;
   cmd->cursorOffset += size;
+  for (int i = 0; i < size; i++) {
+    taosMbToWchar(&wc, c + i, size);
     cmd->screenOffset += taosWcharWidth(wc);
     cmd->endOffset    += taosWcharWidth(wc);
+  }  
 #ifdef WINDOWS
 #else
   shellShowOnScreen(cmd);
@@ -209,6 +206,15 @@ void shellPositionCursorHome(SShellCmd *cmd) {
   }
 }
 
+void positionCursorMiddle(SShellCmd *cmd) {
+  if (cmd->endOffset > 0) {
+    shellClearScreen(cmd->endOffset + PSIZE, cmd->screenOffset + PSIZE);
+    cmd->cursorOffset = cmd->commandSize/2;
+    cmd->screenOffset = cmd->endOffset/2;
+    shellShowOnScreen(cmd);
+  }
+}
+
 void shellPositionCursorEnd(SShellCmd *cmd) {
   assert(cmd->cursorOffset <= cmd->commandSize && cmd->endOffset >= cmd->screenOffset);
 
@@ -464,7 +470,12 @@ int32_t shellReadCommand(char *command) {
         utf8_array[k] = c;
       }
       shellInsertChar(&cmd, utf8_array, count);
+      pressOtherKey(c);
+    } else if (c == TAB_KEY) {
+      // press TAB key
+      pressTabKey(&cmd);
     } else if (c < '\033') {
+      pressOtherKey(c);      
       // Ctrl keys.  TODO: Implement ctrl combinations
       switch (c) {
         case 0:
@@ -519,8 +530,12 @@ int32_t shellReadCommand(char *command) {
         case 21:  // Ctrl + U;
           shellClearLineBefore(&cmd);
           break;
+        case 23:  // Ctrl + W;
+          positionCursorMiddle(&cmd);
+          break;          
       }
     } else if (c == '\033') {
+      pressOtherKey(c);
       c = taosGetConsoleChar();
       switch (c) {
         case '[':
@@ -597,9 +612,11 @@ int32_t shellReadCommand(char *command) {
           break;
       }
     } else if (c == 0x7f) {
+      pressOtherKey(c);
       // press delete key
       shellBackspaceChar(&cmd);
     } else {
+      pressOtherKey(c);
       shellInsertChar(&cmd, &c, 1);
     }
   }

tools/shell/src/shellEngine.c

@@ -19,6 +19,7 @@
 #define _XOPEN_SOURCE
 #define _DEFAULT_SOURCE
 #include "shellInt.h"
+#include "shellAuto.h"
 
 static bool    shellIsEmptyCommand(const char *cmd);
 static int32_t shellRunSingleCommand(char *command);
@@ -193,6 +194,9 @@ void shellRunSingleCommandImp(char *command) {
     fprintf(stdout, "Database changed.\r\n\r\n");
     fflush(stdout);
 
+    // call back auto tab module
+    callbackAutoTab(command, pSql, true);
+
     taos_free_result(pSql);
 
     return;
@@ -217,6 +221,9 @@ void shellRunSingleCommandImp(char *command) {
     taos_free_result(pSql);
     et = taosGetTimestampUs();
     printf("Query OK, %d of %d rows affected (%.6fs)\r\n", num_rows_affacted, num_rows_affacted, (et - st) / 1E6);
+
+    // call auto tab
+    callbackAutoTab(command, pSql, false);    
   }
 
   printf("\r\n");

tools/shell/src/shellMain.c

@@ -15,6 +15,7 @@
 
 #define __USE_XOPEN
 #include "shellInt.h"
+#include "shellAuto.h"
 
 SShellObj shell = {0};
 
@@ -70,5 +71,9 @@ int main(int argc, char *argv[]) {
     return 0;
   }
 
-  return shellExecute();
+  // support port feature 
+  shellAutoInit();
+  int32_t ret = shellExecute();
+  shellAutoExit();
+  return ret;
 }

tools/shell/src/tire.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define __USE_XOPEN
+
+#include "os.h"
+#include "tire.h"
+
+// ----------- interface -------------
+
+// create prefix search tree
+STire* createTire(char type) {
+     STire* tire = taosMemoryMalloc(sizeof(STire));
+     memset(tire, 0, sizeof(STire));
+     tire->ref    = 1; // init is 1
+     tire->type   = type;
+     tire->root.d = (STireNode **)taosMemoryCalloc(CHAR_CNT, sizeof(STireNode *));
+     return tire;
+}
+
+// free tire node
+void freeTireNode(STireNode* node) {
+    if (node == NULL)
+       return ;
+  
+    // nest free sub node on array d 
+    if(node->d) {
+        for (int i = 0; i < CHAR_CNT; i++) {
+            freeTireNode(node->d[i]);
+        }
+        taosMemoryFree(node->d);
+    }
+
+    // free self
+    taosMemoryFree(node);
+}
+
+// destroy prefix search tree
+void freeTire(STire* tire) {
+    // free nodes
+    for (int i = 0; i < CHAR_CNT; i++) {
+        freeTireNode(tire->root.d[i]);
+    }
+    taosMemoryFree(tire->root.d);
+
+    // free from list
+    StrName * item = tire->head;
+    while (item) {
+        StrName * next = item->next;
+        // free string
+        taosMemoryFree(item->name);
+        // free node
+        taosMemoryFree(item);
+
+        // move next
+        item = next;
+    }
+    tire->head = tire->tail = NULL;
+
+    // free tire
+    taosMemoryFree(tire);
+}
+
+// insert a new word to list
+bool insertToList(STire* tire, char* word) {
+    StrName * p = (StrName *)taosMemoryMalloc(sizeof(StrName));
+    p->name = strdup(word);
+    p->next = NULL;
+    
+    if(tire->head == NULL) {
+        tire->head = p;
+        tire->tail = p;
+    }else {
+        tire->tail->next = p;
+        tire->tail = p;
+    }
+
+    return true;
+}
+
+// insert a new word to tree
+bool insertToTree(STire* tire, char* word, int len) {
+    int m  = 0;
+    STireNode ** nodes = tire->root.d;
+    for (int i = 0; i < len; i++) {
+        m = word[i] - FIRST_ASCII;
+        if (m < 0 || m > CHAR_CNT) {
+            return false;
+        }
+
+        if (nodes[m] == NULL) {
+            // no pointer
+            STireNode* p = (STireNode* )taosMemoryMalloc(sizeof(STireNode));
+            memset(p, 0, sizeof(STireNode));
+            nodes[m] = p;
+            if (i == len - 1) {
+                // is end
+                p->end = true;
+                break;
+            }            
+        }
+        
+        if (nodes[m]->d == NULL) {
+            // malloc d
+            nodes[m]->d = (STireNode **)taosMemoryCalloc(CHAR_CNT, sizeof(STireNode *));
+        }
+
+        // move to next node
+        nodes = nodes[m]->d; 
+    }
+
+    // add count
+    tire->count += 1;
+    return true;
+}
+
+// insert a new word 
+bool insertWord(STire* tire, char* word) {
+    int len = strlen(word);
+    if (len >= MAX_WORD_LEN) {
+        return false;
+    }
+    
+    switch (tire->type) {
+      case TIRE_TREE: 
+        return insertToTree(tire, word, len);
+      case TIRE_LIST:
+        return insertToList(tire, word);
+      default:
+        break;
+    }
+    return false;
+}
+
+// delete one word from list
+bool deleteFromList(STire* tire, char* word) {
+    StrName * item = tire->head;
+    while (item) {
+        if (strcmp(item->name, word) == 0) {
+            // found, reset empty to delete
+            item->name[0] = 0;
+        }
+        
+        // move next
+        item = item->next;
+    }
+    return true;
+}
+
+// delete one word from tree 
+bool deleteFromTree(STire* tire, char* word, int len) {
+    int m  = 0;
+    bool del = false;
+
+    STireNode** nodes = tire->root.d;
+    for (int i = 0; i < len; i++) {
+        m = word[i] - FIRST_ASCII;
+        if (m < 0 || m >= CHAR_CNT) {
+            return false;
+        }
+
+        if (nodes[m] == NULL) {
+            // no found
+            return false;
+        } else {
+            // not null
+            if(i == len - 1) {
+                // this is last, only set end false , not free node
+                nodes[m]->end = false;
+                del = true;
+                break;
+            }
+        }
+
+        if(nodes[m]->d == NULL)
+          break;
+        // move to next node
+        nodes = nodes[m]->d;
+    }
+
+    // reduce count
+    if (del) {
+        tire->count -= 1;
+    }
+    
+    return del;
+}
+
+// insert a new word 
+bool deleteWord(STire* tire, char* word) {
+    int len = strlen(word);
+    if (len >= MAX_WORD_LEN) {
+        return false;
+    }
+    
+    switch (tire->type) {
+      case TIRE_TREE: 
+        return deleteFromTree(tire, word, len);
+      case TIRE_LIST:
+        return deleteFromList(tire, word);
+      default:
+        break;
+    }
+    return false;
+}
+
+void addWordToMatch(SMatch* match, char* word){
+    // malloc new
+    SMatchNode* node = (SMatchNode* )taosMemoryMalloc(sizeof(SMatchNode));
+    memset(node, 0, sizeof(SMatchNode));
+    node->word = strdup(word);
+
+    // append to match
+    if (match->head == NULL) {
+        match->head = match->tail = node;
+    } else {
+        match->tail->next = node;
+        match->tail = node;
+    }
+    match->count += 1;
+}
+
+// enum all words from node
+void enumAllWords(STireNode** nodes,  char* prefix, SMatch* match) {
+    STireNode * c;
+    char word[MAX_WORD_LEN];
+    int len = strlen(prefix);
+    for (int i = 0; i < CHAR_CNT; i++) {
+        c = nodes[i];
+        
+        if (c == NULL) {
+            // chain end node
+           continue; 
+        } else {
+            // combine word string
+            memset(word, 0, sizeof(word));
+            strcpy(word, prefix);
+            word[len] =  FIRST_ASCII + i; // append current char
+
+            // chain middle node
+            if (c->end) {
+                // have end flag
+                addWordToMatch(match, word); 
+            }
+            // nested call next layer
+            if (c->d)
+                enumAllWords(c->d, word, match);
+        }
+    }
+}
+
+// match prefix from list
+void matchPrefixFromList(STire* tire, char* prefix, SMatch* match) {
+    StrName * item = tire->head;
+    int len = strlen(prefix);
+    while (item) {
+        if ( strncmp(item->name, prefix, len) == 0) {
+            // prefix matched
+            addWordToMatch(match, item->name);
+        }
+
+        // move next
+        item = item->next;
+    }
+}
+
+// match prefix words, if match is not NULL , put all item to match and return match
+void matchPrefixFromTree(STire* tire, char* prefix, SMatch* match) {
+    SMatch* root = match;
+    int m  = 0;
+    STireNode* c = 0;
+    int len = strlen(prefix);
+    if (len >= MAX_WORD_LEN) {
+        return;
+    }
+
+    STireNode** nodes = tire->root.d;
+    for (int i = 0; i < len; i++) {
+        m = prefix[i] - FIRST_ASCII;
+        if (m < 0 || m > CHAR_CNT) {
+            return;
+        }
+
+        // match
+        c = nodes[m];
+        if (c == NULL) {
+            // arrive end
+            break;
+        }
+
+        // previous items already matched
+        if (i == len - 1) {
+            // malloc match if not pass by param match
+            if (root == NULL) {                        
+                root = (SMatch* )taosMemoryMalloc(sizeof(SMatch));
+                memset(root, 0, sizeof(SMatch));
+                strcpy(root->pre, prefix);
+            }
+
+            // prefix is match to end char
+            if (c->d)
+                enumAllWords(c->d, prefix, root);
+        } else {
+            // move to next node continue match
+            if(c->d == NULL)
+                break;
+            nodes = c->d;
+        }
+    }
+
+    // return 
+    return ;
+}
+
+SMatch* matchPrefix(STire* tire, char* prefix, SMatch* match) {
+    if(match == NULL) {
+        match = (SMatch* )taosMemoryMalloc(sizeof(SMatch));
+        memset(match, 0, sizeof(SMatch));
+    }
+
+    switch (tire->type) {
+      case TIRE_TREE: 
+        matchPrefixFromTree(tire, prefix, match);
+      case TIRE_LIST:
+        matchPrefixFromList(tire, prefix, match);
+      default:
+        break;
+    }
+
+    // return if need
+    if (match->count == 0) {
+        freeMatch(match);
+        match = NULL;
+    }    
+
+    return match;  
+}
+
+
+// get all items from tires tree
+void enumFromList(STire* tire, SMatch* match) {
+    StrName * item = tire->head;
+    while (item) {
+        if (item->name[0] != 0) {
+            // not delete
+            addWordToMatch(match, item->name);
+        }
+
+        // move next
+        item = item->next;
+    }
+}
+
+// get all items from tires tree
+void enumFromTree(STire* tire, SMatch* match) {
+    char pre[2] ={0, 0};
+    STireNode* c;
+    
+    // enum first layer
+    for (int i = 0; i < CHAR_CNT; i++) {
+        pre[0] = FIRST_ASCII + i;
+        
+        // each node
+        c = tire->root.d[i];
+        if (c == NULL) {
+            // this branch no data
+            continue;
+        }
+
+        // this branch have data
+        if(c->end)
+          addWordToMatch(match, pre);
+        else
+          matchPrefix(tire, pre, match);
+    }
+}
+
+// get all items from tires tree
+SMatch* enumAll(STire* tire) {
+    SMatch* match = (SMatch* )taosMemoryMalloc(sizeof(SMatch));
+    memset(match, 0, sizeof(SMatch));
+
+    switch (tire->type) {
+      case TIRE_TREE: 
+        enumFromTree(tire, match);
+      case TIRE_LIST:
+        enumFromList(tire, match);
+      default:
+        break;
+    }
+
+    // return if need
+    if (match->count == 0) {
+        freeMatch(match);
+        match = NULL;
+    }    
+
+    return match;
+}
+
+
+// free match result
+void freeMatchNode(SMatchNode* node) {
+    // first free next
+    if (node->next)
+      freeMatchNode(node->next);
+
+    // second free self
+    if (node->word)
+      taosMemoryFree(node->word);
+    taosMemoryFree(node);
+}
+
+// free match result
+void freeMatch(SMatch* match) {
+    // first free next
+    if (match->head) {
+        freeMatchNode(match->head);
+    }
+
+    // second free self
+    taosMemoryFree(match);
+}