feat(shell): autotab push to 2.6 branch

src/kit/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(TAOS * con, Command * cmd);
+
+// press othr key
+void pressOtherKey(char c);
+
+// init shell auto funciton , shell start call once 
+bool shellAutoInit();
+
+// exit shell auto funciton, shell exit call once
+void shellAutoExit();
+
+// callback autotab module
+void callbackAutoTab(char* sqlstr, TAOS* pSql, bool usedb);
+
+
+#endif

src/kit/shell/inc/shellCommand.h

@@ -41,6 +41,7 @@ extern void deleteChar(Command *cmd);
 extern void moveCursorLeft(Command *cmd);
 extern void moveCursorRight(Command *cmd);
 extern void positionCursorHome(Command *cmd);
+extern void positionCursorMiddle(Command *cmd);
 extern void positionCursorEnd(Command *cmd);
 extern void showOnScreen(Command *cmd);
 extern void updateBuffer(Command *cmd);
@@ -51,5 +52,6 @@ int countPrefixOnes(unsigned char c);
 void clearScreen(int ecmd_pos, int cursor_pos);
 void printChar(char c, int times);
 void positionCursor(int step, int direction);
+void getPrevCharSize(const char *str, int pos, int *size, int *width);
 
 #endif

src/kit/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

src/kit/shell/src/shellCommand.c

@@ -79,8 +79,11 @@ void insertChar(Command *cmd, char *c, int size) {
   /* update the values */
   cmd->commandSize += size;
   cmd->cursorOffset += size;
+  for (int i = 0; i < size; i++) {
+    mbtowc(&wc, c + i, size);
     cmd->screenOffset += wcwidth(wc);
     cmd->endOffset += wcwidth(wc);
+  }
   showOnScreen(cmd);
 }
 
@@ -179,6 +182,16 @@ void positionCursorHome(Command *cmd) {
   }
 }
 
+void positionCursorMiddle(Command *cmd) {
+  if (cmd->endOffset > 0) {
+    clearScreen(cmd->endOffset + prompt_size, cmd->screenOffset + prompt_size);
+    cmd->cursorOffset = cmd->commandSize/2;
+    cmd->screenOffset = cmd->endOffset/2;
+    showOnScreen(cmd);
+  }
+}
+
+
 void positionCursorEnd(Command *cmd) {
   assert(cmd->cursorOffset <= cmd->commandSize && cmd->endOffset >= cmd->screenOffset);
 

src/kit/shell/src/shellLinux.c

@@ -20,6 +20,7 @@
 #include "shellCommand.h"
 #include "tkey.h"
 #include "tulog.h"
+#include "shellAuto.h"
 
 #define OPT_ABORT 1 /* �Cabort */
 
@@ -283,7 +284,12 @@ int32_t shellReadCommand(TAOS *con, char *command) {
         utf8_array[k] = c;
       }
       insertChar(&cmd, utf8_array, count);
+      pressOtherKey(c);
+    } else if (c == TAB_KEY) {
+      // press TAB key
+      pressTabKey(con, &cmd);
     } else if (c < '\033') {
+      pressOtherKey(c);
       // Ctrl keys.  TODO: Implement ctrl combinations
       switch (c) {
         case 1:  // ctrl A
@@ -329,8 +335,12 @@ int32_t shellReadCommand(TAOS *con, char *command) {
         case 21:  // Ctrl + U;
           clearLineBefore(&cmd);
           break;
+        case 23:  // Ctrl + W;
+          positionCursorMiddle(&cmd);
+          break;
       }
     } else if (c == '\033') {
+      pressOtherKey(c);
       c = (char)getchar();
       switch (c) {
         case '[':
@@ -405,9 +415,11 @@ int32_t shellReadCommand(TAOS *con, char *command) {
           break;
       }
     } else if (c == 0x7f) {
+      pressOtherKey(c);
       // press delete key
       backspaceChar(&cmd);
     } else {
+      pressOtherKey(c);
       insertChar(&cmd, &c, 1);
     }
   }
@@ -556,14 +568,14 @@ void showOnScreen(Command *cmd) {
     /* assert(size >= 0); */
     int width = wcwidth(wc);
     if (remain_column > width) {
-      printf("%lc", wc);
+      fprintf(stdout, "%lc", wc);
       remain_column -= width;
     } else {
       if (remain_column == width) {
-        printf("%lc\n\r", wc);
+        fprintf(stdout, "%lc\n\r", wc);
         remain_column = w.ws_col;
       } else {
-        printf("\n\r%lc", wc);
+        fprintf(stdout, "\n\r%lc", wc);
         remain_column = w.ws_col - width;
       }
     }

src/kit/shell/src/shellMain.c

@@ -17,14 +17,20 @@
 #include "shell.h"
 #include "tconfig.h"
 #include "tnettest.h"
+#include "shellCommand.h"
+#include "shellAuto.h"
 
 pthread_t pid;
 static tsem_t cancelSem;
+bool stop_fetch = false;
+int64_t ws_id = 0;
 
 void shellQueryInterruptHandler(int32_t signum, void *sigInfo, void *context) {
   tsem_post(&cancelSem);
 }
 
+void shellRestfulSendInterruptHandler(int32_t signum, void *sigInfo, void *context) {}
+
 void *cancelHandler(void *arg) {
   setThreadName("cancelHandler");
 
@@ -33,7 +39,12 @@ void *cancelHandler(void *arg) {
       taosMsleep(10);
       continue;
     }
-
+    if (args.restful || args.cloud) {
+      stop_fetch = true;
+      if (wsclient_send_sql(NULL, WS_CLOSE, ws_id)) {
+        exit(EXIT_FAILURE);
+      }
+    }
 #ifdef LINUX
     int64_t rid = atomic_val_compare_exchange_64(&result, result, 0);
     SSqlObj* pSql = taosAcquireRef(tscObjRef, rid);
@@ -87,6 +98,7 @@ SShellArguments args = {.host = NULL,
   .pktNum = 100,
   .pktType = "TCP",
   .netTestRole = NULL,
+  .cloudDsn = NULL,
   .cloud = true,
   .cloudHost = NULL,
   .cloudPort = NULL,
@@ -159,13 +171,21 @@ int main(int argc, char* argv[]) {
   taosSetSignal(SIGINT, shellQueryInterruptHandler);
   taosSetSignal(SIGHUP, shellQueryInterruptHandler);
   taosSetSignal(SIGABRT, shellQueryInterruptHandler);
+  if (args.restful || args.cloud) {
+#ifdef LINUX
+    taosSetSignal(SIGPIPE, shellRestfulSendInterruptHandler);
+#endif
+  }
 
   /* Get grant information */
   shellGetGrantInfo(args.con);
+  shellAutoInit();
 
   /* Loop to query the input. */
   while (1) {
     pthread_create(&pid, NULL, shellLoopQuery, args.con);
     pthread_join(pid, NULL);
   }
+
+  shellAutoExit();
 }

src/kit/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 = malloc(sizeof(STire));
+     memset(tire, 0, sizeof(STire));
+     tire->ref    = 1; // init is 1
+     tire->type   = type;
+     tire->root.d = (STireNode **)calloc(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]);
+        }
+        tfree(node->d);
+    }
+
+    // free self
+    tfree(node);
+}
+
+// destroy prefix search tree
+void freeTire(STire* tire) {
+    // free nodes
+    for (int i = 0; i < CHAR_CNT; i++) {
+        freeTireNode(tire->root.d[i]);
+    }
+    tfree(tire->root.d);
+
+    // free from list
+    StrName * item = tire->head;
+    while (item) {
+        // free string
+        tfree(item->name);
+        // free node
+        tfree(item);
+
+        // move next
+        item = item->next;
+    }
+    tire->head = tire->tail = NULL;
+
+    // free tire
+    tfree(tire);
+}
+
+// insert a new word to list
+bool insertToList(STire* tire, char* word) {
+    StrName * p = (StrName *)malloc(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* )tmalloc(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 **)calloc(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* )tmalloc(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* )tmalloc(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* )tmalloc(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* )tmalloc(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)
+      free(node->word);
+    free(node);
+}
+
+// free match result
+void freeMatch(SMatch* match) {
+    // first free next
+    if (match->head) {
+        freeMatchNode(match->head);
+    }
+
+    // second free self
+    free(match);
+}

src/tsdb/src/tsdbMain.c

@@ -128,7 +128,7 @@ int tsdbCloseRepo(STsdbRepo *repo, int toCommit) {
 
   tsdbStopStream(pRepo);
   if(pRepo->pthread){
-    taosDestoryThread(pRepo->pthread);
+    taosDestroyThread(pRepo->pthread);
     pRepo->pthread = NULL;
   }
 

src/util/inc/tthread.h

@@ -26,7 +26,7 @@ extern "C" {
 // create new thread
 pthread_t* taosCreateThread( void *(*__start_routine) (void *), void* param);
 // destory thread 
-bool taosDestoryThread(pthread_t* pthread);
+bool taosDestroyThread(pthread_t* pthread);
 // thread running return true
 bool taosThreadRunning(pthread_t* pthread);
 

src/util/src/tthread.c

@@ -38,7 +38,7 @@ pthread_t* taosCreateThread( void *(*__start_routine) (void *), void* param) {
 }
 
 // destory thread 
-bool taosDestoryThread(pthread_t* pthread) {
+bool taosDestroyThread(pthread_t* pthread) {
   if(pthread == NULL) return false;
   if(taosThreadRunning(pthread)) {
     pthread_cancel(*pthread);

src/vnode/src/vnodeMain.c

@@ -461,7 +461,7 @@ void vnodeStopWaitingThread(SVnodeObj* pVnode) {
     if(loop == 0) {
       vInfo("vgId:%d :SDEL force kill thread to quit. pthread=%p pWrite=%p", pVnode->vgId, pWaitThread->pthread, pWaitThread->param);
       // thread not stop , so need kill
-      taosDestoryThread(pWaitThread->pthread);
+      taosDestroyThread(pWaitThread->pthread);
       // write msg need remove from queue
       SVWriteMsg* pWrite = (SVWriteMsg* )pWaitThread->param;
       if (pWrite)