more code format

source/libs/function/inc/builtinsimpl.h

@@ -28,32 +28,32 @@ bool dummyInit(SqlFunctionCtx* UNUSED_PARAM(pCtx), SResultRowEntryInfo* UNUSED_P
 int32_t dummyProcess(SqlFunctionCtx* UNUSED_PARAM(pCtx));
 int32_t dummyFinalize(SqlFunctionCtx* UNUSED_PARAM(pCtx), SSDataBlock* UNUSED_PARAM(pBlock));
 
-bool functionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t functionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t functionFinalizeWithResultBuf(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, char* finalResult);
 int32_t combineFunction(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 EFuncDataRequired countDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
 bool              getCountFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-int32_t countFunction(SqlFunctionCtx *pCtx);
-int32_t countInvertFunction(SqlFunctionCtx *pCtx);
+int32_t           countFunction(SqlFunctionCtx* pCtx);
+int32_t           countInvertFunction(SqlFunctionCtx* pCtx);
 
 EFuncDataRequired statisDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
 bool              getSumFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-int32_t sumFunction(SqlFunctionCtx *pCtx);
-int32_t sumInvertFunction(SqlFunctionCtx *pCtx);
+int32_t           sumFunction(SqlFunctionCtx* pCtx);
+int32_t           sumInvertFunction(SqlFunctionCtx* pCtx);
 int32_t           sumCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
-bool minmaxFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 bool    getMinmaxFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 int32_t minFunction(SqlFunctionCtx* pCtx);
-int32_t maxFunction(SqlFunctionCtx *pCtx);
+int32_t maxFunction(SqlFunctionCtx* pCtx);
 int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t minCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 int32_t maxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 bool    getAvgFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool avgFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t avgFunction(SqlFunctionCtx* pCtx);
 int32_t avgFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t avgFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -63,7 +63,7 @@ int32_t avgCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 int32_t getAvgInfoSize();
 
 bool    getStddevFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool stddevFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t stddevFunction(SqlFunctionCtx* pCtx);
 int32_t stddevFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t stddevFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -73,20 +73,20 @@ int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 int32_t getStddevInfoSize();
 
 bool    getLeastSQRFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool leastSQRFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t leastSQRFunction(SqlFunctionCtx* pCtx);
 int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t leastSQRInvertFunction(SqlFunctionCtx* pCtx);
 int32_t leastSQRCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 bool    getPercentileFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool percentileFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t percentileFunction(SqlFunctionCtx *pCtx);
+bool    percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t percentileFunction(SqlFunctionCtx* pCtx);
 int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool    getApercentileFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool apercentileFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t apercentileFunction(SqlFunctionCtx *pCtx);
+bool    apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t apercentileFunction(SqlFunctionCtx* pCtx);
 int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t apercentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t apercentilePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -94,25 +94,25 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)
 int32_t getApercentileMaxSize();
 
 bool    getDiffFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool diffFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo);
-int32_t diffFunction(SqlFunctionCtx *pCtx);
+bool    diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t diffFunction(SqlFunctionCtx* pCtx);
 
 bool    getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool derivativeFuncSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo);
-int32_t derivativeFunction(SqlFunctionCtx *pCtx);
+bool    derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t derivativeFunction(SqlFunctionCtx* pCtx);
 
 bool    getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool irateFuncSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo);
-int32_t irateFunction(SqlFunctionCtx *pCtx);
+bool    irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t irateFunction(SqlFunctionCtx* pCtx);
 int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 int32_t cachedLastRowFunction(SqlFunctionCtx* pCtx);
 
 bool              getFirstLastFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-int32_t firstFunction(SqlFunctionCtx *pCtx);
-int32_t firstFunctionMerge(SqlFunctionCtx *pCtx);
-int32_t lastFunction(SqlFunctionCtx *pCtx);
-int32_t lastFunctionMerge(SqlFunctionCtx *pCtx);
+int32_t           firstFunction(SqlFunctionCtx* pCtx);
+int32_t           firstFunctionMerge(SqlFunctionCtx* pCtx);
+int32_t           lastFunction(SqlFunctionCtx* pCtx);
+int32_t           lastFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t           firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t           firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t           firstCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
@@ -120,15 +120,15 @@ int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 int32_t           getFirstLastInfoSize(int32_t resBytes);
 EFuncDataRequired lastDynDataReq(void* pRes, STimeWindow* pTimeWindow);
 
-int32_t lastRowFunction(SqlFunctionCtx *pCtx);
+int32_t lastRowFunction(SqlFunctionCtx* pCtx);
 
 bool    getTopBotFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv);
 bool    getTopBotMergeFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv);
-bool topBotFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t topFunction(SqlFunctionCtx *pCtx);
-int32_t topFunctionMerge(SqlFunctionCtx *pCtx);
-int32_t bottomFunction(SqlFunctionCtx *pCtx);
-int32_t bottomFunctionMerge(SqlFunctionCtx *pCtx);
+bool    topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t topFunction(SqlFunctionCtx* pCtx);
+int32_t topFunctionMerge(SqlFunctionCtx* pCtx);
+int32_t bottomFunction(SqlFunctionCtx* pCtx);
+int32_t bottomFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t topBotPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 int32_t topBotMergeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -137,7 +137,7 @@ int32_t bottomCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 int32_t getTopBotInfoSize(int64_t numOfItems);
 
 bool    getSpreadFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool spreadFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t spreadFunction(SqlFunctionCtx* pCtx);
 int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t spreadFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -146,7 +146,7 @@ int32_t getSpreadInfoSize();
 int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 bool    getElapsedFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool elapsedFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t elapsedFunction(SqlFunctionCtx* pCtx);
 int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t elapsedFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -155,7 +155,7 @@ int32_t getElapsedInfoSize();
 int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 bool    getHistogramFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool histogramFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t histogramFunction(SqlFunctionCtx* pCtx);
 int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx);
 int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx);
@@ -173,7 +173,7 @@ int32_t getHLLInfoSize();
 int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
 
 bool    getStateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool stateFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    stateFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t stateCountFunction(SqlFunctionCtx* pCtx);
 int32_t stateDurationFunction(SqlFunctionCtx* pCtx);
 
@@ -181,36 +181,36 @@ bool getCsumFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 int32_t csumFunction(SqlFunctionCtx* pCtx);
 
 bool    getMavgFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool mavgFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t mavgFunction(SqlFunctionCtx* pCtx);
 
 bool    getSampleFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool sampleFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t sampleFunction(SqlFunctionCtx* pCtx);
 int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool    getTailFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool tailFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool    tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
 int32_t tailFunction(SqlFunctionCtx* pCtx);
 
 bool    getUniqueFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool uniqueFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t uniqueFunction(SqlFunctionCtx *pCtx);
+bool    uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t uniqueFunction(SqlFunctionCtx* pCtx);
 
 bool    getModeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool modeFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t modeFunction(SqlFunctionCtx *pCtx);
+bool    modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t modeFunction(SqlFunctionCtx* pCtx);
 int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool    getTwaFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool twaFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t twaFunction(SqlFunctionCtx *pCtx);
-int32_t twaFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock* pBlock);
+bool    twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t twaFunction(SqlFunctionCtx* pCtx);
+int32_t twaFinalize(struct SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool getSelectivityFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 
-bool blockDistSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-int32_t blockDistFunction(SqlFunctionCtx *pCtx);
+bool    blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t blockDistFunction(SqlFunctionCtx* pCtx);
 int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool    getGroupKeyFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);

source/libs/function/inc/tfunctionInt.h

@@ -22,11 +22,11 @@ extern "C" {
 
 #include "os.h"
 
-#include "tname.h"
-#include "taosdef.h"
-#include "tvariant.h"
 #include "function.h"
+#include "taosdef.h"
+#include "tname.h"
 #include "tudf.h"
+#include "tvariant.h"
 
 bool topbot_datablock_filter(SqlFunctionCtx *pCtx, const char *minval, const char *maxval);
 

source/libs/function/inc/tpercentile.h

@@ -61,10 +61,10 @@ typedef struct tMemBucket {
   MinMaxEntry        range;        // value range
   int32_t            times;        // count that has been checked for deciding the correct data value buckets.
   __compar_fn_t      comparFn;
-  tMemBucketSlot*    pSlots;
-  SDiskbasedBuf*     pBuffer;
+  tMemBucketSlot    *pSlots;
+  SDiskbasedBuf     *pBuffer;
   __perc_hash_func_t hashFunc;
-  SHashObj*          groupPagesMap; // disk page map for different groups;
+  SHashObj          *groupPagesMap;  // disk page map for different groups;
 } tMemBucket;
 
 tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval, double maxval);

source/libs/function/inc/tscript.h

@@ -17,14 +17,14 @@
 #define TDENGINE_QSCRIPT_H
 
 #if 0
-#include <lua.h>
 #include <lauxlib.h>
+#include <lua.h>
 #include <lualib.h>
 
-#include "tutil.h"
 #include "hash.h"
 #include "tlist.h"
 #include "tudf.h"
+#include "tutil.h"
 
 #define MAX_FUNC_NAME 64
 
@@ -81,4 +81,4 @@ void    scriptEnvPoolCleanup();
 bool    isValidScript(char *script, int32_t len);
 #endif
 
-#endif //TDENGINE_QSCRIPT_H 
+#endif  // TDENGINE_QSCRIPT_H

source/libs/function/inc/tudfInt.h

@@ -61,12 +61,10 @@ typedef struct SUdfCallResponse {
   SUdfInterBuf resultBuf;
 } SUdfCallResponse;
 
-
 typedef struct SUdfTeardownRequest {
   int64_t udfHandle;
 } SUdfTeardownRequest;
 
-
 typedef struct SUdfTeardownResponse {
 #ifdef WINDOWS
   size_t avoidCompilationErrors;
@@ -98,20 +96,20 @@ typedef struct SUdfResponse {
   };
 } SUdfResponse;
 
-int32_t encodeUdfRequest(void **buf, const SUdfRequest* request);
-void* decodeUdfRequest(const void *buf, SUdfRequest* request);
+int32_t encodeUdfRequest(void **buf, const SUdfRequest *request);
+void   *decodeUdfRequest(const void *buf, SUdfRequest *request);
 
 int32_t encodeUdfResponse(void **buf, const SUdfResponse *response);
-void* decodeUdfResponse(const void* buf, SUdfResponse *response);
+void   *decodeUdfResponse(const void *buf, SUdfResponse *response);
 
 void freeUdfColumnData(SUdfColumnData *data, SUdfColumnMeta *meta);
-void freeUdfColumn(SUdfColumn* col);
+void freeUdfColumn(SUdfColumn *col);
 void freeUdfDataDataBlock(SUdfDataBlock *block);
 
 int32_t convertDataBlockToUdfDataBlock(SSDataBlock *block, SUdfDataBlock *udfBlock);
 int32_t convertUdfColumnToDataBlock(SUdfColumn *udfCol, SSDataBlock *block);
 
-int32_t getUdfdPipeName(char* pipeName, int32_t size);
+int32_t getUdfdPipeName(char *pipeName, int32_t size);
 #ifdef __cplusplus
 }
 #endif

source/libs/function/inc/udfc.h

@@ -20,7 +20,7 @@ enum {
 
 };
 
-typedef struct SSDataBlock{
+typedef struct SSDataBlock {
   char   *data;
   int32_t size;
 } SSDataBlock;
@@ -36,9 +36,9 @@ int32_t createUdfdProxy();
 
 int32_t destroyUdfdProxy();
 
-//int32_t setupUdf(SUdfInfo *udf, int32_t numOfUdfs, UdfcFuncHandle *handles);
+// int32_t setupUdf(SUdfInfo *udf, int32_t numOfUdfs, UdfcFuncHandle *handles);
 
-int32_t setupUdf(SUdfInfo* udf, UdfcFuncHandle* handle);
+int32_t setupUdf(SUdfInfo *udf, UdfcFuncHandle *handle);
 
 int32_t callUdf(UdfcFuncHandle handle, int8_t step, char *state, int32_t stateSize, SSDataBlock input, char **newstate,
                 int32_t *newStateSize, SSDataBlock *output);
@@ -48,7 +48,7 @@ int32_t doTeardownUdf(UdfcFuncHandle handle);
 typedef struct SUdfSetupRequest {
   char    udfName[16];  //
   int8_t  scriptType;   // 0:c, 1: lua, 2:js
-    int8_t udfType; //udaf, udf, udtf
+  int8_t  udfType;      // udaf, udf, udtf
   int16_t pathSize;
   char   *path;
 } SUdfSetupRequest;
@@ -57,7 +57,6 @@ typedef struct SUdfSetupResponse {
   int64_t udfHandle;
 } SUdfSetupResponse;
 
-
 typedef struct SUdfCallRequest {
   int64_t udfHandle;
   int8_t  step;
@@ -69,7 +68,6 @@ typedef struct SUdfCallRequest {
   char   *state;
 } SUdfCallRequest;
 
-
 typedef struct SUdfCallResponse {
   int32_t outputBytes;
   char   *output;
@@ -77,12 +75,10 @@ typedef struct SUdfCallResponse {
   char   *newState;
 } SUdfCallResponse;
 
-
 typedef struct SUdfTeardownRequest {
   int64_t udfHandle;
 } SUdfTeardownRequest;
 
-
 typedef struct SUdfTeardownResponse {
 #ifdef WINDOWS
   size_t avoidCompilationErrors;
@@ -110,4 +106,4 @@ int32_t decodeRequest(char *buf, int32_t bufLen, SUdfRequest **pRequest);
 int32_t encodeResponse(char **buf, int32_t *bufLen, SUdfResponse *response);
 int32_t encodeRequest(char **buf, int32_t *bufLen, SUdfRequest *request);
 int32_t decodeResponse(char *buf, int32_t bufLen, SUdfResponse **pResponse);
-#endif //UDF_UDF_H
+#endif  // UDF_UDF_H

source/libs/function/src/builtinsimpl.c

@@ -2977,7 +2977,8 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
-static void firstLastTransferInfo(SqlFunctionCtx* pCtx, SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst, int32_t rowIndex) {
+static void firstLastTransferInfo(SqlFunctionCtx* pCtx, SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst,
+                                  int32_t rowIndex) {
   SInputColumnInfoData* pColInfo = &pCtx->input;
 
   if (pOutput->hasResult) {

source/libs/function/src/tfunctionInt.c

@@ -15,8 +15,8 @@
 
 #include "os.h"
 #include "taosdef.h"
-#include "tmsg.h"
 #include "thash.h"
+#include "tmsg.h"
 #include "ttypes.h"
 
 #include "function.h"
@@ -29,15 +29,13 @@
 #include "ttszip.h"
 #include "tudf.h"
 
-void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell) {
-  pCell->initialized = false;
-}
+void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell) { pCell->initialized = false; }
 
 int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock) {
   int32_t maxRows = 0;
 
   for (int32_t j = 0; j < num; ++j) {
-    SResultRowEntryInfo *pResInfo = GET_RES_INFO(&pCtx[j]);
+    SResultRowEntryInfo* pResInfo = GET_RES_INFO(&pCtx[j]);
     if (pResInfo != NULL && maxRows < pResInfo->numOfRes) {
       maxRows = pResInfo->numOfRes;
     }
@@ -46,12 +44,12 @@ int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock
   assert(maxRows >= 0);
 
   blockDataEnsureCapacity(pResBlock, maxRows);
-  for(int32_t i = 0; i < num; ++i) {
+  for (int32_t i = 0; i < num; ++i) {
     SColumnInfoData* pCol = taosArrayGet(pResBlock->pDataBlock, i);
 
-    SResultRowEntryInfo *pResInfo = GET_RES_INFO(&pCtx[i]);
+    SResultRowEntryInfo* pResInfo = GET_RES_INFO(&pCtx[i]);
     if (pResInfo->numOfRes == 0) {
-      for(int32_t j = 0; j < pResInfo->numOfRes; ++j) {
+      for (int32_t j = 0; j < pResInfo->numOfRes; ++j) {
         colDataAppend(pCol, j, NULL, true);  // TODO add set null data api
       }
     } else {
@@ -70,6 +68,4 @@ bool isRowEntryCompleted(struct SResultRowEntryInfo* pEntry) {
   return pEntry->complete;
 }
 
-bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry) {
-  return pEntry->initialized;
-}
+bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry) { return pEntry->initialized; }

source/libs/function/src/thistogram.c

@@ -14,10 +14,10 @@
  */
 #include "os.h"
 
-#include "thistogram.h"
 #include "taosdef.h"
-#include "tmsg.h"
+#include "thistogram.h"
 #include "tlosertree.h"
+#include "tmsg.h"
 
 /**
  *
@@ -54,7 +54,7 @@ SHistogramInfo* tHistogramCreateFrom(void* pBuf, int32_t numOfBins) {
 
   SHistogramInfo* pHisto = (SHistogramInfo*)pBuf;
   pHisto->elems = (SHistBin*)((char*)pBuf + sizeof(SHistogramInfo));
-  for(int32_t i = 0; i < numOfBins; ++i) {
+  for (int32_t i = 0; i < numOfBins; ++i) {
     pHisto->elems[i].val = -DBL_MAX;
   }
 
@@ -357,7 +357,7 @@ void tHistogramDestroy(SHistogramInfo** pHisto) {
 }
 
 void tHistogramPrint(SHistogramInfo* pHisto) {
-  printf("total entries: %d, elements: %"PRId64 "\n", pHisto->numOfEntries, pHisto->numOfElems);
+  printf("total entries: %d, elements: %" PRId64 "\n", pHisto->numOfEntries, pHisto->numOfElems);
 #if defined(USE_ARRAYLIST)
   for (int32_t i = 0; i < pHisto->numOfEntries; ++i) {
     printf("%d: (%f, %" PRId64 ")\n", i + 1, pHisto->elems[i].val, pHisto->elems[i].num);

source/libs/function/src/tpercentile.c

@@ -14,8 +14,8 @@
  */
 
 #include "taoserror.h"
-#include "tglobal.h"
 #include "tcompare.h"
+#include "tglobal.h"
 
 #include "taosdef.h"
 #include "tcompare.h"
@@ -25,21 +25,20 @@
 
 #define DEFAULT_NUM_OF_SLOT 1024
 
-int32_t getGroupId(int32_t numOfSlots, int32_t slotIndex, int32_t times) {
-  return (times * numOfSlots) + slotIndex;
-}
+int32_t getGroupId(int32_t numOfSlots, int32_t slotIndex, int32_t times) { return (times * numOfSlots) + slotIndex; }
 
 static SFilePage *loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx) {
-  SFilePage *buffer = (SFilePage *)taosMemoryCalloc(1, pMemBucket->bytes * pMemBucket->pSlots[slotIdx].info.size + sizeof(SFilePage));
+  SFilePage *buffer =
+      (SFilePage *)taosMemoryCalloc(1, pMemBucket->bytes * pMemBucket->pSlots[slotIdx].info.size + sizeof(SFilePage));
 
   int32_t groupId = getGroupId(pMemBucket->numOfSlots, slotIdx, pMemBucket->times);
-  SArray* pIdList = *(SArray**)taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
+  SArray *pIdList = *(SArray **)taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
 
   int32_t offset = 0;
-  for(int32_t i = 0; i < taosArrayGetSize(pIdList); ++i) {
-    int32_t* pageId = taosArrayGet(pIdList, i);
+  for (int32_t i = 0; i < taosArrayGetSize(pIdList); ++i) {
+    int32_t *pageId = taosArrayGet(pIdList, i);
 
-    SFilePage* pg = getBufPage(pMemBucket->pBuffer, *pageId);
+    SFilePage *pg = getBufPage(pMemBucket->pBuffer, *pageId);
     memcpy(buffer->data + offset, pg->data, (size_t)(pg->num * pMemBucket->bytes));
 
     offset += (int32_t)(pg->num * pMemBucket->bytes);
@@ -49,7 +48,7 @@ static SFilePage *loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx)
   return buffer;
 }
 
-static void resetBoundingBox(MinMaxEntry* range, int32_t type) {
+static void resetBoundingBox(MinMaxEntry *range, int32_t type) {
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
     range->i64MaxVal = INT64_MIN;
     range->i64MinVal = INT64_MAX;
@@ -62,17 +61,17 @@ static void resetBoundingBox(MinMaxEntry* range, int32_t type) {
   }
 }
 
-static int32_t setBoundingBox(MinMaxEntry* range, int16_t type, double minval, double maxval) {
+static int32_t setBoundingBox(MinMaxEntry *range, int16_t type, double minval, double maxval) {
   if (minval > maxval) {
     return -1;
   }
 
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
-    range->i64MinVal = (int64_t) minval;
-    range->i64MaxVal = (int64_t) maxval;
-  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)){
-    range->u64MinVal = (uint64_t) minval;
-    range->u64MaxVal = (uint64_t) maxval;
+    range->i64MinVal = (int64_t)minval;
+    range->i64MaxVal = (int64_t)maxval;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    range->u64MinVal = (uint64_t)minval;
+    range->u64MaxVal = (uint64_t)maxval;
   } else {
     range->dMinVal = minval;
     range->dMaxVal = maxval;
@@ -81,7 +80,7 @@ static int32_t setBoundingBox(MinMaxEntry* range, int16_t type, double minval, d
   return 0;
 }
 
-static void resetPosInfo(SSlotInfo* pInfo) {
+static void resetPosInfo(SSlotInfo *pInfo) {
   pInfo->size = 0;
   pInfo->pageId = -1;
   pInfo->data = NULL;
@@ -97,11 +96,11 @@ double findOnlyResult(tMemBucket *pMemBucket) {
     }
 
     int32_t groupId = getGroupId(pMemBucket->numOfSlots, i, pMemBucket->times);
-    SArray* list = *(SArray**)taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
+    SArray *list = *(SArray **)taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
     assert(list->size == 1);
 
-    int32_t* pageId = taosArrayGet(list, 0);
-    SFilePage* pPage = getBufPage(pMemBucket->pBuffer, *pageId);
+    int32_t   *pageId = taosArrayGet(list, 0);
+    SFilePage *pPage = getBufPage(pMemBucket->pBuffer, *pageId);
     assert(pPage->num == 1);
 
     double v = 0;
@@ -155,7 +154,7 @@ int32_t tBucketUintHash(tMemBucket *pBucket, const void *value) {
   uint64_t span = pBucket->range.u64MaxVal - pBucket->range.u64MinVal;
   if (span < pBucket->numOfSlots) {
     int64_t delta = v - pBucket->range.u64MinVal;
-    index = (int32_t) (delta % pBucket->numOfSlots);
+    index = (int32_t)(delta % pBucket->numOfSlots);
   } else {
     double slotSpan = (double)span / pBucket->numOfSlots;
     index = (int32_t)((v - pBucket->range.u64MinVal) / slotSpan);
@@ -209,9 +208,9 @@ static __perc_hash_func_t getHashFunc(int32_t type) {
   }
 }
 
-static void resetSlotInfo(tMemBucket* pBucket) {
+static void resetSlotInfo(tMemBucket *pBucket) {
   for (int32_t i = 0; i < pBucket->numOfSlots; ++i) {
-    tMemBucketSlot* pSlot = &pBucket->pSlots[i];
+    tMemBucketSlot *pSlot = &pBucket->pSlots[i];
 
     resetBoundingBox(&pSlot->range, pBucket->type);
     resetPosInfo(&pSlot->info);
@@ -235,17 +234,17 @@ tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval,
   pBucket->maxCapacity = 200000;
   pBucket->groupPagesMap = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
   if (setBoundingBox(&pBucket->range, pBucket->type, minval, maxval) != 0) {
-//    qError("MemBucket:%p, invalid value range: %f-%f", pBucket, minval, maxval);
+    //    qError("MemBucket:%p, invalid value range: %f-%f", pBucket, minval, maxval);
     taosMemoryFree(pBucket);
     return NULL;
   }
 
-  pBucket->elemPerPage = (pBucket->bufPageSize - sizeof(SFilePage))/pBucket->bytes;
+  pBucket->elemPerPage = (pBucket->bufPageSize - sizeof(SFilePage)) / pBucket->bytes;
   pBucket->comparFn = getKeyComparFunc(pBucket->type, TSDB_ORDER_ASC);
 
   pBucket->hashFunc = getHashFunc(pBucket->type);
   if (pBucket->hashFunc == NULL) {
-//    qError("MemBucket:%p, not support data type %d, failed", pBucket, pBucket->type);
+    //    qError("MemBucket:%p, not support data type %d, failed", pBucket, pBucket->type);
     taosMemoryFree(pBucket);
     return NULL;
   }
@@ -271,7 +270,7 @@ tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval,
     return NULL;
   }
 
-//  qDebug("MemBucket:%p, elem size:%d", pBucket, pBucket->bytes);
+  //  qDebug("MemBucket:%p, elem size:%d", pBucket, pBucket->bytes);
   return pBucket;
 }
 
@@ -280,9 +279,9 @@ void tMemBucketDestroy(tMemBucket *pBucket) {
     return;
   }
 
-  void* p = taosHashIterate(pBucket->groupPagesMap, NULL);
-  while(p) {
-    SArray** p1 = p;
+  void *p = taosHashIterate(pBucket->groupPagesMap, NULL);
+  while (p) {
+    SArray **p1 = p;
     p = taosHashIterate(pBucket->groupPagesMap, p);
     taosArrayDestroy(*p1);
   }
@@ -341,7 +340,7 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
   int32_t count = 0;
   int32_t bytes = pBucket->bytes;
   for (int32_t i = 0; i < size; ++i) {
-    char *d = (char *) data + i * bytes;
+    char   *d = (char *)data + i * bytes;
     int32_t index = (pBucket->hashFunc)(pBucket, d);
     if (index < 0) {
       continue;
@@ -365,9 +364,9 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
         pSlot->info.data = NULL;
       }
 
-      SArray* pPageIdList = (SArray*)taosHashGet(pBucket->groupPagesMap, &groupId, sizeof(groupId));
+      SArray *pPageIdList = (SArray *)taosHashGet(pBucket->groupPagesMap, &groupId, sizeof(groupId));
       if (pPageIdList == NULL) {
-        SArray* pList = taosArrayInit(4, sizeof(int32_t));
+        SArray *pList = taosArrayInit(4, sizeof(int32_t));
         taosHashPut(pBucket->groupPagesMap, &groupId, sizeof(groupId), &pList, POINTER_BYTES);
         pPageIdList = pList;
       }
@@ -407,18 +406,18 @@ static MinMaxEntry getMinMaxEntryOfNextSlotWithData(tMemBucket *pMemBucket, int3
 
 static bool isIdenticalData(tMemBucket *pMemBucket, int32_t index);
 
-static double getIdenticalDataVal(tMemBucket* pMemBucket, int32_t slotIndex) {
+static double getIdenticalDataVal(tMemBucket *pMemBucket, int32_t slotIndex) {
   assert(isIdenticalData(pMemBucket, slotIndex));
 
   tMemBucketSlot *pSlot = &pMemBucket->pSlots[slotIndex];
 
   double finalResult = 0.0;
   if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-    finalResult = (double) pSlot->range.i64MinVal;
+    finalResult = (double)pSlot->range.i64MinVal;
   } else if (IS_UNSIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-    finalResult = (double) pSlot->range.u64MinVal;
+    finalResult = (double)pSlot->range.u64MinVal;
   } else {
-    finalResult = (double) pSlot->range.dMinVal;
+    finalResult = (double)pSlot->range.dMinVal;
   }
 
   return finalResult;
@@ -445,14 +444,14 @@ double getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction)
         double maxOfThisSlot = 0;
         double minOfNextSlot = 0;
         if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-          maxOfThisSlot = (double) pSlot->range.i64MaxVal;
-          minOfNextSlot = (double) next.i64MinVal;
+          maxOfThisSlot = (double)pSlot->range.i64MaxVal;
+          minOfNextSlot = (double)next.i64MinVal;
         } else if (IS_UNSIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-          maxOfThisSlot = (double) pSlot->range.u64MaxVal;
-          minOfNextSlot = (double) next.u64MinVal;
+          maxOfThisSlot = (double)pSlot->range.u64MaxVal;
+          minOfNextSlot = (double)next.u64MinVal;
         } else {
-          maxOfThisSlot = (double) pSlot->range.dMaxVal;
-          minOfNextSlot = (double) next.dMinVal;
+          maxOfThisSlot = (double)pSlot->range.dMaxVal;
+          minOfNextSlot = (double)next.dMinVal;
         }
 
         assert(minOfNextSlot > maxOfThisSlot);
@@ -484,7 +483,7 @@ double getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction)
 
         // try next round
         pMemBucket->times += 1;
-//       qDebug("MemBucket:%p, start next round data bucketing, time:%d", pMemBucket, pMemBucket->times);
+        //       qDebug("MemBucket:%p, start next round data bucketing, time:%d", pMemBucket, pMemBucket->times);
 
         pMemBucket->range = pSlot->range;
         pMemBucket->total = 0;
@@ -527,7 +526,7 @@ double getPercentile(tMemBucket *pMemBucket, double percent) {
 
   // find the min/max value, no need to scan all data in bucket
   if (fabs(percent - 100.0) < DBL_EPSILON || (percent < DBL_EPSILON)) {
-    MinMaxEntry* pRange = &pMemBucket->range;
+    MinMaxEntry *pRange = &pMemBucket->range;
 
     if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
       double v = (double)(fabs(percent - 100) < DBL_EPSILON ? pRange->i64MaxVal : pRange->i64MinVal);
@@ -536,7 +535,7 @@ double getPercentile(tMemBucket *pMemBucket, double percent) {
       double v = (double)(fabs(percent - 100) < DBL_EPSILON ? pRange->u64MaxVal : pRange->u64MinVal);
       return v;
     } else {
-      return fabs(percent - 100) < DBL_EPSILON? pRange->dMaxVal:pRange->dMinVal;
+      return fabs(percent - 100) < DBL_EPSILON ? pRange->dMaxVal : pRange->dMinVal;
     }
   }
 

source/libs/function/src/tscript.c

@@ -13,10 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
 #include "tscript.h"
-#include "ttypes.h"
+#include "os.h"
 #include "tstrbuild.h"
+#include "ttypes.h"
 //#include "queryLog.h"
 #include "ttokendef.h"
 #if 0

source/libs/function/test/runUdf.c

@@ -53,7 +53,7 @@ int scalarFuncTest() {
     blockDataEnsureCapacity(pBlock, 1024);
     pBlock->info.rows = 1024;
 
-    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, 0);
+    SColumnInfoData *pCol = taosArrayGet(pBlock->pDataBlock, 0);
     for (int32_t j = 0; j < pBlock->info.rows; ++j) {
       colDataAppendInt32(pCol, j, &j);
     }
@@ -68,14 +68,13 @@ int scalarFuncTest() {
 
     SColumnInfoData *col = output.columnData;
     for (int32_t i = 0; i < output.numOfRows; ++i) {
-      if (i % 100 == 0)
-        fprintf(stderr, "%d\t%d\n", i, *(int32_t *)(col->pData + i * sizeof(int32_t)));
+      if (i % 100 == 0) fprintf(stderr, "%d\t%d\n", i, *(int32_t *)(col->pData + i * sizeof(int32_t)));
     }
     colDataDestroy(output.columnData);
     taosMemoryFree(output.columnData);
   }
   int64_t end = taosGetTimestampUs();
-  fprintf(stderr, "time: %f\n", (end-beg)/1000.0);
+  fprintf(stderr, "time: %f\n", (end - beg) / 1000.0);
   doTeardownUdf(handle);
 
   return 0;
@@ -98,7 +97,7 @@ int aggregateFuncTest() {
   blockDataEnsureCapacity(pBlock, 1024);
   pBlock->info.rows = 1024;
 
-  SColumnInfoData* pColInfo = bdGetColumnInfoData(pBlock, 0);
+  SColumnInfoData *pColInfo = bdGetColumnInfoData(pBlock, 0);
   for (int32_t j = 0; j < pBlock->info.rows; ++j) {
     colDataAppendInt32(pColInfo, j, &j);
   }
@@ -111,7 +110,7 @@ int aggregateFuncTest() {
   taosArrayDestroy(pBlock->pDataBlock);
 
   doCallUdfAggFinalize(handle, &newBuf, &resultBuf);
-  fprintf(stderr, "agg result: %f\n", *(double*)resultBuf.buf);
+  fprintf(stderr, "agg result: %f\n", *(double *)resultBuf.buf);
 
   freeUdfInterBuf(&buf);
   freeUdfInterBuf(&newBuf);

source/libs/function/test/udf1.c

-#include <string.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #ifdef LINUX
 #include <unistd.h>
 #endif
@@ -9,16 +9,11 @@
 #endif
 #include "taosudf.h"
 
+DLL_EXPORT int32_t udf1_init() { return 0; }
 
-DLL_EXPORT int32_t udf1_init() {
-  return 0;
-}
-
-DLL_EXPORT int32_t udf1_destroy() {
-  return 0;
-}
+DLL_EXPORT int32_t udf1_destroy() { return 0; }
 
-DLL_EXPORT int32_t udf1(SUdfDataBlock* block, SUdfColumn *resultCol) {
+DLL_EXPORT int32_t udf1(SUdfDataBlock *block, SUdfColumn *resultCol) {
   SUdfColumnMeta *meta = &resultCol->colMeta;
   meta->bytes = 4;
   meta->type = TSDB_DATA_TYPE_INT;
@@ -35,12 +30,12 @@ DLL_EXPORT int32_t udf1(SUdfDataBlock* block, SUdfColumn *resultCol) {
         break;
       }
     }
-    if ( j == block->numOfCols) {
+    if (j == block->numOfCols) {
       int32_t luckyNum = 88;
       udfColDataSet(resultCol, i, (char *)&luckyNum, false);
     }
   }
-  //to simulate actual processing delay by udf
+  // to simulate actual processing delay by udf
 #ifdef LINUX
   usleep(1 * 1000);  // usleep takes sleep time in us (1 millionth of a second)
 #endif

source/libs/function/test/udf2.c

-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "taosudf.h"
 
-DLL_EXPORT int32_t udf2_init() {
-  return 0;
-}
+DLL_EXPORT int32_t udf2_init() { return 0; }
 
-DLL_EXPORT int32_t udf2_destroy() {
-  return 0;
-}
+DLL_EXPORT int32_t udf2_destroy() { return 0; }
 
-DLL_EXPORT int32_t udf2_start(SUdfInterBuf *buf) {
+DLL_EXPORT int32_t udf2_start(SUdfInterBuf* buf) {
   *(int64_t*)(buf->buf) = 0;
   buf->bufLen = sizeof(double);
   buf->numOfResult = 0;
   return 0;
 }
 
-DLL_EXPORT int32_t udf2(SUdfDataBlock* block, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf) {
+DLL_EXPORT int32_t udf2(SUdfDataBlock* block, SUdfInterBuf* interBuf, SUdfInterBuf* newInterBuf) {
   double sumSquares = *(double*)interBuf->buf;
   int8_t numNotNull = 0;
   for (int32_t i = 0; i < block->numOfCols; ++i) {
     SUdfColumn* col = block->udfCols[i];
-    if (!(col->colMeta.type == TSDB_DATA_TYPE_INT || 
-          col->colMeta.type == TSDB_DATA_TYPE_DOUBLE)) {
+    if (!(col->colMeta.type == TSDB_DATA_TYPE_INT || col->colMeta.type == TSDB_DATA_TYPE_DOUBLE)) {
       return TSDB_CODE_UDF_INVALID_INPUT;
     }
   }
@@ -67,7 +62,7 @@ DLL_EXPORT int32_t udf2(SUdfDataBlock* block, SUdfInterBuf *interBuf, SUdfInterB
   return 0;
 }
 
-DLL_EXPORT int32_t udf2_finish(SUdfInterBuf* buf, SUdfInterBuf *resultData) {
+DLL_EXPORT int32_t udf2_finish(SUdfInterBuf* buf, SUdfInterBuf* resultData) {
   if (buf->numOfResult == 0) {
     resultData->numOfResult = 0;
     return 0;

tools/scripts/codeFormat.sh

@@ -16,7 +16,7 @@ FORMAT_DIR_LIST=(
     "${PRJ_ROOT_DIR}/source/libs/catalog"
     "${PRJ_ROOT_DIR}/source/libs/command"
     "${PRJ_ROOT_DIR}/source/libs/executor"
-    # "${PRJ_ROOT_DIR}/source/libs/function"
+    "${PRJ_ROOT_DIR}/source/libs/function"
     "${PRJ_ROOT_DIR}/source/libs/index"
     "${PRJ_ROOT_DIR}/source/libs/monitor"
     "${PRJ_ROOT_DIR}/source/libs/nodes"
@@ -49,3 +49,5 @@ for d in ${FORMAT_DIR_LIST[@]}; do
 done
 
 cd ${ORIGIN_DIR}
+
+# find source/libs/ -path ./source/libs/qworker -prune -o -regex '.*\.\(cpp\|hpp\|c\|h\)' -print