diff --git a/src/client/inc/tschemautil.h b/src/client/inc/tschemautil.h
index 7c41164a046165c785d3d4e0e0a8979854e4b6f2..c881a7a7634c774eee91c64fb41582a1a11683ca 100644
--- a/src/client/inc/tschemautil.h
+++ b/src/client/inc/tschemautil.h
@@ -26,7 +26,7 @@ extern "C" {
 
 #define VALIDNUMOFCOLS(x) ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)
 
-//struct SSchema;
+#define VALIDNUMOFTAGS(x)  ((x) >= 0 && (x) <= TSDB_MAX_TAGS)
 
 /**
  * get the number of tags of this table
@@ -91,7 +91,7 @@ SSchema* tscGetColumnSchemaById(STableMeta* pTableMeta, int16_t colId);
  * @param numOfCols
  * @return
  */
-bool isValidSchema(struct SSchema *pSchema, int32_t numOfCols);
+bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
 /**
  * get the schema for the "tbname" column. it is a built column
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index e833b8d03d2f8051374ad48ea7b4df473a9cb9de..fdda2139e78015910dda2009b3cefed2a13a5bb0 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -388,7 +388,7 @@ void tscAsyncResultOnError(SSqlObj *pSql) {
   }
 
   assert(pSql->res.code != TSDB_CODE_SUCCESS);
-  tscError("%p add into queued async res, code:%s", pSql, tstrerror(pSql->res.code));
+  tscError("%p invoke user specified function due to error occured, code:%s", pSql, tstrerror(pSql->res.code));
 
   SSqlRes *pRes = &pSql->res;
   if (pSql->fp == NULL || pSql->fetchFp == NULL){
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 9b97ed3ce01338688adf704087437de245c36ca6..dbb807ad06c6af061c5d966144a71ee552285fd4 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -128,13 +128,15 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
 }
 
 // todo extract the null value check
-
+static bool isNullStr(SStrToken* pToken) {
+  return (pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
+                                       (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0));
+}
 int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload, char *msg, char **str, bool primaryKey,
                              int16_t timePrec) {
   int64_t iv;
-  int32_t numType;
+  int32_t ret;
   char   *endptr = NULL;
-  errno = 0;  // clear the previous existed error information
 
   if (IS_NUMERIC_TYPE(pSchema->type) && pToken->n == 0) {
     return tscInvalidSQLErrMsg(msg, "invalid numeric data", pToken->z);
@@ -142,39 +144,38 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
 
   switch (pSchema->type) {
     case TSDB_DATA_TYPE_BOOL: {  // bool
-      if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
-        if (strncmp(pToken->z, "true", pToken->n) == 0) {
-          *(uint8_t *)payload = TSDB_TRUE;
-        } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
-          *(uint8_t *)payload = TSDB_FALSE;
-        } else if (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0) {
-          *(uint8_t *)payload = TSDB_DATA_BOOL_NULL;
+      if (isNullStr(pToken)) {
+        *((uint8_t *)payload) = TSDB_DATA_BOOL_NULL;
+      } else {
+        if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
+          if (strncmp(pToken->z, "true", pToken->n) == 0) {
+            *(uint8_t *)payload = TSDB_TRUE;
+          } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
+            *(uint8_t *)payload = TSDB_FALSE;
+          } else {
+            return tscSQLSyntaxErrMsg(msg, "invalid bool data", pToken->z);
+          }
+        } else if (pToken->type == TK_INTEGER) {
+          iv = strtoll(pToken->z, NULL, 10);
+          *(uint8_t *)payload = (int8_t)((iv == 0) ? TSDB_FALSE : TSDB_TRUE);
+        } else if (pToken->type == TK_FLOAT) {
+          double dv = strtod(pToken->z, NULL);
+          *(uint8_t *)payload = (int8_t)((dv == 0) ? TSDB_FALSE : TSDB_TRUE);
         } else {
-          return tscSQLSyntaxErrMsg(msg, "invalid bool data", pToken->z);
+          return tscInvalidSQLErrMsg(msg, "invalid bool data", pToken->z);
         }
-      } else if (pToken->type == TK_INTEGER) {
-        iv = strtoll(pToken->z, NULL, 10);
-        *(uint8_t *)payload = (int8_t)((iv == 0) ? TSDB_FALSE : TSDB_TRUE);
-      } else if (pToken->type == TK_FLOAT) {
-        double dv = strtod(pToken->z, NULL);
-        *(uint8_t *)payload = (int8_t)((dv == 0) ? TSDB_FALSE : TSDB_TRUE);
-      } else if (pToken->type == TK_NULL) {
-        *(uint8_t *)payload = TSDB_DATA_BOOL_NULL;
-      } else {
-        return tscInvalidSQLErrMsg(msg, "invalid bool data", pToken->z);
       }
       break;
     }
 
     case TSDB_DATA_TYPE_TINYINT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                      (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((uint8_t *)payload) = TSDB_DATA_TINYINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid tinyint data", pToken->z);
-        } else if (errno == ERANGE || !IS_VALID_TINYINT(iv)) {
+        } else if (!IS_VALID_TINYINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "data overflow", pToken->z);
         }
 
@@ -184,14 +185,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_UTINYINT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                     (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((uint8_t *)payload) = TSDB_DATA_UTINYINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid unsigned tinyint data", pToken->z);
-        } else if (errno == ERANGE || IS_VALID_UTINYINT(iv)) {
+        } else if (!IS_VALID_UTINYINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "unsigned tinyint data overflow", pToken->z);
         }
 
@@ -201,14 +201,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_SMALLINT:
-      if ((pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                        (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((int16_t *)payload) = TSDB_DATA_SMALLINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid smallint data", pToken->z);
-        } else if (errno == ERANGE || iv > INT16_MAX || iv <= INT16_MIN) {
+        } else if (!IS_VALID_SMALLINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "smallint data overflow", pToken->z);
         }
 
@@ -218,14 +217,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_USMALLINT:
-      if ((pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                        (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((uint16_t *)payload) = TSDB_DATA_USMALLINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid unsigned smallint data", pToken->z);
-        } else if (errno == ERANGE || iv >= UINT16_MAX) {
+        } else if (!IS_VALID_USMALLINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "unsigned smallint data overflow", pToken->z);
         }
 
@@ -235,14 +233,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_INT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                      (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((int32_t *)payload) = TSDB_DATA_INT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid int data", pToken->z);
-        } else if (errno == ERANGE || iv > INT32_MAX || iv <= INT32_MIN) {
+        } else if (!IS_VALID_INT(iv)) {
           return tscInvalidSQLErrMsg(msg, "int data overflow", pToken->z);
         }
 
@@ -252,14 +249,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_UINT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                      (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((uint32_t *)payload) = TSDB_DATA_UINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid unsigned int data", pToken->z);
-        } else if (errno == ERANGE || iv >= UINT32_MAX) {
+        } else if (!IS_VALID_UINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "unsigned int data overflow", pToken->z);
         }
 
@@ -269,14 +265,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_BIGINT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                     (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((int64_t *)payload) = TSDB_DATA_BIGINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, true);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid bigint data", pToken->z);
-        } else if (errno == ERANGE || !IS_VALID_BIGINT(iv)) {
+        } else if (!IS_VALID_BIGINT(iv)) {
           return tscInvalidSQLErrMsg(msg, "bigint data overflow", pToken->z);
         }
 
@@ -285,14 +280,13 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_UBIGINT:
-      if (pToken->type == TK_NULL || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                      (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0))) {
+      if (isNullStr(pToken)) {
         *((uint64_t *)payload) = TSDB_DATA_UBIGINT_NULL;
       } else {
-        numType = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
-        if (TK_ILLEGAL == numType) {
+        ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false);
+        if (ret != TSDB_CODE_SUCCESS) {
           return tscInvalidSQLErrMsg(msg, "invalid unsigned bigint data", pToken->z);
-        } else if (errno == ERANGE || !IS_VALID_UBIGINT((uint64_t)iv)) {
+        } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
           return tscInvalidSQLErrMsg(msg, "unsigned bigint data overflow", pToken->z);
         }
 
@@ -301,10 +295,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_FLOAT:
-      if (pToken->type == TK_NULL) {
-        *((int32_t *)payload) = TSDB_DATA_FLOAT_NULL;
-      } else if ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                 (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0)) {
+      if (isNullStr(pToken)) {
         *((int32_t *)payload) = TSDB_DATA_FLOAT_NULL;
       } else {
         double dv;
@@ -321,10 +312,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload,
       break;
 
     case TSDB_DATA_TYPE_DOUBLE:
-      if (pToken->type == TK_NULL) {
-        *((int64_t *)payload) = TSDB_DATA_DOUBLE_NULL;
-      } else if ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                 (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0)) {
+      if (isNullStr(pToken)) {
         *((int64_t *)payload) = TSDB_DATA_DOUBLE_NULL;
       } else {
         double dv;
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 4d87241ef5bea5bb7eefaa435ebd627f35add9ff..981b354c8a964272058397e8e4b019ca49fe7ac3 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -678,7 +678,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
       return TSDB_CODE_SUCCESS;
 
     case TSDB_DATA_TYPE_NCHAR: {
-      size_t output = 0;
+      int32_t output = 0;
       if (!taosMbsToUcs4(bind->buffer, *bind->length, varDataVal(data + param->offset), param->bytes - VARSTR_HEADER_SIZE, &output)) {
         return TSDB_CODE_TSC_INVALID_VALUE;
       }
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 22752fc7de6785eddc32b9098e03e185313169a9..a08482f57068496f11ab28c81aee24ace67999df 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1012,7 +1012,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
       return false;
     }
 
-    if (p->type < TSDB_DATA_TYPE_BOOL || p->type > TSDB_DATA_TYPE_NCHAR) {
+    if (!isValidDataType(p->type)) {
       invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
       return false;
     }
diff --git a/src/client/src/tscSchemaUtil.c b/src/client/src/tscSchemaUtil.c
index b9d38e3ea76d9ba15c7fe5eb5906e205423aade5..123f0fd2227d56f2b67dd7040afe8dea22c681ba 100644
--- a/src/client/src/tscSchemaUtil.c
+++ b/src/client/src/tscSchemaUtil.c
@@ -66,30 +66,24 @@ STableComInfo tscGetTableInfo(const STableMeta* pTableMeta) {
   return pTableMeta->tableInfo;
 }
 
-bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols) {
-  if (!VALIDNUMOFCOLS(numOfCols)) {
-    return false;
-  }
-
-  /* first column must be the timestamp, which is a primary key */
-  if (pSchema[0].type != TSDB_DATA_TYPE_TIMESTAMP) {
-    return false;
-  }
-
-  /* type is valid, length is valid */
+static bool doValidateSchema(SSchema* pSchema, int32_t numOfCols, int32_t maxLen) {
   int32_t rowLen = 0;
 
   for (int32_t i = 0; i < numOfCols; ++i) {
     // 1. valid types
-    if (pSchema[i].type > TSDB_DATA_TYPE_TIMESTAMP || pSchema[i].type < TSDB_DATA_TYPE_BOOL) {
+    if (!isValidDataType(pSchema[i].type)) {
       return false;
     }
 
     // 2. valid length for each type
-    if (pSchema[i].type == TSDB_DATA_TYPE_TIMESTAMP) {
+    if (pSchema[i].type == TSDB_DATA_TYPE_BINARY) {
       if (pSchema[i].bytes > TSDB_MAX_BINARY_LEN) {
         return false;
       }
+    } else if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
+      if (pSchema[i].bytes > TSDB_MAX_NCHAR_LEN) {
+        return false;
+      }
     } else {
       if (pSchema[i].bytes != tDataTypeDesc[pSchema[i].type].nSize) {
         return false;
@@ -106,8 +100,32 @@ bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols) {
     rowLen += pSchema[i].bytes;
   }
 
-  // valid total length
-  return (rowLen <= TSDB_MAX_BYTES_PER_ROW);
+  return rowLen <= maxLen;
+}
+
+bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags) {
+  if (!VALIDNUMOFCOLS(numOfCols)) {
+    return false;
+  }
+
+  if (!VALIDNUMOFTAGS(numOfTags)) {
+    return false;
+  }
+
+  /* first column must be the timestamp, which is a primary key */
+  if (pSchema[0].type != TSDB_DATA_TYPE_TIMESTAMP) {
+    return false;
+  }
+
+  if (!doValidateSchema(pSchema, numOfCols, TSDB_MAX_BYTES_PER_ROW)) {
+    return false;
+  }
+
+  if (!doValidateSchema(&pSchema[numOfCols], numOfTags, TSDB_MAX_TAGS_LEN)) {
+    return false;
+  }
+
+  return true;
 }
 
 SSchema* tscGetTableColumnSchema(const STableMeta* pTableMeta, int32_t colIndex) {
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 81bb87a7dba9bbab848913451b88e882a9104407..cc2621958f0713967b3a8aa62328c0212a062a5a 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -942,7 +942,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       SSchema *pColSchema = &pSchema[pCol->colIndex.columnIndex];
 
       if ((pCol->colIndex.columnIndex >= numOfTagColumns || pCol->colIndex.columnIndex < -1) ||
-          (pColSchema->type < TSDB_DATA_TYPE_BOOL || pColSchema->type > TSDB_DATA_TYPE_NCHAR)) {
+          (!isValidDataType(pColSchema->type))) {
         tscError("%p tid:%d uid:%" PRIu64 " id:%s, tag index out of range, totalCols:%d, numOfTags:%d, index:%d, column name:%s",
                  pSql, pTableMeta->id.tid, pTableMeta->id.uid, pTableMetaInfo->name, total, numOfTagColumns,
                  pCol->colIndex.columnIndex, pColSchema->name);
diff --git a/src/common/inc/tvariant.h b/src/common/inc/tvariant.h
index dfcc940418a4b9e7e887478fc9acd0b05c0f0501..f8f715c6cae1990b3c208c50bd75a1355795671e 100644
--- a/src/common/inc/tvariant.h
+++ b/src/common/inc/tvariant.h
@@ -37,9 +37,9 @@ typedef struct tVariant {
   };
 } tVariant;
 
-void tVariantCreate(tVariant *pVar, SStrToken *token);
+bool tVariantIsValid(tVariant *pVar);
 
-void tVariantCreateFromString(tVariant *pVar, char *pz, uint32_t len, uint32_t type);
+void tVariantCreate(tVariant *pVar, SStrToken *token);
 
 void tVariantCreateFromBinary(tVariant *pVar, const char *pz, size_t len, uint32_t type);
 
diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 72dfa5c2bda09dc82c5b12f20f832e5c3b6b4c04..e558dc188a440f935955084e2d0a5c25d2735936 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -603,19 +603,21 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf
 
 int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bool issigned) {
   errno = 0;
+  int32_t ret = 0;
 
   char* endPtr = NULL;
   if (type == TK_FLOAT) {
     double v = strtod(z, &endPtr);
     if ((errno == ERANGE && v == HUGE_VALF) || isinf(v) || isnan(v)) {
-      errno = ERANGE;
+      ret = -1;
     } else if ((issigned && (v < INT64_MIN || v > INT64_MAX)) || ((!issigned) && (v < 0 || v > UINT64_MAX))) {
-      errno = ERANGE;
+      ret = -1;
     } else {
       *value = round(v);
     }
 
-    return type;
+    errno = 0;
+    return ret;
   }
 
   int32_t radix = 10;
@@ -626,12 +628,13 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
   }
 
   // the string may be overflow according to errno
-  *value = strtoll(z, &endPtr, radix);
+  *value = issigned? strtoll(z, &endPtr, radix):strtoul(z, &endPtr, radix);
 
   // not a valid integer number, return error
-  if (endPtr - z != n) {
-    return TK_ILLEGAL;
+  if (endPtr - z != n || errno == ERANGE) {
+    ret = -1;
   }
 
-  return type;
+  errno = 0;
+  return ret;
 }
diff --git a/src/common/src/tvariant.c b/src/common/src/tvariant.c
index 77b3c9bf2bf71c5df945b5f220fc1be3c8e03c1e..87981f22d37d21609b4ccf04e2f97461495d0ccc 100644
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -23,35 +23,46 @@
 #include "tutil.h"
 #include "ttype.h"
 
-// todo support scientific expression number and oct number
-void tVariantCreate(tVariant *pVar, SStrToken *token) { tVariantCreateFromString(pVar, token->z, token->n, token->type); }
+void tVariantCreate(tVariant *pVar, SStrToken *token) {
+  int32_t ret = 0;
+  int32_t type = token->type;
 
-void tVariantCreateFromString(tVariant *pVar, char *pz, uint32_t len, uint32_t type) {
   memset(pVar, 0, sizeof(tVariant));
-  
-  switch (type) {
+
+  switch (token->type) {
     case TSDB_DATA_TYPE_BOOL: {
-      int32_t k = strncasecmp(pz, "true", 4);
+      int32_t k = strncasecmp(token->z, "true", 4);
       if (k == 0) {
         pVar->i64 = TSDB_TRUE;
       } else {
-        assert(strncasecmp(pz, "false", 5) == 0);
+        assert(strncasecmp(token->z, "false", 5) == 0);
         pVar->i64 = TSDB_FALSE;
       }
+
       break;
     }
+
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_SMALLINT:
     case TSDB_DATA_TYPE_BIGINT:
-    case TSDB_DATA_TYPE_INT:
-      pVar->i64 = strtoll(pz, NULL, 10);
+    case TSDB_DATA_TYPE_INT:{
+      ret = tStrToInteger(token->z, token->type, token->n, &pVar->i64, true);
+      if (ret != 0) {
+        pVar->nType = -1;   // -1 means error type
+        return;
+      }
+
       break;
+    }
+
     case TSDB_DATA_TYPE_DOUBLE:
-    case TSDB_DATA_TYPE_FLOAT:
-      pVar->dKey = strtod(pz, NULL);
+    case TSDB_DATA_TYPE_FLOAT: {
+      pVar->dKey = strtod(token->z, NULL);
       break;
+    }
+
     case TSDB_DATA_TYPE_BINARY: {
-      pVar->pz = strndup(pz, len);
+      pVar->pz = strndup(token->z, token->n);
       pVar->nLen = strdequote(pVar->pz);
       break;
     }
@@ -158,6 +169,11 @@ void tVariantDestroy(tVariant *pVar) {
   }
 }
 
+bool tVariantIsValid(tVariant *pVar) {
+  assert(pVar != NULL);
+  return isValidDataType(pVar->nType);
+}
+
 void tVariantAssign(tVariant *pDst, const tVariant *pSrc) {
   if (pSrc == NULL || pDst == NULL) return;
   
@@ -406,7 +422,7 @@ static FORCE_INLINE int32_t convertToDouble(char *pStr, int32_t len, double *val
   return 0;
 }
 
-static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result, int32_t type, bool releaseVariantPtr) {
+static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result, int32_t type, bool issigned, bool releaseVariantPtr) {
   if (pVariant->nType == TSDB_DATA_TYPE_NULL) {
     setNull((char *)result, type, tDataTypeDesc[type].nSize);
     return 0;
@@ -440,8 +456,8 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
     }
 
     int64_t res = 0;
-    int32_t t = tStrToInteger(token.z, token.type, token.n, &res, true);
-    if (TK_ILLEGAL == t || errno == ERANGE) {
+    int32_t t = tStrToInteger(token.z, token.type, token.n, &res, issigned);
+    if (t != 0) {
       return -1;
     }
 
@@ -570,37 +586,69 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
     }
     
     case TSDB_DATA_TYPE_TINYINT: {
-      if (convertToInteger(pVariant, &result, type, false) < 0) {
+      if (convertToInteger(pVariant, &result, type, true, false) < 0) {
+        return -1;
+      }
+      *((int8_t *)payload) = (int8_t) result;
+      break;
+    }
+
+    case TSDB_DATA_TYPE_UTINYINT: {
+      if (convertToInteger(pVariant, &result, type, false, false) < 0) {
         return -1;
       }
-      *((int8_t *)payload) = (int8_t)result;
+      *((uint8_t *)payload) = (uint8_t) result;
       break;
     }
     
     case TSDB_DATA_TYPE_SMALLINT: {
-      if (convertToInteger(pVariant, &result, type, false) < 0) {
+      if (convertToInteger(pVariant, &result, type, true, false) < 0) {
         return -1;
       }
       *((int16_t *)payload) = (int16_t)result;
       break;
     }
+
+    case TSDB_DATA_TYPE_USMALLINT: {
+      if (convertToInteger(pVariant, &result, type, false, false) < 0) {
+        return -1;
+      }
+      *((uint16_t *)payload) = (uint16_t)result;
+      break;
+    }
     
     case TSDB_DATA_TYPE_INT: {
-      if (convertToInteger(pVariant, &result, type, false) < 0) {
+      if (convertToInteger(pVariant, &result, type, true, false) < 0) {
         return -1;
       }
       *((int32_t *)payload) = (int32_t)result;
       break;
     }
+
+    case TSDB_DATA_TYPE_UINT: {
+      if (convertToInteger(pVariant, &result, type, false, false) < 0) {
+        return -1;
+      }
+      *((uint32_t *)payload) = (uint32_t)result;
+      break;
+    }
     
     case TSDB_DATA_TYPE_BIGINT: {
-      if (convertToInteger(pVariant, &result, type, false) < 0) {
+      if (convertToInteger(pVariant, &result, type, true, false) < 0) {
         return -1;
       }
       *((int64_t *)payload) = (int64_t)result;
       break;
     }
-    
+
+    case TSDB_DATA_TYPE_UBIGINT: {
+      if (convertToInteger(pVariant, &result, type, false, false) < 0) {
+        return -1;
+      }
+      *((uint64_t *)payload) = (uint64_t)result;
+      break;
+    }
+
     case TSDB_DATA_TYPE_FLOAT: {
       if (pVariant->nType == TSDB_DATA_TYPE_BINARY) {
         if (strncasecmp(TSDB_DATA_NULL_STR_L, pVariant->pz, pVariant->nLen) == 0 &&
@@ -609,20 +657,19 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
           return 0;
         } else {
           double  value = -1;
-          int32_t ret;
-          ret = convertToDouble(pVariant->pz, pVariant->nLen, &value);
+          int32_t ret = convertToDouble(pVariant->pz, pVariant->nLen, &value);
           if ((errno == ERANGE && (float)value == -1) || (ret != 0)) {
             return -1;
           }
 
           SET_FLOAT_VAL(payload, value);
         }
-      } else if (pVariant->nType >= TSDB_DATA_TYPE_BOOL && pVariant->nType <= TSDB_DATA_TYPE_BIGINT) {
+      } else if (pVariant->nType == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(pVariant->nType) || IS_UNSIGNED_NUMERIC_TYPE(pVariant->nType)) {
         SET_FLOAT_VAL(payload, pVariant->i64);
-      } else if (pVariant->nType == TSDB_DATA_TYPE_DOUBLE || pVariant->nType == TSDB_DATA_TYPE_FLOAT) {
+      } else if (IS_FLOAT_TYPE(pVariant->nType)) {
         SET_FLOAT_VAL(payload, pVariant->dKey);
       } else if (pVariant->nType == TSDB_DATA_TYPE_NULL) {
-        *((int32_t *)payload) = TSDB_DATA_FLOAT_NULL;
+        *((uint32_t *)payload) = TSDB_DATA_FLOAT_NULL;
         return 0;
       }
 
@@ -648,9 +695,9 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
 
           SET_DOUBLE_VAL(payload, value);
         }
-      } else if (pVariant->nType >= TSDB_DATA_TYPE_BOOL && pVariant->nType <= TSDB_DATA_TYPE_BIGINT) {
+      } else if (pVariant->nType == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(pVariant->nType) || IS_UNSIGNED_NUMERIC_TYPE(pVariant->nType)) {
         SET_DOUBLE_VAL(payload, pVariant->i64);
-      } else if (pVariant->nType == TSDB_DATA_TYPE_DOUBLE || pVariant->nType == TSDB_DATA_TYPE_FLOAT) {
+      } else if (IS_FLOAT_TYPE(pVariant->nType)) {
         SET_DOUBLE_VAL(payload, pVariant->dKey);
       } else if (pVariant->nType == TSDB_DATA_TYPE_NULL) {
         *((int64_t *)payload) = TSDB_DATA_DOUBLE_NULL;
@@ -658,9 +705,10 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
       }
 
       double dv = GET_DOUBLE_VAL(payload);
-      if (isinf(dv) || isnan(dv) || dv > DBL_MAX || dv < -DBL_MAX) {
+      if (errno == ERANGE || isinf(dv) || isnan(dv)) {
         return -1;
       }
+
       break;
     }
     
@@ -766,7 +814,7 @@ int32_t tVariantTypeSetType(tVariant *pVariant, char type) {
     case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_SMALLINT: {
-      convertToInteger(pVariant, &(pVariant->i64), type, true);
+      convertToInteger(pVariant, &(pVariant->i64), type, true, true);
       pVariant->nType = TSDB_DATA_TYPE_BIGINT;
       break;
     }
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index ed88bc15ee240ae7f87eeb2c5f0f665f21128e75..b6cf1b5f1f56cc4eaae652907fc14b6cf8965b9e 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -180,6 +180,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_NOT_EXIST,            0, 0x036A, "Tag does n
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_ALREAY_EXIST,       0, 0x036B, "Field already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST,          0, 0x036C, "Field does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STABLE_NAME,      0, 0x036D, "Super table does not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG, 0, 0x036E, "Invalid create table message")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED,          0, 0x0380, "Database not specified or available")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST,         0, 0x0381, "Database already exists")
diff --git a/src/inc/ttype.h b/src/inc/ttype.h
index aa8e1e8616ee091c13bfde9f34f1dade41c21caf..1849139df12c2970ef554a722411fec1131262aa 100644
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -16,6 +16,7 @@ extern "C" {
         break;                                       \
       case TSDB_DATA_TYPE_UTINYINT:                  \
         (_v) = (_finalType)GET_UINT8_VAL(_data);     \
+        break;                                       \
       case TSDB_DATA_TYPE_SMALLINT:                  \
         (_v) = (_finalType)GET_INT16_VAL(_data);     \
         break;                                       \
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 5a02857c851a59e9979a5a96a0dac7f1e1a5b0af..4e9c64057567e54e73af31c0662c698fbcd71e59 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1000,7 +1000,7 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
 
   SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
   if (pCreate1->numOfTables == 0) {
-    // todo return to error message
+    return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
   }
 
   SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
@@ -1029,16 +1029,39 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
     mError("msg:%p, app:%p table:%s, failed to create, no schema input", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
     return TSDB_CODE_MND_INVALID_TABLE_NAME;
   }
+
   memcpy(pStable->schema, pCreate->schema, numOfCols * sizeof(SSchema));
 
+  if (pStable->numOfColumns > TSDB_MAX_COLUMNS || pStable->numOfTags > TSDB_MAX_TAGS) {
+    mError("msg:%p, app:%p table:%s, failed to create, too many columns", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    return TSDB_CODE_MND_INVALID_TABLE_NAME;
+  }
+
   pStable->nextColId = 0;
+
+  // TODO extract method to valid the schema
+  int32_t schemaLen = 0;
+  int32_t tagLen = 0;
   for (int32_t col = 0; col < numOfCols; col++) {
     SSchema *tschema = pStable->schema;
     tschema[col].colId = pStable->nextColId++;
     tschema[col].bytes = htons(tschema[col].bytes);
-    
-    // todo 1. check the length of each column; 2. check the total length of all columns
-    assert(tschema[col].type >= TSDB_DATA_TYPE_BOOL && tschema[col].type <= TSDB_DATA_TYPE_NCHAR);
+
+    if (col < pStable->numOfTables) {
+      schemaLen += tschema[col].bytes;
+    } else {
+      tagLen += tschema[col].bytes;
+    }
+
+    if (!isValidDataType(tschema[col].type)) {
+      mError("msg:%p, app:%p table:%s, failed to create, invalid data type in schema", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+      return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
+    }
+  }
+
+  if (schemaLen > (TSDB_MAX_BYTES_PER_ROW || tagLen > TSDB_MAX_TAGS_LEN)) {
+    mError("msg:%p, app:%p table:%s, failed to create, schema is too long", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
   }
 
   pMsg->pTable = (STableObj *)pStable;
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index c3d60e21dc59ccbbf9940c4a155ee29d57d2f8a2..79d98432c87ea7f06187d39f258fcb00d73f30a6 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -30,7 +30,7 @@
 #include "tsqlfunction.h"
 
 struct SColumnFilterElem;
-typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, char* val1, char* val2);
+typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, const char* val1, const char* val2, int16_t type);
 typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
 
 typedef struct SResultRowPool {
diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index 4620e3d61e5e57c1072a7c3b3f6ca5face080d37..27bf7f2d96983567fb0f041545a09c1cb4fe24d8 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -60,11 +60,10 @@ static FORCE_INLINE char *getPosInResultPage(SQueryRuntimeEnv *pRuntimeEnv, int3
       pQuery->pExpr1[columnIndex].bytes * realRowId;
 }
 
-bool isNull_filter(SColumnFilterElem *pFilter, char* minval, char* maxval);
-bool notNull_filter(SColumnFilterElem *pFilter, char* minval, char* maxval);
+bool isNullOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type);
+bool notNullOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type);
 
-__filter_func_t *getRangeFilterFuncArray(int32_t type);
-__filter_func_t *getValueFilterFuncArray(int32_t type);
+__filter_func_t getFilterOperator(int32_t lowerOptr, int32_t upperOptr);
 
 SResultRowPool* initResultRowPool(size_t size);
 SResultRow* getNewResultRow(SResultRowPool* p);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 04885efbfa8012057e4e1a60c8b4e260b1aa61eb..261ba86bdae44eaf4c6ecb2e678ca1b6af99d33c 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -212,22 +212,22 @@ bool doFilterData(SQuery *pQuery, int32_t elemPos) {
 
       bool isnull = isNull(pElem, pFilterInfo->info.type);
       if (isnull) {
-        if (pFilterElem->fp == isNull_filter) {
+        if (pFilterElem->fp == isNullOperator) {
           qualified = true;
           break;
         } else {
           continue;
         }
       } else {
-        if (pFilterElem->fp == notNull_filter) {
+        if (pFilterElem->fp == notNullOperator) {
           qualified = true;
           break;
-        } else if (pFilterElem->fp == isNull_filter) {
+        } else if (pFilterElem->fp == isNullOperator) {
           continue;
         }
       }
 
-      if (pFilterElem->fp(pFilterElem, pElem, pElem)) {
+      if (pFilterElem->fp(pFilterElem, pElem, pElem, pFilterInfo->info.type)) {
         qualified = true;
         break;
       }
@@ -759,7 +759,7 @@ static void doUpdateResultRowIndex(SResultRowInfo*pResultRowInfo, TSKEY lastKey,
     }
 
     if (i == pResultRowInfo->size - 1) {
-      pResultRowInfo->curIndex = i;  
+      pResultRowInfo->curIndex = i;
     } else {
       pResultRowInfo->curIndex = i + 1;  // current not closed result object
     }
@@ -2478,7 +2478,7 @@ static bool needToLoadDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis *pDat
       // if isNULL query exists, load the null data column
       for (int32_t j = 0; j < pFilterInfo->numOfFilters; ++j) {
         SColumnFilterElem *pFilterElem = &pFilterInfo->pFilters[j];
-        if (pFilterElem->fp == isNull_filter) {
+        if (pFilterElem->fp == isNullOperator) {
           return true;
         }
       }
@@ -2493,13 +2493,13 @@ static bool needToLoadDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis *pDat
       float maxval = (float)(*(double *)(&pDataBlockst->max));
 
       for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
-        if (pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&minval, (char *)&maxval)) {
+        if (pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&minval, (char *)&maxval, TSDB_DATA_TYPE_FLOAT)) {
           return true;
         }
       }
     } else {
       for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
-        if (pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max)) {
+        if (pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max, pFilterInfo->info.type)) {
           return true;
         }
       }
@@ -6115,7 +6115,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
   if (pQueryMsg->secondStageOutput) {
     pExprMsg = (SSqlFuncMsg *)pMsg;
     *pSecStageExpr = calloc(pQueryMsg->secondStageOutput, POINTER_BYTES);
-    
+
     for (int32_t i = 0; i < pQueryMsg->secondStageOutput; ++i) {
       (*pSecStageExpr)[i] = pExprMsg;
 
@@ -6449,55 +6449,18 @@ static int32_t createFilterInfo(void *pQInfo, SQuery *pQuery) {
 
         int32_t lower = pSingleColFilter->filterInfo.lowerRelOptr;
         int32_t upper = pSingleColFilter->filterInfo.upperRelOptr;
-
         if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) {
           qError("QInfo:%p invalid filter info", pQInfo);
           return TSDB_CODE_QRY_INVALID_MSG;
         }
 
-        int16_t type  = pQuery->colList[i].type;
-        int16_t bytes = pQuery->colList[i].bytes;
-
-        // todo refactor
-        __filter_func_t *rangeFilterArray = getRangeFilterFuncArray(type);
-        __filter_func_t *filterArray = getValueFilterFuncArray(type);
-
-        if (rangeFilterArray == NULL && filterArray == NULL) {
-          qError("QInfo:%p failed to get filter function, invalid data type:%d", pQInfo, type);
+        pSingleColFilter->fp = getFilterOperator(lower, upper);
+        if (pSingleColFilter->fp == NULL) {
+          qError("QInfo:%p invalid filter info", pQInfo);
           return TSDB_CODE_QRY_INVALID_MSG;
         }
 
-        if ((lower == TSDB_RELATION_GREATER_EQUAL || lower == TSDB_RELATION_GREATER) &&
-            (upper == TSDB_RELATION_LESS_EQUAL || upper == TSDB_RELATION_LESS)) {
-          assert(rangeFilterArray != NULL);
-          if (lower == TSDB_RELATION_GREATER_EQUAL) {
-            if (upper == TSDB_RELATION_LESS_EQUAL) {
-              pSingleColFilter->fp = rangeFilterArray[4];
-            } else {
-              pSingleColFilter->fp = rangeFilterArray[2];
-            }
-          } else {
-            if (upper == TSDB_RELATION_LESS_EQUAL) {
-              pSingleColFilter->fp = rangeFilterArray[3];
-            } else {
-              pSingleColFilter->fp = rangeFilterArray[1];
-            }
-          }
-        } else {  // set callback filter function
-          assert(filterArray != NULL);
-          if (lower != TSDB_RELATION_INVALID) {
-            pSingleColFilter->fp = filterArray[lower];
-
-            if (upper != TSDB_RELATION_INVALID) {
-              qError("pQInfo:%p failed to get filter function, invalid filter condition: %d", pQInfo, type);
-              return TSDB_CODE_QRY_INVALID_MSG;
-            }
-          } else {
-            pSingleColFilter->fp = filterArray[upper];
-          }
-        }
-        assert(pSingleColFilter->fp != NULL);
-        pSingleColFilter->bytes = bytes;
+        pSingleColFilter->bytes = pQuery->colList[i].bytes;
       }
 
       j++;
@@ -6800,7 +6763,7 @@ static int32_t initQInfo(SQueryTableMsg *pQueryMsg, void *tsdb, int32_t vgId, SQ
 
     UNUSED(ret);
   }
-  
+
   pQuery->precision = tsdbGetCfg(tsdb)->precision;
 
   if ((QUERY_IS_ASC_QUERY(pQuery) && (pQuery->window.skey > pQuery->window.ekey)) ||
diff --git a/src/query/src/qFilterfunc.c b/src/query/src/qFilterfunc.c
index 2a40533e90218170a465a4f439477e102123157f..eb602c4372c0d034fe2f2ffd0441a2b099215750 100644
--- a/src/query/src/qFilterfunc.c
+++ b/src/query/src/qFilterfunc.c
@@ -19,212 +19,174 @@
 #include "qExecutor.h"
 #include "taosmsg.h"
 #include "tcompare.h"
-#include "tsqlfunction.h"
+#include "ttype.h"
 
-#define FLT_EQUAL(_x, _y)        (fabs((_x) - (_y)) <= (4 * FLT_EPSILON))
+#define FLT_COMPAR_TOL_FACTOR    4
+#define FLT_EQUAL(_x, _y)        (fabs((_x) - (_y)) <= (FLT_COMPAR_TOL_FACTOR * FLT_EPSILON))
 #define FLT_GREATER(_x, _y)      (!FLT_EQUAL((_x), (_y)) && ((_x) > (_y)))
 #define FLT_LESS(_x, _y)         (!FLT_EQUAL((_x), (_y)) && ((_x) < (_y)))
 #define FLT_GREATEREQUAL(_x, _y) (FLT_EQUAL((_x), (_y)) || ((_x) > (_y)))
 #define FLT_LESSEQUAL(_x, _y)    (FLT_EQUAL((_x), (_y)) || ((_x) < (_y)))
 
-bool less_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval < pFilter->filterInfo.upperBndi);
-}
-
-bool less_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval < pFilter->filterInfo.upperBndi);
-}
-
-bool less_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval < pFilter->filterInfo.upperBndi);
-}
-
-bool less_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval < pFilter->filterInfo.upperBndi);
-}
-
-bool less_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_LESS(*(float*)minval, pFilter->filterInfo.upperBndd);
-}
-
-bool less_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return *(double *)minval < pFilter->filterInfo.upperBndd;
-}
-
-//////////////////////////////////////////////////////////////////
-bool larger_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-bool larger_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-bool larger_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-bool larger_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-bool larger_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_GREATER(*(float*)maxval, pFilter->filterInfo.lowerBndd);
-}
-
-bool larger_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(double *)maxval > pFilter->filterInfo.lowerBndd);
-}
-/////////////////////////////////////////////////////////////////////
-
-bool lessEqual_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval <= pFilter->filterInfo.upperBndi);
-}
-
-bool lessEqual_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval <= pFilter->filterInfo.upperBndi);
-}
-
-bool lessEqual_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval <= pFilter->filterInfo.upperBndi);
-}
-
-bool lessEqual_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval <= pFilter->filterInfo.upperBndi);
-}
-
-bool lessEqual_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_LESSEQUAL(*(float*)minval, pFilter->filterInfo.upperBndd);
-}
-
-bool lessEqual_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if ((fabs(*(double*)minval) - pFilter->filterInfo.upperBndd) <= 2 * DBL_EPSILON) {
-    return true;
-  }
-
-  return (*(double *)minval <= pFilter->filterInfo.upperBndd);
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool largeEqual_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool largeEqual_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool largeEqual_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool largeEqual_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool largeEqual_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_GREATEREQUAL(*(float*)maxval, pFilter->filterInfo.lowerBndd);
-}
-
-bool largeEqual_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (fabs(*(double *)maxval - pFilter->filterInfo.lowerBndd) <= 2 * DBL_EPSILON) {
-    return true;
-  }
-
-  return (*(double *)maxval - pFilter->filterInfo.lowerBndd > (2 * DBL_EPSILON));
-}
-
-////////////////////////////////////////////////////////////////////////
-
-bool equal_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int8_t *)minval == *(int8_t *)maxval) {
-    return (*(int8_t *)minval == pFilter->filterInfo.lowerBndi);
-  } else { /* range filter */
-    assert(*(int8_t *)minval < *(int8_t *)maxval);
-
-    return *(int8_t *)minval <= pFilter->filterInfo.lowerBndi && *(int8_t *)maxval >= pFilter->filterInfo.lowerBndi;
-  }
-}
+bool lessOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) {
+  SColumnFilterInfo* pFilterInfo = &pFilter->filterInfo;
 
-bool equal_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int16_t *)minval == *(int16_t *)maxval) {
-    return (*(int16_t *)minval == pFilter->filterInfo.lowerBndi);
-  } else { /* range filter */
-    assert(*(int16_t *)minval < *(int16_t *)maxval);
-
-    return *(int16_t *)minval <= pFilter->filterInfo.lowerBndi && *(int16_t *)maxval >= pFilter->filterInfo.lowerBndi;
+  switch(type) {
+    case TSDB_DATA_TYPE_TINYINT: return (*(int8_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UTINYINT: return (*(uint8_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_SMALLINT: return (*(int16_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_USMALLINT: return (*(uint16_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_INT: return (*(int32_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UINT: return (*(uint32_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT: return (*(int64_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UBIGINT: return (*(uint64_t *)minval < pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_FLOAT: return FLT_LESS(*(float*)minval, pFilter->filterInfo.upperBndd);
+    case TSDB_DATA_TYPE_DOUBLE: return (*(double *)minval < pFilterInfo->upperBndd);
+    default:
+      return false;
   }
 }
 
-bool equal_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int32_t *)minval == *(int32_t *)maxval) {
-    return (*(int32_t *)minval == pFilter->filterInfo.lowerBndi);
-  } else { /* range filter */
-    assert(*(int32_t *)minval < *(int32_t *)maxval);
-
-    return *(int32_t *)minval <= pFilter->filterInfo.lowerBndi && *(int32_t *)maxval >= pFilter->filterInfo.lowerBndi;
+bool greaterOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT: return (*(int8_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UTINYINT: return (*(uint8_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_SMALLINT: return (*(int16_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_USMALLINT: return (*(uint16_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_INT: return (*(int32_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UINT: return (*(uint32_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT: return (*(int64_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UBIGINT: return (*(uint64_t *)maxval > pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_FLOAT: return FLT_GREATER(*(float *)maxval, pFilterInfo->lowerBndd);
+    case TSDB_DATA_TYPE_DOUBLE: return (*(double *)maxval > pFilterInfo->lowerBndd);
+    default:
+      return false;
   }
 }
 
-bool equal_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int64_t *)minval == *(int64_t *)maxval) {
-    return (*(int64_t *)minval == pFilter->filterInfo.lowerBndi);
-  } else { /* range filter */
-    assert(*(int64_t *)minval < *(int64_t *)maxval);
-
-    return *(int64_t *)minval <= pFilter->filterInfo.lowerBndi && *(int64_t *)maxval >= pFilter->filterInfo.lowerBndi;
-  }
-}
+bool lessEqualOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) {
+  SColumnFilterInfo* pFilterInfo = &pFilter->filterInfo;
 
-// user specified input filter value and the original saved float value may needs to
-// increase the tolerance to obtain the correct result.
-bool equal_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(float *)minval == *(float *)maxval) {
-    return FLT_EQUAL(*(float*)minval, pFilter->filterInfo.lowerBndd);
-  } else { // range filter
-    assert(*(float *)minval < *(float *)maxval);
-    return *(float *)minval <= pFilter->filterInfo.lowerBndd && *(float *)maxval >= pFilter->filterInfo.lowerBndd;
+  switch(type) {
+    case TSDB_DATA_TYPE_TINYINT: return (*(int8_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UTINYINT: return (*(uint8_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_SMALLINT: return (*(int16_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_USMALLINT: return (*(uint16_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_INT: return (*(int32_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UINT: return (*(uint32_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT: return (*(int64_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_UBIGINT: return (*(uint64_t *)minval <= pFilterInfo->upperBndi);
+    case TSDB_DATA_TYPE_FLOAT: return FLT_LESSEQUAL(*(float*)minval, pFilterInfo->upperBndd);
+    case TSDB_DATA_TYPE_DOUBLE: {
+      if ((fabs(*(double*)minval) - pFilterInfo->upperBndd) <= 2 * DBL_EPSILON) {
+        return true;
+      }
+
+      return (*(double *)minval <= pFilterInfo->upperBndd);
+    }
+    default:
+      return false;
   }
 }
 
-bool equal_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(double *)minval == *(double *)maxval) {
-    return (fabs(*(double *)minval - pFilter->filterInfo.lowerBndd) <= 2 * DBL_EPSILON);
-  } else { // range filter
-    assert(*(double *)minval < *(double *)maxval);
-    return *(double *)minval <= pFilter->filterInfo.lowerBndi && *(double *)maxval >= pFilter->filterInfo.lowerBndi;
+bool greaterEqualOperator(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT: return (*(int8_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UTINYINT: return (*(uint8_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_SMALLINT: return (*(int16_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_USMALLINT: return (*(uint16_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_INT: return (*(int32_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UINT: return (*(uint32_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT: return (*(int64_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_UBIGINT: return (*(uint64_t *)maxval >= pFilterInfo->lowerBndi);
+    case TSDB_DATA_TYPE_FLOAT: return FLT_GREATEREQUAL(*(float*)maxval, pFilterInfo->lowerBndd);
+    case TSDB_DATA_TYPE_DOUBLE: {
+      if (fabs(*(double *)maxval - pFilterInfo->lowerBndd) <= 2 * DBL_EPSILON) {
+        return true;
+      }
+
+      return (*(double *)maxval - pFilterInfo->lowerBndd > (2 * DBL_EPSILON));
+    }
+    default:
+      return false;
   }
 }
 
-bool equal_str(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  // query condition string is greater than the max length of string, not qualified data
-  if (pFilter->filterInfo.len != varDataLen(minval)) {
+////////////////////////////////////////////////////////////////////////
+bool equalOperator(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
+    int64_t minv = -1, maxv = -1;
+    GET_TYPED_DATA(minv, int64_t, type, minval);
+    GET_TYPED_DATA(maxv, int64_t, type, maxval);
+
+    if (minv == maxv) {
+      return minv == pFilterInfo->lowerBndi;
+    } else {
+      assert(minv < maxv);
+      return minv <= pFilterInfo->lowerBndi && pFilterInfo->lowerBndi <= maxv;
+    }
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    uint64_t minv = 0, maxv = 0;
+    GET_TYPED_DATA(minv, uint64_t, type, minval);
+    GET_TYPED_DATA(maxv, uint64_t, type, maxval);
+
+    if (minv == maxv) {
+      return minv == pFilterInfo->lowerBndi;
+    } else {
+      assert(minv < maxv);
+      return minv <= pFilterInfo->lowerBndi && pFilterInfo->lowerBndi <= maxv;
+    }
+  } else if (IS_FLOAT_TYPE(type)) {
+    double minv = -1, maxv = -1;
+    GET_TYPED_DATA(minv, double, type, minval);
+    GET_TYPED_DATA(maxv, double, type, maxval);
+
+    if (minv == maxv) {
+      return FLT_EQUAL(minv, pFilterInfo->lowerBndd);
+    } else {  // range filter
+      assert(minv < maxv);
+      return minv <= pFilterInfo->lowerBndd && pFilterInfo->lowerBndd <= maxv;
+    }
+  } else if (type == TSDB_DATA_TYPE_BINARY) {
+    // query condition string is greater than the max length of string, not qualified data
+    if (pFilterInfo->len != varDataLen(minval)) {
+      return false;
+    }
+
+    return strncmp((char *)pFilterInfo->pz, varDataVal(minval), varDataLen(minval)) == 0;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    // query condition string is greater than the max length of string, not qualified data
+    if (pFilterInfo->len != varDataLen(minval)) {
+      return false;
+    }
+
+    return wcsncmp((wchar_t *)pFilterInfo->pz, varDataVal(minval), varDataLen(minval) / TSDB_NCHAR_SIZE) == 0;
+  } else {
     return false;
   }
-
-  return strncmp((char *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)) == 0;
 }
 
-bool equal_nchar(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  // query condition string is greater than the max length of string, not qualified data
-  if (pFilter->filterInfo.len != varDataLen(minval)) {
+////////////////////////////////////////////////////////////////
+bool likeOperator(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
+    return patternMatch((char *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval), &info) == TSDB_PATTERN_MATCH;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
+    return WCSPatternMatch((wchar_t*)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)/TSDB_NCHAR_SIZE, &info) == TSDB_PATTERN_MATCH;
+  } else {
     return false;
   }
-
-  return wcsncmp((wchar_t *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)/TSDB_NCHAR_SIZE) == 0;
-}
-
-////////////////////////////////////////////////////////////////
-bool like_str(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
-  return patternMatch((char *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval), &info) == TSDB_PATTERN_MATCH;
-}
-
-bool like_nchar(SColumnFilterElem* pFilter, char* minval, char *maxval) {
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-  
-  return WCSPatternMatch((wchar_t*)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)/TSDB_NCHAR_SIZE, &info) == TSDB_PATTERN_MATCH;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -236,362 +198,237 @@ bool like_nchar(SColumnFilterElem* pFilter, char* minval, char *maxval) {
  *  During pre-filter stage, if there is one element that locates in [minval, maxval],
  *  the filter function will return true.
  */
-bool nequal_i8(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int8_t *)minval == *(int8_t *)maxval) {
-    return (*(int8_t *)minval != pFilter->filterInfo.lowerBndi);
-  }
-
-  return true;
-}
-
-bool nequal_i16(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int16_t *)minval == *(int16_t *)maxval) {
-    return (*(int16_t *)minval != pFilter->filterInfo.lowerBndi);
+// TODO not equal need to refactor
+bool notEqualOperator(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
+    int64_t minv = -1, maxv = -1;
+    GET_TYPED_DATA(minv, int64_t, type, minval);
+    GET_TYPED_DATA(maxv, int64_t, type, maxval);
+
+    if (minv == maxv) {
+      return minv != pFilterInfo->lowerBndi;
+    }
+    return true;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    uint64_t minv = 0, maxv = 0;
+    GET_TYPED_DATA(minv, uint64_t, type, minval);
+    GET_TYPED_DATA(maxv, uint64_t, type, maxval);
+
+    if (minv == maxv) {
+      return minv != pFilterInfo->lowerBndi;
+    }
+    return true;
+  } else if (IS_FLOAT_TYPE(type)) {
+    double minv = -1, maxv = -1;
+    GET_TYPED_DATA(minv, double, type, minval);
+    GET_TYPED_DATA(maxv, double, type, maxval);
+
+    if (minv == maxv) {
+      return !FLT_EQUAL(minv,  pFilterInfo->lowerBndd);
+    }
+    return true;
+  } else if (type == TSDB_DATA_TYPE_BINARY) {
+    if (pFilterInfo->len != varDataLen(minval)) {
+      return true;
+    }
+    return strncmp((char *)pFilterInfo->pz, varDataVal(minval), varDataLen(minval)) != 0;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    if (pFilterInfo->len != pFilter->bytes) {
+      return true;
+    }
+    return wcsncmp((wchar_t *)pFilterInfo->pz, varDataVal(minval), varDataLen(minval)/TSDB_NCHAR_SIZE) != 0;
+  } else {
+    return false;
   }
-
-  return true;
 }
 
-bool nequal_i32(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int32_t *)minval == *(int32_t *)maxval) {
-    return (*(int32_t *)minval != pFilter->filterInfo.lowerBndi);
-  }
-
+////////////////////////////////////////////////////////////////
+// dummy filter, not used
+bool isNullOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) {
   return true;
 }
 
-bool nequal_i64(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(int64_t *)minval == *(int64_t *)maxval) {
-    return (*(int64_t *)minval != pFilter->filterInfo.lowerBndi);
-  }
-
+bool notNullOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) {
   return true;
 }
 
-bool nequal_ds(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(float *)minval == *(float *)maxval) {
-    return !FLT_EQUAL(*(float *)minval,  pFilter->filterInfo.lowerBndd);
+///////////////////////////////////////////////////////////////////////////////
+bool rangeFilter_ii(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      return ((*(int8_t *)minval <= pFilterInfo->upperBndi) && (*(int8_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UTINYINT:
+      return ((*(uint8_t *)minval <= pFilterInfo->upperBndi) && (*(uint8_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_SMALLINT:
+      return ((*(int16_t *)minval <= pFilterInfo->upperBndi) && (*(int16_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_USMALLINT:
+      return ((*(uint16_t *)minval <= pFilterInfo->upperBndi) && (*(uint16_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_INT:
+      return ((*(int32_t *)minval <= pFilterInfo->upperBndi) && (*(int32_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UINT:
+      return ((*(uint32_t *)minval <= pFilterInfo->upperBndi) && (*(uint32_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT:
+      return ((*(int64_t *)minval <= pFilterInfo->upperBndi) && (*(int64_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UBIGINT:
+      return ((*(uint64_t *)minval <= pFilterInfo->upperBndi) && (*(uint64_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_FLOAT:
+      return FLT_LESSEQUAL(*(float *)minval, pFilterInfo->upperBndd) &&
+             FLT_GREATEREQUAL(*(float *)maxval, pFilterInfo->lowerBndd);
+    case TSDB_DATA_TYPE_DOUBLE:
+      return (*(double *)minval <= pFilterInfo->upperBndd && *(double *)maxval >= pFilterInfo->lowerBndd);
+    default:
+      return false;
   }
-
-  return true;
 }
 
-bool nequal_dd(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (*(double *)minval == *(double *)maxval) {
-    return (*(double *)minval != pFilter->filterInfo.lowerBndd);
+bool rangeFilter_ee(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      return ((*(int8_t *)minval < pFilterInfo->upperBndi) && (*(int8_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UTINYINT:
+      return ((*(uint8_t *)minval < pFilterInfo->upperBndi) && (*(uint8_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_SMALLINT:
+      return ((*(int16_t *)minval < pFilterInfo->upperBndi) && (*(int16_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_USMALLINT:
+      return ((*(uint16_t *)minval < pFilterInfo->upperBndi) && (*(uint16_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_INT:
+      return ((*(int32_t *)minval < pFilterInfo->upperBndi) && (*(int32_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UINT:
+      return ((*(uint32_t *)minval < pFilterInfo->upperBndi) && (*(uint32_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT:
+      return ((*(int64_t *)minval < pFilterInfo->upperBndi) && (*(int64_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UBIGINT:
+      return ((*(uint64_t *)minval < pFilterInfo->upperBndi) && (*(uint64_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_FLOAT:
+      return ((*(float *)minval < pFilterInfo->upperBndd) && (*(float *)maxval > pFilterInfo->lowerBndd));
+    case TSDB_DATA_TYPE_DOUBLE:
+      return ((*(double *)minval < pFilterInfo->upperBndd) && (*(double *)maxval > pFilterInfo->lowerBndd));
+    default:
+      return false;
   }
-
-  return true;
 }
 
-bool nequal_str(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  if (pFilter->filterInfo.len != varDataLen(minval)) {
-    return true;
+bool rangeFilter_ie(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      return ((*(int8_t *)minval < pFilterInfo->upperBndi) && (*(int8_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UTINYINT:
+      return ((*(uint8_t *)minval < pFilterInfo->upperBndi) && (*(uint8_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_SMALLINT:
+      return ((*(int16_t *)minval < pFilterInfo->upperBndi) && (*(int16_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_USMALLINT:
+      return ((*(uint16_t *)minval < pFilterInfo->upperBndi) && (*(uint16_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_INT:
+      return ((*(int32_t *)minval < pFilterInfo->upperBndi) && (*(int32_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UINT:
+      return ((*(uint32_t *)minval < pFilterInfo->upperBndi) && (*(uint32_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT:
+      return ((*(int64_t *)minval < pFilterInfo->upperBndi) && (*(int64_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UBIGINT:
+      return ((*(uint64_t *)minval < pFilterInfo->upperBndi) && (*(uint64_t *)maxval >= pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_FLOAT:
+      return ((*(float *)minval < pFilterInfo->upperBndd) && (*(float *)maxval >= pFilterInfo->lowerBndd));
+    case TSDB_DATA_TYPE_DOUBLE:
+      return ((*(double *)minval < pFilterInfo->upperBndd) && (*(double *)maxval >= pFilterInfo->lowerBndd));
+    default:
+      return false;
   }
-
-  return strncmp((char *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)) != 0;
 }
 
-bool nequal_nchar(SColumnFilterElem *pFilter, char* minval, char *maxval) {
-  if (pFilter->filterInfo.len > pFilter->bytes) {
-    return true;
+bool rangeFilter_ei(SColumnFilterElem *pFilter, const char *minval, const char *maxval, int16_t type) {
+  SColumnFilterInfo *pFilterInfo = &pFilter->filterInfo;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      return ((*(int8_t *)minval <= pFilterInfo->upperBndi) && (*(int8_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UTINYINT:
+      return ((*(uint8_t *)minval <= pFilterInfo->upperBndi) && (*(uint8_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_SMALLINT:
+      return ((*(int16_t *)minval <= pFilterInfo->upperBndi) && (*(int16_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_USMALLINT:
+      return ((*(uint16_t *)minval <= pFilterInfo->upperBndi) && (*(uint16_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_INT:
+      return ((*(int32_t *)minval <= pFilterInfo->upperBndi) && (*(int32_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UINT:
+      return ((*(uint32_t *)minval <= pFilterInfo->upperBndi) && (*(uint32_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT:
+      return ((*(int64_t *)minval <= pFilterInfo->upperBndi) && (*(int64_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_UBIGINT:
+      return ((*(uint64_t *)minval <= pFilterInfo->upperBndi) && (*(uint64_t *)maxval > pFilterInfo->lowerBndi));
+    case TSDB_DATA_TYPE_FLOAT:
+      return FLT_GREATER(*(float *)maxval, pFilterInfo->lowerBndd) &&
+             FLT_LESSEQUAL(*(float *)minval, pFilterInfo->upperBndd);
+    case TSDB_DATA_TYPE_DOUBLE:
+      return ((*(double *)minval <= pFilterInfo->upperBndd) && (*(double *)maxval > pFilterInfo->lowerBndd));
+    default:
+      return false;
   }
-
-  return wcsncmp((wchar_t *)pFilter->filterInfo.pz, varDataVal(minval), varDataLen(minval)/TSDB_NCHAR_SIZE) != 0;
-}
-////////////////////////////////////////////////////////////////
-bool isNull_filter(SColumnFilterElem *pFilter, char* minval, char* maxval) {
-  return true;
-}
-
-bool notNull_filter(SColumnFilterElem *pFilter, char* minval, char* maxval) {
-  return true;
-}
-
-////////////////////////////////////////////////////////////////
-
-bool rangeFilter_i32_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval <= pFilter->filterInfo.upperBndi && *(int32_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i32_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval<pFilter->filterInfo.upperBndi &&*(int32_t *)maxval> pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i32_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval < pFilter->filterInfo.upperBndi && *(int32_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i32_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int32_t *)minval <= pFilter->filterInfo.upperBndi && *(int32_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-bool rangeFilter_i8_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval <= pFilter->filterInfo.upperBndi && *(int8_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i8_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval<pFilter->filterInfo.upperBndi &&*(int8_t *)maxval> pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i8_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval < pFilter->filterInfo.upperBndi && *(int8_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i8_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int8_t *)minval <= pFilter->filterInfo.upperBndi && *(int8_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-/////////////////////////////////////////////////////////////////////////////////////
-bool rangeFilter_i16_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval <= pFilter->filterInfo.upperBndi && *(int16_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i16_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval<pFilter->filterInfo.upperBndi &&*(int16_t *)maxval> pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i16_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval < pFilter->filterInfo.upperBndi && *(int16_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i16_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int16_t *)minval <= pFilter->filterInfo.upperBndi && *(int16_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-////////////////////////////////////////////////////////////////////////
-bool rangeFilter_i64_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval <= pFilter->filterInfo.upperBndi && *(int64_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i64_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval<pFilter->filterInfo.upperBndi &&*(int64_t *)maxval> pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i64_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval < pFilter->filterInfo.upperBndi && *(int64_t *)maxval >= pFilter->filterInfo.lowerBndi);
-}
-
-bool rangeFilter_i64_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(int64_t *)minval <= pFilter->filterInfo.upperBndi && *(int64_t *)maxval > pFilter->filterInfo.lowerBndi);
-}
-
-////////////////////////////////////////////////////////////////////////
-bool rangeFilter_ds_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_LESSEQUAL(*(float *)minval, pFilter->filterInfo.upperBndd) &&
-         FLT_GREATEREQUAL(*(float *)maxval, pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_ds_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(float *)minval<pFilter->filterInfo.upperBndd &&*(float *)maxval> pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_ds_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(float *)minval < pFilter->filterInfo.upperBndd && *(float *)maxval >= pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_ds_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return FLT_GREATER(*(float *)maxval, pFilter->filterInfo.lowerBndd) &&
-         FLT_LESSEQUAL(*(float *)minval, pFilter->filterInfo.upperBndd);
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool rangeFilter_dd_ii(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(double *)minval <= pFilter->filterInfo.upperBndd && *(double *)maxval >= pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_dd_ee(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(double *)minval<pFilter->filterInfo.upperBndd &&*(double *)maxval> pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_dd_ie(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(double *)minval < pFilter->filterInfo.upperBndd && *(double *)maxval >= pFilter->filterInfo.lowerBndd);
-}
-
-bool rangeFilter_dd_ei(SColumnFilterElem *pFilter, char *minval, char *maxval) {
-  return (*(double *)minval <= pFilter->filterInfo.upperBndd && *(double *)maxval > pFilter->filterInfo.lowerBndd);
 }
 
 ////////////////////////////////////////////////////////////////////////////
-bool (*filterFunc_i8[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_i8,
-  larger_i8,
-  equal_i8,
-  lessEqual_i8,
-  largeEqual_i8,
-  nequal_i8,
-  NULL,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*filterFunc_i16[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_i16,
-  larger_i16,
-  equal_i16,
-  lessEqual_i16,
-  largeEqual_i16,
-  nequal_i16,
-  NULL,
-  isNull_filter,
-  notNull_filter,
+bool (*filterOperators[])(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) = {
+    NULL,
+    lessOperator,
+    greaterOperator,
+    equalOperator,
+    lessEqualOperator,
+    greaterEqualOperator,
+    notEqualOperator,
+    likeOperator,
+    isNullOperator,
+    notNullOperator,
 };
 
-bool (*filterFunc_i32[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_i32,
-  larger_i32,
-  equal_i32,
-  lessEqual_i32,
-  largeEqual_i32,
-  nequal_i32,
-  NULL,
-  isNull_filter,
-  notNull_filter,
+bool (*rangeFilterOperators[])(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type) = {
+    NULL,
+    rangeFilter_ee,
+    rangeFilter_ie,
+    rangeFilter_ei,
+    rangeFilter_ii,
 };
 
-bool (*filterFunc_i64[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_i64,
-  larger_i64,
-  equal_i64,
-  lessEqual_i64,
-  largeEqual_i64,
-  nequal_i64,
-  NULL,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*filterFunc_ds[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_ds,
-  larger_ds,
-  equal_ds,
-  lessEqual_ds,
-  largeEqual_ds,
-  nequal_ds,
-  NULL,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*filterFunc_dd[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  less_dd,
-  larger_dd,
-  equal_dd,
-  lessEqual_dd,
-  largeEqual_dd,
-  nequal_dd,
-  NULL,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*filterFunc_str[])(SColumnFilterElem* pFilter, char* minval, char *maxval) = {
-  NULL,
-  NULL,
-  NULL,
-  equal_str,
-  NULL,
-  NULL,
-  nequal_str,
-  like_str,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*filterFunc_nchar[])(SColumnFilterElem* pFitler, char* minval, char* maxval) = {
-  NULL,
-  NULL,
-  NULL,
-  equal_nchar,
-  NULL,
-  NULL,
-  nequal_nchar,
-  like_nchar,
-  isNull_filter,
-  notNull_filter,
-};
-
-bool (*rangeFilterFunc_i8[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_i8_ee,
-  rangeFilter_i8_ie,
-  rangeFilter_i8_ei,
-  rangeFilter_i8_ii,
-};
-
-bool (*rangeFilterFunc_i16[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_i16_ee,
-  rangeFilter_i16_ie,
-  rangeFilter_i16_ei,
-  rangeFilter_i16_ii,
-};
-
-bool (*rangeFilterFunc_i32[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_i32_ee,
-  rangeFilter_i32_ie,
-  rangeFilter_i32_ei,
-  rangeFilter_i32_ii,
-};
-
-bool (*rangeFilterFunc_i64[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_i64_ee,
-  rangeFilter_i64_ie,
-  rangeFilter_i64_ei,
-  rangeFilter_i64_ii,
-};
-
-bool (*rangeFilterFunc_ds[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_ds_ee,
-  rangeFilter_ds_ie,
-  rangeFilter_ds_ei,
-  rangeFilter_ds_ii,
-};
-
-bool (*rangeFilterFunc_dd[])(SColumnFilterElem *pFilter, char *minval, char *maxval) = {
-  NULL,
-  rangeFilter_dd_ee,
-  rangeFilter_dd_ie,
-  rangeFilter_dd_ei,
-  rangeFilter_dd_ii,
-};
-
-__filter_func_t* getRangeFilterFuncArray(int32_t type) {
-  switch(type) {
-    case TSDB_DATA_TYPE_BOOL:
-    case TSDB_DATA_TYPE_TINYINT:    return rangeFilterFunc_i8;
-    case TSDB_DATA_TYPE_SMALLINT:   return rangeFilterFunc_i16;
-    case TSDB_DATA_TYPE_INT:        return rangeFilterFunc_i32;
-    case TSDB_DATA_TYPE_TIMESTAMP:  //timestamp uses bigint filter
-    case TSDB_DATA_TYPE_BIGINT:     return rangeFilterFunc_i64;
-    case TSDB_DATA_TYPE_FLOAT:      return rangeFilterFunc_ds;
-    case TSDB_DATA_TYPE_DOUBLE:     return rangeFilterFunc_dd;
-    default:return NULL;
+__filter_func_t getFilterOperator(int32_t lowerOptr, int32_t upperOptr) {
+  __filter_func_t funcFp = NULL;
+
+  if ((lowerOptr == TSDB_RELATION_GREATER_EQUAL || lowerOptr == TSDB_RELATION_GREATER) &&
+      (upperOptr == TSDB_RELATION_LESS_EQUAL || upperOptr == TSDB_RELATION_LESS)) {
+    if (lowerOptr == TSDB_RELATION_GREATER_EQUAL) {
+      if (upperOptr == TSDB_RELATION_LESS_EQUAL) {
+        funcFp = rangeFilterOperators[4];
+      } else {
+        funcFp = rangeFilterOperators[2];
+      }
+    } else {
+      if (upperOptr == TSDB_RELATION_LESS_EQUAL) {
+        funcFp = rangeFilterOperators[3];
+      } else {
+        funcFp = rangeFilterOperators[1];
+      }
+    }
+  } else {  // set callback filter function
+    if (lowerOptr != TSDB_RELATION_INVALID) {
+      funcFp = filterOperators[lowerOptr];
+
+      // invalid filter condition: %d", pQInfo, type
+      if (upperOptr != TSDB_RELATION_INVALID) {
+        return NULL;
+      }
+    } else {
+      funcFp = filterOperators[upperOptr];
+    }
   }
-}
 
-__filter_func_t* getValueFilterFuncArray(int32_t type) {
-  switch(type) {
-    case TSDB_DATA_TYPE_BOOL:
-    case TSDB_DATA_TYPE_TINYINT:    return filterFunc_i8;
-    case TSDB_DATA_TYPE_SMALLINT:   return filterFunc_i16;
-    case TSDB_DATA_TYPE_INT:        return filterFunc_i32;
-    case TSDB_DATA_TYPE_TIMESTAMP:  //timestamp uses bigint filter
-    case TSDB_DATA_TYPE_BIGINT:     return filterFunc_i64;
-    case TSDB_DATA_TYPE_FLOAT:      return filterFunc_ds;
-    case TSDB_DATA_TYPE_DOUBLE:     return filterFunc_dd;
-    case TSDB_DATA_TYPE_BINARY:     return filterFunc_str;
-    case TSDB_DATA_TYPE_NCHAR:      return filterFunc_nchar;
-    default: return NULL;
-  }
+  return funcFp;
 }
diff --git a/src/query/tests/astTest.cpp b/src/query/tests/astTest.cpp
index 99f03a7ff8185f8537ebb243e00bce77992db344..728de4357ce64abad78eb5bc421ce82a1e1e7a6d 100644
--- a/src/query/tests/astTest.cpp
+++ b/src/query/tests/astTest.cpp
@@ -471,7 +471,7 @@ tExprNode *createExpr1() {
   pRight->pVal = (tVariant*) calloc(1, sizeof(tVariant));
   
   pRight->pVal->nType = TSDB_DATA_TYPE_INT;
-  pRight->pVal->i64Key = 12;
+  pRight->pVal->i64 = 12;
   
   auto *pRoot = (tExprNode*) calloc(1, sizeof(tExprNode));
   pRoot->nodeType = TSQL_NODE_EXPR;
@@ -574,7 +574,7 @@ void exprSerializeTest1() {
   tVariant* v2 = p2->_node.pRight->pVal;
   
   ASSERT_EQ(v1->nType, v2->nType);
-  ASSERT_EQ(v1->i64Key, v2->i64Key);
+  ASSERT_EQ(v1->i64, v2->i64);
   ASSERT_EQ(p1->_node.hasPK, p2->_node.hasPK);
   
   tExprTreeDestroy(&p1, nullptr);
diff --git a/tests/script/general/parser/null_char.sim b/tests/script/general/parser/null_char.sim
index 4c6ac100abb0f55facc67a756607b44b73517cf9..b3200da88e0a9d77899031d71271e580cb279c3b 100644
--- a/tests/script/general/parser/null_char.sim
+++ b/tests/script/general/parser/null_char.sim
@@ -451,11 +451,8 @@ sql select tag_bigint, tag_smallint, tag_tinyint from st51
 if $data00 != 9223372036854775807 then
   return -1
 endi
-sql alter table st51 set tag tag_bigint = 9223372036854775808
-sql select tag_bigint, tag_smallint, tag_tinyint from st51
-if $data00 != 9223372036854775807 then
-  return -1
-endi
+sql_error alter table st51 set tag tag_bigint = 9223372036854775808
+
 sql alter table st51 set tag tag_bigint = -9223372036854775807
 sql select tag_bigint, tag_smallint, tag_tinyint from st51
 if $data00 != -9223372036854775807 then
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 90cccb80e52670ef3ad0ab8cea4503f27f6ac23f..2d77cb15d248ee805f0b214960d18e06e3ac4d7e 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -1,64 +1,64 @@
-run general/parser/alter.sim
-sleep 100
-run general/parser/alter1.sim
-sleep 100
-run general/parser/alter_stable.sim
-sleep 100
-run general/parser/auto_create_tb.sim
-sleep 100
-run general/parser/auto_create_tb_drop_tb.sim
-sleep 100
-run general/parser/col_arithmetic_operation.sim
-sleep 100
-run general/parser/columnValue.sim
-sleep 100
-run general/parser/commit.sim
-sleep 100
-run general/parser/create_db.sim
-sleep 100
-run general/parser/create_mt.sim
-sleep 100
-run general/parser/create_tb.sim
-sleep 100
-run general/parser/dbtbnameValidate.sim
-sleep 100
-run general/parser/fill.sim
-sleep 100
-run general/parser/fill_stb.sim
-sleep 100
-#run general/parser/fill_us.sim               #
-sleep 100
-run general/parser/first_last.sim
-sleep 100
-run general/parser/import_commit1.sim
-sleep 100
-run general/parser/import_commit2.sim
-sleep 100
-run general/parser/import_commit3.sim
-sleep 100
-#run general/parser/import_file.sim
-sleep 100
-run general/parser/insert_tb.sim
-sleep 100
-run general/parser/tags_dynamically_specifiy.sim
-sleep 100
-run general/parser/interp.sim
-sleep 100
-run general/parser/lastrow.sim
-sleep 100
-run general/parser/limit.sim
-sleep 100
-run general/parser/limit1.sim
-sleep 100
-run general/parser/limit1_tblocks100.sim
-sleep 100
-run general/parser/limit2.sim
-sleep 100
-run general/parser/mixed_blocks.sim
-sleep 100
-run general/parser/nchar.sim
-sleep 100
-run general/parser/null_char.sim
+#run general/parser/alter.sim
+#sleep 100
+#run general/parser/alter1.sim
+#sleep 100
+#run general/parser/alter_stable.sim
+#sleep 100
+#run general/parser/auto_create_tb.sim
+#sleep 100
+#run general/parser/auto_create_tb_drop_tb.sim
+#sleep 100
+#run general/parser/col_arithmetic_operation.sim
+#sleep 100
+#run general/parser/columnValue.sim
+#sleep 100
+#run general/parser/commit.sim
+#sleep 100
+#run general/parser/create_db.sim
+#sleep 100
+#run general/parser/create_mt.sim
+#sleep 100
+#run general/parser/create_tb.sim
+#sleep 100
+#run general/parser/dbtbnameValidate.sim
+#sleep 100
+#run general/parser/fill.sim
+#sleep 100
+#run general/parser/fill_stb.sim
+#sleep 100
+##run general/parser/fill_us.sim               #
+#sleep 100
+#run general/parser/first_last.sim
+#sleep 100
+#run general/parser/import_commit1.sim
+#sleep 100
+#run general/parser/import_commit2.sim
+#sleep 100
+#run general/parser/import_commit3.sim
+#sleep 100
+##run general/parser/import_file.sim
+#sleep 100
+#run general/parser/insert_tb.sim
+#sleep 100
+#run general/parser/tags_dynamically_specifiy.sim
+#sleep 100
+#run general/parser/interp.sim
+#sleep 100
+#run general/parser/lastrow.sim
+#sleep 100
+#run general/parser/limit.sim
+#sleep 100
+#run general/parser/limit1.sim
+#sleep 100
+#run general/parser/limit1_tblocks100.sim
+#sleep 100
+#run general/parser/limit2.sim
+#sleep 100
+#run general/parser/mixed_blocks.sim
+#sleep 100
+#run general/parser/nchar.sim
+#sleep 100
+#run general/parser/null_char.sim
 sleep 100
 run general/parser/selectResNum.sim
 sleep 100
diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c
index 0323f6ca687c40c8bc70b0672abe4e2f7852a8cc..a23dff13be07c1a56da6d3051a4384ccfb96d9bb 100644
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
@@ -746,15 +746,27 @@ bool simExecuteNativeSqlCommand(SScript *script, char *rest, bool isSlow) {
             case TSDB_DATA_TYPE_TINYINT:
               sprintf(value, "%d", *((int8_t *)row[i]));
               break;
+            case TSDB_DATA_TYPE_UTINYINT:
+              sprintf(value, "%u", *((uint8_t*)row[i]));
+              break;
             case TSDB_DATA_TYPE_SMALLINT:
               sprintf(value, "%d", *((int16_t *)row[i]));
               break;
+            case TSDB_DATA_TYPE_USMALLINT:
+              sprintf(value, "%u", *((uint16_t *)row[i]));
+              break;
             case TSDB_DATA_TYPE_INT:
               sprintf(value, "%d", *((int32_t *)row[i]));
               break;
+            case TSDB_DATA_TYPE_UINT:
+              sprintf(value, "%u", *((uint32_t *)row[i]));
+              break;
             case TSDB_DATA_TYPE_BIGINT:
               sprintf(value, "%" PRId64, *((int64_t *)row[i]));
               break;
+            case TSDB_DATA_TYPE_UBIGINT:
+              sprintf(value, "%" PRIu64, *((uint64_t *)row[i]));
+              break;
             case TSDB_DATA_TYPE_FLOAT:
               sprintf(value, "%.5f", GET_FLOAT_VAL(row[i]));
               break;