diff --git a/include/util/tthread.h b/include/util/tthread.h index 2215add06262ea63cbeb447f505c3a9e2bc134de..7afed98839dfc8a09ce46191f62216b418a671f1 100644 --- a/include/util/tthread.h +++ b/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); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 2251d09776a7f7ec3e49c66c299616488a42aba0..1f0d96a2e8dc88b15db2d6efa22a6979c8b99151 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -3097,6 +3097,7 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) { STagScanInfo* pInfo = pOperator->info; SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0]; SSDataBlock* pRes = pInfo->pRes; + blockDataCleanup(pRes); int32_t size = taosArrayGetSize(pInfo->pTableList->pTableList); if (size == 0) { diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c index 27b8e83a20cd5ea7d8f010911a6af5e8199de266..34997a5dd83aa6612d985acb07c91f1c5655e40a 100644 --- a/source/libs/executor/src/tfill.c +++ b/source/libs/executor/src/tfill.c @@ -584,7 +584,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma assert(numOfRes >= numOfRows); } else { // reach the end of data if ((ekey1 < pFillInfo->currentKey && FILL_IS_ASC_FILL(pFillInfo)) || - (ekey1 > pFillInfo->currentKey && !FILL_IS_ASC_FILL(pFillInfo))) { + (ekey1 >= pFillInfo->currentKey && !FILL_IS_ASC_FILL(pFillInfo))) { return 0; } numOfRes = taosTimeCountInterval(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding, diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 42512d3a11de0b5480d23a96fa463dc3572a370a..d91423ab5c3adbde9932e409d17e59060460183e 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -1251,12 +1251,12 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) { } } } else if (type == TSDB_DATA_TYPE_FLOAT) { - double prev = 0; - GET_TYPED_DATA(prev, double, type, &pBuf->v); + float prev = 0; + GET_TYPED_DATA(prev, float, type, &pBuf->v); - double val = GET_DOUBLE_VAL(tval); + float val = GET_DOUBLE_VAL(tval); if ((prev < val) ^ isMinFunc) { - *(double*)&pBuf->v = val; + *(float*)&pBuf->v = val; } if (pCtx->subsidiaries.num > 0) { diff --git a/source/util/src/tthread.c b/source/util/src/tthread.c index 3a2247872972a49b6f84bae370fc4463c432c4d4..5c409935ffba5bf4eb18beb9c81d28e72033edd5 100644 --- a/source/util/src/tthread.c +++ b/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); diff --git a/tests/script/tsim/parser/fill.sim b/tests/script/tsim/parser/fill.sim index 4892345e12ed4b22a1c3d96ae2e6233e7e9fe642..ea0311ebdebd05a166e67ac888f6cc2f53d8f93b 100644 --- a/tests/script/tsim/parser/fill.sim +++ b/tests/script/tsim/parser/fill.sim @@ -795,12 +795,34 @@ if $data81 != 4 then endi # desc fill query +print asc fill query +sql select _wstart,count(*) from m_fl_tb0 where ts>='2018-9-17 9:0:0' and ts<='2018-9-17 9:11:00' interval(1m) fill(value,10) order by _wstart asc; +if $rows != 12 then + return -1 +endi + +if $data00 != @18-09-17 09:00:00.000@ then + return -1 +endi + +if $data01 != 1 then + return -1 +endi + print desc fill query -sql select count(*) from m_fl_tb0 where ts>='2018-9-17 9:0:0' and ts<='2018-9-17 9:11:00' interval(1m) fill(value,10); +sql select _wstart,count(*) from m_fl_tb0 where ts>='2018-9-17 9:0:0' and ts<='2018-9-17 9:11:00' interval(1m) fill(value,10) order by _wstart desc; if $rows != 12 then return -1 endi +if $data00 != @18-09-17 09:11:00.000@ then + return -1 +endi + +if $data01 != 10 then + return -1 +endi + print =====================> aggregation + arithmetic + fill, need to add cases TODO #sql select avg(cpu_taosd) - first(cpu_taosd) from dn1 where ts<'2020-11-13 11:00:00' and ts>'2020-11-13 10:50:00' interval(10s) fill(value, 99) #sql select count(*), first(k), avg(k), avg(k)-first(k) from tm0 where ts>'2020-1-1 1:1:1' and ts<'2020-1-1 1:02:59' interval(10s) fill(value, 99); diff --git a/tools/shell/inc/shellAuto.h b/tools/shell/inc/shellAuto.h new file mode 100644 index 0000000000000000000000000000000000000000..2cfab41f26e91c0ad015670e825e216bb266996a --- /dev/null +++ b/tools/shell/inc/shellAuto.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#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); + +// introduction +void printfIntroduction(); + +#endif diff --git a/tools/shell/inc/shellInt.h b/tools/shell/inc/shellInt.h index 15f6f6dc6a362c8c94994727fe19fa090ca94c57..af724c1533177c2203d58b6f5cd1f02fc236f5c4 100644 --- a/tools/shell/inc/shellInt.h +++ b/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[]); diff --git a/tools/shell/inc/shellTire.h b/tools/shell/inc/shellTire.h new file mode 100644 index 0000000000000000000000000000000000000000..88bae5480937cfdb1513415d13ba41d0a60e6b22 --- /dev/null +++ b/tools/shell/inc/shellTire.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#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 diff --git a/tools/shell/src/shellAuto.c b/tools/shell/src/shellAuto.c new file mode 100644 index 0000000000000000000000000000000000000000..c648b6932b9a9a3167844459af192ff8921d836d --- /dev/null +++ b/tools/shell/src/shellAuto.c @@ -0,0 +1,2052 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#define __USE_XOPEN + +#include "shellInt.h" +#include "shellAuto.h" +#include "shellTire.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); +bool appendAfterSelect(TAOS * con, SShellCmd * cmd, char* p, int32_t len); + + +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 ;", 0, 0, NULL}, + {"alter dnode balance ", 0, 0, NULL}, + {"alter dnode resetlog;", 0, 0, NULL}, + {"alter dnode debugFlag 141;", 0, 0, NULL}, + {"alter dnode monitor 1;", 0, 0, NULL}, + {"alter all dnodes monitor ", 0, 0, NULL}, + {"alter alldnodes balance ", 0, 0, NULL}, + {"alter alldnodes resetlog;", 0, 0, NULL}, + {"alter alldnodes debugFlag 141;", 0, 0, NULL}, + {"alter alldnodes monitor 1;", 0, 0, NULL}, + {"alter table ;", 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 ;", 0, 0, NULL}, + // 20 + {"create table using tags(", 0, 0, NULL}, + {"create database ;", 0, 0, NULL}, + {"create dnode ", 0, 0, NULL}, + {"create index ", 0, 0, NULL}, + {"create mnode on dnode ;", 0, 0, NULL}, + {"create qnode on dnode ;", 0, 0, NULL}, + {"create stream into as select", 0, 0, NULL}, // 26 append sub sql + {"create topic as select", 0, 0, NULL}, // 27 append sub sql + {"create function ", 0, 0, NULL}, + {"create user pass sysinfo 0;", 0, 0, NULL}, + {"create user pass sysinfo 1;", 0, 0, NULL}, + {"describe ", 0, 0, NULL}, + {"delete from where ", 0, 0, NULL}, + {"drop database ", 0, 0, NULL}, + {"drop table ", 0, 0, NULL}, + {"drop dnode ", 0, 0, NULL}, + {"drop mnode on dnode ;", 0, 0, NULL}, + {"drop qnode on dnode ;", 0, 0, NULL}, + {"drop user ;", 0, 0, NULL}, + // 40 + {"drop function", 0, 0, NULL}, + {"drop consumer group on ", 0, 0, NULL}, + {"drop topic ;", 0, 0, NULL}, + {"drop stream ;", 0, 0, NULL}, + {"explain select", 0, 0, NULL}, // 44 append sub sql + {"grant all on to ;", 0, 0, NULL}, + {"grant read on to ;", 0, 0, NULL}, + {"grant write on to ;", 0, 0, NULL}, + {"kill connection ;", 0, 0, NULL}, + {"kill query ", 0, 0, NULL}, + {"kill transaction ", 0, 0, NULL}, + {"merge vgroup ", 0, 0, NULL}, + {"reset query cache;", 0, 0, NULL}, + {"revoke all on from ;", 0, 0, NULL}, + {"revoke read on from ;", 0, 0, NULL}, + {"revoke write on from ;", 0, 0, NULL}, + {"select * from ", 0, 0, NULL}, + {"select _block_dist() from \\G;", 0, 0, NULL}, + {"select client_version();", 0, 0, NULL}, + // 60 + {"select current_user();", 0, 0, NULL}, + {"select database();", 0, 0, NULL}, + {"select server_version();", 0, 0, NULL}, + {"select server_status();", 0, 0, NULL}, + {"select now();", 0, 0, NULL}, + {"select today();", 0, 0, NULL}, + {"select timezone();", 0, 0, NULL}, + {"set max_binary_display_width ", 0, 0, NULL}, + {"show apps;", 0, 0, NULL}, + {"show create database \\G;", 0, 0, NULL}, + {"show create stable \\G;", 0, 0, NULL}, + {"show create table \\G;", 0, 0, NULL}, + {"show connections;", 0, 0, NULL}, + {"show cluster;", 0, 0, NULL}, + {"show databases;", 0, 0, NULL}, + {"show dnodes;", 0, 0, NULL}, + {"show dnode variables;", 0, 0, NULL}, + {"show functions;", 0, 0, NULL}, + {"show mnodes;", 0, 0, NULL}, + {"show queries;", 0, 0, NULL}, + // 80 + {"show query ;", 0, 0, NULL}, + {"show qnodes;", 0, 0, NULL}, + {"show snodes;", 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 subscriptions;", 0, 0, NULL}, + {"show tables;", 0, 0, NULL}, + {"show tables like", 0, 0, NULL}, + {"show table distributed ", 0, 0, NULL}, + {"show tags from ", 0, 0, NULL}, + {"show tags from ", 0, 0, NULL}, + {"show topics;", 0, 0, NULL}, + {"show transactions;", 0, 0, NULL}, + {"show users;", 0, 0, NULL}, + {"show variables;", 0, 0, NULL}, + {"show local variables;", 0, 0, NULL}, + {"show vnodes ", 0, 0, NULL}, + {"show vgroups;", 0, 0, NULL}, + {"show consumers;", 0, 0, NULL}, + {"show grants;", 0, 0, NULL}, + {"split vgroup ", 0, 0, NULL}, + {"insert into values(", 0, 0, NULL}, + {"insert into using tags(", 0, 0, NULL}, + {"insert into using values(", 0, 0, NULL}, + {"insert into file ", 0, 0, NULL}, + {"trim database ", 0, 0, NULL}, + {"use ", 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 ", + "partition by " +}; + +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 ", + "rename column ", + "add tag ", + "modify tag ", + "drop tag ", + "rename tag ", + "set tag ", +}; + +char * user_actions[] = { + "pass ", + "enable ", + "sysinfo " +}; + +char * tb_options[] = { + "comment ", + "watermark ", + "max_delay ", + "ttl ", + "rollup(", + "sma(" +}; + +char * db_options[] = { + "keep ", + "replica ", + "precision ", + "strict ", + "buffer ", + "cachemodel ", + "cachesize ", + "comp ", + "duration ", + "wal_fsync_period", + "maxrows ", + "minrows ", + "pages ", + "pagesize ", + "retentions ", + "wal_level ", + "vgroups ", + "single_stable ", + "wal_retention_period ", + "wal_roll_period ", + "wal_retention_size ", + "wal_segment_size " +}; + +char * alter_db_options[] = { + "keep ", + "cachemodel ", + "cachesize ", + "wal_fsync_period ", + "wal_level " +}; + +char * data_types[] = { + "timestamp", + "int", + "int unsigned", + "varchar(16)", + "float", + "double", + "binary(16)", + "nchar(16)", + "bigint", + "bigint unsigned", + "smallint", + "smallint unsigned", + "tinyint", + "tinyint unsigned", + "bool", + "json" +}; + +char * key_tags[] = { + "tags(" +}; + +char * key_select[] = { + "select " +}; + +// +// ------- 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_TOPIC 5 +#define WT_VAR_STREAM 6 +#define WT_VAR_ALLTABLE 7 +#define WT_VAR_FUNC 8 +#define WT_VAR_KEYWORD 9 +#define WT_VAR_TBACTION 10 +#define WT_VAR_DBOPTION 11 +#define WT_VAR_ALTER_DBOPTION 12 +#define WT_VAR_DATATYPE 13 +#define WT_VAR_KEYTAGS 14 +#define WT_VAR_ANYWORD 15 +#define WT_VAR_TBOPTION 16 +#define WT_VAR_USERACTION 17 +#define WT_VAR_KEYSELECT 18 + + +#define WT_VAR_CNT 19 + +#define WT_FROM_DB_MAX 6 // 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] = { + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" +}; + +char varSqls[WT_FROM_DB_CNT][64] = { + "show databases;", + "show stables;", + "show tables;", + "show dnodes;", + "show users;", + "show topics;", + "show streams;" +}; + + +// 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 Key ********************************\n"); + printf(" * TDengine Command Line supports pressing TAB key to complete word, *\n"); + printf(" * including database name, table name, function name and keywords. *\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 TDengine Command Line:"); + printf("\n\ + ----- A ----- \n\ + alter database \n\ + alter dnode balance \n\ + alter dnode resetlog;\n\ + alter all dnodes monitor \n\ + alter alldnodes balance \n\ + alter alldnodes resetlog;\n\ + alter alldnodes debugFlag \n\ + alter alldnodes monitor \n\ + alter table ;\n\ + alter table modify column\n\ + alter local resetlog;\n\ + alter local DebugFlag 143;\n\ + alter topic\n\ + alter user ...\n\ + ----- C ----- \n\ + create table using tags ...\n\ + create database ...\n\ + create dnode ...\n\ + create index ...\n\ + create mnode on dnode ;\n\ + create qnode on dnode ;\n\ + create stream into as select ...\n\ + create topic as select ...\n\ + create function ...\n\ + create user pass ...\n\ + ----- D ----- \n\ + describe \n\ + delete from where ...\n\ + drop database ;\n\ + drop table ;\n\ + drop dnode ;\n\ + drop mnode on dnode ;\n\ + drop qnode on dnode ;\n\ + drop user ;\n\ + drop function ;\n\ + drop consumer group ... \n\ + drop topic ;\n\ + drop stream ;\n\ + ----- E ----- \n\ + explain select clause ...\n\ + ----- I ----- \n\ + insert into values(...) ;\n\ + insert into using tags(...) values(...) ;\n\ + ----- G ----- \n\ + grant all on to ;\n\ + grant read on to ;\n\ + grant write on to ;\n\ + ----- K ----- \n\ + kill connection ; \n\ + kill query ; \n\ + kill transaction ;\n\ + ----- M ----- \n\ + merge vgroup ...\n\ + ----- R ----- \n\ + reset query cache;\n\ + revoke all on from ;\n\ + revoke read on from ;\n\ + revoke write on from ;\n\ + ----- S ----- \n\ + select * from where ... \n\ + select _block_dist() from ;\n\ + select client_version();\n\ + select current_user();\n\ + select database();\n\ + select server_version();\n\ + select server_status();\n\ + select now();\n\ + select today();\n\ + select timezone();\n\ + set max_binary_display_width ...\n\ + show apps;\n\ + show create database ;\n\ + show create stable ;\n\ + show create table ;\n\ + show connections;\n\ + show cluster;\n\ + show databases;\n\ + show dnodes;\n\ + show dnode variables;\n\ + show functions;\n\ + show mnodes;\n\ + show queries;\n\ + show query ;\n\ + show qnodes;\n\ + show snodes;\n\ + show stables;\n\ + show stables like \n\ + show streams;\n\ + show scores;\n\ + show subscriptions;\n\ + show tables;\n\ + show tables like\n\ + show table distributed ;\n\ + show tags from \n\ + show tags from \n\ + show topics;\n\ + show transactions;\n\ + show users;\n\ + show variables;\n\ + show local variables;\n\ + show vnodes \n\ + show vgroups;\n\ + show consumers;\n\ + show grants;\n\ + split vgroup ...\n\ + ----- T ----- \n\ + trim database ;\n\ + ----- U ----- \n\ + use ;"); + + 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_ALTER_DBOPTION, alter_db_options, sizeof(alter_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 *)); + GenerateVarType(WT_VAR_TBOPTION, tb_options, sizeof(tb_options) /sizeof(char *)); + GenerateVarType(WT_VAR_USERACTION, user_actions, sizeof(user_actions) /sizeof(char *)); + GenerateVarType(WT_VAR_KEYSELECT,key_select, sizeof(key_select) /sizeof(char *)); + + 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_FROM_DB_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_INT) { + 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 p1 > p2 ? 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; +} + +// p is string following select keyword +bool appendAfterSelect(TAOS * con, SShellCmd * cmd, char* sql, int32_t len) { + char* p = strndup(sql, 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(p); + 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(p); + 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(p); + return ret; +} + +int32_t searchAfterSelect(char* p, int32_t len) { + // select * from st; + if(strncasecmp(p, "select ", 7) == 0) { + // check nest query + char *p1 = p + 7; + while(1) { + char *p2 = strstr(p1, "select "); + if(p2 == NULL) + break; + p1 = p2 + 7; + } + + return p1 - p; + } + + // explain as select * from st; + if(strncasecmp(p, "explain select ", 15) == 0) { + return 15; + } + + char* as_pos_end = strstr(p, " as select "); + if (as_pos_end == NULL) + return -1; + as_pos_end += 11; + + // create stream as select + if(strncasecmp(p, "create stream ", 14) == 0) { + return as_pos_end - p;; + } + + // create topic as select + if(strncasecmp(p, "create topic ", 13) == 0) { + return as_pos_end - p; + } + + return -1; +} + +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; + } + + // search + char* sql_cp = strndup(p, len); + int32_t n = searchAfterSelect(sql_cp, len); + taosMemoryFree(sql_cp); + if(n == -1 || n > len) + return false; + p += n; + len -= n; + + // append + return appendAfterSelect(con, cmd, p, len); +} + +// 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); + } + } + } + + // tb options + if (!ret) { + // find like create talbe st (...) tags(..) + char * p1 = strchr(ps, ')'); // first ')' end + if (p1) { + if(strchr(p1 + 1, ')')) { // second ')' end + // here is tb options area, can insert option + ret = fillWithType(con, cmd, last, WT_VAR_TBOPTION); + } + } + } + + 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; + } + + // too small + if(len < 8) + return false; + + // like 'from ( ' + char* sql = strndup(p, len); + char* last = lastWord(sql); + + if (strcmp(last, "from(") == 0) { + fillWithType(con, cmd, "", WT_VAR_KEYSELECT); + taosMemoryFree(sql); + return true; + } + if (strncmp(last, "(", 1) == 0) { + last += 1; + } + + char* from = strstr(sql, " from"); + // find last ' from' + while (from) { + char* p1 = strstr(from + 5, " from"); + if (p1 == NULL) + break; + from = p1; + } + + if (from) { + // find next is '(' + char * p2 = from + 5; + bool found = false; // found 'from ... ( ...' ... is any count of blank + bool found1 = false; // found '(' + while (1) { + if ( p2 == last || *p2 == '\0') { + // last word or string end + if (found1) { + found = true; + } + break; + } else if(*p2 == '(') { + found1 = true; + } else if(*p2 == ' ') { + // do nothing + } else { + // have any other char + break; + } + + // move next + p2++; + } + + if (found) { + fillWithType(con, cmd, last, WT_VAR_KEYSELECT); + taosMemoryFree(sql); + return true; + } + } + + // INSERT + + + taosMemoryFree(sql); + + 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 if (strcasecmp(name, "topic") == 0) { + type = WT_VAR_TOPIC; + } else if (strcasecmp(name, "stream") == 0) { + type = WT_VAR_STREAM; + } 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 if (strcasecmp(name, "topic") == 0) { + type = WT_VAR_TOPIC; + } else if (strcasecmp(name, "stream") == 0) { + type = WT_VAR_STREAM; + } 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 ; +} diff --git a/tools/shell/src/shellCommand.c b/tools/shell/src/shellCommand.c index b73317e991042f6ce96a470ca9325cc2754fe47a..cffa02824e28dcbd84e7930b9ae7df6422f38610 100644 --- a/tools/shell/src/shellCommand.c +++ b/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; - cmd->screenOffset += taosWcharWidth(wc); - cmd->endOffset += taosWcharWidth(wc); + 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); } } diff --git a/tools/shell/src/shellEngine.c b/tools/shell/src/shellEngine.c index 45d5489803fb5a0f7ec5506320d9e21257c8281b..066b3a0156098961707328eac5ebd76baf6df5b3 100644 --- a/tools/shell/src/shellEngine.c +++ b/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"); @@ -1053,6 +1060,7 @@ int32_t shellExecute() { } #endif + shellSetConn(shell.conn); shellReadHistory(); if (pArgs->commands != NULL || pArgs->file[0] != 0) { @@ -1098,6 +1106,7 @@ int32_t shellExecute() { #ifdef WEBSOCKET if (!shell.args.restful && !shell.args.cloud) { #endif + printfIntroduction(); shellGetGrantInfo(); #ifdef WEBSOCKET } diff --git a/tools/shell/src/shellMain.c b/tools/shell/src/shellMain.c index 964082f3c3576967457b95ee1b3ab1730bf71542..fa3c0f2585ad6d6ef14c3dda35fb64024a521a02 100644 --- a/tools/shell/src/shellMain.c +++ b/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; } diff --git a/tools/shell/src/shellTire.c b/tools/shell/src/shellTire.c new file mode 100644 index 0000000000000000000000000000000000000000..dc5efa4e8d152adb6d4dde2732a49ef91b678561 --- /dev/null +++ b/tools/shell/src/shellTire.c @@ -0,0 +1,435 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#define __USE_XOPEN + +#include "os.h" +#include "shellTire.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); +}