Skip to content

TDengine
TDengine

taosdata / TDengine
大约 2 年 前同步成功

通知 1192
Star 22018
Fork 4786
TDengine
TDengine
提交 29f40db1 编写于 作者: S Shengliang Guan
浏览文件
操作

Merge remote-tracking branch 'origin/3.0' into feature/dnode3

上级 97f7018f ea3f05f6
隐藏空白更改
内联 并排
Showing with 502 addition and 547 deletion
include/libs/parser/parser.h
浏览文件 @ 29f40db1
...@@ -27,7 +27,7 @@ typedef struct SParseContext { ...@@ -27,7 +27,7 @@ typedef struct SParseContext {
int8_t schemaAttached; // denote if submit block is built with table schema or not int8_t schemaAttached; // denote if submit block is built with table schema or not
const char *pSql; // sql string const char *pSql; // sql string
size_t sqlLen; // length of the sql string size_t sqlLen; // length of the sql string
char *pMsg; // extended error message if exists to help avoid the problem in sql statement. char *pMsg; // extended error message if exists to help identifying the problem in sql statement.
int32_t msgLen; // max length of the msg int32_t msgLen; // max length of the msg
} SParseContext; } SParseContext;
......
source/client/src/clientImpl.c
浏览文件 @ 29f40db1
...@@ -181,43 +181,13 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) { ...@@ -181,43 +181,13 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
pRequest->body.requestMsg = (SDataBuf){.pData = pDcl->pMsg, .len = pDcl->msgLen}; pRequest->body.requestMsg = (SDataBuf){.pData = pDcl->pMsg, .len = pDcl->msgLen};
STscObj* pTscObj = pRequest->pTscObj; STscObj* pTscObj = pRequest->pTscObj;
SMsgSendInfo* pSendMsg = buildSendMsgInfoImpl(pRequest); SMsgSendInfo* pSendMsg = buildSendMsgInfoImpl(pRequest);
SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
int64_t transporterId = 0;
if (pDcl->msgType == TDMT_VND_CREATE_TABLE) { if (pDcl->msgType == TDMT_VND_CREATE_TABLE) {
// struct SCatalog* pCatalog = NULL;
//
// char buf[18] = {0};
// sprintf(buf, "%" PRId64, pRequest->pTscObj->pAppInfo->clusterId);
// int32_t code = catalogGetHandle(buf, &pCatalog);
// if (code != TSDB_CODE_SUCCESS) {
// return code;
// }
//
// SCreateTableMsg* pMsg = pSendMsg->msgInfo.pData;
//
// SName t = {0};
// tNameFromString(&t, pMsg->name, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
//
// char db[TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_ACCT_ID_LEN] = {0};
// tNameGetFullDbName(&t, db);
//
// SVgroupInfo info = {0};
// catalogGetTableHashVgroup(pCatalog, pRequest->pTscObj->pTransporter, pEpSet, db, tNameGetTableName(&t), &info);
//
int64_t transporterId = 0;
// SEpSet ep = {0};
// ep.inUse = info.inUse;
// ep.numOfEps = info.numOfEps;
// for(int32_t i = 0; i < ep.numOfEps; ++i) {
// ep.port[i] = info.epAddr[i].port;
// tstrncpy(ep.fqdn[i], info.epAddr[i].fqdn, tListLen(ep.fqdn[i]));
// }
asyncSendMsgToServer(pTscObj->pTransporter, &pDcl->epSet, &transporterId, pSendMsg); asyncSendMsgToServer(pTscObj->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
} else { } else {
int64_t transporterId = 0; SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
asyncSendMsgToServer(pTscObj->pTransporter, pEpSet, &transporterId, pSendMsg); asyncSendMsgToServer(pTscObj->pTransporter, pEpSet, &transporterId, pSendMsg);
} }
......
source/client/test/clientTests.cpp
浏览文件 @ 29f40db1
...@@ -433,7 +433,6 @@ TEST(testCase, create_topic_Test) { ...@@ -433,7 +433,6 @@ TEST(testCase, create_topic_Test) {
taos_close(pConn); taos_close(pConn);
} }
//TEST(testCase, show_table_Test) { //TEST(testCase, show_table_Test) {
// TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0); // TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
// assert(pConn != NULL); // assert(pConn != NULL);
......
source/libs/parser/inc/parserUtil.h
浏览文件 @ 29f40db1
...@@ -62,7 +62,7 @@ void cleanupTagCond(STagCond* pTagCond); ...@@ -62,7 +62,7 @@ void cleanupTagCond(STagCond* pTagCond);
void cleanupColumnCond(SArray** pCond); void cleanupColumnCond(SArray** pCond);
uint32_t convertRelationalOperator(SToken *pToken); uint32_t convertRelationalOperator(SToken *pToken);
int32_t getExprFunctionId(SExprInfo *pExprInfo); int32_t getExprFunctionId(SExprInfo *pExprInfo);
STableMeta* tableMetaDup(const STableMeta* pTableMeta); STableMeta* tableMetaDup(const STableMeta* pTableMeta);
...@@ -70,6 +70,17 @@ bool isDclSqlStatement(SSqlInfo* pSqlInfo); ...@@ -70,6 +70,17 @@ bool isDclSqlStatement(SSqlInfo* pSqlInfo);
bool isDdlSqlStatement(SSqlInfo* pSqlInfo); bool isDdlSqlStatement(SSqlInfo* pSqlInfo);
bool isDqlSqlStatement(SSqlInfo* pSqlInfo); bool isDqlSqlStatement(SSqlInfo* pSqlInfo);
typedef struct SKvParam {
SKVRowBuilder *builder;
SSchema *schema;
char buf[TSDB_MAX_TAGS_LEN];
} SKvParam;
int32_t KvRowAppend(const void *value, int32_t len, void *param);
typedef int32_t (*_row_append_fn_t)(const void *value, int32_t len, void *param);
int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
......
source/libs/parser/src/dCDAstProcess.c
浏览文件 @ 29f40db1
...@@ -429,7 +429,6 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p ...@@ -429,7 +429,6 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
SSchema *pSchema = &pTagSchema[i]; SSchema *pSchema = &pTagSchema[i];
SToken* pItem = taosArrayGet(pValList, i); SToken* pItem = taosArrayGet(pValList, i);
char tagVal[TSDB_MAX_TAGS_LEN];
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) { if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
if (pItem->n > pSchema->bytes) { if (pItem->n > pSchema->bytes) {
tdDestroyKVRowBuilder(&kvRowBuilder); tdDestroyKVRowBuilder(&kvRowBuilder);
...@@ -446,26 +445,16 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p ...@@ -446,26 +445,16 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
// } // }
} }
char* endPtr = NULL; char tmpTokenBuf[TSDB_MAX_TAGS_LEN] = {0};
int64_t v = strtoll(pItem->z, &endPtr, 10); SKvParam param = {.builder = &kvRowBuilder, .schema = pSchema};
*(int32_t*) tagVal = v;
// code = taosVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
// check again after the convert since it may be converted from binary to nchar. char* endPtr = NULL;
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) { code = parseValueToken(&endPtr, pItem, pSchema, tinfo.precision, tmpTokenBuf, KvRowAppend, &param, pMsgBuf);
int16_t len = varDataTLen(tagVal);
if (len > pSchema->bytes) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return buildInvalidOperationMsg(pMsgBuf, msg3);
}
}
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
tdDestroyKVRowBuilder(&kvRowBuilder); tdDestroyKVRowBuilder(&kvRowBuilder);
return buildInvalidOperationMsg(pMsgBuf, msg4); return buildInvalidOperationMsg(pMsgBuf, msg4);
} }
tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
} }
} }
......
source/libs/parser/src/insertParser.c
浏览文件 @ 29f40db1
...@@ -51,8 +51,8 @@ enum { ...@@ -51,8 +51,8 @@ enum {
typedef struct SInsertParseContext { typedef struct SInsertParseContext {
SParseContext* pComCxt; // input SParseContext* pComCxt; // input
const char* pSql; // input char *pSql; // input
SMsgBuf msg; // input SMsgBuf msg; // input
STableMeta* pTableMeta; // each table STableMeta* pTableMeta; // each table
SParsedDataColInfo tags; // each table SParsedDataColInfo tags; // each table
SKVRowBuilder tagsBuilder; // each table SKVRowBuilder tagsBuilder; // each table
...@@ -64,22 +64,6 @@ typedef struct SInsertParseContext { ...@@ -64,22 +64,6 @@ typedef struct SInsertParseContext {
SInsertStmtInfo* pOutput; SInsertStmtInfo* pOutput;
} SInsertParseContext; } SInsertParseContext;
typedef int32_t (*FRowAppend)(const void *value, int32_t len, void *param);
typedef struct SKvParam {
char buf[TSDB_MAX_TAGS_LEN];
SKVRowBuilder* builder;
SSchema* schema;
} SKvParam;
static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE;
static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE;
static bool isNullStr(SToken *pToken) {
return (pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
(strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0));
}
static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPtr) { static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPtr) {
errno = 0; errno = 0;
*value = strtold(pToken->z, endPtr); *value = strtold(pToken->z, endPtr);
...@@ -263,23 +247,21 @@ static int32_t checkTimestamp(STableDataBlocks *pDataBlocks, const char *start) ...@@ -263,23 +247,21 @@ static int32_t checkTimestamp(STableDataBlocks *pDataBlocks, const char *start)
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec, int64_t *time) { static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time, SMsgBuf* pMsgBuf) {
int32_t index = 0; int32_t index = 0;
SToken sToken; SToken sToken;
int64_t interval; int64_t interval;
int64_t useconds = 0; int64_t ts = 0;
const char* pTokenEnd = pCxt->pSql; char* pTokenEnd = *end;
if (pToken->type == TK_NOW) { if (pToken->type == TK_NOW) {
useconds = taosGetTimestamp(timePrec); ts = taosGetTimestamp(timePrec);
} else if (strncmp(pToken->z, "0", 1) == 0 && pToken->n == 1) {
// do nothing
} else if (pToken->type == TK_INTEGER) { } else if (pToken->type == TK_INTEGER) {
useconds = taosStr2int64(pToken->z); bool isSigned = false;
} else { toInteger(pToken->z, pToken->n, 10, &ts, &isSigned);
// strptime("2001-11-12 18:31:01", "%Y-%m-%d %H:%M:%S", &tm); } else { // parse the RFC-3339/ISO-8601 timestamp format string
if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) { if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {
return buildSyntaxErrMsg(&pCxt->msg, "invalid timestamp format", pToken->z); return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z);
} }
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
...@@ -288,8 +270,8 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec ...@@ -288,8 +270,8 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
for (int k = pToken->n; pToken->z[k] != '\0'; k++) { for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue; if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
if (pToken->z[k] == ',') { if (pToken->z[k] == ',') {
pCxt->pSql = pTokenEnd; *end = pTokenEnd;
*time = useconds; *time = ts;
return 0; return 0;
} }
...@@ -311,7 +293,7 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec ...@@ -311,7 +293,7 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
pTokenEnd += index; pTokenEnd += index;
if (valueToken.n < 2) { if (valueToken.n < 2) {
return buildSyntaxErrMsg(&pCxt->msg, "value expected in timestamp", sToken.z); return buildSyntaxErrMsg(pMsgBuf, "value expected in timestamp", sToken.z);
} }
char unit = 0; char unit = 0;
...@@ -320,34 +302,15 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec ...@@ -320,34 +302,15 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
} }
if (sToken.type == TK_PLUS) { if (sToken.type == TK_PLUS) {
useconds += interval; ts += interval;
} else { } else {
useconds = useconds - interval; ts = ts - interval;
} }
pCxt->pSql = pTokenEnd; *end = pTokenEnd;
} }
*time = useconds; *time = ts;
return TSDB_CODE_SUCCESS;
}
static FORCE_INLINE int32_t KvRowAppend(const void *value, int32_t len, void *param) {
SKvParam* pa = (SKvParam*)param;
if (TSDB_DATA_TYPE_BINARY == pa->schema->type) {
STR_WITH_SIZE_TO_VARSTR(pa->buf, value, len);
tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, pa->buf);
} else if (TSDB_DATA_TYPE_NCHAR == pa->schema->type) {
// if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
int32_t output = 0;
if (!taosMbsToUcs4(value, len, varDataVal(pa->buf), pa->schema->bytes - VARSTR_HEADER_SIZE, &output)) {
return TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
}
varDataSetLen(pa->buf, output);
tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, pa->buf);
} else {
tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, value);
}
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
...@@ -381,193 +344,206 @@ static FORCE_INLINE int32_t MemRowAppend(const void *value, int32_t len, void *p ...@@ -381,193 +344,206 @@ static FORCE_INLINE int32_t MemRowAppend(const void *value, int32_t len, void *p
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static FORCE_INLINE int32_t checkAndTrimValue(SInsertParseContext* pCxt, SToken* pToken, SSchema* pSchema, char* tmpTokenBuf) { //static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
int16_t type = pToken->type; // if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL && // type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) ||
type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) || // (pToken->n == 0) || (type == TK_RP)) {
(pToken->n == 0) || (type == TK_RP)) { // return buildSyntaxErrMsg(pMsgBuf, "invalid data or symbol", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "invalid data or symbol", pToken->z); // }
} //
// if (IS_NUMERIC_TYPE(type) && pToken->n == 0) {
if (IS_NUMERIC_TYPE(pSchema->type) && pToken->n == 0) { // return buildSyntaxErrMsg(pMsgBuf, "invalid numeric data", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "invalid numeric data", pToken->z); // }
} //
// // Remove quotation marks
// Remove quotation marks // if (TK_STRING == type) {
if (TK_STRING == type) { // if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) {
if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) { // return buildSyntaxErrMsg(pMsgBuf, "too long string", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "too long string", pToken->z); // }
} //
// delete escape character: \\, \', \" // // delete escape character: \\, \', \"
char delim = pToken->z[0]; // char delim = pToken->z[0];
int32_t cnt = 0; // int32_t cnt = 0;
int32_t j = 0; // int32_t j = 0;
for (uint32_t k = 1; k < pToken->n - 1; ++k) { // for (uint32_t k = 1; k < pToken->n - 1; ++k) {
if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) { // if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) {
tmpTokenBuf[j] = pToken->z[k + 1]; // tmpTokenBuf[j] = pToken->z[k + 1];
cnt++; // cnt++;
j++; // j++;
k++; // k++;
continue; // continue;
} // }
tmpTokenBuf[j] = pToken->z[k]; // tmpTokenBuf[j] = pToken->z[k];
j++; // j++;
} // }
tmpTokenBuf[j] = 0; //
pToken->z = tmpTokenBuf; // tmpTokenBuf[j] = 0;
pToken->n -= 2 + cnt; // pToken->z = tmpTokenBuf;
} // pToken->n -= 2 + cnt;
// }
return TSDB_CODE_SUCCESS; //
} // return TSDB_CODE_SUCCESS;
//}
static FORCE_INLINE int32_t parseOneValue(SInsertParseContext* pCxt, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, FRowAppend func, void* param) {
int64_t iv; //static FORCE_INLINE int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf) {
int32_t ret; // int64_t iv;
char * endptr = NULL; // char *endptr = NULL;
// bool isSigned = false;
CHECK_CODE(checkAndTrimValue(pCxt, pToken, pSchema, tmpTokenBuf)); //
// CHECK_CODE(checkAndTrimValue(pToken, pSchema->type, tmpTokenBuf, pMsgBuf));
if (isNullStr(pToken)) { //
if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) { // if (isNullStr(pToken)) {
int64_t tmpVal = 0; // if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
return func(&tmpVal, pSchema->bytes, param); // int64_t tmpVal = 0;
} // return func(&tmpVal, pSchema->bytes, param);
return func(getNullValue(pSchema->type), 0, param); // }
} //
// return func(getNullValue(pSchema->type), 0, param);
switch (pSchema->type) { // }
case TSDB_DATA_TYPE_BOOL: { //
if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) { // switch (pSchema->type) {
if (strncmp(pToken->z, "true", pToken->n) == 0) { // case TSDB_DATA_TYPE_BOOL: {
return func(&TRUE_VALUE, pSchema->bytes, param); // if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
} else if (strncmp(pToken->z, "false", pToken->n) == 0) { // if (strncmp(pToken->z, "true", pToken->n) == 0) {
return func(&FALSE_VALUE, pSchema->bytes, param); // return func(&TRUE_VALUE, pSchema->bytes, param);
} else { // } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
return buildSyntaxErrMsg(&pCxt->msg, "invalid bool data", pToken->z); // return func(&FALSE_VALUE, pSchema->bytes, param);
} // } else {
} else if (pToken->type == TK_INTEGER) { // return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param); // }
} else if (pToken->type == TK_FLOAT) { // } else if (pToken->type == TK_INTEGER) {
return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param); // return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
} else { // } else if (pToken->type == TK_FLOAT) {
return buildSyntaxErrMsg(&pCxt->msg, "invalid bool data", pToken->z); // return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
} // } else {
break; // return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
} // }
case TSDB_DATA_TYPE_TINYINT: { // }
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) { //
return buildSyntaxErrMsg(&pCxt->msg, "invalid tinyint data", pToken->z); // case TSDB_DATA_TYPE_TINYINT: {
} else if (!IS_VALID_TINYINT(iv)) { // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return buildSyntaxErrMsg(&pCxt->msg, "data overflow", pToken->z); // return buildSyntaxErrMsg(pMsgBuf, "invalid tinyint data", pToken->z);
} // } else if (!IS_VALID_TINYINT(iv)) {
uint8_t tmpVal = (uint8_t)iv; // return buildSyntaxErrMsg(pMsgBuf, "tinyint data overflow", pToken->z);
return func(&tmpVal, pSchema->bytes, param); // }
} //
case TSDB_DATA_TYPE_UTINYINT:{ // uint8_t tmpVal = (uint8_t)iv;
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) { // return func(&tmpVal, pSchema->bytes, param);
return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned tinyint data", pToken->z); // }
} else if (!IS_VALID_UTINYINT(iv)) { //
return buildSyntaxErrMsg(&pCxt->msg, "unsigned tinyint data overflow", pToken->z); // case TSDB_DATA_TYPE_UTINYINT:{
} // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
uint8_t tmpVal = (uint8_t)iv; // return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned tinyint data", pToken->z);
return func(&tmpVal, pSchema->bytes, param); // } else if (!IS_VALID_UTINYINT(iv)) {
} // return buildSyntaxErrMsg(pMsgBuf, "unsigned tinyint data overflow", pToken->z);
case TSDB_DATA_TYPE_SMALLINT: { // }
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) { // uint8_t tmpVal = (uint8_t)iv;
return buildSyntaxErrMsg(&pCxt->msg, "invalid smallint data", pToken->z); // return func(&tmpVal, pSchema->bytes, param);
} else if (!IS_VALID_SMALLINT(iv)) { // }
return buildSyntaxErrMsg(&pCxt->msg, "smallint data overflow", pToken->z); //
} // case TSDB_DATA_TYPE_SMALLINT: {
int16_t tmpVal = (int16_t)iv; // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return func(&tmpVal, pSchema->bytes, param); // return buildSyntaxErrMsg(pMsgBuf, "invalid smallint data", pToken->z);
} // } else if (!IS_VALID_SMALLINT(iv)) {
case TSDB_DATA_TYPE_USMALLINT: { // return buildSyntaxErrMsg(pMsgBuf, "smallint data overflow", pToken->z);
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) { // }
return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned smallint data", pToken->z); // int16_t tmpVal = (int16_t)iv;
} else if (!IS_VALID_USMALLINT(iv)) { // return func(&tmpVal, pSchema->bytes, param);
return buildSyntaxErrMsg(&pCxt->msg, "unsigned smallint data overflow", pToken->z); // }
} //
uint16_t tmpVal = (uint16_t)iv; // case TSDB_DATA_TYPE_USMALLINT: {
return func(&tmpVal, pSchema->bytes, param); // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
} // return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned smallint data", pToken->z);
case TSDB_DATA_TYPE_INT: { // } else if (!IS_VALID_USMALLINT(iv)) {
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) { // return buildSyntaxErrMsg(pMsgBuf, "unsigned smallint data overflow", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "invalid int data", pToken->z); // }
} else if (!IS_VALID_INT(iv)) { // uint16_t tmpVal = (uint16_t)iv;
return buildSyntaxErrMsg(&pCxt->msg, "int data overflow", pToken->z); // return func(&tmpVal, pSchema->bytes, param);
} // }
int32_t tmpVal = (int32_t)iv; //
return func(&tmpVal, pSchema->bytes, param); // case TSDB_DATA_TYPE_INT: {
} // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
case TSDB_DATA_TYPE_UINT: { // return buildSyntaxErrMsg(pMsgBuf, "invalid int data", pToken->z);
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) { // } else if (!IS_VALID_INT(iv)) {
return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned int data", pToken->z); // return buildSyntaxErrMsg(pMsgBuf, "int data overflow", pToken->z);
} else if (!IS_VALID_UINT(iv)) { // }
return buildSyntaxErrMsg(&pCxt->msg, "unsigned int data overflow", pToken->z); // int32_t tmpVal = (int32_t)iv;
} // return func(&tmpVal, pSchema->bytes, param);
uint32_t tmpVal = (uint32_t)iv; // }
return func(&tmpVal, pSchema->bytes, param); //
} // case TSDB_DATA_TYPE_UINT: {
case TSDB_DATA_TYPE_BIGINT: { // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) { // return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned int data", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "invalid bigint data", pToken->z); // } else if (!IS_VALID_UINT(iv)) {
} else if (!IS_VALID_BIGINT(iv)) { // return buildSyntaxErrMsg(pMsgBuf, "unsigned int data overflow", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "bigint data overflow", pToken->z); // }
} // uint32_t tmpVal = (uint32_t)iv;
return func(&iv, pSchema->bytes, param); // return func(&tmpVal, pSchema->bytes, param);
} // }
case TSDB_DATA_TYPE_UBIGINT: { //
if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) { // case TSDB_DATA_TYPE_BIGINT: {
return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned bigint data", pToken->z); // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
} else if (!IS_VALID_UBIGINT((uint64_t)iv)) { // return buildSyntaxErrMsg(pMsgBuf, "invalid bigint data", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "unsigned bigint data overflow", pToken->z); // } else if (!IS_VALID_BIGINT(iv)) {
} // return buildSyntaxErrMsg(pMsgBuf, "bigint data overflow", pToken->z);
uint64_t tmpVal = (uint64_t)iv; // }
return func(&tmpVal, pSchema->bytes, param); // return func(&iv, pSchema->bytes, param);
} // }
case TSDB_DATA_TYPE_FLOAT: { //
double dv; // case TSDB_DATA_TYPE_UBIGINT: {
if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) { // if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z); // return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned bigint data", pToken->z);
} // } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) { // return buildSyntaxErrMsg(pMsgBuf, "unsigned bigint data overflow", pToken->z);
return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z); // }
} // uint64_t tmpVal = (uint64_t)iv;
float tmpVal = (float)dv; // return func(&tmpVal, pSchema->bytes, param);
return func(&tmpVal, pSchema->bytes, param); // }
} //
case TSDB_DATA_TYPE_DOUBLE: { // case TSDB_DATA_TYPE_FLOAT: {
double dv; // double dv;
if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) { // if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
return buildSyntaxErrMsg(&pCxt->msg, "illegal double data", pToken->z); // return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
} // }
if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) { // if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) {
return buildSyntaxErrMsg(&pCxt->msg, "illegal double data", pToken->z); // return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
} // }
return func(&dv, pSchema->bytes, param); // float tmpVal = (float)dv;
} // return func(&tmpVal, pSchema->bytes, param);
case TSDB_DATA_TYPE_BINARY: { // }
// too long values will return invalid sql, not be truncated automatically //
if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) { // case TSDB_DATA_TYPE_DOUBLE: {
return buildSyntaxErrMsg(&pCxt->msg, "string data overflow", pToken->z); // double dv;
} // if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
return func(pToken->z, pToken->n, param); // return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
} // }
case TSDB_DATA_TYPE_NCHAR: { // if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) {
return func(pToken->z, pToken->n, param); // return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
} // }
case TSDB_DATA_TYPE_TIMESTAMP: { // return func(&dv, pSchema->bytes, param);
int64_t tmpVal; // }
if (parseTime(pCxt, pToken, timePrec, &tmpVal) != TSDB_CODE_SUCCESS) { //
return buildSyntaxErrMsg(&pCxt->msg, "invalid timestamp", pToken->z); // case TSDB_DATA_TYPE_BINARY: {
} // // too long values will return invalid sql, not be truncated automatically
return func(&tmpVal, pSchema->bytes, param); // if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
} // return buildSyntaxErrMsg(pMsgBuf, "string data overflow", pToken->z);
} // }
// return func(pToken->z, pToken->n, param);
return TSDB_CODE_FAILED; // }
} // case TSDB_DATA_TYPE_NCHAR: {
// return func(pToken->z, pToken->n, param);
// }
// case TSDB_DATA_TYPE_TIMESTAMP: {
// int64_t tmpVal;
// if (parseTime(end, pToken, timePrec, &tmpVal, pMsgBuf) != TSDB_CODE_SUCCESS) {
// return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp", pToken->z);
// }
// return func(&tmpVal, pSchema->bytes, param);
// }
// }
//
// return TSDB_CODE_FAILED;
//}
// pSql -> tag1_name, ...) // pSql -> tag1_name, ...)
static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo* pColList, SSchema* pSchema) { static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo* pColList, SSchema* pSchema) {
...@@ -644,7 +620,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pTagsSchema, ...@@ -644,7 +620,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pTagsSchema,
NEXT_TOKEN(pCxt->pSql, sToken); NEXT_TOKEN(pCxt->pSql, sToken);
SSchema* pSchema = &pTagsSchema[pCxt->tags.boundedColumns[i]]; SSchema* pSchema = &pTagsSchema[pCxt->tags.boundedColumns[i]];
param.schema = pSchema; param.schema = pSchema;
CHECK_CODE(parseOneValue(pCxt, &sToken, pSchema, precision, tmpTokenBuf, KvRowAppend, &param)); CHECK_CODE(parseValueToken(&pCxt->pSql, &sToken, pSchema, precision, tmpTokenBuf, KvRowAppend, &param, &pCxt->msg));
} }
SKVRow row = tdGetKVRowFromBuilder(&pCxt->tagsBuilder); SKVRow row = tdGetKVRowFromBuilder(&pCxt->tagsBuilder);
...@@ -709,7 +685,7 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks, ...@@ -709,7 +685,7 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
param.schema = pSchema; param.schema = pSchema;
param.compareStat = pBuilder->compareStat; param.compareStat = pBuilder->compareStat;
getMemRowAppendInfo(schema, pBuilder->memRowType, spd, i, &param.toffset); getMemRowAppendInfo(schema, pBuilder->memRowType, spd, i, &param.toffset);
CHECK_CODE(parseOneValue(pCxt, &sToken, pSchema, timePrec, tmpTokenBuf, MemRowAppend, &param)); CHECK_CODE(parseValueToken(&pCxt->pSql, &sToken, pSchema, timePrec, tmpTokenBuf, MemRowAppend, &param, &pCxt->msg));
if (PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) { if (PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
TSKEY tsKey = memRowKey(row); TSKEY tsKey = memRowKey(row);
...@@ -894,7 +870,7 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) { ...@@ -894,7 +870,7 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) { int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) {
SInsertParseContext context = { SInsertParseContext context = {
.pComCxt = pContext, .pComCxt = pContext,
.pSql = pContext->pSql, .pSql = (char*) pContext->pSql,
.msg = {.buf = pContext->pMsg, .len = pContext->msgLen}, .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
.pTableMeta = NULL, .pTableMeta = NULL,
.pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false), .pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false),
......
source/libs/parser/src/parserUtil.c
浏览文件 @ 29f40db1
...@@ -13,19 +13,20 @@ ...@@ -13,19 +13,20 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "parserUtil.h"
#include "tmsg.h" #include <tglobal.h>
#include <ttime.h>
#include "function.h"
#include "parser.h" #include "parser.h"
#include "parserInt.h"
#include "queryInfoUtil.h"
#include "taoserror.h" #include "taoserror.h"
#include "tutil.h"
#include "ttypes.h"
#include "thash.h"
#include "tbuffer.h" #include "tbuffer.h"
#include "parserInt.h" #include "thash.h"
#include "parserUtil.h" #include "tmsg.h"
#include "tmsgtype.h" #include "tmsgtype.h"
#include "queryInfoUtil.h" #include "ttypes.h"
#include "function.h" #include "tutil.h"
typedef struct STableFilterCond { typedef struct STableFilterCond {
uint64_t uid; uint64_t uid;
...@@ -1627,313 +1628,322 @@ bool isDqlSqlStatement(SSqlInfo* pSqlInfo) { ...@@ -1627,313 +1628,322 @@ bool isDqlSqlStatement(SSqlInfo* pSqlInfo) {
return pSqlInfo->type == TSDB_SQL_SELECT; return pSqlInfo->type == TSDB_SQL_SELECT;
} }
#if 0 static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE;
int32_t tscCreateQueryFromQueryInfo(SQueryStmtInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr) { static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE;
memset(pQueryAttr, 0, sizeof(SQueryAttr));
int16_t numOfCols = (int16_t) taosArrayGetSize(pQueryInfo->colList);
int16_t numOfOutput = (int16_t) getNumOfExprs(pQueryInfo);
pQueryAttr->topBotQuery = tscIsTopBotQuery(pQueryInfo);
pQueryAttr->hasTagResults = hasTagValOutput(pQueryInfo);
pQueryAttr->stabledev = isStabledev(pQueryInfo);
pQueryAttr->tsCompQuery = isTsCompQuery(pQueryInfo);
pQueryAttr->diffQuery = tscIsDiffDerivQuery(pQueryInfo);
pQueryAttr->simpleAgg = isSimpleAggregateRv(pQueryInfo);
pQueryAttr->needReverseScan = tscNeedReverseScan(pQueryInfo);
pQueryAttr->stableQuery = QUERY_IS_STABLE_QUERY(pQueryInfo->type);
pQueryAttr->groupbyColumn = (!pQueryInfo->stateWindow) && tscGroupbyColumn(pQueryInfo);
pQueryAttr->queryBlockDist = isBlockDistQuery(pQueryInfo);
pQueryAttr->pointInterpQuery = tscIsPointInterpQuery(pQueryInfo);
pQueryAttr->timeWindowInterpo = timeWindowInterpoRequired(pQueryInfo);
pQueryAttr->distinct = pQueryInfo->distinct;
pQueryAttr->sw = pQueryInfo->sessionWindow;
pQueryAttr->stateWindow = pQueryInfo->stateWindow;
pQueryAttr->multigroupResult = pQueryInfo->multigroupResult;
pQueryAttr->numOfCols = numOfCols;
pQueryAttr->numOfOutput = numOfOutput;
pQueryAttr->limit = pQueryInfo->limit;
pQueryAttr->slimit = pQueryInfo->slimit;
pQueryAttr->order = pQueryInfo->order;
pQueryAttr->fillType = pQueryInfo->fillType;
pQueryAttr->havingNum = pQueryInfo->havingFieldNum;
pQueryAttr->pUdfInfo = pQueryInfo->pUdfInfo;
if (pQueryInfo->order.order == TSDB_ORDER_ASC) { // TODO refactor
pQueryAttr->window = pQueryInfo->window;
} else {
pQueryAttr->window.skey = pQueryInfo->window.ekey;
pQueryAttr->window.ekey = pQueryInfo->window.skey;
}
memcpy(&pQueryAttr->interval, &pQueryInfo->interval, sizeof(pQueryAttr->interval));
STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0]; static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPtr) {
errno = 0;
*value = strtold(pToken->z, endPtr);
if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) { // not a valid integer number, return error
pQueryAttr->pGroupbyExpr = calloc(1, sizeof(SGroupbyExpr)); if ((*endPtr - pToken->z) != pToken->n) {
*(pQueryAttr->pGroupbyExpr) = pQueryInfo->groupbyExpr; return TK_ILLEGAL;
pQueryAttr->pGroupbyExpr->columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
} else {
assert(pQueryInfo->groupbyExpr.columnInfo == NULL);
} }
pQueryAttr->pExpr1 = calloc(pQueryAttr->numOfOutput, sizeof(SExprInfo)); return pToken->type;
for(int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { }
SExprInfo* pExpr = getExprInfo(pQueryInfo, i);
ExprInfoCopy(&pQueryAttr->pExpr1[i], pExpr);
if (pQueryAttr->pExpr1[i].base.functionId == FUNCTION_ARITHM) {
for (int32_t j = 0; j < pQueryAttr->pExpr1[i].base.numOfParams; ++j) {
buildArithmeticExprFromMsg(&pQueryAttr->pExpr1[i], NULL);
}
}
}
pQueryAttr->tableCols = calloc(numOfCols, sizeof(SColumnInfo)); static bool isNullStr(SToken *pToken) {
for(int32_t i = 0; i < numOfCols; ++i) { return (pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
SColumn* pCol = taosArrayGetP(pQueryInfo->colList, i); (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0));
if (!isValidDataType(pCol->info.type) || pCol->info.type == TSDB_DATA_TYPE_NULL) { }
assert(0);
}
pQueryAttr->tableCols[i] = pCol->info; static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
pQueryAttr->tableCols[i].flist.filterInfo = tFilterInfoDup(pCol->info.flist.filterInfo, pQueryAttr->tableCols[i].flist.numOfFilters); if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) ||
(pToken->n == 0) || (type == TK_RP)) {
return buildSyntaxErrMsg(pMsgBuf, "invalid data or symbol", pToken->z);
} }
// global aggregate query if (IS_NUMERIC_TYPE(type) && pToken->n == 0) {
if (pQueryAttr->stableQuery && (pQueryAttr->simpleAgg || pQueryAttr->interval.interval > 0) && tscIsTwoStageSTableQuery(pQueryInfo, 0)) { return buildSyntaxErrMsg(pMsgBuf, "invalid numeric data", pToken->z);
createGlobalAggregateExpr(pQueryAttr, pQueryInfo);
} }
// for simple table, not for super table // Remove quotation marks
if (pQueryInfo->arithmeticOnAgg) { if (TK_STRING == type) {
pQueryAttr->numOfExpr2 = (int32_t) taosArrayGetSize(pQueryInfo->exprList1); if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) {
pQueryAttr->pExpr2 = calloc(pQueryAttr->numOfExpr2, sizeof(SExprInfo)); return buildSyntaxErrMsg(pMsgBuf, "too long string", pToken->z);
for(int32_t i = 0; i < pQueryAttr->numOfExpr2; ++i) {
SExprInfo* p = taosArrayGetP(pQueryInfo->exprList1, i);
ExprInfoCopy(&pQueryAttr->pExpr2[i], p);
} }
}
// tag column info // delete escape character: \\, \', \"
int32_t code = createTagColumnInfo(pQueryAttr, pQueryInfo, pTableMetaInfo); char delim = pToken->z[0];
if (code != TSDB_CODE_SUCCESS) { int32_t cnt = 0;
return code; int32_t j = 0;
} for (uint32_t k = 1; k < pToken->n - 1; ++k) {
if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) {
if (pQueryAttr->fillType != TSDB_FILL_NONE) { tmpTokenBuf[j] = pToken->z[k + 1];
pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t)); cnt++;
memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t)); j++;
} k++;
continue;
pQueryAttr->srcRowSize = 0; }
pQueryAttr->maxTableColumnWidth = 0; tmpTokenBuf[j] = pToken->z[k];
for (int16_t i = 0; i < numOfCols; ++i) { j++;
pQueryAttr->srcRowSize += pQueryAttr->tableCols[i].bytes;
if (pQueryAttr->maxTableColumnWidth < pQueryAttr->tableCols[i].bytes) {
pQueryAttr->maxTableColumnWidth = pQueryAttr->tableCols[i].bytes;
} }
tmpTokenBuf[j] = 0;
pToken->z = tmpTokenBuf;
pToken->n -= 2 + cnt;
} }
pQueryAttr->interBufSize = getOutputInterResultBufSize(pQueryAttr); return TSDB_CODE_SUCCESS;
}
if (pQueryAttr->numOfCols <= 0 && !tscQueryTags(pQueryInfo) && !pQueryAttr->queryBlockDist) { static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time, SMsgBuf* pMsgBuf) {
tscError("%p illegal value of numOfCols in query msg: %" PRIu64 ", table cols:%d", addr, int32_t index = 0;
(uint64_t)pQueryAttr->numOfCols, numOfCols); SToken sToken;
int64_t interval;
int64_t ts = 0;
char* pTokenEnd = *end;
if (pToken->type == TK_NOW) {
ts = taosGetTimestamp(timePrec);
} else if (pToken->type == TK_INTEGER) {
bool isSigned = false;
toInteger(pToken->z, pToken->n, 10, &ts, &isSigned);
} else { // parse the RFC-3339/ISO-8601 timestamp format string
if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {
return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z);
}
return TSDB_CODE_TSC_INVALID_OPERATION; return TSDB_CODE_SUCCESS;
} }
if (pQueryAttr->interval.interval < 0) { for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
tscError("%p illegal value of aggregation time interval in query msg: %" PRId64, addr, if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
(int64_t)pQueryInfo->interval.interval); if (pToken->z[k] == ',') {
return TSDB_CODE_TSC_INVALID_OPERATION; *end = pTokenEnd;
} *time = ts;
return 0;
}
if (pQueryAttr->pGroupbyExpr != NULL && pQueryAttr->pGroupbyExpr->numOfGroupCols < 0) { break;
tscError("%p illegal value of numOfGroupCols in query msg: %d", addr, pQueryInfo->groupbyExpr.numOfGroupCols);
return TSDB_CODE_TSC_INVALID_OPERATION;
} }
return TSDB_CODE_SUCCESS; /*
} * time expression:
* e.g., now+12a, now-5h
*/
SToken valueToken;
index = 0;
sToken = tStrGetToken(pTokenEnd, &index, false);
pTokenEnd += index;
static int32_t doAddTableName(char* nextStr, char** str, SArray* pNameArray, SSqlObj* pSql) { if (sToken.type == TK_MINUS || sToken.type == TK_PLUS) {
int32_t code = TSDB_CODE_SUCCESS; index = 0;
SSqlCmd* pCmd = &pSql->cmd; valueToken = tStrGetToken(pTokenEnd, &index, false);
pTokenEnd += index;
char tablename[TSDB_TABLE_FNAME_LEN] = {0}; if (valueToken.n < 2) {
int32_t len = 0; return buildSyntaxErrMsg(pMsgBuf, "value expected in timestamp", sToken.z);
}
if (nextStr == NULL) { char unit = 0;
tstrncpy(tablename, *str, TSDB_TABLE_FNAME_LEN); if (parseAbsoluteDuration(valueToken.z, valueToken.n, &interval, &unit, timePrec) != TSDB_CODE_SUCCESS) {
len = (int32_t) strlen(tablename);
} else {
len = (int32_t)(nextStr - (*str));
if (len >= TSDB_TABLE_NAME_LEN) {
sprintf(pCmd->payload, "table name too long");
return TSDB_CODE_TSC_INVALID_OPERATION; return TSDB_CODE_TSC_INVALID_OPERATION;
} }
memcpy(tablename, *str, nextStr - (*str)); if (sToken.type == TK_PLUS) {
tablename[len] = '\0'; ts += interval;
} else {
ts = ts - interval;
}
*end = pTokenEnd;
} }
(*str) = nextStr + 1; *time = ts;
len = (int32_t)strtrim(tablename); return TSDB_CODE_SUCCESS;
}
SToken sToken = {.n = len, .type = TK_ID, .z = tablename}; int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf) {
tGetToken(tablename, &sToken.type); int64_t iv;
char *endptr = NULL;
bool isSigned = false;
// Check if the table name available or not int32_t code = checkAndTrimValue(pToken, pSchema->type, tmpTokenBuf, pMsgBuf);
if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
sprintf(pCmd->payload, "table name is invalid");
return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
}
SName name = {0};
if ((code = tscSetTableFullName(&name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
return code; return code;
} }
memset(tablename, 0, tListLen(tablename)); if (isNullStr(pToken)) {
tNameExtractFullName(&name, tablename); if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
int64_t tmpVal = 0;
char* p = strdup(tablename); return func(&tmpVal, pSchema->bytes, param);
taosArrayPush(pNameArray, &p); }
return TSDB_CODE_SUCCESS;
}
int32_t nameComparFn(const void* n1, const void* n2) { return func(getNullValue(pSchema->type), 0, param);
int32_t ret = strcmp(*(char**)n1, *(char**)n2);
if (ret == 0) {
return 0;
} else {
return ret > 0? 1:-1;
} }
}
static void freeContent(void* p) { switch (pSchema->type) {
char* ptr = *(char**)p; case TSDB_DATA_TYPE_BOOL: {
tfree(ptr); if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
} if (strncmp(pToken->z, "true", pToken->n) == 0) {
return func(&TRUE_VALUE, pSchema->bytes, param);
} else if (strncmp(pToken->z, "false", pToken->n) == 0) {
return func(&FALSE_VALUE, pSchema->bytes, param);
} else {
return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
}
} else if (pToken->type == TK_INTEGER) {
return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
} else if (pToken->type == TK_FLOAT) {
return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
} else {
return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
}
}
case TSDB_DATA_TYPE_TINYINT: {
if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return buildSyntaxErrMsg(pMsgBuf, "invalid tinyint data", pToken->z);
} else if (!IS_VALID_TINYINT(iv)) {
return buildSyntaxErrMsg(pMsgBuf, "tinyint data overflow", pToken->z);
}
int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray) { uint8_t tmpVal = (uint8_t)iv;
SSqlCmd *pCmd = &pSql->cmd; return func(&tmpVal, pSchema->bytes, param);
}
pCmd->command = TSDB_SQL_MULTI_META; case TSDB_DATA_TYPE_UTINYINT:{
pCmd->msgType = TDMT_VND_TABLES_META; if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned tinyint data", pToken->z);
} else if (!IS_VALID_UTINYINT(iv)) {
return buildSyntaxErrMsg(pMsgBuf, "unsigned tinyint data overflow", pToken->z);
}
uint8_t tmpVal = (uint8_t)iv;
return func(&tmpVal, pSchema->bytes, param);
}
int code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; case TSDB_DATA_TYPE_SMALLINT: {
char *str = (char *)pNameList; if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return buildSyntaxErrMsg(pMsgBuf, "invalid smallint data", pToken->z);
} else if (!IS_VALID_SMALLINT(iv)) {
return buildSyntaxErrMsg(pMsgBuf, "smallint data overflow", pToken->z);
}
int16_t tmpVal = (int16_t)iv;
return func(&tmpVal, pSchema->bytes, param);
}
SQueryStmtInfo *pQueryInfo = tscGetQueryInfoS(pCmd); case TSDB_DATA_TYPE_USMALLINT: {
if (pQueryInfo == NULL) { if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
pSql->res.code = terrno; return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned smallint data", pToken->z);
return terrno; } else if (!IS_VALID_USMALLINT(iv)) {
} return buildSyntaxErrMsg(pMsgBuf, "unsigned smallint data overflow", pToken->z);
}
uint16_t tmpVal = (uint16_t)iv;
return func(&tmpVal, pSchema->bytes, param);
}
char *nextStr; case TSDB_DATA_TYPE_INT: {
while (1) { if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
nextStr = strchr(str, ','); return buildSyntaxErrMsg(pMsgBuf, "invalid int data", pToken->z);
if (nextStr == NULL) { } else if (!IS_VALID_INT(iv)) {
code = doAddTableName(nextStr, &str, pNameArray, pSql); return buildSyntaxErrMsg(pMsgBuf, "int data overflow", pToken->z);
break; }
int32_t tmpVal = (int32_t)iv;
return func(&tmpVal, pSchema->bytes, param);
} }
code = doAddTableName(nextStr, &str, pNameArray, pSql); case TSDB_DATA_TYPE_UINT: {
if (code != TSDB_CODE_SUCCESS) { if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return code; return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned int data", pToken->z);
} else if (!IS_VALID_UINT(iv)) {
return buildSyntaxErrMsg(pMsgBuf, "unsigned int data overflow", pToken->z);
}
uint32_t tmpVal = (uint32_t)iv;
return func(&tmpVal, pSchema->bytes, param);
} }
if (taosArrayGetSize(pNameArray) > TSDB_MULTI_TABLEMETA_MAX_NUM) { case TSDB_DATA_TYPE_BIGINT: {
code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
sprintf(pCmd->payload, "tables over the max number"); return buildSyntaxErrMsg(pMsgBuf, "invalid bigint data", pToken->z);
return code; } else if (!IS_VALID_BIGINT(iv)) {
return buildSyntaxErrMsg(pMsgBuf, "bigint data overflow", pToken->z);
}
return func(&iv, pSchema->bytes, param);
} }
}
size_t len = taosArrayGetSize(pNameArray); case TSDB_DATA_TYPE_UBIGINT: {
if (len == 1) { if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
return TSDB_CODE_SUCCESS; return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned bigint data", pToken->z);
} } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
return buildSyntaxErrMsg(pMsgBuf, "unsigned bigint data overflow", pToken->z);
}
uint64_t tmpVal = (uint64_t)iv;
return func(&tmpVal, pSchema->bytes, param);
}
if (len > TSDB_MULTI_TABLEMETA_MAX_NUM) { case TSDB_DATA_TYPE_FLOAT: {
code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; double dv;
sprintf(pCmd->payload, "tables over the max number"); if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
return code; return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
} }
if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) {
return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
}
float tmpVal = (float)dv;
return func(&tmpVal, pSchema->bytes, param);
}
taosArraySort(pNameArray, nameComparFn); case TSDB_DATA_TYPE_DOUBLE: {
taosArrayRemoveDuplicate(pNameArray, nameComparFn, freeContent); double dv;
return TSDB_CODE_SUCCESS; if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
} return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
}
if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) {
return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
}
return func(&dv, pSchema->bytes, param);
}
bool vgroupInfoIdentical(SNewVgroupInfo *pExisted, SVgroupMsg* src) { case TSDB_DATA_TYPE_BINARY: {
assert(pExisted != NULL && src != NULL); // Too long values will raise the invalid sql error message
if (pExisted->numOfEps != src->numOfEps) { if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
return false; return buildSyntaxErrMsg(pMsgBuf, "string data overflow", pToken->z);
} }
for(int32_t i = 0; i < pExisted->numOfEps; ++i) { return func(pToken->z, pToken->n, param);
if (pExisted->ep[i].port != src->epAddr[i].port) {
return false;
} }
if (strncmp(pExisted->ep[i].fqdn, src->epAddr[i].fqdn, tListLen(pExisted->ep[i].fqdn)) != 0) { case TSDB_DATA_TYPE_NCHAR: {
return false; return func(pToken->z, pToken->n, param);
} }
}
return true;
}
SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg) {
assert(pVgroupMsg != NULL);
SNewVgroupInfo info = {0}; case TSDB_DATA_TYPE_TIMESTAMP: {
info.numOfEps = pVgroupMsg->numOfEps; int64_t tmpVal;
info.vgId = pVgroupMsg->vgId; if (parseTime(end, pToken, timePrec, &tmpVal, pMsgBuf) != TSDB_CODE_SUCCESS) {
info.inUse = 0; // 0 is the default value of inUse in case of multiple replica return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp", pToken->z);
}
assert(info.numOfEps >= 1 && info.vgId >= 1); return func(&tmpVal, pSchema->bytes, param);
for(int32_t i = 0; i < pVgroupMsg->numOfEps; ++i) { }
tstrncpy(info.ep[i].fqdn, pVgroupMsg->epAddr[i].fqdn, TSDB_FQDN_LEN);
info.ep[i].port = pVgroupMsg->epAddr[i].port;
} }
return info; return TSDB_CODE_FAILED;
} }
char* cloneCurrentDBName(SSqlObj* pSql) { int32_t KvRowAppend(const void *value, int32_t len, void *param) {
char *p = NULL; SKvParam* pa = (SKvParam*) param;
HttpContext *pCtx = NULL;
pthread_mutex_lock(&pSql->pTscObj->mutex); int32_t type = pa->schema->type;
STscObj *pTscObj = pSql->pTscObj; int32_t colId = pa->schema->colId;
switch (pTscObj->from) {
case TAOS_REQ_FROM_HTTP:
pCtx = pSql->param;
if (pCtx && pCtx->db[0] != '\0') {
char db[TSDB_DB_FNAME_LEN] = {0};
int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
assert(len <= sizeof(db));
p = strdup(db); if (TSDB_DATA_TYPE_BINARY == type) {
} STR_WITH_SIZE_TO_VARSTR(pa->buf, value, len);
break; tdAddColToKVRow(pa->builder, colId, type, pa->buf);
default: } else if (TSDB_DATA_TYPE_NCHAR == type) {
break; // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
} int32_t output = 0;
if (p == NULL) { if (!taosMbsToUcs4(value, len, varDataVal(pa->buf), pa->schema->bytes - VARSTR_HEADER_SIZE, &output)) {
p = strdup(pSql->pTscObj->db); return TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
} }
pthread_mutex_unlock(&pSql->pTscObj->mutex);
return p; varDataSetLen(pa->buf, output);
} tdAddColToKVRow(pa->builder, colId, type, pa->buf);
} else {
tdAddColToKVRow(pa->builder, colId, type, value);
}
#endif return TSDB_CODE_SUCCESS;
\ No newline at end of file }
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或