fix(query): enhanced bitwise and function

[TS-1210]

src/client/src/tscSQLParser.c

@@ -10124,8 +10124,8 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
       *pExpr = calloc(1, sizeof(tExprNode));
       (*pExpr)->nodeType = TSQL_NODE_VALUE;
       (*pExpr)->pVal = calloc(1, sizeof(tVariant));
+      tVariantAssign((*pExpr)->pVal, &pSqlExpr->value);
 
-      tVariant value = pSqlExpr->value;
       STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, pQueryInfo->curTableIdx)->pTableMeta;
       if (pCols != NULL) {
         size_t colSize = taosArrayGetSize(pCols);
@@ -10134,14 +10134,12 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
           SColIndex* idx = taosArrayGet(pCols, colSize - 1);
 
           SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, idx->colIndex);
-          value.nType = pSchema->type;
           // convert time by precision
           if (pSchema != NULL && TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && TSDB_DATA_TYPE_BINARY == (*pExpr)->pVal->nType) {
             ret = setColumnFilterInfoForTimestamp(pCmd, pQueryInfo, (*pExpr)->pVal);
           }
         }
       }
-      tVariantAssign((*pExpr)->pVal, &value);
       return ret;
     } else if (pSqlExpr->type == SQL_NODE_TABLE_COLUMN) {  // column name, normal column arithmetic expression
       SColumnIndex index = COLUMN_INDEX_INITIALIZER;

src/common/src/texpr.c

@@ -23,6 +23,7 @@
 #include "tarray.h"
 #include "tbuffer.h"
 #include "tcompare.h"
+#include "tglobal.h"
 #include "tsdb.h"
 #include "tskiplist.h"
 #include "texpr.h"
@@ -47,7 +48,7 @@ static int32_t exprInvalidOperationMsg(char *msgbuf, const char *msg) {
 
 int32_t exprTreeValidateFunctionNode(char* msgbuf, tExprNode *pExpr) {
   int32_t code = TSDB_CODE_SUCCESS;
-  //TODO: check childs for every function
+  //TODO: check children for every function
   switch (pExpr->_func.functionId) {
     case TSDB_FUNC_SCALAR_POW:
     case TSDB_FUNC_SCALAR_LOG:
@@ -87,6 +88,7 @@ int32_t exprTreeValidateFunctionNode(char* msgbuf, tExprNode *pExpr) {
 int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
   int16_t leftType = pExpr->_node.pLeft->resultType;
   int16_t rightType = pExpr->_node.pRight->resultType;
+  int16_t resultType = leftType;
 
   if (pExpr->_node.optr == TSDB_BINARY_OP_ADD || pExpr->_node.optr == TSDB_BINARY_OP_SUBTRACT ||
       pExpr->_node.optr == TSDB_BINARY_OP_MULTIPLY || pExpr->_node.optr == TSDB_BINARY_OP_DIVIDE ||
@@ -98,18 +100,168 @@ int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
     pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
     return TSDB_CODE_SUCCESS;
   } else if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND) {
-    if ((leftType != rightType) || (leftType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(leftType) && !IS_UNSIGNED_NUMERIC_TYPE(leftType)) ||
+    if ((leftType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(leftType) && !IS_UNSIGNED_NUMERIC_TYPE(leftType)) ||
         (rightType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(rightType) && !IS_UNSIGNED_NUMERIC_TYPE(rightType)))
     {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
-    if (leftType == TSDB_DATA_TYPE_BOOL) {
+    uint8_t schemaType;
+    // now leftType and rightType are both numeric
+    if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL && pExpr->_node.pRight->nodeType == TSQL_NODE_COL) {
+      if (leftType != rightType) {
+        return TSDB_CODE_TSC_INVALID_OPERATION;
+      }
+    } else if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL) {
+      if (pExpr->_node.pRight->nodeType != TSQL_NODE_VALUE) {
+        return TSDB_CODE_TSC_INVALID_OPERATION;
+      } else {
+        schemaType = pExpr->_node.pLeft->pSchema->type;
+        int64_t sVal = pExpr->_node.pRight->pVal->i64;
+        uint64_t uVal = pExpr->_node.pRight->pVal->u64;
+
+        switch (schemaType) {
+        case TSDB_DATA_TYPE_BOOL:
+          if ((pExpr->_node.pRight->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
+              (pExpr->_node.pRight->pVal->i64 != 0 &&
+               pExpr->_node.pRight->pVal->i64 != 1 &&
+               pExpr->_node.pRight->pVal->i64 != TSDB_DATA_BOOL_NULL))
+          {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_TINYINT:
+          if (sVal < -128 || sVal > 127) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_SMALLINT:
+          if (sVal < -65536 || sVal > 65535) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_INT:
+          if (sVal < INT32_MIN || sVal > INT32_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_BIGINT:
+          if (sVal < INT64_MIN || sVal > INT64_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_UTINYINT:
+          if (uVal > 128) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_USMALLINT:
+          if (uVal > 65536) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_UINT:
+          if (uVal > UINT32_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        case TSDB_DATA_TYPE_UBIGINT:
+          if (uVal > UINT64_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          break;
+        }
+
+        pExpr->_node.pRight->pSchema->type = schemaType;
+        pExpr->_node.pRight->pVal->nType = schemaType;
+
+        pExpr->_node.pRight->resultType = schemaType;
+        pExpr->_node.pRight->resultBytes = tDataTypes[schemaType].bytes;
+      }
+    } else {
+      if (pExpr->_node.pLeft->nodeType != TSQL_NODE_VALUE) {
+        return TSDB_CODE_TSC_INVALID_OPERATION;
+      } else {
+        schemaType = pExpr->_node.pRight->pSchema->type;
+        int64_t sVal = pExpr->_node.pLeft->pVal->i64;
+        uint64_t uVal = pExpr->_node.pLeft->pVal->u64;
+        switch (schemaType) {
+        case TSDB_DATA_TYPE_BOOL:
+          if ((pExpr->_node.pLeft->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
+              (pExpr->_node.pLeft->pVal->i64 != 0 &&
+               pExpr->_node.pLeft->pVal->i64 != 1 &&
+               pExpr->_node.pLeft->pVal->i64 != TSDB_DATA_BOOL_NULL))
+          {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 1;
+          break;
+        case TSDB_DATA_TYPE_TINYINT:
+          if (sVal < -128 || sVal > 127) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 1;
+          break;
+        case TSDB_DATA_TYPE_SMALLINT:
+          if (sVal < -65536 || sVal > 65535) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 2;
+          break;
+        case TSDB_DATA_TYPE_INT:
+          if (sVal < INT32_MIN || sVal > INT32_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 4;
+          break;
+        case TSDB_DATA_TYPE_BIGINT:
+          if (sVal < INT64_MIN || sVal > INT64_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 8;
+          break;
+        case TSDB_DATA_TYPE_UTINYINT:
+          if (uVal > 128) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 1;
+          break;
+        case TSDB_DATA_TYPE_USMALLINT:
+          if (uVal > 65536) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 2;
+          break;
+        case TSDB_DATA_TYPE_UINT:
+          if (uVal > UINT32_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 4;
+          break;
+        case TSDB_DATA_TYPE_UBIGINT:
+          if (uVal > UINT64_MAX) {
+            return TSDB_CODE_TSC_INVALID_OPERATION;
+          }
+          pExpr->_node.pLeft->pVal->nLen = 8;
+          break;
+        }
+
+        pExpr->_node.pLeft->pSchema->type = schemaType;
+        pExpr->_node.pLeft->pVal->nType = schemaType;
+
+        pExpr->_node.pLeft->resultType = schemaType;
+        pExpr->_node.pLeft->resultBytes = tDataTypes[schemaType].bytes;
+      }
+
+      resultType = schemaType;
+    }
+
+    if (resultType == TSDB_DATA_TYPE_BOOL) {
       pExpr->resultType = TSDB_DATA_TYPE_BOOL;
       pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
     } else {
-      pExpr->resultType = leftType;
-      pExpr->resultBytes = tDataTypes[leftType].bytes;
+      pExpr->resultType = resultType;
+      pExpr->resultBytes = tDataTypes[resultType].bytes;
     }
     return TSDB_CODE_SUCCESS;
   } else {
@@ -504,7 +656,7 @@ void exprTreeExprNodeTraverse(tExprNode *pExpr, int32_t numOfRows, tExprOperandI
 
   _arithmetic_operator_fn_t OperatorFn = getArithmeticOperatorFn(pExpr->_node.optr);
   OperatorFn(leftIn, leftNum, leftType, rightIn, rightNum, rightType, output->data, fnOrder);
-  
+
   output->numOfRows = MAX(leftNum, rightNum);
   if(leftType == TSDB_DATA_TYPE_TIMESTAMP || rightType == TSDB_DATA_TYPE_TIMESTAMP) {
     output->type = TSDB_DATA_TYPE_BIGINT;
@@ -513,7 +665,7 @@ void exprTreeExprNodeTraverse(tExprNode *pExpr, int32_t numOfRows, tExprOperandI
       output->type = leftType; // rightType must be the same as leftType
     } else {
       output->type = TSDB_DATA_TYPE_DOUBLE;
-    }    
+    }
   }
   output->bytes = tDataTypes[output->type].bytes;
 
@@ -1748,4 +1900,5 @@ tScalarFunctionInfo aScalarFunctions[] = {
         "cast",
         vectorMathFunc
     },
+
 };