add delete

src/client/inc/tscDelete.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_TSCDELETE_H
+#define TDENGINE_TSCDELETE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "qTableMeta.h"
+
+int32_t executeDelete(SSqlObj* pSql, SQueryInfo* pQueryInfo);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_TSCDELETE_H

src/client/inc/tscSubquery.h

@@ -54,7 +54,7 @@ void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
 
 void tscFreeRetrieveSup(void **param);
 
-
+SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj, int32_t cmd, __async_cb_func_t fp);
 
 #ifdef __cplusplus
 }

src/client/src/tscDelete.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "tcmdtype.h"
+#include "tscLog.h"
+#include "tscUtil.h"
+#include "tsclient.h"
+#include "tscDelete.h"
+
+int32_t executeDelete(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
+
+  int32_t ret = TSDB_CODE_SUCCESS;
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  if(!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+    // not super table
+    pSql->cmd.active = pQueryInfo;
+    return tscBuildAndSendRequest(pSql, pQueryInfo);
+  }
+
+  //
+  // super table
+  //
+
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+  
+  // pRes->code check only serves in launching super table sub-queries
+  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+    pCmd->command = TSDB_SQL_RETRIEVE_GLOBALMERGE;  // enable the abort of kill super table function.
+    return pRes->code;
+  }
+  
+  tExtMemBuffer   **pMemoryBuf = NULL;
+  tOrderDescriptor *pDesc  = NULL;
+
+  pRes->qId = 0x1;  // hack the qhandle check
+
+  uint32_t nBufferSize = (1u << 18u);  // 256KB, default buffer size
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  SSubqueryState *pState = &pSql->subState;
+  int32_t numOfSub = (pTableMetaInfo->pVgroupTables == NULL) ? pTableMetaInfo->vgroupList->numOfVgroups
+                                                             : (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+
+  int32_t ret = doInitSubState(pSql, numOfSub);
+  if (ret != 0) {
+    tscAsyncResultOnError(pSql);
+    return ret;
+  }
+
+  ret = tscCreateGlobalMergerEnv(pQueryInfo, &pMemoryBuf, pSql->subState.numOfSub, &pDesc, &nBufferSize, pSql->self);
+  if (ret != 0) {
+    pRes->code = ret;
+    tscAsyncResultOnError(pSql);
+    tfree(pDesc);
+    tfree(pMemoryBuf);
+    return ret;
+  }
+
+  tscDebug("0x%"PRIx64" retrieved query data from %d vnode(s)", pSql->self, pState->numOfSub);
+  pRes->code = TSDB_CODE_SUCCESS;
+  
+  int32_t i = 0;
+  for (; i < pState->numOfSub; ++i) {
+    SRetrieveSupport *trs = (SRetrieveSupport *)calloc(1, sizeof(SRetrieveSupport));
+    if (trs == NULL) {
+      tscError("0x%"PRIx64" failed to malloc buffer for SRetrieveSupport, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
+      break;
+    }
+    
+    trs->pExtMemBuffer = pMemoryBuf;
+    trs->pOrderDescriptor = pDesc;
+
+    trs->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
+    trs->localBufferSize = nBufferSize + sizeof(tFilePage);
+    if (trs->localBuffer == NULL) {
+      tscError("0x%"PRIx64" failed to malloc buffer for local buffer, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
+      tfree(trs);
+      break;
+    }
+
+    trs->localBuffer->num = 0;
+    trs->subqueryIndex = i;
+    trs->pParentSql    = pSql;
+
+    SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
+    if (pNew == NULL) {
+      tscError("0x%"PRIx64" failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
+      tfree(trs->localBuffer);
+      tfree(trs);
+      break;
+    }
+    
+    // todo handle multi-vnode situation
+    if (pQueryInfo->tsBuf) {
+      SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
+      pNewQueryInfo->tsBuf = tsBufClone(pQueryInfo->tsBuf);
+      assert(pNewQueryInfo->tsBuf != NULL);
+    }
+    
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" create subquery success. orderOfSub:%d", pSql->self, pNew->self,
+        trs->subqueryIndex);
+  }
+  
+  if (i < pState->numOfSub) {
+    tscError("0x%"PRIx64" failed to prepare subquery structure and launch subqueries", pSql->self);
+    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    
+    tscDestroyGlobalMergerEnv(pMemoryBuf, pDesc, pState->numOfSub);
+    doCleanupSubqueries(pSql, i);
+    return pRes->code;   // free all allocated resource
+  }
+  
+  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+    tscDestroyGlobalMergerEnv(pMemoryBuf, pDesc, pState->numOfSub);
+    doCleanupSubqueries(pSql, i);
+    return pRes->code;
+  }
+
+  doConcurrentlySendSubQueries(pSql);
+
+  return TSDB_CODE_SUCCESS;
+}
\ No newline at end of file

src/client/src/tscServer.c

@@ -3380,7 +3380,7 @@ int tscBuildDelDataMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   if(UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    return buildSTableDelDataMsg(pSql, pCmd, pQueryInfo, pTableMetaInfo, pInfo);
+    return buildTableDelDataMsg(pSql, pCmd, pQueryInfo, pTableMetaInfo, pInfo);
   } else {
     return buildTableDelDataMsg(pSql, pCmd, pQueryInfo, pTableMetaInfo, pInfo);
   }
@@ -3390,6 +3390,7 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
   tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg;
   tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg;
+  tscBuildMsg[TSDB_SQL_DELETE_DATA] = tscBuildDelDataMsg;
 
   tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
   tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
@@ -3425,7 +3426,6 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg;
   tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg;
   tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg;
-  tscBuildMsg[TSDB_SQL_DELETE_DATA] = tscBuildDelDataMsg;
 
   tscProcessMsgRsp[TSDB_SQL_SELECT] = tscProcessQueryRsp;
   tscProcessMsgRsp[TSDB_SQL_FETCH] = tscProcessRetrieveRspFromNode;

src/client/src/tscSubquery.c

@@ -2716,7 +2716,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     trs->subqueryIndex = i;
     trs->pParentSql    = pSql;
 
-    SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
+    SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL, tscRetrieveDataRes, CMD_SQL_SELECT);
     if (pNew == NULL) {
       tscError("0x%"PRIx64" failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
       tfree(trs->localBuffer);
@@ -3165,12 +3165,12 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
   }
 }
 
-static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj) {
+static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj, int32_t cmd, __async_cb_func_t fp) {
   const int32_t table_index = 0;
   SSqlCmd *   pCmd = &pSql->cmd;
   SQueryInfo *pPQueryInfo = tscGetQueryInfo(pCmd); // Parent SQueryInfo
   
-  SSqlObj *pNew = createSubqueryObj(pSql, table_index, tscRetrieveDataRes, trsupport, TSDB_SQL_SELECT, prevSqlObj);
+  SSqlObj *pNew = createSubqueryObj(pSql, table_index, fp, trsupport, cmd, prevSqlObj);
   if (pNew != NULL) {  // the sub query of two-stage super table query
     SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd);
 

src/client/src/tscUtil.c

@@ -30,6 +30,7 @@
 #include "ttimer.h"
 #include "ttokendef.h"
 #include "cJSON.h"
+#include "tscDelete.h"
 
 #ifdef HTTP_EMBEDDED
 #include "httpInt.h"
@@ -4168,7 +4169,13 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
     (*pSql->fp)(pSql->param, pSql, 0);
     return;
-  }
+  } else if (pSql->cmd.command == TSDB_SQL_DELETE_DATA) {
+    code = executeDelete(pSql, pQueryInfo);
+    if (code != TSDB_CODE_SUCCESS) {
+      (*pSql->fp)(pSql->param, pSql, 0);
+    }
+    return ;
+  } 
 
   if (pSql->cmd.command == TSDB_SQL_SELECT) {
     tscAddIntoSqlList(pSql);

src/tsdb/inc/tsdbTruncate.h → src/tsdb/inc/tsdbDelete.h

@@ -12,8 +12,8 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_TSDB_TRUNCATE_H_
-#define _TD_TSDB_TRUNCATE_H_
+#ifndef _TD_TSDB_DELETE_H_
+#define _TD_TSDB_DELETE_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -38,4 +38,4 @@ int tsdbControlDelete(STsdbRepo* pRepo, SControlDataInfo* pCtlDataInfo);
 }
 #endif
 
-#endif /* _TD_TSDB_TRUNCATE_H_ */
\ No newline at end of file
+#endif /* _TD_TSDB_DELETE_H_ */
\ No newline at end of file

src/tsdb/inc/tsdbMemTable.h

@@ -16,7 +16,7 @@
 #ifndef _TD_TSDB_MEMTABLE_H_
 #define _TD_TSDB_MEMTABLE_H_
 
-#include "tsdbTruncate.h"
+#include "tsdbDelete.h"
 typedef struct {
   int   rowsInserted;
   int   rowsUpdated;

src/tsdb/inc/tsdbint.h

@@ -66,8 +66,8 @@ extern "C" {
 #include "tsdbCommit.h"
 // Compact
 #include "tsdbCompact.h"
-// Truncate
-#include "tsdbTruncate.h"
+// Delete
+#include "tsdbDelete.h"
 // Commit Queue
 #include "tsdbCommitQueue.h"