Merge pull request #15012 from taosdata/autotab26

Autotab V26 auto tab feature for linux and mac

src/kit/shell/CMakeLists.txt

@@ -46,6 +46,8 @@ ELSEIF (TD_DARWIN)
   LIST(APPEND SRC ./src/shellCommand.c)
   LIST(APPEND SRC ./src/shellImport.c)
   LIST(APPEND SRC ./src/shellCheck.c)
+  LIST(APPEND SRC ./src/shellAuto.c)
+  LIST(APPEND SRC ./src/tire.c)
   ADD_EXECUTABLE(shell ${SRC})
   # linking with dylib
   TARGET_LINK_LIBRARIES(shell taos cJson)

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;
-  cmd->screenOffset += wcwidth(wc);
-  cmd->endOffset += wcwidth(wc);
+  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/shellDarwin.c

@@ -22,6 +22,7 @@
 #include "tkey.h"
 
 #include "tscLog.h"
+#include "shellAuto.h"
 
 #define OPT_ABORT 1 /* �Cabort */
 
@@ -255,7 +256,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
@@ -301,6 +307,9 @@ 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') {
       c = getchar();
@@ -377,9 +386,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);
     }
   }

src/kit/shell/src/shellEngine.c

@@ -27,6 +27,7 @@
 #include "tglobal.h"
 #include "tsclient.h"
 #include "cJSON.h"
+#include "shellAuto.h"
 
 #include <regex.h>
 
@@ -327,6 +328,12 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
     fprintf(stdout, "Database changed.\n\n");
     fflush(stdout);
 
+#ifndef WINDOWS
+    // call back auto tab module
+    callbackAutoTab(command, pSql, true);
+#endif    
+
+
     atomic_store_64(&result, 0);
     freeResultWithRid(oresult);
     return;
@@ -365,6 +372,11 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
     int num_rows_affacted = taos_affected_rows(pSql);
     et = taosGetTimestampUs();
     printf("Query OK, %d of %d row(s) in database (%.6fs)\n", num_rows_affacted, num_rows_affacted, (et - st) / 1E6);
+
+#ifndef WINDOWS
+    // call auto tab
+    callbackAutoTab(command, pSql, false);
+#endif
   }
 
   printf("\n");

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

src/kit/shell/src/shellMain.c

@@ -17,6 +17,8 @@
 #include "shell.h"
 #include "tconfig.h"
 #include "tnettest.h"
+#include "shellCommand.h"
+#include "shellAuto.h"
 
 pthread_t pid;
 static tsem_t cancelSem;
@@ -162,10 +164,16 @@ int main(int argc, char* argv[]) {
 
   /* Get grant information */
   shellGetGrantInfo(args.con);
+#ifndef WINDOWS
+  shellAutoInit();
+#endif
 
   /* Loop to query the input. */
   while (1) {
     pthread_create(&pid, NULL, shellLoopQuery, args.con);
     pthread_join(pid, NULL);
   }
+#ifndef WINDOWS
+  shellAutoExit();
+#endif
 }

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) {
+        StrName * next = item->next;
+        // free string
+        tfree(item->name);
+        // free node
+        tfree(item);
+
+        // move next
+        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)