[td-225]merge develop.
This commit is contained in:
Haojun Liao
commit
e3046f62f6
|
|
@ -83,6 +83,8 @@ IF (TD_ARM_64)
|
|||
ADD_DEFINITIONS(-DUSE_LIBICONV)
|
||||
MESSAGE(STATUS "arm64 is defined")
|
||||
SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
|
||||
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_ARM_32)
|
||||
|
|
@ -91,6 +93,8 @@ IF (TD_ARM_32)
|
|||
ADD_DEFINITIONS(-DUSE_LIBICONV)
|
||||
MESSAGE(STATUS "arm32 is defined")
|
||||
SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
|
||||
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_MIPS_64)
|
||||
|
|
@ -143,6 +147,7 @@ IF (TD_LINUX)
|
|||
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_DARWIN_64)
|
||||
|
|
@ -164,6 +169,7 @@ IF (TD_DARWIN_64)
|
|||
SET(RELEASE_FLAGS "-Og")
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_WINDOWS)
|
||||
|
|
@ -194,6 +200,7 @@ IF (TD_WINDOWS)
|
|||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/regex)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/wepoll/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/MsvcLibX/include)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_WINDOWS_64)
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ IF (TD_LINUX)
|
|||
IF (TD_LINUX_64)
|
||||
TARGET_LINK_LIBRARIES(taos lua)
|
||||
ENDIF ()
|
||||
|
||||
|
||||
SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
|
||||
#set version of .so
|
||||
|
|
@ -37,13 +37,13 @@ ELSEIF (TD_DARWIN)
|
|||
|
||||
# set the static lib name
|
||||
ADD_LIBRARY(taos_static STATIC ${SRC})
|
||||
TARGET_LINK_LIBRARIES(taos_static common query trpc tutil pthread m)
|
||||
TARGET_LINK_LIBRARIES(taos_static common query trpc tutil pthread m lua)
|
||||
SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
|
||||
SET_TARGET_PROPERTIES(taos_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
|
||||
# generate dynamic library (*.dylib)
|
||||
ADD_LIBRARY(taos SHARED ${SRC})
|
||||
TARGET_LINK_LIBRARIES(taos common query trpc tutil pthread m)
|
||||
TARGET_LINK_LIBRARIES(taos common query trpc tutil pthread m lua)
|
||||
SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
|
||||
#set version of .dylib
|
||||
|
|
@ -68,19 +68,19 @@ ELSEIF (TD_WINDOWS)
|
|||
IF (NOT TD_GODLL)
|
||||
SET_TARGET_PROPERTIES(taos PROPERTIES LINK_FLAGS /DEF:${TD_COMMUNITY_DIR}/src/client/src/taos.def)
|
||||
ENDIF ()
|
||||
TARGET_LINK_LIBRARIES(taos trpc tutil query)
|
||||
TARGET_LINK_LIBRARIES(taos trpc tutil query lua)
|
||||
|
||||
ELSEIF (TD_DARWIN)
|
||||
SET(CMAKE_MACOSX_RPATH 1)
|
||||
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/linux)
|
||||
|
||||
ADD_LIBRARY(taos_static STATIC ${SRC})
|
||||
TARGET_LINK_LIBRARIES(taos_static query trpc tutil pthread m)
|
||||
TARGET_LINK_LIBRARIES(taos_static query trpc tutil pthread m lua)
|
||||
SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
|
||||
|
||||
# generate dynamic library (*.dylib)
|
||||
ADD_LIBRARY(taos SHARED ${SRC})
|
||||
TARGET_LINK_LIBRARIES(taos query trpc tutil pthread m)
|
||||
TARGET_LINK_LIBRARIES(taos query trpc tutil pthread m lua)
|
||||
|
||||
SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
|
||||
|
|
|
|||
|
|
@ -107,6 +107,7 @@ SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint
|
|||
uint32_t offset);
|
||||
|
||||
void* tscDestroyBlockArrayList(SArray* pDataBlockList);
|
||||
void* tscDestroyUdfArrayList(SArray* pUdfList);
|
||||
void* tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta);
|
||||
|
||||
int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
|
||||
|
|
@ -261,6 +262,7 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
|
|||
int tscGetSTableVgroupInfo(SSqlObj* pSql, SQueryInfo* pQueryInfo);
|
||||
int tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
|
||||
int tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
|
||||
int32_t tscGetUdfFromNode(SSqlObj *pSql, SQueryInfo* pQueryInfo);
|
||||
|
||||
void tscResetForNextRetrieve(SSqlRes* pRes);
|
||||
void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
|
||||
|
|
@ -307,10 +309,9 @@ bool hasMoreClauseToTry(SSqlObj* pSql);
|
|||
void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta);
|
||||
|
||||
void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
|
||||
void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
|
||||
void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
|
||||
int tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
|
||||
int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp, bool metaClone);
|
||||
int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, SArray* pUdfList, __async_cb_func_t fp, bool metaClone);
|
||||
|
||||
int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray);
|
||||
|
||||
|
|
|
|||
|
|
@ -146,6 +146,7 @@ typedef struct {
|
|||
SInsertStatementParam insertParam;
|
||||
char reserve1[3]; // fix bus error on arm32
|
||||
int32_t count; // todo remove it
|
||||
bool subCmd;
|
||||
|
||||
char reserve2[3]; // fix bus error on arm32
|
||||
int16_t numOfCols;
|
||||
|
|
|
|||
|
|
@ -602,6 +602,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
|
|||
if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
|
||||
|
||||
doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[functionId].mergeFunc(&pCtx[j]);
|
||||
}
|
||||
} else {
|
||||
|
|
@ -610,6 +619,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
|
|||
if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
|
||||
|
||||
doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[functionId].xFinalize(&pCtx[j]);
|
||||
}
|
||||
|
||||
|
|
@ -626,7 +644,11 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
|
|||
}
|
||||
|
||||
for(int32_t j = 0; j < numOfExpr; ++j) {
|
||||
aAggs[pCtx[j].functionId].init(&pCtx[j]);
|
||||
if (pCtx[j].functionId < 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
|
||||
}
|
||||
|
||||
for (int32_t j = 0; j < numOfExpr; ++j) {
|
||||
|
|
@ -638,6 +660,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
|
|||
if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
|
||||
|
||||
doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[functionId].mergeFunc(&pCtx[j]);
|
||||
}
|
||||
}
|
||||
|
|
@ -651,6 +682,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
|
|||
if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
|
||||
|
||||
doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[functionId].mergeFunc(&pCtx[j]);
|
||||
}
|
||||
}
|
||||
|
|
@ -871,7 +911,6 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
|
|||
|
||||
{
|
||||
if (pAggInfo->hasDataBlockForNewGroup) {
|
||||
pAggInfo->binfo.pRes->info.rows = 0;
|
||||
pAggInfo->hasPrev = false; // now we start from a new group data set.
|
||||
|
||||
// not belongs to the same group, return the result of current group;
|
||||
|
|
@ -880,7 +919,13 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
|
|||
|
||||
{ // reset output buffer
|
||||
for(int32_t j = 0; j < pOperator->numOfOutput; ++j) {
|
||||
aAggs[pAggInfo->binfo.pCtx[j].functionId].init(&pAggInfo->binfo.pCtx[j]);
|
||||
SQLFunctionCtx* pCtx = &pAggInfo->binfo.pCtx[j];
|
||||
if (pCtx->functionId < 0) {
|
||||
clearOutputBuf(&pAggInfo->binfo, &pAggInfo->bufCapacity);
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[pCtx->functionId].init(pCtx, pCtx->resultInfo);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -933,6 +978,14 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
|
|||
continue;
|
||||
}
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pAggInfo->udfInfo, -1 * functionId - 1);
|
||||
|
||||
doInvokeUdf(pUdfInfo, &pAggInfo->binfo.pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
aAggs[functionId].xFinalize(&pAggInfo->binfo.pCtx[j]);
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -503,6 +503,7 @@ int doBuildAndSendMsg(SSqlObj *pSql) {
|
|||
pCmd->command == TSDB_SQL_INSERT ||
|
||||
pCmd->command == TSDB_SQL_CONNECT ||
|
||||
pCmd->command == TSDB_SQL_HB ||
|
||||
pCmd->command == TSDB_SQL_RETRIEVE_FUNC ||
|
||||
pCmd->command == TSDB_SQL_STABLEVGROUP) {
|
||||
pRes->code = tscBuildMsg[pCmd->command](pSql, NULL);
|
||||
}
|
||||
|
|
@ -545,7 +546,7 @@ int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
|
|||
type = pQueryInfo->type;
|
||||
|
||||
// while numOfTables equals to 0, it must be Heartbeat
|
||||
assert((pQueryInfo->numOfTables == 0 && pQueryInfo->command == TSDB_SQL_HB) || pQueryInfo->numOfTables > 0);
|
||||
assert((pQueryInfo->numOfTables == 0 && (pQueryInfo->command == TSDB_SQL_HB || pSql->cmd.command == TSDB_SQL_RETRIEVE_FUNC)) || pQueryInfo->numOfTables > 0);
|
||||
}
|
||||
|
||||
tscDebug("0x%"PRIx64" SQL cmd:%s will be processed, name:%s, type:%d", pSql->self, sqlCmd[pCmd->command], name, type);
|
||||
|
|
@ -1032,6 +1033,34 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
pMsg += sizeof(int32_t);
|
||||
}
|
||||
|
||||
// support only one udf
|
||||
if (pQueryInfo->pUdfInfo != NULL && taosArrayGetSize(pQueryInfo->pUdfInfo) > 0) {
|
||||
pQueryMsg->udfContentOffset = htonl((int32_t) (pMsg - pCmd->payload));
|
||||
for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, i);
|
||||
*(int8_t*) pMsg = pUdfInfo->resType;
|
||||
pMsg += sizeof(pUdfInfo->resType);
|
||||
|
||||
*(int16_t*) pMsg = htons(pUdfInfo->resBytes);
|
||||
pMsg += sizeof(pUdfInfo->resBytes);
|
||||
|
||||
STR_TO_VARSTR(pMsg, pUdfInfo->name);
|
||||
|
||||
pMsg += varDataTLen(pMsg);
|
||||
|
||||
*(int32_t*) pMsg = htonl(pUdfInfo->funcType);
|
||||
pMsg += sizeof(pUdfInfo->funcType);
|
||||
|
||||
*(int32_t*) pMsg = htonl(pUdfInfo->bufSize);
|
||||
pMsg += sizeof(pUdfInfo->bufSize);
|
||||
|
||||
pQueryMsg->udfContentLen = htonl(pUdfInfo->contLen);
|
||||
memcpy(pMsg, pUdfInfo->content, pUdfInfo->contLen);
|
||||
|
||||
pMsg += pUdfInfo->contLen;
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(pMsg, pSql->sqlstr, sqlLen);
|
||||
pMsg += sqlLen;
|
||||
|
||||
|
|
@ -1067,6 +1096,18 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t tscBuildCreateFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
SCreateFuncMsg *pCreateFuncMsg = (SCreateFuncMsg *)pCmd->payload;
|
||||
|
||||
pCmd->msgType = TSDB_MSG_TYPE_CM_CREATE_FUNCTION;
|
||||
|
||||
pCmd->payloadLen = sizeof(SCreateFuncMsg) + htonl(pCreateFuncMsg->codeLen);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
pCmd->payloadLen = sizeof(SCreateDnodeMsg);
|
||||
|
|
@ -1191,6 +1232,17 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t tscBuildDropFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
|
||||
pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_FUNCTION;
|
||||
|
||||
pCmd->payloadLen = sizeof(SDropFuncMsg);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
pCmd->payloadLen = sizeof(SCMDropTableMsg);
|
||||
|
|
@ -1294,11 +1346,19 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
return TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
SShowMsg *pShowMsg = (SShowMsg *)pCmd->payload;
|
||||
SShowInfo *pShowInfo = &pInfo->pMiscInfo->showOpt;
|
||||
SShowMsg *pShowMsg = (SShowMsg *)pCmd->payload;
|
||||
|
||||
STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
|
||||
if (pShowInfo->showType == TSDB_MGMT_TABLE_FUNCTION) {
|
||||
pShowMsg->type = pShowInfo->showType;
|
||||
pShowMsg->payloadLen = 0;
|
||||
pCmd->payloadLen = sizeof(SShowMsg);
|
||||
|
||||
if (tNameIsEmpty(&pTableMetaInfo->name)) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (tNameIsEmpty(&pTableMetaInfo->name)) {
|
||||
pthread_mutex_lock(&pObj->mutex);
|
||||
tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));
|
||||
pthread_mutex_unlock(&pObj->mutex);
|
||||
|
|
@ -1306,7 +1366,6 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
|
||||
}
|
||||
|
||||
SShowInfo *pShowInfo = &pInfo->pMiscInfo->showOpt;
|
||||
pShowMsg->type = pShowInfo->showType;
|
||||
|
||||
if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) {
|
||||
|
|
@ -1819,6 +1878,29 @@ int tscBuildSTableVgroupMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int tscBuildRetrieveFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
|
||||
char *pMsg = pCmd->payload;
|
||||
SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
int32_t numOfFuncs = (int32_t)taosArrayGetSize(pQueryInfo->pUdfInfo);
|
||||
|
||||
SRetrieveFuncMsg *pRetrieveFuncMsg = (SRetrieveFuncMsg *)pMsg;
|
||||
pRetrieveFuncMsg->num = htonl(numOfFuncs);
|
||||
|
||||
pMsg += sizeof(SRetrieveFuncMsg);
|
||||
for(int32_t i = 0; i < numOfFuncs; ++i) {
|
||||
SUdfInfo* pUdf = taosArrayGet(pQueryInfo->pUdfInfo, i);
|
||||
STR_TO_NET_VARSTR(pMsg, pUdf->name);
|
||||
pMsg += varDataNetTLen(pMsg);
|
||||
}
|
||||
|
||||
pCmd->msgType = TSDB_MSG_TYPE_CM_RETRIEVE_FUNC;
|
||||
pCmd->payloadLen = (int32_t)(pMsg - pCmd->payload);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
|
||||
SSqlCmd *pCmd = &pSql->cmd;
|
||||
STscObj *pObj = pSql->pTscObj;
|
||||
|
|
@ -2034,12 +2116,64 @@ static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t
|
|||
return pVgroupInfo;
|
||||
}
|
||||
|
||||
int tscProcessRetrieveFuncRsp(SSqlObj* pSql) {
|
||||
SSqlCmd* pCmd = &pSql->cmd;
|
||||
SUdfFuncMsg* pFuncMsg = (SUdfFuncMsg *)pSql->res.pRsp;
|
||||
SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
|
||||
pFuncMsg->num = htonl(pFuncMsg->num);
|
||||
assert(pFuncMsg->num == taosArrayGetSize(pQueryInfo->pUdfInfo));
|
||||
|
||||
char* pMsg = pFuncMsg->content;
|
||||
for(int32_t i = 0; i < pFuncMsg->num; ++i) {
|
||||
SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
|
||||
|
||||
for(int32_t j = 0; j < pFuncMsg->num; ++j) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
|
||||
if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (pUdfInfo->content) {
|
||||
continue;
|
||||
}
|
||||
|
||||
pUdfInfo->resBytes = htons(pFunc->resBytes);
|
||||
pUdfInfo->resType = pFunc->resType;
|
||||
pUdfInfo->funcType = htonl(pFunc->funcType);
|
||||
pUdfInfo->contLen = htonl(pFunc->len);
|
||||
pUdfInfo->bufSize = htonl(pFunc->bufSize);
|
||||
|
||||
pUdfInfo->content = malloc(pUdfInfo->contLen);
|
||||
memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
|
||||
|
||||
pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
|
||||
}
|
||||
}
|
||||
|
||||
// master sqlObj locates in param
|
||||
SSqlObj* parent = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
|
||||
if(parent == NULL) {
|
||||
return pSql->res.code;
|
||||
}
|
||||
|
||||
SQueryInfo* parQueryInfo = tscGetQueryInfo(&parent->cmd);
|
||||
|
||||
assert(parent->signature == parent && (int64_t)pSql->param == parent->self);
|
||||
taosArrayDestroy(parQueryInfo->pUdfInfo);
|
||||
|
||||
parQueryInfo->pUdfInfo = pQueryInfo->pUdfInfo; // assigned to parent sql obj.
|
||||
pQueryInfo->pUdfInfo = NULL;
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
|
||||
char *rsp = pSql->res.pRsp;
|
||||
|
||||
SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
|
||||
pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
|
||||
pMultiMeta->numOfVgroup = htonl(pMultiMeta->numOfVgroup);
|
||||
pMultiMeta->numOfUdf = htonl(pMultiMeta->numOfUdf);
|
||||
|
||||
rsp += sizeof(SMultiTableMeta);
|
||||
|
||||
|
|
@ -2077,6 +2211,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
|
|||
STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
|
||||
if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
|
||||
tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, pMetaMsg->tableFname);
|
||||
tfree(pTableMeta);
|
||||
taosHashCleanup(pSet);
|
||||
taosReleaseRef(tscObjRef, pParentSql->self);
|
||||
|
||||
|
|
@ -2128,10 +2263,45 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
|
|||
assert(p != NULL);
|
||||
|
||||
int32_t size = 0;
|
||||
if (p->pVgroupInfo!= NULL) {
|
||||
tscVgroupInfoClear(p->pVgroupInfo);
|
||||
//tfree(p->pTableMeta);
|
||||
}
|
||||
p->pVgroupInfo = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
|
||||
pMsg += size;
|
||||
}
|
||||
|
||||
SQueryInfo* pQueryInfo = tscGetQueryInfo(pParentCmd);
|
||||
if (pMultiMeta->numOfUdf > 0) {
|
||||
assert(pQueryInfo->pUdfInfo != NULL);
|
||||
}
|
||||
|
||||
for(int32_t i = 0; i < pMultiMeta->numOfUdf; ++i) {
|
||||
SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
|
||||
|
||||
for(int32_t j = 0; j < pMultiMeta->numOfUdf; ++j) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
|
||||
if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (pUdfInfo->content) {
|
||||
continue;
|
||||
}
|
||||
|
||||
pUdfInfo->resBytes = htons(pFunc->resBytes);
|
||||
pUdfInfo->resType = pFunc->resType;
|
||||
pUdfInfo->funcType = htonl(pFunc->funcType);
|
||||
pUdfInfo->contLen = htonl(pFunc->len);
|
||||
pUdfInfo->bufSize = htonl(pFunc->bufSize);
|
||||
|
||||
pUdfInfo->content = malloc(pUdfInfo->contLen);
|
||||
memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
|
||||
|
||||
pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
|
||||
}
|
||||
}
|
||||
|
||||
pSql->res.code = TSDB_CODE_SUCCESS;
|
||||
pSql->res.numOfTotal = pMultiMeta->numOfTables;
|
||||
tscDebug("0x%"PRIx64" load multi-tableMeta from mnode, numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
|
||||
|
|
@ -2522,7 +2692,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp, bool metaClone) {
|
||||
int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, SArray* pUdfList, __async_cb_func_t fp, bool metaClone) {
|
||||
SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
|
||||
if (NULL == pNew) {
|
||||
tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
|
||||
|
|
@ -2535,8 +2705,9 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
|
|||
|
||||
int32_t numOfTable = (int32_t) taosArrayGetSize(pNameList);
|
||||
int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pVgroupNameList);
|
||||
int32_t numOfUdf = pUdfList ? (int32_t)taosArrayGetSize(pUdfList) : 0;
|
||||
|
||||
int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + sizeof(SMultiTableInfoMsg);
|
||||
int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + TSDB_FUNC_NAME_LEN * numOfUdf + sizeof(SMultiTableInfoMsg);
|
||||
if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, size)) {
|
||||
tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
|
||||
tscFreeSqlObj(pNew);
|
||||
|
|
@ -2547,12 +2718,13 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
|
|||
pInfo->metaClone = metaClone? 1:0;
|
||||
pInfo->numOfTables = htonl((uint32_t) taosArrayGetSize(pNameList));
|
||||
pInfo->numOfVgroups = htonl((uint32_t) taosArrayGetSize(pVgroupNameList));
|
||||
pInfo->numOfUdfs = htonl(numOfUdf);
|
||||
|
||||
char* start = pInfo->tableNames;
|
||||
int32_t len = 0;
|
||||
for(int32_t i = 0; i < numOfTable; ++i) {
|
||||
char* name = taosArrayGetP(pNameList, i);
|
||||
if (i < numOfTable - 1 || numOfVgroupList > 0) {
|
||||
if (i < numOfTable - 1 || numOfVgroupList > 0 || numOfUdf > 0) {
|
||||
len = sprintf(start, "%s,", name);
|
||||
} else {
|
||||
len = sprintf(start, "%s", name);
|
||||
|
|
@ -2563,7 +2735,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
|
|||
|
||||
for(int32_t i = 0; i < numOfVgroupList; ++i) {
|
||||
char* name = taosArrayGetP(pVgroupNameList, i);
|
||||
if (i < numOfVgroupList - 1) {
|
||||
if (i < numOfVgroupList - 1 || numOfUdf > 0) {
|
||||
len = sprintf(start, "%s,", name);
|
||||
} else {
|
||||
len = sprintf(start, "%s", name);
|
||||
|
|
@ -2572,12 +2744,23 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
|
|||
start += len;
|
||||
}
|
||||
|
||||
for(int32_t i = 0; i < numOfUdf; ++i) {
|
||||
SUdfInfo * u = taosArrayGet(pUdfList, i);
|
||||
if (i < numOfUdf - 1) {
|
||||
len = sprintf(start, "%s,", u->name);
|
||||
} else {
|
||||
len = sprintf(start, "%s", u->name);
|
||||
}
|
||||
|
||||
start += len;
|
||||
}
|
||||
|
||||
pNew->cmd.payloadLen = (int32_t) ((start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg));
|
||||
pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLES_META;
|
||||
|
||||
registerSqlObj(pNew);
|
||||
tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, msg size:%d", pSql->self,
|
||||
pNew->self, numOfTable, numOfVgroupList, pNew->cmd.payloadLen);
|
||||
tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, udf:%d, msg size:%d", pSql->self,
|
||||
pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
|
||||
|
||||
pNew->fp = fp;
|
||||
pNew->param = (void *)pSql->self;
|
||||
|
|
@ -2648,6 +2831,60 @@ int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool create
|
|||
return tscGetTableMetaImpl(pSql, pTableMetaInfo, createIfNotExists);
|
||||
}
|
||||
|
||||
int32_t tscGetUdfFromNode(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
|
||||
SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
|
||||
if (NULL == pNew) {
|
||||
tscError("%p malloc failed for new sqlobj to get user-defined functions", pSql);
|
||||
return TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
pNew->pTscObj = pSql->pTscObj;
|
||||
pNew->signature = pNew;
|
||||
pNew->cmd.command = TSDB_SQL_RETRIEVE_FUNC;
|
||||
|
||||
if (tscAddQueryInfo(&pNew->cmd) != TSDB_CODE_SUCCESS) {
|
||||
tscError("%p malloc failed for new queryinfo", pSql);
|
||||
tscFreeSqlObj(pNew);
|
||||
return TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
|
||||
|
||||
pNewQueryInfo->pUdfInfo = taosArrayInit(4, sizeof(SUdfInfo));
|
||||
for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
|
||||
SUdfInfo info = {0};
|
||||
SUdfInfo* p1 = taosArrayGet(pQueryInfo->pUdfInfo, i);
|
||||
info = *p1;
|
||||
info.name = strdup(p1->name);
|
||||
taosArrayPush(pNewQueryInfo->pUdfInfo, &info);
|
||||
}
|
||||
|
||||
pNew->cmd.active = pNewQueryInfo;
|
||||
|
||||
if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
|
||||
tscError("%p malloc failed for payload to get table meta", pSql);
|
||||
tscFreeSqlObj(pNew);
|
||||
return TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
tscDebug("%p new pSqlObj:%p to retrieve udf", pSql, pNew);
|
||||
registerSqlObj(pNew);
|
||||
|
||||
pNew->fp = tscTableMetaCallBack;
|
||||
pNew->param = (void *)pSql->self;
|
||||
|
||||
tscDebug("%p metaRid from %" PRId64 " to %" PRId64 , pSql, pSql->metaRid, pNew->self);
|
||||
|
||||
pSql->metaRid = pNew->self;
|
||||
|
||||
int32_t code = tscBuildAndSendRequest(pNew, NULL);
|
||||
if (code == TSDB_CODE_SUCCESS) {
|
||||
code = TSDB_CODE_TSC_ACTION_IN_PROGRESS; // notify application that current process needs to be terminated
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
/**
|
||||
* retrieve table meta from mnode, and then update the local table meta hashmap.
|
||||
* @param pSql sql object
|
||||
|
|
@ -2749,6 +2986,7 @@ void tscInitMsgsFp() {
|
|||
|
||||
tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
|
||||
tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
|
||||
tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg;
|
||||
|
||||
tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg;
|
||||
tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg;
|
||||
|
|
@ -2757,6 +2995,7 @@ void tscInitMsgsFp() {
|
|||
tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
|
||||
tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
|
||||
tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
|
||||
tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg;
|
||||
tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
|
||||
tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
|
||||
tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
|
||||
|
|
@ -2772,6 +3011,7 @@ void tscInitMsgsFp() {
|
|||
tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
|
||||
// tscBuildMsg[TSDB_SQL_META] = tscBuildTableMetaMsg;
|
||||
tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
|
||||
tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg;
|
||||
|
||||
tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
|
||||
tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
|
||||
|
|
@ -2790,6 +3030,7 @@ void tscInitMsgsFp() {
|
|||
tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
|
||||
tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
|
||||
tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
|
||||
tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
|
||||
|
||||
tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
|
||||
tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode; // rsp handled by same function.
|
||||
|
|
@ -2819,3 +3060,4 @@ void tscInitMsgsFp() {
|
|||
tscKeepConn[TSDB_SQL_FETCH] = 1;
|
||||
tscKeepConn[TSDB_SQL_HB] = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -566,7 +566,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
|
|||
|
||||
SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
|
||||
if ((pQueryInfo == NULL) || tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
|
||||
if ((pQueryInfo == NULL) || pQueryInfo->globalMerge) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -679,7 +679,7 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
|
|||
|
||||
SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
|
||||
if (!tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
|
||||
if (!pQueryInfo->globalMerge) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -730,7 +730,7 @@ void taos_stop_query(TAOS_RES *res) {
|
|||
|
||||
SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
|
||||
if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
|
||||
if (pQueryInfo->globalMerge) {
|
||||
assert(pSql->rpcRid <= 0);
|
||||
tscKillSTableQuery(pSql);
|
||||
} else {
|
||||
|
|
@ -987,7 +987,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
|
|||
registerSqlObj(pSql);
|
||||
tscDebug("0x%"PRIx64" load multiple table meta, tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
|
||||
|
||||
code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, loadMultiTableMetaCallback, false);
|
||||
code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, NULL, loadMultiTableMetaCallback, false);
|
||||
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
|
||||
code = TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include "tscSubquery.h"
|
||||
#include "qTableMeta.h"
|
||||
#include "tsclient.h"
|
||||
#include "qUdf.h"
|
||||
#include "qUtil.h"
|
||||
#include "qPlan.h"
|
||||
|
||||
|
|
@ -32,7 +33,7 @@ typedef struct SInsertSupporter {
|
|||
} SInsertSupporter;
|
||||
|
||||
static void freeJoinSubqueryObj(SSqlObj* pSql);
|
||||
static bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql);
|
||||
//static bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql);
|
||||
|
||||
static int32_t tsCompare(int32_t order, int64_t left, int64_t right) {
|
||||
if (left == right) {
|
||||
|
|
@ -107,6 +108,9 @@ bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
|
|||
subState->states[idx] = 1;
|
||||
|
||||
bool done = allSubqueryDone(pParentSql);
|
||||
if (!done) {
|
||||
tscDebug("0x%"PRIx64" sub:%p,%d completed, total:%d", pParentSql->self, pSql, idx, pParentSql->subState.numOfSub);
|
||||
}
|
||||
pthread_mutex_unlock(&subState->mutex);
|
||||
return done;
|
||||
}
|
||||
|
|
@ -416,7 +420,9 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
|
|||
}
|
||||
|
||||
// tscFieldInfoClear(&pSupporter->fieldsInfo);
|
||||
|
||||
if (pSupporter->fieldsInfo.internalField != NULL) {
|
||||
taosArrayDestroy(pSupporter->fieldsInfo.internalField);
|
||||
}
|
||||
if (pSupporter->pTSBuf != NULL) {
|
||||
tsBufDestroy(pSupporter->pTSBuf);
|
||||
pSupporter->pTSBuf = NULL;
|
||||
|
|
@ -430,7 +436,8 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
|
|||
}
|
||||
|
||||
if (pSupporter->pVgroupTables != NULL) {
|
||||
taosArrayDestroy(pSupporter->pVgroupTables);
|
||||
//taosArrayDestroy(pSupporter->pVgroupTables);
|
||||
tscFreeVgroupTableInfo(pSupporter->pVgroupTables);
|
||||
pSupporter->pVgroupTables = NULL;
|
||||
}
|
||||
|
||||
|
|
@ -889,7 +896,9 @@ static int32_t getIntersectionOfTableTuple(SQueryInfo* pQueryInfo, SSqlObj* pPar
|
|||
tscDebug("Join %d - num:%d", i, p->num);
|
||||
|
||||
// sort according to the tag valu
|
||||
qsort(p->pIdTagList, p->num, p->tagSize, tagValCompar);
|
||||
if (p->pIdTagList != NULL) {
|
||||
qsort(p->pIdTagList, p->num, p->tagSize, tagValCompar);
|
||||
}
|
||||
|
||||
if (!checkForDuplicateTagVal(pColSchema, p, pParentSql)) {
|
||||
for (int32_t j = 0; j <= i; j++) {
|
||||
|
|
@ -1173,7 +1182,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
|
|||
// no data exists in next vnode, mark the <tid, tags> query completed
|
||||
// only when there is no subquery exits any more, proceeds to get the intersect of the <tid, tags> tuple sets.
|
||||
if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
|
||||
tscDebug("0x%"PRIx64" tagRetrieve:%p,%d completed, total:%d", pParentSql->self, tres, pSupporter->subqueryIndex, pParentSql->subState.numOfSub);
|
||||
//tscDebug("0x%"PRIx64" tagRetrieve:%p,%d completed, total:%d", pParentSql->self, tres, pSupporter->subqueryIndex, pParentSql->subState.numOfSub);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1441,7 +1450,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
|
|||
}
|
||||
|
||||
if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
|
||||
tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d completed, total:%d", pParentSql->self, pSql->self, pSupporter->subqueryIndex, pState->numOfSub);
|
||||
//tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d completed, total:%d", pParentSql->self, pSql->self, pSupporter->subqueryIndex, pState->numOfSub);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1888,7 +1897,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
|
|||
int16_t type = 0;
|
||||
int32_t inter = 0;
|
||||
|
||||
getResultDataInfo(s->type, s->bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0);
|
||||
getResultDataInfo(s->type, s->bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0, NULL);
|
||||
|
||||
SSchema s1 = {.colId = s->colId, .type = (uint8_t)type, .bytes = bytes};
|
||||
pSupporter->tagSize = s1.bytes;
|
||||
|
|
@ -2794,6 +2803,28 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
|
|||
|
||||
tscFreeRetrieveSup(pSql);
|
||||
|
||||
// set the command flag must be after the semaphore been correctly set.
|
||||
if (pParentSql->cmd.command != TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
|
||||
pParentSql->cmd.command = TSDB_SQL_RETRIEVE_GLOBALMERGE;
|
||||
|
||||
SQueryInfo *pQueryInfo2 = tscGetQueryInfo(&pParentSql->cmd);
|
||||
|
||||
size_t size = tscNumOfExprs(pQueryInfo);
|
||||
for (int32_t j = 0; j < size; ++j) {
|
||||
SExprInfo* pExprInfo = tscExprGet(pQueryInfo2, j);
|
||||
|
||||
int32_t functionId = pExprInfo->base.functionId;
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo2->pUdfInfo, -1 * functionId - 1);
|
||||
code = initUdfInfo(pUdfInfo);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
pParentSql->res.code = code;
|
||||
tscAsyncResultOnError(pParentSql);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
|
||||
(*pParentSql->fp)(pParentSql->param, pParentSql, 0);
|
||||
} else {
|
||||
|
|
@ -3048,9 +3079,10 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
|
|||
pParentObj->cmd.insertParam.schemaAttached = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (!subAndCheckDone(tres, pParentObj, pSupporter->index)) {
|
||||
tscDebug("0x%"PRIx64" insert:%p,%d completed, total:%d", pParentObj->self, tres, pSupporter->index, pParentObj->subState.numOfSub);
|
||||
// concurrency problem, other thread already release pParentObj
|
||||
//tscDebug("0x%"PRIx64" insert:%p,%d completed, total:%d", pParentObj->self, tres, suppIdx, pParentObj->subState.numOfSub);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -3461,20 +3493,20 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
|
|||
SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
|
||||
if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
|
||||
bool allSubqueryExhausted = true;
|
||||
|
||||
|
||||
for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
|
||||
if (pSql->pSubs[i] == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
SSqlRes *pRes1 = &pSql->pSubs[i]->res;
|
||||
SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
|
||||
|
||||
|
||||
SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd1);
|
||||
assert(pQueryInfo1->numOfTables == 1);
|
||||
|
||||
|
||||
STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo1, 0);
|
||||
|
||||
|
||||
/*
|
||||
* if the global limitation is not reached, and current result has not exhausted, or next more vnodes are
|
||||
* available, goes on
|
||||
|
|
@ -3485,14 +3517,14 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
hasData = !allSubqueryExhausted;
|
||||
} else { // otherwise, in case inner join, if any subquery exhausted, query completed.
|
||||
for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
|
||||
if (pSql->pSubs[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
SSqlRes * pRes1 = &pSql->pSubs[i]->res;
|
||||
SQueryInfo *pQueryInfo1 = tscGetQueryInfo(&pSql->pSubs[i]->cmd);
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#include "tconfig.h"
|
||||
#include "ttimezone.h"
|
||||
#include "tlocale.h"
|
||||
#include "qScript.h"
|
||||
|
||||
// global, not configurable
|
||||
#define TSC_VAR_NOT_RELEASE 1
|
||||
|
|
@ -148,6 +149,8 @@ void taos_init_imp(void) {
|
|||
taosInitNotes();
|
||||
|
||||
rpcInit();
|
||||
|
||||
scriptEnvPoolInit();
|
||||
tscDebug("starting to initialize TAOS client ...");
|
||||
tscDebug("Local End Point is:%s", tsLocalEp);
|
||||
}
|
||||
|
|
@ -202,7 +205,9 @@ void taos_cleanup(void) {
|
|||
if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (tscEmbedded == 0) {
|
||||
scriptEnvPoolCleanup();
|
||||
}
|
||||
taosHashCleanup(tscTableMetaInfo);
|
||||
tscTableMetaInfo = NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -34,54 +34,54 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
|
|||
|
||||
int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *len) {
|
||||
int32_t n = 0;
|
||||
|
||||
|
||||
switch (type) {
|
||||
case TSDB_DATA_TYPE_NULL:
|
||||
n = sprintf(str, "null");
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_BOOL:
|
||||
n = sprintf(str, (*(int8_t*)buf) ? "true" : "false");
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_TINYINT:
|
||||
n = sprintf(str, "%d", *(int8_t*)buf);
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_SMALLINT:
|
||||
n = sprintf(str, "%d", *(int16_t*)buf);
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_INT:
|
||||
n = sprintf(str, "%d", *(int32_t*)buf);
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_BIGINT:
|
||||
case TSDB_DATA_TYPE_TIMESTAMP:
|
||||
n = sprintf(str, "%" PRId64, *(int64_t*)buf);
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_FLOAT:
|
||||
n = sprintf(str, "%f", GET_FLOAT_VAL(buf));
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_DOUBLE:
|
||||
n = sprintf(str, "%f", GET_DOUBLE_VAL(buf));
|
||||
break;
|
||||
|
||||
|
||||
case TSDB_DATA_TYPE_BINARY:
|
||||
case TSDB_DATA_TYPE_NCHAR:
|
||||
if (bufSize < 0) {
|
||||
tscError("invalid buf size");
|
||||
return TSDB_CODE_TSC_INVALID_VALUE;
|
||||
}
|
||||
|
||||
|
||||
*str = '"';
|
||||
memcpy(str + 1, buf, bufSize);
|
||||
*(str + bufSize + 1) = '"';
|
||||
n = bufSize + 2;
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
tscError("unsupported type:%d", type);
|
||||
return TSDB_CODE_TSC_INVALID_VALUE;
|
||||
|
|
@ -216,6 +216,15 @@ bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex) {
|
|||
for (int32_t i = 0; i < numOfExprs; ++i) {
|
||||
int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
|
||||
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId != TSDB_FUNC_PRJ &&
|
||||
functionId != TSDB_FUNC_TAGPRJ &&
|
||||
functionId != TSDB_FUNC_TAG &&
|
||||
|
|
@ -266,6 +275,16 @@ bool tscIsProjectionQuery(SQueryInfo* pQueryInfo) {
|
|||
f != TSDB_FUNC_DERIVATIVE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (f < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * f - 1);
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
|
|
@ -297,7 +316,7 @@ bool tscHasColumnFilter(SQueryInfo* pQueryInfo) {
|
|||
|
||||
size_t size = taosArrayGetSize(pQueryInfo->colList);
|
||||
for (int32_t i = 0; i < size; ++i) {
|
||||
SColumn* pCol = taosArrayGet(pQueryInfo->colList, i);
|
||||
SColumn* pCol = taosArrayGetP(pQueryInfo->colList, i);
|
||||
if (pCol->info.flist.numOfFilters > 0) {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -338,6 +357,10 @@ bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo) {
|
|||
}
|
||||
}
|
||||
|
||||
if (tscIsProjectionQuery(pQueryInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -526,6 +549,15 @@ bool isSimpleAggregateRv(SQueryInfo* pQueryInfo) {
|
|||
}
|
||||
|
||||
int32_t functionId = pExpr->base.functionId;
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
return true;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY) {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -1186,7 +1218,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
|
|||
SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilterInfo, numOfFilterCols);
|
||||
|
||||
pOutput->precision = pSqlObjList[0]->res.precision;
|
||||
|
||||
|
||||
SSchema* schema = NULL;
|
||||
if (px->numOfTables > 1) {
|
||||
SOperatorInfo** p = calloc(px->numOfTables, POINTER_BYTES);
|
||||
|
|
@ -1302,6 +1334,12 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
|
|||
tfree(pUpQueryInfo);
|
||||
}
|
||||
|
||||
if (pQueryInfo->udfCopy) {
|
||||
pQueryInfo->pUdfInfo = taosArrayDestroy(pQueryInfo->pUdfInfo);
|
||||
} else {
|
||||
pQueryInfo->pUdfInfo = tscDestroyUdfArrayList(pQueryInfo->pUdfInfo);
|
||||
}
|
||||
|
||||
freeQueryInfoImpl(pQueryInfo);
|
||||
clearAllTableMetaInfo(pQueryInfo, removeMeta);
|
||||
|
||||
|
|
@ -1535,6 +1573,47 @@ void* tscDestroyBlockArrayList(SArray* pDataBlockList) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
void freeUdfInfo(SUdfInfo* pUdfInfo) {
|
||||
if (pUdfInfo == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY]) {
|
||||
(*(udfDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(&pUdfInfo->init);
|
||||
}
|
||||
|
||||
tfree(pUdfInfo->name);
|
||||
|
||||
if (pUdfInfo->path) {
|
||||
unlink(pUdfInfo->path);
|
||||
}
|
||||
|
||||
tfree(pUdfInfo->path);
|
||||
|
||||
tfree(pUdfInfo->content);
|
||||
|
||||
taosCloseDll(pUdfInfo->handle);
|
||||
}
|
||||
|
||||
|
||||
void* tscDestroyUdfArrayList(SArray* pUdfList) {
|
||||
if (pUdfList == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
size_t size = taosArrayGetSize(pUdfList);
|
||||
for (int32_t i = 0; i < size; i++) {
|
||||
SUdfInfo* udf = taosArrayGet(pUdfList, i);
|
||||
freeUdfInfo(udf);
|
||||
}
|
||||
|
||||
taosArrayDestroy(pUdfList);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void* tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta) {
|
||||
if (pBlockHashTable == NULL) {
|
||||
return NULL;
|
||||
|
|
@ -1782,7 +1861,7 @@ static void extractTableNameList(SInsertStatementParam *pInsertParam, bool freeB
|
|||
}
|
||||
|
||||
int32_t tscMergeTableDataBlocks(SInsertStatementParam *pInsertParam, bool freeBlockMap) {
|
||||
const int INSERT_HEAD_SIZE = sizeof(SMsgDesc) + sizeof(SSubmitMsg);
|
||||
const int INSERT_HEAD_SIZE = sizeof(SMsgDesc) + sizeof(SSubmitMsg);
|
||||
|
||||
void* pVnodeDataBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
|
||||
SArray* pVnodeDataBlockList = taosArrayInit(8, POINTER_BYTES);
|
||||
|
|
@ -2126,7 +2205,7 @@ void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArr
|
|||
assert(pfield->pExpr->pExpr != NULL);
|
||||
p.pExpr = calloc(1, sizeof(SExprInfo));
|
||||
tscExprAssign(p.pExpr, pfield->pExpr);
|
||||
}
|
||||
}
|
||||
|
||||
taosArrayPush(pFieldInfo->internalField, &p);
|
||||
}
|
||||
|
|
@ -2985,8 +3064,9 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
|
|||
pQueryInfo->tsBuf = NULL;
|
||||
pQueryInfo->fillType = pSrc->fillType;
|
||||
pQueryInfo->fillVal = NULL;
|
||||
pQueryInfo->numOfFillVal = 0;;
|
||||
pQueryInfo->clauseLimit = pSrc->clauseLimit;
|
||||
pQueryInfo->prjOffset = pSrc->prjOffset;
|
||||
pQueryInfo->prjOffset = pSrc->prjOffset;
|
||||
pQueryInfo->numOfTables = 0;
|
||||
pQueryInfo->window = pSrc->window;
|
||||
pQueryInfo->sessionWindow = pSrc->sessionWindow;
|
||||
|
|
@ -3020,11 +3100,12 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
|
|||
}
|
||||
|
||||
if (pSrc->fillType != TSDB_FILL_NONE) {
|
||||
pQueryInfo->fillVal = malloc(pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
pQueryInfo->fillVal = calloc(1, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
if (pQueryInfo->fillVal == NULL) {
|
||||
code = TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
goto _error;
|
||||
}
|
||||
pQueryInfo->numOfFillVal = pSrc->fieldsInfo.numOfOutput;
|
||||
|
||||
memcpy(pQueryInfo->fillVal, pSrc->fillVal, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
}
|
||||
|
|
@ -3056,6 +3137,14 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
|
|||
tscAddTableMetaInfo(pQueryInfo, &p1->name, pMeta, p1->vgroupList, p1->tagColList, p1->pVgroupTables);
|
||||
}
|
||||
|
||||
SArray *pUdfInfo = NULL;
|
||||
if (pSrc->pUdfInfo) {
|
||||
pUdfInfo = taosArrayDup(pSrc->pUdfInfo);
|
||||
}
|
||||
|
||||
pQueryInfo->pUdfInfo = pUdfInfo;
|
||||
pQueryInfo->udfCopy = true;
|
||||
|
||||
_error:
|
||||
return code;
|
||||
}
|
||||
|
|
@ -3102,7 +3191,9 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo) {
|
|||
info->vgInfo.epAddr[j].fqdn = strdup(pInfo->vgInfo.epAddr[j].fqdn);
|
||||
}
|
||||
|
||||
info->itemList = taosArrayDup(pInfo->itemList);
|
||||
if (pInfo->itemList) {
|
||||
info->itemList = taosArrayDup(pInfo->itemList);
|
||||
}
|
||||
}
|
||||
|
||||
SArray* tscVgroupTableInfoDup(SArray* pVgroupTables) {
|
||||
|
|
@ -3353,6 +3444,11 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
|
|||
|
||||
SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pnCmd);
|
||||
|
||||
if (pQueryInfo->pUdfInfo) {
|
||||
pNewQueryInfo->pUdfInfo = taosArrayDup(pQueryInfo->pUdfInfo);
|
||||
pNewQueryInfo->udfCopy = true;
|
||||
}
|
||||
|
||||
pNewQueryInfo->command = pQueryInfo->command;
|
||||
pnCmd->active = pNewQueryInfo;
|
||||
|
||||
|
|
@ -3366,11 +3462,13 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
|
|||
pNewQueryInfo->tsBuf = NULL;
|
||||
pNewQueryInfo->fillType = pQueryInfo->fillType;
|
||||
pNewQueryInfo->fillVal = NULL;
|
||||
pNewQueryInfo->numOfFillVal = 0;
|
||||
pNewQueryInfo->clauseLimit = pQueryInfo->clauseLimit;
|
||||
pNewQueryInfo->prjOffset = pQueryInfo->prjOffset;
|
||||
pNewQueryInfo->numOfTables = 0;
|
||||
pNewQueryInfo->pTableMetaInfo = NULL;
|
||||
pNewQueryInfo->bufLen = pQueryInfo->bufLen;
|
||||
|
||||
pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
|
||||
if (pNewQueryInfo->buf == NULL) {
|
||||
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
|
|
@ -3396,11 +3494,14 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
|
|||
}
|
||||
|
||||
if (pQueryInfo->fillType != TSDB_FILL_NONE) {
|
||||
pNewQueryInfo->fillVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
//just make memory memory sanitizer happy
|
||||
//refator later
|
||||
pNewQueryInfo->fillVal = calloc(1, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
if (pNewQueryInfo->fillVal == NULL) {
|
||||
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
|
||||
goto _error;
|
||||
}
|
||||
pNewQueryInfo->numOfFillVal = pQueryInfo->fieldsInfo.numOfOutput;
|
||||
|
||||
memcpy(pNewQueryInfo->fillVal, pQueryInfo->fillVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
|
||||
}
|
||||
|
|
@ -4210,7 +4311,7 @@ int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaI
|
|||
|
||||
int32_t inter = 0;
|
||||
getResultDataInfo(pSource->base.colType, pSource->base.colBytes, functionId, 0, &pse->resType,
|
||||
&pse->resBytes, &inter, 0, false);
|
||||
&pse->resBytes, &inter, 0, false, NULL);
|
||||
pse->colType = pse->resType;
|
||||
pse->colBytes = pse->resBytes;
|
||||
|
||||
|
|
@ -4277,8 +4378,14 @@ static int32_t createGlobalAggregateExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQu
|
|||
functionId = TSDB_FUNC_STDDEV;
|
||||
}
|
||||
|
||||
SUdfInfo* pUdfInfo = NULL;
|
||||
|
||||
if (functionId < 0) {
|
||||
pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
|
||||
}
|
||||
|
||||
getResultDataInfo(pExpr->base.colType, pExpr->base.colBytes, functionId, 0, &pse->resType, &pse->resBytes, &inter,
|
||||
0, false);
|
||||
0, false, pUdfInfo);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4354,7 +4461,8 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
|
|||
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 {
|
||||
|
|
@ -4420,7 +4528,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
|
|||
|
||||
if (pQueryAttr->fillType != TSDB_FILL_NONE) {
|
||||
pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
|
||||
memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryAttr->numOfOutput * sizeof(int64_t));
|
||||
memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
|
||||
}
|
||||
|
||||
pQueryAttr->srcRowSize = 0;
|
||||
|
|
|
|||
|
|
@ -41,8 +41,10 @@ enum {
|
|||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MGMT, "mgmt" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DB, "create-db" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_TABLE, "create-table" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_FUNCTION, "create-function" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_DB, "drop-db" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_TABLE, "drop-table" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_FUNCTION, "drop-function" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_ACCT, "create-acct" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_USER, "create-user" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_ACCT, "drop-acct" )
|
||||
|
|
@ -74,6 +76,7 @@ enum {
|
|||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_STABLEVGROUP, "stable-vgroup" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MULTI_META, "multi-meta" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_HB, "heart-beat" )
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_FUNC, "retrieve-function" )
|
||||
|
||||
// SQL below for client local
|
||||
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_LOCAL, "local" )
|
||||
|
|
|
|||
|
|
@ -31,6 +31,14 @@ extern "C" {
|
|||
memcpy(varDataVal(x), (str), __len); \
|
||||
} while (0);
|
||||
|
||||
#define STR_TO_NET_VARSTR(x, str) \
|
||||
do { \
|
||||
VarDataLenT __len = (VarDataLenT)strlen(str); \
|
||||
*(VarDataLenT *)(x) = htons(__len); \
|
||||
memcpy(varDataVal(x), (str), __len); \
|
||||
} while (0);
|
||||
|
||||
|
||||
#define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs) \
|
||||
do { \
|
||||
char *_e = stpncpy(varDataVal(x), (str), (_maxs)-VARSTR_HEADER_SIZE); \
|
||||
|
|
|
|||
|
|
@ -18,7 +18,58 @@
|
|||
#include "ttype.h"
|
||||
#include "tutil.h"
|
||||
#include "tarithoperator.h"
|
||||
#include "tcompare.h"
|
||||
|
||||
//GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));
|
||||
#define ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
|
||||
{ \
|
||||
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1; \
|
||||
int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; \
|
||||
\
|
||||
if ((len1) == (len2)) { \
|
||||
for (; i < (len2) && i >= 0; i += step, (out) += 1) { \
|
||||
if (isNull((char *)&((left)[i]), _left_type) || isNull((char *)&((right)[i]), _right_type)) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[i] op(right)[i]; \
|
||||
} \
|
||||
} else if ((len1) == 1) { \
|
||||
for (; i >= 0 && i < (len2); i += step, (out) += 1) { \
|
||||
if (isNull((char *)(left), _left_type) || isNull((char *)&(right)[i], _right_type)) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[0] op(right)[i]; \
|
||||
} \
|
||||
} else if ((len2) == 1) { \
|
||||
for (; i >= 0 && i < (len1); i += step, (out) += 1) { \
|
||||
if (isNull((char *)&(left)[i], _left_type) || isNull((char *)(right), _right_type)) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[i] op(right)[0]; \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
#define ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
|
||||
{ \
|
||||
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1; \
|
||||
|
|
@ -62,6 +113,12 @@
|
|||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[i])) * (right)[i]; \
|
||||
} \
|
||||
} else if (len1 == 1) { \
|
||||
|
|
@ -70,6 +127,12 @@
|
|||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[0] - ((int64_t)(((double)(left)[0]) / (right)[i])) * (right)[i]; \
|
||||
} \
|
||||
} else if ((len2) == 1) { \
|
||||
|
|
@ -78,6 +141,12 @@
|
|||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
double v, z = 0.0; \
|
||||
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0])); \
|
||||
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
|
||||
SET_DOUBLE_NULL(out); \
|
||||
continue; \
|
||||
} \
|
||||
*(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[0])) * (right)[0]; \
|
||||
} \
|
||||
} \
|
||||
|
|
@ -90,7 +159,7 @@
|
|||
#define ARRAY_LIST_MULTI(left, right, _left_type, _right_type, len1, len2, out, _ord) \
|
||||
ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, *, TSDB_DATA_TYPE_DOUBLE, _ord)
|
||||
#define ARRAY_LIST_DIV(left, right, _left_type, _right_type, len1, len2, out, _ord) \
|
||||
ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, /, TSDB_DATA_TYPE_DOUBLE, _ord)
|
||||
ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, /, TSDB_DATA_TYPE_DOUBLE, _ord)
|
||||
#define ARRAY_LIST_REM(left, right, _left_type, _right_type, len1, len2, out, _ord) \
|
||||
ARRAY_LIST_OP_REM(left, right, _left_type, _right_type, len1, len2, out, %, TSDB_DATA_TYPE_DOUBLE, _ord)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,54 +1,62 @@
|
|||
# Java Connector
|
||||
|
||||
## TAOS-JDBCDriver 概述
|
||||
TDengine 提供了遵循 JDBC 标准（3.0）API 规范的 `taos-jdbcdriver` 实现，可在 maven 的中央仓库 [Sonatype Repository][1] 搜索下载。
|
||||
|
||||
TDengine 为了方便 Java 应用使用，提供了遵循 JDBC 标准(3.0)API 规范的 `taos-jdbcdriver` 实现。目前可以通过 [Sonatype Repository][1] 搜索并下载。
|
||||
`taos-jdbcdriver` 的实现包括 2 种形式： JDBC-JNI 和 JDBC-RESTful（taos-jdbcdriver-2.0.18 开始支持 JDBC-RESTful）。 JDBC-JNI 通过调用客户端 libtaos.so（或 taos.dll ）的本地方法实现， JDBC-RESTful 则在内部封装了 RESTful 接口实现。
|
||||
|
||||
由于 TDengine 是使用 c 语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
|
||||
|
||||
|
||||
* libtaos.so
|
||||
在 linux 系统中成功安装 TDengine 后，依赖的本地函数库 libtaos.so 文件会被自动拷贝至 /usr/lib/libtaos.so，该目录包含在 Linux 自动扫描路径上，无需单独指定。
|
||||
|
||||
* taos.dll
|
||||
在 windows 系统中安装完客户端之后，驱动包依赖的 taos.dll 文件会自动拷贝到系统默认搜索路径 C:/Windows/System32 下，同样无需要单独指定。
|
||||
|
||||
> 注意：在 windows 环境开发时需要安装 TDengine 对应的 windows 版本客户端，由于目前没有提供 Linux 环境单独的客户端，需要安装 TDengine 才能使用。
|
||||
上图显示了 3 种 Java 应用使用连接器访问 TDengine 的方式：
|
||||
|
||||
TDengine 的 JDBC 驱动实现尽可能的与关系型数据库驱动保持一致，但时序空间数据库与关系对象型数据库服务的对象和技术特征的差异导致 taos-jdbcdriver 并未完全实现 JDBC 标准规范。在使用时需要注意以下几点：
|
||||
* JDBC-JNI：Java 应用在物理节点1（pnode1）上使用 JDBC-JNI 的 API ，直接调用客户端 API（libtaos.so 或 taos.dll）将写入和查询请求发送到位于物理节点2（pnode2）上的 taosd 实例。
|
||||
* RESTful：应用将 SQL 发送给位于物理节点2（pnode2）上的 RESTful 连接器，再调用客户端 API（libtaos.so）。
|
||||
* JDBC-RESTful：Java 应用通过 JDBC-RESTful 的 API ，将 SQL 封装成一个 RESTful 请求，发送给物理节点2的 RESTful 连接器。
|
||||
|
||||
* TDengine 不提供针对单条数据记录的删除和修改的操作，驱动中也没有支持相关方法。
|
||||
* 由于不支持删除和修改，所以也不支持事务操作。
|
||||
* 目前不支持表间的 union 操作。
|
||||
* 目前不支持嵌套查询(nested query)，`对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet还没关闭的情况下执行了新的查询，TSDBJDBCDriver 则会自动关闭上一个 ResultSet`。
|
||||
TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致，但时序空间数据库与关系对象型数据库服务的对象和技术特征存在差异，导致 `taos-jdbcdriver` 与传统的 JDBC driver 也存在一定差异。在使用时需要注意以下几点：
|
||||
|
||||
* TDengine 目前不支持针对单条数据记录的删除操作。
|
||||
* 目前不支持事务操作。
|
||||
* 目前不支持嵌套查询（nested query）。
|
||||
* 对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet 还没关闭的情况下执行了新的查询，taos-jdbcdriver 会自动关闭上一个 ResultSet。
|
||||
|
||||
|
||||
## TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
|
||||
## JDBC-JNI和JDBC-RESTful的对比
|
||||
|
||||
| taos-jdbcdriver 版本 | TDengine 版本 | JDK 版本 |
|
||||
| --- | --- | --- |
|
||||
| 1.0.3 | 1.6.1.x 及以上 | 1.8.x |
|
||||
| 1.0.2 | 1.6.1.x 及以上 | 1.8.x |
|
||||
| 1.0.1 | 1.6.1.x 及以上 | 1.8.x |
|
||||
<table >
|
||||
<tr align="center"><th>对比项</th><th>JDBC-JNI</th><th>JDBC-RESTful</th></tr>
|
||||
<tr align="center">
|
||||
<td>支持的操作系统</td>
|
||||
<td>linux、windows</td>
|
||||
<td>全平台</td>
|
||||
</tr>
|
||||
<tr align="center">
|
||||
<td>是否需要安装 client</td>
|
||||
<td>需要</td>
|
||||
<td>不需要</td>
|
||||
</tr>
|
||||
<tr align="center">
|
||||
<td>server 升级后是否需要升级 client</td>
|
||||
<td>需要</td>
|
||||
<td>不需要</td>
|
||||
</tr>
|
||||
<tr align="center">
|
||||
<td>写入性能</td>
|
||||
<td colspan="2">JDBC-RESTful 是 JDBC-JNI 的 50%～90% </td>
|
||||
</tr>
|
||||
<tr align="center">
|
||||
<td>查询性能</td>
|
||||
<td colspan="2">JDBC-RESTful 与 JDBC-JNI 没有差别</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
## TDengine DataType 和 Java DataType
|
||||
注意：与 JNI 方式不同，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，RESTful 下所有对表名、超级表名的引用都需要指定数据库名前缀。
|
||||
|
||||
TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对应类型转换如下：
|
||||
|
||||
| TDengine DataType | Java DataType |
|
||||
| --- | --- |
|
||||
| TIMESTAMP | java.sql.Timestamp |
|
||||
| INT | java.lang.Integer |
|
||||
| BIGINT | java.lang.Long |
|
||||
| FLOAT | java.lang.Float |
|
||||
| DOUBLE | java.lang.Double |
|
||||
| SMALLINT, TINYINT |java.lang.Short |
|
||||
| BOOL | java.lang.Boolean |
|
||||
| BINARY, NCHAR | java.lang.String |
|
||||
|
||||
## 如何获取 TAOS-JDBCDriver
|
||||
## 如何获取 taos-jdbcdriver
|
||||
|
||||
### maven 仓库
|
||||
|
||||
目前 taos-jdbcdriver 已经发布到 [Sonatype Repository][1] 仓库，且各大仓库都已同步。
|
||||
|
||||
* [sonatype][8]
|
||||
* [mvnrepository][9]
|
||||
* [maven.aliyun][10]
|
||||
|
|
@ -56,56 +64,86 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
|
|||
maven 项目中使用如下 pom.xml 配置即可：
|
||||
|
||||
```xml
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>com.taosdata.jdbc</groupId>
|
||||
<artifactId>taos-jdbcdriver</artifactId>
|
||||
<version>1.0.3</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
<dependency>
|
||||
<groupId>com.taosdata.jdbc</groupId>
|
||||
<artifactId>taos-jdbcdriver</artifactId>
|
||||
<version>2.0.18</version>
|
||||
</dependency>
|
||||
```
|
||||
|
||||
### 源码编译打包
|
||||
|
||||
下载 [TDengine][3] 源码之后，进入 taos-jdbcdriver 源码目录 `src/connector/jdbc` 执行 `mvn clean package` 即可生成相应 jar 包。
|
||||
下载 [TDengine][3] 源码之后，进入 taos-jdbcdriver 源码目录 `src/connector/jdbc` 执行 `mvn clean package -Dmaven.test.skip=true` 即可生成相应 jar 包。
|
||||
|
||||
|
||||
## 使用说明
|
||||
|
||||
## JDBC的使用说明
|
||||
|
||||
### 获取连接
|
||||
|
||||
如下所示配置即可获取 TDengine Connection：
|
||||
#### 指定URL获取连接
|
||||
|
||||
通过指定URL获取连接，如下所示：
|
||||
|
||||
```java
|
||||
Class.forName("com.taosdata.jdbc.TSDBDriver");
|
||||
String jdbcUrl = "jdbc:TAOS://127.0.0.1:6030/log?user=root&password=taosdata";
|
||||
Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
|
||||
String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
|
||||
Connection conn = DriverManager.getConnection(jdbcUrl);
|
||||
```
|
||||
> 端口 6030 为默认连接端口，JDBC URL 中的 log 为系统本身的监控数据库。
|
||||
|
||||
以上示例，使用 **JDBC-RESTful** 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
|
||||
|
||||
使用 JDBC-RESTful 接口，不需要依赖本地函数库。与 JDBC-JNI 相比，仅需要：
|
||||
|
||||
1. driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
|
||||
2. jdbcUrl 以“jdbc:TAOS-RS://”开头；
|
||||
3. 使用 6041 作为连接端口。
|
||||
|
||||
如果希望获得更好的写入和查询性能，Java 应用可以使用 **JDBC-JNI** 的driver，如下所示：
|
||||
|
||||
```java
|
||||
Class.forName("com.taosdata.jdbc.TSDBDriver");
|
||||
String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
|
||||
Connection conn = DriverManager.getConnection(jdbcUrl);
|
||||
```
|
||||
|
||||
以上示例，使用了 JDBC-JNI 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
|
||||
|
||||
**注意**：使用 JDBC-JNI 的 driver，taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
|
||||
|
||||
* libtaos.so
|
||||
在 linux 系统中成功安装 TDengine 后，依赖的本地函数库 libtaos.so 文件会被自动拷贝至 /usr/lib/libtaos.so，该目录包含在 Linux 自动扫描路径上，无需单独指定。
|
||||
|
||||
* taos.dll
|
||||
在 windows 系统中安装完客户端之后，驱动包依赖的 taos.dll 文件会自动拷贝到系统默认搜索路径 C:/Windows/System32 下，同样无需要单独指定。
|
||||
|
||||
> 在 windows 环境开发时需要安装 TDengine 对应的 [windows 客户端][14]，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端][15] 连接远程 TDengine Server。
|
||||
|
||||
JDBC-JNI 的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。
|
||||
|
||||
TDengine 的 JDBC URL 规范格式为：
|
||||
`jdbc:TSDB://{host_ip}:{port}/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
|
||||
|
||||
其中，`{}` 中的内容必须，`[]` 中为可选。配置参数说明如下：
|
||||
`jdbc:[TAOS|TAOS-RS]://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
|
||||
|
||||
url中的配置参数如下：
|
||||
* user：登录 TDengine 用户名，默认值 root。
|
||||
* password：用户登录密码，默认值 taosdata。
|
||||
* charset：客户端使用的字符集，默认值为系统字符集。
|
||||
* cfgdir：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
|
||||
* charset：客户端使用的字符集，默认值为系统字符集。
|
||||
* locale：客户端语言环境，默认值系统当前 locale。
|
||||
* timezone：客户端使用的时区，默认值为系统当前时区。
|
||||
|
||||
以上参数可以在 3 处配置，`优先级由高到低`分别如下：
|
||||
1. JDBC URL 参数
|
||||
如上所述，可以在 JDBC URL 的参数中指定。
|
||||
2. java.sql.DriverManager.getConnection(String jdbcUrl, Properties connProps)
|
||||
|
||||
|
||||
#### 指定URL和Properties获取连接
|
||||
|
||||
除了通过指定的 URL 获取连接，还可以使用 Properties 指定建立连接时的参数，如下所示：
|
||||
```java
|
||||
public Connection getConn() throws Exception{
|
||||
Class.forName("com.taosdata.jdbc.TSDBDriver");
|
||||
String jdbcUrl = "jdbc:TAOS://127.0.0.1:0/log?user=root&password=taosdata";
|
||||
// Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
|
||||
String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
|
||||
// String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
|
||||
Properties connProps = new Properties();
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_CONFIG_DIR, "/etc/taos");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
|
|
@ -114,22 +152,68 @@ public Connection getConn() throws Exception{
|
|||
}
|
||||
```
|
||||
|
||||
3. 客户端配置文件 taos.cfg
|
||||
以上示例，建立一个到 hostname 为 taosdemo.com，端口为 6030，数据库名为 test 的连接。注释为使用 JDBC-RESTful 时的方法。这个连接在 url 中指定了用户名(user)为 root，密码（password）为 taosdata，并在 connProps 中指定了使用的字符集、语言环境、时区等信息。
|
||||
|
||||
linux 系统默认配置文件为 /var/lib/taos/taos.cfg，windows 系统默认配置文件路径为 C:\TDengine\cfg\taos.cfg。
|
||||
```properties
|
||||
# client default username
|
||||
# defaultUser root
|
||||
properties 中的配置参数如下：
|
||||
* TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 root。
|
||||
* TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 taosdata。
|
||||
* TSDBDriver.PROPERTY_KEY_CONFIG_DIR：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
|
||||
* TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
|
||||
* TSDBDriver.PROPERTY_KEY_LOCALE：客户端语言环境，默认值系统当前 locale。
|
||||
* TSDBDriver.PROPERTY_KEY_TIME_ZONE：客户端使用的时区，默认值为系统当前时区。
|
||||
|
||||
# client default password
|
||||
# defaultPass taosdata
|
||||
|
||||
|
||||
#### 使用客户端配置文件建立连接
|
||||
|
||||
当使用 JDBC-JNI 连接 TDengine 集群时，可以使用客户端配置文件，在客户端配置文件中指定集群的 firstEp、secondEp参数。
|
||||
如下所示：
|
||||
|
||||
1. 在 Java 应用中不指定 hostname 和 port
|
||||
|
||||
```java
|
||||
public Connection getConn() throws Exception{
|
||||
Class.forName("com.taosdata.jdbc.TSDBDriver");
|
||||
String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
|
||||
Properties connProps = new Properties();
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
|
||||
return conn;
|
||||
}
|
||||
```
|
||||
|
||||
2. 在配置文件中指定 firstEp 和 secondEp
|
||||
|
||||
```
|
||||
# first fully qualified domain name (FQDN) for TDengine system
|
||||
firstEp cluster_node1:6030
|
||||
|
||||
# second fully qualified domain name (FQDN) for TDengine system, for cluster only
|
||||
secondEp cluster_node2:6030
|
||||
|
||||
# default system charset
|
||||
# charset UTF-8
|
||||
# charset UTF-8
|
||||
|
||||
# system locale
|
||||
# locale en_US.UTF-8
|
||||
```
|
||||
|
||||
以上示例，jdbc 会使用客户端的配置文件，建立到 hostname 为 cluster_node1、端口为 6030、数据库名为 test 的连接。当集群中 firstEp 节点失效时，JDBC 会尝试使用 secondEp 连接集群。
|
||||
TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可以正常建立到集群的连接。
|
||||
|
||||
> 注意：这里的配置文件指的是调用 JDBC Connector 的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值 C://TDengine/cfg/taos.cfg。
|
||||
|
||||
#### 配置参数的优先级
|
||||
|
||||
通过以上 3 种方式获取连接，如果配置参数在 url、Properties、客户端配置文件中有重复，则参数的`优先级由高到低`分别如下：
|
||||
1. JDBC URL 参数，如上所述，可以在 JDBC URL 的参数中指定。
|
||||
2. Properties connProps
|
||||
3. 客户端配置文件 taos.cfg
|
||||
|
||||
例如：在 url 中指定了 password 为 taosdata，在 Properties 中指定了 password 为 taosdemo，那么，JDBC 会使用 url 中的 password 建立连接。
|
||||
|
||||
> 更多详细配置请参考[客户端配置][13]
|
||||
|
||||
### 创建数据库和表
|
||||
|
|
@ -146,6 +230,7 @@ stmt.executeUpdate("use db");
|
|||
// create table
|
||||
stmt.executeUpdate("create table if not exists tb (ts timestamp, temperature int, humidity float)");
|
||||
```
|
||||
|
||||
> 注意：如果不使用 `use db` 指定数据库，则后续对表的操作都需要增加数据库名称作为前缀，如 db.tb。
|
||||
|
||||
### 插入数据
|
||||
|
|
@ -156,6 +241,7 @@ int affectedRows = stmt.executeUpdate("insert into tb values(now, 23, 10.3) (now
|
|||
|
||||
System.out.println("insert " + affectedRows + " rows.");
|
||||
```
|
||||
|
||||
> now 为系统内部函数，默认为服务器当前时间。
|
||||
> `now + 1s` 代表服务器当前时间往后加 1 秒，数字后面代表时间单位：a(毫秒), s(秒), m(分), h(小时), d(天)，w(周), n(月), y(年)。
|
||||
|
||||
|
|
@ -177,8 +263,150 @@ while(resultSet.next()){
|
|||
System.out.printf("%s, %d, %s\n", ts, temperature, humidity);
|
||||
}
|
||||
```
|
||||
|
||||
> 查询和操作关系型数据库一致，使用下标获取返回字段内容时从 1 开始，建议使用字段名称获取。
|
||||
|
||||
### 处理异常
|
||||
|
||||
在报错后，通过SQLException可以获取到错误的信息和错误码：
|
||||
|
||||
```java
|
||||
try (Statement statement = connection.createStatement()) {
|
||||
// executeQuery
|
||||
ResultSet resultSet = statement.executeQuery(sql);
|
||||
// print result
|
||||
printResult(resultSet);
|
||||
} catch (SQLException e) {
|
||||
System.out.println("ERROR Message: " + e.getMessage());
|
||||
System.out.println("ERROR Code: " + e.getErrorCode());
|
||||
e.printStackTrace();
|
||||
}
|
||||
```
|
||||
|
||||
JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（错误码在0x2301到0x2350之间），JNI方法的报错（错误码在0x2351到0x2400之间），TDengine其他功能模块的报错。
|
||||
具体的错误码请参考：
|
||||
* https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
|
||||
* https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
|
||||
|
||||
### <a class="anchor" id="stmt-java"></a>通过参数绑定写入数据
|
||||
|
||||
从 2.1.2.0 版本开始，TDengine 的 **JDBC-JNI** 实现大幅改进了参数绑定方式对数据写入（INSERT）场景的支持。采用这种方式写入数据时，能避免 SQL 语法解析的资源消耗，从而在很多情况下显著提升写入性能。（注意：**JDBC-RESTful** 实现并不提供参数绑定这种使用方式。）
|
||||
|
||||
```java
|
||||
Statement stmt = conn.createStatement();
|
||||
Random r = new Random();
|
||||
|
||||
// INSERT 语句中，VALUES 部分允许指定具体的数据列；如果采取自动建表，则 TAGS 部分需要设定全部 TAGS 列的参数值：
|
||||
TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? using weather_test tags (?, ?) (ts, c1, c2) values(?, ?, ?)");
|
||||
|
||||
// 设定数据表名：
|
||||
s.setTableName("w1");
|
||||
// 设定 TAGS 取值：
|
||||
s.setTagInt(0, r.nextInt(10));
|
||||
s.setTagString(1, "Beijing");
|
||||
|
||||
int numOfRows = 10;
|
||||
|
||||
// VALUES 部分以逐列的方式进行设置：
|
||||
ArrayList<Long> ts = new ArrayList<>();
|
||||
for (int i = 0; i < numOfRows; i++){
|
||||
ts.add(System.currentTimeMillis() + i);
|
||||
}
|
||||
s.setTimestamp(0, ts);
|
||||
|
||||
ArrayList<Integer> s1 = new ArrayList<>();
|
||||
for (int i = 0; i < numOfRows; i++){
|
||||
s1.add(r.nextInt(100));
|
||||
}
|
||||
s.setInt(1, s1);
|
||||
|
||||
ArrayList<String> s2 = new ArrayList<>();
|
||||
for (int i = 0; i < numOfRows; i++){
|
||||
s2.add("test" + r.nextInt(100));
|
||||
}
|
||||
s.setString(2, s2, 10);
|
||||
|
||||
// AddBatch 之后，缓存并未清空。为避免混乱，并不推荐在 ExecuteBatch 之前再次绑定新一批的数据：
|
||||
s.columnDataAddBatch();
|
||||
// 执行绑定数据后的语句：
|
||||
s.columnDataExecuteBatch();
|
||||
// 执行语句后清空缓存。在清空之后，可以复用当前的对象，绑定新的一批数据（可以是新表名、新 TAGS 值、新 VALUES 值）：
|
||||
s.columnDataClearBatch();
|
||||
// 执行完毕，释放资源：
|
||||
s.columnDataCloseBatch();
|
||||
```
|
||||
|
||||
用于设定 TAGS 取值的方法总共有：
|
||||
```java
|
||||
public void setTagNull(int index, int type)
|
||||
public void setTagBoolean(int index, boolean value)
|
||||
public void setTagInt(int index, int value)
|
||||
public void setTagByte(int index, byte value)
|
||||
public void setTagShort(int index, short value)
|
||||
public void setTagLong(int index, long value)
|
||||
public void setTagTimestamp(int index, long value)
|
||||
public void setTagFloat(int index, float value)
|
||||
public void setTagDouble(int index, double value)
|
||||
public void setTagString(int index, String value)
|
||||
public void setTagNString(int index, String value)
|
||||
```
|
||||
|
||||
用于设定 VALUES 数据列的取值的方法总共有：
|
||||
```java
|
||||
public void setInt(int columnIndex, ArrayList<Integer> list) throws SQLException
|
||||
public void setFloat(int columnIndex, ArrayList<Float> list) throws SQLException
|
||||
public void setTimestamp(int columnIndex, ArrayList<Long> list) throws SQLException
|
||||
public void setLong(int columnIndex, ArrayList<Long> list) throws SQLException
|
||||
public void setDouble(int columnIndex, ArrayList<Double> list) throws SQLException
|
||||
public void setBoolean(int columnIndex, ArrayList<Boolean> list) throws SQLException
|
||||
public void setByte(int columnIndex, ArrayList<Byte> list) throws SQLException
|
||||
public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
|
||||
public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
|
||||
public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
|
||||
```
|
||||
其中 setString 和 setNString 都要求用户在 size 参数里声明表定义中对应列的列宽。
|
||||
|
||||
### <a class="anchor" id="subscribe"></a>订阅
|
||||
|
||||
#### 创建
|
||||
|
||||
```java
|
||||
TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from meters", false);
|
||||
```
|
||||
|
||||
`subscribe` 方法的三个参数含义如下：
|
||||
|
||||
* topic：订阅的主题（即名称），此参数是订阅的唯一标识
|
||||
* sql：订阅的查询语句，此语句只能是 `select` 语句，只应查询原始数据，只能按时间正序查询数据
|
||||
* restart：如果订阅已经存在，是重新开始，还是继续之前的订阅
|
||||
|
||||
如上面的例子将使用 SQL 语句 `select * from meters` 创建一个名为 `topic` 的订阅，如果这个订阅已经存在，将继续之前的查询进度，而不是从头开始消费所有的数据。
|
||||
|
||||
#### 消费数据
|
||||
|
||||
```java
|
||||
int total = 0;
|
||||
while(true) {
|
||||
TSDBResultSet rs = sub.consume();
|
||||
int count = 0;
|
||||
while(rs.next()) {
|
||||
count++;
|
||||
}
|
||||
total += count;
|
||||
System.out.printf("%d rows consumed, total %d\n", count, total);
|
||||
Thread.sleep(1000);
|
||||
}
|
||||
```
|
||||
|
||||
`consume` 方法返回一个结果集，其中包含从上次 `consume` 到目前为止的所有新数据。请务必按需选择合理的调用 `consume` 的频率（如例子中的 `Thread.sleep(1000)`），否则会给服务端造成不必要的压力。
|
||||
|
||||
#### 关闭订阅
|
||||
|
||||
```java
|
||||
sub.close(true);
|
||||
```
|
||||
|
||||
`close` 方法关闭一个订阅。如果其参数为 `true` 表示保留订阅进度信息，后续可以创建同名订阅继续消费数据；如为 `false` 则不保留订阅进度。
|
||||
|
||||
### 关闭资源
|
||||
|
||||
|
|
@ -187,12 +415,17 @@ resultSet.close();
|
|||
stmt.close();
|
||||
conn.close();
|
||||
```
|
||||
|
||||
> `注意务必要将 connection 进行关闭`，否则会出现连接泄露。
|
||||
|
||||
|
||||
|
||||
## 与连接池使用
|
||||
|
||||
**HikariCP**
|
||||
|
||||
* 引入相应 HikariCP maven 依赖：
|
||||
|
||||
```xml
|
||||
<dependency>
|
||||
<groupId>com.zaxxer</groupId>
|
||||
|
|
@ -202,31 +435,34 @@ conn.close();
|
|||
```
|
||||
|
||||
* 使用示例如下：
|
||||
|
||||
```java
|
||||
public static void main(String[] args) throws SQLException {
|
||||
HikariConfig config = new HikariConfig();
|
||||
// jdbc properties
|
||||
config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/log");
|
||||
config.setUsername("root");
|
||||
config.setPassword("taosdata");
|
||||
|
||||
config.setMinimumIdle(3); //minimum number of idle connection
|
||||
// connection pool configurations
|
||||
config.setMinimumIdle(10); //minimum number of idle connection
|
||||
config.setMaximumPoolSize(10); //maximum number of connection in the pool
|
||||
config.setConnectionTimeout(10000); //maximum wait milliseconds for get connection from pool
|
||||
config.setIdleTimeout(60000); // max idle time for recycle idle connection
|
||||
config.setConnectionTestQuery("describe log.dn"); //validation query
|
||||
config.setValidationTimeout(3000); //validation query timeout
|
||||
config.setConnectionTimeout(30000); //maximum wait milliseconds for get connection from pool
|
||||
config.setMaxLifetime(0); // maximum life time for each connection
|
||||
config.setIdleTimeout(0); // max idle time for recycle idle connection
|
||||
config.setConnectionTestQuery("select server_status()"); //validation query
|
||||
|
||||
HikariDataSource ds = new HikariDataSource(config); //create datasource
|
||||
|
||||
|
||||
Connection connection = ds.getConnection(); // get connection
|
||||
Statement statement = connection.createStatement(); // get statement
|
||||
|
||||
//query or insert
|
||||
|
||||
//query or insert
|
||||
// ...
|
||||
|
||||
|
||||
connection.close(); // put back to conneciton pool
|
||||
}
|
||||
```
|
||||
|
||||
> 通过 HikariDataSource.getConnection() 获取连接后，使用完成后需要调用 close() 方法，实际上它并不会关闭连接，只是放回连接池中。
|
||||
> 更多 HikariCP 使用问题请查看[官方说明][5]
|
||||
|
||||
|
|
@ -243,40 +479,32 @@ conn.close();
|
|||
```
|
||||
|
||||
* 使用示例如下：
|
||||
|
||||
```java
|
||||
public static void main(String[] args) throws Exception {
|
||||
Properties properties = new Properties();
|
||||
properties.put("driverClassName","com.taosdata.jdbc.TSDBDriver");
|
||||
properties.put("url","jdbc:TAOS://127.0.0.1:6030/log");
|
||||
properties.put("username","root");
|
||||
properties.put("password","taosdata");
|
||||
|
||||
properties.put("maxActive","10"); //maximum number of connection in the pool
|
||||
properties.put("initialSize","3");//initial number of connection
|
||||
properties.put("maxWait","10000");//maximum wait milliseconds for get connection from pool
|
||||
properties.put("minIdle","3");//minimum number of connection in the pool
|
||||
|
||||
properties.put("timeBetweenEvictionRunsMillis","3000");// the interval milliseconds to test connection
|
||||
|
||||
properties.put("minEvictableIdleTimeMillis","60000");//the minimum milliseconds to keep idle
|
||||
properties.put("maxEvictableIdleTimeMillis","90000");//the maximum milliseconds to keep idle
|
||||
|
||||
properties.put("validationQuery","describe log.dn"); //validation query
|
||||
properties.put("testWhileIdle","true"); // test connection while idle
|
||||
properties.put("testOnBorrow","false"); // don't need while testWhileIdle is true
|
||||
properties.put("testOnReturn","false"); // don't need while testWhileIdle is true
|
||||
|
||||
//create druid datasource
|
||||
DataSource ds = DruidDataSourceFactory.createDataSource(properties);
|
||||
Connection connection = ds.getConnection(); // get connection
|
||||
DruidDataSource dataSource = new DruidDataSource();
|
||||
// jdbc properties
|
||||
dataSource.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
|
||||
dataSource.setUrl(url);
|
||||
dataSource.setUsername("root");
|
||||
dataSource.setPassword("taosdata");
|
||||
// pool configurations
|
||||
dataSource.setInitialSize(10);
|
||||
dataSource.setMinIdle(10);
|
||||
dataSource.setMaxActive(10);
|
||||
dataSource.setMaxWait(30000);
|
||||
dataSource.setValidationQuery("select server_status()");
|
||||
|
||||
Connection connection = dataSource.getConnection(); // get connection
|
||||
Statement statement = connection.createStatement(); // get statement
|
||||
|
||||
//query or insert
|
||||
// ...
|
||||
|
||||
connection.close(); // put back to conneciton pool
|
||||
}
|
||||
```
|
||||
|
||||
> 更多 druid 使用问题请查看[官方说明][6]
|
||||
|
||||
**注意事项**
|
||||
|
|
@ -291,29 +519,64 @@ server_status()|
|
|||
Query OK, 1 row(s) in set (0.000141s)
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 与框架使用
|
||||
|
||||
* Spring JdbcTemplate 中使用 taos-jdbcdriver，可参考 [SpringJdbcTemplate][11]
|
||||
* Springboot + Mybatis 中使用，可参考 [springbootdemo][12]
|
||||
|
||||
|
||||
|
||||
## <a class="anchor" id="version"></a>TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
|
||||
|
||||
| taos-jdbcdriver 版本 | TDengine 版本 | JDK 版本 |
|
||||
| -------------------- | ----------------- | -------- |
|
||||
| 2.0.31 | 2.1.3.0 及以上 | 1.8.x |
|
||||
| 2.0.22 - 2.0.30 | 2.0.18.0 - 2.1.2.x | 1.8.x |
|
||||
| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.x | 1.8.x |
|
||||
| 2.0.4 - 2.0.11 | 2.0.0.0 - 2.0.7.x | 1.8.x |
|
||||
| 1.0.3 | 1.6.1.x 及以上 | 1.8.x |
|
||||
| 1.0.2 | 1.6.1.x 及以上 | 1.8.x |
|
||||
| 1.0.1 | 1.6.1.x 及以上 | 1.8.x |
|
||||
|
||||
|
||||
|
||||
## TDengine DataType 和 Java DataType
|
||||
|
||||
TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对应类型转换如下：
|
||||
|
||||
| TDengine DataType | Java DataType |
|
||||
| ----------------- | ------------------ |
|
||||
| TIMESTAMP | java.sql.Timestamp |
|
||||
| INT | java.lang.Integer |
|
||||
| BIGINT | java.lang.Long |
|
||||
| FLOAT | java.lang.Float |
|
||||
| DOUBLE | java.lang.Double |
|
||||
| SMALLINT | java.lang.Short |
|
||||
| TINYINT | java.lang.Byte |
|
||||
| BOOL | java.lang.Boolean |
|
||||
| BINARY | byte array |
|
||||
| NCHAR | java.lang.String |
|
||||
|
||||
|
||||
|
||||
## 常见问题
|
||||
|
||||
* java.lang.UnsatisfiedLinkError: no taos in java.library.path
|
||||
|
||||
|
||||
**原因**：程序没有找到依赖的本地函数库 taos。
|
||||
|
||||
**解决方法**：windows 下可以将 C:\TDengine\driver\taos.dll 拷贝到 C:\Windows\System32\ 目录下，linux 下将建立如下软链 ` ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so` 即可。
|
||||
|
||||
|
||||
**解决方法**：windows 下可以将 C:\TDengine\driver\taos.dll 拷贝到 C:\Windows\System32\ 目录下，linux 下将建立如下软链 `ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so` 即可。
|
||||
|
||||
* java.lang.UnsatisfiedLinkError: taos.dll Can't load AMD 64 bit on a IA 32-bit platform
|
||||
|
||||
|
||||
**原因**：目前 TDengine 只支持 64 位 JDK。
|
||||
|
||||
|
||||
**解决方法**：重新安装 64 位 JDK。
|
||||
|
||||
* 其它问题请参考 [Issues][7]
|
||||
|
||||
|
||||
|
||||
[1]: https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver
|
||||
[2]: https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver
|
||||
[3]: https://github.com/taosdata/TDengine
|
||||
|
|
@ -324,6 +587,9 @@ Query OK, 1 row(s) in set (0.000141s)
|
|||
[8]: https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver
|
||||
[9]: https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver
|
||||
[10]: https://maven.aliyun.com/mvn/search
|
||||
[11]: https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/SpringJdbcTemplate
|
||||
[11]: https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/SpringJdbcTemplate
|
||||
[12]: https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/springbootdemo
|
||||
[13]: https://www.taosdata.com/cn/documentation/administrator/#%E5%AE%A2%E6%88%B7%E7%AB%AF%E9%85%8D%E7%BD%AE
|
||||
[13]: https://www.taosdata.com/cn/documentation/administrator/#client
|
||||
[14]: https://www.taosdata.com/cn/all-downloads/#TDengine-Windows-Client
|
||||
[15]: https://www.taosdata.com/cn/getting-started/#%E5%AE%A2%E6%88%B7%E7%AB%AF
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package com.taosdata.jdbc;
|
|||
|
||||
import java.sql.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public abstract class AbstractStatement extends WrapperImpl implements Statement {
|
||||
|
|
@ -196,13 +197,44 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
|
|||
if (batchedArgs == null || batchedArgs.isEmpty())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_BATCH_IS_EMPTY);
|
||||
|
||||
String clientInfo = getConnection().getClientInfo(TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE);
|
||||
boolean batchErrorIgnore = clientInfo == null ? TSDBConstants.DEFAULT_BATCH_ERROR_IGNORE : Boolean.parseBoolean(clientInfo);
|
||||
|
||||
if (batchErrorIgnore) {
|
||||
return executeBatchIgnoreException();
|
||||
}
|
||||
return executeBatchThrowException();
|
||||
}
|
||||
|
||||
private int[] executeBatchIgnoreException() {
|
||||
return batchedArgs.stream().mapToInt(sql -> {
|
||||
try {
|
||||
boolean isSelect = execute(sql);
|
||||
if (isSelect) {
|
||||
return SUCCESS_NO_INFO;
|
||||
} else {
|
||||
return getUpdateCount();
|
||||
}
|
||||
} catch (SQLException e) {
|
||||
return EXECUTE_FAILED;
|
||||
}
|
||||
}).toArray();
|
||||
}
|
||||
|
||||
private int[] executeBatchThrowException() throws BatchUpdateException {
|
||||
int[] res = new int[batchedArgs.size()];
|
||||
for (int i = 0; i < batchedArgs.size(); i++) {
|
||||
boolean isSelect = execute(batchedArgs.get(i));
|
||||
if (isSelect) {
|
||||
res[i] = SUCCESS_NO_INFO;
|
||||
} else {
|
||||
res[i] = getUpdateCount();
|
||||
try {
|
||||
boolean isSelect = execute(batchedArgs.get(i));
|
||||
if (isSelect) {
|
||||
res[i] = SUCCESS_NO_INFO;
|
||||
} else {
|
||||
res[i] = getUpdateCount();
|
||||
}
|
||||
} catch (SQLException e) {
|
||||
String reason = e.getMessage();
|
||||
int[] updateCounts = Arrays.copyOfRange(res, 0, i);
|
||||
throw new BatchUpdateException(reason, updateCounts, e);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
|
|
|
|||
|
|
@ -74,6 +74,8 @@ public abstract class TSDBConstants {
|
|||
|
||||
public static final String DEFAULT_PRECISION = "ms";
|
||||
|
||||
public static final boolean DEFAULT_BATCH_ERROR_IGNORE = false;
|
||||
|
||||
public static int typeName2JdbcType(String type) {
|
||||
switch (type.toUpperCase()) {
|
||||
case "TIMESTAMP":
|
||||
|
|
|
|||
|
|
@ -100,6 +100,11 @@ public class TSDBDriver extends AbstractDriver {
|
|||
*/
|
||||
public static final String PROPERTY_KEY_TIMESTAMP_FORMAT = "timestampFormat";
|
||||
|
||||
/**
|
||||
* continue process commands in executeBatch
|
||||
*/
|
||||
public static final String PROPERTY_KEY_BATCH_ERROR_IGNORE = "batchErrorIgnore";
|
||||
|
||||
private TSDBDatabaseMetaData dbMetaData = null;
|
||||
|
||||
static {
|
||||
|
|
|
|||
|
|
@ -841,13 +841,13 @@ public class TSDBPreparedStatementTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void setBytes() throws SQLException, IOException {
|
||||
public void setBytes() throws SQLException {
|
||||
// given
|
||||
long ts = System.currentTimeMillis();
|
||||
byte[] f8 = "{\"name\": \"john\", \"age\": 10, \"address\": \"192.168.1.100\"}".getBytes();
|
||||
|
||||
// when
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(ts));
|
||||
pstmt_insert.setBytes(9, f8);
|
||||
int result = pstmt_insert.executeUpdate();
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,144 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
import org.junit.*;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.stream.IntStream;
|
||||
|
||||
public class BatchErrorIgnoreTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
|
||||
@Test
|
||||
public void batchErrorThrowException() throws SQLException {
|
||||
// given
|
||||
Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
|
||||
|
||||
// when
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
IntStream.range(1, 6).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + ")").forEach(sql -> {
|
||||
try {
|
||||
stmt.addBatch(sql);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
stmt.addBatch("insert into t11 values(now, 11)");
|
||||
IntStream.range(6, 11).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + "),(now + 1s, " + (10 * i) + ")").forEach(sql -> {
|
||||
try {
|
||||
stmt.addBatch(sql);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
stmt.addBatch("select count(*) from test.weather");
|
||||
|
||||
stmt.executeBatch();
|
||||
} catch (BatchUpdateException e) {
|
||||
int[] updateCounts = e.getUpdateCounts();
|
||||
Assert.assertEquals(5, updateCounts.length);
|
||||
Assert.assertEquals(1, updateCounts[0]);
|
||||
Assert.assertEquals(1, updateCounts[1]);
|
||||
Assert.assertEquals(1, updateCounts[2]);
|
||||
Assert.assertEquals(1, updateCounts[3]);
|
||||
Assert.assertEquals(1, updateCounts[4]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void batchErrorIgnore() throws SQLException {
|
||||
// given
|
||||
Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata&batchErrorIgnore=true");
|
||||
|
||||
// when
|
||||
int[] results = null;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
IntStream.range(1, 6).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + ")").forEach(sql -> {
|
||||
try {
|
||||
stmt.addBatch(sql);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
stmt.addBatch("insert into t11 values(now, 11)");
|
||||
IntStream.range(6, 11).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + "),(now + 1s, " + (10 * i) + ")").forEach(sql -> {
|
||||
try {
|
||||
stmt.addBatch(sql);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
stmt.addBatch("select count(*) from test.weather");
|
||||
|
||||
results = stmt.executeBatch();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
// then
|
||||
assert results != null;
|
||||
Assert.assertEquals(12, results.length);
|
||||
Assert.assertEquals(1, results[0]);
|
||||
Assert.assertEquals(1, results[1]);
|
||||
Assert.assertEquals(1, results[2]);
|
||||
Assert.assertEquals(1, results[3]);
|
||||
Assert.assertEquals(1, results[4]);
|
||||
Assert.assertEquals(Statement.EXECUTE_FAILED, results[5]);
|
||||
Assert.assertEquals(2, results[6]);
|
||||
Assert.assertEquals(2, results[7]);
|
||||
Assert.assertEquals(2, results[8]);
|
||||
Assert.assertEquals(2, results[9]);
|
||||
Assert.assertEquals(2, results[10]);
|
||||
Assert.assertEquals(Statement.SUCCESS_NO_INFO, results[11]);
|
||||
}
|
||||
|
||||
@Before
|
||||
public void before() {
|
||||
try {
|
||||
Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
|
||||
Statement stmt = conn.createStatement();
|
||||
stmt.execute("use test");
|
||||
stmt.execute("drop table if exists weather");
|
||||
stmt.execute("create table weather (ts timestamp, f1 float) tags(t1 int)");
|
||||
IntStream.range(1, 11).mapToObj(i -> "create table t" + i + " using weather tags(" + i + ")").forEach(sql -> {
|
||||
try {
|
||||
stmt.execute(sql);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
stmt.close();
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() {
|
||||
try {
|
||||
Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
|
||||
Statement stmt = conn.createStatement();
|
||||
stmt.execute("drop database if exists test");
|
||||
stmt.execute("create database if not exists test");
|
||||
stmt.close();
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() {
|
||||
try {
|
||||
Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
|
||||
Statement stmt = conn.createStatement();
|
||||
stmt.execute("drop database if exists test");
|
||||
stmt.close();
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -18,7 +18,7 @@ ELSE ()
|
|||
ENDIF ()
|
||||
|
||||
ADD_EXECUTABLE(taosd ${SRC})
|
||||
TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync ${LINK_JEMALLOC})
|
||||
TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lua lz4 balance sync ${LINK_JEMALLOC})
|
||||
|
||||
IF (TD_SOMODE_STATIC)
|
||||
TARGET_LINK_LIBRARIES(taosd taos_static)
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@
|
|||
#include "dnodeShell.h"
|
||||
#include "dnodeTelemetry.h"
|
||||
#include "module.h"
|
||||
#include "qScript.h"
|
||||
#include "mnode.h"
|
||||
|
||||
#if !defined(_MODULE) || !defined(_TD_LINUX)
|
||||
|
|
@ -84,6 +85,7 @@ static SStep tsDnodeSteps[] = {
|
|||
{"dnode-shell", dnodeInitShell, dnodeCleanupShell},
|
||||
{"dnode-statustmr", dnodeInitStatusTimer,dnodeCleanupStatusTimer},
|
||||
{"dnode-telemetry", dnodeInitTelemetry, dnodeCleanupTelemetry},
|
||||
{"dnode-script", scriptEnvPoolInit, scriptEnvPoolCleanup},
|
||||
};
|
||||
|
||||
static SStep tsDnodeCompactSteps[] = {
|
||||
|
|
@ -266,7 +268,7 @@ static int32_t dnodeInitStorage() {
|
|||
return -1;
|
||||
}
|
||||
}
|
||||
//TODO(dengyihao): no need to init here
|
||||
//TODO(dengyihao): no need to init here
|
||||
if (dnodeCreateDir(tsMnodeDir) < 0) {
|
||||
dError("failed to create dir: %s, reason: %s", tsMnodeDir, strerror(errno));
|
||||
return -1;
|
||||
|
|
|
|||
|
|
@ -48,9 +48,11 @@ int32_t dnodeInitShell() {
|
|||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = dnodeDispatchToMWriteQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= dnodeDispatchToMWriteQueue;
|
||||
|
|
@ -72,6 +74,7 @@ int32_t dnodeInitShell() {
|
|||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = dnodeDispatchToMReadQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = dnodeDispatchToMReadQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = dnodeDispatchToMReadQueue;
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = dnodeDispatchToMReadQueue;
|
||||
|
||||
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dnodeSendStartupStep;
|
||||
|
||||
|
|
|
|||
|
|
@ -202,12 +202,12 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
|
|||
for (int32_t i = 0; i < numOfMsgs; ++i) {
|
||||
taosGetQitem(pWorker->qall, &qtype, (void **)&pWrite);
|
||||
dTrace("msg:%p, app:%p type:%s will be processed in vwrite queue, qtype:%s hver:%" PRIu64, pWrite,
|
||||
pWrite->rpcMsg.ahandle, taosMsg[pWrite->pHead.msgType], qtypeStr[qtype], pWrite->pHead.version);
|
||||
pWrite->rpcMsg.ahandle, taosMsg[pWrite->walHead.msgType], qtypeStr[qtype], pWrite->walHead.version);
|
||||
|
||||
pWrite->code = vnodeProcessWrite(pVnode, &pWrite->pHead, qtype, pWrite);
|
||||
pWrite->code = vnodeProcessWrite(pVnode, &pWrite->walHead, qtype, pWrite);
|
||||
if (pWrite->code <= 0) atomic_add_fetch_32(&pWrite->processedCount, 1);
|
||||
if (pWrite->code > 0) pWrite->code = 0;
|
||||
if (pWrite->code == 0 && pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;
|
||||
if (pWrite->code == 0 && pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;
|
||||
|
||||
dTrace("msg:%p is processed in vwrite queue, code:0x%x", pWrite, pWrite->code);
|
||||
}
|
||||
|
|
@ -222,7 +222,7 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
|
|||
dnodeSendRpcVWriteRsp(pVnode, pWrite, pWrite->code);
|
||||
} else {
|
||||
if (qtype == TAOS_QTYPE_FWD) {
|
||||
vnodeConfirmForward(pVnode, pWrite->pHead.version, pWrite->code, pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT);
|
||||
vnodeConfirmForward(pVnode, pWrite->walHead.version, pWrite->code, pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT);
|
||||
}
|
||||
if (pWrite->rspRet.rsp) {
|
||||
rpcFreeCont(pWrite->rspRet.rsp);
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ typedef void* qinfo_t;
|
|||
* @param qinfo
|
||||
* @return
|
||||
*/
|
||||
int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryTableMsg, qinfo_t* qinfo, uint64_t *qId);
|
||||
int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryTableMsg, qinfo_t* qinfo, uint64_t qId);
|
||||
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -186,6 +186,10 @@ do { \
|
|||
#define TSDB_NODE_NAME_LEN 64
|
||||
#define TSDB_TABLE_NAME_LEN 193 // it is a null-terminated string
|
||||
#define TSDB_DB_NAME_LEN 33
|
||||
#define TSDB_FUNC_NAME_LEN 65
|
||||
#define TSDB_FUNC_CODE_LEN (65535 - 512)
|
||||
#define TSDB_FUNC_BUF_SIZE 512
|
||||
#define TSDB_TYPE_STR_MAX_LEN 32
|
||||
#define TSDB_TABLE_FNAME_LEN (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_TABLE_NAME_LEN)
|
||||
#define TSDB_COL_NAME_LEN 65
|
||||
#define TSDB_MAX_SAVED_SQL_LEN TSDB_MAX_COLUMNS * 64
|
||||
|
|
@ -332,6 +336,10 @@ do { \
|
|||
#define TSDB_QUERY_TYPE_NON_TYPE 0x00u // none type
|
||||
#define TSDB_QUERY_TYPE_FREE_RESOURCE 0x01u // free qhandle at vnode
|
||||
|
||||
#define TSDB_UDF_TYPE_SCALAR 1
|
||||
#define TSDB_UDF_TYPE_AGGREGATE 2
|
||||
|
||||
|
||||
/*
|
||||
* 1. ordinary sub query for select * from super_table
|
||||
* 2. all sqlobj generated by createSubqueryObj with this flag
|
||||
|
|
|
|||
|
|
@ -100,6 +100,7 @@ int32_t* taosGetErrno();
|
|||
#define TSDB_CODE_TSC_DB_NOT_SELECTED TAOS_DEF_ERROR_CODE(0, 0x0217) //"Database not specified or available")
|
||||
#define TSDB_CODE_TSC_INVALID_TABLE_NAME TAOS_DEF_ERROR_CODE(0, 0x0218) //"Table does not exist")
|
||||
#define TSDB_CODE_TSC_EXCEED_SQL_LIMIT TAOS_DEF_ERROR_CODE(0, 0x0219) //"SQL statement too long check maxSQLLength config")
|
||||
#define TSDB_CODE_TSC_FILE_EMPTY TAOS_DEF_ERROR_CODE(0, 0x021A) //"File is empty")
|
||||
|
||||
// mnode
|
||||
#define TSDB_CODE_MND_MSG_NOT_PROCESSED TAOS_DEF_ERROR_CODE(0, 0x0300) //"Message not processed")
|
||||
|
|
@ -174,6 +175,13 @@ int32_t* taosGetErrno();
|
|||
#define TSDB_CODE_MND_INVALID_STABLE_NAME TAOS_DEF_ERROR_CODE(0, 0x036D) //"Super table does not exist")
|
||||
#define TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG TAOS_DEF_ERROR_CODE(0, 0x036E) //"Invalid create table message")
|
||||
|
||||
#define TSDB_CODE_MND_INVALID_FUNC_NAME TAOS_DEF_ERROR_CODE(0, 0x0370) //"Invalid func name")
|
||||
#define TSDB_CODE_MND_INVALID_FUNC_LEN TAOS_DEF_ERROR_CODE(0, 0x0371) //"Invalid func length")
|
||||
#define TSDB_CODE_MND_INVALID_FUNC_CODE TAOS_DEF_ERROR_CODE(0, 0x0372) //"Invalid func code")
|
||||
#define TSDB_CODE_MND_FUNC_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0373) //"Func already exists")
|
||||
#define TSDB_CODE_MND_INVALID_FUNC TAOS_DEF_ERROR_CODE(0, 0x0374) //"Invalid func")
|
||||
#define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE TAOS_DEF_ERROR_CODE(0, 0x0375) //"Invalid func bufSize")
|
||||
|
||||
#define TSDB_CODE_MND_DB_NOT_SELECTED TAOS_DEF_ERROR_CODE(0, 0x0380) //"Database not specified or available")
|
||||
#define TSDB_CODE_MND_DB_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0381) //"Database already exists")
|
||||
#define TSDB_CODE_MND_INVALID_DB_OPTION TAOS_DEF_ERROR_CODE(0, 0x0382) //"Invalid database options")
|
||||
|
|
@ -261,6 +269,7 @@ int32_t* taosGetErrno();
|
|||
#define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW TAOS_DEF_ERROR_CODE(0, 0x070A) //"Too many time window in query")
|
||||
#define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER TAOS_DEF_ERROR_CODE(0, 0x070B) //"Query buffer limit has reached")
|
||||
#define TSDB_CODE_QRY_INCONSISTAN TAOS_DEF_ERROR_CODE(0, 0x070C) //"File inconsistency in replica")
|
||||
#define TSDB_CODE_QRY_SYS_ERROR TAOS_DEF_ERROR_CODE(0, 0x070D) //"System error")
|
||||
|
||||
|
||||
// grant
|
||||
|
|
@ -395,6 +404,8 @@ int32_t* taosGetErrno();
|
|||
#define TSDB_CODE_HTTP_OP_VALUE_NULL TAOS_DEF_ERROR_CODE(0, 0x11A5) //"value not find")
|
||||
#define TSDB_CODE_HTTP_OP_VALUE_TYPE TAOS_DEF_ERROR_CODE(0, 0x11A6) //"value type should be boolean number or string")
|
||||
|
||||
#define TSDB_CODE_HTTP_REQUEST_JSON_ERROR TAOS_DEF_ERROR_CODE(0, 0x1F00) //"http request json error")
|
||||
|
||||
// odbc
|
||||
#define TSDB_CODE_ODBC_OOM TAOS_DEF_ERROR_CODE(0, 0x2100) //"out of memory")
|
||||
#define TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM TAOS_DEF_ERROR_CODE(0, 0x2101) //"convertion not a valid literal input")
|
||||
|
|
|
|||
|
|
@ -77,8 +77,10 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_USER, "drop-user" )
|
|||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DNODE, "create-dnode" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DNODE, "drop-dnode" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DB, "create-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DB, "drop-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_FUNCTION, "create-function" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DB, "drop-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_FUNCTION, "drop-function" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_DB, "alter-db" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_SYNC_DB, "sync-db-replica" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_TABLE, "create-table" )
|
||||
|
|
@ -96,7 +98,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_KILL_STREAM, "kill-stream" )
|
|||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_KILL_CONN, "kill-conn" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CONFIG_DNODE, "cm-config-dnode" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_HEARTBEAT, "heartbeat" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY8, "dummy8" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, "retrieve-func" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY9, "dummy9" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY10, "dummy10" )
|
||||
TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY11, "dummy11" )
|
||||
|
|
@ -153,6 +155,7 @@ enum _mgmt_table {
|
|||
TSDB_MGMT_TABLE_STREAMTABLES,
|
||||
TSDB_MGMT_TABLE_CLUSTER,
|
||||
TSDB_MGMT_TABLE_TP,
|
||||
TSDB_MGMT_TABLE_FUNCTION,
|
||||
TSDB_MGMT_TABLE_MAX,
|
||||
};
|
||||
|
||||
|
|
@ -507,6 +510,9 @@ typedef struct {
|
|||
int32_t prevResultLen; // previous result length
|
||||
int32_t numOfOperator;
|
||||
int32_t tableScanOperator;// table scan operator. -1 means no scan operator
|
||||
int32_t udfNum; // number of udf function
|
||||
int32_t udfContentOffset;
|
||||
int32_t udfContentLen;
|
||||
SColumnInfo tableCols[];
|
||||
} SQueryTableMsg;
|
||||
|
||||
|
|
@ -571,6 +577,41 @@ typedef struct {
|
|||
int8_t reserve[5];
|
||||
} SCreateDbMsg, SAlterDbMsg;
|
||||
|
||||
typedef struct {
|
||||
char name[TSDB_FUNC_NAME_LEN];
|
||||
char path[PATH_MAX];
|
||||
int32_t funcType;
|
||||
uint8_t outputType;
|
||||
int16_t outputLen;
|
||||
int32_t bufSize;
|
||||
int32_t codeLen;
|
||||
char code[];
|
||||
} SCreateFuncMsg;
|
||||
|
||||
typedef struct {
|
||||
int32_t num;
|
||||
char name[];
|
||||
} SRetrieveFuncMsg;
|
||||
|
||||
typedef struct {
|
||||
char name[TSDB_FUNC_NAME_LEN];
|
||||
int32_t funcType;
|
||||
int8_t resType;
|
||||
int16_t resBytes;
|
||||
int32_t bufSize;
|
||||
int32_t len;
|
||||
char content[];
|
||||
} SFunctionInfoMsg;
|
||||
|
||||
typedef struct {
|
||||
int32_t num;
|
||||
char content[];
|
||||
} SUdfFuncMsg;
|
||||
|
||||
typedef struct {
|
||||
char name[TSDB_FUNC_NAME_LEN];
|
||||
} SDropFuncMsg;
|
||||
|
||||
typedef struct {
|
||||
char db[TSDB_TABLE_FNAME_LEN];
|
||||
uint8_t ignoreNotExists;
|
||||
|
|
@ -713,6 +754,7 @@ typedef struct {
|
|||
uint8_t metaClone; // create local clone of the cached table meta
|
||||
int32_t numOfVgroups;
|
||||
int32_t numOfTables;
|
||||
int32_t numOfUdfs;
|
||||
char tableNames[];
|
||||
} SMultiTableInfoMsg;
|
||||
|
||||
|
|
@ -761,13 +803,14 @@ typedef struct STableMetaMsg {
|
|||
} STableMetaMsg;
|
||||
|
||||
typedef struct SMultiTableMeta {
|
||||
int32_t numOfTables;
|
||||
uint8_t metaClone; // make meta clone after retrieve meta from mnode
|
||||
uint8_t compressed; // denote if compressed or not
|
||||
int32_t numOfVgroup; // number of tables
|
||||
uint32_t contLen; // current content length
|
||||
uint32_t rawLen; // size before compressed
|
||||
char meta[];
|
||||
int32_t numOfTables;
|
||||
int32_t numOfVgroup;
|
||||
int32_t numOfUdf;
|
||||
int32_t contLen;
|
||||
uint8_t compressed; // denote if compressed or not
|
||||
uint32_t rawLen; // size before compress
|
||||
uint8_t metaClone; // make meta clone after retrieve meta from mnode
|
||||
char meta[];
|
||||
} SMultiTableMeta;
|
||||
|
||||
typedef struct {
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ typedef struct {
|
|||
int32_t vgId;
|
||||
char user[TSDB_USER_LEN];
|
||||
char pass[TSDB_KEY_LEN];
|
||||
char db[TSDB_DB_NAME_LEN];
|
||||
char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
|
||||
FCqWrite cqWrite;
|
||||
} SCqCfg;
|
||||
|
||||
|
|
|
|||
|
|
@ -62,149 +62,154 @@
|
|||
#define TK_SHOW 44
|
||||
#define TK_DATABASES 45
|
||||
#define TK_TOPICS 46
|
||||
#define TK_MNODES 47
|
||||
#define TK_DNODES 48
|
||||
#define TK_ACCOUNTS 49
|
||||
#define TK_USERS 50
|
||||
#define TK_MODULES 51
|
||||
#define TK_QUERIES 52
|
||||
#define TK_CONNECTIONS 53
|
||||
#define TK_STREAMS 54
|
||||
#define TK_VARIABLES 55
|
||||
#define TK_SCORES 56
|
||||
#define TK_GRANTS 57
|
||||
#define TK_VNODES 58
|
||||
#define TK_IPTOKEN 59
|
||||
#define TK_DOT 60
|
||||
#define TK_CREATE 61
|
||||
#define TK_TABLE 62
|
||||
#define TK_STABLE 63
|
||||
#define TK_DATABASE 64
|
||||
#define TK_TABLES 65
|
||||
#define TK_STABLES 66
|
||||
#define TK_VGROUPS 67
|
||||
#define TK_DROP 68
|
||||
#define TK_TOPIC 69
|
||||
#define TK_DNODE 70
|
||||
#define TK_USER 71
|
||||
#define TK_ACCOUNT 72
|
||||
#define TK_USE 73
|
||||
#define TK_DESCRIBE 74
|
||||
#define TK_ALTER 75
|
||||
#define TK_PASS 76
|
||||
#define TK_PRIVILEGE 77
|
||||
#define TK_LOCAL 78
|
||||
#define TK_COMPACT 79
|
||||
#define TK_LP 80
|
||||
#define TK_RP 81
|
||||
#define TK_IF 82
|
||||
#define TK_EXISTS 83
|
||||
#define TK_PPS 84
|
||||
#define TK_TSERIES 85
|
||||
#define TK_DBS 86
|
||||
#define TK_STORAGE 87
|
||||
#define TK_QTIME 88
|
||||
#define TK_CONNS 89
|
||||
#define TK_STATE 90
|
||||
#define TK_COMMA 91
|
||||
#define TK_KEEP 92
|
||||
#define TK_CACHE 93
|
||||
#define TK_REPLICA 94
|
||||
#define TK_QUORUM 95
|
||||
#define TK_DAYS 96
|
||||
#define TK_MINROWS 97
|
||||
#define TK_MAXROWS 98
|
||||
#define TK_BLOCKS 99
|
||||
#define TK_CTIME 100
|
||||
#define TK_WAL 101
|
||||
#define TK_FSYNC 102
|
||||
#define TK_COMP 103
|
||||
#define TK_PRECISION 104
|
||||
#define TK_UPDATE 105
|
||||
#define TK_CACHELAST 106
|
||||
#define TK_PARTITIONS 107
|
||||
#define TK_UNSIGNED 108
|
||||
#define TK_TAGS 109
|
||||
#define TK_USING 110
|
||||
#define TK_AS 111
|
||||
#define TK_NULL 112
|
||||
#define TK_NOW 113
|
||||
#define TK_SELECT 114
|
||||
#define TK_UNION 115
|
||||
#define TK_ALL 116
|
||||
#define TK_DISTINCT 117
|
||||
#define TK_FROM 118
|
||||
#define TK_VARIABLE 119
|
||||
#define TK_INTERVAL 120
|
||||
#define TK_SESSION 121
|
||||
#define TK_STATE_WINDOW 122
|
||||
#define TK_FILL 123
|
||||
#define TK_SLIDING 124
|
||||
#define TK_ORDER 125
|
||||
#define TK_BY 126
|
||||
#define TK_ASC 127
|
||||
#define TK_DESC 128
|
||||
#define TK_GROUP 129
|
||||
#define TK_HAVING 130
|
||||
#define TK_LIMIT 131
|
||||
#define TK_OFFSET 132
|
||||
#define TK_SLIMIT 133
|
||||
#define TK_SOFFSET 134
|
||||
#define TK_WHERE 135
|
||||
#define TK_RESET 136
|
||||
#define TK_QUERY 137
|
||||
#define TK_SYNCDB 138
|
||||
#define TK_ADD 139
|
||||
#define TK_COLUMN 140
|
||||
#define TK_MODIFY 141
|
||||
#define TK_TAG 142
|
||||
#define TK_CHANGE 143
|
||||
#define TK_SET 144
|
||||
#define TK_KILL 145
|
||||
#define TK_CONNECTION 146
|
||||
#define TK_STREAM 147
|
||||
#define TK_COLON 148
|
||||
#define TK_ABORT 149
|
||||
#define TK_AFTER 150
|
||||
#define TK_ATTACH 151
|
||||
#define TK_BEFORE 152
|
||||
#define TK_BEGIN 153
|
||||
#define TK_CASCADE 154
|
||||
#define TK_CLUSTER 155
|
||||
#define TK_CONFLICT 156
|
||||
#define TK_COPY 157
|
||||
#define TK_DEFERRED 158
|
||||
#define TK_DELIMITERS 159
|
||||
#define TK_DETACH 160
|
||||
#define TK_EACH 161
|
||||
#define TK_END 162
|
||||
#define TK_EXPLAIN 163
|
||||
#define TK_FAIL 164
|
||||
#define TK_FOR 165
|
||||
#define TK_IGNORE 166
|
||||
#define TK_IMMEDIATE 167
|
||||
#define TK_INITIALLY 168
|
||||
#define TK_INSTEAD 169
|
||||
#define TK_MATCH 170
|
||||
#define TK_KEY 171
|
||||
#define TK_OF 172
|
||||
#define TK_RAISE 173
|
||||
#define TK_REPLACE 174
|
||||
#define TK_RESTRICT 175
|
||||
#define TK_ROW 176
|
||||
#define TK_STATEMENT 177
|
||||
#define TK_TRIGGER 178
|
||||
#define TK_VIEW 179
|
||||
#define TK_SEMI 180
|
||||
#define TK_NONE 181
|
||||
#define TK_PREV 182
|
||||
#define TK_LINEAR 183
|
||||
#define TK_IMPORT 184
|
||||
#define TK_TBNAME 185
|
||||
#define TK_JOIN 186
|
||||
#define TK_INSERT 187
|
||||
#define TK_INTO 188
|
||||
#define TK_VALUES 189
|
||||
#define TK_FUNCTIONS 47
|
||||
#define TK_MNODES 48
|
||||
#define TK_DNODES 49
|
||||
#define TK_ACCOUNTS 50
|
||||
#define TK_USERS 51
|
||||
#define TK_MODULES 52
|
||||
#define TK_QUERIES 53
|
||||
#define TK_CONNECTIONS 54
|
||||
#define TK_STREAMS 55
|
||||
#define TK_VARIABLES 56
|
||||
#define TK_SCORES 57
|
||||
#define TK_GRANTS 58
|
||||
#define TK_VNODES 59
|
||||
#define TK_IPTOKEN 60
|
||||
#define TK_DOT 61
|
||||
#define TK_CREATE 62
|
||||
#define TK_TABLE 63
|
||||
#define TK_STABLE 64
|
||||
#define TK_DATABASE 65
|
||||
#define TK_TABLES 66
|
||||
#define TK_STABLES 67
|
||||
#define TK_VGROUPS 68
|
||||
#define TK_DROP 69
|
||||
#define TK_TOPIC 70
|
||||
#define TK_FUNCTION 71
|
||||
#define TK_DNODE 72
|
||||
#define TK_USER 73
|
||||
#define TK_ACCOUNT 74
|
||||
#define TK_USE 75
|
||||
#define TK_DESCRIBE 76
|
||||
#define TK_ALTER 77
|
||||
#define TK_PASS 78
|
||||
#define TK_PRIVILEGE 79
|
||||
#define TK_LOCAL 80
|
||||
#define TK_COMPACT 81
|
||||
#define TK_LP 82
|
||||
#define TK_RP 83
|
||||
#define TK_IF 84
|
||||
#define TK_EXISTS 85
|
||||
#define TK_AS 86
|
||||
#define TK_OUTPUTTYPE 87
|
||||
#define TK_AGGREGATE 88
|
||||
#define TK_BUFSIZE 89
|
||||
#define TK_PPS 90
|
||||
#define TK_TSERIES 91
|
||||
#define TK_DBS 92
|
||||
#define TK_STORAGE 93
|
||||
#define TK_QTIME 94
|
||||
#define TK_CONNS 95
|
||||
#define TK_STATE 96
|
||||
#define TK_COMMA 97
|
||||
#define TK_KEEP 98
|
||||
#define TK_CACHE 99
|
||||
#define TK_REPLICA 100
|
||||
#define TK_QUORUM 101
|
||||
#define TK_DAYS 102
|
||||
#define TK_MINROWS 103
|
||||
#define TK_MAXROWS 104
|
||||
#define TK_BLOCKS 105
|
||||
#define TK_CTIME 106
|
||||
#define TK_WAL 107
|
||||
#define TK_FSYNC 108
|
||||
#define TK_COMP 109
|
||||
#define TK_PRECISION 110
|
||||
#define TK_UPDATE 111
|
||||
#define TK_CACHELAST 112
|
||||
#define TK_PARTITIONS 113
|
||||
#define TK_UNSIGNED 114
|
||||
#define TK_TAGS 115
|
||||
#define TK_USING 116
|
||||
#define TK_NULL 117
|
||||
#define TK_NOW 118
|
||||
#define TK_SELECT 119
|
||||
#define TK_UNION 120
|
||||
#define TK_ALL 121
|
||||
#define TK_DISTINCT 122
|
||||
#define TK_FROM 123
|
||||
#define TK_VARIABLE 124
|
||||
#define TK_INTERVAL 125
|
||||
#define TK_SESSION 126
|
||||
#define TK_STATE_WINDOW 127
|
||||
#define TK_FILL 128
|
||||
#define TK_SLIDING 129
|
||||
#define TK_ORDER 130
|
||||
#define TK_BY 131
|
||||
#define TK_ASC 132
|
||||
#define TK_DESC 133
|
||||
#define TK_GROUP 134
|
||||
#define TK_HAVING 135
|
||||
#define TK_LIMIT 136
|
||||
#define TK_OFFSET 137
|
||||
#define TK_SLIMIT 138
|
||||
#define TK_SOFFSET 139
|
||||
#define TK_WHERE 140
|
||||
#define TK_RESET 141
|
||||
#define TK_QUERY 142
|
||||
#define TK_SYNCDB 143
|
||||
#define TK_ADD 144
|
||||
#define TK_COLUMN 145
|
||||
#define TK_MODIFY 146
|
||||
#define TK_TAG 147
|
||||
#define TK_CHANGE 148
|
||||
#define TK_SET 149
|
||||
#define TK_KILL 150
|
||||
#define TK_CONNECTION 151
|
||||
#define TK_STREAM 152
|
||||
#define TK_COLON 153
|
||||
#define TK_ABORT 154
|
||||
#define TK_AFTER 155
|
||||
#define TK_ATTACH 156
|
||||
#define TK_BEFORE 157
|
||||
#define TK_BEGIN 158
|
||||
#define TK_CASCADE 159
|
||||
#define TK_CLUSTER 160
|
||||
#define TK_CONFLICT 161
|
||||
#define TK_COPY 162
|
||||
#define TK_DEFERRED 163
|
||||
#define TK_DELIMITERS 164
|
||||
#define TK_DETACH 165
|
||||
#define TK_EACH 166
|
||||
#define TK_END 167
|
||||
#define TK_EXPLAIN 168
|
||||
#define TK_FAIL 169
|
||||
#define TK_FOR 170
|
||||
#define TK_IGNORE 171
|
||||
#define TK_IMMEDIATE 172
|
||||
#define TK_INITIALLY 173
|
||||
#define TK_INSTEAD 174
|
||||
#define TK_MATCH 175
|
||||
#define TK_KEY 176
|
||||
#define TK_OF 177
|
||||
#define TK_RAISE 178
|
||||
#define TK_REPLACE 179
|
||||
#define TK_RESTRICT 180
|
||||
#define TK_ROW 181
|
||||
#define TK_STATEMENT 182
|
||||
#define TK_TRIGGER 183
|
||||
#define TK_VIEW 184
|
||||
#define TK_SEMI 185
|
||||
#define TK_NONE 186
|
||||
#define TK_PREV 187
|
||||
#define TK_LINEAR 188
|
||||
#define TK_IMPORT 189
|
||||
#define TK_TBNAME 190
|
||||
#define TK_JOIN 191
|
||||
#define TK_INSERT 192
|
||||
#define TK_INTO 193
|
||||
#define TK_VALUES 194
|
||||
|
||||
|
||||
#define TK_SPACE 300
|
||||
|
|
|
|||
|
|
@ -28,6 +28,10 @@ typedef struct tstr {
|
|||
#define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT) (_len))
|
||||
#define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
|
||||
|
||||
#define varDataNetLen(v) (htons(((VarDataLenT *)(v))[0]))
|
||||
#define varDataNetTLen(v) (sizeof(VarDataLenT) + varDataNetLen(v))
|
||||
|
||||
|
||||
// this data type is internally used only in 'in' query to hold the values
|
||||
#define TSDB_DATA_TYPE_ARRAY (1000)
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ typedef struct {
|
|||
SRpcMsg rpcMsg;
|
||||
SRspRet rspRet;
|
||||
char reserveForSync[24];
|
||||
SWalHead pHead;
|
||||
SWalHead walHead;
|
||||
} SVWriteMsg;
|
||||
|
||||
// vnodeStatus
|
||||
|
|
|
|||
|
|
@ -19,9 +19,9 @@ ELSE ()
|
|||
ENDIF ()
|
||||
|
||||
IF (TD_SOMODE_STATIC)
|
||||
TARGET_LINK_LIBRARIES(shell taos_static ${LINK_JEMALLOC})
|
||||
TARGET_LINK_LIBRARIES(shell taos_static lua ${LINK_JEMALLOC})
|
||||
ELSE ()
|
||||
TARGET_LINK_LIBRARIES(shell taos ${LINK_JEMALLOC})
|
||||
TARGET_LINK_LIBRARIES(shell taos lua ${LINK_JEMALLOC})
|
||||
ENDIF ()
|
||||
|
||||
SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ IF (TD_LINUX)
|
|||
ADD_EXECUTABLE(taosdemo ${SRC})
|
||||
|
||||
IF (TD_SOMODE_STATIC)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson ${LINK_JEMALLOC})
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua ${LINK_JEMALLOC})
|
||||
ELSE ()
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos cJson ${LINK_JEMALLOC})
|
||||
ENDIF ()
|
||||
|
|
@ -76,9 +76,9 @@ ELSEIF (TD_WINDOWS)
|
|||
ADD_EXECUTABLE(taosdemo ${SRC})
|
||||
SET_SOURCE_FILES_PROPERTIES(./taosdemo.c PROPERTIES COMPILE_FLAGS -w)
|
||||
IF (TD_SOMODE_STATIC)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua)
|
||||
ELSE ()
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos cJson)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos cJson lua)
|
||||
ENDIF ()
|
||||
ELSEIF (TD_DARWIN)
|
||||
# missing a few dependencies, such as <argp.h>
|
||||
|
|
@ -86,9 +86,9 @@ ELSEIF (TD_DARWIN)
|
|||
ADD_EXECUTABLE(taosdemo ${SRC})
|
||||
|
||||
IF (TD_SOMODE_STATIC)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua)
|
||||
ELSE ()
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos cJson)
|
||||
TARGET_LINK_LIBRARIES(taosdemo taos cJson lua)
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
|
||||
|
|
|
|||
|
|
@ -106,9 +106,9 @@ enum TEST_MODE {
|
|||
|
||||
|
||||
typedef enum CREATE_SUB_TALBE_MOD_EN {
|
||||
PRE_CREATE_SUBTBL,
|
||||
AUTO_CREATE_SUBTBL,
|
||||
NO_CREATE_SUBTBL
|
||||
PRE_CREATE_SUBTBL,
|
||||
AUTO_CREATE_SUBTBL,
|
||||
NO_CREATE_SUBTBL
|
||||
} CREATE_SUB_TALBE_MOD_EN;
|
||||
|
||||
typedef enum TALBE_EXISTS_EN {
|
||||
|
|
@ -569,7 +569,7 @@ SArguments g_args = {
|
|||
0, // test_mode
|
||||
"127.0.0.1", // host
|
||||
6030, // port
|
||||
TAOSC_IFACE, // iface
|
||||
INTERFACE_BUT, // iface
|
||||
"root", // user
|
||||
#ifdef _TD_POWER_
|
||||
"powerdb", // password
|
||||
|
|
@ -637,7 +637,7 @@ static FILE * g_fpOfInsertResult = NULL;
|
|||
|
||||
#define performancePrint(fmt, ...) \
|
||||
do { if (g_args.performance_print) \
|
||||
fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0)
|
||||
fprintf(stderr, "PERF: "fmt, __VA_ARGS__); } while(0)
|
||||
|
||||
#define errorPrint(fmt, ...) \
|
||||
do { fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); } while(0)
|
||||
|
|
@ -1429,8 +1429,13 @@ static int printfInsertMeta() {
|
|||
else
|
||||
printf("\ntaosdemo is simulating random data as you request..\n\n");
|
||||
|
||||
printf("interface: \033[33m%s\033[0m\n",
|
||||
(g_args.iface==TAOSC_IFACE)?"taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
|
||||
if (g_args.iface != INTERFACE_BUT) {
|
||||
// first time if no iface specified
|
||||
printf("interface: \033[33m%s\033[0m\n",
|
||||
(g_args.iface==TAOSC_IFACE)?"taosc":
|
||||
(g_args.iface==REST_IFACE)?"rest":"stmt");
|
||||
}
|
||||
|
||||
printf("host: \033[33m%s:%u\033[0m\n",
|
||||
g_Dbs.host, g_Dbs.port);
|
||||
printf("user: \033[33m%s\033[0m\n", g_Dbs.user);
|
||||
|
|
@ -3178,8 +3183,10 @@ static void createChildTables() {
|
|||
if (g_Dbs.db[i].superTblCount > 0) {
|
||||
// with super table
|
||||
for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
|
||||
if ((AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable)
|
||||
|| (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists)) {
|
||||
if ((AUTO_CREATE_SUBTBL
|
||||
== g_Dbs.db[i].superTbls[j].autoCreateTable)
|
||||
|| (TBL_ALREADY_EXISTS
|
||||
== g_Dbs.db[i].superTbls[j].childTblExists)) {
|
||||
continue;
|
||||
}
|
||||
verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
|
||||
|
|
@ -4151,6 +4158,22 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
|
|||
goto PARSE_OVER;
|
||||
}
|
||||
*/
|
||||
cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
|
||||
if (insertRows && insertRows->type == cJSON_Number) {
|
||||
if (insertRows->valueint < 0) {
|
||||
errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
|
||||
__func__, __LINE__);
|
||||
goto PARSE_OVER;
|
||||
}
|
||||
g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
|
||||
} else if (!insertRows) {
|
||||
g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
|
||||
} else {
|
||||
errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
|
||||
__func__, __LINE__);
|
||||
goto PARSE_OVER;
|
||||
}
|
||||
|
||||
cJSON* stbInterlaceRows = cJSON_GetObjectItem(stbInfo, "interlace_rows");
|
||||
if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
|
||||
if (stbInterlaceRows->valueint < 0) {
|
||||
|
|
@ -4159,15 +4182,15 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
|
|||
goto PARSE_OVER;
|
||||
}
|
||||
g_Dbs.db[i].superTbls[j].interlaceRows = stbInterlaceRows->valueint;
|
||||
// rows per table need be less than insert batch
|
||||
if (g_Dbs.db[i].superTbls[j].interlaceRows > g_args.num_of_RPR) {
|
||||
printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > num_of_records_per_req %u\n\n",
|
||||
i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
|
||||
g_args.num_of_RPR);
|
||||
printf(" interlace rows value will be set to num_of_records_per_req %u\n\n",
|
||||
g_args.num_of_RPR);
|
||||
prompt();
|
||||
g_Dbs.db[i].superTbls[j].interlaceRows = g_args.num_of_RPR;
|
||||
|
||||
if (g_Dbs.db[i].superTbls[j].interlaceRows > g_Dbs.db[i].superTbls[j].insertRows) {
|
||||
printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > insert_rows %"PRId64"\n\n",
|
||||
i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
|
||||
g_Dbs.db[i].superTbls[j].insertRows);
|
||||
printf(" interlace rows value will be set to insert_rows %"PRId64"\n\n",
|
||||
g_Dbs.db[i].superTbls[j].insertRows);
|
||||
prompt();
|
||||
g_Dbs.db[i].superTbls[j].interlaceRows = g_Dbs.db[i].superTbls[j].insertRows;
|
||||
}
|
||||
} else if (!stbInterlaceRows) {
|
||||
g_Dbs.db[i].superTbls[j].interlaceRows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
|
||||
|
|
@ -4204,22 +4227,6 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
|
|||
goto PARSE_OVER;
|
||||
}
|
||||
|
||||
cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
|
||||
if (insertRows && insertRows->type == cJSON_Number) {
|
||||
if (insertRows->valueint < 0) {
|
||||
errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
|
||||
__func__, __LINE__);
|
||||
goto PARSE_OVER;
|
||||
}
|
||||
g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
|
||||
} else if (!insertRows) {
|
||||
g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
|
||||
} else {
|
||||
errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
|
||||
__func__, __LINE__);
|
||||
goto PARSE_OVER;
|
||||
}
|
||||
|
||||
cJSON* insertInterval = cJSON_GetObjectItem(stbInfo, "insert_interval");
|
||||
if (insertInterval && insertInterval->type == cJSON_Number) {
|
||||
g_Dbs.db[i].superTbls[j].insertInterval = insertInterval->valueint;
|
||||
|
|
@ -4976,12 +4983,20 @@ static int64_t generateData(char *recBuf, char **data_type,
|
|||
bool b = rand_bool() & 1;
|
||||
pstr += sprintf(pstr, ",%s", b ? "true" : "false");
|
||||
} else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
|
||||
char *s = malloc(lenOfBinary);
|
||||
char *s = malloc(lenOfBinary + 1);
|
||||
if (s == NULL) {
|
||||
errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
|
||||
__func__, __LINE__, lenOfBinary + 1);
|
||||
}
|
||||
rand_string(s, lenOfBinary);
|
||||
pstr += sprintf(pstr, ",\"%s\"", s);
|
||||
free(s);
|
||||
} else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
|
||||
char *s = malloc(lenOfBinary);
|
||||
char *s = malloc(lenOfBinary + 1);
|
||||
if (s == NULL) {
|
||||
errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
|
||||
__func__, __LINE__, lenOfBinary + 1);
|
||||
}
|
||||
rand_string(s, lenOfBinary);
|
||||
pstr += sprintf(pstr, ",\"%s\"", s);
|
||||
free(s);
|
||||
|
|
@ -5038,13 +5053,17 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
|
|||
uint16_t iface;
|
||||
if (superTblInfo)
|
||||
iface = superTblInfo->iface;
|
||||
else
|
||||
iface = g_args.iface;
|
||||
else {
|
||||
if (g_args.iface == INTERFACE_BUT)
|
||||
iface = TAOSC_IFACE;
|
||||
else
|
||||
iface = g_args.iface;
|
||||
}
|
||||
|
||||
debugPrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
|
||||
__func__, __LINE__,
|
||||
(g_args.iface==TAOSC_IFACE)?
|
||||
"taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
|
||||
(iface==TAOSC_IFACE)?
|
||||
"taosc":(iface==REST_IFACE)?"rest":"stmt");
|
||||
|
||||
switch(iface) {
|
||||
case TAOSC_IFACE:
|
||||
|
|
@ -5134,12 +5153,18 @@ static int32_t generateDataTailWithoutStb(
|
|||
char **data_type = g_args.datatype;
|
||||
int lenOfBinary = g_args.len_of_binary;
|
||||
|
||||
retLen = generateData(data, data_type,
|
||||
startTime + getTSRandTail(
|
||||
(int64_t) DEFAULT_TIMESTAMP_STEP, k,
|
||||
g_args.disorderRatio,
|
||||
g_args.disorderRange),
|
||||
lenOfBinary);
|
||||
if (g_args.disorderRatio) {
|
||||
retLen = generateData(data, data_type,
|
||||
startTime + getTSRandTail(
|
||||
(int64_t) DEFAULT_TIMESTAMP_STEP, k,
|
||||
g_args.disorderRatio,
|
||||
g_args.disorderRange),
|
||||
lenOfBinary);
|
||||
} else {
|
||||
retLen = generateData(data, data_type,
|
||||
startTime + (int64_t) (DEFAULT_TIMESTAMP_STEP* k),
|
||||
lenOfBinary);
|
||||
}
|
||||
|
||||
if (len > remainderBufLen)
|
||||
break;
|
||||
|
|
@ -5191,14 +5216,14 @@ static int32_t generateStbDataTail(
|
|||
|
||||
bool tsRand;
|
||||
if (0 == strncasecmp(superTblInfo->dataSource, "rand", strlen("rand"))) {
|
||||
tsRand = true;
|
||||
tsRand = true;
|
||||
} else {
|
||||
tsRand = false;
|
||||
tsRand = false;
|
||||
}
|
||||
verbosePrint("%s() LN%d batch=%u buflen=%"PRId64"\n",
|
||||
__func__, __LINE__, batch, remainderBufLen);
|
||||
|
||||
int32_t k = 0;
|
||||
int32_t k;
|
||||
for (k = 0; k < batch;) {
|
||||
char data[MAX_DATA_SIZE];
|
||||
memset(data, 0, MAX_DATA_SIZE);
|
||||
|
|
@ -5647,10 +5672,15 @@ static int32_t prepareStmtWithoutStb(
|
|||
|
||||
bind_ts = (int64_t *)ptr;
|
||||
bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
|
||||
*bind_ts = startTime + getTSRandTail(
|
||||
(int64_t)DEFAULT_TIMESTAMP_STEP, k,
|
||||
g_args.disorderRatio,
|
||||
g_args.disorderRange);
|
||||
|
||||
if (g_args.disorderRatio) {
|
||||
*bind_ts = startTime + getTSRandTail(
|
||||
(int64_t)DEFAULT_TIMESTAMP_STEP, k,
|
||||
g_args.disorderRatio,
|
||||
g_args.disorderRange);
|
||||
} else {
|
||||
*bind_ts = startTime + (int64_t)(DEFAULT_TIMESTAMP_STEP * k);
|
||||
}
|
||||
bind->buffer_length = sizeof(int64_t);
|
||||
bind->buffer = bind_ts;
|
||||
bind->length = &bind->buffer_length;
|
||||
|
|
@ -5735,7 +5765,7 @@ static int32_t prepareStbStmt(
|
|||
|
||||
bind_ts = (int64_t *)ptr;
|
||||
bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
|
||||
if (sourceRand) {
|
||||
if (stbInfo->disorderRatio) {
|
||||
*bind_ts = startTime + getTSRandTail(
|
||||
stbInfo->timeStampStep, k,
|
||||
stbInfo->disorderRatio,
|
||||
|
|
@ -5802,6 +5832,7 @@ static int32_t prepareStbStmt(
|
|||
if (!sourceRand) {
|
||||
(*pSamplePos) ++;
|
||||
}
|
||||
|
||||
if (recordFrom >= insertRows) {
|
||||
break;
|
||||
}
|
||||
|
|
@ -5811,6 +5842,43 @@ static int32_t prepareStbStmt(
|
|||
free(bindArray);
|
||||
return k;
|
||||
}
|
||||
|
||||
static int32_t prepareStbStmtInterlace(
|
||||
SSuperTable *stbInfo,
|
||||
TAOS_STMT *stmt,
|
||||
char *tableName, uint32_t batch,
|
||||
uint64_t insertRows,
|
||||
uint64_t recordFrom,
|
||||
int64_t startTime,
|
||||
int64_t *pSamplePos)
|
||||
{
|
||||
return prepareStbStmt(
|
||||
stbInfo,
|
||||
stmt,
|
||||
tableName,
|
||||
g_args.num_of_RPR,
|
||||
insertRows, 0, startTime,
|
||||
pSamplePos);
|
||||
}
|
||||
|
||||
static int32_t prepareStbStmtProgressive(
|
||||
SSuperTable *stbInfo,
|
||||
TAOS_STMT *stmt,
|
||||
char *tableName, uint32_t batch,
|
||||
uint64_t insertRows,
|
||||
uint64_t recordFrom,
|
||||
int64_t startTime,
|
||||
int64_t *pSamplePos)
|
||||
{
|
||||
return prepareStbStmt(
|
||||
stbInfo,
|
||||
stmt,
|
||||
tableName,
|
||||
g_args.num_of_RPR,
|
||||
insertRows, recordFrom, startTime,
|
||||
pSamplePos);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static int32_t generateStbProgressiveData(
|
||||
|
|
@ -5884,7 +5952,7 @@ static void printStatPerThread(threadInfo *pThreadInfo)
|
|||
pThreadInfo->threadID,
|
||||
pThreadInfo->totalInsertRows,
|
||||
pThreadInfo->totalAffectedRows,
|
||||
(double)(pThreadInfo->totalAffectedRows / (pThreadInfo->totalDelay/1000.0)));
|
||||
(pThreadInfo->totalDelay)?(double)((pThreadInfo->totalAffectedRows / (pThreadInfo->totalDelay)/1000.0)): FLT_MAX);
|
||||
}
|
||||
|
||||
// sync write interlace data
|
||||
|
|
@ -5983,7 +6051,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
|
|||
|
||||
uint32_t recOfBatch = 0;
|
||||
|
||||
for (uint32_t i = 0; i < batchPerTblTimes; i ++) {
|
||||
for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
|
||||
char tableName[TSDB_TABLE_NAME_LEN];
|
||||
|
||||
getTableName(tableName, pThreadInfo, tableSeq);
|
||||
|
|
@ -6000,7 +6068,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
|
|||
if (superTblInfo) {
|
||||
if (superTblInfo->iface == STMT_IFACE) {
|
||||
#if STMT_IFACE_ENABLED == 1
|
||||
generated = prepareStbStmt(
|
||||
generated = prepareStbStmtInterlace(
|
||||
superTblInfo,
|
||||
pThreadInfo->stmt,
|
||||
tableName,
|
||||
|
|
@ -6229,7 +6297,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
|
|||
if (superTblInfo) {
|
||||
if (superTblInfo->iface == STMT_IFACE) {
|
||||
#if STMT_IFACE_ENABLED == 1
|
||||
generated = prepareStbStmt(
|
||||
generated = prepareStbStmtProgressive(
|
||||
superTblInfo,
|
||||
pThreadInfo->stmt,
|
||||
tableName,
|
||||
|
|
@ -6463,7 +6531,7 @@ static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *
|
|||
}
|
||||
|
||||
static void startMultiThreadInsertData(int threads, char* db_name,
|
||||
char* precision,SSuperTable* superTblInfo) {
|
||||
char* precision, SSuperTable* superTblInfo) {
|
||||
|
||||
int32_t timePrec = TSDB_TIME_PRECISION_MILLI;
|
||||
if (0 != precision[0]) {
|
||||
|
|
@ -6659,13 +6727,24 @@ static void startMultiThreadInsertData(int threads, char* db_name,
|
|||
|
||||
char buffer[3000];
|
||||
char *pstr = buffer;
|
||||
pstr += sprintf(pstr, "INSERT INTO ? values(?");
|
||||
|
||||
if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) {
|
||||
pstr += sprintf(pstr, "INSERT INTO ? USING %s TAGS(?",
|
||||
superTblInfo->sTblName);
|
||||
for (int tag = 0; tag < (superTblInfo->tagCount - 1); tag ++ ) {
|
||||
pstr += sprintf(pstr, ",?");
|
||||
}
|
||||
pstr += sprintf(pstr, ") VALUES(?");
|
||||
} else {
|
||||
pstr += sprintf(pstr, "INSERT INTO ? VALUES(?");
|
||||
}
|
||||
|
||||
for (int col = 0; col < columnCount; col ++) {
|
||||
pstr += sprintf(pstr, ",?");
|
||||
}
|
||||
pstr += sprintf(pstr, ")");
|
||||
|
||||
debugPrint("%s() LN%d, buffer: %s", __func__, __LINE__, buffer);
|
||||
int ret = taos_stmt_prepare(pThreadInfo->stmt, buffer, 0);
|
||||
if (ret != 0){
|
||||
errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
|
||||
|
|
@ -7936,7 +8015,12 @@ static void setParaFromArg(){
|
|||
tstrncpy(g_Dbs.db[0].superTbls[0].childTblPrefix,
|
||||
g_args.tb_prefix, TSDB_TABLE_NAME_LEN - 20);
|
||||
tstrncpy(g_Dbs.db[0].superTbls[0].dataSource, "rand", MAX_TB_NAME_SIZE);
|
||||
g_Dbs.db[0].superTbls[0].iface = g_args.iface;
|
||||
|
||||
if (g_args.iface == INTERFACE_BUT) {
|
||||
g_Dbs.db[0].superTbls[0].iface = TAOSC_IFACE;
|
||||
} else {
|
||||
g_Dbs.db[0].superTbls[0].iface = g_args.iface;
|
||||
}
|
||||
tstrncpy(g_Dbs.db[0].superTbls[0].startTimestamp,
|
||||
"2017-07-14 10:40:00.000", MAX_TB_NAME_SIZE);
|
||||
g_Dbs.db[0].superTbls[0].timeStampStep = DEFAULT_TIMESTAMP_STEP;
|
||||
|
|
|
|||
|
|
@ -214,6 +214,23 @@ typedef struct SUserObj {
|
|||
struct SAcctObj * pAcct;
|
||||
} SUserObj;
|
||||
|
||||
typedef struct SFuncObj {
|
||||
char name[TSDB_FUNC_NAME_LEN];
|
||||
char path[128];
|
||||
int32_t contLen;
|
||||
char cont[TSDB_FUNC_CODE_LEN];
|
||||
int32_t funcType;
|
||||
int32_t bufSize;
|
||||
int64_t createdTime;
|
||||
uint8_t resType;
|
||||
int16_t resBytes;
|
||||
int64_t sig; // partial md5 sign
|
||||
int16_t type; // [lua script|so|js]
|
||||
int8_t reserved[64];
|
||||
int8_t updateEnd[4];
|
||||
int32_t refCount;
|
||||
} SFuncObj;
|
||||
|
||||
typedef struct {
|
||||
int64_t totalStorage; // Total storage wrtten from this account
|
||||
int64_t compStorage; // Compressed storage on disk
|
||||
|
|
@ -258,7 +275,7 @@ typedef struct {
|
|||
void * pIter;
|
||||
void ** ppShow;
|
||||
int16_t offset[TSDB_MAX_COLUMNS];
|
||||
int16_t bytes[TSDB_MAX_COLUMNS];
|
||||
int32_t bytes[TSDB_MAX_COLUMNS];
|
||||
int32_t numOfReads;
|
||||
int8_t maxReplica;
|
||||
int8_t reserved0[1];
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef TDENGINE_MNODE_FUNC_H
|
||||
#define TDENGINE_MNODE_FUNC_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#include "mnodeDef.h"
|
||||
|
||||
int32_t mnodeInitFuncs();
|
||||
void mnodeCleanupFuncs();
|
||||
|
||||
SFuncObj *mnodeGetFunc(char *name);
|
||||
void * mnodeGetNextFunc(void *pIter, SFuncObj **pFunc);
|
||||
void mnodeCancelGetNextFunc(void *pIter);
|
||||
|
||||
void mnodeIncFuncRef(SFuncObj *pFunc);
|
||||
void mnodeDecFuncRef(SFuncObj *pFunc);
|
||||
|
||||
int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *code, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -33,7 +33,8 @@ typedef enum {
|
|||
SDB_TABLE_VGROUP = 6,
|
||||
SDB_TABLE_STABLE = 7,
|
||||
SDB_TABLE_CTABLE = 8,
|
||||
SDB_TABLE_MAX = 9
|
||||
SDB_TABLE_FUNC = 9,
|
||||
SDB_TABLE_MAX = 10
|
||||
} ESdbTable;
|
||||
|
||||
typedef enum {
|
||||
|
|
@ -112,4 +113,4 @@ int32_t mnodeCompactWal();
|
|||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -554,6 +554,9 @@ void mnodeCleanupDbs() {
|
|||
tsDbSdb = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
|
||||
int32_t cols = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,485 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#define _DEFAULT_SOURCE
|
||||
#include "os.h"
|
||||
#include "trpc.h"
|
||||
#include "tutil.h"
|
||||
#include "tglobal.h"
|
||||
#include "tgrant.h"
|
||||
#include "tdataformat.h"
|
||||
#include "tkey.h"
|
||||
#include "mnode.h"
|
||||
#include "dnode.h"
|
||||
#include "mnodeDef.h"
|
||||
#include "mnodeInt.h"
|
||||
#include "mnodeAcct.h"
|
||||
#include "mnodeUser.h"
|
||||
#include "mnodeMnode.h"
|
||||
#include "mnodeSdb.h"
|
||||
#include "mnodeShow.h"
|
||||
#include "mnodeFunc.h"
|
||||
#include "mnodeWrite.h"
|
||||
#include "mnodeRead.h"
|
||||
#include "mnodePeer.h"
|
||||
|
||||
int64_t tsFuncRid = -1;
|
||||
static void * tsFuncSdb = NULL;
|
||||
static int32_t tsFuncUpdateSize = 0;
|
||||
static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
|
||||
static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
|
||||
static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg);
|
||||
static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg);
|
||||
static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg);
|
||||
|
||||
static int32_t mnodeFuncActionDestroy(SSdbRow *pRow) {
|
||||
tfree(pRow->pObj);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionInsert(SSdbRow *pRow) {
|
||||
SFuncObj *pFunc = pRow->pObj;
|
||||
|
||||
mTrace("func:%s, contLen: %d, insert into sdb", pFunc->name, pFunc->contLen);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionDelete(SSdbRow *pRow) {
|
||||
SFuncObj *pFunc = pRow->pObj;
|
||||
|
||||
mTrace("func:%s, length: %d, delete from sdb", pFunc->name, pFunc->contLen);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionUpdate(SSdbRow *pRow) {
|
||||
SFuncObj *pFunc = pRow->pObj;
|
||||
|
||||
SFuncObj *pSaved = mnodeGetFunc(pFunc->name);
|
||||
if (pFunc != pSaved) {
|
||||
memcpy(pSaved, pFunc, tsFuncUpdateSize);
|
||||
free(pFunc);
|
||||
}
|
||||
|
||||
mnodeDecFuncRef(pSaved);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionEncode(SSdbRow *pRow) {
|
||||
SFuncObj *pFunc = pRow->pObj;
|
||||
|
||||
memcpy(pRow->rowData, pFunc, tsFuncUpdateSize);
|
||||
pRow->rowSize = tsFuncUpdateSize;
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionDecode(SSdbRow *pRow) {
|
||||
SFuncObj *pFunc = (SFuncObj *)calloc(1, sizeof(SFuncObj));
|
||||
if (pFunc == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
|
||||
|
||||
memcpy(pFunc, pRow->rowData, tsFuncUpdateSize);
|
||||
pRow->pObj = pFunc;
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t mnodeFuncActionRestored() {
|
||||
int64_t numOfRows = sdbGetNumOfRows(tsFuncSdb);
|
||||
|
||||
if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
|
||||
mInfo("dnode first deploy, func restored.");
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t mnodeInitFuncs() {
|
||||
SFuncObj tObj;
|
||||
tsFuncUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
|
||||
|
||||
SSdbTableDesc desc = {
|
||||
.id = SDB_TABLE_FUNC,
|
||||
.name = "funcs",
|
||||
.hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
|
||||
.maxRowSize = tsFuncUpdateSize,
|
||||
.refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
|
||||
.keyType = SDB_KEY_STRING,
|
||||
.fpInsert = mnodeFuncActionInsert,
|
||||
.fpDelete = mnodeFuncActionDelete,
|
||||
.fpUpdate = mnodeFuncActionUpdate,
|
||||
.fpEncode = mnodeFuncActionEncode,
|
||||
.fpDecode = mnodeFuncActionDecode,
|
||||
.fpDestroy = mnodeFuncActionDestroy,
|
||||
.fpRestored = mnodeFuncActionRestored
|
||||
};
|
||||
|
||||
tsFuncRid = sdbOpenTable(&desc);
|
||||
tsFuncSdb = sdbGetTableByRid(tsFuncRid);
|
||||
if (tsFuncSdb == NULL) {
|
||||
mError("table:%s, failed to create hash", desc.name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg);
|
||||
mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg);
|
||||
mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, mnodeProcessRetrieveFuncImplMsg);
|
||||
|
||||
mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta);
|
||||
mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs);
|
||||
mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeCancelGetNextFunc);
|
||||
|
||||
mDebug("table:%s, hash is created", desc.name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mnodeCleanupFuncs() {
|
||||
sdbCloseTable(tsFuncRid);
|
||||
tsFuncSdb = NULL;
|
||||
}
|
||||
|
||||
SFuncObj *mnodeGetFunc(char *name) {
|
||||
return (SFuncObj *)sdbGetRow(tsFuncSdb, name);
|
||||
}
|
||||
|
||||
void *mnodeGetNextFunc(void *pIter, SFuncObj **pFunc) {
|
||||
return sdbFetchRow(tsFuncSdb, pIter, (void **)pFunc);
|
||||
}
|
||||
|
||||
void mnodeCancelGetNextFunc(void *pIter) {
|
||||
sdbFreeIter(tsFuncSdb, pIter);
|
||||
}
|
||||
|
||||
void mnodeIncFuncRef(SFuncObj *pFunc) {
|
||||
sdbIncRef(tsFuncSdb, pFunc);
|
||||
}
|
||||
|
||||
void mnodeDecFuncRef(SFuncObj *pFunc) {
|
||||
sdbDecRef(tsFuncSdb, pFunc);
|
||||
}
|
||||
/*
|
||||
static int32_t mnodeUpdateFunc(SFuncObj *pFunc, void *pMsg) {
|
||||
SSdbRow row = {
|
||||
.type = SDB_OPER_GLOBAL,
|
||||
.pTable = tsFuncSdb,
|
||||
.pObj = pFunc,
|
||||
.pMsg = pMsg
|
||||
};
|
||||
|
||||
int32_t code = sdbUpdateRow(&row);
|
||||
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
|
||||
mError("func:%s, failed to alter by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
|
||||
} else {
|
||||
mLInfo("func:%s, is altered by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
*/
|
||||
int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *codeScript, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg) {
|
||||
if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
|
||||
return TSDB_CODE_GRANT_EXPIRED;
|
||||
}
|
||||
|
||||
if (!pMsg->pUser->writeAuth) {
|
||||
return TSDB_CODE_MND_NO_RIGHTS;
|
||||
}
|
||||
|
||||
int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
return code;
|
||||
}
|
||||
|
||||
code = grantCheck(TSDB_GRANT_USER);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
return code;
|
||||
}
|
||||
|
||||
if (name[0] == 0) {
|
||||
return TSDB_CODE_MND_INVALID_FUNC_NAME;
|
||||
}
|
||||
|
||||
if (codeScript[0] == 0) {
|
||||
return TSDB_CODE_MND_INVALID_FUNC_CODE;
|
||||
}
|
||||
|
||||
if (codeLen < 0 || codeLen > TSDB_FUNC_CODE_LEN) {
|
||||
return TSDB_CODE_MND_INVALID_FUNC_CODE;
|
||||
}
|
||||
|
||||
if (bufSize < 0 || bufSize > TSDB_FUNC_BUF_SIZE) {
|
||||
return TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
|
||||
}
|
||||
|
||||
SFuncObj *pFunc = mnodeGetFunc(name);
|
||||
if (pFunc != NULL) {
|
||||
mDebug("func:%s, is already there", name);
|
||||
mnodeDecFuncRef(pFunc);
|
||||
return TSDB_CODE_MND_FUNC_ALREADY_EXIST;
|
||||
}
|
||||
|
||||
pFunc = calloc(1, sizeof(SFuncObj));
|
||||
tstrncpy(pFunc->name, name, TSDB_FUNC_NAME_LEN);
|
||||
tstrncpy(pFunc->path, path, tListLen(pFunc->path));
|
||||
memcpy(pFunc->cont, codeScript, codeLen);
|
||||
pFunc->contLen = codeLen;
|
||||
pFunc->createdTime = taosGetTimestampMs();
|
||||
pFunc->resType = outputType;
|
||||
pFunc->resBytes = outputLen;
|
||||
pFunc->funcType = funcType;
|
||||
pFunc->bufSize = bufSize;
|
||||
pFunc->sig = 0;
|
||||
pFunc->type = 1; //lua script, refactor
|
||||
|
||||
SSdbRow row = {
|
||||
.type = SDB_OPER_GLOBAL,
|
||||
.pTable = tsFuncSdb,
|
||||
.pObj = pFunc,
|
||||
.rowSize = sizeof(SFuncObj),
|
||||
.pMsg = pMsg
|
||||
};
|
||||
|
||||
code = sdbInsertRow(&row);
|
||||
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
|
||||
mError("func:%s, failed to create by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
|
||||
tfree(pFunc);
|
||||
} else {
|
||||
mLInfo("func:%s, is created by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t mnodeDropFunc(SFuncObj *pFunc, void *pMsg) {
|
||||
SSdbRow row = {
|
||||
.type = SDB_OPER_GLOBAL,
|
||||
.pTable = tsFuncSdb,
|
||||
.pObj = pFunc,
|
||||
.pMsg = pMsg
|
||||
};
|
||||
|
||||
int32_t code = sdbDeleteRow(&row);
|
||||
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
|
||||
mError("func:%s, failed to drop by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
|
||||
} else {
|
||||
mLInfo("func:%s, is dropped by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t mnodeGetFuncsNum() {
|
||||
return (int32_t)sdbGetNumOfRows(tsFuncSdb);
|
||||
}
|
||||
|
||||
static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
|
||||
SUserObj *pUser = mnodeGetUserFromConn(pConn);
|
||||
if (pUser == NULL) {
|
||||
return TSDB_CODE_MND_NO_USER_FROM_CONN;
|
||||
}
|
||||
|
||||
int32_t cols = 0;
|
||||
SSchema *pSchema = pMeta->schema;
|
||||
|
||||
pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
|
||||
strcpy(pSchema[cols].name, "name");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
|
||||
strcpy(pSchema[cols].name, "path");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = 4;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_INT;
|
||||
strcpy(pSchema[cols].name, "aggregate");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
|
||||
strcpy(pSchema[cols].name, "outputtype");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = 8;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
|
||||
strcpy(pSchema[cols].name, "create_time");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = 4;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_INT;
|
||||
strcpy(pSchema[cols].name, "code_len");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pShow->bytes[cols] = 4;
|
||||
pSchema[cols].type = TSDB_DATA_TYPE_INT;
|
||||
strcpy(pSchema[cols].name, "bufsize");
|
||||
pSchema[cols].bytes = htons(pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pMeta->numOfColumns = htons(cols);
|
||||
strcpy(pMeta->tableFname, "show funcs");
|
||||
pShow->numOfColumns = cols;
|
||||
|
||||
pShow->offset[0] = 0;
|
||||
for (int32_t i = 1; i < cols; ++i) {
|
||||
pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
|
||||
}
|
||||
|
||||
pShow->numOfRows = mnodeGetFuncsNum();
|
||||
pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
|
||||
|
||||
mnodeDecUserRef(pUser);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void* mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t len) {
|
||||
char *msg = "unknown";
|
||||
if (type >= sizeof(tDataTypes)/sizeof(tDataTypes[0])) {
|
||||
return msg;
|
||||
}
|
||||
|
||||
if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
|
||||
int32_t bytes = len > 0 ? (int)(len - VARSTR_HEADER_SIZE) : len;
|
||||
|
||||
snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes/4 : bytes);
|
||||
buf[buflen - 1] = 0;
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
return tDataTypes[type].name;
|
||||
}
|
||||
|
||||
static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
|
||||
int32_t numOfRows = 0;
|
||||
SFuncObj *pFunc = NULL;
|
||||
int32_t cols = 0;
|
||||
char *pWrite;
|
||||
char buf[TSDB_TYPE_STR_MAX_LEN];
|
||||
|
||||
while (numOfRows < rows) {
|
||||
pShow->pIter = mnodeGetNextFunc(pShow->pIter, &pFunc);
|
||||
if (pFunc == NULL) break;
|
||||
|
||||
cols = 0;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->name, pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->path, pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
*(int32_t *)pWrite = pFunc->funcType == TSDB_UDF_TYPE_AGGREGATE ? 1 : 0;
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
STR_WITH_MAXSIZE_TO_VARSTR(pWrite, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->resType, pFunc->resBytes), pShow->bytes[cols]);
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
*(int64_t *)pWrite = pFunc->createdTime;
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
*(int32_t *)pWrite = pFunc->contLen;
|
||||
cols++;
|
||||
|
||||
pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
|
||||
*(int32_t *)pWrite = pFunc->bufSize;
|
||||
cols++;
|
||||
|
||||
numOfRows++;
|
||||
mnodeDecFuncRef(pFunc);
|
||||
}
|
||||
|
||||
mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
|
||||
pShow->numOfReads += numOfRows;
|
||||
return numOfRows;
|
||||
}
|
||||
|
||||
static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) {
|
||||
SCreateFuncMsg *pCreate = pMsg->rpcMsg.pCont;
|
||||
pCreate->codeLen = htonl(pCreate->codeLen);
|
||||
pCreate->outputLen = htons(pCreate->outputLen);
|
||||
pCreate->funcType = htonl(pCreate->funcType);
|
||||
pCreate->bufSize = htonl(pCreate->bufSize);
|
||||
|
||||
return mnodeCreateFunc(pMsg->pUser->pAcct, pCreate->name, pCreate->codeLen, pCreate->code, pCreate->path, pCreate->outputType, pCreate->outputLen, pCreate->funcType, pCreate->bufSize, pMsg);
|
||||
}
|
||||
|
||||
static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) {
|
||||
SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont;
|
||||
|
||||
SFuncObj *pFunc = mnodeGetFunc(pDrop->name);
|
||||
if (pFunc == NULL) {
|
||||
return TSDB_CODE_MND_INVALID_FUNC;
|
||||
}
|
||||
|
||||
return mnodeDropFunc(pFunc, pMsg);
|
||||
}
|
||||
|
||||
static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg) {
|
||||
SRetrieveFuncMsg *pInfo = pMsg->rpcMsg.pCont;
|
||||
pInfo->num = htonl(pInfo->num);
|
||||
|
||||
int32_t t = sizeof(SUdfFuncMsg) + (sizeof(SFunctionInfoMsg) + TSDB_FUNC_CODE_LEN) * pInfo->num + 16384;
|
||||
|
||||
SUdfFuncMsg *pFuncMsg = rpcMallocCont(t);
|
||||
pFuncMsg->num = htonl(pInfo->num);
|
||||
char* pOutput = pFuncMsg->content;
|
||||
tstr* name = (tstr*) pInfo->name;
|
||||
|
||||
for(int32_t i = 0; i < pInfo->num; ++i) {
|
||||
char buf[TSDB_FUNC_NAME_LEN] = {0};
|
||||
tstrncpy(buf, name->data, htons(name->len) + 1);
|
||||
|
||||
SFuncObj* pFuncObj = mnodeGetFunc(buf);
|
||||
if (pFuncObj == NULL) {
|
||||
mError("function %s does not exist", buf);
|
||||
return TSDB_CODE_MND_INVALID_FUNC;
|
||||
}
|
||||
|
||||
SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) pOutput;
|
||||
|
||||
strcpy(pFuncInfo->name, buf);
|
||||
pFuncInfo->len = htonl(pFuncObj->contLen);
|
||||
memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
|
||||
|
||||
pFuncInfo->funcType = htonl(pFuncObj->funcType);
|
||||
pFuncInfo->resType = pFuncObj->resType;
|
||||
pFuncInfo->resBytes = htons(pFuncObj->resBytes);
|
||||
pFuncInfo->bufSize = htonl(pFuncObj->bufSize);
|
||||
|
||||
pOutput += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
|
||||
name =(tstr *)((char *)name + sizeof(*name) + htons(name->len));
|
||||
}
|
||||
|
||||
pMsg->rpcRsp.rsp = pFuncMsg;
|
||||
pMsg->rpcRsp.len = (int32_t)(pOutput - (char*)pFuncMsg);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
|
@ -32,6 +32,7 @@
|
|||
#include "mnodeSdb.h"
|
||||
#include "mnodeVgroup.h"
|
||||
#include "mnodeUser.h"
|
||||
#include "mnodeFunc.h"
|
||||
#include "mnodeTable.h"
|
||||
#include "mnodeCluster.h"
|
||||
#include "mnodeShow.h"
|
||||
|
|
@ -46,6 +47,7 @@ static SStep tsMnodeSteps[] = {
|
|||
{"cluster", mnodeInitCluster, mnodeCleanupCluster},
|
||||
{"accts", mnodeInitAccts, mnodeCleanupAccts},
|
||||
{"users", mnodeInitUsers, mnodeCleanupUsers},
|
||||
{"funcs", mnodeInitFuncs, mnodeCleanupFuncs},
|
||||
{"dnodes", mnodeInitDnodes, mnodeCleanupDnodes},
|
||||
{"dbs", mnodeInitDbs, mnodeCleanupDbs},
|
||||
{"vgroups", mnodeInitVgroups, mnodeCleanupVgroups},
|
||||
|
|
|
|||
|
|
@ -42,6 +42,7 @@
|
|||
#include "mnodeWrite.h"
|
||||
#include "mnodeRead.h"
|
||||
#include "mnodePeer.h"
|
||||
#include "mnodeFunc.h"
|
||||
|
||||
#define ALTER_CTABLE_RETRY_TIMES 3
|
||||
#define CREATE_CTABLE_RETRY_TIMES 10
|
||||
|
|
@ -104,6 +105,20 @@ static void mnodeDestroyChildTable(SCTableObj *pTable) {
|
|||
tfree(pTable);
|
||||
}
|
||||
|
||||
static char* mnodeGetTableShowPattern(SShowObj *pShow) {
|
||||
char* pattern = NULL;
|
||||
if (pShow != NULL && pShow->payloadLen > 0) {
|
||||
pattern = (char*)malloc(pShow->payloadLen + 1);
|
||||
if (pattern == NULL) {
|
||||
terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
|
||||
return NULL;
|
||||
}
|
||||
memcpy(pattern, pShow->payload, pShow->payloadLen);
|
||||
pattern[pShow->payloadLen] = 0;
|
||||
}
|
||||
return pattern;
|
||||
}
|
||||
|
||||
static int32_t mnodeChildTableActionDestroy(SSdbRow *pRow) {
|
||||
mnodeDestroyChildTable(pRow->pObj);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
|
|
@ -1620,6 +1635,11 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
|
|||
SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
|
||||
char stableName[TSDB_TABLE_NAME_LEN] = {0};
|
||||
|
||||
char* pattern = mnodeGetTableShowPattern(pShow);
|
||||
if (pShow->payloadLen > 0 && pattern == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (numOfRows < rows) {
|
||||
pShow->pIter = mnodeGetNextSuperTable(pShow->pIter, &pTable);
|
||||
if (pTable == NULL) break;
|
||||
|
|
@ -1631,7 +1651,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
|
|||
memset(stableName, 0, tListLen(stableName));
|
||||
mnodeExtractTableName(pTable->info.tableId, stableName);
|
||||
|
||||
if (pShow->payloadLen > 0 && patternMatch(pShow->payload, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
|
||||
if (pShow->payloadLen > 0 && patternMatch(pattern, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
|
||||
mnodeDecTableRef(pTable);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -1671,6 +1691,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
|
|||
|
||||
mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
|
||||
mnodeDecDbRef(pDb);
|
||||
free(pattern);
|
||||
|
||||
return numOfRows;
|
||||
}
|
||||
|
|
@ -2906,6 +2927,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
|
|||
|
||||
pInfo->numOfTables = htonl(pInfo->numOfTables);
|
||||
pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
|
||||
pInfo->numOfUdfs = htonl(pInfo->numOfUdfs);
|
||||
|
||||
int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
|
||||
|
||||
|
|
@ -2914,9 +2936,9 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
|
|||
char* str = strndup(pInfo->tableNames, contLen);
|
||||
char** nameList = strsplit(str, ",", &num);
|
||||
SArray* pList = taosArrayInit(4, POINTER_BYTES);
|
||||
SMultiTableMeta *pMultiMeta = NULL;
|
||||
|
||||
if (num != pInfo->numOfTables + pInfo->numOfVgroups) {
|
||||
SMultiTableMeta *pMultiMeta = NULL;
|
||||
if (num != pInfo->numOfTables + pInfo->numOfVgroups + pInfo->numOfUdfs) {
|
||||
mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
|
||||
code = TSDB_CODE_MND_INVALID_TABLE_NAME;
|
||||
goto _end;
|
||||
|
|
@ -2991,8 +3013,10 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
|
|||
}
|
||||
}
|
||||
|
||||
int32_t tableNum = pInfo->numOfTables + pInfo->numOfVgroups;
|
||||
|
||||
// add the additional super table names that needs the vgroup info
|
||||
for(;t < num; ++t) {
|
||||
for(;t < tableNum; ++t) {
|
||||
taosArrayPush(pList, &nameList[t]);
|
||||
}
|
||||
|
||||
|
|
@ -3023,6 +3047,36 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
|
|||
pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
|
||||
|
||||
pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
|
||||
|
||||
// add the user-defined-function information
|
||||
for(int32_t i = 0; i < pInfo->numOfUdfs; ++i, ++t) {
|
||||
char buf[TSDB_FUNC_NAME_LEN] = {0};
|
||||
strcpy(buf, nameList[t]);
|
||||
|
||||
SFuncObj* pFuncObj = mnodeGetFunc(buf);
|
||||
if (pFuncObj == NULL) {
|
||||
mError("function %s does not exist", buf);
|
||||
code = TSDB_CODE_MND_INVALID_FUNC;
|
||||
goto _end;
|
||||
}
|
||||
|
||||
SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) msg;
|
||||
|
||||
strcpy(pFuncInfo->name, buf);
|
||||
pFuncInfo->len = htonl(pFuncObj->contLen);
|
||||
memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
|
||||
|
||||
pFuncInfo->funcType = htonl(pFuncObj->funcType);
|
||||
pFuncInfo->resType = pFuncObj->resType;
|
||||
pFuncInfo->resBytes = htons(pFuncObj->resBytes);
|
||||
pFuncInfo->bufSize = htonl(pFuncObj->bufSize);
|
||||
|
||||
msg += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
|
||||
}
|
||||
|
||||
pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
|
||||
pMultiMeta->numOfUdf = htonl(pInfo->numOfUdfs);
|
||||
|
||||
pMsg->rpcRsp.rsp = pMultiMeta;
|
||||
pMsg->rpcRsp.len = pMultiMeta->contLen;
|
||||
code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -3033,12 +3087,13 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
|
|||
goto _end;
|
||||
}
|
||||
|
||||
int32_t len = tsCompressString(pMultiMeta->meta, (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta), 1,
|
||||
tmp + sizeof(SMultiTableMeta), (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta) + 2, ONE_STAGE_COMP, NULL, 0);
|
||||
int32_t dataLen = (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta);
|
||||
int32_t len = tsCompressString(pMultiMeta->meta, dataLen, 1, tmp + sizeof(SMultiTableMeta), (int32_t)dataLen + 2,
|
||||
ONE_STAGE_COMP, NULL, 0);
|
||||
|
||||
pMultiMeta->metaClone = pInfo->metaClone;
|
||||
pMultiMeta->rawLen = pMultiMeta->contLen;
|
||||
if (len == -1 || len + sizeof(SMultiTableMeta) >= pMultiMeta->contLen + 2) { // compress failed, do not compress this binary data
|
||||
if (len == -1 || len >= dataLen + 2) { // compress failed, do not compress this binary data
|
||||
pMultiMeta->compressed = 0;
|
||||
memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta) + pMultiMeta->contLen);
|
||||
} else {
|
||||
|
|
@ -3158,15 +3213,9 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows
|
|||
char prefix[64] = {0};
|
||||
int32_t prefixLen = (int32_t)tableIdPrefix(pDb->name, prefix, 64);
|
||||
|
||||
char* pattern = NULL;
|
||||
if (pShow->payloadLen > 0) {
|
||||
pattern = (char*)malloc(pShow->payloadLen + 1);
|
||||
if (pattern == NULL) {
|
||||
terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
|
||||
return 0;
|
||||
}
|
||||
memcpy(pattern, pShow->payload, pShow->payloadLen);
|
||||
pattern[pShow->payloadLen] = 0;
|
||||
char* pattern = mnodeGetTableShowPattern(pShow);
|
||||
if (pShow->payloadLen > 0 && pattern == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (numOfRows < rows) {
|
||||
|
|
@ -3398,6 +3447,11 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
|
|||
strcat(prefix, TS_PATH_DELIMITER);
|
||||
int32_t prefixLen = (int32_t)strlen(prefix);
|
||||
|
||||
char* pattern = mnodeGetTableShowPattern(pShow);
|
||||
if (pShow->payloadLen > 0 && pattern == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (numOfRows < rows) {
|
||||
pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
|
||||
if (pTable == NULL) break;
|
||||
|
|
@ -3413,7 +3467,7 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
|
|||
// pattern compare for table name
|
||||
mnodeExtractTableName(pTable->info.tableId, tableName);
|
||||
|
||||
if (pShow->payloadLen > 0 && patternMatch(pShow->payload, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
|
||||
if (pShow->payloadLen > 0 && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
|
||||
mnodeDecTableRef(pTable);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -3445,6 +3499,7 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
|
|||
|
||||
mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
|
||||
mnodeDecDbRef(pDb);
|
||||
free(pattern);
|
||||
|
||||
return numOfRows;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ extern "C" {
|
|||
#include "osSysinfo.h"
|
||||
#include "osTime.h"
|
||||
#include "osTimer.h"
|
||||
#include "osSystem.h"
|
||||
|
||||
void osInit();
|
||||
|
||||
|
|
|
|||
|
|
@ -76,7 +76,8 @@ extern "C" {
|
|||
#include <dispatch/dispatch.h>
|
||||
#include "osEok.h"
|
||||
#else
|
||||
#include <argp.h>
|
||||
#include <argp.h>
|
||||
#include <dlfcn.h>
|
||||
#include <endian.h>
|
||||
#include <linux/sysctl.h>
|
||||
#include <poll.h>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,31 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef TDENGINE_OS_SYSTEM_H
|
||||
#define TDENGINE_OS_SYSTEM_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void* taosLoadDll(const char *filename);
|
||||
void* taosLoadSym(void* handle, char* name);
|
||||
void taosCloseDll(void *handle);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#define _DEFAULT_SOURCE
|
||||
#include "os.h"
|
||||
#include "tglobal.h"
|
||||
#include "tulog.h"
|
||||
|
||||
void* taosLoadDll(const char *filename) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void* taosLoadSym(void* handle, char* name) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void taosCloseDll(void *handle) {
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -4,4 +4,4 @@ PROJECT(TDengine)
|
|||
AUX_SOURCE_DIRECTORY(. SRC)
|
||||
ADD_LIBRARY(oslinux ${SRC})
|
||||
|
||||
TARGET_LINK_LIBRARIES(oslinux m rt z)
|
||||
TARGET_LINK_LIBRARIES(oslinux m rt z dl)
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#define _DEFAULT_SOURCE
|
||||
#include "os.h"
|
||||
#include "tconfig.h"
|
||||
#include "tglobal.h"
|
||||
#include "tulog.h"
|
||||
|
||||
void* taosLoadDll(const char *filename) {
|
||||
void *handle = dlopen (filename, RTLD_LAZY);
|
||||
if (!handle) {
|
||||
uError("load dll:%s failed, error:%s", filename, dlerror());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uDebug("dll %s loaded", filename);
|
||||
|
||||
return handle;
|
||||
}
|
||||
|
||||
void* taosLoadSym(void* handle, char* name) {
|
||||
void* sym = dlsym(handle, name);
|
||||
char* error = NULL;
|
||||
|
||||
if ((error = dlerror()) != NULL) {
|
||||
uWarn("load sym:%s failed, error:%s", name, dlerror());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uDebug("sym %s loaded", name)
|
||||
|
||||
return sym;
|
||||
}
|
||||
|
||||
void taosCloseDll(void *handle) {
|
||||
if (handle) {
|
||||
dlclose(handle);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#define _DEFAULT_SOURCE
|
||||
#include "os.h"
|
||||
#include "tglobal.h"
|
||||
#include "tulog.h"
|
||||
|
||||
void* taosLoadDll(const char *filename) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void* taosLoadSym(void* handle, char* name) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void taosCloseDll(void *handle) {
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
#define HTTP_PARSER_H
|
||||
#include "httpGzip.h"
|
||||
|
||||
#define HTTP_MAX_URL 5 // http url stack size
|
||||
#define HTTP_MAX_URL 6 // http url stack size
|
||||
|
||||
#define HTTP_CODE_CONTINUE 100
|
||||
#define HTTP_CODE_SWITCHING_PROTOCOL 101
|
||||
|
|
|
|||
|
|
@ -35,4 +35,7 @@ void httpTrimTableName(char *name);
|
|||
int32_t httpShrinkTableName(HttpContext *pContext, int32_t pos, char *name);
|
||||
char * httpGetCmdsString(HttpContext *pContext, int32_t pos);
|
||||
|
||||
int32_t httpCheckAllocEscapeSql(char *oldSql, char **newSql);
|
||||
void httpCheckFreeEscapedSql(char *oldSql, char *newSql);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -176,6 +176,16 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
|
|||
return false;
|
||||
}
|
||||
|
||||
#define ESCAPE_ERROR_PROC(code, context, root) \
|
||||
do { \
|
||||
if (code != TSDB_CODE_SUCCESS) { \
|
||||
httpSendErrorResp(context, code); \
|
||||
\
|
||||
cJSON_Delete(root); \
|
||||
return false; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
for (int32_t i = 0; i < size; ++i) {
|
||||
cJSON* query = cJSON_GetArrayItem(root, i);
|
||||
if (query == NULL) continue;
|
||||
|
|
@ -186,7 +196,14 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
|
|||
continue;
|
||||
}
|
||||
|
||||
int32_t refIdBuffer = httpAddToSqlCmdBuffer(pContext, refId->valuestring);
|
||||
char *newStr = NULL;
|
||||
int32_t retCode = 0;
|
||||
|
||||
retCode = httpCheckAllocEscapeSql(refId->valuestring, &newStr);
|
||||
ESCAPE_ERROR_PROC(retCode, pContext, root);
|
||||
|
||||
int32_t refIdBuffer = httpAddToSqlCmdBuffer(pContext, newStr);
|
||||
httpCheckFreeEscapedSql(refId->valuestring, newStr);
|
||||
if (refIdBuffer == -1) {
|
||||
httpWarn("context:%p, fd:%d, user:%s, refId buffer is full", pContext, pContext->fd, pContext->user);
|
||||
break;
|
||||
|
|
@ -195,7 +212,11 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
|
|||
cJSON* alias = cJSON_GetObjectItem(query, "alias");
|
||||
int32_t aliasBuffer = -1;
|
||||
if (!(alias == NULL || alias->valuestring == NULL || strlen(alias->valuestring) == 0)) {
|
||||
aliasBuffer = httpAddToSqlCmdBuffer(pContext, alias->valuestring);
|
||||
retCode = httpCheckAllocEscapeSql(alias->valuestring, &newStr);
|
||||
ESCAPE_ERROR_PROC(retCode, pContext, root);
|
||||
|
||||
aliasBuffer = httpAddToSqlCmdBuffer(pContext, newStr);
|
||||
httpCheckFreeEscapedSql(alias->valuestring, newStr);
|
||||
if (aliasBuffer == -1) {
|
||||
httpWarn("context:%p, fd:%d, user:%s, alias buffer is full", pContext, pContext->fd, pContext->user);
|
||||
break;
|
||||
|
|
@ -211,7 +232,11 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
|
|||
continue;
|
||||
}
|
||||
|
||||
int32_t sqlBuffer = httpAddToSqlCmdBuffer(pContext, sql->valuestring);
|
||||
retCode = httpCheckAllocEscapeSql(sql->valuestring, &newStr);
|
||||
ESCAPE_ERROR_PROC(retCode, pContext, root);
|
||||
|
||||
int32_t sqlBuffer = httpAddToSqlCmdBuffer(pContext, newStr);
|
||||
httpCheckFreeEscapedSql(sql->valuestring, newStr);
|
||||
if (sqlBuffer == -1) {
|
||||
httpWarn("context:%p, fd:%d, user:%s, sql buffer is full", pContext, pContext->fd, pContext->user);
|
||||
break;
|
||||
|
|
@ -237,6 +262,8 @@ bool gcProcessQueryRequest(HttpContext* pContext) {
|
|||
}
|
||||
}
|
||||
|
||||
#undef ESCAPE_ERROR_PROC
|
||||
|
||||
pContext->reqType = HTTP_REQTYPE_MULTI_SQL;
|
||||
pContext->encodeMethod = &gcQueryMethod;
|
||||
pContext->multiCmds->pos = 0;
|
||||
|
|
|
|||
|
|
@ -119,6 +119,90 @@ bool restProcessSqlRequest(HttpContext* pContext, int32_t timestampFmt) {
|
|||
return true;
|
||||
}
|
||||
|
||||
#define REST_FUNC_URL_POS 2
|
||||
#define REST_OUTP_URL_POS 3
|
||||
#define REST_AGGR_URL_POS 4
|
||||
#define REST_BUFF_URL_POS 5
|
||||
|
||||
#define HTTP_FUNC_LEN 32
|
||||
#define HTTP_OUTP_LEN 16
|
||||
#define HTTP_AGGR_LEN 2
|
||||
#define HTTP_BUFF_LEN 32
|
||||
|
||||
static int udfSaveFile(const char *fname, const char *content, long len) {
|
||||
int fd = open(fname, O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0755);
|
||||
if (fd < 0)
|
||||
return -1;
|
||||
if (taosWrite(fd, (void *)content, len) < 0)
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool restProcessUdfRequest(HttpContext* pContext) {
|
||||
HttpParser* pParser = pContext->parser;
|
||||
if (pParser->path[REST_FUNC_URL_POS].pos >= HTTP_FUNC_LEN || pParser->path[REST_FUNC_URL_POS].pos <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pParser->path[REST_OUTP_URL_POS].pos >= HTTP_OUTP_LEN || pParser->path[REST_OUTP_URL_POS].pos <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pParser->path[REST_AGGR_URL_POS].pos >= HTTP_AGGR_LEN || pParser->path[REST_AGGR_URL_POS].pos <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pParser->path[REST_BUFF_URL_POS].pos >= HTTP_BUFF_LEN || pParser->path[REST_BUFF_URL_POS].pos <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
char* sql = pContext->parser->body.str;
|
||||
int len = pContext->parser->body.pos;
|
||||
if (sql == NULL) {
|
||||
httpSendErrorResp(pContext, TSDB_CODE_HTTP_NO_SQL_INPUT);
|
||||
return false;
|
||||
}
|
||||
|
||||
char udfDir[256] = {0};
|
||||
char buf[64] = "udf-";
|
||||
char funcName[64] = {0};
|
||||
int aggr = 0;
|
||||
char outputType[16] = {0};
|
||||
char buffSize[32] = {0};
|
||||
|
||||
tstrncpy(funcName, pParser->path[REST_FUNC_URL_POS].str, HTTP_FUNC_LEN);
|
||||
tstrncpy(buf + 4, funcName, HTTP_FUNC_LEN);
|
||||
|
||||
if (pParser->path[REST_AGGR_URL_POS].str[0] != '0') {
|
||||
aggr = 1;
|
||||
}
|
||||
|
||||
tstrncpy(outputType, pParser->path[REST_OUTP_URL_POS].str, HTTP_OUTP_LEN);
|
||||
tstrncpy(buffSize, pParser->path[REST_BUFF_URL_POS].str, HTTP_BUFF_LEN);
|
||||
|
||||
taosGetTmpfilePath(funcName, udfDir);
|
||||
|
||||
udfSaveFile(udfDir, sql, len);
|
||||
|
||||
tfree(sql);
|
||||
pContext->parser->body.str = malloc(1024);
|
||||
sql = pContext->parser->body.str;
|
||||
int sqlLen = sprintf(sql, "create %s function %s as \"%s\" outputtype %s bufsize %s",
|
||||
aggr == 1 ? "aggregate" : " ", funcName, udfDir, outputType, buffSize);
|
||||
|
||||
pContext->parser->body.pos = sqlLen;
|
||||
pContext->parser->body.size = sqlLen + 1;
|
||||
|
||||
HttpSqlCmd* cmd = &(pContext->singleCmd);
|
||||
cmd->nativSql = sql;
|
||||
|
||||
pContext->reqType = HTTP_REQTYPE_SINGLE_SQL;
|
||||
pContext->encodeMethod = &restEncodeSqlLocalTimeStringMethod;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool restProcessRequest(struct HttpContext* pContext) {
|
||||
if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "login")) {
|
||||
restGetUserFromUrl(pContext);
|
||||
|
|
@ -138,6 +222,8 @@ bool restProcessRequest(struct HttpContext* pContext) {
|
|||
return restProcessSqlRequest(pContext, REST_TIMESTAMP_FMT_UTC_STRING);
|
||||
} else if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "login")) {
|
||||
return restProcessLoginRequest(pContext);
|
||||
} else if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "udf")) {
|
||||
return restProcessUdfRequest(pContext);
|
||||
} else {
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -423,3 +423,65 @@ void httpProcessRequest(HttpContext *pContext) {
|
|||
httpExecCmd(pContext);
|
||||
}
|
||||
}
|
||||
|
||||
int32_t httpCheckAllocEscapeSql(char *oldSql, char **newSql)
|
||||
{
|
||||
char *pos;
|
||||
|
||||
if (oldSql == NULL || newSql == NULL) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
/* bad sql clause */
|
||||
pos = strstr(oldSql, "%%");
|
||||
if (pos) {
|
||||
httpError("bad sql:%s", oldSql);
|
||||
return TSDB_CODE_HTTP_REQUEST_JSON_ERROR;
|
||||
}
|
||||
|
||||
pos = strchr(oldSql, '%');
|
||||
if (pos == NULL) {
|
||||
httpDebug("sql:%s", oldSql);
|
||||
*newSql = oldSql;
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
*newSql = (char *) calloc(1, (strlen(oldSql) << 1) + 1);
|
||||
if (newSql == NULL) {
|
||||
httpError("failed to allocate for new sql, old sql:%s", oldSql);
|
||||
return TSDB_CODE_HTTP_NO_ENOUGH_MEMORY;
|
||||
}
|
||||
|
||||
char *src = oldSql;
|
||||
char *dst = *newSql;
|
||||
size_t sqlLen = strlen(src);
|
||||
|
||||
while (1) {
|
||||
memcpy(dst, src, pos - src + 1);
|
||||
dst += pos - src + 1;
|
||||
*dst++ = '%';
|
||||
|
||||
if (pos + 1 >= oldSql + sqlLen) {
|
||||
break;
|
||||
}
|
||||
|
||||
src = ++pos;
|
||||
pos = strchr(pos, '%');
|
||||
if (pos == NULL) {
|
||||
memcpy(dst, src, strlen(src));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
void httpCheckFreeEscapedSql(char *oldSql, char *newSql)
|
||||
{
|
||||
if (oldSql && newSql) {
|
||||
if (oldSql != newSql) {
|
||||
free(newSql);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -610,7 +610,18 @@ bool tgProcessSingleMetric(HttpContext *pContext, cJSON *metric, char *db) {
|
|||
// stable tag for detail
|
||||
for (int32_t i = 0; i < orderTagsLen; ++i) {
|
||||
cJSON *tag = orderedTags[i];
|
||||
stable_cmd->tagNames[i] = table_cmd->tagNames[i] = httpAddToSqlCmdBuffer(pContext, tag->string);
|
||||
|
||||
char *tagStr = NULL;
|
||||
int32_t retCode = httpCheckAllocEscapeSql(tag->string, &tagStr);
|
||||
if (retCode != TSDB_CODE_SUCCESS) {
|
||||
httpSendErrorResp(pContext, retCode);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
stable_cmd->tagNames[i] = table_cmd->tagNames[i] = httpAddToSqlCmdBuffer(pContext, tagStr);
|
||||
|
||||
httpCheckFreeEscapedSql(tag->string, tagStr);
|
||||
|
||||
if (tag->type == cJSON_String)
|
||||
stable_cmd->tagValues[i] = table_cmd->tagValues[i] = httpAddToSqlCmdBuffer(pContext, "'%s'", tag->valuestring);
|
||||
|
|
|
|||
|
|
@ -8,14 +8,14 @@ INCLUDE_DIRECTORIES(inc)
|
|||
AUX_SOURCE_DIRECTORY(src SRC)
|
||||
ADD_LIBRARY(query ${SRC})
|
||||
SET_SOURCE_FILES_PROPERTIES(src/sql.c PROPERTIES COMPILE_FLAGS -w)
|
||||
TARGET_LINK_LIBRARIES(query tsdb tutil)
|
||||
TARGET_LINK_LIBRARIES(query tsdb tutil lua)
|
||||
|
||||
IF (TD_LINUX)
|
||||
TARGET_LINK_LIBRARIES(query m rt)
|
||||
TARGET_LINK_LIBRARIES(query m rt lua)
|
||||
ADD_SUBDIRECTORY(tests)
|
||||
ENDIF ()
|
||||
|
||||
IF (TD_DARWIN)
|
||||
TARGET_LINK_LIBRARIES(query m)
|
||||
TARGET_LINK_LIBRARIES(query m lua)
|
||||
ADD_SUBDIRECTORY(tests)
|
||||
ENDIF ()
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ extern "C" {
|
|||
#include "trpc.h"
|
||||
#include "tvariant.h"
|
||||
#include "tsdb.h"
|
||||
#include "qUdf.h"
|
||||
|
||||
#define TSDB_FUNC_INVALID_ID -1
|
||||
#define TSDB_FUNC_COUNT 0
|
||||
|
|
@ -201,10 +202,8 @@ typedef struct SAggFunctionInfo {
|
|||
int8_t stableFuncId; // transfer function for super table query
|
||||
uint16_t status;
|
||||
|
||||
bool (*init)(SQLFunctionCtx *pCtx); // setup the execute environment
|
||||
|
||||
bool (*init)(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultCellInfo); // setup the execute environment
|
||||
void (*xFunction)(SQLFunctionCtx *pCtx); // blocks version function
|
||||
// void (*xFunctionF)(SQLFunctionCtx *pCtx, int32_t position); // single-row function version, todo merge with blockwise function
|
||||
|
||||
// finalizer must be called after all xFunction has been executed to generated final result.
|
||||
void (*xFinalize)(SQLFunctionCtx *pCtx);
|
||||
|
|
@ -216,7 +215,7 @@ typedef struct SAggFunctionInfo {
|
|||
#define GET_RES_INFO(ctx) ((ctx)->resultInfo)
|
||||
|
||||
int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, int16_t *type,
|
||||
int16_t *len, int32_t *interBytes, int16_t extLength, bool isSuperTable);
|
||||
int16_t *len, int32_t *interBytes, int16_t extLength, bool isSuperTable, SUdfInfo* pUdfInfo);
|
||||
int32_t isValidFunction(const char* name, int32_t len);
|
||||
|
||||
#define IS_STREAM_QUERY_VALID(x) (((x)&TSDB_FUNCSTATE_STREAM) != 0)
|
||||
|
|
@ -262,9 +261,9 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
|
|||
static FORCE_INLINE void initResultInfo(SResultRowCellInfo *pResInfo, int32_t bufLen) {
|
||||
pResInfo->initialized = true; // the this struct has been initialized flag
|
||||
|
||||
pResInfo->complete = false;
|
||||
pResInfo->complete = false;
|
||||
pResInfo->hasResult = false;
|
||||
pResInfo->numOfRes = 0;
|
||||
pResInfo->numOfRes = 0;
|
||||
|
||||
memset(GET_ROWCELL_INTERBUF(pResInfo), 0, bufLen);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@
|
|||
#include "tarray.h"
|
||||
#include "tlockfree.h"
|
||||
#include "tsdb.h"
|
||||
#include "qUdf.h"
|
||||
|
||||
struct SColumnFilterElem;
|
||||
typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, const char* val1, const char* val2, int16_t type);
|
||||
|
|
@ -257,6 +258,7 @@ typedef struct SQueryAttr {
|
|||
SMemRef memRef;
|
||||
STableGroupInfo tableGroupInfo; // table <tid, last_key> list SArray<STableKeyInfo>
|
||||
int32_t vgId;
|
||||
SArray *pUdfInfo; // no need to free
|
||||
} SQueryAttr;
|
||||
|
||||
typedef SSDataBlock* (*__operator_fn_t)(void* param, bool* newgroup);
|
||||
|
|
@ -297,6 +299,7 @@ typedef struct SQueryRuntimeEnv {
|
|||
STableQueryInfo *current;
|
||||
SRspResultInfo resultInfo;
|
||||
SHashObj *pTableRetrieveTsMap;
|
||||
SUdfInfo *pUdfInfo;
|
||||
} SQueryRuntimeEnv;
|
||||
|
||||
enum {
|
||||
|
|
@ -392,6 +395,7 @@ typedef struct SQueryParam {
|
|||
SGroupbyExpr *pGroupbyExpr;
|
||||
int32_t tableScanOperator;
|
||||
SArray *pOperator;
|
||||
SUdfInfo *pUdfInfo;
|
||||
} SQueryParam;
|
||||
|
||||
typedef struct STableScanInfo {
|
||||
|
|
@ -531,6 +535,7 @@ typedef struct SMultiwayMergeInfo {
|
|||
|
||||
bool hasPrev;
|
||||
bool groupMix;
|
||||
SArray *udfInfo;
|
||||
} SMultiwayMergeInfo;
|
||||
|
||||
void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
|
||||
|
|
@ -553,8 +558,8 @@ SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperat
|
|||
SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
|
||||
SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
|
||||
int32_t numOfRows, void* merger, bool groupMix);
|
||||
SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo);
|
||||
SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
|
||||
SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param);
|
||||
SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
|
||||
SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
|
||||
int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
|
||||
|
|
@ -578,18 +583,19 @@ void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlo
|
|||
int32_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput);
|
||||
void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset);
|
||||
void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOfInputRows);
|
||||
void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity);
|
||||
|
||||
void freeParam(SQueryParam *param);
|
||||
int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param);
|
||||
int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
|
||||
SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg);
|
||||
SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg, SUdfInfo* pUdfInfo);
|
||||
|
||||
int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
|
||||
SSqlExpr **pExpr, SExprInfo *prevExpr);
|
||||
SSqlExpr **pExpr, SExprInfo *prevExpr, SUdfInfo *pUdfInfo);
|
||||
|
||||
SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
|
||||
SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
|
||||
SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t qId);
|
||||
SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t qId, SUdfInfo* pUdfInfo);
|
||||
|
||||
int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
|
||||
int32_t prevResultLen, void* merger);
|
||||
|
|
@ -608,6 +614,8 @@ bool doBuildResCheck(SQInfo* pQInfo);
|
|||
void setQueryStatus(SQueryRuntimeEnv *pRuntimeEnv, int8_t status);
|
||||
|
||||
bool onlyQueryTags(SQueryAttr* pQueryAttr);
|
||||
void destroyUdfInfo(SUdfInfo* pUdfInfo);
|
||||
|
||||
bool isValidQInfo(void *param);
|
||||
|
||||
int32_t doDumpQueryResult(SQInfo *pQInfo, char *data);
|
||||
|
|
@ -625,4 +633,6 @@ void freeQueryAttr(SQueryAttr *pQuery);
|
|||
|
||||
int32_t getMaximumIdleDurationSec();
|
||||
|
||||
void doInvokeUdf(SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type);
|
||||
|
||||
#endif // TDENGINE_QEXECUTOR_H
|
||||
|
|
|
|||
|
|
@ -0,0 +1,82 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef TDENGINE_QSCRIPT_H
|
||||
#define TDENGINE_QSCRIPT_H
|
||||
|
||||
#include <lua.h>
|
||||
#include <lauxlib.h>
|
||||
#include <lualib.h>
|
||||
|
||||
#include "tutil.h"
|
||||
#include "hash.h"
|
||||
#include "tlist.h"
|
||||
#include "qUdf.h"
|
||||
|
||||
#define MAX_FUNC_NAME 64
|
||||
|
||||
#define USER_FUNC_NAME "funcName"
|
||||
#define USER_FUNC_NAME_LIMIT 48
|
||||
|
||||
enum ScriptState {
|
||||
SCRIPT_STATE_INIT,
|
||||
SCRIPT_STATE_ADD,
|
||||
SCRIPT_STATE_MERGE,
|
||||
SCRIPT_STATE_FINALIZE
|
||||
};
|
||||
|
||||
|
||||
typedef struct {
|
||||
SHashObj *funcId; //func already registed in lua_env, may be no use
|
||||
lua_State *lua_state; // lua env
|
||||
} ScriptEnv;
|
||||
|
||||
typedef struct ScriptCtx {
|
||||
char funcName[USER_FUNC_NAME_LIMIT];
|
||||
int8_t state;
|
||||
ScriptEnv *pEnv;
|
||||
int8_t isAgg; // agg function or not
|
||||
|
||||
// init value of udf script
|
||||
int8_t resType;
|
||||
int16_t resBytes;
|
||||
|
||||
int32_t numOfOutput;
|
||||
int32_t offset;
|
||||
|
||||
} ScriptCtx;
|
||||
|
||||
int taosLoadScriptInit(void *pInit);
|
||||
void taosLoadScriptNormal(void *pInit, char *pInput, int16_t iType, int16_t iBytes, int32_t numOfRows,
|
||||
int64_t *ptsList, int64_t key, char* pOutput, char *ptsOutput, int32_t *numOfOutput, int16_t oType, int16_t oBytes);
|
||||
void taosLoadScriptFinalize(void *pInit, int64_t key, char *pOutput, int32_t *output);
|
||||
void taosLoadScriptMerge(void *pCtx, char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput);
|
||||
void taosLoadScriptDestroy(void *pInit);
|
||||
|
||||
typedef struct {
|
||||
SList *scriptEnvs; //
|
||||
int32_t mSize; // pool limit
|
||||
int32_t cSize; // current available size
|
||||
pthread_mutex_t mutex;
|
||||
} ScriptEnvPool;
|
||||
|
||||
ScriptCtx* createScriptCtx(char *str, int8_t resType, int16_t resBytes);
|
||||
void destroyScriptCtx(void *pScriptCtx);
|
||||
|
||||
int32_t scriptEnvPoolInit();
|
||||
void scriptEnvPoolCleanup();
|
||||
bool isValidScript(char *script, int32_t len);
|
||||
|
||||
#endif //TDENGINE_QSCRIPT_H
|
||||
|
|
@ -182,6 +182,15 @@ typedef struct SCreateDbInfo {
|
|||
int16_t partitions;
|
||||
} SCreateDbInfo;
|
||||
|
||||
typedef struct SCreateFuncInfo {
|
||||
SStrToken name;
|
||||
SStrToken path;
|
||||
int32_t type;
|
||||
int32_t bufSize;
|
||||
TAOS_FIELD output;
|
||||
} SCreateFuncInfo;
|
||||
|
||||
|
||||
typedef struct SCreateAcctInfo {
|
||||
int32_t maxUsers;
|
||||
int32_t maxDbs;
|
||||
|
|
@ -214,10 +223,11 @@ typedef struct SMiscInfo {
|
|||
int16_t tableType;
|
||||
SUserInfo user;
|
||||
union {
|
||||
SCreateDbInfo dbOpt;
|
||||
SCreateAcctInfo acctOpt;
|
||||
SShowInfo showOpt;
|
||||
SStrToken id;
|
||||
SCreateDbInfo dbOpt;
|
||||
SCreateAcctInfo acctOpt;
|
||||
SCreateFuncInfo funcOpt;
|
||||
SShowInfo showOpt;
|
||||
SStrToken id;
|
||||
};
|
||||
} SMiscInfo;
|
||||
|
||||
|
|
@ -226,6 +236,7 @@ typedef struct SSqlInfo {
|
|||
bool valid;
|
||||
SArray *list; // todo refactor
|
||||
char msg[256];
|
||||
SArray *funcs;
|
||||
union {
|
||||
SCreateTableSql *pCreateTableInfo;
|
||||
SAlterTableInfo *pAlterInfo;
|
||||
|
|
@ -271,6 +282,7 @@ SRelationInfo *addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrT
|
|||
// sql expr leaf node
|
||||
tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
|
||||
tSqlExpr *tSqlExprCreateFunction(SArray *pParam, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
|
||||
SArray *tStrTokenAppend(SArray *pList, SStrToken *pToken);
|
||||
|
||||
tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType);
|
||||
tSqlExpr *tSqlExprClone(tSqlExpr *pSrc);
|
||||
|
|
|
|||
|
|
@ -106,11 +106,14 @@ typedef struct SQueryInfo {
|
|||
STagCond tagCond;
|
||||
|
||||
SOrderVal order;
|
||||
int16_t fillType; // final result fill type
|
||||
int16_t numOfTables;
|
||||
STableMetaInfo **pTableMetaInfo;
|
||||
struct STSBuf *tsBuf;
|
||||
|
||||
int16_t fillType; // final result fill type
|
||||
int64_t * fillVal; // default value for fill
|
||||
int32_t numOfFillVal; // fill value size
|
||||
|
||||
char * msg; // pointer to the pCmd->payload to keep error message temporarily
|
||||
int64_t clauseLimit; // limit for current sub clause
|
||||
|
||||
|
|
@ -122,8 +125,12 @@ typedef struct SQueryInfo {
|
|||
int32_t round; // 0/1/....
|
||||
int32_t bufLen;
|
||||
char* buf;
|
||||
struct SQInfo* pQInfo; // global merge operator
|
||||
struct SQueryAttr* pQueryAttr; // query object
|
||||
|
||||
bool udfCopy;
|
||||
SArray *pUdfInfo;
|
||||
|
||||
struct SQInfo *pQInfo; // global merge operator
|
||||
struct SQueryAttr *pQueryAttr; // query object
|
||||
|
||||
struct SQueryInfo *sibling; // sibling
|
||||
SArray *pUpstream; // SArray<struct SQueryInfo>
|
||||
|
|
@ -138,6 +145,7 @@ typedef struct SQueryInfo {
|
|||
bool onlyTagQuery;
|
||||
bool orderProjectQuery;
|
||||
bool stateWindow;
|
||||
bool globalMerge;
|
||||
} SQueryInfo;
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -0,0 +1,74 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef TDENGINE_QUDF_H
|
||||
#define TDENGINE_QUDF_H
|
||||
|
||||
enum { TSDB_UDF_FUNC_NORMAL = 0, TSDB_UDF_FUNC_INIT, TSDB_UDF_FUNC_FINALIZE, TSDB_UDF_FUNC_MERGE, TSDB_UDF_FUNC_DESTROY, TSDB_UDF_FUNC_MAX_NUM };
|
||||
|
||||
|
||||
|
||||
typedef struct SUdfInit{
|
||||
int32_t maybe_null; /* 1 if function can return NULL */
|
||||
uint32_t decimals; /* for real functions */
|
||||
uint64_t length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
int32_t const_item; /* 0 if result is independent of arguments */
|
||||
|
||||
// script like lua/javascript
|
||||
void* script_ctx;
|
||||
void (*destroyCtxFunc)(void *script_ctx);
|
||||
} SUdfInit;
|
||||
|
||||
|
||||
typedef struct SUdfInfo {
|
||||
int32_t functionId; // system assigned function id
|
||||
int32_t funcType; // scalar function or aggregate function
|
||||
int8_t resType; // result type
|
||||
int16_t resBytes; // result byte
|
||||
int32_t contLen; // content length
|
||||
int32_t bufSize; //interbuf size
|
||||
char *name; // function name
|
||||
void *handle; // handle loaded in mem
|
||||
void *funcs[TSDB_UDF_FUNC_MAX_NUM]; // function ptr
|
||||
|
||||
// for script like lua/javascript only
|
||||
int isScript;
|
||||
void *pScriptCtx;
|
||||
|
||||
SUdfInit init;
|
||||
char *content;
|
||||
char *path;
|
||||
} SUdfInfo;
|
||||
|
||||
//script
|
||||
|
||||
typedef int32_t (*scriptInitFunc)(void *pCtx);
|
||||
typedef void (*scriptNormalFunc)(void *pCtx, char* data, int16_t iType, int16_t iBytes, int32_t numOfRows,
|
||||
int64_t* ptList, int64_t key, char* dataOutput, char* tsOutput, int32_t* numOfOutput, int16_t oType, int16_t oBytes);
|
||||
typedef void (*scriptFinalizeFunc)(void *pCtx, int64_t key, char* dataOutput, int32_t* numOfOutput);
|
||||
typedef void (*scriptMergeFunc)(void *pCtx, char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput);
|
||||
typedef void (*scriptDestroyFunc)(void* pCtx);
|
||||
|
||||
// dynamic lib
|
||||
typedef void (*udfNormalFunc)(char* data, int16_t itype, int16_t iBytes, int32_t numOfRows, int64_t* ts, char* dataOutput, char* interBuf,
|
||||
char* tsOutput, int32_t* numOfOutput, int16_t oType, int16_t oBytes, SUdfInit* buf);
|
||||
typedef int32_t (*udfInitFunc)(SUdfInit* data);
|
||||
typedef void (*udfFinalizeFunc)(char* dataOutput, char *interBuf, int32_t* numOfOutput, SUdfInit* buf);
|
||||
typedef void (*udfMergeFunc)(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf);
|
||||
typedef void (*udfDestroyFunc)(SUdfInit* buf);
|
||||
|
||||
|
||||
#endif // TDENGINE_QUDF_H
|
||||
|
|
@ -104,4 +104,6 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
|
|||
|
||||
int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, SQueryRuntimeEnv *pRuntimeEnv, int32_t* offset);
|
||||
|
||||
int32_t initUdfInfo(SUdfInfo* pUdfInfo);
|
||||
|
||||
#endif // TDENGINE_QUERYUTIL_H
|
||||
|
|
|
|||
|
|
@ -65,6 +65,7 @@ program ::= cmd. {}
|
|||
//////////////////////////////////THE SHOW STATEMENT///////////////////////////////////////////
|
||||
cmd ::= SHOW DATABASES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_DB, 0, 0);}
|
||||
cmd ::= SHOW TOPICS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);}
|
||||
cmd ::= SHOW FUNCTIONS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_FUNCTION, 0, 0);}
|
||||
cmd ::= SHOW MNODES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);}
|
||||
cmd ::= SHOW DNODES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);}
|
||||
cmd ::= SHOW ACCOUNTS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);}
|
||||
|
|
@ -147,6 +148,7 @@ cmd ::= DROP STABLE ifexists(Y) ids(X) cpxName(Z). {
|
|||
|
||||
cmd ::= DROP DATABASE ifexists(Y) ids(X). { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_DEFAULT, -1); }
|
||||
cmd ::= DROP TOPIC ifexists(Y) ids(X). { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_TOPIC, -1); }
|
||||
cmd ::= DROP FUNCTION ids(X). { setDropFuncInfo(pInfo, TSDB_SQL_DROP_FUNCTION, &X); }
|
||||
|
||||
cmd ::= DROP DNODE ids(X). { setDCLSqlElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &X); }
|
||||
cmd ::= DROP USER ids(X). { setDCLSqlElems(pInfo, TSDB_SQL_DROP_USER, 1, &X); }
|
||||
|
|
@ -200,8 +202,13 @@ cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
|
|||
{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);}
|
||||
cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
|
||||
cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
|
||||
cmd ::= CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B). { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 1);}
|
||||
cmd ::= CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B). { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 2);}
|
||||
cmd ::= CREATE USER ids(X) PASS ids(Y). { setCreateUserSql(pInfo, &X, &Y);}
|
||||
|
||||
bufsize(Y) ::= . { Y.n = 0; }
|
||||
bufsize(Y) ::= BUFSIZE INTEGER(X). { Y = X; }
|
||||
|
||||
pps(Y) ::= . { Y.n = 0; }
|
||||
pps(Y) ::= PPS INTEGER(X). { Y = X; }
|
||||
|
||||
|
|
@ -704,10 +711,10 @@ expr(A) ::= BOOL(X). { A = tSqlExprCreateIdValue(&X, TK_BOOL);}
|
|||
expr(A) ::= NULL(X). { A = tSqlExprCreateIdValue(&X, TK_NULL);}
|
||||
|
||||
// ordinary functions: min(x), max(x), top(k, 20)
|
||||
expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSqlExprCreateFunction(Y, &X, &E, X.type); }
|
||||
expr(A) ::= ID(X) LP exprlist(Y) RP(E). { tStrTokenAppend(pInfo->funcs, &X); A = tSqlExprCreateFunction(Y, &X, &E, X.type); }
|
||||
|
||||
// for parsing sql functions with wildcard for parameters. e.g., count(*)/first(*)/last(*) operation
|
||||
expr(A) ::= ID(X) LP STAR RP(Y). { A = tSqlExprCreateFunction(NULL, &X, &Y, X.type); }
|
||||
expr(A) ::= ID(X) LP STAR RP(Y). { tStrTokenAppend(pInfo->funcs, &X); A = tSqlExprCreateFunction(NULL, &X, &Y, X.type); }
|
||||
|
||||
// is (not) null expression
|
||||
expr(A) ::= expr(X) IS NULL. {A = tSqlExprCreate(X, NULL, TK_ISNULL);}
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@
|
|||
#include "qPercentile.h"
|
||||
#include "qTsbuf.h"
|
||||
#include "queryLog.h"
|
||||
#include "qUdf.h"
|
||||
|
||||
#define GET_INPUT_DATA_LIST(x) ((char *)((x)->pInput))
|
||||
#define GET_INPUT_DATA(x, y) (GET_INPUT_DATA_LIST(x) + (y) * (x)->inputBytes)
|
||||
|
|
@ -169,12 +170,13 @@ typedef struct SDerivInfo {
|
|||
} SDerivInfo;
|
||||
|
||||
int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, int16_t *type,
|
||||
int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable) {
|
||||
int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable, SUdfInfo* pUdfInfo) {
|
||||
if (!isValidDataType(dataType)) {
|
||||
qError("Illegal data type %d or data type length %d", dataType, dataBytes);
|
||||
return TSDB_CODE_TSC_INVALID_OPERATION;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY ||
|
||||
functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAGPRJ ||
|
||||
functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_INTERP) {
|
||||
|
|
@ -234,6 +236,20 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
|
|||
}
|
||||
|
||||
if (isSuperTable) {
|
||||
if (functionId < 0) {
|
||||
if (pUdfInfo->bufSize > 0) {
|
||||
*type = TSDB_DATA_TYPE_BINARY;
|
||||
*bytes = pUdfInfo->bufSize;
|
||||
*interBytes = *bytes;
|
||||
} else {
|
||||
*type = pUdfInfo->resType;
|
||||
*bytes = pUdfInfo->resBytes;
|
||||
*interBytes = *bytes;
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (functionId == TSDB_FUNC_MIN || functionId == TSDB_FUNC_MAX) {
|
||||
*type = TSDB_DATA_TYPE_BINARY;
|
||||
*bytes = (int16_t)(dataBytes + DATA_SET_FLAG_SIZE);
|
||||
|
|
@ -288,7 +304,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (functionId == TSDB_FUNC_SUM) {
|
||||
if (IS_SIGNED_NUMERIC_TYPE(dataType)) {
|
||||
*type = TSDB_DATA_TYPE_BIGINT;
|
||||
|
|
@ -313,7 +329,20 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
|
|||
*interBytes = sizeof(STwaInfo);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
if (functionId < 0) {
|
||||
*type = pUdfInfo->resType;
|
||||
*bytes = pUdfInfo->resBytes;
|
||||
|
||||
if (pUdfInfo->bufSize > 0) {
|
||||
*interBytes = pUdfInfo->bufSize;
|
||||
} else {
|
||||
*interBytes = *bytes;
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (functionId == TSDB_FUNC_AVG) {
|
||||
*type = TSDB_DATA_TYPE_DOUBLE;
|
||||
*bytes = sizeof(double);
|
||||
|
|
@ -390,14 +419,13 @@ int32_t isValidFunction(const char* name, int32_t len) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
static bool function_setup(SQLFunctionCtx *pCtx) {
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
if (pResInfo->initialized) {
|
||||
static bool function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (pResultInfo->initialized) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(pCtx->pOutput, 0, (size_t)pCtx->outputBytes);
|
||||
initResultInfo(pResInfo, pCtx->interBufBytes);
|
||||
initResultInfo(pResultInfo, pCtx->interBufBytes);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -985,8 +1013,8 @@ static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin,
|
|||
}
|
||||
}
|
||||
|
||||
static bool min_func_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool min_func_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (!function_setup(pCtx, pResultInfo)) {
|
||||
return false; // not initialized since it has been initialized
|
||||
}
|
||||
|
||||
|
|
@ -1030,8 +1058,8 @@ static bool min_func_setup(SQLFunctionCtx *pCtx) {
|
|||
return true;
|
||||
}
|
||||
|
||||
static bool max_func_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool max_func_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (!function_setup(pCtx, pResultInfo)) {
|
||||
return false; // not initialized since it has been initialized
|
||||
}
|
||||
|
||||
|
|
@ -1435,8 +1463,8 @@ static void stddev_dst_finalizer(SQLFunctionCtx *pCtx) {
|
|||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
static bool first_last_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool first_last_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1606,7 +1634,7 @@ static void last_function(SQLFunctionCtx *pCtx) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SET_VAL(pCtx, notNullElems, 1);
|
||||
}
|
||||
|
||||
|
|
@ -2007,7 +2035,7 @@ static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
|
|||
char *tmp = (char *)pTopBotInfo + sizeof(STopBotInfo);
|
||||
pTopBotInfo->res = (tValuePair**) tmp;
|
||||
tmp += POINTER_BYTES * pCtx->param[0].i64;
|
||||
|
||||
|
||||
size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
|
||||
|
||||
for (int32_t i = 0; i < pCtx->param[0].i64; ++i) {
|
||||
|
|
@ -2073,14 +2101,13 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
|
|||
}
|
||||
}
|
||||
|
||||
static bool top_bottom_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool top_bottom_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
STopBotInfo *pInfo = getTopBotOutputInfo(pCtx);
|
||||
buildTopBotStruct(pInfo, pCtx);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -2229,14 +2256,13 @@ static void top_bottom_func_finalizer(SQLFunctionCtx *pCtx) {
|
|||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////
|
||||
static bool percentile_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool percentile_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (!function_setup(pCtx, pResultInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// in the first round, get the min-max value of all involved data
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
|
||||
SET_DOUBLE_VAL(&pInfo->minval, DBL_MAX);
|
||||
SET_DOUBLE_VAL(&pInfo->maxval, -DBL_MAX);
|
||||
pInfo->numOfElems = 0;
|
||||
|
|
@ -2367,8 +2393,8 @@ static SAPercentileInfo *getAPerctInfo(SQLFunctionCtx *pCtx) {
|
|||
return pInfo;
|
||||
}
|
||||
|
||||
static bool apercentile_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool apercentile_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (!function_setup(pCtx, pResultInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -2477,12 +2503,11 @@ static void apercentile_finalizer(SQLFunctionCtx *pCtx) {
|
|||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
static bool leastsquares_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool leastsquares_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SResultRowCellInfo * pResInfo = GET_RES_INFO(pCtx);
|
||||
|
||||
SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
|
||||
// 2*3 matrix
|
||||
|
|
@ -2706,8 +2731,8 @@ enum {
|
|||
INITIAL_VALUE_NOT_ASSIGNED = 0,
|
||||
};
|
||||
|
||||
static bool diff_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool diff_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -2716,14 +2741,13 @@ static bool diff_function_setup(SQLFunctionCtx *pCtx) {
|
|||
return false;
|
||||
}
|
||||
|
||||
static bool deriv_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool deriv_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
|
||||
if (!function_setup(pCtx, pResultInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// diff function require the value is set to -1
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResultInfo);
|
||||
|
||||
pDerivInfo->ignoreNegative = pCtx->param[1].i64;
|
||||
pDerivInfo->prevTs = -1;
|
||||
|
|
@ -3130,12 +3154,12 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
|
|||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
static bool spread_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool spread_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SSpreadInfo *pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
|
||||
SSpreadInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
|
||||
// this is the server-side setup function in client-side, the secondary merge do not need this procedure
|
||||
if (pCtx->currentStage == MERGE_STAGE) {
|
||||
|
|
@ -3289,12 +3313,10 @@ void spread_function_finalizer(SQLFunctionCtx *pCtx) {
|
|||
* param[2]: end time
|
||||
* @param pCtx
|
||||
*/
|
||||
static bool twa_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool twa_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
|
||||
STwaInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
pInfo->p.key = INT64_MIN;
|
||||
|
|
@ -3726,14 +3748,12 @@ static void interp_function(SQLFunctionCtx *pCtx) {
|
|||
}
|
||||
}
|
||||
|
||||
static bool ts_comp_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool ts_comp_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false; // not initialized since it has been initialized
|
||||
}
|
||||
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
|
||||
STSCompInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
|
||||
pInfo->pTSBuf = tsBufCreate(false, pCtx->order);
|
||||
pInfo->pTSBuf->tsOrder = pCtx->order;
|
||||
return true;
|
||||
|
|
@ -3816,13 +3836,11 @@ static double do_calc_rate(const SRateInfo* pRateInfo, double tickPerSec) {
|
|||
return (duration > 0)? ((double)diff) / (duration/tickPerSec):0.0;
|
||||
}
|
||||
|
||||
static bool rate_function_setup(SQLFunctionCtx *pCtx) {
|
||||
if (!function_setup(pCtx)) {
|
||||
static bool rate_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
|
||||
if (!function_setup(pCtx, pResInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
|
||||
SRateInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
pInfo->correctionValue = 0;
|
||||
pInfo->firstKey = INT64_MIN;
|
||||
|
|
@ -3920,7 +3938,7 @@ static void irate_function(SQLFunctionCtx *pCtx) {
|
|||
int32_t notNullElems = 0;
|
||||
SRateInfo *pRateInfo = (SRateInfo *)GET_ROWCELL_INTERBUF(pResInfo);
|
||||
TSKEY *primaryKey = GET_TS_LIST(pCtx);
|
||||
|
||||
|
||||
for (int32_t i = pCtx->size - 1; i >= 0; --i) {
|
||||
char *pData = GET_INPUT_DATA(pCtx, i);
|
||||
if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
|
||||
|
|
|
|||
|
|
@ -29,10 +29,11 @@
|
|||
#include "ttype.h"
|
||||
#include "tcompare.h"
|
||||
#include "tscompression.h"
|
||||
#include "qScript.h"
|
||||
|
||||
#define IS_MASTER_SCAN(runtime) ((runtime)->scanFlag == MASTER_SCAN)
|
||||
#define IS_REVERSE_SCAN(runtime) ((runtime)->scanFlag == REVERSE_SCAN)
|
||||
#define IS_REPEAT_SCAN(runtime) ((runtime)->scanFlag == REPEAT_SCAN)
|
||||
#define IS_REPEAT_SCAN(runtime) ((runtime)->scanFlag == REPEAT_SCAN)
|
||||
#define SET_MASTER_SCAN_FLAG(runtime) ((runtime)->scanFlag = MASTER_SCAN)
|
||||
#define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN)
|
||||
|
||||
|
|
@ -212,24 +213,24 @@ SArray* getOrderCheckColumns(SQueryAttr* pQuery);
|
|||
|
||||
|
||||
typedef struct SRowCompSupporter {
|
||||
SQueryRuntimeEnv *pRuntimeEnv;
|
||||
SQueryRuntimeEnv *pRuntimeEnv;
|
||||
int16_t dataOffset;
|
||||
__compar_fn_t comFunc;
|
||||
__compar_fn_t comFunc;
|
||||
} SRowCompSupporter;
|
||||
|
||||
static int compareRowData(const void *a, const void *b, const void *userData) {
|
||||
const SResultRow *pRow1 = (const SResultRow *)a;
|
||||
const SResultRow *pRow1 = (const SResultRow *)a;
|
||||
const SResultRow *pRow2 = (const SResultRow *)b;
|
||||
|
||||
SRowCompSupporter *supporter = (SRowCompSupporter *)userData;
|
||||
SQueryRuntimeEnv* pRuntimeEnv = supporter->pRuntimeEnv;
|
||||
|
||||
SRowCompSupporter *supporter = (SRowCompSupporter *)userData;
|
||||
SQueryRuntimeEnv* pRuntimeEnv = supporter->pRuntimeEnv;
|
||||
|
||||
tFilePage *page1 = getResBufPage(pRuntimeEnv->pResultBuf, pRow1->pageId);
|
||||
tFilePage *page2 = getResBufPage(pRuntimeEnv->pResultBuf, pRow2->pageId);
|
||||
|
||||
int16_t offset = supporter->dataOffset;
|
||||
int16_t offset = supporter->dataOffset;
|
||||
char *in1 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page1, pRow1->offset, offset);
|
||||
char *in2 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset);
|
||||
char *in2 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset);
|
||||
|
||||
return (in1 != NULL && in2 != NULL) ? supporter->comFunc(in1, in2) : 0;
|
||||
}
|
||||
|
|
@ -250,7 +251,7 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, SQueryRuntimeE
|
|||
|
||||
bool found = false;
|
||||
int16_t dataOffset = 0;
|
||||
|
||||
|
||||
for (int32_t j = 0; j < pDataBlock->info.numOfCols; ++j) {
|
||||
SColumnInfoData* pColInfoData = (SColumnInfoData *)taosArrayGet(pDataBlock->pDataBlock, j);
|
||||
if (orderId == j) {
|
||||
|
|
@ -259,15 +260,15 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, SQueryRuntimeE
|
|||
}
|
||||
|
||||
dataOffset += pColInfoData->info.bytes;
|
||||
}
|
||||
}
|
||||
|
||||
if (found == false) {
|
||||
return;
|
||||
}
|
||||
|
||||
int16_t type = pRuntimeEnv->pQueryAttr->pExpr1[orderId].base.resType;
|
||||
|
||||
SRowCompSupporter support = {.pRuntimeEnv = pRuntimeEnv, .dataOffset = dataOffset, .comFunc = getComparFunc(type, 0)};
|
||||
|
||||
SRowCompSupporter support = {.pRuntimeEnv = pRuntimeEnv, .dataOffset = dataOffset, .comFunc = getComparFunc(type, 0)};
|
||||
taosArraySortPWithExt(pGroupResInfo->pRows, compareRowData, &support);
|
||||
}
|
||||
|
||||
|
|
@ -780,6 +781,79 @@ static int32_t getNumOfRowsInTimeWindow(SQueryRuntimeEnv* pRuntimeEnv, SDataBloc
|
|||
return num;
|
||||
}
|
||||
|
||||
void doInvokeUdf(SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type) {
|
||||
int32_t output = 0;
|
||||
|
||||
if (pUdfInfo == NULL || pUdfInfo->funcs[type] == NULL) {
|
||||
qError("empty udf function, type:%d", type);
|
||||
return;
|
||||
}
|
||||
|
||||
qDebug("invoke udf function:%s,%p", pUdfInfo->name, pUdfInfo->funcs[type]);
|
||||
|
||||
switch (type) {
|
||||
case TSDB_UDF_FUNC_NORMAL:
|
||||
if (pUdfInfo->isScript) {
|
||||
(*(scriptNormalFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL])(pUdfInfo->pScriptCtx,
|
||||
(char *)pCtx->pInput + idx * pCtx->inputType, pCtx->inputType, pCtx->inputBytes, pCtx->size, pCtx->ptsList, pCtx->startTs, pCtx->pOutput,
|
||||
(char *)pCtx->ptsOutputBuf, &output, pCtx->outputType, pCtx->outputBytes);
|
||||
} else {
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
|
||||
void *interBuf = (void *)GET_ROWCELL_INTERBUF(pResInfo);
|
||||
|
||||
(*(udfNormalFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL])((char *)pCtx->pInput + idx * pCtx->inputType, pCtx->inputType, pCtx->inputBytes, pCtx->size, pCtx->ptsList,
|
||||
pCtx->pOutput, interBuf, (char *)pCtx->ptsOutputBuf, &output, pCtx->outputType, pCtx->outputBytes, &pUdfInfo->init);
|
||||
}
|
||||
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
pCtx->resultInfo->numOfRes = output;
|
||||
} else {
|
||||
pCtx->resultInfo->numOfRes += output;
|
||||
}
|
||||
|
||||
if (pCtx->resultInfo->numOfRes > 0) {
|
||||
pCtx->resultInfo->hasResult = DATA_SET_FLAG;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case TSDB_UDF_FUNC_MERGE:
|
||||
if (pUdfInfo->isScript) {
|
||||
(*(scriptMergeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE])(pUdfInfo->pScriptCtx, pCtx->pInput, pCtx->size, pCtx->pOutput, &output);
|
||||
} else {
|
||||
(*(udfMergeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE])(pCtx->pInput, pCtx->size, pCtx->pOutput, &output, &pUdfInfo->init);
|
||||
}
|
||||
|
||||
// set the output value exist
|
||||
pCtx->resultInfo->numOfRes = output;
|
||||
if (output > 0) {
|
||||
pCtx->resultInfo->hasResult = DATA_SET_FLAG;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case TSDB_UDF_FUNC_FINALIZE: {
|
||||
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
|
||||
void *interBuf = (void *)GET_ROWCELL_INTERBUF(pResInfo);
|
||||
if (pUdfInfo->isScript) {
|
||||
(*(scriptFinalizeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE])(pUdfInfo->pScriptCtx, pCtx->startTs, pCtx->pOutput, &output);
|
||||
} else {
|
||||
(*(udfFinalizeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE])(pCtx->pOutput, interBuf, &output, &pUdfInfo->init);
|
||||
}
|
||||
// set the output value exist
|
||||
pCtx->resultInfo->numOfRes = output;
|
||||
if (output > 0) {
|
||||
pCtx->resultInfo->hasResult = DATA_SET_FLAG;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, STimeWindow* pWin, int32_t offset,
|
||||
int32_t forwardStep, TSKEY* tsCol, int32_t numOfTotal, int32_t numOfOutput) {
|
||||
SQueryAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
|
||||
|
|
@ -789,7 +863,7 @@ static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
|
|||
pCtx[k].size = forwardStep;
|
||||
pCtx[k].startTs = pWin->skey;
|
||||
|
||||
// keep it temprarily
|
||||
// keep it temporarialy
|
||||
char* start = pCtx[k].pInput;
|
||||
|
||||
int32_t pos = (QUERY_IS_ASC_QUERY(pQueryAttr)) ? offset : offset - (forwardStep - 1);
|
||||
|
|
@ -807,8 +881,14 @@ static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
|
|||
pCtx[k].preAggVals.isSet = false;
|
||||
}
|
||||
|
||||
int32_t functionId = pCtx[k].functionId;
|
||||
if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
|
||||
aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
|
||||
if (functionId < 0) { // load the script and exec, pRuntimeEnv->pUdfInfo
|
||||
SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
|
||||
doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
|
||||
} else {
|
||||
aAggs[functionId].xFunction(&pCtx[k]);
|
||||
}
|
||||
}
|
||||
|
||||
// restore it
|
||||
|
|
@ -951,7 +1031,9 @@ static TSKEY getStartTsKey(SQueryAttr* pQueryAttr, STimeWindow* win, const TSKEY
|
|||
static void setArithParams(SArithmeticSupport* sas, SExprInfo *pExprInfo, SSDataBlock* pSDataBlock) {
|
||||
sas->numOfCols = (int32_t) pSDataBlock->info.numOfCols;
|
||||
sas->pExprInfo = pExprInfo;
|
||||
|
||||
if (sas->colList != NULL) {
|
||||
return;
|
||||
}
|
||||
sas->colList = calloc(1, pSDataBlock->info.numOfCols*sizeof(SColumnInfo));
|
||||
for(int32_t i = 0; i < sas->numOfCols; ++i) {
|
||||
SColumnInfoData* pColData = taosArrayGet(pSDataBlock->pDataBlock, i);
|
||||
|
|
@ -1016,6 +1098,13 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx,
|
|||
pCtx[i].pInput = p->pData;
|
||||
assert(p->info.colId == pColIndex->colId && pCtx[i].inputType == p->info.type);
|
||||
|
||||
if (pCtx[i].functionId < 0) {
|
||||
SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
|
||||
pCtx[i].ptsList = (int64_t*) tsInfo->pData;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
uint32_t status = aAggs[pCtx[i].functionId].status;
|
||||
if ((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) {
|
||||
SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
|
||||
|
|
@ -1048,7 +1137,14 @@ static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SQLFunction
|
|||
for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
|
||||
if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
|
||||
pCtx[k].startTs = startTs;// this can be set during create the struct
|
||||
aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
|
||||
|
||||
int32_t functionId = pCtx[k].functionId;
|
||||
if (functionId < 0) {
|
||||
SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
|
||||
doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
|
||||
} else {
|
||||
aAggs[functionId].xFunction(&pCtx[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1064,7 +1160,15 @@ static void projectApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
|
|||
pCtx[k].order = TSDB_ORDER_ASC;
|
||||
}
|
||||
|
||||
aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
|
||||
pCtx[k].startTs = pQueryAttr->window.skey;
|
||||
|
||||
if (pCtx[k].functionId < 0) {
|
||||
// load the script and exec
|
||||
SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
|
||||
doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
|
||||
} else {
|
||||
aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1951,7 +2055,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
|
|||
|
||||
case OP_GlobalAggregate: {
|
||||
pRuntimeEnv->proot = createGlobalAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
|
||||
pQueryAttr->numOfExpr3, merger);
|
||||
pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -2022,6 +2126,8 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
tfree(pRuntimeEnv->sasArray);
|
||||
}
|
||||
|
||||
destroyUdfInfo(pRuntimeEnv->pUdfInfo);
|
||||
|
||||
destroyResultBuf(pRuntimeEnv->pResultBuf);
|
||||
doFreeQueryHandle(pRuntimeEnv);
|
||||
|
||||
|
|
@ -2232,7 +2338,7 @@ static bool onlyFirstQuery(SQueryAttr *pQueryAttr) { return onlyOneQueryType(pQu
|
|||
|
||||
static bool onlyLastQuery(SQueryAttr *pQueryAttr) { return onlyOneQueryType(pQueryAttr, TSDB_FUNC_LAST, TSDB_FUNC_LAST_DST); }
|
||||
|
||||
static bool notContainSessionOrStateWindow(SQueryAttr *pQueryAttr) { return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); }
|
||||
static bool notContainSessionOrStateWindow(SQueryAttr *pQueryAttr) { return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); }
|
||||
|
||||
static int32_t updateBlockLoadStatus(SQueryAttr *pQuery, int32_t status) {
|
||||
bool hasFirstLastFunc = false;
|
||||
|
|
@ -2442,14 +2548,14 @@ static bool doFilterByBlockStatistics(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis
|
|||
}
|
||||
|
||||
SDataStatis* pDataBlockst = &pDataStatis[index];
|
||||
|
||||
|
||||
if (pFilterInfo->info.type == TSDB_DATA_TYPE_FLOAT) {
|
||||
float minval = (float)(*(double *)(&pDataBlockst->min));
|
||||
float maxval = (float)(*(double *)(&pDataBlockst->max));
|
||||
|
||||
|
||||
for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
|
||||
if (pFilterInfo->pFilters[i].filterInfo.lowerRelOptr == TSDB_RELATION_IN) {
|
||||
continue;
|
||||
continue;
|
||||
}
|
||||
ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&minval, (char *)&maxval, TSDB_DATA_TYPE_FLOAT);
|
||||
if (ret == false) {
|
||||
|
|
@ -2459,9 +2565,9 @@ static bool doFilterByBlockStatistics(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis
|
|||
} else {
|
||||
for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
|
||||
if (pFilterInfo->pFilters[i].filterInfo.lowerRelOptr == TSDB_RELATION_IN) {
|
||||
continue;
|
||||
continue;
|
||||
}
|
||||
ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max, pFilterInfo->info.type);
|
||||
ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max, pFilterInfo->info.type);
|
||||
if (ret == false) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -2701,9 +2807,14 @@ static uint32_t doFilterByBlockTimeWindow(STableScanInfo* pTableScanInfo, SSData
|
|||
int32_t colId = pTableScanInfo->pExpr[i].base.colInfo.colId;
|
||||
|
||||
// group by + first/last should not apply the first/last block filter
|
||||
status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId);
|
||||
if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) {
|
||||
if (functionId < 0) {
|
||||
status |= BLK_DATA_ALL_NEEDED;
|
||||
return status;
|
||||
} else {
|
||||
status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId);
|
||||
if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3008,8 +3119,8 @@ void setTagValue(SOperatorInfo* pOperatorInfo, void *pTable, SQLFunctionCtx* pCt
|
|||
doSetTagValueInParam(pTable, pLocalExprInfo->base.colInfo.colId, &pCtx[idx].tag, pLocalExprInfo->base.resType,
|
||||
pLocalExprInfo->base.resBytes);
|
||||
|
||||
if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resType)
|
||||
|| pLocalExprInfo->base.resType == TSDB_DATA_TYPE_BOOL
|
||||
if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resType)
|
||||
|| pLocalExprInfo->base.resType == TSDB_DATA_TYPE_BOOL
|
||||
|| pLocalExprInfo->base.resType == TSDB_DATA_TYPE_TIMESTAMP) {
|
||||
memcpy(pRuntimeEnv->tagVal + offset, &pCtx[idx].tag.i64, pLocalExprInfo->base.resBytes);
|
||||
} else {
|
||||
|
|
@ -3297,6 +3408,21 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf
|
|||
}
|
||||
}
|
||||
|
||||
void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity) {
|
||||
SSDataBlock* pDataBlock = pBInfo->pRes;
|
||||
|
||||
for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
|
||||
SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i);
|
||||
|
||||
int32_t functionId = pBInfo->pCtx[i].functionId;
|
||||
if (functionId < 0) {
|
||||
memset(pBInfo->pCtx[i].pOutput, 0, pColInfo->info.bytes * (*bufCapacity));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void initCtxOutputBuffer(SQLFunctionCtx* pCtx, int32_t size) {
|
||||
for (int32_t j = 0; j < size; ++j) {
|
||||
SResultRowCellInfo* pResInfo = GET_RES_INFO(&pCtx[j]);
|
||||
|
|
@ -3304,7 +3430,11 @@ void initCtxOutputBuffer(SQLFunctionCtx* pCtx, int32_t size) {
|
|||
continue;
|
||||
}
|
||||
|
||||
aAggs[pCtx[j].functionId].init(&pCtx[j]);
|
||||
if (pCtx[j].functionId < 0) { // todo udf initialization
|
||||
continue;
|
||||
} else {
|
||||
aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3359,9 +3489,15 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
|
|||
setResultOutputBuf(pRuntimeEnv, buf, pCtx, numOfOutput, rowCellInfoOffset);
|
||||
|
||||
for (int32_t j = 0; j < numOfOutput; ++j) {
|
||||
aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
|
||||
pCtx[j].startTs = buf->win.skey;
|
||||
if (pCtx[j].functionId < 0) {
|
||||
doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
|
||||
} else {
|
||||
aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* set the number of output results for group by normal columns, the number of output rows usually is 1 except
|
||||
* the top and bottom query
|
||||
|
|
@ -3371,7 +3507,11 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
|
|||
|
||||
} else {
|
||||
for (int32_t j = 0; j < numOfOutput; ++j) {
|
||||
aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
|
||||
if (pCtx[j].functionId < 0) {
|
||||
doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
|
||||
} else {
|
||||
aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3457,12 +3597,16 @@ void setResultRowOutputBufInitCtx(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pRe
|
|||
offset += pCtx[i].outputBytes;
|
||||
|
||||
int32_t functionId = pCtx[i].functionId;
|
||||
if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
|
||||
if (functionId < 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF) {
|
||||
pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
|
||||
}
|
||||
|
||||
if (!pResInfo->initialized) {
|
||||
aAggs[functionId].init(&pCtx[i]);
|
||||
aAggs[functionId].init(&pCtx[i], pResInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3949,7 +4093,7 @@ void calculateOperatorProfResults(SQInfo* pQInfo) {
|
|||
qDebug("QInfo:0x%"PRIx64" operator prof results hash is null", pQInfo->qId);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
SArray* opStack = taosArrayInit(32, sizeof(SOperatorStackItem));
|
||||
if (opStack == NULL) {
|
||||
return;
|
||||
|
|
@ -4801,7 +4945,7 @@ void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInf
|
|||
pTableScanInfo->pResultRowInfo = &pInfo->binfo.resultRowInfo;
|
||||
pTableScanInfo->rowCellInfoOffset = pInfo->binfo.rowCellInfoOffset;
|
||||
} else if (pDownstream->operatorType == OP_StateWindow) {
|
||||
SStateWindowOperatorInfo* pInfo = pDownstream->info;
|
||||
SStateWindowOperatorInfo* pInfo = pDownstream->info;
|
||||
|
||||
pTableScanInfo->pCtx = pInfo->binfo.pCtx;
|
||||
pTableScanInfo->pResultRowInfo = &pInfo->binfo.resultRowInfo;
|
||||
|
|
@ -4921,7 +5065,7 @@ static void destroySlimitOperatorInfo(void* param, int32_t numOfOutput) {
|
|||
}
|
||||
|
||||
SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream,
|
||||
SExprInfo* pExpr, int32_t numOfOutput, void* param) {
|
||||
SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo) {
|
||||
SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
|
||||
|
||||
pInfo->resultRowFactor =
|
||||
|
|
@ -4931,6 +5075,7 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
|
|||
|
||||
pInfo->pMerge = param;
|
||||
pInfo->bufCapacity = 4096;
|
||||
pInfo->udfInfo = pUdfInfo;
|
||||
|
||||
pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pInfo->bufCapacity * pInfo->resultRowFactor);
|
||||
pInfo->binfo.pCtx = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
|
||||
|
|
@ -5460,7 +5605,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
|
|||
TSKEY* tsList = (TSKEY*)pTsColInfoData->pData;
|
||||
if (IS_REPEAT_SCAN(pRuntimeEnv) && !pInfo->reptScan) {
|
||||
pInfo->reptScan = true;
|
||||
tfree(pInfo->prevData);
|
||||
tfree(pInfo->prevData);
|
||||
}
|
||||
|
||||
pInfo->numOfRows = 0;
|
||||
|
|
@ -5470,17 +5615,17 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
|
|||
continue;
|
||||
}
|
||||
if (pInfo->prevData == NULL) {
|
||||
pInfo->prevData = malloc(bytes);
|
||||
pInfo->prevData = malloc(bytes);
|
||||
memcpy(pInfo->prevData, val, bytes);
|
||||
pInfo->numOfRows = 1;
|
||||
pInfo->curWindow.skey = tsList[j];
|
||||
pInfo->curWindow.ekey = tsList[j];
|
||||
pInfo->start = j;
|
||||
|
||||
pInfo->start = j;
|
||||
|
||||
} else if (memcmp(pInfo->prevData, val, bytes) == 0) {
|
||||
pInfo->curWindow.ekey = tsList[j];
|
||||
pInfo->numOfRows += 1;
|
||||
//pInfo->start = j;
|
||||
//pInfo->start = j;
|
||||
if (j == 0 && pInfo->start != 0) {
|
||||
pInfo->numOfRows = 1;
|
||||
pInfo->start = 0;
|
||||
|
|
@ -5502,7 +5647,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
|
|||
memcpy(pInfo->prevData, val, bytes);
|
||||
pInfo->numOfRows = 1;
|
||||
pInfo->start = j;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -5555,10 +5700,10 @@ static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
|
|||
setInputDataBlock(pOperator, pBInfo->pCtx, pBlock, pQueryAttr->order.order);
|
||||
if (pWindowInfo->colIndex == -1) {
|
||||
pWindowInfo->colIndex = getGroupbyColumnIndex(pRuntimeEnv->pQueryAttr->pGroupbyExpr, pBlock);
|
||||
}
|
||||
}
|
||||
doStateWindowAggImpl(pOperator, pWindowInfo, pBlock);
|
||||
}
|
||||
|
||||
|
||||
// restore the value
|
||||
pQueryAttr->order.order = order;
|
||||
pQueryAttr->window = win;
|
||||
|
|
@ -5576,7 +5721,7 @@ static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
|
|||
}
|
||||
|
||||
return pBInfo->pRes->info.rows == 0? NULL:pBInfo->pRes;
|
||||
}
|
||||
}
|
||||
static SSDataBlock* doSessionWindowAgg(void* param, bool* newgroup) {
|
||||
SOperatorInfo* pOperator = (SOperatorInfo*) param;
|
||||
if (pOperator->status == OP_EXEC_DONE) {
|
||||
|
|
@ -5691,7 +5836,7 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
|
|||
sortGroupResByOrderList(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pInfo->binfo.pRes);
|
||||
}
|
||||
toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pInfo->binfo.pRes);
|
||||
|
||||
|
||||
if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
|
||||
pOperator->status = OP_EXEC_DONE;
|
||||
}
|
||||
|
|
@ -5984,8 +6129,13 @@ SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int3
|
|||
pCols[i].colId = pExpr[i].base.resColId;
|
||||
|
||||
pCols[i].flist.numOfFilters = pExpr[i].base.flist.numOfFilters;
|
||||
pCols[i].flist.filterInfo = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
|
||||
memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
|
||||
if (pCols[i].flist.numOfFilters != 0) {
|
||||
pCols[i].flist.filterInfo = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
|
||||
memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
|
||||
} else {
|
||||
// avoid runtime error
|
||||
pCols[i].flist.filterInfo = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
assert(numOfFilter > 0);
|
||||
|
|
@ -6081,8 +6231,8 @@ SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOpe
|
|||
pOperator->cleanup = destroyStateWindowOperatorInfo;
|
||||
|
||||
appendUpstream(pOperator, upstream);
|
||||
return pOperator;
|
||||
|
||||
return pOperator;
|
||||
|
||||
}
|
||||
SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
|
||||
SSWindowOperatorInfo* pInfo = calloc(1, sizeof(SSWindowOperatorInfo));
|
||||
|
|
@ -6092,7 +6242,7 @@ SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
|
|||
initResultRowInfo(&pInfo->binfo.resultRowInfo, 8, TSDB_DATA_TYPE_INT);
|
||||
|
||||
pInfo->prevTs = INT64_MIN;
|
||||
pInfo->reptScan = false;
|
||||
pInfo->reptScan = false;
|
||||
SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
|
||||
|
||||
pOperator->name = "SessionWindowAggOperator";
|
||||
|
|
@ -6444,10 +6594,10 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
|
|||
if (isNull(val, type)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int dummy;
|
||||
void* res = taosHashGet(pInfo->pSet, val, bytes);
|
||||
if (res == NULL) {
|
||||
taosHashPut(pInfo->pSet, val, bytes, NULL, 0);
|
||||
taosHashPut(pInfo->pSet, val, bytes, &dummy, sizeof(dummy));
|
||||
char* start = pResultColInfoData->pData + bytes * pInfo->pRes->info.rows;
|
||||
memcpy(start, val, bytes);
|
||||
pRes->info.rows += 1;
|
||||
|
|
@ -6683,6 +6833,9 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
|
|||
pQueryMsg->sw.primaryColId = htonl(pQueryMsg->sw.primaryColId);
|
||||
pQueryMsg->tableScanOperator = htonl(pQueryMsg->tableScanOperator);
|
||||
pQueryMsg->numOfOperator = htonl(pQueryMsg->numOfOperator);
|
||||
pQueryMsg->udfContentOffset = htonl(pQueryMsg->udfContentOffset);
|
||||
pQueryMsg->udfContentLen = htonl(pQueryMsg->udfContentLen);
|
||||
pQueryMsg->udfNum = htonl(pQueryMsg->udfNum);
|
||||
|
||||
// query msg safety check
|
||||
if (!validateQueryMsg(pQueryMsg)) {
|
||||
|
|
@ -6926,6 +7079,33 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
|
|||
pMsg += sizeof(int32_t);
|
||||
}
|
||||
|
||||
if (pQueryMsg->udfContentLen > 0) {
|
||||
param->pUdfInfo = calloc(1, sizeof(SUdfInfo));
|
||||
param->pUdfInfo->contLen = pQueryMsg->udfContentLen;
|
||||
|
||||
pMsg = (char*)pQueryMsg + pQueryMsg->udfContentOffset;
|
||||
param->pUdfInfo->resType = *(int8_t*) pMsg;
|
||||
pMsg += sizeof(int8_t);
|
||||
|
||||
param->pUdfInfo->resBytes = htons(*(int16_t*)pMsg);
|
||||
pMsg += sizeof(int16_t);
|
||||
|
||||
tstr* name = (tstr*)(pMsg);
|
||||
param->pUdfInfo->name = strndup(name->data, name->len);
|
||||
|
||||
pMsg += varDataTLen(name);
|
||||
param->pUdfInfo->funcType = htonl(*(int32_t*)pMsg);
|
||||
pMsg += sizeof(int32_t);
|
||||
|
||||
param->pUdfInfo->bufSize = htonl(*(int32_t*)pMsg);
|
||||
pMsg += sizeof(int32_t);
|
||||
|
||||
param->pUdfInfo->content = malloc(pQueryMsg->udfContentLen);
|
||||
memcpy(param->pUdfInfo->content, pMsg, pQueryMsg->udfContentLen);
|
||||
|
||||
pMsg += pQueryMsg->udfContentLen;
|
||||
}
|
||||
|
||||
param->sql = strndup(pMsg, pQueryMsg->sqlstrLen);
|
||||
|
||||
SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
|
||||
|
|
@ -7016,7 +7196,7 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol
|
|||
} else {
|
||||
SColumnInfo* pCol = &pTableInfo->colList[j];
|
||||
int32_t ret = getResultDataInfo(pCol->type, pCol->bytes, functId, (int32_t)pExprs[i].base.param[0].i64,
|
||||
&pExprs[i].base.resType, &pExprs[i].base.resBytes, &pExprs[i].base.interBytes, tagLen, superTable);
|
||||
&pExprs[i].base.resType, &pExprs[i].base.resBytes, &pExprs[i].base.interBytes, tagLen, superTable, NULL);
|
||||
assert(ret == TSDB_CODE_SUCCESS);
|
||||
}
|
||||
}
|
||||
|
|
@ -7025,12 +7205,138 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
void destroyUdfInfo(SUdfInfo* pUdfInfo) {
|
||||
if (pUdfInfo == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY]) {
|
||||
if (pUdfInfo->isScript) {
|
||||
(*(scriptDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(pUdfInfo->pScriptCtx);
|
||||
tfree(pUdfInfo->content);
|
||||
}else{
|
||||
(*(udfDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(&pUdfInfo->init);
|
||||
}
|
||||
}
|
||||
|
||||
tfree(pUdfInfo->name);
|
||||
|
||||
if (pUdfInfo->path) {
|
||||
unlink(pUdfInfo->path);
|
||||
}
|
||||
|
||||
tfree(pUdfInfo->path);
|
||||
tfree(pUdfInfo->content);
|
||||
taosCloseDll(pUdfInfo->handle);
|
||||
tfree(pUdfInfo);
|
||||
}
|
||||
|
||||
static char* getUdfFuncName(char* name, int type) {
|
||||
char* funcname = calloc(1, TSDB_FUNCTIONS_NAME_MAX_LENGTH + 10);
|
||||
|
||||
switch (type) {
|
||||
case TSDB_UDF_FUNC_NORMAL:
|
||||
strcpy(funcname, name);
|
||||
break;
|
||||
case TSDB_UDF_FUNC_INIT:
|
||||
sprintf(funcname, "%s_init", name);
|
||||
break;
|
||||
case TSDB_UDF_FUNC_FINALIZE:
|
||||
sprintf(funcname, "%s_finalize", name);
|
||||
break;
|
||||
case TSDB_UDF_FUNC_MERGE:
|
||||
sprintf(funcname, "%s_merge", name);
|
||||
break;
|
||||
case TSDB_UDF_FUNC_DESTROY:
|
||||
sprintf(funcname, "%s_destroy", name);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
|
||||
return funcname;
|
||||
}
|
||||
|
||||
int32_t initUdfInfo(SUdfInfo* pUdfInfo) {
|
||||
if (pUdfInfo == NULL) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
//qError("script len: %d", pUdfInfo->contLen);
|
||||
if (isValidScript(pUdfInfo->content, pUdfInfo->contLen)) {
|
||||
pUdfInfo->isScript = 1;
|
||||
pUdfInfo->pScriptCtx = createScriptCtx(pUdfInfo->content, pUdfInfo->resType, pUdfInfo->resBytes);
|
||||
if (pUdfInfo->pScriptCtx == NULL) {
|
||||
return TSDB_CODE_QRY_SYS_ERROR;
|
||||
}
|
||||
tfree(pUdfInfo->content);
|
||||
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] = taosLoadScriptInit;
|
||||
if (pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] == NULL
|
||||
|| (*(scriptInitFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_INIT])(pUdfInfo->pScriptCtx) != TSDB_CODE_SUCCESS) {
|
||||
return TSDB_CODE_QRY_SYS_ERROR;
|
||||
}
|
||||
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL] = taosLoadScriptNormal;
|
||||
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE] = taosLoadScriptFinalize;
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE] = taosLoadScriptMerge;
|
||||
}
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY] = taosLoadScriptDestroy;
|
||||
|
||||
} else {
|
||||
char path[PATH_MAX] = {0};
|
||||
taosGetTmpfilePath("script", path);
|
||||
|
||||
FILE* file = fopen(path, "w+");
|
||||
|
||||
// TODO check for failure of flush to disk
|
||||
/*size_t t = */ fwrite(pUdfInfo->content, pUdfInfo->contLen, 1, file);
|
||||
fclose(file);
|
||||
tfree(pUdfInfo->content);
|
||||
|
||||
pUdfInfo->path = strdup(path);
|
||||
|
||||
pUdfInfo->handle = taosLoadDll(path);
|
||||
|
||||
if (NULL == pUdfInfo->handle) {
|
||||
return TSDB_CODE_QRY_SYS_ERROR;
|
||||
}
|
||||
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_NORMAL));
|
||||
if (NULL == pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL]) {
|
||||
return TSDB_CODE_QRY_SYS_ERROR;
|
||||
}
|
||||
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_INIT));
|
||||
|
||||
if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_FINALIZE));
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_MERGE));
|
||||
}
|
||||
|
||||
pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_DESTROY));
|
||||
|
||||
if (pUdfInfo->funcs[TSDB_UDF_FUNC_INIT]) {
|
||||
return (*(udfInitFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_INIT])(&pUdfInfo->init);
|
||||
}
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
// TODO tag length should be passed from client, refactor
|
||||
int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
|
||||
SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg) {
|
||||
SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg, SUdfInfo* pUdfInfo) {
|
||||
*pExprInfo = NULL;
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
||||
code = initUdfInfo(pUdfInfo);
|
||||
if (code) {
|
||||
return code;
|
||||
}
|
||||
|
||||
SExprInfo *pExprs = (SExprInfo *)calloc(numOfOutput, sizeof(SExprInfo));
|
||||
if (pExprs == NULL) {
|
||||
return TSDB_CODE_QRY_OUT_OF_MEMORY;
|
||||
|
|
@ -7119,7 +7425,7 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
|
|||
|
||||
// todo remove it
|
||||
if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].base.resType, &pExprs[i].base.resBytes,
|
||||
&pExprs[i].base.interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
|
||||
&pExprs[i].base.interBytes, 0, isSuperTable, pUdfInfo) != TSDB_CODE_SUCCESS) {
|
||||
tfree(pExprs);
|
||||
return TSDB_CODE_QRY_INVALID_MSG;
|
||||
}
|
||||
|
|
@ -7140,7 +7446,7 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
|
|||
|
||||
// todo refactor
|
||||
int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg* pQueryMsg, int32_t numOfOutput, SExprInfo** pExprInfo,
|
||||
SSqlExpr** pExpr, SExprInfo* prevExpr) {
|
||||
SSqlExpr** pExpr, SExprInfo* prevExpr, SUdfInfo *pUdfInfo) {
|
||||
*pExprInfo = NULL;
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
||||
|
|
@ -7185,7 +7491,7 @@ int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg* pQueryMsg, int32_t nu
|
|||
|
||||
int32_t param = (int32_t)pExprs[i].base.param[0].i64;
|
||||
if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].base.resType, &pExprs[i].base.resBytes,
|
||||
&pExprs[i].base.interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
|
||||
&pExprs[i].base.interBytes, 0, isSuperTable, pUdfInfo) != TSDB_CODE_SUCCESS) {
|
||||
tfree(pExprs);
|
||||
return TSDB_CODE_QRY_INVALID_MSG;
|
||||
}
|
||||
|
|
@ -7371,7 +7677,7 @@ FORCE_INLINE bool checkQIdEqual(void *qHandle, uint64_t qId) {
|
|||
|
||||
SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, SExprInfo* pExprs,
|
||||
SExprInfo* pSecExprs, STableGroupInfo* pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId,
|
||||
char* sql, uint64_t qId) {
|
||||
char* sql, uint64_t qId, SUdfInfo* pUdfInfo) {
|
||||
int16_t numOfCols = pQueryMsg->numOfCols;
|
||||
int16_t numOfOutput = pQueryMsg->numOfOutput;
|
||||
|
||||
|
|
@ -7382,6 +7688,8 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
|
|||
|
||||
pQInfo->qId = qId;
|
||||
|
||||
pQInfo->runtimeEnv.pUdfInfo = pUdfInfo;
|
||||
|
||||
// to make sure third party won't overwrite this structure
|
||||
pQInfo->signature = pQInfo;
|
||||
SQueryAttr* pQueryAttr = &pQInfo->query;
|
||||
|
|
@ -7405,6 +7713,7 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
|
|||
pQueryAttr->prjInfo.vgroupLimit = pQueryMsg->vgroupLimit;
|
||||
pQueryAttr->prjInfo.ts = (pQueryMsg->order == TSDB_ORDER_ASC)? INT64_MIN:INT64_MAX;
|
||||
pQueryAttr->sw = pQueryMsg->sw;
|
||||
pQueryAttr->vgId = vgId;
|
||||
|
||||
pQueryAttr->stableQuery = pQueryMsg->stableQuery;
|
||||
pQueryAttr->topBotQuery = pQueryMsg->topBotQuery;
|
||||
|
|
@ -7437,7 +7746,6 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
|
|||
}
|
||||
}
|
||||
|
||||
// calculate the result row size
|
||||
for (int16_t col = 0; col < numOfOutput; ++col) {
|
||||
assert(pExprs[col].base.resBytes > 0);
|
||||
pQueryAttr->resultRowSize += pExprs[col].base.resBytes;
|
||||
|
|
@ -7458,6 +7766,20 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
|
|||
goto _cleanup;
|
||||
}
|
||||
|
||||
if (pSecExprs != NULL) {
|
||||
int32_t resultRowSize = 0;
|
||||
|
||||
// calculate the result row size
|
||||
for (int16_t col = 0; col < pQueryAttr->numOfExpr2; ++col) {
|
||||
assert(pSecExprs[col].base.resBytes > 0);
|
||||
resultRowSize += pSecExprs[col].base.resBytes;
|
||||
}
|
||||
|
||||
if (resultRowSize > pQueryAttr->resultRowSize) {
|
||||
pQueryAttr->resultRowSize = resultRowSize;
|
||||
}
|
||||
}
|
||||
|
||||
if (pQueryAttr->fillType != TSDB_FILL_NONE) {
|
||||
pQueryAttr->fillVal = malloc(sizeof(int64_t) * pQueryAttr->numOfOutput);
|
||||
if (pQueryAttr->fillVal == NULL) {
|
||||
|
|
@ -7603,8 +7925,8 @@ int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo*
|
|||
|
||||
SArray* prevResult = NULL;
|
||||
if (prevResultLen > 0) {
|
||||
prevResult = interResFromBinary(param->prevResult, prevResultLen);
|
||||
|
||||
prevResult = interResFromBinary(param->prevResult, prevResultLen);
|
||||
|
||||
pRuntimeEnv->prevResult = prevResult;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,443 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "os.h"
|
||||
#include "qScript.h"
|
||||
#include "ttype.h"
|
||||
#include "tstrbuild.h"
|
||||
#include "queryLog.h"
|
||||
#include "ttokendef.h"
|
||||
|
||||
static ScriptEnvPool *pool = NULL;
|
||||
|
||||
static ScriptEnv* getScriptEnvFromPool();
|
||||
static void addScriptEnvToPool(ScriptEnv *pEnv);
|
||||
|
||||
static lua_State* createLuaEnv();
|
||||
static void destroyLuaEnv(lua_State *state);
|
||||
|
||||
static void destroyScriptEnv(ScriptEnv *pEnv);
|
||||
|
||||
static void luaValueToTaosType(lua_State *lua, char *interBuf, int32_t *numOfOutput, int16_t oType, int16_t oBytes);
|
||||
static void taosValueToLuaType(lua_State *lua, int32_t type, char *val);
|
||||
|
||||
static bool hasBaseFuncDefinedInScript(lua_State *lua, const char *funcPrefix, int32_t len);
|
||||
|
||||
static int userlib_exampleFunc(lua_State *lua) {
|
||||
double op1 = luaL_checknumber(lua,1);
|
||||
double op2 = luaL_checknumber(lua,2);
|
||||
lua_pushnumber(lua, op1 * op2);
|
||||
return 1;
|
||||
}
|
||||
void luaRegisterLibFunc(lua_State *lua) {
|
||||
lua_register(lua, "exampleFunc", userlib_exampleFunc);
|
||||
}
|
||||
|
||||
void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {
|
||||
lua_pushcfunction(lua, luafunc);
|
||||
lua_pushstring(lua, libname);
|
||||
lua_call(lua, 1, 0);
|
||||
}
|
||||
|
||||
LUALIB_API int (luaopen_cjson) (lua_State *L);
|
||||
LUALIB_API int (luaopen_struct) (lua_State *L);
|
||||
LUALIB_API int (luaopen_cmsgpack) (lua_State *L);
|
||||
LUALIB_API int (luaopen_bit) (lua_State *L);
|
||||
|
||||
|
||||
static void luaLoadLibraries(lua_State *lua) {
|
||||
luaLoadLib(lua, "", luaopen_base);
|
||||
luaLoadLib(lua, LUA_TABLIBNAME, luaopen_table);
|
||||
luaLoadLib(lua, LUA_STRLIBNAME, luaopen_string);
|
||||
luaLoadLib(lua, LUA_MATHLIBNAME, luaopen_math);
|
||||
luaLoadLib(lua, LUA_DBLIBNAME, luaopen_debug);
|
||||
}
|
||||
static void luaRemoveUnsupportedFunctions(lua_State *lua) {
|
||||
lua_pushnil(lua);
|
||||
lua_setglobal(lua,"loadfile");
|
||||
lua_pushnil(lua);
|
||||
lua_setglobal(lua,"dofile");
|
||||
}
|
||||
void taosValueToLuaType(lua_State *lua, int32_t type, char *val) {
|
||||
//TODO(dengyihao): handle more data type
|
||||
if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
|
||||
int64_t v;
|
||||
GET_TYPED_DATA(v, int64_t, type, val);
|
||||
lua_pushnumber(lua, (lua_Number)v);
|
||||
} else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
|
||||
uint64_t v;
|
||||
GET_TYPED_DATA(v, uint64_t, type, val);
|
||||
lua_pushnumber(lua,(lua_Number)v);
|
||||
} else if (IS_FLOAT_TYPE(type)) {
|
||||
double v;
|
||||
GET_TYPED_DATA(v, double, type, val);
|
||||
lua_pushnumber(lua,v);
|
||||
} else if (type == TSDB_DATA_TYPE_BINARY) {
|
||||
lua_pushlstring(lua, val, varDataLen(val));
|
||||
} else if (type == TSDB_DATA_TYPE_NCHAR) {
|
||||
}
|
||||
}
|
||||
int taosLoadScriptInit(void* pInit) {
|
||||
ScriptCtx *pCtx = pInit;
|
||||
char funcName[MAX_FUNC_NAME] = {0};
|
||||
sprintf(funcName, "%s_init", pCtx->funcName);
|
||||
|
||||
lua_State* lua = pCtx->pEnv->lua_state;
|
||||
lua_getglobal(lua, funcName);
|
||||
if (lua_pcall(lua, 0, -1, 0)) {
|
||||
lua_pop(lua, -1);
|
||||
}
|
||||
lua_setglobal(lua, "global");
|
||||
return 0;
|
||||
}
|
||||
void taosLoadScriptNormal(void *pInit, char *pInput, int16_t iType, int16_t iBytes, int32_t numOfRows,
|
||||
int64_t *ptsList, int64_t key, char* pOutput, char *ptsOutput, int32_t *numOfOutput, int16_t oType, int16_t oBytes) {
|
||||
ScriptCtx* pCtx = pInit;
|
||||
char funcName[MAX_FUNC_NAME] = {0};
|
||||
sprintf(funcName, "%s_add", pCtx->funcName);
|
||||
|
||||
lua_State* lua = pCtx->pEnv->lua_state;
|
||||
lua_getglobal(lua, funcName);
|
||||
|
||||
// first param of script;
|
||||
lua_newtable(lua);
|
||||
int32_t offset = 0;
|
||||
for (int32_t i = 0; i < numOfRows; i++) {
|
||||
taosValueToLuaType(lua, iType, pInput + offset);
|
||||
lua_rawseti(lua, -2, i+1);
|
||||
offset += iBytes;
|
||||
}
|
||||
int isGlobalState = false;
|
||||
lua_getglobal(lua, "global");
|
||||
if (lua_istable(lua, -1)) {
|
||||
isGlobalState = true;
|
||||
}
|
||||
lua_pushnumber(lua, (lua_Number)key);
|
||||
// do call lua script
|
||||
if (lua_pcall(lua, 3, 1, 0) != 0) {
|
||||
qError("SCRIPT ERROR: %s", lua_tostring(lua, -1));
|
||||
lua_pop(lua, -1);
|
||||
return;
|
||||
}
|
||||
int tNumOfOutput = 0;
|
||||
if (isGlobalState == false) {
|
||||
luaValueToTaosType(lua, pOutput, &tNumOfOutput, oType, oBytes);
|
||||
} else {
|
||||
lua_setglobal(lua, "global");
|
||||
}
|
||||
*numOfOutput = tNumOfOutput;
|
||||
}
|
||||
|
||||
void taosLoadScriptMerge(void *pInit, char* data, int32_t numOfRows, char* pOutput, int32_t* numOfOutput) {
|
||||
ScriptCtx *pCtx = pInit;
|
||||
char funcName[MAX_FUNC_NAME] = {0};
|
||||
sprintf(funcName, "%s_merge", pCtx->funcName);
|
||||
|
||||
lua_State* lua = pCtx->pEnv->lua_state;
|
||||
lua_getglobal(lua, funcName);
|
||||
if (!lua_isfunction(lua, -1)) {
|
||||
qError("SCRIPT ERROR: %s", lua_tostring(lua, -1));
|
||||
return;
|
||||
}
|
||||
|
||||
lua_getglobal(lua, "global");
|
||||
if (lua_pcall(lua, 1, 1, 0) != 0) {
|
||||
qError("SCRIPT ERROR: %s", lua_tostring(lua, -1));
|
||||
lua_pop(lua, -1);
|
||||
return;
|
||||
}
|
||||
int tNumOfOutput = 0;
|
||||
luaValueToTaosType(lua, pOutput, &tNumOfOutput, pCtx->resType, pCtx->resBytes);
|
||||
*numOfOutput = tNumOfOutput;
|
||||
}
|
||||
|
||||
//do not support agg now
|
||||
void taosLoadScriptFinalize(void *pInit,int64_t key, char *pOutput, int32_t* numOfOutput) {
|
||||
ScriptCtx *pCtx = pInit;
|
||||
char funcName[MAX_FUNC_NAME] = {0};
|
||||
sprintf(funcName, "%s_finalize", pCtx->funcName);
|
||||
|
||||
lua_State* lua = pCtx->pEnv->lua_state;
|
||||
lua_getglobal(lua, funcName);
|
||||
if (!lua_isfunction(lua, -1)) {
|
||||
qError("SCRIPT ERROR: %s", lua_tostring(lua, -1));
|
||||
return;
|
||||
}
|
||||
|
||||
lua_getglobal(lua, "global");
|
||||
|
||||
lua_pushnumber(lua, (lua_Number)key);
|
||||
if (lua_pcall(lua, 2, 2, 0) != 0) {
|
||||
qError("SCRIPT ERROR: %s", lua_tostring(lua, -1));
|
||||
lua_pop(lua, -1);
|
||||
return;
|
||||
}
|
||||
lua_setglobal(lua, "global");
|
||||
int tNumOfOutput = 0;
|
||||
luaValueToTaosType(lua, pOutput, &tNumOfOutput, pCtx->resType, pCtx->resBytes);
|
||||
*numOfOutput = tNumOfOutput;
|
||||
}
|
||||
|
||||
void taosLoadScriptDestroy(void *pInit) {
|
||||
destroyScriptCtx(pInit);
|
||||
}
|
||||
|
||||
ScriptCtx* createScriptCtx(char *script, int8_t resType, int16_t resBytes) {
|
||||
ScriptCtx *pCtx = (ScriptCtx *)calloc(1, sizeof(ScriptCtx));
|
||||
pCtx->state = SCRIPT_STATE_INIT;
|
||||
pCtx->pEnv = getScriptEnvFromPool(); //
|
||||
pCtx->resType = resType;
|
||||
pCtx->resBytes = resBytes;
|
||||
|
||||
if (pCtx->pEnv == NULL) {
|
||||
destroyScriptCtx(pCtx);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
lua_State *lua = pCtx->pEnv->lua_state;
|
||||
if (luaL_dostring(lua, script)) {
|
||||
lua_pop(lua, 1);
|
||||
qError("dynamic load script failed");
|
||||
destroyScriptCtx(pCtx);
|
||||
return NULL;
|
||||
}
|
||||
lua_getglobal(lua, USER_FUNC_NAME);
|
||||
const char *name = lua_tostring(lua, -1);
|
||||
if (name == NULL) {
|
||||
lua_pop(lua, 1);
|
||||
qError("SCRIPT ERROR: invalid script");
|
||||
destroyScriptCtx(pCtx);
|
||||
return NULL;
|
||||
}
|
||||
memcpy(pCtx->funcName, name, strlen(name));
|
||||
lua_pop(lua, 1);
|
||||
|
||||
return pCtx;
|
||||
}
|
||||
void destroyScriptCtx(void *pCtx) {
|
||||
if (pCtx == NULL) return;
|
||||
addScriptEnvToPool(((ScriptCtx *)pCtx)->pEnv);
|
||||
free(pCtx);
|
||||
}
|
||||
|
||||
void luaValueToTaosType(lua_State *lua, char *interBuf, int32_t *numOfOutput, int16_t oType, int16_t oBytes) {
|
||||
int t = lua_type(lua,-1);
|
||||
int32_t sz = 0;
|
||||
switch (t) {
|
||||
case LUA_TSTRING:
|
||||
//TODO(yihaodeng): handle str type
|
||||
{
|
||||
const char *v = lua_tostring(lua, -1);
|
||||
memcpy(interBuf, v, strlen(v));
|
||||
sz = 1;
|
||||
}
|
||||
break;
|
||||
case LUA_TBOOLEAN:
|
||||
{
|
||||
double v = lua_tonumber(lua, -1);
|
||||
memcpy(interBuf, (char *)&v, oBytes);
|
||||
sz = 1;
|
||||
}
|
||||
break;
|
||||
case LUA_TNUMBER:
|
||||
{
|
||||
if (oType == TSDB_DATA_TYPE_FLOAT) {
|
||||
float v = (float)lua_tonumber(lua, -1);
|
||||
memcpy(interBuf, (char *)&v, oBytes);
|
||||
sz = 1;
|
||||
} else if (oType == TSDB_DATA_TYPE_DOUBLE) {
|
||||
double v = (double)lua_tonumber(lua, -1);
|
||||
memcpy(interBuf, (char *)&v, oBytes);
|
||||
sz = 1;
|
||||
} else if (oType == TSDB_DATA_TYPE_BIGINT) {
|
||||
int64_t v = (int64_t)lua_tonumber(lua, -1);
|
||||
memcpy(interBuf, (char *)&v, oBytes);
|
||||
sz = 1;
|
||||
} else if (oType <= TSDB_DATA_TYPE_INT) {
|
||||
int32_t v = (int32_t)lua_tonumber(lua, -1);
|
||||
memcpy(interBuf, (char *)&v, oBytes);
|
||||
sz = 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case LUA_TTABLE:
|
||||
{
|
||||
lua_pushnil(lua);
|
||||
int32_t offset = 0;
|
||||
while(lua_next(lua, -2)) {
|
||||
int32_t v = (int32_t)lua_tonumber(lua, -1);
|
||||
memcpy(interBuf + offset, (char *)&v, oBytes);
|
||||
offset += oBytes;
|
||||
lua_pop(lua, 1);
|
||||
sz += 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
setNull(interBuf, oType, oBytes);
|
||||
sz = 1;
|
||||
break;
|
||||
}
|
||||
lua_pop(lua,1); // pop ret value from script
|
||||
*numOfOutput = sz;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*Initialize the scripting environment.
|
||||
*/
|
||||
lua_State* createLuaEnv() {
|
||||
lua_State *lua = lua_open();
|
||||
luaLoadLibraries(lua);
|
||||
luaRemoveUnsupportedFunctions(lua);
|
||||
|
||||
// register func in external lib
|
||||
luaRegisterLibFunc(lua);
|
||||
|
||||
{
|
||||
char *errh_func = "local dbg = debug\n"
|
||||
"function __taos__err__handler(err)\n"
|
||||
" local i = dbg.getinfo(2,'nSl')\n"
|
||||
" if i and i.what == 'C' then\n"
|
||||
" i = dbg.getinfo(3,'nSl')\n"
|
||||
" end\n"
|
||||
" if i then\n"
|
||||
" return i.source .. ':' .. i.currentline .. ': ' .. err\n"
|
||||
" else\n"
|
||||
" return err\n"
|
||||
" end\n"
|
||||
"end\n";
|
||||
luaL_loadbuffer(lua,errh_func,strlen(errh_func),"@err_handler_def");
|
||||
lua_pcall(lua,0,0,0);
|
||||
}
|
||||
|
||||
return lua;
|
||||
}
|
||||
|
||||
void destroyLuaEnv(lua_State *lua) {
|
||||
lua_close(lua);
|
||||
}
|
||||
|
||||
int32_t scriptEnvPoolInit() {
|
||||
const int size = 10; // configure or not
|
||||
pool = malloc(sizeof(ScriptEnvPool));
|
||||
pthread_mutex_init(&pool->mutex, NULL);
|
||||
|
||||
pool->scriptEnvs = tdListNew(sizeof(ScriptEnv *));
|
||||
for (int i = 0; i < size; i++) {
|
||||
ScriptEnv *env = malloc(sizeof(ScriptEnv));
|
||||
env->funcId = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);;
|
||||
env->lua_state = createLuaEnv();
|
||||
tdListAppend(pool->scriptEnvs, (void *)(&env));
|
||||
}
|
||||
pool->mSize = size;
|
||||
pool->cSize = size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void scriptEnvPoolCleanup() {
|
||||
if (pool == NULL) return;
|
||||
|
||||
SListNode *pNode = NULL;
|
||||
while ((pNode = tdListPopHead(pool->scriptEnvs)) != NULL) {
|
||||
ScriptEnv *pEnv = NULL;
|
||||
tdListNodeGetData(pool->scriptEnvs, pNode, (void *)(&pEnv));
|
||||
destroyScriptEnv(pEnv);
|
||||
listNodeFree(pNode);
|
||||
}
|
||||
tdListFree(pool->scriptEnvs);
|
||||
pthread_mutex_destroy(&pool->mutex);
|
||||
free(pool);
|
||||
}
|
||||
|
||||
void destroyScriptEnv(ScriptEnv *pEnv) {
|
||||
destroyLuaEnv(pEnv->lua_state);
|
||||
taosHashCleanup(pEnv->funcId);
|
||||
free(pEnv);
|
||||
}
|
||||
|
||||
ScriptEnv* getScriptEnvFromPool() {
|
||||
ScriptEnv *pEnv = NULL;
|
||||
|
||||
pthread_mutex_lock(&pool->mutex);
|
||||
if (pool->cSize <= 0) {
|
||||
pthread_mutex_unlock(&pool->mutex);
|
||||
return NULL;
|
||||
}
|
||||
SListNode *pNode = tdListPopHead(pool->scriptEnvs);
|
||||
tdListNodeGetData(pool->scriptEnvs, pNode, (void *)(&pEnv));
|
||||
listNodeFree(pNode);
|
||||
|
||||
pool->cSize--;
|
||||
pthread_mutex_unlock(&pool->mutex);
|
||||
return pEnv;
|
||||
}
|
||||
|
||||
void addScriptEnvToPool(ScriptEnv *pEnv) {
|
||||
if (pEnv == NULL) {
|
||||
return;
|
||||
}
|
||||
pthread_mutex_lock(&pool->mutex);
|
||||
lua_settop(pEnv->lua_state, 0);
|
||||
tdListAppend(pool->scriptEnvs, (void *)(&pEnv));
|
||||
pool->cSize++;
|
||||
pthread_mutex_unlock(&pool->mutex);
|
||||
}
|
||||
|
||||
bool hasBaseFuncDefinedInScript(lua_State *lua, const char *funcPrefix, int32_t len) {
|
||||
bool ret = true;
|
||||
char funcName[MAX_FUNC_NAME];
|
||||
memcpy(funcName, funcPrefix, len);
|
||||
|
||||
const char *base[] = {"_init", "_add"};
|
||||
for (int i = 0; (i < sizeof(base)/sizeof(base[0])) && (ret == true); i++) {
|
||||
memcpy(funcName + len, base[i], strlen(base[i]));
|
||||
memset(funcName + len + strlen(base[i]), 0, MAX_FUNC_NAME - len - strlen(base[i]));
|
||||
lua_getglobal(lua, funcName);
|
||||
ret = lua_isfunction(lua, -1); // exsit function or not
|
||||
lua_pop(lua, 1);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool isValidScript(char *script, int32_t len) {
|
||||
ScriptEnv *pEnv = getScriptEnvFromPool(); //
|
||||
if (pEnv == NULL) {
|
||||
return false;
|
||||
}
|
||||
lua_State *lua = pEnv->lua_state;
|
||||
if (len < strlen(script)) {
|
||||
script[len] = 0;
|
||||
}
|
||||
if (luaL_dostring(lua, script)) {
|
||||
lua_pop(lua, 1);
|
||||
addScriptEnvToPool(pEnv);
|
||||
qError("error at %s and %d", script, (int)(strlen(script)));
|
||||
return false;
|
||||
}
|
||||
lua_getglobal(lua, USER_FUNC_NAME);
|
||||
const char *name = lua_tostring(lua, -1);
|
||||
if (name == NULL || strlen(name) >= USER_FUNC_NAME_LIMIT) {
|
||||
lua_pop(lua, 1);
|
||||
addScriptEnvToPool(pEnv);
|
||||
qError("error at %s name: %s, len = %d", script, name, (int)(strlen(name)));
|
||||
return false;
|
||||
}
|
||||
bool ret = hasBaseFuncDefinedInScript(lua, name, (int32_t)strlen(name));
|
||||
lua_pop(lua, 1); // pop
|
||||
addScriptEnvToPool(pEnv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -28,6 +28,7 @@ SSqlInfo qSqlParse(const char *pStr) {
|
|||
|
||||
SSqlInfo sqlInfo = {0};
|
||||
sqlInfo.valid = true;
|
||||
sqlInfo.funcs = taosArrayInit(4, sizeof(SStrToken));
|
||||
|
||||
int32_t i = 0;
|
||||
while (1) {
|
||||
|
|
@ -120,6 +121,19 @@ void tSqlExprListDestroy(SArray *pList) {
|
|||
taosArrayDestroyEx(pList, freeExprElem);
|
||||
}
|
||||
|
||||
|
||||
SArray *tStrTokenAppend(SArray *pList, SStrToken *pToken) {
|
||||
if (pList == NULL) {
|
||||
pList = taosArrayInit(4, sizeof(tVariantListItem));
|
||||
}
|
||||
|
||||
if (pToken) {
|
||||
taosArrayPush(pList, pToken);
|
||||
}
|
||||
|
||||
return pList;
|
||||
}
|
||||
|
||||
tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType) {
|
||||
tSqlExpr *pSqlExpr = calloc(1, sizeof(tSqlExpr));
|
||||
|
||||
|
|
@ -923,8 +937,8 @@ void* destroyCreateTableSql(SCreateTableSql* pCreate) {
|
|||
}
|
||||
|
||||
void SqlInfoDestroy(SSqlInfo *pInfo) {
|
||||
if (pInfo == NULL) return;
|
||||
|
||||
if (pInfo == NULL) return;;
|
||||
taosArrayDestroy(pInfo->funcs);
|
||||
if (pInfo->type == TSDB_SQL_SELECT) {
|
||||
destroyAllSqlNode(pInfo->list);
|
||||
} else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
|
||||
|
|
@ -1019,6 +1033,18 @@ void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrTo
|
|||
pInfo->pMiscInfo->tableType = tableType;
|
||||
}
|
||||
|
||||
void setDropFuncInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken) {
|
||||
pInfo->type = type;
|
||||
|
||||
if (pInfo->pMiscInfo == NULL) {
|
||||
pInfo->pMiscInfo = (SMiscInfo *)calloc(1, sizeof(SMiscInfo));
|
||||
pInfo->pMiscInfo->a = taosArrayInit(4, sizeof(SStrToken));
|
||||
}
|
||||
|
||||
taosArrayPush(pInfo->pMiscInfo->a, pToken);
|
||||
}
|
||||
|
||||
|
||||
void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns) {
|
||||
if (pInfo->pMiscInfo == NULL) {
|
||||
pInfo->pMiscInfo = calloc(1, sizeof(SMiscInfo));
|
||||
|
|
@ -1053,6 +1079,24 @@ void setCreateDbInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDb
|
|||
pInfo->pMiscInfo->dbOpt.ignoreExists = pIgExists->n; // sql.y has: ifnotexists(X) ::= IF NOT EXISTS. {X.n = 1;}
|
||||
}
|
||||
|
||||
void setCreateFuncInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPath, TAOS_FIELD *output, SStrToken* bufSize, int32_t funcType) {
|
||||
pInfo->type = type;
|
||||
if (pInfo->pMiscInfo == NULL) {
|
||||
pInfo->pMiscInfo = calloc(1, sizeof(SMiscInfo));
|
||||
}
|
||||
|
||||
pInfo->pMiscInfo->funcOpt.name = *pName;
|
||||
pInfo->pMiscInfo->funcOpt.path = *pPath;
|
||||
pInfo->pMiscInfo->funcOpt.output = *output;
|
||||
pInfo->pMiscInfo->funcOpt.type = funcType;
|
||||
if (bufSize->n > 0) {
|
||||
pInfo->pMiscInfo->funcOpt.bufSize = strtol(bufSize->z, NULL, 10);
|
||||
} else {
|
||||
pInfo->pMiscInfo->funcOpt.bufSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void setCreateAcctSql(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctInfo *pAcctInfo) {
|
||||
pInfo->type = type;
|
||||
if (pInfo->pMiscInfo == NULL) {
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void freeParam(SQueryParam *param) {
|
|||
tfree(param->prevResult);
|
||||
}
|
||||
|
||||
int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo, uint64_t *qId) {
|
||||
int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo, uint64_t qId) {
|
||||
assert(pQueryMsg != NULL && tsdb != NULL);
|
||||
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -93,12 +93,12 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
|
|||
|
||||
SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
|
||||
if ((code = createQueryFunc(&info, pQueryMsg->numOfOutput, ¶m.pExprs, param.pExpr, param.pTagColumnInfo,
|
||||
pQueryMsg->queryType, pQueryMsg)) != TSDB_CODE_SUCCESS) {
|
||||
pQueryMsg->queryType, pQueryMsg, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
|
||||
goto _over;
|
||||
}
|
||||
|
||||
if (param.pSecExpr != NULL) {
|
||||
if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, ¶m.pSecExprs, param.pSecExpr, param.pExprs)) != TSDB_CODE_SUCCESS) {
|
||||
if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, ¶m.pSecExprs, param.pSecExpr, param.pExprs, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
|
||||
goto _over;
|
||||
}
|
||||
}
|
||||
|
|
@ -162,18 +162,14 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
|
|||
|
||||
assert(pQueryMsg->stableQuery == isSTableQuery);
|
||||
(*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo,
|
||||
param.pTagColumnInfo, vgId, param.sql, *qId);
|
||||
param.pTagColumnInfo, vgId, param.sql, qId, param.pUdfInfo);
|
||||
|
||||
param.sql = NULL;
|
||||
param.pExprs = NULL;
|
||||
param.pSecExprs = NULL;
|
||||
param.pGroupbyExpr = NULL;
|
||||
param.pTagColumnInfo = NULL;
|
||||
|
||||
if ((*pQInfo) == NULL) {
|
||||
code = TSDB_CODE_QRY_OUT_OF_MEMORY;
|
||||
goto _over;
|
||||
}
|
||||
param.pUdfInfo = NULL;
|
||||
|
||||
code = initQInfo(&pQueryMsg->tsBuf, tsdb, NULL, *pQInfo, ¶m, (char*)pQueryMsg, pQueryMsg->prevResultLen, NULL);
|
||||
|
||||
|
|
@ -182,6 +178,8 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
|
|||
taosArrayDestroy(param.pGroupbyExpr->columnInfo);
|
||||
}
|
||||
|
||||
destroyUdfInfo(param.pUdfInfo);
|
||||
|
||||
taosArrayDestroy(param.pTableIdList);
|
||||
param.pTableIdList = NULL;
|
||||
|
||||
|
|
|
|||
3304
src/query/src/sql.c
3304
src/query/src/sql.c
File diff suppressed because it is too large
Load Diff
|
|
@ -109,11 +109,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SQL_SYNTAX_ERROR, "Syntax error in SQL")
|
|||
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DB_NOT_SELECTED, "Database not specified or available")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_NAME, "Table does not exist")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT, "SQL statement too long, check maxSQLLength config")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_FILE_EMPTY, "File is empty")
|
||||
|
||||
// mnode
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED, "Message not processed")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_IN_PROGRESS, "Message is progressing")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED, "Messag need to be reprocessed")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED, "Message need to be reprocessed")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_RIGHTS, "Insufficient privilege for operation")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_APP_ERROR, "Unexpected generic error in mnode")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONNECTION, "Invalid message connection")
|
||||
|
|
@ -183,6 +184,13 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST, "Field does not exist"
|
|||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STABLE_NAME, "Super table does not exist")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG, "Invalid create table message")
|
||||
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_NAME, "Invalid func name")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_LEN, "Invalid func length")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_CODE, "Invalid func code")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_ALREADY_EXIST, "Func already exists")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC, "Invalid func")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE, "Invalid func bufSize")
|
||||
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED, "Database not specified or available")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST, "Database already exists")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION, "Invalid database options")
|
||||
|
|
@ -269,6 +277,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC, "Multiple retrieval of
|
|||
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW, "Too many time window in query")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER, "Query buffer limit has reached")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN, "File inconsistance in replica")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SYS_ERROR, "System error")
|
||||
|
||||
|
||||
// grant
|
||||
|
|
@ -403,6 +412,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG, "tag value can not mor
|
|||
TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL, "value not find")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE, "value type should be boolean, number or string")
|
||||
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_REQUEST_JSON_ERROR, "http request json error")
|
||||
|
||||
// odbc
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM, "out of memory")
|
||||
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM, "convertion not a valid literal input")
|
||||
|
|
|
|||
|
|
@ -173,10 +173,12 @@ int taosReadAllQitems(taos_queue param, taos_qall p2) {
|
|||
STaosQueue *queue = (STaosQueue *)param;
|
||||
STaosQall *qall = (STaosQall *)p2;
|
||||
int code = 0;
|
||||
bool empty;
|
||||
|
||||
pthread_mutex_lock(&queue->mutex);
|
||||
|
||||
if (queue->head) {
|
||||
empty = queue->head == NULL;
|
||||
if (!empty) {
|
||||
memset(qall, 0, sizeof(STaosQall));
|
||||
qall->current = queue->head;
|
||||
qall->start = queue->head;
|
||||
|
|
@ -188,11 +190,17 @@ int taosReadAllQitems(taos_queue param, taos_qall p2) {
|
|||
queue->tail = NULL;
|
||||
queue->numOfItems = 0;
|
||||
if (queue->qset) atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&queue->mutex);
|
||||
|
||||
return code;
|
||||
|
||||
// if source queue is empty, we set destination qall to empty too.
|
||||
if (empty) {
|
||||
qall->current = NULL;
|
||||
qall->start = NULL;
|
||||
qall->numOfItems = 0;
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
int taosGetQitem(taos_qall param, int *type, void **pitem) {
|
||||
|
|
@ -423,10 +431,22 @@ int taosReadAllQitemsFromQset(taos_qset param, taos_qall p2, void **phandle) {
|
|||
|
||||
int taosGetQueueItemsNumber(taos_queue param) {
|
||||
STaosQueue *queue = (STaosQueue *)param;
|
||||
return queue->numOfItems;
|
||||
if (!queue) return 0;
|
||||
|
||||
int num;
|
||||
pthread_mutex_lock(&queue->mutex);
|
||||
num = queue->numOfItems;
|
||||
pthread_mutex_unlock(&queue->mutex);
|
||||
return num;
|
||||
}
|
||||
|
||||
int taosGetQsetItemsNumber(taos_qset param) {
|
||||
STaosQset *qset = (STaosQset *)param;
|
||||
return qset->numOfItems;
|
||||
if (!qset) return 0;
|
||||
|
||||
int num = 0;
|
||||
pthread_mutex_lock(&qset->mutex);
|
||||
num = qset->numOfItems;
|
||||
pthread_mutex_unlock(&qset->mutex);
|
||||
return num;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -546,7 +546,6 @@ static FORCE_INLINE int32_t getSkipListNodeRandomHeight(SSkipList *pSkipList) {
|
|||
const uint32_t factor = 4;
|
||||
|
||||
int32_t n = 1;
|
||||
|
||||
#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
|
||||
while ((rand() % factor) == 0 && n <= pSkipList->maxLevel) {
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -219,8 +219,13 @@ static SKeyword keywordTable[] = {
|
|||
{"PARTITIONS", TK_PARTITIONS},
|
||||
{"TOPIC", TK_TOPIC},
|
||||
{"TOPICS", TK_TOPICS},
|
||||
{"COMPACT", TK_COMPACT},
|
||||
{"MODIFY", TK_MODIFY}
|
||||
{"COMPACT", TK_COMPACT},
|
||||
{"MODIFY", TK_MODIFY},
|
||||
{"FUNCTION", TK_FUNCTION},
|
||||
{"FUNCTIONS", TK_FUNCTIONS},
|
||||
{"OUTPUTTYPE", TK_OUTPUTTYPE},
|
||||
{"AGGREGATE", TK_AGGREGATE},
|
||||
{"BUFSIZE", TK_BUFSIZE},
|
||||
};
|
||||
|
||||
static const char isIdChar[] = {
|
||||
|
|
@ -269,7 +274,7 @@ static int32_t tKeywordCode(const char* z, int n) {
|
|||
if (keywordHashTable == NULL) {
|
||||
return TK_ILLEGAL;
|
||||
}
|
||||
|
||||
|
||||
SKeyword** pKey = (SKeyword**)taosHashGet(keywordHashTable, key, n);
|
||||
return (pKey != NULL)? (*pKey)->type:TK_ID;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -231,7 +231,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
|
|||
if (contLen != 0) {
|
||||
qinfo_t pQInfo = NULL;
|
||||
uint64_t qId = genQueryId();
|
||||
code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, &pQInfo, &qId);
|
||||
code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, &pQInfo, qId);
|
||||
|
||||
SQueryTableRsp *pRsp = (SQueryTableRsp *)rpcMallocCont(sizeof(SQueryTableRsp));
|
||||
pRsp->code = code;
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ int32_t vnodeProcessWrite(void *vparam, void *wparam, int32_t qtype, void *rpara
|
|||
|
||||
// forward to peers, even it is WAL/FWD, it shall be called to update version in sync
|
||||
int32_t syncCode = 0;
|
||||
bool force = (pWrite == NULL ? false : pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT);
|
||||
bool force = (pWrite == NULL ? false : pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT);
|
||||
syncCode = syncForwardToPeer(pVnode->sync, pHead, pWrite, qtype, force);
|
||||
if (syncCode < 0) {
|
||||
pHead->version = 0;
|
||||
|
|
@ -237,7 +237,7 @@ static SVWriteMsg *vnodeBuildVWriteMsg(SVnodeObj *pVnode, SWalHead *pHead, int32
|
|||
return NULL;
|
||||
}
|
||||
|
||||
int32_t size = sizeof(SVWriteMsg) + sizeof(SWalHead) + pHead->len;
|
||||
int32_t size = sizeof(SVWriteMsg) + pHead->len;
|
||||
SVWriteMsg *pWrite = taosAllocateQitem(size);
|
||||
if (pWrite == NULL) {
|
||||
terrno = TSDB_CODE_VND_OUT_OF_MEMORY;
|
||||
|
|
@ -248,7 +248,7 @@ static SVWriteMsg *vnodeBuildVWriteMsg(SVnodeObj *pVnode, SWalHead *pHead, int32
|
|||
pWrite->rpcMsg = *pRpcMsg;
|
||||
}
|
||||
|
||||
memcpy(&pWrite->pHead, pHead, sizeof(SWalHead) + pHead->len);
|
||||
memcpy(&pWrite->walHead, pHead, sizeof(SWalHead) + pHead->len);
|
||||
pWrite->pVnode = pVnode;
|
||||
pWrite->qtype = qtype;
|
||||
|
||||
|
|
@ -286,7 +286,7 @@ static int32_t vnodeWriteToWQueueImp(SVWriteMsg *pWrite) {
|
|||
}
|
||||
|
||||
int32_t queued = atomic_add_fetch_32(&pVnode->queuedWMsg, 1);
|
||||
int64_t queuedSize = atomic_add_fetch_64(&pVnode->queuedWMsgSize, pWrite->pHead.len);
|
||||
int64_t queuedSize = atomic_add_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
|
||||
|
||||
if (queued > MAX_QUEUED_MSG_NUM || queuedSize > MAX_QUEUED_MSG_SIZE) {
|
||||
int32_t ms = (queued / MAX_QUEUED_MSG_NUM) * 10 + 3;
|
||||
|
|
@ -330,7 +330,7 @@ void vnodeFreeFromWQueue(void *vparam, SVWriteMsg *pWrite) {
|
|||
SVnodeObj *pVnode = vparam;
|
||||
if (pVnode) {
|
||||
int32_t queued = atomic_sub_fetch_32(&pVnode->queuedWMsg, 1);
|
||||
int64_t queuedSize = atomic_sub_fetch_64(&pVnode->queuedWMsgSize, pWrite->pHead.len);
|
||||
int64_t queuedSize = atomic_sub_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
|
||||
|
||||
vTrace("vgId:%d, msg:%p, app:%p, free from vwqueue, queued:%d size:%" PRId64, pVnode->vgId, pWrite,
|
||||
pWrite->rpcMsg.ahandle, queued, queuedSize);
|
||||
|
|
|
|||
|
|
@ -36,9 +36,16 @@ static int32_t walInitObj(SWal *pWal);
|
|||
static void walFreeObj(void *pWal);
|
||||
|
||||
int32_t walInit() {
|
||||
int32_t code = 0;
|
||||
tsWal.refId = taosOpenRef(TSDB_MIN_VNODES, walFreeObj);
|
||||
|
||||
int32_t code = walCreateThread();
|
||||
code = pthread_mutex_init(&tsWal.mutex, NULL);
|
||||
if (code) {
|
||||
wError("failed to init wal mutex since %s", tstrerror(code));
|
||||
return code;
|
||||
}
|
||||
|
||||
code = walCreateThread();
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
wError("failed to init wal module since %s", tstrerror(code));
|
||||
return code;
|
||||
|
|
@ -51,6 +58,7 @@ int32_t walInit() {
|
|||
void walCleanUp() {
|
||||
walStopThread();
|
||||
taosCloseRef(tsWal.refId);
|
||||
pthread_mutex_destroy(&tsWal.mutex);
|
||||
wInfo("wal module is cleaned up");
|
||||
}
|
||||
|
||||
|
|
@ -183,10 +191,15 @@ static void walFsyncAll() {
|
|||
}
|
||||
|
||||
static void *walThreadFunc(void *param) {
|
||||
int stop = 0;
|
||||
while (1) {
|
||||
walUpdateSeq();
|
||||
walFsyncAll();
|
||||
if (tsWal.stop) break;
|
||||
|
||||
pthread_mutex_lock(&tsWal.mutex);
|
||||
stop = tsWal.stop;
|
||||
pthread_mutex_unlock(&tsWal.mutex);
|
||||
if (stop) break;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
|
@ -209,7 +222,10 @@ static int32_t walCreateThread() {
|
|||
}
|
||||
|
||||
static void walStopThread() {
|
||||
pthread_mutex_lock(&tsWal.mutex);
|
||||
tsWal.stop = 1;
|
||||
pthread_mutex_unlock(&tsWal.mutex);
|
||||
|
||||
if (taosCheckPthreadValid(tsWal.thread)) {
|
||||
pthread_join(tsWal.thread, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,13 +8,13 @@ IF (TD_LINUX)
|
|||
ADD_EXECUTABLE(subscribe subscribe.c)
|
||||
TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
|
||||
ADD_EXECUTABLE(epoll epoll.c)
|
||||
TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
|
||||
TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
|
||||
ENDIF ()
|
||||
IF (TD_DARWIN)
|
||||
INCLUDE_DIRECTORIES(. ${TD_COMMUNITY_DIR}/src/inc ${TD_COMMUNITY_DIR}/src/client/inc ${TD_COMMUNITY_DIR}/inc)
|
||||
AUX_SOURCE_DIRECTORY(. SRC)
|
||||
ADD_EXECUTABLE(demo demo.c)
|
||||
TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
|
||||
TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
|
||||
ADD_EXECUTABLE(epoll epoll.c)
|
||||
TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
|
||||
TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
|
||||
ENDIF ()
|
||||
|
|
|
|||
|
|
@ -240,6 +240,7 @@ python3 ./test.py -f query/nestedQuery/queryInterval.py
|
|||
python3 ./test.py -f query/queryStateWindow.py
|
||||
python3 ./test.py -f query/nestedQuery/queryWithOrderLimit.py
|
||||
python3 ./test.py -f query/nestquery_last_row.py
|
||||
python3 ./test.py -f query/queryCnameDisplay.py
|
||||
|
||||
|
||||
#stream
|
||||
|
|
|
|||
|
|
@ -0,0 +1,104 @@
|
|||
###################################################################
|
||||
# Copyright (c) 2016 by TAOS Technologies, Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# This file is proprietary and confidential to TAOS Technologies.
|
||||
# No part of this file may be reproduced, stored, transmitted,
|
||||
# disclosed or used in any form or by any means other than as
|
||||
# expressly provided by the written permission from Jianhui Tao
|
||||
#
|
||||
###################################################################
|
||||
|
||||
# -*- coding: utf-8 -*-
|
||||
import string
|
||||
import random
|
||||
import sys
|
||||
import taos
|
||||
from util.log import tdLog
|
||||
from util.cases import tdCases
|
||||
from util.sql import tdSql
|
||||
|
||||
|
||||
class TDTestCase:
|
||||
def init(self, conn, logSql):
|
||||
tdLog.debug("start to execute %s" % __file__)
|
||||
tdSql.init(conn.cursor(), logSql)
|
||||
|
||||
def getLongName(self, len, mode = "mixed"):
|
||||
"""
|
||||
generate long str
|
||||
"""
|
||||
chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(len))
|
||||
return chars
|
||||
|
||||
def checkRegularTableCname(self):
|
||||
"""
|
||||
check regular table cname
|
||||
"""
|
||||
# len(colName) <=64, generate cname list and make first param = 63 and second param = 65
|
||||
cname_list = []
|
||||
for i in range(10):
|
||||
cname_list.append(self.getLongName(64))
|
||||
cname_list[0] = self.getLongName(63)
|
||||
cname_list[1] = self.getLongName(65)
|
||||
# create table and insert data
|
||||
tdSql.execute("CREATE TABLE regular_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20))")
|
||||
tdSql.execute('insert into regular_table_cname_check values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
|
||||
tdSql.execute('insert into regular_table_cname_check values (now, 2, 3, 1.2, 2.3, "b", 2, 1, false, "aa");')
|
||||
tdSql.execute('insert into regular_table_cname_check values (now, 3, 4, 1.3, 2.4, "c", 1, 3, true, "bb");')
|
||||
|
||||
# select as cname with cname_list
|
||||
sql_seq = f'select count(ts) as {cname_list[0]}, sum(pi1) as {cname_list[1]}, avg(pi2) as {cname_list[2]}, count(pf1) as {cname_list[3]}, count(pf2) as {cname_list[4]}, count(ps1) as {cname_list[5]}, min(pi3) as {cname_list[6]}, max(pi4) as {cname_list[7]}, count(pb1) as {cname_list[8]}, count(ps2) as {cname_list[9]} from regular_table_cname_check'
|
||||
sql_seq_no_as = sql_seq.replace('as ', '')
|
||||
res = tdSql.getColNameList(sql_seq)
|
||||
res_no_as = tdSql.getColNameList(sql_seq_no_as)
|
||||
|
||||
# cname[1] > 64, it is expected to be equal to 64
|
||||
cname_list_1_expected = cname_list[1][:-1]
|
||||
cname_list[1] = cname_list_1_expected
|
||||
checkColNameList = tdSql.checkColNameList(res, cname_list)
|
||||
checkColNameList = tdSql.checkColNameList(res_no_as, cname_list)
|
||||
|
||||
def checkSuperTableCname(self):
|
||||
"""
|
||||
check super table cname
|
||||
"""
|
||||
# len(colName) <=64, generate cname list and make first param = 63 and second param = 65
|
||||
cname_list = []
|
||||
for i in range(19):
|
||||
cname_list.append(self.getLongName(64))
|
||||
cname_list[0] = self.getLongName(63)
|
||||
cname_list[1] = self.getLongName(65)
|
||||
|
||||
# create table and insert data
|
||||
tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));")
|
||||
tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
|
||||
tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
|
||||
tdSql.execute('insert into st1 values (now, 1, 1, 1.4, 2.3, "b", 3, 2, true, "aa");')
|
||||
tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, false, "bb");')
|
||||
|
||||
# select as cname with cname_list
|
||||
sql_seq = f'select count(ts) as {cname_list[0]}, sum(pi1) as {cname_list[1]}, avg(pi2) as {cname_list[2]}, count(pf1) as {cname_list[3]}, count(pf2) as {cname_list[4]}, count(ps1) as {cname_list[5]}, min(pi3) as {cname_list[6]}, max(pi4) as {cname_list[7]}, count(pb1) as {cname_list[8]}, count(ps2) as {cname_list[9]}, count(si1) as {cname_list[10]}, count(si2) as {cname_list[11]}, count(sf1) as {cname_list[12]}, count(sf2) as {cname_list[13]}, count(ss1) as {cname_list[14]}, count(si3) as {cname_list[15]}, count(si4) as {cname_list[16]}, count(sb1) as {cname_list[17]}, count(ss2) as {cname_list[18]} from super_table_cname_check'
|
||||
sql_seq_no_as = sql_seq.replace('as ', '')
|
||||
res = tdSql.getColNameList(sql_seq)
|
||||
res_no_as = tdSql.getColNameList(sql_seq_no_as)
|
||||
|
||||
# cname[1] > 64, it is expected to be equal to 64
|
||||
cname_list_1_expected = cname_list[1][:-1]
|
||||
cname_list[1] = cname_list_1_expected
|
||||
checkColNameList = tdSql.checkColNameList(res, cname_list)
|
||||
checkColNameList = tdSql.checkColNameList(res_no_as, cname_list)
|
||||
|
||||
def run(self):
|
||||
tdSql.prepare()
|
||||
self.checkRegularTableCname()
|
||||
self.checkSuperTableCname()
|
||||
|
||||
def stop(self):
|
||||
tdSql.close()
|
||||
tdLog.success("%s successfully executed" % __file__)
|
||||
|
||||
|
||||
tdCases.addWindows(__file__, TDTestCase())
|
||||
tdCases.addLinux(__file__, TDTestCase())
|
||||
|
||||
|
|
@ -79,6 +79,21 @@ class TDSql:
|
|||
raise Exception(repr(e))
|
||||
return self.queryRows
|
||||
|
||||
def getColNameList(self, sql):
|
||||
self.sql = sql
|
||||
try:
|
||||
col_name_list = []
|
||||
self.cursor.execute(sql)
|
||||
self.queryCols = self.cursor.description
|
||||
for query_col in self.queryCols:
|
||||
col_name_list.append(query_col[0])
|
||||
except Exception as e:
|
||||
caller = inspect.getframeinfo(inspect.stack()[1][0])
|
||||
args = (caller.filename, caller.lineno, sql, repr(e))
|
||||
tdLog.notice("%s(%d) failed: sql:%s, %s" % args)
|
||||
raise Exception(repr(e))
|
||||
return col_name_list
|
||||
|
||||
def waitedQuery(self, sql, expectRows, timeout):
|
||||
tdLog.info("sql: %s, try to retrieve %d rows in %d seconds" % (sql, expectRows, timeout))
|
||||
self.sql = sql
|
||||
|
|
@ -209,6 +224,14 @@ class TDSql:
|
|||
|
||||
tdLog.info("sql:%s, affectedRows:%d == expect:%d" % (self.sql, self.affectedRows, expectAffectedRows))
|
||||
|
||||
def checkColNameList(self, col_name_list, expect_col_name_list):
|
||||
if col_name_list == expect_col_name_list:
|
||||
tdLog.info("sql:%s, col_name_list:%s == expect_col_name_list:%s" % (self.sql, col_name_list, expect_col_name_list))
|
||||
else:
|
||||
caller = inspect.getframeinfo(inspect.stack()[1][0])
|
||||
args = (caller.filename, caller.lineno, self.sql, col_name_list, expect_col_name_list)
|
||||
tdLog.exit("%s(%d) failed: sql:%s, col_name_list:%s != expect_col_name_list:%s" % args)
|
||||
|
||||
def taosdStatus(self, state):
|
||||
tdLog.sleep(5)
|
||||
pstate = 0
|
||||
|
|
|
|||
|
|
@ -0,0 +1,324 @@
|
|||
#!/bin/bash
|
||||
stty erase '^H'
|
||||
stty erase '^?'
|
||||
|
||||
# 运行前需要安装expect; apt install expect
|
||||
# 运行方式:
|
||||
# ./cluster.sh -c xxx.cfg
|
||||
# cfg文件内格式: 每行代表一个节点 第一列为external ip、第二列为密码、第三列为用户名、第四列为hostname、第五列为interal ip
|
||||
# 注意：列与列直接用空格隔开
|
||||
# 例子:
|
||||
# 51.143.97.155 tbase125! root node5 10.2.0.10
|
||||
# 20.94.253.116 tbase125! root node2 10.2.0.12
|
||||
# 20.94.250.236 tbase125! root node3 10.2.0.13
|
||||
# 20.98.72.51 tbase125! root node4 10.2.0.14
|
||||
|
||||
menu(){
|
||||
echo "=============================="
|
||||
echo "-------------Target-----------"
|
||||
echo "=============================="
|
||||
echo "1 cluster"
|
||||
echo "=============================="
|
||||
echo "2 dnode"
|
||||
echo "=============================="
|
||||
echo "3 arbitrator"
|
||||
echo "=============================="
|
||||
echo "4 exit"
|
||||
echo "=============================="
|
||||
}
|
||||
|
||||
cluster_menu(){
|
||||
echo "=============================="
|
||||
echo "----------Operation-----------"
|
||||
echo "=============================="
|
||||
echo "1 start cluster"
|
||||
echo "=============================="
|
||||
echo "2 stop cluster"
|
||||
echo "=============================="
|
||||
echo "3 exit"
|
||||
echo "=============================="
|
||||
}
|
||||
|
||||
dnode_menu(){
|
||||
echo "=============================="
|
||||
echo "----------Operation-----------"
|
||||
echo "=============================="
|
||||
echo "1 start dnode"
|
||||
echo "=============================="
|
||||
echo "2 stop dnode"
|
||||
echo "=============================="
|
||||
echo "3 add dnode"
|
||||
echo "=============================="
|
||||
echo "4 drop dnode"
|
||||
echo "=============================="
|
||||
echo "5 exit"
|
||||
echo "=============================="
|
||||
}
|
||||
|
||||
arbitrator_menu(){
|
||||
echo "=============================="
|
||||
echo "----------Operation-----------"
|
||||
echo "=============================="
|
||||
echo "1 start arbitrator"
|
||||
echo "=============================="
|
||||
echo "2 stop arbitrator"
|
||||
echo "=============================="
|
||||
echo "3 exit"
|
||||
echo "=============================="
|
||||
}
|
||||
|
||||
print_cfg() {
|
||||
echo "=============================="
|
||||
echo "-------Configure file---------"
|
||||
echo "=============================="
|
||||
echo "Id | IP address | hostname"
|
||||
i=1
|
||||
while read line || [[ -n ${line} ]]
|
||||
do
|
||||
arr=($line)
|
||||
echo " $i | ${arr[0]} | ${arr[3]}"
|
||||
i=`expr $i + 1`;
|
||||
done < $1
|
||||
echo "=============================="
|
||||
}
|
||||
|
||||
update(){
|
||||
expect -c "
|
||||
set timeout -1;
|
||||
spawn ssh $3@$1;
|
||||
expect {
|
||||
*yes/no* { send \"yes\r\"; exp_continue }
|
||||
*assword:* { send \"$2\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"systemctl $4 taosd\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"exit\r\" }
|
||||
}
|
||||
expect eof;
|
||||
"
|
||||
echo -e "\033[32mdnode successfully $4 \033[0m"
|
||||
}
|
||||
|
||||
update_dnode(){
|
||||
i=1
|
||||
while read line || [[ -n ${line} ]]
|
||||
do
|
||||
if [[ $1 -eq $i ]]; then
|
||||
arr=($line)
|
||||
update ${arr[0]} ${arr[1]} ${arr[2]} $2
|
||||
break;
|
||||
fi
|
||||
i=`expr $i + 1`;
|
||||
done < $3
|
||||
}
|
||||
|
||||
add_hosts() {
|
||||
expect -c "
|
||||
set timeout -1;
|
||||
spawn ssh $3@$1;
|
||||
expect {
|
||||
*yes/no* { send \"yes\r\"; exp_continue }
|
||||
*assword:* { send \"$2\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"echo $4 $5 >> /etc/hosts\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"exit\r\" }
|
||||
}
|
||||
expect eof;
|
||||
"
|
||||
echo -e "\033[32mSuccessfully add to /etc/hosts in $1\033[0m"
|
||||
}
|
||||
|
||||
remove_hosts() {
|
||||
expect -c "
|
||||
set timeout -1;
|
||||
spawn ssh $3@$1;
|
||||
expect {
|
||||
*yes/no* { send \"yes\r\"; exp_continue }
|
||||
*assword:* { send \"$2\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"sed -i '/$4/d\' /etc/hosts\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"exit\r\" }
|
||||
}
|
||||
expect eof;
|
||||
"
|
||||
echo -e "\033[32mSuccessfully remove from /etc/hosts in $1\033[0m"
|
||||
}
|
||||
|
||||
remove_varlibtaos() {
|
||||
expect -c "
|
||||
set timeout -1;
|
||||
spawn ssh $3@$1;
|
||||
expect {
|
||||
*yes/no* { send \"yes\r\"; exp_continue }
|
||||
*assword:* { send \"$2\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"rm -rf /var/lib/taos/*\r\" }
|
||||
}
|
||||
expect {
|
||||
*#* { send \"exit\r\" }
|
||||
}
|
||||
expect eof;
|
||||
"
|
||||
echo -e "\033[32mSuccessfully remove /var/lib/taos/* in $1\033[0m"
|
||||
}
|
||||
|
||||
scp_cfg() {
|
||||
expect -c "
|
||||
set timeout -1;
|
||||
spawn scp /etc/taos/taos.cfg $3@$1:/etc/taos;
|
||||
expect {
|
||||
*yes/no* { send \"yes\r\"; exp_continue }
|
||||
*assword:* { send \"$2\r\" }
|
||||
}
|
||||
expect eof;
|
||||
"
|
||||
echo -e "\033[32mSuccessfully scp /etc/taos/taos.cfg to $1\033[0m"
|
||||
}
|
||||
|
||||
manage_dnode(){
|
||||
i=1
|
||||
while read line || [[ -n ${line} ]]
|
||||
do
|
||||
if [[ $1 -eq $i ]]; then
|
||||
arr=($line)
|
||||
scp_cfg ${arr[0]} ${arr[1]} ${arr[2]}
|
||||
ip=${arr[0]}
|
||||
pd=${arr[1]}
|
||||
user=${arr[2]}
|
||||
j=1
|
||||
while read line2 || [[ -n ${line2} ]]
|
||||
do
|
||||
arr2=($line2)
|
||||
if [[ $1 -ne $j ]]; then
|
||||
if [ $3 == "create" ];then
|
||||
echo "$3"
|
||||
add_hosts $ip $pd $user ${arr2[4]} ${arr2[3]}
|
||||
else
|
||||
remove_hosts $ip $pd $user ${arr2[4]} ${arr2[3]}
|
||||
fi
|
||||
fi
|
||||
j=`expr $j + 1`;
|
||||
done < $2
|
||||
remove_varlibtaos $ip $pd $user
|
||||
if [ $3 == "create" ];then
|
||||
update $ip $pd $user "start"
|
||||
else
|
||||
update $ip $pd $user "stop"
|
||||
fi
|
||||
taos -s "$3 dnode \"${arr[3]}:6030\""
|
||||
break;
|
||||
fi
|
||||
i=`expr $i + 1`;
|
||||
done < $2
|
||||
echo -e "\033[32mSuccessfully $3 dnode id $1\033[0m"
|
||||
}
|
||||
|
||||
update_cluster() {
|
||||
while read line || [[ -n ${line} ]]
|
||||
do
|
||||
arr=($line)
|
||||
if [ $1 == "start" ]; then
|
||||
scp_cfg ${arr[0]} ${arr[1]} ${arr[2]}
|
||||
fi
|
||||
update ${arr[0]} ${arr[1]} ${arr[2]} $1
|
||||
done < $2
|
||||
}
|
||||
|
||||
while :
|
||||
do
|
||||
clear
|
||||
menu
|
||||
read -p "select mode: " n
|
||||
case $n in
|
||||
1)
|
||||
clear
|
||||
print_cfg $2
|
||||
cluster_menu
|
||||
read -p "select operation: " c
|
||||
case $c in
|
||||
1)
|
||||
update_cluster "start" $2
|
||||
break
|
||||
;;
|
||||
2)
|
||||
update_cluster "stop" $2
|
||||
break
|
||||
;;
|
||||
3)
|
||||
break
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
2)
|
||||
clear
|
||||
print_cfg $2
|
||||
dnode_menu
|
||||
read -p "select operation: " d
|
||||
case $d in
|
||||
1)
|
||||
clear
|
||||
print_cfg $2
|
||||
read -p "select dnode: " id
|
||||
update_dnode $id "start" $2
|
||||
break
|
||||
;;
|
||||
2)
|
||||
clear
|
||||
print_cfg $2
|
||||
read -p "select dnode: " id
|
||||
update_dnode $id "stop" $2
|
||||
break
|
||||
;;
|
||||
3)
|
||||
clear
|
||||
print_cfg $2
|
||||
read -p "select dnode: " id
|
||||
manage_dnode $id $2 "create"
|
||||
break
|
||||
;;
|
||||
4)
|
||||
clear
|
||||
print_cfg $2
|
||||
read -p "select dnode: " id
|
||||
manage_dnode $id $2 "drop"
|
||||
break
|
||||
;;
|
||||
5)
|
||||
break
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
3)
|
||||
clear
|
||||
arbitrator_menu
|
||||
read -p "select operation: " m
|
||||
case $m in
|
||||
1)
|
||||
nohup /usr/local/taos/bin/tarbitrator >/dev/null 2>&1 &
|
||||
echo -e "\033[32mSuccessfully start arbitrator $3 \033[0m"
|
||||
break
|
||||
;;
|
||||
2)
|
||||
var=`ps -ef | grep tarbitrator | awk '{print $2}' | head -n 1`
|
||||
kill -9 $var
|
||||
break
|
||||
;;
|
||||
3)
|
||||
break
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
4)
|
||||
break
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
|
@ -247,4 +247,25 @@ if $system_content != @[{"refId":"A","target":"{val1:nil, val2:nil}","datapoints
|
|||
return -1
|
||||
endi
|
||||
|
||||
sql create table tt (ts timestamp ,i int) tags(j binary(20),k binary(20));
|
||||
sql insert into t1 using tt tags('jnetworki','t1') values('2020-01-01 00:00:00.000',1)('2020-01-01 00:01:00.000',2)('2020-01-01 00:02:00.000',3)('2020-01-01 00:03:00.000',4)('2020-01-01 00:04:00.000',5);
|
||||
|
||||
system_content curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d '[ {"refId":"A","alias":"","sql":"select max(i) from db.tt where j like \u0027%network%\u0027 and ts >= \u00272020-01-01 00:00:00.000\u0027 and ts < \u00272020-01-01 00:05:00.000\u0027 interval(5m) group by k "} ]' 127.0.0.1:7111/grafana/query
|
||||
print step1-> $system_content
|
||||
if $system_content != @[{"refId":"A","target":"{k:t1}","datapoints":[[5,1577808000000]]}]@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
system_content curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d '[ {"refId":"A","alias":"","sql":"select max(i) from db.tt where j like \u0027jnetwo%\u0027 and ts >= \u00272020-01-01 00:00:00.000\u0027 and ts < \u00272020-01-01 00:05:00.000\u0027 interval(5m) group by k "} ]' 127.0.0.1:7111/grafana/query
|
||||
print step1-> $system_content
|
||||
if $system_content != @[{"refId":"A","target":"{k:t1}","datapoints":[[5,1577808000000]]}]@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
system_content curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d '[ {"refId":"A","alias":"","sql":"select max(i) from db.tt where j like \u0027%networki\u0027 and ts >= \u00272020-01-01 00:00:00.000\u0027 and ts < \u00272020-01-01 00:05:00.000\u0027 interval(5m) group by k "} ]' 127.0.0.1:7111/grafana/query
|
||||
print step1-> $system_content
|
||||
if $system_content != @[{"refId":"A","target":"{k:t1}","datapoints":[[5,1577808000000]]}]@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
@ -193,7 +193,7 @@ if $data02 != 0.000000000 then
|
|||
return -1
|
||||
endi
|
||||
|
||||
if $data03 != 0.000000000 then
|
||||
if $data03 != NULL then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -444,7 +444,7 @@ if $data02 != 8.077777778 then
|
|||
return -1
|
||||
endi
|
||||
|
||||
if $data03 != inf then
|
||||
if $data03 != NULL then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ run general/parser/create_tb.sim
|
|||
run general/parser/dbtbnameValidate.sim
|
||||
run general/parser/fill.sim
|
||||
run general/parser/fill_stb.sim
|
||||
run general/parser/fill_us.sim
|
||||
#run general/parser/fill_us.sim #
|
||||
run general/parser/first_last.sim
|
||||
run general/parser/import_commit1.sim
|
||||
run general/parser/import_commit2.sim
|
||||
|
|
@ -39,7 +39,6 @@ run general/parser/slimit1.sim
|
|||
run general/parser/slimit_alter_tags.sim
|
||||
run general/parser/tbnameIn.sim
|
||||
run general/parser/join.sim
|
||||
#run general/parser/join_multitables.sim
|
||||
run general/parser/join_multivnode.sim
|
||||
run general/parser/join_manyblocks.sim
|
||||
run general/parser/projection_limit_offset.sim
|
||||
|
|
@ -61,5 +60,9 @@ run general/parser/slimit_alter_tags.sim
|
|||
run general/parser/binary_escapeCharacter.sim
|
||||
run general/parser/between_and.sim
|
||||
run general/parser/last_cache.sim
|
||||
run general/parser/slimit_alter_tags.sim
|
||||
run general/parser/udf.sim
|
||||
run general/parser/udf_dll.sim
|
||||
run general/parser/udf_dll_stable.sim
|
||||
run general/parser/nestquery.sim
|
||||
run general/parser/precision_ns.sim
|
||||
|
|
|
|||
|
|
@ -0,0 +1,637 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c walLevel -v 1
|
||||
system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
system sh/prepare_udf.sh
|
||||
|
||||
sleep 100
|
||||
sql connect
|
||||
print ======================== dnode1 start
|
||||
|
||||
sql create function n01 as '/tmp/normal' outputtype int;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n01 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != INT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n01;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n02 as '/tmp/normal' outputtype bool;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n02 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != BOOL then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n02;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n03 as '/tmp/normal' outputtype TINYINT;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n03 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != TINYINT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n03;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n04 as '/tmp/normal' outputtype SMALLINT;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n04 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != SMALLINT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n04;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n05 as '/tmp/normal' outputtype INT;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n05 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != INT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n05;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n06 as '/tmp/normal' outputtype BIGINT;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n06 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != BIGINT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n06;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n07 as '/tmp/normal' outputtype FLOAT;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n07 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != FLOAT then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n07;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n08 as '/tmp/normal' outputtype DOUBLE;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n08 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != DOUBLE then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n08;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n09 as '/tmp/normal' outputtype BINARY;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n09 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != BINARY(0) then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n09;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n10 as '/tmp/normal' outputtype BINARY(10);
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n10 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != BINARY(10) then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n10;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n11 as '/tmp/normal' outputtype TIMESTAMP;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n11 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != TIMESTAMP then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n11;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n12 as '/tmp/normal' outputtype NCHAR;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n12 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != NCHAR(0) then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n12;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n13 as '/tmp/normal' outputtype NCHAR(10);
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n13 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != NCHAR(10) then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n13;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n14 as '/tmp/normal' outputtype TINYINT UNSIGNED;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n14 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n14;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n15 as '/tmp/normal' outputtype SMALLINT UNSIGNED;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n15 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n15;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function n16 as '/tmp/normal' outputtype INT UNSIGNED;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n16 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n16;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
sql create function n17 as '/tmp/normal' outputtype BIGINT UNSIGNED;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n17 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n17;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql create aggregate function n18 as '/tmp/normal' outputtype BIGINT UNSIGNED;
|
||||
sql show functions;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
if $data00 != n18 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != /tmp/normal then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql drop function n18;
|
||||
|
||||
sql show functions;
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
sql create function t01 as '/tmp/normal' outputtype INT;
|
||||
sql_error create function t01 as '/tmp/normal' outputtype SMALLINT;
|
||||
sql drop function t01;
|
||||
sql create function t01 as '/tmp/normal' outputtype INT;
|
||||
sql create function t02 as '/tmp/normal' outputtype SMALLINT;
|
||||
sql show functions;
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
sql_error create function e1 as '/tmp/normal';
|
||||
sql_error create function e2 as '/tmp/normal' outputtype;
|
||||
sql_error create function e3 as '/tmp/normal' a;
|
||||
sql_error create function e4 as '/tmp/normal' outputtype a;
|
||||
sql_error create function e5 as '/tmp/normal' outputtype bool int;
|
||||
sql_error create function as '/tmp/normal' outputtype;
|
||||
sql_error create function e6 as '/tmp/empty' outputtype int;
|
||||
sql_error create function e7 as '/tmp/big' outputtype int;
|
||||
sql_error create function e8 as '/tmp/noexistfile' outputtype int;
|
||||
sql_error create function e0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456 as '/tmp/normal' outputtype int;
|
||||
sql_error create function e9 as outputtype int;
|
||||
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
@ -0,0 +1,494 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c walLevel -v 1
|
||||
system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
system sh/prepare_udf.sh
|
||||
|
||||
sleep 100
|
||||
sql connect
|
||||
print ======================== dnode1 start
|
||||
|
||||
sql create function add_one as '/tmp/add_one.so' outputtype int;
|
||||
sql create aggregate function sum_double as '/tmp/sum_double.so' outputtype int;
|
||||
sql show functions;
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql create database db;
|
||||
sql use db;
|
||||
sql create table tb1 (ts timestamp, f1 int, f2 bool, f3 binary(10));
|
||||
sql insert into tb1 values ('2021-03-23 17:17:19.660', 1, true, 'tb1-1');
|
||||
sql insert into tb1 values ('2021-03-23 19:23:28.595', 2, false, 'tb1-2');
|
||||
sql insert into tb1 values ('2021-03-23 19:33:39.070', 3, true, 'tb1-3');
|
||||
sql insert into tb1 values ('2021-03-23 19:34:37.670', 4, false, 'tb1-4');
|
||||
sql insert into tb1 values ('2021-03-24 19:08:06.609', 5, true, 'tb1-5');
|
||||
sql insert into tb1 values ('2021-03-24 19:26:38.231', 6, false, 'tb1-6');
|
||||
sql insert into tb1 values ('2021-03-25 10:03:17.688', 7, true, 'tb1-7');
|
||||
|
||||
sql select add_one(f1) from tb1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != 7 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != 8 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select sum_double(f1) from tb1;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 56 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select ts,add_one(f1),f1 from tb1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-23 17:17:19.660@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-23 19:23:28.595@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data12 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-03-23 19:33:39.070@ then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data22 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-03-23 19:34:37.670@ then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data32 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != @21-03-24 19:08:06.609@ then
|
||||
return -1
|
||||
endi
|
||||
if $data41 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data42 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != @21-03-24 19:26:38.231@ then
|
||||
return -1
|
||||
endi
|
||||
if $data51 != 7 then
|
||||
return -1
|
||||
endi
|
||||
if $data52 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != @21-03-25 10:03:17.688@ then
|
||||
return -1
|
||||
endi
|
||||
if $data61 != 8 then
|
||||
return -1
|
||||
endi
|
||||
if $data62 != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
|
||||
sql select add_one(f1),add_one(f1) from tb1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data41 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != 7 then
|
||||
return -1
|
||||
endi
|
||||
if $data51 != 7 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != 8 then
|
||||
return -1
|
||||
endi
|
||||
if $data61 != 8 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select add_one(f1)+1 from tb1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 3.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 4.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != 5.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != 6.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != 7.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != 8.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != 9.000000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select sum_double(f1)+1 from tb1;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 57.000000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select add_one(f1)+1,f1 from tb1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 3.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 4.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != 5.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != 6.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != 7.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data41 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != 8.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data51 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != 9.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $data61 != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select sum_double(f1) from tb1 interval (10a);
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-23 17:17:19.660@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-23 19:23:28.590@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-03-23 19:33:39.070@ then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-03-23 19:34:37.670@ then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 8 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != @21-03-24 19:08:06.600@ then
|
||||
return -1
|
||||
endi
|
||||
if $data41 != 10 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != @21-03-24 19:26:38.230@ then
|
||||
return -1
|
||||
endi
|
||||
if $data51 != 12 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != @21-03-25 10:03:17.680@ then
|
||||
return -1
|
||||
endi
|
||||
if $data61 != 14 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select ts,add_one(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000";
|
||||
if $rows != 6 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-23 17:17:19.660@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-23 19:23:28.595@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-03-23 19:33:39.070@ then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-03-23 19:34:37.670@ then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 5 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != @21-03-24 19:08:06.609@ then
|
||||
return -1
|
||||
endi
|
||||
if $data41 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != @21-03-24 19:26:38.231@ then
|
||||
return -1
|
||||
endi
|
||||
if $data51 != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h);
|
||||
if $rows != 3 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-23 17:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-23 19:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 18 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-03-24 19:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 22 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h) fill(value,999);
|
||||
if $rows != 28 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql_error select add_one(f1) from tb1 group by f1;
|
||||
|
||||
sql select sum_double(f1) from tb1 group by f1;
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != 8 then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != 10 then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != 12 then
|
||||
return -1
|
||||
endi
|
||||
if $data60 != 14 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select sum_double(f1) from tb1 interval (1h) order by ts desc;
|
||||
if $rows != 4 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-25 10:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 14 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-24 19:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 22 then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-03-23 19:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 18 then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-03-23 17:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data31 != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select add_one(f1) from tb1 limit 2;
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != 3 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql select sum_double(f1) from tb1 interval (1d) limit 2;
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
if $data00 != @21-03-23 00:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 20 then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-03-24 00:00:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 22 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
sql_error select ts,sum_double(f1),f1 from tb1;
|
||||
sql_error select add_one(f1),count(f1) from tb1;
|
||||
sql_error select sum_double(f1),count(f1) from tb1;
|
||||
sql_error select add_one(f1),top(f1,3) from tb1;
|
||||
sql_error select add_one(f1) from tb1 interval(10a);
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,88 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct SUdfInit{
|
||||
int maybe_null; /* 1 if function can return NULL */
|
||||
int decimals; /* for real functions */
|
||||
long long length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
int const_item; /* 0 if result is independent of arguments */
|
||||
} SUdfInit;
|
||||
|
||||
|
||||
#define TSDB_DATA_INT_NULL 0x80000000L
|
||||
#define TSDB_DATA_BIGINT_NULL 0x8000000000000000L
|
||||
|
||||
void abs_max(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
|
||||
int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
|
||||
int i;
|
||||
int r = 0;
|
||||
printf("abs_max input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
|
||||
if (itype == 5) {
|
||||
r=*(long *)dataOutput;
|
||||
*numOfOutput=0;
|
||||
|
||||
for(i=0;i<numOfRows;++i) {
|
||||
if (*((long *)data + i) == TSDB_DATA_BIGINT_NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
*numOfOutput=1;
|
||||
long v = abs(*((long *)data + i));
|
||||
if (v > r) {
|
||||
r = v;
|
||||
}
|
||||
}
|
||||
|
||||
*(long *)dataOutput=r;
|
||||
|
||||
printf("abs_max out, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
|
||||
int i;
|
||||
int r = 0;
|
||||
printf("abs_max_finalize dataoutput:%p:%d, numOfOutput:%d, buf:%p\n", dataOutput, *dataOutput, *numOfOutput, buf);
|
||||
*numOfOutput=1;
|
||||
printf("abs_max finalize, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
|
||||
}
|
||||
|
||||
void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
|
||||
int r = 0;
|
||||
|
||||
if (numOfRows > 0) {
|
||||
r = *((long *)data);
|
||||
}
|
||||
printf("abs_max_merge numOfRows:%d, dataoutput:%p, buf:%p\n", numOfRows, dataOutput, buf);
|
||||
for (int i = 1; i < numOfRows; ++i) {
|
||||
printf("abs_max_merge %d - %ld\n", i, *((long *)data + i));
|
||||
if (*((long*)data + i) > r) {
|
||||
r= *((long*)data + i);
|
||||
}
|
||||
}
|
||||
|
||||
*(long*)dataOutput=r;
|
||||
if (numOfRows > 0) {
|
||||
*numOfOutput=1;
|
||||
} else {
|
||||
*numOfOutput=0;
|
||||
}
|
||||
|
||||
printf("abs_max_merge, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
|
||||
}
|
||||
|
||||
|
||||
int abs_max_init(SUdfInit* buf) {
|
||||
printf("abs_max init\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void abs_max_destroy(SUdfInit* buf) {
|
||||
printf("abs_max destroy\n");
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct SUdfInit{
|
||||
int maybe_null; /* 1 if function can return NULL */
|
||||
int decimals; /* for real functions */
|
||||
long long length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
int const_item; /* 0 if result is independent of arguments */
|
||||
} SUdfInit;
|
||||
|
||||
void add_one(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBUf, char* tsOutput,
|
||||
int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
|
||||
int i;
|
||||
int r = 0;
|
||||
printf("add_one input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
|
||||
if (itype == 4) {
|
||||
for(i=0;i<numOfRows;++i) {
|
||||
printf("input %d - %d", i, *((int *)data + i));
|
||||
*((int *)dataOutput+i)=*((int *)data + i) + 1;
|
||||
printf(", output %d\n", *((int *)dataOutput+i));
|
||||
if (tsOutput) {
|
||||
*(long long*)tsOutput=1000000;
|
||||
}
|
||||
}
|
||||
*numOfOutput=numOfRows;
|
||||
|
||||
printf("add_one out, numOfOutput:%d\n", *numOfOutput);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct SUdfInit{
|
||||
int maybe_null; /* 1 if function can return NULL */
|
||||
int decimals; /* for real functions */
|
||||
long long length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
int const_item; /* 0 if result is independent of arguments */
|
||||
} SUdfInit;
|
||||
|
||||
typedef struct SDemo{
|
||||
double sum;
|
||||
int num;
|
||||
short otype;
|
||||
}SDemo;
|
||||
|
||||
#define FLOAT_NULL 0x7FF00000 // it is an NAN
|
||||
#define DOUBLE_NULL 0x7FFFFF0000000000L // it is an NAN
|
||||
|
||||
|
||||
void demo(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
|
||||
int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
|
||||
int i;
|
||||
double r = 0;
|
||||
SDemo *p = (SDemo *)interBuf;
|
||||
SDemo *q = (SDemo *)dataOutput;
|
||||
printf("demo input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, interBUf:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, interBuf, tsOutput, numOfOutput, buf);
|
||||
|
||||
for(i=0;i<numOfRows;++i) {
|
||||
if (itype == 4) {
|
||||
r=*((int *)data+i);
|
||||
} else if (itype == 6) {
|
||||
r=*((float *)data+i);
|
||||
} else if (itype == 7) {
|
||||
r=*((double *)data+i);
|
||||
}
|
||||
|
||||
p->sum += r*r;
|
||||
}
|
||||
|
||||
p->otype = otype;
|
||||
p->num += numOfRows;
|
||||
|
||||
q->sum = p->sum;
|
||||
q->num = p->num;
|
||||
q->otype = p->otype;
|
||||
|
||||
*numOfOutput=1;
|
||||
|
||||
printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
|
||||
}
|
||||
|
||||
|
||||
void demo_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
|
||||
int i;
|
||||
SDemo *p = (SDemo *)data;
|
||||
SDemo res = {0};
|
||||
printf("demo_merge input data:%p, rows:%d, dataoutput:%p, numOfOutput:%p, buf:%p\n", data, numOfRows, dataOutput, numOfOutput, buf);
|
||||
|
||||
for(i=0;i<numOfRows;++i) {
|
||||
res.sum += p->sum * p->sum;
|
||||
res.num += p->num;
|
||||
p++;
|
||||
}
|
||||
|
||||
p->sum = res.sum;
|
||||
p->num = res.num;
|
||||
|
||||
*numOfOutput=1;
|
||||
|
||||
printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void demo_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
|
||||
SDemo *p = (SDemo *)interBuf;
|
||||
printf("demo_finalize interbuf:%p, numOfOutput:%p, buf:%p, sum:%f, num:%d\n", interBuf, numOfOutput, buf, p->sum, p->num);
|
||||
if (p->otype == 6) {
|
||||
if (p->num != 30000) {
|
||||
*(unsigned int *)dataOutput = FLOAT_NULL;
|
||||
} else {
|
||||
*(float *)dataOutput = (float)(p->sum / p->num);
|
||||
}
|
||||
printf("finalize values:%f\n", *(float *)dataOutput);
|
||||
} else if (p->otype == 7) {
|
||||
if (p->num != 30000) {
|
||||
*(unsigned long long *)dataOutput = DOUBLE_NULL;
|
||||
} else {
|
||||
*(double *)dataOutput = (double)(p->sum / p->num);
|
||||
}
|
||||
printf("finalize values:%f\n", *(double *)dataOutput);
|
||||
}
|
||||
|
||||
*numOfOutput=1;
|
||||
|
||||
printf("demo finalize, numOfOutput:%d\n", *numOfOutput);
|
||||
}
|
||||
|
||||
|
||||
int demo_init(SUdfInit* buf) {
|
||||
printf("demo init\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void demo_destroy(SUdfInit* buf) {
|
||||
printf("demo destroy\n");
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
funcName = "test"
|
||||
|
||||
global = {}
|
||||
|
||||
function test_init()
|
||||
return global
|
||||
end
|
||||
|
||||
function test_add(rows, ans, key)
|
||||
t = {}
|
||||
t["sum"] = 0.0
|
||||
t["num"] = 0
|
||||
for i=1, #rows do
|
||||
t["sum"] = t["sum"] + rows[i] * rows[i]
|
||||
end
|
||||
t["num"] = #rows
|
||||
|
||||
|
||||
if (ans[key] ~= nil)
|
||||
then
|
||||
ans[key]["sum"] = ans[key]["sum"] + t["sum"]
|
||||
ans[key]["num"] = ans[key]["num"] + t["num"]
|
||||
else
|
||||
ans[key] = t
|
||||
end
|
||||
|
||||
return ans;
|
||||
end
|
||||
|
||||
function test_finalize(ans, key)
|
||||
local ret = 0.0
|
||||
|
||||
if (ans[key] ~= nil and ans[key]["num"] == 30000)
|
||||
then
|
||||
ret = ans[key]["sum"]/ans[key]["num"]
|
||||
ans[key]["sum"] = 0.0
|
||||
ans[key]["num"] = 0
|
||||
else
|
||||
ret = inf
|
||||
end
|
||||
|
||||
return ret, ans
|
||||
end
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#!/bin/sh
|
||||
|
||||
echo -n "hello" > /tmp/normal
|
||||
echo -n "" > /tmp/empty
|
||||
dd if=/dev/zero bs=3584 of=/tmp/big count=1
|
||||
|
||||
rm -rf /tmp/sum_double.so /tmp/add_one.so
|
||||
|
||||
gcc -g -O0 -fPIC -shared sh/sum_double.c -o /tmp/sum_double.so
|
||||
gcc -g -O0 -fPIC -shared sh/add_one.c -o /tmp/add_one.so
|
||||
gcc -g -O0 -fPIC -shared sh/demo.c -o /tmp/demo.so
|
||||
gcc -g -O0 -fPIC -shared sh/abs_max.c -o /tmp/abs_max.so
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
funcName = "test"
|
||||
|
||||
ans = 1
|
||||
|
||||
function test_init()
|
||||
return ans
|
||||
end
|
||||
|
||||
function test_add(rows, ans)
|
||||
for i=1, #rows do
|
||||
rows[i] = rows[i] + ans
|
||||
end
|
||||
return rows
|
||||
end
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct SUdfInit{
|
||||
int maybe_null; /* 1 if function can return NULL */
|
||||
int decimals; /* for real functions */
|
||||
long long length; /* For string functions */
|
||||
char *ptr; /* free pointer for function data */
|
||||
int const_item; /* 0 if result is independent of arguments */
|
||||
} SUdfInit;
|
||||
|
||||
#define TSDB_DATA_INT_NULL 0x80000000L
|
||||
|
||||
|
||||
void sum_double(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
|
||||
int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
|
||||
int i;
|
||||
int r = 0;
|
||||
printf("sum_double input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
|
||||
if (itype == 4) {
|
||||
r=*(int *)dataOutput;
|
||||
*numOfOutput=0;
|
||||
|
||||
for(i=0;i<numOfRows;++i) {
|
||||
if (*((int *)data + i) == TSDB_DATA_INT_NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
*numOfOutput=1;
|
||||
r+=*((int *)data + i);
|
||||
*(int *)dataOutput=r;
|
||||
}
|
||||
|
||||
printf("sum_double out, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void sum_double_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
|
||||
int i;
|
||||
int r = 0;
|
||||
printf("sum_double_finalize dataoutput:%p:%d, numOfOutput:%d, buf:%p\n", dataOutput, *dataOutput, *numOfOutput, buf);
|
||||
*numOfOutput=1;
|
||||
*(int*)(buf->ptr)=*(int*)dataOutput*2;
|
||||
*(int*)dataOutput=*(int*)(buf->ptr);
|
||||
printf("sum_double finalize, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
|
||||
}
|
||||
|
||||
void sum_double_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
|
||||
int r = 0;
|
||||
int sum = 0;
|
||||
|
||||
printf("sum_double_merge numOfRows:%d, dataoutput:%p, buf:%p\n", numOfRows, dataOutput, buf);
|
||||
for (int i = 0; i < numOfRows; ++i) {
|
||||
printf("sum_double_merge %d - %d\n", i, *((int*)data + i));
|
||||
sum +=*((int*)data + i);
|
||||
}
|
||||
|
||||
*(int*)dataOutput+=sum;
|
||||
if (numOfRows > 0) {
|
||||
*numOfOutput=1;
|
||||
} else {
|
||||
*numOfOutput=0;
|
||||
}
|
||||
|
||||
printf("sum_double_merge, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
|
||||
}
|
||||
|
||||
|
||||
int sum_double_init(SUdfInit* buf) {
|
||||
buf->maybe_null=1;
|
||||
buf->ptr = malloc(sizeof(int));
|
||||
printf("sum_double init\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void sum_double_destroy(SUdfInit* buf) {
|
||||
free(buf->ptr);
|
||||
printf("sum_double destroy\n");
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue