Merge pull request #5279 from taosdata/feature/query

Feature/query

src/client/src/tscSQLParser.c

@@ -1144,7 +1144,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
     return false;
   }
 
-  if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_NCHAR)) {
+  if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_UBIGINT)) {
     invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
     return false;
   }
@@ -1208,7 +1208,7 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
     return false;
   }
 
-  if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_NCHAR) {
+  if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_UBIGINT) {
     invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
     return false;
   }
@@ -1885,6 +1885,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
   const char* msg7 = "normal table can not apply this function";
   const char* msg8 = "multi-columns selection does not support alias column name";
   const char* msg9 = "invalid function";
+  const char* msg10 = "diff can no be applied to unsigned numeric type";
 
   switch (optr) {
     case TK_COUNT: {
@@ -2023,6 +2024,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       if (!IS_NUMERIC_TYPE(colType)) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      } else if (IS_UNSIGNED_NUMERIC_TYPE(colType) && optr == TK_DIFF) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg10);
       }
 
       int16_t resultType = 0;

src/query/src/qAggMain.c

@@ -1051,7 +1051,7 @@ static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin,
       TYPED_LOOPCHECK_N(uint16_t, pOutput, p, pCtx, pCtx->inputType, isMin, *notNullElems);
     } else if (pCtx->inputType == TSDB_DATA_TYPE_UINT) {
       TYPED_LOOPCHECK_N(uint32_t, pOutput, p, pCtx, pCtx->inputType, isMin, *notNullElems);
-    } else if (pCtx->inputType == TSDB_DATA_TYPE_BIGINT) {
+    } else if (pCtx->inputType == TSDB_DATA_TYPE_UBIGINT) {
       TYPED_LOOPCHECK_N(uint64_t, pOutput, p, pCtx, pCtx->inputType, isMin, *notNullElems);
     }
   } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE) {
@@ -2172,19 +2172,22 @@ static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData,
   
   if (pInfo->num < maxLen) {
     if (pInfo->num == 0 ||
-        ((type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) &&
+        (IS_SIGNED_NUMERIC_TYPE(type) && val.i64 >= pList[pInfo->num - 1]->v.i64) ||
-            val.i64 >= pList[pInfo->num - 1]->v.i64) ||
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 >= pList[pInfo->num - 1]->v.u64) ||
-        ((type >= TSDB_DATA_TYPE_FLOAT && type <= TSDB_DATA_TYPE_DOUBLE) &&
+        (IS_FLOAT_TYPE(type) && val.dKey >= pList[pInfo->num - 1]->v.dKey)) {
-            val.dKey >= pList[pInfo->num - 1]->v.dKey)) {
       valuePairAssign(pList[pInfo->num], type, (const char*)&val.i64, ts, pTags, pTagInfo, stage);
     } else {
       int32_t i = pInfo->num - 1;
-      
+      if (IS_SIGNED_NUMERIC_TYPE(type)) {
-      if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) {
         while (i >= 0 && pList[i]->v.i64 > val.i64) {
           VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
           i -= 1;
         }
+      } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+        while (i >= 0 && pList[i]->v.u64 > val.u64) {
+          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
+          i -= 1;
+        }
       } else {
         while (i >= 0 && pList[i]->v.dKey > val.dKey) {
           VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
@@ -2198,23 +2201,29 @@ static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData,
     pInfo->num++;
   } else {
     int32_t i = 0;
-    
+
-    if (((type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) && val.i64 > pList[0]->v.i64) ||
+    if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i64 > pList[0]->v.i64) ||
-        ((type >= TSDB_DATA_TYPE_FLOAT && type <= TSDB_DATA_TYPE_DOUBLE) && val.dKey > pList[0]->v.dKey)) {
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 > pList[0]->v.u64) ||
+        (IS_FLOAT_TYPE(type) && val.dKey > pList[0]->v.dKey)) {
       // find the appropriate the slot position
-      if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) {
+      if (IS_SIGNED_NUMERIC_TYPE(type)) {
         while (i + 1 < maxLen && pList[i + 1]->v.i64 < val.i64) {
           VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
           i += 1;
         }
+      } if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+        while (i + 1 < maxLen && pList[i + 1]->v.u64 < val.u64) {
+          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
+          i += 1;
+        }
       } else {
         while (i + 1 < maxLen && pList[i + 1]->v.dKey < val.dKey) {
           VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
           i += 1;
         }
       }
-      
+
-      valuePairAssign(pList[i], type, (const char*) &val.i64, ts, pTags, pTagInfo, stage);
+      valuePairAssign(pList[i], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
     }
   }
 }
@@ -2233,11 +2242,16 @@ static void do_bottom_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pDa
     } else {
       int32_t i = pInfo->num - 1;
       
-      if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) {
+      if (IS_SIGNED_NUMERIC_TYPE(type)) {
         while (i >= 0 && pList[i]->v.i64 < val.i64) {
           VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
           i -= 1;
         }
+      } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+          while (i >= 0 && pList[i]->v.u64 < val.u64) {
+            VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
+            i -= 1;
+          }
       } else {
         while (i >= 0 && pList[i]->v.dKey < val.dKey) {
           VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
@@ -2252,14 +2266,20 @@ static void do_bottom_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pDa
   } else {
     int32_t i = 0;
     
-    if (((type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) && val.i64 < pList[0]->v.i64) ||
+    if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i64 < pList[0]->v.i64) ||
-        ((type >= TSDB_DATA_TYPE_FLOAT && type <= TSDB_DATA_TYPE_DOUBLE) && val.dKey < pList[0]->v.dKey)) {
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 < pList[0]->v.u64) ||
+        (IS_FLOAT_TYPE(type) && val.dKey < pList[0]->v.dKey)) {
       // find the appropriate the slot position
-      if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_BIGINT) {
+      if (IS_SIGNED_NUMERIC_TYPE(type)) {
         while (i + 1 < maxLen && pList[i + 1]->v.i64 > val.i64) {
           VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
           i += 1;
         }
+      } if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+        while (i + 1 < maxLen && pList[i + 1]->v.u64 > val.u64) {
+          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
+          i += 1;
+        }
       } else {
         while (i + 1 < maxLen && pList[i + 1]->v.dKey > val.dKey) {
           VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
@@ -2289,19 +2309,24 @@ static int32_t resDataAscComparFn(const void *pLeft, const void *pRight) {
   tValuePair *pLeftElem = *(tValuePair **)pLeft;
   tValuePair *pRightElem = *(tValuePair **)pRight;
   
-  int32_t type = pLeftElem->v.nType;
+  if (IS_FLOAT_TYPE(pLeftElem->v.nType)) {
-  if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) {
     if (pLeftElem->v.dKey == pRightElem->v.dKey) {
       return 0;
     } else {
       return pLeftElem->v.dKey > pRightElem->v.dKey ? 1 : -1;
     }
-  } else {
+  } else if (IS_SIGNED_NUMERIC_TYPE(pLeftElem->v.nType)){
     if (pLeftElem->v.i64 == pRightElem->v.i64) {
       return 0;
     } else {
       return pLeftElem->v.i64 > pRightElem->v.i64 ? 1 : -1;
     }
+  } else {
+    if (pLeftElem->v.u64 == pRightElem->v.u64) {
+      return 0;
+    } else {
+      return pLeftElem->v.u64 > pRightElem->v.u64 ? 1 : -1;
+    }
   }
 }
 
@@ -3034,17 +3059,17 @@ static void leastsquares_function(SQLFunctionCtx *pCtx) {
         numOfElem++;
       }
       break;
-    };
+    }
     case TSDB_DATA_TYPE_BIGINT: {
       int64_t *p = pData;
       LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
       break;
-    };
+    }
     case TSDB_DATA_TYPE_DOUBLE: {
       double *p = pData;
       LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
       break;
-    };
+    }
     case TSDB_DATA_TYPE_FLOAT: {
       float *p = pData;
       LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
@@ -3054,12 +3079,32 @@ static void leastsquares_function(SQLFunctionCtx *pCtx) {
       int16_t *p = pData;
       LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
       break;
-    };
+    }
     case TSDB_DATA_TYPE_TINYINT: {
       int8_t *p = pData;
       LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
       break;
-    };
+    }
+    case TSDB_DATA_TYPE_UTINYINT: {
+      uint8_t *p = pData;
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
+      break;
+    }
+    case TSDB_DATA_TYPE_USMALLINT: {
+      uint16_t *p = pData;
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
+      break;
+    }
+    case TSDB_DATA_TYPE_UINT: {
+      uint32_t *p = pData;
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
+      break;
+    }
+    case TSDB_DATA_TYPE_UBIGINT: {
+      uint64_t *p = pData;
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].dKey);
+      break;
+    }
   }
   
   pInfo->startVal = x;
@@ -3956,6 +4001,58 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t index, int32_t si
       }
       break;
     }
+    case TSDB_DATA_TYPE_UTINYINT: {
+      uint8_t *val = (uint8_t*) GET_INPUT_DATA(pCtx, 0);
+      for (; i < size && i >= 0; i += step) {
+        if (pCtx->hasNull && isNull((const char*) &val[i], pCtx->inputType)) {
+          continue;
+        }
+
+        SPoint1 st = {.key = tsList[i], .val = val[i]};
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
+        pInfo->p = st;
+      }
+      break;
+    }
+    case TSDB_DATA_TYPE_USMALLINT: {
+      uint16_t *val = (uint16_t*) GET_INPUT_DATA(pCtx, 0);
+      for (; i < size && i >= 0; i += step) {
+        if (pCtx->hasNull && isNull((const char*) &val[i], pCtx->inputType)) {
+          continue;
+        }
+
+        SPoint1 st = {.key = tsList[i], .val = val[i]};
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
+        pInfo->p = st;
+      }
+      break;
+    }
+    case TSDB_DATA_TYPE_UINT: {
+      uint32_t *val = (uint32_t*) GET_INPUT_DATA(pCtx, 0);
+      for (; i < size && i >= 0; i += step) {
+        if (pCtx->hasNull && isNull((const char*) &val[i], pCtx->inputType)) {
+          continue;
+        }
+
+        SPoint1 st = {.key = tsList[i], .val = val[i]};
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
+        pInfo->p = st;
+      }
+      break;
+    }
+    case TSDB_DATA_TYPE_UBIGINT: {
+      uint64_t *val = (uint64_t*) GET_INPUT_DATA(pCtx, 0);
+      for (; i < size && i >= 0; i += step) {
+        if (pCtx->hasNull && isNull((const char*) &val[i], pCtx->inputType)) {
+          continue;
+        }
+
+        SPoint1 st = {.key = tsList[i], .val = (double) val[i]};
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
+        pInfo->p = st;
+      }
+      break;
+    }
     default: assert(0);
   }
 

src/query/src/qParserImpl.c

@@ -413,7 +413,55 @@ void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType)
   } else {
     pField->bytes = pType->bytes;
   }
+}
 
+static int32_t tryParseNameTwoParts(SStrToken *type) {
+  int32_t t = -1;
+
+  char* str = strndup(type->z, type->n);
+  if (str == NULL) {
+    return t;
+  }
+
+  char* p = strtok(str, " ");
+  if (p == NULL) {
+    tfree(str);
+    return t;
+  } else {
+    char* unsign = strtok(NULL, " ");
+    if (unsign == NULL) {
+      tfree(str);
+      return t;
+    }
+
+    if (strncasecmp(unsign, "UNSIGNED", 8) == 0) {
+      for(int32_t j = TSDB_DATA_TYPE_TINYINT; j <= TSDB_DATA_TYPE_BIGINT; ++j) {
+        if (strcasecmp(p, tDataTypes[j].name) == 0) {
+          t = j;
+          break;
+        }
+      }
+
+      tfree(str);
+
+      if (t == -1) {
+        return -1;
+      }
+
+      switch(t) {
+        case TSDB_DATA_TYPE_TINYINT:  return TSDB_DATA_TYPE_UTINYINT;
+        case TSDB_DATA_TYPE_SMALLINT: return TSDB_DATA_TYPE_USMALLINT;
+        case TSDB_DATA_TYPE_INT:      return TSDB_DATA_TYPE_UINT;
+        case TSDB_DATA_TYPE_BIGINT:   return TSDB_DATA_TYPE_UBIGINT;
+        default:
+          return -1;
+      }
+
+    } else {
+      tfree(str);
+      return -1;
+    }
+  }
 }
 
 void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
@@ -431,8 +479,12 @@ void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
     i += 1;
   }
 
+  // no qualified data type found, try unsigned data type
   if (i == tListLen(tDataTypes)) {
-    return;
+    i = tryParseNameTwoParts(type);
+    if (i == -1) {
+      return;
+    }
   }
 
   pField->type = i;

src/util/src/tcompare.c

@@ -297,32 +297,14 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
   __compar_fn_t comparFn = NULL;
   
   switch (type) {
-    case TSDB_DATA_TYPE_SMALLINT: {
-      comparFn = compareInt16Val;  break;
-    }
-    
-    case TSDB_DATA_TYPE_INT: {
-      comparFn = compareInt32Val;  break;
-    }
-    
-    case TSDB_DATA_TYPE_BIGINT:
-    case TSDB_DATA_TYPE_TIMESTAMP: {
-      comparFn = compareInt64Val;  break;
-    }
-
     case TSDB_DATA_TYPE_BOOL:
-    case TSDB_DATA_TYPE_TINYINT:{
+    case TSDB_DATA_TYPE_TINYINT:   comparFn = compareInt8Val;   break;
-      comparFn = compareInt8Val;   break;
+    case TSDB_DATA_TYPE_SMALLINT:  comparFn = compareInt16Val;  break;
-    }
+    case TSDB_DATA_TYPE_INT:       comparFn = compareInt32Val;  break;
-
+    case TSDB_DATA_TYPE_BIGINT:
-    case TSDB_DATA_TYPE_FLOAT: {
+    case TSDB_DATA_TYPE_TIMESTAMP: comparFn = compareInt64Val;  break;
-      comparFn = compareFloatVal;  break;
+    case TSDB_DATA_TYPE_FLOAT:     comparFn = compareFloatVal;  break;
-    }
+    case TSDB_DATA_TYPE_DOUBLE:    comparFn = compareDoubleVal; break;
-    
-    case TSDB_DATA_TYPE_DOUBLE: {
-      comparFn = compareDoubleVal; break;
-    }
-
     case TSDB_DATA_TYPE_BINARY: {
       if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
         comparFn = compareStrPatternComp;
@@ -341,10 +323,14 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
       } else {
         comparFn = compareLenPrefixedWStr;
       }
-    
       break;
     }
-    
+
+    case TSDB_DATA_TYPE_UTINYINT:  comparFn = compareUint8Val; break;
+    case TSDB_DATA_TYPE_USMALLINT: comparFn = compareUint16Val;break;
+    case TSDB_DATA_TYPE_UINT:      comparFn = compareUint32Val;break;
+    case TSDB_DATA_TYPE_UBIGINT:   comparFn = compareUint64Val;break;
+
     default:
       comparFn = compareInt32Val;
       break;