diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 4b1ab477304d68d5d52ed02b9b2d2c0121c4ffa6..bb015bce3d1a8ea9d92f3915d1edccd7f31539a3 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -749,7 +749,10 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
 
 static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
   char db[TSDB_DB_NAME_LEN] = {0};
+
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
   extractDBName(pSql->pTscObj->db, db);
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
 
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 2f98fbc27035342a4f4eb65e1e5d9d76d6e671ab..ec699408de943f228e2c0aa7057f265bc9fc446a 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -62,7 +62,7 @@ static int32_t setShowInfo(SSqlObj* pSql, SSqlInfo* pInfo);
 static char*   getAccountId(SSqlObj* pSql);
 
 static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
-static char* getCurrentDBName(SSqlObj* pSql);
+static char* cloneCurrentDBName(SSqlObj* pSql);
 static bool hasSpecifyDB(SStrToken* pTableName);
 static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd);
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd);
@@ -923,16 +923,19 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   } else {  // get current DB name first, and then set it into path
-    char* t = getCurrentDBName(pSql);
+    char* t = cloneCurrentDBName(pSql);
     if (strlen(t) == 0) {
       return TSDB_CODE_TSC_DB_NOT_SELECTED;
     }
 
     code = tNameFromString(&pTableMetaInfo->name, t, T_NAME_ACCT | T_NAME_DB);
     if (code != 0) {
+      free(t);
       return TSDB_CODE_TSC_DB_NOT_SELECTED;
     }
 
+    free(t);
+
     if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
@@ -1246,8 +1249,12 @@ static bool has(SArray* pFieldList, int32_t startIdx, const char* name) {
 
 static char* getAccountId(SSqlObj* pSql) { return pSql->pTscObj->acctId; }
 
-static char* getCurrentDBName(SSqlObj* pSql) {
-  return pSql->pTscObj->db;
+static char* cloneCurrentDBName(SSqlObj* pSql) {
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
+  char *p = strdup(pSql->pTscObj->db);  
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
+
+  return p;
 }
 
 /* length limitation, strstr cannot be applied */
@@ -4302,6 +4309,77 @@ static void doAddJoinTagsColumnsIntoTagList(SSqlCmd* pCmd, SQueryInfo* pQueryInf
   }
 }
 
+static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
+  const char *msg1 = "invalid tag operator";
+  const char* msg2 = "not supported filter condition";
+  
+  do {
+    if (p->nodeType != TSQL_NODE_EXPR) {
+      break;
+    }
+    
+    if (!p->_node.pLeft || !p->_node.pRight) {
+      break;
+    }
+    
+    if (IS_ARITHMETIC_OPTR(p->_node.optr)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1); 
+    }
+    
+    if (!IS_RELATION_OPTR(p->_node.optr)) {
+      break;
+    }
+    
+    tVariant * vVariant = NULL;
+    int32_t schemaType = -1;
+  
+    if (p->_node.pLeft->nodeType == TSQL_NODE_VALUE && p->_node.pRight->nodeType == TSQL_NODE_COL) {
+      if (!p->_node.pRight->pSchema) {
+        break;
+      }
+      
+      vVariant = p->_node.pLeft->pVal;
+      schemaType = p->_node.pRight->pSchema->type;
+    } else if (p->_node.pLeft->nodeType == TSQL_NODE_COL && p->_node.pRight->nodeType == TSQL_NODE_VALUE) {
+      if (!p->_node.pLeft->pSchema) {
+        break;
+      }
+
+      vVariant = p->_node.pRight->pVal;
+      schemaType = p->_node.pLeft->pSchema->type;
+    } else {
+      break;
+    }
+
+    if (schemaType >= TSDB_DATA_TYPE_TINYINT && schemaType <= TSDB_DATA_TYPE_BIGINT) {
+      schemaType = TSDB_DATA_TYPE_BIGINT;
+    } else if (schemaType == TSDB_DATA_TYPE_FLOAT || schemaType == TSDB_DATA_TYPE_DOUBLE) {
+      schemaType = TSDB_DATA_TYPE_DOUBLE;
+    }
+    
+    int32_t retVal = TSDB_CODE_SUCCESS;
+    if (schemaType == TSDB_DATA_TYPE_BINARY) {
+      char *tmp = calloc(1, vVariant->nLen + TSDB_NCHAR_SIZE);
+      retVal = tVariantDump(vVariant, tmp, schemaType, false);
+      free(tmp);
+    } else if (schemaType == TSDB_DATA_TYPE_NCHAR) {
+      // pRight->val.nLen + 1 is larger than the actual nchar string length
+      char *tmp = calloc(1, (vVariant->nLen + 1) * TSDB_NCHAR_SIZE);
+      retVal = tVariantDump(vVariant, tmp, schemaType, false);
+      free(tmp);
+    } else {
+      double tmp;
+      retVal = tVariantDump(vVariant, (char*)&tmp, schemaType, false);
+    }
+    
+    if (retVal != TSDB_CODE_SUCCESS) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
+  }while (0);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr* pCondExpr, tSQLExpr** pExpr) {
   int32_t ret = TSDB_CODE_SUCCESS;
 
@@ -4344,6 +4422,10 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
     tsSetSTableQueryCond(&pQueryInfo->tagCond, uid, &bw);
     doCompactQueryExpr(pExpr);
 
+    if (ret == TSDB_CODE_SUCCESS) {
+      ret = validateTagCondExpr(pCmd, p);
+    }
+
     tSqlExprDestroy(p1);
     tExprTreeDestroy(p, NULL);
     
@@ -4351,6 +4433,10 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
     if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0 && !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "filter on tag not supported for normal table");
     }
+
+    if (ret) {
+      break;
+    }
   }
 
   pCondExpr->pTagCond = NULL;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 840387656691e0bd0e76908d311b0ac124db5baf..6035a270c5494560744b12cfa77c7449ca2fcb06 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1250,8 +1250,10 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
 
-  if (tNameIsEmpty(&pTableMetaInfo->name)) {
-    tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));
+  if (tNameIsEmpty(&pTableMetaInfo->name)) {    
+    pthread_mutex_lock(&pObj->mutex);
+    tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));  
+    pthread_mutex_unlock(&pObj->mutex);
   } else {
     tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
   }
@@ -1611,9 +1613,14 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   // TODO refactor full_name
   char *db;  // ugly code to move the space
+  
+  pthread_mutex_lock(&pObj->mutex);
   db = strstr(pObj->db, TS_PATH_DELIMITER);
+
   db = (db == NULL) ? pObj->db : db + 1;
   tstrncpy(pConnect->db, db, sizeof(pConnect->db));
+  pthread_mutex_unlock(&pObj->mutex);
+
   tstrncpy(pConnect->clientVersion, version, sizeof(pConnect->clientVersion));
   tstrncpy(pConnect->msgVersion, "", sizeof(pConnect->msgVersion));
 
@@ -2131,10 +2138,13 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
 
   SConnectRsp *pConnect = (SConnectRsp *)pRes->pRsp;
   tstrncpy(pObj->acctId, pConnect->acctId, sizeof(pObj->acctId));  // copy acctId from response
+  
+  pthread_mutex_lock(&pObj->mutex);
   int32_t len = sprintf(temp, "%s%s%s", pObj->acctId, TS_PATH_DELIMITER, pObj->db);
 
   assert(len <= sizeof(pObj->db));
   tstrncpy(pObj->db, temp, sizeof(pObj->db));
+  pthread_mutex_unlock(&pObj->mutex);
   
   if (pConnect->epSet.numOfEps > 0) {
     tscEpSetHtons(&pConnect->epSet);
@@ -2161,11 +2171,18 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
 int tscProcessUseDbRsp(SSqlObj *pSql) {
   STscObj *       pObj = pSql->pTscObj;
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
-  return tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
+  
+  pthread_mutex_lock(&pObj->mutex);
+  int ret = tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
+  pthread_mutex_unlock(&pObj->mutex);
+  
+  return ret;
 }
 
 int tscProcessDropDbRsp(SSqlObj *pSql) {
-  pSql->pTscObj->db[0] = 0;
+  //TODO LOCK DB WHEN MODIFY IT
+  //pSql->pTscObj->db[0] = 0;
+  
   taosHashEmpty(tscTableMetaInfo);
   return 0;
 }
diff --git a/src/common/src/tvariant.c b/src/common/src/tvariant.c
index fa95e17f32556e63935da51af33e990f1363a170..cfad85be60c19811909c0f6abbcfa26a2f5bad69 100644
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -430,7 +430,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
   }
 
   errno = 0;
-  if (IS_SIGNED_NUMERIC_TYPE(pVariant->nType)) {
+  if (IS_SIGNED_NUMERIC_TYPE(pVariant->nType) || (pVariant->nType == TSDB_DATA_TYPE_BOOL)) {
     *result = pVariant->i64;
   } else if (IS_UNSIGNED_NUMERIC_TYPE(pVariant->nType)) {
     *result = pVariant->u64;
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index 6fea04907492d29f50e12f2ac43af0ae20c79a27..9f3c31f22595d6dc6007dc9517390b970b781943 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -163,6 +163,11 @@ do { \
 #define TSDB_BINARY_OP_MULTIPLY   32
 #define TSDB_BINARY_OP_DIVIDE     33
 #define TSDB_BINARY_OP_REMAINDER  34
+
+
+#define IS_RELATION_OPTR(op) (((op) >= TSDB_RELATION_LESS) && ((op) <= TSDB_RELATION_IN))
+#define IS_ARITHMETIC_OPTR(op) (((op) >= TSDB_BINARY_OP_ADD) && ((op) <= TSDB_BINARY_OP_REMAINDER))
+
 #define TS_PATH_DELIMITER_LEN     1
 
 #define TSDB_UNI_LEN              24