#define _XOPEN_SOURCE

#define _DEFAULT_SOURCE

#include "os.h"

#include "qast.h"

#include "taos.h"

#include "taosmsg.h"

#include "tstoken.h"

#include "tstrbuild.h"

#include "ttime.h"

#include "tscUtil.h"

#include "tschemautil.h"

#include "tsclient.h"

#include "ttokendef.h"

#include "name.h"

#include "tcompare.h"

#define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"

#define COLUMN_INDEX_INITIAL_VAL (-2)

#define COLUMN_INDEX_INITIALIZER \

{ COLUMN_INDEX_INITIAL_VAL, COLUMN_INDEX_INITIAL_VAL }

#define COLUMN_INDEX_VALIDE(index) (((index).tableIndex >= 0) && ((index).columnIndex >= TSDB_TBNAME_COLUMN_INDEX))

#define TBNAME_LIST_SEP ","

typedef struct SColumnList {

int32_t num;

SColumnIndex ids[TSDB_MAX_COLUMNS];

} SColumnList;

static SSqlExpr* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t outputIndex, int32_t colIndex, int32_t tableIndex);

static int32_t setShowInfo(SSqlObj* pSql, SSqlInfo* pInfo);

static char* getAccountId(SSqlObj* pSql);

static bool has(tFieldList* pFieldList, int32_t startIdx, const char* name);

static void getCurrentDBName(SSqlObj* pSql, SSQLToken* pDBToken);

static bool hasSpecifyDB(SSQLToken* pTableName);

static bool validateTableColumnInfo(tFieldList* pFieldList, SSqlCmd* pCmd);

static bool validateTagParams(tFieldList* pTagsList, tFieldList* pFieldList, SSqlCmd* pCmd);

static int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQLToken* tableName, int32_t* len);

static void getColumnName(tSQLExprItem* pItem, char* resultFieldName, int32_t nameLength);

static void getRevisedName(char* resultFieldName, int32_t functionId, int32_t maxLen, char* columnName);

static int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExprItem* pItem, bool finalResult);

static int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnList* pIdList, int16_t bytes,

int8_t type, char* fieldName, SSqlExpr* pSqlExpr);

static int32_t changeFunctionID(int32_t optr, int16_t* functionId);

static int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSelection, bool isSTable);

static bool validateIpAddress(const char* ip, size_t size);

static bool hasUnsupportFunctionsForSTableQuery(SQueryInfo* pQueryInfo);

static bool functionCompatibleCheck(SQueryInfo* pQueryInfo);

static void setColumnOffsetValueInResultset(SQueryInfo* pQueryInfo);

static int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd* pCmd);

static int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql);

static int32_t parseSlidingClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql);

static int32_t addProjectionExprAndResultField(SQueryInfo* pQueryInfo, tSQLExprItem* pItem);

static int32_t parseWhereClause(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SSqlObj* pSql);

static int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL);

static int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema* pSchema);

static int32_t tsRewriteFieldNameIfNecessary(SQueryInfo* pQueryInfo);

static int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo);

static int32_t validateSqlFunctionInStreamSql(SQueryInfo* pQueryInfo);

static int32_t buildArithmeticExprString(tSQLExpr* pExpr, char** exprString);

static int32_t validateFunctionsInIntervalOrGroupbyQuery(SQueryInfo* pQueryInfo);

static int32_t validateArithmeticSQLExpr(tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnList* pList, int32_t* type);

static int32_t validateDNodeConfig(tDCLSQL* pOptions);

static int32_t validateLocalConfig(tDCLSQL* pOptions);

static int32_t validateColumnName(char* name);

static int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo);

static bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField);

static bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo);

static void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex);

static int32_t parseLimitClause(SQueryInfo* pQueryInfo, int32_t index, SQuerySQL* pQuerySql, SSqlObj* pSql);

static int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDBInfo* pCreateDbSql);

static int32_t getColumnIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);

static int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);

static int32_t optrToString(tSQLExpr* pExpr, char** exprString);

static int32_t getMeterIndex(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);

static int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);

static int32_t doLocalQueryProcess(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql);

static int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCMCreateDbMsg* pCreate);

static SColumnList getColumnList(int32_t num, int16_t tableIndex, int32_t columnIndex);

static int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* pInfo);

static int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo);

static int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo);

static int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index);

static int32_t exprTreeFromSqlExpr(tExprNode **pExpr, tSQLExpr* pSqlExpr, SSqlExprInfo* pExprInfo, SQueryInfo* pQueryInfo, SArray* pCols);

static int32_t invalidSqlErrMsg(char* dstBuffer, const char* errMsg) {

return tscInvalidSQLErrMsg(dstBuffer, errMsg, NULL);

}

static int32_t tscQueryOnlyMetricTags(SQueryInfo* pQueryInfo, bool* queryOnMetricTags) {

assert(QUERY_IS_STABLE_QUERY(pQueryInfo->type));

*queryOnMetricTags = true;

for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {

SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);

if (pExpr->functionId != TSDB_FUNC_TAGPRJ &&

!(pExpr->functionId == TSDB_FUNC_COUNT && pExpr->colInfo.colIndex == TSDB_TBNAME_COLUMN_INDEX)) {

*queryOnMetricTags = false;

break;

}

}

return TSDB_CODE_SUCCESS;

}

static int setColumnFilterInfoForTimestamp(SQueryInfo* pQueryInfo, tVariant* pVar) {

int64_t time = 0;

const char* msg = "invalid timestamp";

strdequote(pVar->pz);

char* seg = strnchr(pVar->pz, '-', pVar->nLen, false);

STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);

if (seg != NULL) {

if (taosParseTime(pVar->pz, &time, pVar->nLen, tinfo.precision) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(pQueryInfo->msg, msg);

}

} else {

if (tVariantDump(pVar, (char*)&time, TSDB_DATA_TYPE_BIGINT)) {

return invalidSqlErrMsg(pQueryInfo->msg, msg);

}

}

tVariantDestroy(pVar);

tVariantCreateFromBinary(pVar, (char*)&time, 0, TSDB_DATA_TYPE_BIGINT);

return TSDB_CODE_SUCCESS;

}

static int32_t handlePassword(SSqlCmd* pCmd, SSQLToken* pPwd) {

const char* msg1 = "password can not be empty";

const char* msg2 = "name or password too long";

const char* msg3 = "password needs single quote marks enclosed";

if (pPwd->type != TK_STRING) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

}

strdequote(pPwd->z);

strtrim(pPwd->z); // trim space before and after passwords

pPwd->n = strlen(pPwd->z);

if (pPwd->n <= 0) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

if (pPwd->n > TSDB_PASSWORD_LEN) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

return TSDB_CODE_SUCCESS;

}

int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {

if (pInfo == NULL || pSql == NULL || pSql->signature != pSql) {

return TSDB_CODE_APP_ERROR;

}

SSqlCmd* pCmd = &(pSql->cmd);

SQueryInfo* pQueryInfo = NULL;

if (!pInfo->valid) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), pInfo->pzErrMsg);

}

int32_t code = tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex, &pQueryInfo);

STableMetaInfo* pTableMetaInfo = NULL;

if (pQueryInfo->numOfTables == 0) {

pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);

} else {

pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];

}

pCmd->command = pInfo->type;

switch (pInfo->type) {

case TSDB_SQL_DROP_TABLE:

case TSDB_SQL_DROP_USER:

case TSDB_SQL_DROP_ACCT:

case TSDB_SQL_DROP_DNODE:

case TSDB_SQL_DROP_DB: {

const char* msg1 = "invalid ip address";

const char* msg2 = "invalid name";

const char* msg3 = "param name too long";

SSQLToken* pzName = &pInfo->pDCLInfo->a[0];

if ((pInfo->type != TSDB_SQL_DROP_DNODE) && (tscValidateName(pzName) != TSDB_CODE_SUCCESS)) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

if (pInfo->type == TSDB_SQL_DROP_DB) {

assert(pInfo->pDCLInfo->nTokens == 1);

code = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), pzName, NULL, NULL);

if (code != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

} else if (pInfo->type == TSDB_SQL_DROP_TABLE) {

assert(pInfo->pDCLInfo->nTokens == 1);

if (setMeterID(pTableMetaInfo, pzName, pSql) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

}

} else if (pInfo->type == TSDB_SQL_DROP_DNODE) {

if (!validateIpAddress(pzName->z, pzName->n)) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

strncpy(pTableMetaInfo->name, pzName->z, pzName->n);

} else { // drop user

if (pzName->n > TSDB_USER_LEN) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

}

strncpy(pTableMetaInfo->name, pzName->z, pzName->n);

}

break;

}

case TSDB_SQL_USE_DB: {

const char* msg = "invalid db name";

SSQLToken* pToken = &pInfo->pDCLInfo->a[0];

if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

int32_t ret = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), pToken, NULL, NULL);

if (ret != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

break;

}

case TSDB_SQL_RESET_CACHE: {

return TSDB_CODE_SUCCESS;

}

case TSDB_SQL_SHOW: {

if (setShowInfo(pSql, pInfo) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

break;

}

case TSDB_SQL_ALTER_DB:

case TSDB_SQL_CREATE_DB: {

const char* msg1 = "invalid db name";

const char* msg2 = "name too long";

SCreateDBInfo* pCreateDB = &(pInfo->pDCLInfo->dbOpt);

if (tscValidateName(&pCreateDB->dbname) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

int32_t ret = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), &(pCreateDB->dbname), NULL, NULL);

if (ret != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

if (parseCreateDBOptions(pCmd, pCreateDB) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

break;

}

case TSDB_SQL_CREATE_DNODE: { // todo parse hostname

const char* msg = "invalid ip address";

if (pInfo->pDCLInfo->nTokens > 1) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

SSQLToken* pIpAddr = &pInfo->pDCLInfo->a[0];

if (!validateIpAddress(pIpAddr->z, pIpAddr->n)) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

break;

}

case TSDB_SQL_CREATE_ACCT:

case TSDB_SQL_ALTER_ACCT: {

const char* msg1 = "invalid state option, available options[no, r, w, all]";

const char* msg2 = "invalid user/account name";

const char* msg3 = "name too long";

SSQLToken* pName = &pInfo->pDCLInfo->user.user;

SSQLToken* pPwd = &pInfo->pDCLInfo->user.passwd;

if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

if (pName->n > TSDB_USER_LEN) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

}

if (tscValidateName(pName) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

SCreateAcctSQL* pAcctOpt = &pInfo->pDCLInfo->acctOpt;

if (pAcctOpt->stat.n > 0) {

if (pAcctOpt->stat.z[0] == 'r' && pAcctOpt->stat.n == 1) {

} else if (pAcctOpt->stat.z[0] == 'w' && pAcctOpt->stat.n == 1) {

} else if (strncmp(pAcctOpt->stat.z, "all", 3) == 0 && pAcctOpt->stat.n == 3) {

} else if (strncmp(pAcctOpt->stat.z, "no", 2) == 0 && pAcctOpt->stat.n == 2) {

} else {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

}

break;

}

case TSDB_SQL_DESCRIBE_TABLE: {

SSQLToken* pToken = &pInfo->pDCLInfo->a[0];

const char* msg2 = "table name is too long";

const char* msg1 = "invalid table name";

if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

if (pToken->n > TSDB_TABLE_NAME_LEN) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

if (setMeterID(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

return tscGetTableMeta(pSql, pTableMetaInfo);

}

case TSDB_SQL_CFG_DNODE: {

const char* msg1 = "invalid ip address";

const char* msg2 = "invalid configure options or values";

/* validate the ip address */

tDCLSQL* pDCL = pInfo->pDCLInfo;

if (!validateIpAddress(pDCL->a[0].z, pDCL->a[0].n)) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

/* validate the parameter names and options */

if (validateDNodeConfig(pDCL) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

char* pMsg = pCmd->payload + tsRpcHeadSize;

pMsg += sizeof(SMgmtHead);

SCMCfgDnodeMsg* pCfg = (SCMCfgDnodeMsg*)pMsg;

strncpy(pCfg->ip, pDCL->a[0].z, pDCL->a[0].n);

strncpy(pCfg->config, pDCL->a[1].z, pDCL->a[1].n);

if (pDCL->nTokens == 3) {

pCfg->config[pDCL->a[1].n] = ' '; // add sep

strncpy(&pCfg->config[pDCL->a[1].n + 1], pDCL->a[2].z, pDCL->a[2].n);

}

break;

}

case TSDB_SQL_CREATE_USER:

case TSDB_SQL_ALTER_USER: {

const char* msg5 = "invalid user rights";

const char* msg7 = "not support options";

const char* msg2 = "invalid user/account name";

const char* msg3 = "name too long";

pCmd->command = pInfo->type;

// tDCLSQL* pDCL = pInfo->pDCLInfo;

SUserInfo* pUser = &pInfo->pDCLInfo->user;

SSQLToken* pName = &pUser->user;

SSQLToken* pPwd = &pUser->passwd;

if (pName->n > TSDB_USER_LEN) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

}

if (tscValidateName(pName) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

}

if (pCmd->command == TSDB_SQL_CREATE_USER) {

if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

} else {

if (pUser->type == TSDB_ALTER_USER_PASSWD) {

if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

} else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {

assert(pPwd->type == TSDB_DATA_TYPE_NULL);

SSQLToken* pPrivilege = &pUser->privilege;

if (strncasecmp(pPrivilege->z, "super", 5) == 0 && pPrivilege->n == 5) {

pCmd->count = 1;

} else if (strncasecmp(pPrivilege->z, "read", 4) == 0 && pPrivilege->n == 4) {

pCmd->count = 2;

} else if (strncasecmp(pPrivilege->z, "write", 5) == 0 && pPrivilege->n == 5) {

pCmd->count = 3;

} else {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);

}

} else {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);

}

}

break;

}

case TSDB_SQL_CFG_LOCAL: {

tDCLSQL* pDCL = pInfo->pDCLInfo;

const char* msg = "invalid configure options or values";

// validate the parameter names and options

if (validateLocalConfig(pDCL) != TSDB_CODE_SUCCESS) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

strncpy(pCmd->payload, pDCL->a[0].z, pDCL->a[0].n);

if (pDCL->nTokens == 2) {

pCmd->payload[pDCL->a[0].n] = ' '; // add sep

strncpy(&pCmd->payload[pDCL->a[0].n + 1], pDCL->a[1].z, pDCL->a[1].n);

}

break;

}

case TSDB_SQL_CREATE_TABLE: {

SCreateTableSQL* pCreateTable = pInfo->pCreateTableInfo;

if (pCreateTable->type == TSQL_CREATE_TABLE || pCreateTable->type == TSQL_CREATE_STABLE) {

if ((code = doCheckForCreateTable(pSql, 0, pInfo)) != TSDB_CODE_SUCCESS) {

return code;

}

} else if (pCreateTable->type == TSQL_CREATE_TABLE_FROM_STABLE) {

assert(pCmd->numOfCols == 0);

if ((code = doCheckForCreateFromStable(pSql, pInfo)) != TSDB_CODE_SUCCESS) {

return code;

}

} else if (pCreateTable->type == TSQL_CREATE_STREAM) {

if ((code = doCheckForStream(pSql, pInfo)) != TSDB_CODE_SUCCESS) {

return code;

}

}

break;

}

case TSDB_SQL_SELECT: {

assert(pCmd->numOfClause == 1);

const char* msg1 = "columns in select clause not identical";

for (int32_t i = pCmd->numOfClause; i < pInfo->subclauseInfo.numOfClause; ++i) {

SQueryInfo* pqi = NULL;

if ((code = tscGetQueryInfoDetailSafely(pCmd, i, &pqi)) != TSDB_CODE_SUCCESS) {

return code;

}

}

assert(pCmd->numOfClause == pInfo->subclauseInfo.numOfClause);

for (int32_t i = 0; i < pInfo->subclauseInfo.numOfClause; ++i) {

SQuerySQL* pQuerySql = pInfo->subclauseInfo.pClause[i];

if ((code = doCheckForQuery(pSql, pQuerySql, i)) != TSDB_CODE_SUCCESS) {

return code;

}

tscPrintSelectClause(pSql, i);

}

// set the command/global limit parameters from the first subclause to the sqlcmd object

SQueryInfo* pQueryInfo1 = tscGetQueryInfoDetail(pCmd, 0);

pCmd->command = pQueryInfo1->command;

// if there is only one element, the limit of clause is the limit of global result.

for (int32_t i = 1; i < pCmd->numOfClause; ++i) {

SQueryInfo* pQueryInfo2 = tscGetQueryInfoDetail(pCmd, i);

int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pQueryInfo2->fieldsInfo);

if (ret != 0) {

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

}

}

return TSDB_CODE_SUCCESS; // do not build query message here

}

case TSDB_SQL_ALTER_TABLE: {

if ((code = setAlterTableInfo(pSql, pInfo)) != TSDB_CODE_SUCCESS) {

return code;

}

break;

}

case TSDB_SQL_KILL_QUERY:

case TSDB_SQL_KILL_STREAM:

case TSDB_SQL_KILL_CONNECTION: {

if ((code = setKillInfo(pSql, pInfo)) != TSDB_CODE_SUCCESS) {

return code;

}

break;

}

default:

return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");

}

return tscBuildMsg[pCmd->command](pSql, pInfo);

}

static bool isTopBottomQuery(SQueryInfo* pQueryInfo) {

for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {

int32_t functionId = tscSqlExprGet(pQueryInfo, i)->functionId;

if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM) {

return true;

}

}

return false;

}

int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {

const char* msg1 = "invalid query expression";

const char* msg2 = "interval cannot be less than 10 ms";

STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);

if (pQuerySql->interval.type == 0 || pQuerySql->interval.n == 0) {

return TSDB_CODE_SUCCESS;

}

// interval is not null

SSQLToken* t = &pQuerySql->interval;

if (getTimestampInUsFromStr(t->z, t->n, &pQueryInfo->intervalTime) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

// if the unit of time window value is millisecond, change the value from microsecond

if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {

pQueryInfo->intervalTime = pQueryInfo->intervalTime / 1000;

}

/* parser has filter the illegal type, no need to check here */

pQueryInfo->slidingTimeUnit = pQuerySql->interval.z[pQuerySql->interval.n - 1];

// interval cannot be less than 10 milliseconds

if (pQueryInfo->intervalTime < tsMinIntervalTime) {

return invalidSqlErrMsg(pQueryInfo->msg, msg2);

}

// for top/bottom + interval query, we do not add additional timestamp column in the front

if (isTopBottomQuery(pQueryInfo)) {

if (parseSlidingClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

return TSDB_CODE_SUCCESS;

}

/*

for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {

SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);

if (pExpr->functionId == TSDB_FUNC_COUNT && TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {

return invalidSqlErrMsg(pQueryInfo->msg, msg1);

}

}

/*

if (tscQueryTags(pQueryInfo) && pQueryInfo->intervalTime > 0) {

return invalidSqlErrMsg(pQueryInfo->msg, msg1);

}

// need to add timestamp column in result set, if interval is existed

uint64_t uid = tscSqlExprGet(pQueryInfo, 0)->uid;

int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;

for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {

pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);

if (pTableMetaInfo->pTableMeta->uid == uid) {

tableIndex = i;

break;

}

}

if (tableIndex == COLUMN_INDEX_INITIAL_VAL) {

return TSDB_CODE_INVALID_SQL;

}

SColumnIndex index = {tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};

SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, 0, TSDB_FUNC_TS, &index, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, TSDB_KEYSIZE);

SColumnList ids = getColumnList(1, 0, PRIMARYKEY_TIMESTAMP_COL_INDEX);

int32_t ret =

insertResultField(pQueryInfo, 0, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS].aName, pExpr);

if (ret != TSDB_CODE_SUCCESS) {

return ret;

}

if (parseSlidingClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) {

return TSDB_CODE_INVALID_SQL;

}

return TSDB_CODE_SUCCESS;

}

int32_t parseSlidingClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {

const char* msg0 = "sliding value too small";

const char* msg1 = "sliding value no larger than the interval value";

STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

SSQLToken* pSliding = &pQuerySql->sliding;

STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);

if (pSliding->n != 0) {

getTimestampInUsFromStr(pSliding->z, pSliding->n, &pQueryInfo->slidingTime);

if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {

pQueryInfo->slidingTime /= 1000;

}

if (pQueryInfo->slidingTime < tsMinSlidingTime) {

return invalidSqlErrMsg(pQueryInfo->msg, msg0);

}

if (pQueryInfo->slidingTime > pQueryInfo->intervalTime) {

return invalidSqlErrMsg(pQueryInfo->msg, msg1);

}

} else {

pQueryInfo->slidingTime = pQueryInfo->intervalTime;

}

return TSDB_CODE_SUCCESS;

}

int32_t setMeterID(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {

const char* msg = "name too long";

SSqlCmd* pCmd = &pSql->cmd;

int32_t code = TSDB_CODE_SUCCESS;

// backup the old name in pTableMetaInfo

size_t size = strlen(pTableMetaInfo->name);

char* oldName = NULL;

if (size > 0) {

oldName = strdup(pTableMetaInfo->name);

}

if (hasSpecifyDB(pzTableName)) {

// db has been specified in sql string so we ignore current db path

code = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), NULL, pzTableName, NULL);

} else { // get current DB name first, then set it into path

SSQLToken t = {0};

getCurrentDBName(pSql, &t);

code = setObjFullName(pTableMetaInfo->name, NULL, &t, pzTableName, NULL);

}

if (code != TSDB_CODE_SUCCESS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

}

if (code != TSDB_CODE_SUCCESS) {

free(oldName);

return code;

}

/*

if (size > 0) {

if (strncasecmp(oldName, pTableMetaInfo->name, tListLen(pTableMetaInfo->name)) != 0) {

tscClearMeterMetaInfo(pTableMetaInfo, false);

}

} else {

assert(pTableMetaInfo->pTableMeta == NULL);

}

tfree(oldName);

return TSDB_CODE_SUCCESS;

}

static bool validateTableColumnInfo(tFieldList* pFieldList, SSqlCmd* pCmd) {

assert(pFieldList != NULL);

const char* msg = "illegal number of columns";

const char* msg1 = "first column must be timestamp";

const char* msg2 = "row length exceeds max length";

const char* msg3 = "duplicated column names";

const char* msg4 = "invalid data types";

const char* msg5 = "invalid binary/nchar column length";

const char* msg6 = "invalid column name";

// number of fields no less than 2

if (pFieldList->nField <= 1 || pFieldList->nField > TSDB_MAX_COLUMNS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

return false;

}

// first column must be timestamp

if (pFieldList->p[0].type != TSDB_DATA_TYPE_TIMESTAMP) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

return false;

}

int32_t nLen = 0;

for (int32_t i = 0; i < pFieldList->nField; ++i) {

nLen += pFieldList->p[i].bytes;

}

// max row length must be less than TSDB_MAX_BYTES_PER_ROW

if (nLen > TSDB_MAX_BYTES_PER_ROW) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

return false;

}

// field name must be unique

for (int32_t i = 0; i < pFieldList->nField; ++i) {

TAOS_FIELD* pField = &pFieldList->p[i];

if (pField->type < TSDB_DATA_TYPE_BOOL || pField->type > TSDB_DATA_TYPE_NCHAR) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);

return false;

}

if ((pField->type == TSDB_DATA_TYPE_BINARY && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_BINARY_LEN)) ||

(pField->type == TSDB_DATA_TYPE_NCHAR && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_NCHAR_LEN))) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);

return false;

}

if (validateColumnName(pField->name) != TSDB_CODE_SUCCESS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);

return false;

}

if (has(pFieldList, i + 1, pFieldList->p[i].name) == true) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

return false;

}

}

return true;

}

static bool validateTagParams(tFieldList* pTagsList, tFieldList* pFieldList, SSqlCmd* pCmd) {

assert(pTagsList != NULL);

const char* msg1 = "invalid number of tag columns";

const char* msg2 = "tag length too long";

const char* msg3 = "duplicated column names";

const char* msg4 = "timestamp not allowed in tags";

const char* msg5 = "invalid data type in tags";

const char* msg6 = "invalid tag name";

const char* msg7 = "invalid binary/nchar tag length";

// number of fields at least 1

if (pTagsList->nField < 1 || pTagsList->nField > TSDB_MAX_TAGS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

return false;

}

int32_t nLen = 0;

for (int32_t i = 0; i < pTagsList->nField; ++i) {

nLen += pTagsList->p[i].bytes;

}

// max tag row length must be less than TSDB_MAX_TAGS_LEN

if (nLen > TSDB_MAX_TAGS_LEN) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

return false;

}

// field name must be unique

for (int32_t i = 0; i < pTagsList->nField; ++i) {

if (has(pFieldList, 0, pTagsList->p[i].name) == true) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

return false;

}

}

/* timestamp in tag is not allowed */

for (int32_t i = 0; i < pTagsList->nField; ++i) {

if (pTagsList->p[i].type == TSDB_DATA_TYPE_TIMESTAMP) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);

return false;

}

if (pTagsList->p[i].type < TSDB_DATA_TYPE_BOOL || pTagsList->p[i].type > TSDB_DATA_TYPE_NCHAR) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);

return false;

}

if ((pTagsList->p[i].type == TSDB_DATA_TYPE_BINARY && pTagsList->p[i].bytes <= 0) ||

(pTagsList->p[i].type == TSDB_DATA_TYPE_NCHAR && pTagsList->p[i].bytes <= 0)) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);

return false;

}

if (validateColumnName(pTagsList->p[i].name) != TSDB_CODE_SUCCESS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);

return false;

}

if (has(pTagsList, i + 1, pTagsList->p[i].name) == true) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

return false;

}

}

return true;

}

bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {

const char* msg1 = "timestamp not allowed in tags";

const char* msg2 = "duplicated column names";

const char* msg3 = "tag length too long";

const char* msg4 = "invalid tag name";

const char* msg5 = "invalid binary/nchar tag length";

const char* msg6 = "invalid data type in tags";

assert(pCmd->numOfClause == 1);

STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);

STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;

int32_t numOfTags = tscGetNumOfTags(pTableMeta);

int32_t numOfCols = tscGetNumOfColumns(pTableMeta);

// no more than 6 tags

if (numOfTags == TSDB_MAX_TAGS) {

char msg[128] = {0};

sprintf(msg, "tags no more than %d", TSDB_MAX_TAGS);

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);

return false;

}

// no timestamp allowable

if (pTagField->type == TSDB_DATA_TYPE_TIMESTAMP) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

return false;

}

if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_NCHAR)) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);

return false;

}

SSchema* pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);

int32_t nLen = 0;

for (int32_t i = 0; i < numOfTags; ++i) {

nLen += pTagSchema[i].bytes;

}

// length less than TSDB_MAX_TASG_LEN

if (nLen + pTagField->bytes > TSDB_MAX_TAGS_LEN) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);

return false;

}

// tags name can not be a keyword

if (validateColumnName(pTagField->name) != TSDB_CODE_SUCCESS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);

return false;

}

// binary(val), val can not be equalled to or less than 0

if ((pTagField->type == TSDB_DATA_TYPE_BINARY || pTagField->type == TSDB_DATA_TYPE_NCHAR) && pTagField->bytes <= 0) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);

return false;

}

// field name must be unique

SSchema* pSchema = tscGetTableSchema(pTableMeta);

for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {

if (strncasecmp(pTagField->name, pSchema[i].name, TSDB_COL_NAME_LEN) == 0) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);

return false;

}

}

return true;

}

bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {

const char* msg1 = "too many columns";

const char* msg2 = "duplicated column names";

const char* msg3 = "column length too long";

const char* msg4 = "invalid data types";

const char* msg5 = "invalid column name";

const char* msg6 = "invalid column length";

assert(pCmd->numOfClause == 1);

STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);

STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;

int32_t numOfTags = tscGetNumOfTags(pTableMeta);

int32_t numOfCols = tscGetNumOfColumns(pTableMeta);

// no more max columns

if (numOfCols >= TSDB_MAX_COLUMNS || numOfTags + numOfCols >= TSDB_MAX_COLUMNS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);

return false;

}

if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_NCHAR) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);

return false;

}

if (validateColumnName(pColField->name) != TSDB_CODE_SUCCESS) {

invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);

return false;

}

SSchema* pSchema = tscGetTableSchema(pTableMeta);

int32_t nLen = 0;