From fcbe6c154d98f2d747dabd1e73e1895d4f69bcbf Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Sat, 27 Jun 2020 21:10:15 -0700
Subject: [PATCH 01/87] Adjusted crash_gen to examine returned error codes

---
 tests/pytest/crash_gen.py | 192 +++++++++++++++++++++++++++++---------
 1 file changed, 147 insertions(+), 45 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 916e8904ff..94ad63697c 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -78,13 +78,22 @@ class WorkerThread:
         if ( gConfig.per_thread_db_connection ): # type: ignore
             self._dbConn = DbConn()   
 
+        self._dbInUse = False # if "use db" was executed already
+
     def logDebug(self, msg):
         logger.debug("    TRD[{}] {}".format(self._tid, msg))
 
     def logInfo(self, msg):
         logger.info("    TRD[{}] {}".format(self._tid, msg))
 
-   
+    def dbInUse(self):
+        return self._dbInUse
+
+    def useDb(self):
+        if ( not self._dbInUse ):
+            self.execSql("use db")
+        self._dbInUse = True
+
     def getTaskExecutor(self):
         return self._tc.getTaskExecutor()     
 
@@ -118,12 +127,17 @@ class WorkerThread:
                 logger.debug("[TRD] Thread Coordinator not running any more, worker thread now stopping...")
                 break
 
+            # Fetch a task from the Thread Coordinator
             logger.debug("[TRD] Worker thread [{}] about to fetch task".format(self._tid))
             task = tc.fetchTask()
+
+            # Execute such a task
             logger.debug("[TRD] Worker thread [{}] about to execute task: {}".format(self._tid, task.__class__.__name__))
             task.execute(self)
             tc.saveExecutedTask(task)
             logger.debug("[TRD] Worker thread [{}] finished executing task".format(self._tid))
+
+            self._dbInUse = False # there may be changes between steps
   
     def verifyThreadSelf(self): # ensure we are called by this own thread
         if ( threading.get_ident() != self._thread.ident ): 
@@ -163,6 +177,18 @@ class WorkerThread:
         else:
             return self._tc.getDbManager().getDbConn().execute(sql)
 
+    def querySql(self, sql): # TODO: expose DbConn directly
+        if ( gConfig.per_thread_db_connection ):
+            return self._dbConn.query(sql)            
+        else:
+            return self._tc.getDbManager().getDbConn().query(sql)
+
+    def getQueryResult(self):
+        if ( gConfig.per_thread_db_connection ):
+            return self._dbConn.getQueryResult()       
+        else:
+            return self._tc.getDbManager().getDbConn().getQueryResult()
+
     def getDbConn(self):
         if ( gConfig.per_thread_db_connection ):
             return self._dbConn     
@@ -176,7 +202,7 @@ class WorkerThread:
     #         return self._tc.getDbState().getDbConn().query(sql)
 
 class ThreadCoordinator:
-    def __init__(self, pool, dbManager):
+    def __init__(self, pool: ThreadPool, dbManager):
         self._curStep = -1 # first step is 0
         self._pool = pool
         # self._wd = wd
@@ -216,7 +242,16 @@ class ThreadCoordinator:
 
             # At this point, all threads should be pass the overall "barrier" and before the per-thread "gate"
             try:
-                self._dbManager.getStateMachine().transition(self._executedTasks) # at end of step, transiton the DB state
+                sm = self._dbManager.getStateMachine()
+                logger.debug("[STT] starting transitions")
+                sm.transition(self._executedTasks) # at end of step, transiton the DB state
+                logger.debug("[STT] transition ended")
+                if sm.hasDatabase() :
+                    for t in self._pool.threadList:
+                        logger.debug("[DB] use db for all worker threads")
+                        t.useDb()
+                        # t.execSql("use db") # main thread executing "use db" on behalf of every worker thread
+
             except taos.error.ProgrammingError as err:
                 if ( err.msg == 'network unavailable' ): # broken DB connection
                     logger.info("DB connection broken, execution failed")
@@ -268,7 +303,7 @@ class ThreadCoordinator:
                 wakeSeq.append(i)
             else:
                 wakeSeq.insert(0, i)
-        logger.debug("[TRD] Main thread waking up worker thread: {}".format(str(wakeSeq)))
+        logger.debug("[TRD] Main thread waking up worker threads: {}".format(str(wakeSeq)))
         # TODO: set dice seed to a deterministic value
         for i in wakeSeq:
             self._pool.threadList[i].tapStepGate() # TODO: maybe a bit too deep?!
@@ -306,7 +341,7 @@ class ThreadPool:
         self.maxSteps = maxSteps
         # Internal class variables
         self.curStep = 0
-        self.threadList = []
+        self.threadList = [] # type: List[WorkerThread]
         
     # starting to run all the threads, in locking steps
     def createAndStartThreads(self, tc: ThreadCoordinator):
@@ -412,7 +447,7 @@ class DbConn:
 
         # Get the connection/cursor ready
         self._cursor.execute('reset query cache')
-        # self._cursor.execute('use db') # note we do this in _findCurrenState
+        # self._cursor.execute('use db') # do this at the beginning of every step
 
         # Open connection
         self._tdSql = TDSql()
@@ -450,7 +485,7 @@ class DbConn:
             raise RuntimeError("Cannot query database until connection is open")
         logger.debug("[SQL] Executing SQL: {}".format(sql))
         nRows = self._tdSql.query(sql)
-        logger.debug("[SQL] Execution Result, nRows = {}, SQL = {}".format(nRows, sql))
+        logger.debug("[SQL] Query Result, nRows = {}, SQL = {}".format(nRows, sql))
         return nRows
         # results are in: return self._tdSql.queryResult
 
@@ -620,10 +655,10 @@ class StateDbOnly(AnyState):
             # self.assertHasTask(tasks, DropDbTask) # implied by hasSuccess
             # self.assertAtMostOneSuccess(tasks, DropDbTask)
             # self._state = self.STATE_EMPTY
-        if ( self.hasSuccess(tasks, TaskCreateSuperTable) ): # did not drop db, create table success
-            # self.assertHasTask(tasks, CreateFixedTableTask) # tried to create table
-            if ( not self.hasTask(tasks, TaskDropSuperTable) ): 
-                self.assertAtMostOneSuccess(tasks, TaskCreateSuperTable) # at most 1 attempt is successful, if we don't drop anything
+        # if ( self.hasSuccess(tasks, TaskCreateSuperTable) ): # did not drop db, create table success
+        #     # self.assertHasTask(tasks, CreateFixedTableTask) # tried to create table
+        #     if ( not self.hasTask(tasks, TaskDropSuperTable) ): 
+        #         self.assertAtMostOneSuccess(tasks, TaskCreateSuperTable) # at most 1 attempt is successful, if we don't drop anything
             # self.assertNoTask(tasks, DropDbTask) # should have have tried
             # if ( not self.hasSuccess(tasks, AddFixedDataTask) ): # just created table, no data yet
             #     # can't say there's add-data attempts, since they may all fail
@@ -648,7 +683,9 @@ class StateSuperTableOnly(AnyState):
 
     def verifyTasksToState(self, tasks, newState):
         if ( self.hasSuccess(tasks, TaskDropSuperTable) ): # we are able to drop the table
-            self.assertAtMostOneSuccess(tasks, TaskDropSuperTable)
+            #self.assertAtMostOneSuccess(tasks, TaskDropSuperTable)
+            self.hasSuccess(tasks, TaskCreateSuperTable) # we must have had recreted it
+
             # self._state = self.STATE_DB_ONLY
         # elif ( self.hasSuccess(tasks, AddFixedDataTask) ): # no success dropping the table, but added data
         #     self.assertNoTask(tasks, DropFixedTableTask) # not true in massively parrallel cases
@@ -692,7 +729,7 @@ class StateHasData(AnyState):
                 self.assertNoTask(tasks, TaskDropSuperTable) # we should not have a task that drops it            
             # self.assertIfExistThenSuccess(tasks, ReadFixedDataTask)
 
-class StateMechine :
+class StateMechine:
     def __init__(self, dbConn):
         self._dbConn = dbConn
         self._curState = self._findCurrentState() # starting state
@@ -701,8 +738,17 @@ class StateMechine :
     def getCurrentState(self):
         return self._curState
 
+    def hasDatabase(self):
+        return self._curState.canDropDb()  # ha, can drop DB means it has one
+
     # May be slow, use cautionsly...
     def getTaskTypes(self): # those that can run (directly/indirectly) from the current state
+        def typesToStrings(types):
+            ss = []
+            for t in types:
+                ss.append(t.__name__)
+            return ss
+
         allTaskClasses = StateTransitionTask.__subclasses__() # all state transition tasks
         firstTaskTypes = []
         for tc in allTaskClasses:
@@ -721,7 +767,7 @@ class StateMechine :
 
         if len(taskTypes) <= 0:
             raise RuntimeError("No suitable task types found for state: {}".format(self._curState))   
-        logger.debug("[OPS] Tasks found for state {}: {}".format(self._curState, taskTypes))     
+        logger.debug("[OPS] Tasks found for state {}: {}".format(self._curState, typesToStrings(taskTypes)))     
         return taskTypes
 
     def _findCurrentState(self):
@@ -731,7 +777,7 @@ class StateMechine :
             # logger.debug("Found EMPTY state")
             logger.debug("[STT] empty database found, between {} and {}".format(ts, time.time()))
             return StateEmpty()
-        dbc.execute("use db") # did not do this when openning connection
+        dbc.execute("use db") # did not do this when openning connection, and this is NOT the worker thread, which does this on their own
         if dbc.query("show tables") == 0 : # no tables
             # logger.debug("Found DB ONLY state")
             logger.debug("[STT] DB_ONLY found, between {} and {}".format(ts, time.time()))
@@ -747,6 +793,7 @@ class StateMechine :
 
     def transition(self, tasks):
         if ( len(tasks) == 0 ): # before 1st step, or otherwise empty
+            logger.debug("[STT] Starting State: {}".format(self._curState))
             return # do nothing
 
         self._dbConn.execute("show dnodes") # this should show up in the server log, separating steps
@@ -830,7 +877,7 @@ class DbManager():
     def getDbConn(self):
         return self._dbConn
 
-    def getStateMachine(self):
+    def getStateMachine(self) -> StateMechine :
         return self._stateMachine
 
     # def getState(self):
@@ -931,6 +978,7 @@ class Task():
         # logger.debug("Creating new task {}...".format(self._taskNum))
 
         self._execStats = execStats
+        self._lastSql = "" # last SQL executed/attempted
 
     def isSuccess(self):
         return self._err == None
@@ -961,10 +1009,16 @@ class Task():
         try:
             self._executeInternal(te, wt) # TODO: no return value?
         except taos.error.ProgrammingError as err:
-            self.logDebug("[=] Taos library exception: errno={:X}, msg: {}".format(err.errno, err))
-            self._err = err           
+            errno2 = 0x80000000 + err.errno # positive error number
+            if ( errno2 in [0x200, 0x360, 0x362, 0x381, 0x380, 0x600 ]) : # allowed errors
+                self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
+                print("e", end="", flush=True)
+                self._err = err  
+            else:
+                self.logDebug("[=] Unexpected Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
+                raise
         except:
-            self.logDebug("[=] Unexpected exception")
+            self.logDebug("[=] Unexpected exception, SQL: {}".format(self._lastSql))
             raise
         self._execStats.endTaskType(self.__class__.__name__, self.isSuccess())
         
@@ -972,8 +1026,21 @@ class Task():
         self._execStats.incExecCount(self.__class__.__name__, self.isSuccess()) # TODO: merge with above.
 
     def execSql(self, sql):
+        self._lastSql = sql
         return self._dbManager.execute(sql)
 
+    def execWtSql(self, wt: WorkerThread, sql): # execute an SQL on the worker thread
+        self._lastSql = sql
+        return wt.execSql(sql)
+
+    def queryWtSql(self, wt: WorkerThread, sql): # execute an SQL on the worker thread
+        self._lastSql = sql
+        return wt.querySql(sql)
+
+    def getQueryResult(self, wt: WorkerThread): # execute an SQL on the worker thread
+        return wt.getQueryResult()
+
+
                   
 class ExecutionStats:
     def __init__(self):
@@ -1039,6 +1106,11 @@ class ExecutionStats:
 
 
 class StateTransitionTask(Task):
+    LARGE_NUMBER_OF_TABLES = 35
+    SMALL_NUMBER_OF_TABLES = 3
+    LARGE_NUMBER_OF_RECORDS = 50
+    SMALL_NUMBER_OF_RECORDS = 3
+
     @classmethod
     def getInfo(cls): # each sub class should supply their own information
         raise RuntimeError("Overriding method expected")
@@ -1061,6 +1133,10 @@ class StateTransitionTask(Task):
         # return state.getValue() in cls.getBeginStates()
         raise RuntimeError("must be overriden")
 
+    @classmethod
+    def getRegTableName(cls, i):
+        return "db.reg_table_{}".format(i)
+
     def execute(self, wt: WorkerThread):
         super().execute(wt)
         
@@ -1074,7 +1150,7 @@ class TaskCreateDb(StateTransitionTask):
         return state.canCreateDb()
 
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
-        wt.execSql("create database db")       
+        self.execWtSql(wt, "create database db")       
 
 class TaskDropDb(StateTransitionTask):
     @classmethod
@@ -1086,7 +1162,7 @@ class TaskDropDb(StateTransitionTask):
         return state.canDropDb()
 
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
-        wt.execSql("drop database db")
+        self.execWtSql(wt, "drop database db")
         logger.debug("[OPS] database dropped at {}".format(time.time()))
 
 class TaskCreateSuperTable(StateTransitionTask):
@@ -1099,8 +1175,13 @@ class TaskCreateSuperTable(StateTransitionTask):
         return state.canCreateFixedSuperTable()
 
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
-        tblName = self._dbManager.getFixedSuperTableName()        
-        wt.execSql("create table db.{} (ts timestamp, speed int) tags (b binary(200), f float) ".format(tblName))
+        if not wt.dbInUse(): # no DB yet, to the best of our knowledge
+            logger.debug("Skipping task, no DB yet")
+            return
+
+        tblName = self._dbManager.getFixedSuperTableName()   
+        # wt.execSql("use db")    # should always be in place
+        self.execWtSql(wt, "create table db.{} (ts timestamp, speed int) tags (b binary(200), f float) ".format(tblName))
         # No need to create the regular tables, INSERT will do that automatically
 
 
@@ -1115,16 +1196,16 @@ class TaskReadData(StateTransitionTask):
 
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
         sTbName = self._dbManager.getFixedSuperTableName()        
-        dbc = wt.getDbConn()
-        dbc.query("select TBNAME from db.{}".format(sTbName)) # TODO: analyze result set later
+        self.queryWtSql(wt, "select TBNAME from db.{}".format(sTbName)) # TODO: analyze result set later
+
         if random.randrange(5) == 0 : # 1 in 5 chance, simulate a broken connection. TODO: break connection in all situations
-            dbc.close()
-            dbc.open()
+            wt.getDbConn().close()
+            wt.getDbConn().open()
         else:
-            rTables = dbc.getQueryResult()
+            rTables = self.getQueryResult(wt) # wt.getDbConn().getQueryResult()
             # print("rTables[0] = {}, type = {}".format(rTables[0], type(rTables[0])))
             for rTbName in rTables : # regular tables
-                dbc.query("select * from db.{}".format(rTbName[0])) # TODO: check success failure
+                self.execWtSql(wt, "select * from db.{}".format(rTbName[0]))
 
         # tdSql.query(" cars where tbname in ('carzero', 'carone')")
 
@@ -1138,8 +1219,31 @@ class TaskDropSuperTable(StateTransitionTask):
         return state.canDropFixedSuperTable()
 
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
-        tblName = self._dbManager.getFixedSuperTableName()        
-        wt.execSql("drop table db.{}".format(tblName))
+        # 1/2 chance, we'll drop the regular tables one by one, in a randomized sequence
+        if Dice.throw(2) == 0 : 
+            tblSeq = list(range(2 + (self.LARGE_NUMBER_OF_TABLES if gConfig.larger_data else self.SMALL_NUMBER_OF_TABLES))) 
+            random.shuffle(tblSeq) 
+            tickOutput = False # if we have spitted out a "d" character for "drop regular table"
+            for i in tblSeq: 
+                regTableName = self.getRegTableName(i); # "db.reg_table_{}".format(i)  
+                try:
+                    nRows = self.execWtSql(wt, "drop table {}".format(regTableName))  
+                except taos.error.ProgrammingError as err:
+                    errno2 = 0x80000000 + err.errno # positive error number
+                    if ( errno2 in [0x362]) : # allowed errors
+                        logger.debug("[DB] Acceptable error when dropping a table")
+                    continue
+
+                if (not tickOutput):
+                    tickOutput = True # Print only one time
+                    if nRows >= 1 :
+                        print("d", end="", flush=True)
+                    else:
+                        print("f({})".format(nRows), end="", flush=True)                    
+
+        # Drop the super table itself
+        tblName = self._dbManager.getFixedSuperTableName()     
+        self.execWtSql(wt, "drop table db.{}".format(tblName))
 
 class TaskAlterTags(StateTransitionTask):
     @classmethod
@@ -1154,20 +1258,18 @@ class TaskAlterTags(StateTransitionTask):
         tblName = self._dbManager.getFixedSuperTableName()   
         dice = Dice.throw(4)
         if dice == 0 :
-            wt.execSql("alter table db.{} add tag extraTag int".format(tblName))
+            sql = "alter table db.{} add tag extraTag int".format(tblName)
         elif dice == 1 :
-            wt.execSql("alter table db.{} drop tag extraTag".format(tblName))
+            sql = "alter table db.{} drop tag extraTag".format(tblName)
         elif dice == 2 :
-            wt.execSql("alter table db.{} drop tag newTag".format(tblName))
+            sql = "alter table db.{} drop tag newTag".format(tblName)
         else: # dice == 3
-            wt.execSql("alter table db.{} change tag extraTag newTag".format(tblName))
+            sql = "alter table db.{} change tag extraTag newTag".format(tblName)
+
+        self.execWtSql(wt, sql)
 
 class TaskAddData(StateTransitionTask):
     activeTable : Set[int] = set() # Track which table is being actively worked on
-    LARGE_NUMBER_OF_TABLES = 35
-    SMALL_NUMBER_OF_TABLES = 3
-    LARGE_NUMBER_OF_RECORDS = 50
-    SMALL_NUMBER_OF_RECORDS = 3
 
     # We use these two files to record operations to DB, useful for power-off tests
     fAddLogReady = None
@@ -1193,7 +1295,7 @@ class TaskAddData(StateTransitionTask):
         
     def _executeInternal(self, te: TaskExecutor, wt: WorkerThread):
         ds = self._dbManager
-        wt.execSql("use db") # TODO: seems to be an INSERT bug to require this
+        # wt.execSql("use db") # TODO: seems to be an INSERT bug to require this
         tblSeq = list(range(self.LARGE_NUMBER_OF_TABLES if gConfig.larger_data else self.SMALL_NUMBER_OF_TABLES)) 
         random.shuffle(tblSeq) 
         for i in tblSeq: 
@@ -1203,10 +1305,10 @@ class TaskAddData(StateTransitionTask):
                 print("x", end="", flush=True)
             else:
                 self.activeTable.add(i) # marking it active
-            # No need to shuffle data sequence, unless later we decide to do non-increment insertion            
+            # No need to shuffle data sequence, unless later we decide to do non-increment insertion      
+            regTableName = self.getRegTableName(i); # "db.reg_table_{}".format(i)      
             for j in range(self.LARGE_NUMBER_OF_RECORDS if gConfig.larger_data else self.SMALL_NUMBER_OF_RECORDS) : # number of records per table
-                nextInt = ds.getNextInt()
-                regTableName = "db.reg_table_{}".format(i)
+                nextInt = ds.getNextInt()                
                 if gConfig.record_ops:
                     self.prepToRecordOps()
                     self.fAddLogReady.write("Ready to write {} to {}\n".format(nextInt, regTableName))
@@ -1217,7 +1319,7 @@ class TaskAddData(StateTransitionTask):
                     ds.getFixedSuperTableName(), 
                     ds.getNextBinary(), ds.getNextFloat(),
                     ds.getNextTick(), nextInt)
-                wt.execSql(sql) 
+                self.execWtSql(wt, sql) 
                 if gConfig.record_ops:
                     self.fAddLogDone.write("Wrote {} to {}\n".format(nextInt, regTableName))
                     self.fAddLogDone.flush()
@@ -1390,7 +1492,7 @@ def main():
     # if len(sys.argv) == 1:
     #     parser.print_help()
     #     sys.exit()
-
+ 
     global logger
     logger = logging.getLogger('CrashGen')
     logger.addFilter(LoggingFilter())

From b251dadab4e2225900f1d576e710eca380782d0f Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Sat, 27 Jun 2020 21:23:53 -0700
Subject: [PATCH 02/87] Revert "revert crash_gen.py"

This reverts commit abb55ed0744dfe7a8cb7575af07b756e463bfa74.
---
 tests/pytest/crash_gen.py | 137 +++++++++++++++++++++-----------------
 1 file changed, 75 insertions(+), 62 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index cc41fd5e7d..916e8904ff 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -686,7 +686,8 @@ class StateHasData(AnyState):
             self.assertNoTask(tasks, TaskAddData)
             # self.hasSuccess(tasks, DeleteDataTasks)
         else: # should be STATE_HAS_DATA
-            self.assertNoTask(tasks, TaskDropDb)
+            if (not self.hasTask(tasks, TaskCreateDb) ): # only if we didn't create one
+                self.assertNoTask(tasks, TaskDropDb) # we shouldn't have dropped it
             if (not self.hasTask(tasks, TaskCreateSuperTable)) :  # if we didn't create the table
                 self.assertNoTask(tasks, TaskDropSuperTable) # we should not have a task that drops it            
             # self.assertIfExistThenSuccess(tasks, ReadFixedDataTask)
@@ -1295,7 +1296,67 @@ class LoggingFilter(logging.Filter):
         #     return False
         return True
 
+class MainExec:
+    @classmethod
+    def runClient(cls):
+        # resetDb = False # DEBUG only
+        # dbState = DbState(resetDb)  # DBEUG only!
+        dbManager = DbManager() # Regular function
+        Dice.seed(0) # initial seeding of dice
+        thPool = ThreadPool(gConfig.num_threads, gConfig.max_steps)
+        tc = ThreadCoordinator(thPool, dbManager)
         
+        tc.run()
+        tc.logStats()
+        dbManager.cleanUp()    
+
+    @classmethod
+    def runService(cls):
+        print("Running service...")
+
+    @classmethod
+    def runTemp(cls): # for debugging purposes
+        # # Hack to exercise reading from disk, imcreasing coverage. TODO: fix
+        # dbc = dbState.getDbConn()
+        # sTbName = dbState.getFixedSuperTableName()   
+        # dbc.execute("create database if not exists db")
+        # if not dbState.getState().equals(StateEmpty()):
+        #     dbc.execute("use db")     
+
+        # rTables = None
+        # try: # the super table may not exist
+        #     sql = "select TBNAME from db.{}".format(sTbName)
+        #     logger.info("Finding out tables in super table: {}".format(sql))
+        #     dbc.query(sql) # TODO: analyze result set later
+        #     logger.info("Fetching result")
+        #     rTables = dbc.getQueryResult()
+        #     logger.info("Result: {}".format(rTables))
+        # except taos.error.ProgrammingError as err:
+        #     logger.info("Initial Super table OPS error: {}".format(err))
+        
+        # # sys.exit()
+        # if ( not rTables == None):
+        #     # print("rTables[0] = {}, type = {}".format(rTables[0], type(rTables[0])))
+        #     try:
+        #         for rTbName in rTables : # regular tables
+        #             ds = dbState
+        #             logger.info("Inserting into table: {}".format(rTbName[0]))
+        #             sql = "insert into db.{} values ('{}', {});".format(
+        #                 rTbName[0],                    
+        #                 ds.getNextTick(), ds.getNextInt())
+        #             dbc.execute(sql)
+        #         for rTbName in rTables : # regular tables        
+        #             dbc.query("select * from db.{}".format(rTbName[0])) # TODO: check success failure
+        #         logger.info("Initial READING operation is successful")       
+        #     except taos.error.ProgrammingError as err:
+        #         logger.info("Initial WRITE/READ error: {}".format(err))   
+        
+        # Sandbox testing code
+        # dbc = dbState.getDbConn()
+        # while True:
+        #     rows = dbc.query("show databases") 
+        #     print("Rows: {}, time={}".format(rows, time.time()))
+        return 
 
 def main():
     # Super cool Python argument library: https://docs.python.org/3/library/argparse.html
@@ -1308,24 +1369,27 @@ def main():
             2. You run the server there before this script: ./build/bin/taosd -c test/cfg
 
             '''))
+
     parser.add_argument('-d', '--debug', action='store_true',                        
                         help='Turn on DEBUG mode for more logging (default: false)')
+    parser.add_argument('-e', '--run-tdengine', action='store_true',                        
+                        help='Run TDengine service in foreground (default: false)')
     parser.add_argument('-l', '--larger-data', action='store_true',                        
                         help='Write larger amount of data during write operations (default: false)')
-    parser.add_argument('-p', '--per-thread-db-connection', action='store_true',                        
+    parser.add_argument('-p', '--per-thread-db-connection', action='store_false',                        
                         help='Use a single shared db connection (default: false)')
     parser.add_argument('-r', '--record-ops', action='store_true',                        
                         help='Use a pair of always-fsynced fils to record operations performing + performed, for power-off tests (default: false)')                    
-    parser.add_argument('-s', '--max-steps', action='store', default=100, type=int,
+    parser.add_argument('-s', '--max-steps', action='store', default=1000, type=int,
                         help='Maximum number of steps to run (default: 100)')
-    parser.add_argument('-t', '--num-threads', action='store', default=10, type=int,
+    parser.add_argument('-t', '--num-threads', action='store', default=5, type=int,
                         help='Number of threads to run (default: 10)')
 
     global gConfig
     gConfig = parser.parse_args()
-    if len(sys.argv) == 1:
-        parser.print_help()
-        sys.exit()
+    # if len(sys.argv) == 1:
+    #     parser.print_help()
+    #     sys.exit()
 
     global logger
     logger = logging.getLogger('CrashGen')
@@ -1337,62 +1401,11 @@ def main():
     ch = logging.StreamHandler()
     logger.addHandler(ch)
 
-    # resetDb = False # DEBUG only
-    # dbState = DbState(resetDb)  # DBEUG only!
-    dbManager = DbManager() # Regular function
-    Dice.seed(0) # initial seeding of dice
-    tc = ThreadCoordinator(
-        ThreadPool(gConfig.num_threads, gConfig.max_steps), 
-        # WorkDispatcher(dbState), # Obsolete?
-        dbManager
-        )
+    if gConfig.run_tdengine : # run server
+        MainExec.runService()
+    else :
+        MainExec.runClient()
 
-    # # Hack to exercise reading from disk, imcreasing coverage. TODO: fix
-    # dbc = dbState.getDbConn()
-    # sTbName = dbState.getFixedSuperTableName()   
-    # dbc.execute("create database if not exists db")
-    # if not dbState.getState().equals(StateEmpty()):
-    #     dbc.execute("use db")     
-
-    # rTables = None
-    # try: # the super table may not exist
-    #     sql = "select TBNAME from db.{}".format(sTbName)
-    #     logger.info("Finding out tables in super table: {}".format(sql))
-    #     dbc.query(sql) # TODO: analyze result set later
-    #     logger.info("Fetching result")
-    #     rTables = dbc.getQueryResult()
-    #     logger.info("Result: {}".format(rTables))
-    # except taos.error.ProgrammingError as err:
-    #     logger.info("Initial Super table OPS error: {}".format(err))
-    
-    # # sys.exit()
-    # if ( not rTables == None):
-    #     # print("rTables[0] = {}, type = {}".format(rTables[0], type(rTables[0])))
-    #     try:
-    #         for rTbName in rTables : # regular tables
-    #             ds = dbState
-    #             logger.info("Inserting into table: {}".format(rTbName[0]))
-    #             sql = "insert into db.{} values ('{}', {});".format(
-    #                 rTbName[0],                    
-    #                 ds.getNextTick(), ds.getNextInt())
-    #             dbc.execute(sql)
-    #         for rTbName in rTables : # regular tables        
-    #             dbc.query("select * from db.{}".format(rTbName[0])) # TODO: check success failure
-    #         logger.info("Initial READING operation is successful")       
-    #     except taos.error.ProgrammingError as err:
-    #         logger.info("Initial WRITE/READ error: {}".format(err))   
-    
-    
-
-    # Sandbox testing code
-    # dbc = dbState.getDbConn()
-    # while True:
-    #     rows = dbc.query("show databases") 
-    #     print("Rows: {}, time={}".format(rows, time.time()))
-    
-    tc.run()
-    tc.logStats()
-    dbManager.cleanUp()    
     
     # logger.info("Crash_Gen execution finished")
 

From 6cb97b3730cf5af306e12b620fbf54a6d0f913fc Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Sun, 28 Jun 2020 21:22:21 -0700
Subject: [PATCH 03/87] Discovered Python client problem, ready to file JIRA

---
 tests/pytest/crash_gen.py | 39 +++++++++++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 10 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 94ad63697c..4f3f3a98e8 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -270,7 +270,7 @@ class ThreadCoordinator:
             # Get ready for next step
             logger.debug("<-- Step {} finished".format(self._curStep))
             self._curStep += 1 # we are about to get into next step. TODO: race condition here!                
-            logger.debug("\r\n--> Step {} starts with main thread waking up".format(self._curStep)) # Now not all threads had time to go to sleep
+            logger.debug("\r\n\n--> Step {} starts with main thread waking up".format(self._curStep)) # Now not all threads had time to go to sleep
 
             # A new TE for the new step
             if not failed: # only if not failed
@@ -452,6 +452,7 @@ class DbConn:
         # Open connection
         self._tdSql = TDSql()
         self._tdSql.init(self._cursor)
+        logger.debug("[DB] data connection opened")
         self.isOpen = True
 
     def resetDb(self): # reset the whole database, etc.
@@ -470,6 +471,7 @@ class DbConn:
         if ( not self.isOpen ):
             raise RuntimeError("Cannot clean up database until connection is open")
         self._tdSql.close()
+        logger.debug("[DB] Database connection closed")
         self.isOpen = False
 
     def execute(self, sql): 
@@ -1010,13 +1012,19 @@ class Task():
             self._executeInternal(te, wt) # TODO: no return value?
         except taos.error.ProgrammingError as err:
             errno2 = 0x80000000 + err.errno # positive error number
-            if ( errno2 in [0x200, 0x360, 0x362, 0x381, 0x380, 0x600 ]) : # allowed errors
+            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x381, 0x380, 0x383, 0x600 ]) : # allowed errors
                 self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
                 print("e", end="", flush=True)
                 self._err = err  
             else:
-                self.logDebug("[=] Unexpected Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
-                raise
+                errMsg = "[=] Unexpected Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql)
+                self.logDebug(errMsg)
+                if gConfig.debug :
+                    raise # so that we see full stack
+                else: # non-debug
+                    print("\n\n----------------------------\nProgram ABORTED Due to Unexpected TAOS Error: \n\n{}\n" +
+                        "--------------\n".format(errMsg))
+                    sys.exit(-1)
         except:
             self.logDebug("[=] Unexpected exception, SQL: {}".format(self._lastSql))
             raise
@@ -1388,7 +1396,8 @@ class LoggingFilter(logging.Filter):
         if ( record.levelno >= logging.INFO ) :
             return True # info or above always log
 
-        msg = record.msg
+
+        
         # print("type = {}, value={}".format(type(msg), msg))
         # sys.exit()
 
@@ -1398,6 +1407,11 @@ class LoggingFilter(logging.Filter):
         #     return False
         return True
 
+class MyLoggingAdapter(logging.LoggerAdapter):    
+    def process(self, msg, kwargs):
+        return "[{}]{}".format(threading.get_ident() % 10000, msg), kwargs
+        # return '[%s] %s' % (self.extra['connid'], msg), kwargs
+
 class MainExec:
     @classmethod
     def runClient(cls):
@@ -1493,16 +1507,21 @@ def main():
     #     parser.print_help()
     #     sys.exit()
  
+    # Logging Stuff
     global logger
-    logger = logging.getLogger('CrashGen')
-    logger.addFilter(LoggingFilter())
+    _logger = logging.getLogger('CrashGen') # real logger
+    _logger.addFilter(LoggingFilter()) 
+    ch = logging.StreamHandler()
+    _logger.addHandler(ch)
+
+    logger = MyLoggingAdapter(_logger, []) # Logging adapter, to be used as a logger
+
     if ( gConfig.debug ):
         logger.setLevel(logging.DEBUG) # default seems to be INFO        
     else:
         logger.setLevel(logging.INFO)
-    ch = logging.StreamHandler()
-    logger.addHandler(ch)
-
+    
+    # Run server or client
     if gConfig.run_tdengine : # run server
         MainExec.runService()
     else :

From 496932f0cc0987242141df4694479a3866d4d596 Mon Sep 17 00:00:00 2001
From: liu0x54 <tliu@taosdata.com>
Date: Tue, 30 Jun 2020 01:32:38 +0000
Subject: [PATCH 04/87] [TD-785]check the caller and creater, if not match,
 return none

---
 .../python/linux/python3/taos/cursor.py          | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/connector/python/linux/python3/taos/cursor.py b/src/connector/python/linux/python3/taos/cursor.py
index 06d6a19462..3bd353e3c5 100644
--- a/src/connector/python/linux/python3/taos/cursor.py
+++ b/src/connector/python/linux/python3/taos/cursor.py
@@ -1,6 +1,7 @@
 from .cinterface import CTaosInterface
 from .error import *
 from .constants import FieldType
+import threading
 
 # querySeqNum = 0
 
@@ -37,6 +38,7 @@ class TDengineCursor(object):
         self._block_iter = 0
         self._affected_rows = 0
         self._logfile = ""
+        self._threadId = threading.get_ident()
 
         if connection is not None:
             self._connection = connection
@@ -103,6 +105,11 @@ class TDengineCursor(object):
     def execute(self, operation, params=None):
         """Prepare and execute a database operation (query or command).
         """
+        if threading.get_ident() != self._threadId:
+            info ="Cursor execute:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+            print(info)
+            return None
+
         if not operation:
             return None
 
@@ -188,6 +195,10 @@ class TDengineCursor(object):
     def fetchall(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
+        if threading.get_ident() != self._threadId:
+            info ="Cursor fetchall:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+            print(info)
+            return None
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 
@@ -232,6 +243,11 @@ class TDengineCursor(object):
     def _handle_result(self):
         """Handle the return result from query.
         """
+        if threading.get_ident() != self._threadId:
+            info = "Cursor handleresult:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+            print(info)
+            return None
+
         self._description = []
         for ele in self._fields:
             self._description.append(

From 30f5a202f9ec4c6e6e10505c39d3fb8fc3a18747 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 29 Jun 2020 20:05:31 -0700
Subject: [PATCH 05/87] Corrected connection-shared-by-thread flag in Crash_Gen

---
 .../python/linux/python3/taos/cursor.py       | 27 ++++++++++---------
 tests/pytest/crash_gen.py                     |  5 +++-
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/connector/python/linux/python3/taos/cursor.py b/src/connector/python/linux/python3/taos/cursor.py
index 3bd353e3c5..3f0f315d33 100644
--- a/src/connector/python/linux/python3/taos/cursor.py
+++ b/src/connector/python/linux/python3/taos/cursor.py
@@ -105,10 +105,11 @@ class TDengineCursor(object):
     def execute(self, operation, params=None):
         """Prepare and execute a database operation (query or command).
         """
-        if threading.get_ident() != self._threadId:
-            info ="Cursor execute:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
-            print(info)
-            return None
+        # if threading.get_ident() != self._threadId:
+        #     info ="Cursor execute:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+        #     raise OperationalError(info)
+            # print(info)
+            # return None
 
         if not operation:
             return None
@@ -195,10 +196,11 @@ class TDengineCursor(object):
     def fetchall(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
-        if threading.get_ident() != self._threadId:
-            info ="Cursor fetchall:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
-            print(info)
-            return None
+        # if threading.get_ident() != self._threadId:
+        #     info ="[WARNING] Cursor fetchall:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+        #     raise OperationalError(info)
+            # print(info)
+            # return None
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 
@@ -243,10 +245,11 @@ class TDengineCursor(object):
     def _handle_result(self):
         """Handle the return result from query.
         """
-        if threading.get_ident() != self._threadId:
-            info = "Cursor handleresult:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
-            print(info)
-            return None
+        # if threading.get_ident() != self._threadId:
+        #     info = "Cursor handleresult:Thread ID not match,creater:"+str(self._threadId)+" caller:"+str(threading.get_ident())
+        #     raise OperationalError(info)
+            # print(info)
+            # return None
 
         self._description = []
         for ele in self._fields:
diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 4f3f3a98e8..ccd99ca6cf 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -106,6 +106,7 @@ class WorkerThread:
         logger.info("Starting to run thread: {}".format(self._tid))
 
         if ( gConfig.per_thread_db_connection ): # type: ignore
+            logger.debug("Worker thread openning database connection")
             self._dbConn.open()
 
         self._doTaskLoop()       
@@ -246,6 +247,7 @@ class ThreadCoordinator:
                 logger.debug("[STT] starting transitions")
                 sm.transition(self._executedTasks) # at end of step, transiton the DB state
                 logger.debug("[STT] transition ended")
+                # Due to limitation (or maybe not) of the Python library, we cannot share connections across threads
                 if sm.hasDatabase() :
                     for t in self._pool.threadList:
                         logger.debug("[DB] use db for all worker threads")
@@ -1492,7 +1494,7 @@ def main():
                         help='Run TDengine service in foreground (default: false)')
     parser.add_argument('-l', '--larger-data', action='store_true',                        
                         help='Write larger amount of data during write operations (default: false)')
-    parser.add_argument('-p', '--per-thread-db-connection', action='store_false',                        
+    parser.add_argument('-p', '--per-thread-db-connection', action='store_true',                        
                         help='Use a single shared db connection (default: false)')
     parser.add_argument('-r', '--record-ops', action='store_true',                        
                         help='Use a pair of always-fsynced fils to record operations performing + performed, for power-off tests (default: false)')                    
@@ -1503,6 +1505,7 @@ def main():
 
     global gConfig
     gConfig = parser.parse_args()
+
     # if len(sys.argv) == 1:
     #     parser.print_help()
     #     sys.exit()

From 4b4c0905578d64995742aceb194f0a5c113ff93c Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 29 Jun 2020 23:02:05 -0700
Subject: [PATCH 06/87] Tweaked abort message in Crash_Gen tool

---
 tests/pytest/crash_gen.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index ccd99ca6cf..4457fd1493 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -1024,8 +1024,8 @@ class Task():
                 if gConfig.debug :
                     raise # so that we see full stack
                 else: # non-debug
-                    print("\n\n----------------------------\nProgram ABORTED Due to Unexpected TAOS Error: \n\n{}\n" +
-                        "--------------\n".format(errMsg))
+                    print("\n\n----------------------------\nProgram ABORTED Due to Unexpected TAOS Error: \n\n{}\n".format(errMsg) +
+                        "----------------------------\n")
                     sys.exit(-1)
         except:
             self.logDebug("[=] Unexpected exception, SQL: {}".format(self._lastSql))

From d796aaaa0191f2c9300fd80a2cdd66776f3c4962 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Tue, 30 Jun 2020 21:39:53 -0700
Subject: [PATCH 07/87] Corrected TAOS client error detection

---
 tests/pytest/crash_gen.py | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 4457fd1493..21de44ef98 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -292,7 +292,7 @@ class ThreadCoordinator:
 
         logger.debug("Main thread joining all threads")
         self._pool.joinAll() # Get all threads to finish
-        logger.info("All worker thread finished")
+        logger.info("\nAll worker threads finished")
         self._execStats.endExec()
 
     def logStats(self):
@@ -721,10 +721,10 @@ class StateHasData(AnyState):
                 self.assertNoTask(tasks, TaskDropDb) # we must have drop_db task
             self.hasSuccess(tasks, TaskDropSuperTable)
             # self.assertAtMostOneSuccess(tasks, DropFixedSuperTableTask) # TODO: dicy
-        elif ( newState.equals(AnyState.STATE_TABLE_ONLY) ): # data deleted
-            self.assertNoTask(tasks, TaskDropDb)
-            self.assertNoTask(tasks, TaskDropSuperTable)
-            self.assertNoTask(tasks, TaskAddData)
+        # elif ( newState.equals(AnyState.STATE_TABLE_ONLY) ): # data deleted
+            # self.assertNoTask(tasks, TaskDropDb)
+            # self.assertNoTask(tasks, TaskDropSuperTable)
+            # self.assertNoTask(tasks, TaskAddData)
             # self.hasSuccess(tasks, DeleteDataTasks)
         else: # should be STATE_HAS_DATA
             if (not self.hasTask(tasks, TaskCreateDb) ): # only if we didn't create one
@@ -1014,9 +1014,9 @@ class Task():
             self._executeInternal(te, wt) # TODO: no return value?
         except taos.error.ProgrammingError as err:
             errno2 = 0x80000000 + err.errno # positive error number
-            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x381, 0x380, 0x383, 0x600 ]) : # allowed errors
+            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x36D, 0x381, 0x380, 0x383, 0x503, 0x600 ]) : # allowed errors
                 self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
-                print("e", end="", flush=True)
+                print("_", end="", flush=True)
                 self._err = err  
             else:
                 errMsg = "[=] Unexpected Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql)
@@ -1234,22 +1234,24 @@ class TaskDropSuperTable(StateTransitionTask):
             tblSeq = list(range(2 + (self.LARGE_NUMBER_OF_TABLES if gConfig.larger_data else self.SMALL_NUMBER_OF_TABLES))) 
             random.shuffle(tblSeq) 
             tickOutput = False # if we have spitted out a "d" character for "drop regular table"
+            isSuccess = True
             for i in tblSeq: 
-                regTableName = self.getRegTableName(i); # "db.reg_table_{}".format(i)  
+                regTableName = self.getRegTableName(i); # "db.reg_table_{}".format(i)                  
                 try:
-                    nRows = self.execWtSql(wt, "drop table {}".format(regTableName))  
+                    self.execWtSql(wt, "drop table {}".format(regTableName)) # nRows always 0, like MySQL
                 except taos.error.ProgrammingError as err:
                     errno2 = 0x80000000 + err.errno # positive error number
-                    if ( errno2 in [0x362]) : # allowed errors
+                    if ( errno2 in [0x362]) : # mnode invalid table name
+                        isSuccess = False
                         logger.debug("[DB] Acceptable error when dropping a table")
-                    continue
+                    continue # try to delete next regular table
 
                 if (not tickOutput):
                     tickOutput = True # Print only one time
-                    if nRows >= 1 :
+                    if isSuccess :
                         print("d", end="", flush=True)
                     else:
-                        print("f({})".format(nRows), end="", flush=True)                    
+                        print("f", end="", flush=True)                    
 
         # Drop the super table itself
         tblName = self._dbManager.getFixedSuperTableName()     

From 88ac7bb6df9068b1f3f66f9ab42932b0e28a0c75 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Wed, 1 Jul 2020 22:33:52 -0700
Subject: [PATCH 08/87] Added -c option to Crash_Gen, enabling REST, but
 encountered error

---
 tests/pytest/crash_gen.py | 202 +++++++++++++++++++++++++++++---------
 1 file changed, 158 insertions(+), 44 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 21de44ef98..bd2038ca3a 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -30,6 +30,8 @@ import time
 import logging
 import datetime
 import textwrap
+import requests
+from requests.auth import HTTPBasicAuth
 
 from typing import List
 from typing import Dict
@@ -76,7 +78,8 @@ class WorkerThread:
 
         # Let us have a DB connection of our own
         if ( gConfig.per_thread_db_connection ): # type: ignore
-            self._dbConn = DbConn()   
+            # print("connector_type = {}".format(gConfig.connector_type))
+            self._dbConn = DbConn.createNative() if (gConfig.connector_type == 'native') else DbConn.createRest()
 
         self._dbInUse = False # if "use db" was executed already
 
@@ -434,15 +437,151 @@ class LinearQueue():
                     return ret
 
 class DbConn:
+    TYPE_NATIVE = "native-c"
+    TYPE_REST = "rest-api"
+    TYPE_INVALID = "invalid"
+
+    @classmethod
+    def create(cls, connType):
+        if connType == cls.TYPE_NATIVE:
+            return DbConnNative()
+        elif connType == cls.TYPE_REST:
+            return DbConnRest()
+        else:
+            raise RuntimeError("Unexpected connection type: {}".format(connType))
+
+    @classmethod
+    def createNative(cls):
+        return cls.create(cls.TYPE_NATIVE)
+
+    @classmethod
+    def createRest(cls):
+        return cls.create(cls.TYPE_REST)
+
     def __init__(self):
-        self._conn = None 
-        self._cursor = None
         self.isOpen = False
-        
-    def open(self): # Open connection
+        self._type = self.TYPE_INVALID
+
+    def open(self):
         if ( self.isOpen ):
             raise RuntimeError("Cannot re-open an existing DB connection")
 
+        # below implemented by child classes
+        self.openByType()
+
+        logger.debug("[DB] data connection opened, type = {}".format(self._type))
+        self.isOpen = True
+
+    def resetDb(self): # reset the whole database, etc.
+        if ( not self.isOpen ):
+            raise RuntimeError("Cannot reset database until connection is open")
+        # self._tdSql.prepare() # Recreate database, etc.
+
+        self.execute('drop database if exists db')
+        logger.debug("Resetting DB, dropped database")
+        # self._cursor.execute('create database db')
+        # self._cursor.execute('use db')
+        # tdSql.execute('show databases')
+
+    def queryScalar(self, sql) -> int :
+        return self._queryAny(sql)
+
+    def queryString(self, sql) -> str :
+        return self._queryAny(sql)
+
+    def _queryAny(self, sql) : # actual query result as an int
+        if ( not self.isOpen ):
+            raise RuntimeError("Cannot query database until connection is open")
+        nRows = self.query(sql)
+        if nRows != 1 :
+            raise RuntimeError("Unexpected result for query: {}, rows = {}".format(sql, nRows))
+        if self.getResultRows() != 1 or self.getResultCols() != 1:
+            raise RuntimeError("Unexpected result set for query: {}".format(sql))
+        return self.getQueryResult()[0][0]
+
+    def execute(self, sql):
+        raise RuntimeError("Unexpected execution, should be overriden")
+    def openByType(self):
+        raise RuntimeError("Unexpected execution, should be overriden")
+    def getQueryResult(self):
+        raise RuntimeError("Unexpected execution, should be overriden")
+    def getResultRows(self):
+        raise RuntimeError("Unexpected execution, should be overriden")
+    def getResultCols(self):
+        raise RuntimeError("Unexpected execution, should be overriden")
+
+# Sample: curl -u root:taosdata -d "show databases" localhost:6020/rest/sql
+class DbConnRest(DbConn):
+    def __init__(self):
+        super().__init__()
+        self._type = self.TYPE_REST
+        self._url = "http://localhost:6020/rest/sql" # fixed for now
+        self._result = None
+
+    def openByType(self): # Open connection
+        pass # do nothing, always open
+        
+    def close(self):
+        if ( not self.isOpen ):
+            raise RuntimeError("Cannot clean up database until connection is open")
+        # Do nothing for REST
+        logger.debug("[DB] REST Database connection closed")
+        self.isOpen = False
+
+    def _doSql(self, sql):
+        r = requests.post(self._url, 
+            data = sql,
+            auth = HTTPBasicAuth('root', 'taosdata'))
+        rj = r.json()
+        # Sanity check for the "Json Result"
+        if (not 'status' in rj):
+            raise RuntimeError("No status in REST response")
+
+        if rj['status'] == 'error': # clearly reported error
+            if (not 'code' in rj): # error without code
+                raise RuntimeError("REST error return without code")            
+            errno = rj['code'] # May need to massage this in the future
+            # print("Raising programming error with REST return: {}".format(rj))
+            raise taos.error.ProgrammingError(rj['desc'], errno) # todo: check existance of 'desc'
+
+        if rj['status'] != 'succ': # better be this
+            raise RuntimeError("Unexpected REST return status: {}".format(rj['status']))
+
+        nRows = rj['rows'] if ('rows' in rj) else 0
+        self._result = rj        
+        return nRows
+
+    def execute(self, sql): 
+        if ( not self.isOpen ):
+            raise RuntimeError("Cannot execute database commands until connection is open")
+        logger.debug("[SQL-REST] Executing SQL: {}".format(sql))
+        nRows = self._doSql(sql)
+        logger.debug("[SQL-REST] Execution Result, nRows = {}, SQL = {}".format(nRows, sql))
+        return nRows
+
+    def query(self, sql) :  # return rows affected
+        return self.execute(sql)
+
+    def getQueryResult(self):
+        return self._result['data']
+
+    def getResultRows(self):
+        print(self._result)
+        raise RuntimeError("TBD")
+        # return self._tdSql.queryRows
+
+    def getResultCols(self):
+        print(self._result)
+        raise RuntimeError("TBD")
+    
+class DbConnNative(DbConn):
+    def __init__(self):
+        super().__init__()
+        self._type = self.TYPE_REST
+        self._conn = None 
+        self._cursor = None
+        
+    def openByType(self): # Open connection
         cfgPath = "../../build/test/cfg" 
         self._conn = taos.connect(host="127.0.0.1", config=cfgPath) # TODO: make configurable
         self._cursor = self._conn.cursor()
@@ -454,21 +593,7 @@ class DbConn:
         # Open connection
         self._tdSql = TDSql()
         self._tdSql.init(self._cursor)
-        logger.debug("[DB] data connection opened")
-        self.isOpen = True
-
-    def resetDb(self): # reset the whole database, etc.
-        if ( not self.isOpen ):
-            raise RuntimeError("Cannot reset database until connection is open")
-        # self._tdSql.prepare() # Recreate database, etc.
-
-        self._cursor.execute('drop database if exists db')
-        logger.debug("Resetting DB, dropped database")
-        # self._cursor.execute('create database db')
-        # self._cursor.execute('use db')
-
-        # tdSql.execute('show databases')
-
+        
     def close(self):
         if ( not self.isOpen ):
             raise RuntimeError("Cannot clean up database until connection is open")
@@ -496,22 +621,12 @@ class DbConn:
     def getQueryResult(self):
         return self._tdSql.queryResult
 
-    def _queryAny(self, sql) : # actual query result as an int
-        if ( not self.isOpen ):
-            raise RuntimeError("Cannot query database until connection is open")
-        tSql = self._tdSql
-        nRows = tSql.query(sql)
-        if nRows != 1 :
-            raise RuntimeError("Unexpected result for query: {}, rows = {}".format(sql, nRows))
-        if tSql.queryRows != 1 or tSql.queryCols != 1:
-            raise RuntimeError("Unexpected result set for query: {}".format(sql))
-        return tSql.queryResult[0][0]
+    def getResultRows(self):
+        return self._tdSql.queryRows
 
-    def queryScalar(self, sql) -> int :
-        return self._queryAny(sql)
+    def getResultCols(self):
+        return self._tdSql.queryCols
 
-    def queryString(self, sql) -> str :
-        return self._queryAny(sql)
     
 class AnyState:
     STATE_INVALID    = -1
@@ -859,7 +974,7 @@ class DbManager():
         self._lock = threading.RLock()
         
         # self.openDbServerConnection()
-        self._dbConn = DbConn()
+        self._dbConn = DbConn.createNative() if (gConfig.connector_type=='native') else DbConn.createRest()
         try:
             self._dbConn.open() # may throw taos.error.ProgrammingError: disconnected
         except taos.error.ProgrammingError as err:
@@ -1013,8 +1128,10 @@ class Task():
         try:
             self._executeInternal(te, wt) # TODO: no return value?
         except taos.error.ProgrammingError as err:
-            errno2 = 0x80000000 + err.errno # positive error number
-            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x36D, 0x381, 0x380, 0x383, 0x503, 0x600 ]) : # allowed errors
+            errno2 = err.errno if (err.errno > 0) else 0x80000000 + err.errno # correct error scheme
+            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x36D, 0x381, 0x380, 0x383, 0x503, 0x600,
+                1000 # REST catch-all error
+                ]) : # allowed errors
                 self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))
                 print("_", end="", flush=True)
                 self._err = err  
@@ -1239,8 +1356,8 @@ class TaskDropSuperTable(StateTransitionTask):
                 regTableName = self.getRegTableName(i); # "db.reg_table_{}".format(i)                  
                 try:
                     self.execWtSql(wt, "drop table {}".format(regTableName)) # nRows always 0, like MySQL
-                except taos.error.ProgrammingError as err:
-                    errno2 = 0x80000000 + err.errno # positive error number
+                except taos.error.ProgrammingError as err:                    
+                    errno2 = err.errno if (err.errno > 0) else 0x80000000 + err.errno # correcting for strange error number scheme
                     if ( errno2 in [0x362]) : # mnode invalid table name
                         isSuccess = False
                         logger.debug("[DB] Acceptable error when dropping a table")
@@ -1400,11 +1517,6 @@ class LoggingFilter(logging.Filter):
         if ( record.levelno >= logging.INFO ) :
             return True # info or above always log
 
-
-        
-        # print("type = {}, value={}".format(type(msg), msg))
-        # sys.exit()
-
         # Commenting out below to adjust...
 
         # if msg.startswith("[TRD]"):
@@ -1490,6 +1602,8 @@ def main():
 
             '''))
 
+    parser.add_argument('-c', '--connector-type', action='store', default='native', type=str,
+                        help='Connector type to use: native, rest, or mixed (default: 10)')
     parser.add_argument('-d', '--debug', action='store_true',                        
                         help='Turn on DEBUG mode for more logging (default: false)')
     parser.add_argument('-e', '--run-tdengine', action='store_true',                        

From a519389d38e0a0f69ecf5c3e910fbd43bc84f1cd Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Fri, 3 Jul 2020 00:28:26 -0700
Subject: [PATCH 09/87] Now supporting CTRL-C abort in Crash_Gen, plus tracking
 top numbers

---
 tests/pytest/crash_gen.py | 294 ++++++++++++++++++++++++++++++++------
 1 file changed, 251 insertions(+), 43 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index bd2038ca3a..9d3c66b97f 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -15,6 +15,8 @@ from __future__ import annotations  # For type hinting before definition, ref: h
 
 import sys
 import os
+import io
+import signal
 import traceback
 # Require Python 3
 if sys.version_info[0] < 3:
@@ -36,6 +38,8 @@ from requests.auth import HTTPBasicAuth
 from typing import List
 from typing import Dict
 from typing import Set
+from typing import IO
+from queue import Queue, Empty
 
 from util.log import *
 from util.dnodes import *
@@ -205,6 +209,7 @@ class WorkerThread:
     #     else:
     #         return self._tc.getDbState().getDbConn().query(sql)
 
+# The coordinator of all worker threads, mostly running in main thread
 class ThreadCoordinator:
     def __init__(self, pool: ThreadPool, dbManager):
         self._curStep = -1 # first step is 0
@@ -217,6 +222,7 @@ class ThreadCoordinator:
 
         self._stepBarrier = threading.Barrier(self._pool.numThreads + 1) # one barrier for all threads
         self._execStats = ExecutionStats()
+        self._runStatus = MainExec.STATUS_RUNNING
 
     def getTaskExecutor(self):
         return self._te
@@ -227,6 +233,10 @@ class ThreadCoordinator:
     def crossStepBarrier(self):
         self._stepBarrier.wait()
 
+    def requestToStop(self):
+        self._runStatus = MainExec.STATUS_STOPPING
+        self._execStats.registerFailure("User Interruption")
+
     def run(self):              
         self._pool.createAndStartThreads(self)
 
@@ -234,41 +244,56 @@ class ThreadCoordinator:
         self._curStep = -1 # not started yet
         maxSteps = gConfig.max_steps # type: ignore
         self._execStats.startExec() # start the stop watch
-        failed = False
-        while(self._curStep < maxSteps-1 and not failed):  # maxStep==10, last curStep should be 9
+        transitionFailed = False
+        hasAbortedTask = False
+        while(self._curStep < maxSteps-1 and 
+            (not transitionFailed) and 
+            (self._runStatus==MainExec.STATUS_RUNNING) and
+            (not hasAbortedTask)):  # maxStep==10, last curStep should be 9
+
             if not gConfig.debug: 
                 print(".", end="", flush=True) # print this only if we are not in debug mode
             logger.debug("[TRD] Main thread going to sleep")
 
-            # Now ready to enter a step
+            # Now main thread (that's us) is ready to enter a step
             self.crossStepBarrier() # let other threads go past the pool barrier, but wait at the thread gate
             self._stepBarrier.reset() # Other worker threads should now be at the "gate"            
 
             # At this point, all threads should be pass the overall "barrier" and before the per-thread "gate"
-            try:
-                sm = self._dbManager.getStateMachine()
-                logger.debug("[STT] starting transitions")
-                sm.transition(self._executedTasks) # at end of step, transiton the DB state
-                logger.debug("[STT] transition ended")
-                # Due to limitation (or maybe not) of the Python library, we cannot share connections across threads
-                if sm.hasDatabase() :
-                    for t in self._pool.threadList:
-                        logger.debug("[DB] use db for all worker threads")
-                        t.useDb()
-                        # t.execSql("use db") # main thread executing "use db" on behalf of every worker thread
+            # We use this period to do house keeping work, when all worker threads are QUIET.
+            hasAbortedTask = False
+            for task in self._executedTasks :
+                if task.isAborted() :
+                    print("Task aborted: {}".format(task))
+                    hasAbortedTask = True
+                    break
 
-            except taos.error.ProgrammingError as err:
-                if ( err.msg == 'network unavailable' ): # broken DB connection
-                    logger.info("DB connection broken, execution failed")
-                    traceback.print_stack()
-                    failed = True
-                    self._te = None # Not running any more
-                    self._execStats.registerFailure("Broken DB Connection")
-                    # continue # don't do that, need to tap all threads at end, and maybe signal them to stop
-                else:
-                    raise 
-            finally:
-                pass
+            if hasAbortedTask : # do transition only if tasks are error free
+                self._execStats.registerFailure("Aborted Task Encountered")
+            else: 
+                try:
+                    sm = self._dbManager.getStateMachine()
+                    logger.debug("[STT] starting transitions")
+                    sm.transition(self._executedTasks) # at end of step, transiton the DB state
+                    logger.debug("[STT] transition ended")
+                    # Due to limitation (or maybe not) of the Python library, we cannot share connections across threads
+                    if sm.hasDatabase() :
+                        for t in self._pool.threadList:
+                            logger.debug("[DB] use db for all worker threads")
+                            t.useDb()
+                            # t.execSql("use db") # main thread executing "use db" on behalf of every worker thread
+                except taos.error.ProgrammingError as err:
+                    if ( err.msg == 'network unavailable' ): # broken DB connection
+                        logger.info("DB connection broken, execution failed")
+                        traceback.print_stack()
+                        transitionFailed = True
+                        self._te = None # Not running any more
+                        self._execStats.registerFailure("Broken DB Connection")
+                        # continue # don't do that, need to tap all threads at end, and maybe signal them to stop
+                    else:
+                        raise 
+            # finally:
+            #     pass
             
             self.resetExecutedTasks() # clear the tasks after we are done
 
@@ -278,14 +303,14 @@ class ThreadCoordinator:
             logger.debug("\r\n\n--> Step {} starts with main thread waking up".format(self._curStep)) # Now not all threads had time to go to sleep
 
             # A new TE for the new step
-            if not failed: # only if not failed
+            if not transitionFailed: # only if not failed
                 self._te = TaskExecutor(self._curStep)
 
             logger.debug("[TRD] Main thread waking up at step {}, tapping worker threads".format(self._curStep)) # Now not all threads had time to go to sleep            
-            self.tapAllThreads()
+            self.tapAllThreads() # Worker threads will wake up at this point, and each execute it's own task
 
         logger.debug("Main thread ready to finish up...")
-        if not failed: # only in regular situations
+        if not transitionFailed: # only in regular situations
             self.crossStepBarrier() # Cross it one last time, after all threads finish
             self._stepBarrier.reset()
             logger.debug("Main thread in exclusive zone...")
@@ -298,8 +323,8 @@ class ThreadCoordinator:
         logger.info("\nAll worker threads finished")
         self._execStats.endExec()
 
-    def logStats(self):
-        self._execStats.logStats()
+    def printStats(self):
+        self._execStats.printStats()
 
     def tapAllThreads(self): # in a deterministic manner
         wakeSeq = []
@@ -1061,15 +1086,60 @@ class DbManager():
         self._dbConn.close()      
 
 class TaskExecutor():
+    class BoundedList:
+        def __init__(self, size = 10):
+            self._size = size
+            self._list = []
+
+        def add(self, n: int) :
+            if not self._list: # empty
+                self._list.append(n)
+                return
+            # now we should insert
+            nItems = len(self._list)
+            insPos = 0
+            for i in range(nItems):
+                insPos = i
+                if n <= self._list[i] : # smaller than this item, time to insert
+                    break # found the insertion point
+                insPos += 1 # insert to the right
+
+            if insPos == 0 : # except for the 1st item, # TODO: elimiate first item as gating item
+                return # do nothing
+
+            # print("Inserting at postion {}, value: {}".format(insPos, n))
+            self._list.insert(insPos, n) # insert
+            
+            newLen = len(self._list)
+            if newLen <= self._size :
+                return # do nothing
+            elif newLen == (self._size + 1) :                
+                del self._list[0] # remove the first item
+            else :
+                raise RuntimeError("Corrupt Bounded List")
+
+        def __str__(self):
+            return repr(self._list)
+
+    _boundedList = BoundedList()
+
     def __init__(self, curStep):
         self._curStep = curStep
 
+    @classmethod
+    def getBoundedList(cls):
+        return cls._boundedList
+
     def getCurStep(self):
         return self._curStep
 
     def execute(self, task: Task, wt: WorkerThread): # execute a task on a thread
         task.execute(wt)
 
+    def recordDataMark(self, n: int):
+        # print("[{}]".format(n), end="", flush=True)
+        self._boundedList.add(n)
+
     # def logInfo(self, msg):
     #     logger.info("    T[{}.x]: ".format(self._curStep) + msg)
 
@@ -1089,6 +1159,7 @@ class Task():
         self._dbManager = dbManager
         self._workerThread = None 
         self._err = None
+        self._aborted = False
         self._curStep = None
         self._numRows = None # Number of rows affected
 
@@ -1102,6 +1173,9 @@ class Task():
     def isSuccess(self):
         return self._err == None
 
+    def isAborted(self):
+        return self._aborted
+
     def clone(self): # TODO: why do we need this again?
         newTask = self.__class__(self._dbManager, self._execStats)
         return newTask
@@ -1143,7 +1217,9 @@ class Task():
                 else: # non-debug
                     print("\n\n----------------------------\nProgram ABORTED Due to Unexpected TAOS Error: \n\n{}\n".format(errMsg) +
                         "----------------------------\n")
-                    sys.exit(-1)
+                    # sys.exit(-1)
+                    self._err = err
+                    self._aborted = True
         except:
             self.logDebug("[=] Unexpected exception, SQL: {}".format(self._lastSql))
             raise
@@ -1213,7 +1289,7 @@ class ExecutionStats:
         self._failed = True
         self._failureReason = reason
 
-    def logStats(self):
+    def printStats(self):
         logger.info("----------------------------------------------------------------------")
         logger.info("| Crash_Gen test {}, with the following stats:".
             format("FAILED (reason: {})".format(self._failureReason) if self._failed else "SUCCEEDED"))
@@ -1228,6 +1304,7 @@ class ExecutionStats:
         logger.info("| Total Task Busy Time (elapsed time when any task is in progress): {:.3f} seconds".format(self._accRunTime))
         logger.info("| Average Per-Task Execution Time: {:.3f} seconds".format(self._accRunTime/execTimesAny))
         logger.info("| Total Elapsed Time (from wall clock): {:.3f} seconds".format(self._elapsedTime))
+        logger.info("| Top numbers written: {}".format(TaskExecutor.getBoundedList()))
         logger.info("----------------------------------------------------------------------")
         
 
@@ -1449,6 +1526,8 @@ class TaskAddData(StateTransitionTask):
                     ds.getNextBinary(), ds.getNextFloat(),
                     ds.getNextTick(), nextInt)
                 self.execWtSql(wt, sql) 
+                # Successfully wrote the data into the DB, let's record it somehow
+                te.recordDataMark(nextInt)
                 if gConfig.record_ops:
                     self.fAddLogDone.write("Wrote {} to {}\n".format(nextInt, regTableName))
                     self.fAddLogDone.flush()
@@ -1528,23 +1607,152 @@ class MyLoggingAdapter(logging.LoggerAdapter):
         return "[{}]{}".format(threading.get_ident() % 10000, msg), kwargs
         # return '[%s] %s' % (self.extra['connid'], msg), kwargs
 
-class MainExec:
-    @classmethod
-    def runClient(cls):
-        # resetDb = False # DEBUG only
-        # dbState = DbState(resetDb)  # DBEUG only!
+class SvcManager:    
+    
+    def __init__(self):
+        print("Starting service manager")
+        signal.signal(signal.SIGTERM, self.sigIntHandler)
+        signal.signal(signal.SIGINT, self.sigIntHandler)
+        self.ioThread = None
+        self.subProcess = None
+        self.shouldStop = False
+        self.status = MainExec.STATUS_RUNNING
+
+    def svcOutputReader(self, out: IO, queue):
+        # print("This is the svcOutput Reader...")
+        for line in out : # iter(out.readline, b''):
+            # print("Finished reading a line: {}".format(line))
+            queue.put(line.rstrip()) # get rid of new lines
+        print("No more output from incoming IO") # meaning sub process must have died
+        out.close()
+
+    def sigIntHandler(self, signalNumber, frame):
+        if self.status != MainExec.STATUS_RUNNING :
+            print("Ignoring repeated SIGINT...")
+            return # do nothing if it's already not running
+        self.status = MainExec.STATUS_STOPPING # immediately set our status
+
+        print("Terminating program...")
+        self.subProcess.send_signal(signal.SIGINT)
+        self.shouldStop = True
+        self.joinIoThread()
+
+    def joinIoThread(self):
+        if self.ioThread :
+            self.ioThread.join()
+            self.ioThread = None        
+
+    def run(self):
+        ON_POSIX = 'posix' in sys.builtin_module_names
+        svcCmd = ['../../build/build/bin/taosd', '-c', '../../build/test/cfg']
+        # svcCmd = ['vmstat', '1']
+        self.subProcess = subprocess.Popen(svcCmd, stdout=subprocess.PIPE, bufsize=1, close_fds=ON_POSIX, text=True)
+        q = Queue()
+        self.ioThread = threading.Thread(target=self.svcOutputReader, args=(self.subProcess.stdout, q))
+        self.ioThread.daemon = True # thread dies with the program
+        self.ioThread.start()
+
+        # proc = subprocess.Popen(['echo', '"to stdout"'], 
+        #                 stdout=subprocess.PIPE,
+        #                 )
+        # stdout_value = proc.communicate()[0]
+        # print('\tstdout: {}'.format(repr(stdout_value)))
+
+        while True :
+            try:  
+                line = q.get_nowait() # getting output at fast speed                    
+            except Empty:
+                # print('no output yet')
+                time.sleep(2.3) # wait only if there's no output
+            else: # got line
+                print(line)
+            # print("----end of iteration----")
+            if self.shouldStop:
+                print("Ending main Svc thread")
+                break
+
+        print("end of loop")
+        
+        self.joinIoThread()
+        print("Finished")
+
+class ClientManager:
+    def __init__(self):
+        print("Starting service manager")
+        signal.signal(signal.SIGTERM, self.sigIntHandler)
+        signal.signal(signal.SIGINT, self.sigIntHandler)
+
+        self.status = MainExec.STATUS_RUNNING
+        self.tc = None
+
+    def sigIntHandler(self, signalNumber, frame):
+        if self.status != MainExec.STATUS_RUNNING :
+            print("Ignoring repeated SIGINT...")
+            return # do nothing if it's already not running
+        self.status = MainExec.STATUS_STOPPING # immediately set our status
+
+        print("Terminating program...")
+        self.tc.requestToStop()
+
+    def _printLastNumbers(self): # to verify data durability
+        dbManager = DbManager(resetDb=False)
+        dbc = dbManager.getDbConn()
+        if dbc.query("show databases") == 0 : # no databae
+            return
+
+        dbc.execute("use db")
+        sTbName = dbManager.getFixedSuperTableName()        
+
+        # get all regular tables
+        dbc.query("select TBNAME from db.{}".format(sTbName)) # TODO: analyze result set later
+        rTables = dbc.getQueryResult()
+
+        bList = TaskExecutor.BoundedList()
+        for rTbName in rTables : # regular tables
+            dbc.query("select speed from db.{}".format(rTbName[0]))
+            numbers = dbc.getQueryResult()
+            for row in numbers :                
+                # print("<{}>".format(n), end="", flush=True)
+                bList.add(row[0])
+
+        print("Top numbers in DB right now: {}".format(bList))
+        print("TDengine client execution is about to start in 2 seconds...")
+        time.sleep(2.0)
+        dbManager = None # release?
+
+    def prepare(self):
+        self._printLastNumbers()
+
+    def run(self):
+        self._printLastNumbers()
+
         dbManager = DbManager() # Regular function
         Dice.seed(0) # initial seeding of dice
         thPool = ThreadPool(gConfig.num_threads, gConfig.max_steps)
-        tc = ThreadCoordinator(thPool, dbManager)
+        self.tc = ThreadCoordinator(thPool, dbManager)
         
-        tc.run()
-        tc.logStats()
-        dbManager.cleanUp()    
+        self.tc.run()
+        self.conclude()
+
+    def conclude(self):
+        self.tc.printStats()
+        self.tc.getDbManager().cleanUp()    
+
+
+class MainExec:
+    STATUS_RUNNING = 1
+    STATUS_STOPPING = 2
+    # STATUS_STOPPED = 3 # Not used yet
+
+    @classmethod
+    def runClient(cls):
+        clientManager = ClientManager()
+        clientManager.run()
 
     @classmethod
     def runService(cls):
-        print("Running service...")
+        svcManager = SvcManager()
+        svcManager.run()
 
     @classmethod
     def runTemp(cls): # for debugging purposes

From b823afbd6e1a6408132d5c5111e2bd59156e2fe5 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Fri, 3 Jul 2020 18:28:51 +0800
Subject: [PATCH 10/87] update table schema change code

---
 src/client/src/tscUtil.c    |   4 +-
 src/inc/taoserror.h         |   1 +
 src/inc/taosmsg.h           |   3 +-
 src/tsdb/inc/tsdbMain.h     |  43 +++++++
 src/tsdb/src/tsdbMain.c     | 230 +++++++++++++++++++++++-------------
 src/tsdb/src/tsdbMemTable.c |  11 +-
 src/tsdb/src/tsdbMeta.c     |  61 +++++-----
 src/tsdb/src/tsdbRWHelper.c |   2 +-
 8 files changed, 233 insertions(+), 122 deletions(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 9b6eff7123..74d41304a4 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -579,9 +579,9 @@ static int trimDataBlock(void* pDataBlock, STableDataBlocks* pTableDataBlock, bo
     int32_t numOfCols = tscGetNumOfColumns(pTableDataBlock->pTableMeta);
     for(int32_t j = 0; j < numOfCols; ++j) {
       STColumn* pCol = (STColumn*) pDataBlock;
-      pCol->colId = pSchema[j].colId;
+      pCol->colId = htons(pSchema[j].colId);
       pCol->type  = pSchema[j].type;
-      pCol->bytes = pSchema[j].bytes;
+      pCol->bytes = htons(pSchema[j].bytes);
       pCol->offset = 0;
 
       pDataBlock += sizeof(STColumn);
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 4a7d86c434..6139d4bf49 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -200,6 +200,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_ACTION,           0, 0x060D, "tsdb inval
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_CREATE_TB_MSG,    0, 0x060E, "tsdb invalid create table message")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_TABLE_DATA_IN_MEM,     0, 0x060F, "tsdb no table data in memory skiplist")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_FILE_ALREADY_EXISTS,      0, 0x0610, "tsdb file already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TABLE_RECONFIGURE,        0, 0x0611, "tsdb need to reconfigure table")
 
 // query
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_QHANDLE,          0, 0x0700, "query invalid handle")
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 6155f08e76..8b856ccdd9 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -203,8 +203,7 @@ typedef struct SSubmitBlk {
 typedef struct SSubmitMsg {
   SMsgHead   header;
   int32_t    length;
-  int32_t    compressed : 2;
-  int32_t    numOfBlocks : 30;
+  int32_t    numOfBlocks;
   SSubmitBlk blocks[];
 } SSubmitMsg;
 
diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index 3ae88c3141..f431830d94 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -308,6 +308,49 @@ int        tsdbRLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbUnlockRepoMeta(STsdbRepo* pRepo);
 void       tsdbRefTable(STable* pTable);
 void       tsdbUnRefTable(STable* pTable);
+void       tsdbUpdateTableSchema(STsdbRepo* pRepo, STable* pTable, STSchema* pSchema, bool insertAct);
+
+static FORCE_INLINE int tsdbCompareSchemaVersion(const void *key1, const void *key2) {
+  if (*(int16_t *)key1 < schemaVersion(*(STSchema **)key2)) {
+    return -1;
+  } else if (*(int16_t *)key1 > schemaVersion(*(STSchema **)key2)) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock, bool copy, int16_t version) {
+  ASSERT(TABLE_TYPE(pTable) != TSDB_SUPER_TABLE);
+  STable*   pDTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
+  STSchema* pSchema = NULL;
+  STSchema* pTSchema = NULL;
+
+  if (lock) taosRLockLatch(&(pDTable->latch));
+  if (version < 0) {  // get the latest version of schema
+    pTSchema = pDTable->schema[pDTable->numOfSchemas - 1];
+  } else {  // get the schema with version
+    void* ptr = taosbsearch(&version, pDTable->schema, pDTable->numOfSchemas, sizeof(STSchema*),
+                            tsdbCompareSchemaVersion, TD_EQ);
+    if (ptr == NULL) {
+      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
+      goto _exit;
+    }
+    pTSchema = *(STSchema**)ptr;
+  }
+
+  ASSERT(pTSchema != NULL);
+
+  if (copy) {
+    if ((pSchema = tdDupSchema(pTSchema)) == NULL) terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+  } else {
+    pSchema = pTSchema;
+  }
+
+_exit:
+  if (lock) taosRUnLockLatch(&(pDTable->latch));
+  return pSchema;
+}
 
 // ------------------ tsdbBuffer.c
 STsdbBufPool* tsdbNewBufPool();
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 4b9e977a1b..7f8144db13 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -41,9 +41,9 @@ typedef struct {
 } SSubmitBlkIter;
 
 typedef struct {
-  int32_t     totalLen;
-  int32_t     len;
-  SSubmitBlk *pBlock;
+  int32_t totalLen;
+  int32_t len;
+  void *  pMsg;
 } SSubmitMsgIter;
 
 static int32_t     tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg);
@@ -56,7 +56,7 @@ static STsdbRepo * tsdbNewRepo(char *rootDir, STsdbAppH *pAppH, STsdbCfg *pCfg);
 static void        tsdbFreeRepo(STsdbRepo *pRepo);
 static int         tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter);
 static int32_t     tsdbInsertDataToTable(STsdbRepo *pRepo, SSubmitBlk *pBlock, TSKEY now, int32_t *affectedrows);
-static SSubmitBlk *tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter);
+static int         tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock);
 static SDataRow    tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter);
 static int         tsdbRestoreInfo(STsdbRepo *pRepo);
 static int         tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter);
@@ -68,6 +68,7 @@ static int         keyFGroupCompFunc(const void *key, const void *fgroup);
 static int         tsdbEncodeCfg(void **buf, STsdbCfg *pCfg);
 static void *      tsdbDecodeCfg(void *buf, STsdbCfg *pCfg);
 static int         tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable);
+static int         tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg);
 
 // Function declaration
 int32_t tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg) {
@@ -164,6 +165,15 @@ int32_t tsdbInsertData(TSDB_REPO_T *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *
   STsdbRepo *    pRepo = (STsdbRepo *)repo;
   SSubmitMsgIter msgIter = {0};
 
+  if (tsdbScanAndConvertSubmitMsg(pRepo, pMsg) < 0) {
+    if (terrno == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+      return 0;
+    } else {
+      tsdbError("vgId:%d failed to insert data since %s", REPO_ID(pRepo), tstrerror(terrno));
+      return -1;
+    }
+  }
+
   if (tsdbInitSubmitMsgIter(pMsg, &msgIter) < 0) {
     tsdbError("vgId:%d failed to insert data since %s", REPO_ID(pRepo), tstrerror(terrno));
     return -1;
@@ -173,12 +183,14 @@ int32_t tsdbInsertData(TSDB_REPO_T *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *
   int32_t     affectedrows = 0;
 
   TSKEY now = taosGetTimestamp(pRepo->config.precision);
-
-  while ((pBlock = tsdbGetSubmitMsgNext(&msgIter)) != NULL) {
+  while (true) {
+    tsdbGetSubmitMsgNext(&msgIter, &pBlock);
+    if (pBlock == NULL) break;
     if (tsdbInsertDataToTable(pRepo, pBlock, now, &affectedrows) < 0) {
       return -1;
     }
   }
+
   if (pRsp != NULL) pRsp->affectedRows = htonl(affectedrows);
   return 0;
 }
@@ -263,7 +275,7 @@ void tsdbStartStream(TSDB_REPO_T *repo) {
     STable *pTable = pMeta->tables[i];
     if (pTable && pTable->type == TSDB_STREAM_TABLE) {
       pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), pTable->sql,
-                                                     tsdbGetTableSchema(pTable));
+                                                     tsdbGetTableSchemaImpl(pTable, false, false, -1));
     }
   }
 }
@@ -694,17 +706,12 @@ static int tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
     return -1;
   }
 
-  pMsg->length = htonl(pMsg->length);
-  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
-  pMsg->compressed = htonl(pMsg->compressed);
-
   pIter->totalLen = pMsg->length;
-  pIter->len = TSDB_SUBMIT_MSG_HEAD_SIZE;
+  pIter->len = 0;
+  pIter->pMsg = pMsg;
   if (pMsg->length <= TSDB_SUBMIT_MSG_HEAD_SIZE) {
     terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
     return -1;
-  } else {
-    pIter->pBlock = pMsg->blocks;
   }
 
   return 0;
@@ -714,26 +721,8 @@ static int32_t tsdbInsertDataToTable(STsdbRepo *pRepo, SSubmitBlk *pBlock, TSKEY
   STsdbMeta *pMeta = pRepo->tsdbMeta;
   int64_t    points = 0;
 
-  STable *pTable = tsdbGetTableByUid(pMeta, pBlock->uid);
-  if (pTable == NULL || TABLE_TID(pTable) != pBlock->tid) {
-    tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
-              pBlock->tid);
-    terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
-    return -1;
-  }
-
-  if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
-    tsdbError("vgId:%d invalid action trying to insert a super table %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable));
-    terrno = TSDB_CODE_TDB_INVALID_ACTION;
-    return -1;
-  }
-
-  // Check schema version and update schema if needed
-  if (tsdbCheckTableSchema(pRepo, pBlock, pTable) < 0) {
-    tsdbError("vgId:%d failed to insert data to table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-              tstrerror(terrno));
-    return -1;
-  }
+  STable *pTable = pMeta->tables[pBlock->tid];
+  ASSERT(pTable != NULL && TABLE_UID(pTable) == pBlock->uid);
 
   SSubmitBlkIter blkIter = {0};
   SDataRow       row = NULL;
@@ -764,27 +753,23 @@ static int32_t tsdbInsertDataToTable(STsdbRepo *pRepo, SSubmitBlk *pBlock, TSKEY
   return 0;
 }
 
-static SSubmitBlk *tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter) {
-  SSubmitBlk *pBlock = pIter->pBlock;
-  if (pBlock == NULL) return NULL;
-
-  pBlock->dataLen = htonl(pBlock->dataLen);
-  pBlock->schemaLen = htonl(pBlock->schemaLen);
-  pBlock->numOfRows = htons(pBlock->numOfRows);
-  pBlock->uid = htobe64(pBlock->uid);
-  pBlock->tid = htonl(pBlock->tid);
-
-  pBlock->sversion = htonl(pBlock->sversion);
-  pBlock->padding = htonl(pBlock->padding);
-
-  pIter->len = pIter->len + sizeof(SSubmitBlk) + pBlock->dataLen;
-  if (pIter->len >= pIter->totalLen) {
-    pIter->pBlock = NULL;
+static int tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
+  if (pIter->len == 0) {
+    pIter->len += TSDB_SUBMIT_MSG_HEAD_SIZE;
   } else {
-    pIter->pBlock = (SSubmitBlk *)((char *)pBlock + pBlock->dataLen + sizeof(SSubmitBlk));
+    SSubmitBlk *pSubmitBlk = (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
+    pIter->len += (sizeof(SSubmitBlk) + pSubmitBlk->dataLen + pSubmitBlk->schemaLen);
   }
 
-  return pBlock;
+  if (pIter->len > pIter->totalLen) {
+    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
+    *pPBlock = NULL;
+    return -1;
+  }
+
+  *pPBlock = (pIter->len == pIter->totalLen) ? NULL : (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
+
+  return 0;
 }
 
 static SDataRow tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter) {
@@ -969,42 +954,64 @@ static void *tsdbDecodeCfg(void *buf, STsdbCfg *pCfg) {
 static int tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable) {
   ASSERT(pTable != NULL);
 
-  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
   int       sversion = schemaVersion(pSchema);
 
-  if (pBlock->sversion == sversion) return 0;
-  if (pBlock->sversion > sversion) {  // need to config
-    tsdbDebug("vgId:%d table %s tid %d has version %d smaller than client version %d, try to config", REPO_ID(pRepo),
-              TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), sversion, pBlock->sversion);
-    if (pRepo->appH.configFunc) {
-      void *msg = (*pRepo->appH.configFunc)(REPO_ID(pRepo), TABLE_TID(pTable));
-      if (msg == NULL) {
-        tsdbError("vgId:%d failed to config table %s tid %d since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-                  TABLE_TID(pTable), tstrerror(terrno));
-        return -1;
-      }
-
-      STableCfg *pTableCfg = tsdbCreateTableCfgFromMsg(msg);
-      if (pTableCfg == NULL) {
-        rpcFreeCont(msg);
-        return -1;
-      }
-
-      if (tsdbUpdateTable(pRepo, (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable, pTableCfg) < 0) {
-        tsdbError("vgId:%d failed to update table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-                  tstrerror(terrno));
-        tsdbClearTableCfg(pTableCfg);
-        rpcFreeCont(msg);
-        return -1;
-      }
-      tsdbClearTableCfg(pTableCfg);
-      rpcFreeCont(msg);
-    } else {
+  if (pBlock->sversion == sversion) {
+    return 0;
+  } else {
+    if (TABLE_TYPE(pTable) == TSDB_STREAM_TABLE) {  // stream table is not allowed to change schema
       terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
       return -1;
     }
+  }
+
+  if (pBlock->sversion > sversion) {  // may need to update table schema
+    if (pBlock->schemaLen > 0) {
+      tsdbDebug(
+          "vgId:%d table %s tid %d uid %" PRIu64 " schema version %d is out of data, client version %d, update...",
+          REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable), sversion, pBlock->sversion);
+      ASSERT(pBlock->schemaLen % sizeof(STColumn) == 0);
+      int       numOfCols = pBlock->schemaLen / sizeof(STColumn);
+      STColumn *pTCol = (STColumn *)pBlock->data;
+
+      STSchemaBuilder schemaBuilder = {0};
+      if (tdInitTSchemaBuilder(&schemaBuilder, pBlock->sversion) < 0) {
+        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+        tsdbError("vgId:%d failed to update schema of table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
+                  tstrerror(terrno));
+        return -1;
+      }
+
+      for (int i = 0; i < numOfCols; i++) {
+        if (tdAddColToSchema(&schemaBuilder, pTCol[i].type, htons(pTCol[i].colId), htons(pTCol[i].bytes)) < 0) {
+          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+          tsdbError("vgId:%d failed to update schema of table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
+                    tstrerror(terrno));
+          tdDestroyTSchemaBuilder(&schemaBuilder);
+          return -1;
+        }
+      }
+
+      STSchema *pNSchema = tdGetSchemaFromBuilder(&schemaBuilder);
+      if (pNSchema == NULL) {
+        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+        tdDestroyTSchemaBuilder(&schemaBuilder);
+        return -1;
+      }
+
+      tdDestroyTSchemaBuilder(&schemaBuilder);
+      tsdbUpdateTableSchema(pRepo, pTable, pNSchema, true);
+    } else {
+      tsdbDebug(
+          "vgId:%d table %s tid %d uid %" PRIu64 " schema version %d is out of data, client version %d, reconfigure...",
+          REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable), sversion, pBlock->sversion);
+      terrno = TSDB_CODE_TDB_TABLE_RECONFIGURE;
+      return -1;
+    }
   } else {
-    if (tsdbGetTableSchemaByVersion(pTable, pBlock->sversion) == NULL) {
+    ASSERT(pBlock->sversion >= 0);
+    if (tsdbGetTableSchemaImpl(pTable, false, false, pBlock->sversion) == NULL) {
       tsdbError("vgId:%d invalid submit schema version %d to table %s tid %d from client", REPO_ID(pRepo),
                 pBlock->sversion, TABLE_CHAR_NAME(pTable), TABLE_TID(pTable));
     }
@@ -1013,7 +1020,64 @@ static int tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pT
   }
 
   return 0;
- }
+}
+
+static int tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg) {
+  ASSERT(pMsg != NULL);
+  STsdbMeta *    pMeta = pRepo->tsdbMeta;
+  SSubmitMsgIter msgIter = {0};
+  SSubmitBlk *   pBlock = NULL;
+
+  terrno = TSDB_CODE_SUCCESS;
+  pMsg->length = htonl(pMsg->length);
+  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
+
+  if (tsdbInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
+  while (true) {
+    if (tsdbGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
+    if (pBlock == NULL) break;
+
+    pBlock->uid = htobe64(pBlock->uid);
+    pBlock->tid = htonl(pBlock->tid);
+    pBlock->sversion = htonl(pBlock->sversion);
+    pBlock->dataLen = htonl(pBlock->dataLen);
+    pBlock->schemaLen = htonl(pBlock->schemaLen);
+    pBlock->numOfRows = htons(pBlock->numOfRows);
+
+    if (pBlock->tid <= 0 || pBlock->tid >= pRepo->config.maxTables) {
+      tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
+                pBlock->tid);
+      terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
+      return -1;
+    }
+
+    STable *pTable = pMeta->tables[pBlock->tid];
+    if (pTable == NULL || TABLE_UID(pTable) != pBlock->uid) {
+      tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
+                pBlock->tid);
+      terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
+      return -1;
+    }
+
+    if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
+      tsdbError("vgId:%d invalid action trying to insert a super table %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable));
+      terrno = TSDB_CODE_TDB_INVALID_ACTION;
+      return -1;
+    }
+
+    // Check schema version and update schema if needed
+    if (tsdbCheckTableSchema(pRepo, pBlock, pTable) < 0) {
+      if (terrno == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+        continue;
+      } else {
+        return -1;
+      }
+    }
+  }
+
+  if (terrno != TSDB_CODE_SUCCESS) return -1;
+  return 0;
+}
 
 static int tsdbAlterCacheTotalBlocks(STsdbRepo *pRepo, int totalBlocks) {
   // TODO
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index d3b9081a36..af86de5aa8 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -538,10 +538,12 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
     SCommitIter *pIter = iters + tid;
     if (pIter->pTable == NULL) continue;
 
+    taosRLockLatch(&(pIter->pTable->latch));
+
     tsdbSetHelperTable(pHelper, pIter->pTable, pRepo);
 
     if (pIter->pIter != NULL) {
-      tdInitDataCols(pDataCols, tsdbGetTableSchema(pIter->pTable));
+      tdInitDataCols(pDataCols, tsdbGetTableSchemaImpl(pIter->pTable, false, false, -1));
 
       int maxRowsToRead = pCfg->maxRowsPerFileBlock * 4 / 5;
       int nLoop = 0;
@@ -557,6 +559,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
         int rowsWritten = tsdbWriteDataBlock(pHelper, pDataCols);
         ASSERT(rowsWritten != 0);
         if (rowsWritten < 0) {
+          taosRUnLockLatch(&(pIter->pTable->latch));
           tsdbError("vgId:%d failed to write data block to table %s tid %d uid %" PRIu64 " since %s", REPO_ID(pRepo),
                     TABLE_CHAR_NAME(pIter->pTable), TABLE_TID(pIter->pTable), TABLE_UID(pIter->pTable),
                     tstrerror(terrno));
@@ -571,6 +574,8 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
       ASSERT(pDataCols->numOfRows == 0);
     }
 
+    taosRUnLockLatch(&(pIter->pTable->latch));
+
     // Move the last block to the new .l file if neccessary
     if (tsdbMoveLastBlockIfNeccessary(pHelper) < 0) {
       tsdbError("vgId:%d, failed to move last block, since %s", REPO_ID(pRepo), tstrerror(terrno));
@@ -680,10 +685,10 @@ static int tsdbReadRowsFromCache(STsdbMeta *pMeta, STable *pTable, SSkipListIter
     if (dataRowKey(row) > maxKey) break;
 
     if (pSchema == NULL || schemaVersion(pSchema) != dataRowVersion(row)) {
-      pSchema = tsdbGetTableSchemaByVersion(pTable, dataRowVersion(row));
+      pSchema = tsdbGetTableSchemaImpl(pTable, true, false, dataRowVersion(row));
       if (pSchema == NULL) {
         // TODO: deal with the error here
-        ASSERT(false);
+        ASSERT(0);
       }
     }
 
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index cbbf51d862..a473f86fa0 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -449,17 +449,7 @@ int tsdbCloseMeta(STsdbRepo *pRepo) {
   return 0;
 }
 
-STSchema *tsdbGetTableSchema(STable *pTable) {
-  if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) {
-    return pTable->schema[pTable->numOfSchemas - 1];
-  } else if (pTable->type == TSDB_CHILD_TABLE) {
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->schema[pSuper->numOfSchemas - 1];
-  } else {
-    return NULL;
-  }
-}
+STSchema *tsdbGetTableSchema(STable *pTable) { return tsdbGetTableSchemaImpl(pTable, true, true, -1); }
 
 STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
   void *ptr = taosHashGet(pMeta->uidMap, (char *)(&uid), sizeof(uid));
@@ -470,14 +460,7 @@ STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
 }
 
 STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t version) {
-  STable *pSearchTable = (pTable->type == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
-  if (pSearchTable == NULL) return NULL;
-
-  void *ptr = taosbsearch(&version, pSearchTable->schema, pSearchTable->numOfSchemas, sizeof(STSchema *),
-                          tsdbCompareSchemaVersion, TD_EQ);
-  if (ptr == NULL) return NULL;
-
-  return *(STSchema **)ptr;
+  return tsdbGetTableSchemaImpl(pTable, true, true, version);
 }
 
 STSchema *tsdbGetTableTagSchema(STable *pTable) {
@@ -575,7 +558,7 @@ void tsdbRefTable(STable *pTable) {
 
 void tsdbUnRefTable(STable *pTable) {
   int32_t ref = T_REF_DEC(pTable);
-  tsdbTrace("unref table uid:%"PRIu64", tid:%d, refCount:%d", TABLE_UID(pTable), TABLE_TID(pTable), ref);
+  tsdbDebug("unref table uid:%"PRIu64", tid:%d, refCount:%d", TABLE_UID(pTable), TABLE_TID(pTable), ref);
 
   if (ref == 0) {
     // tsdbDebug("destory table name:%s uid:%"PRIu64", tid:%d", TABLE_CHAR_NAME(pTable), TABLE_UID(pTable), TABLE_TID(pTable));
@@ -587,17 +570,32 @@ void tsdbUnRefTable(STable *pTable) {
   }
 }
 
-// ------------------ LOCAL FUNCTIONS ------------------
-static int tsdbCompareSchemaVersion(const void *key1, const void *key2) {
-  if (*(int16_t *)key1 < schemaVersion(*(STSchema **)key2)) {
-    return -1;
-  } else if (*(int16_t *)key1 > schemaVersion(*(STSchema **)key2)) {
-    return 1;
+void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema, bool insertAct) {
+  ASSERT(TABLE_TYPE(pTable) != TSDB_STREAM_TABLE && TABLE_TYPE(pTable) != TSDB_SUPER_TABLE);
+
+  STable *pCTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
+  ASSERT(schemaVersion(pSchema) > schemaVersion(pCTable->schema[pCTable->numOfSchemas - 1]));
+
+  taosWLockLatch(&(pCTable->latch));
+  if (pCTable->numOfSchemas < TSDB_MAX_TABLE_SCHEMAS) {
+    pCTable->schema[pCTable->numOfSchemas++] = pSchema;
   } else {
-    return 0;
+    ASSERT(pCTable->numOfSchemas == TSDB_MAX_TABLE_SCHEMAS);
+    tdFreeSchema(pCTable->schema[0]);
+    memmove(pCTable->schema, pCTable->schema + 1, sizeof(STSchema *) * (TSDB_MAX_TABLE_SCHEMAS - 1));
+    pCTable->schema[pCTable->numOfSchemas - 1] = pSchema;
+  }
+  taosWUnLockLatch(&(pCTable->latch));
+
+  if (insertAct) {
+    int   tlen = tsdbGetTableEncodeSize(TSDB_UPDATE_META, pCTable);
+    void *buf = tsdbAllocBytes(pRepo, tlen);
+    ASSERT(buf != NULL);
+    tsdbInsertTableAct(pRepo, TSDB_UPDATE_META, buf, pTable);
   }
 }
 
+// ------------------ LOCAL FUNCTIONS ------------------
 static int tsdbRestoreTable(void *pHandle, void *cont, int contLen) {
   STsdbRepo *pRepo = (STsdbRepo *)pHandle;
   STable *   pTable = NULL;
@@ -809,14 +807,15 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx) {
   }
 
   if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
-    STSchema *pSchema = tsdbGetTableSchema(pTable);
+    STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
     if (schemaNCols(pSchema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(pSchema);
     if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
   }
 
   if (addIdx && tsdbUnlockRepoMeta(pRepo) < 0) return -1;
   if (TABLE_TYPE(pTable) == TSDB_STREAM_TABLE && addIdx) {
-    pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), pTable->sql, tsdbGetTableSchema(pTable));
+    pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), pTable->sql,
+                                                   tsdbGetTableSchemaImpl(pTable, false, false, -1));
   }
 
   tsdbTrace("vgId:%d table %s tid %d uid %" PRIu64 " is added to meta", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
@@ -836,7 +835,7 @@ static void tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFro
   STable *   tTable = NULL;
   STsdbCfg * pCfg = &(pRepo->config);
 
-  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
   int       maxCols = schemaNCols(pSchema);
   int       maxRowBytes = schemaTLen(pSchema);
 
@@ -870,7 +869,7 @@ static void tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFro
     for (int i = 0; i < pCfg->maxTables; i++) {
       STable *pTable = pMeta->tables[i];
       if (pTable != NULL) {
-        pSchema = tsdbGetTableSchema(pTable);
+        pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
         maxCols = MAX(maxCols, schemaNCols(pSchema));
         maxRowBytes = MAX(maxRowBytes, schemaTLen(pSchema));
       }
diff --git a/src/tsdb/src/tsdbRWHelper.c b/src/tsdb/src/tsdbRWHelper.c
index 934fa8e733..bf4e5395a1 100644
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
@@ -217,7 +217,7 @@ void tsdbSetHelperTable(SRWHelper *pHelper, STable *pTable, STsdbRepo *pRepo) {
 
   pHelper->tableInfo.tid = pTable->tableId.tid;
   pHelper->tableInfo.uid = pTable->tableId.uid;
-  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
   pHelper->tableInfo.sversion = schemaVersion(pSchema);
 
   tdInitDataCols(pHelper->pDataCols[0], pSchema);

From c07c7ca74f704151db824fa0a056887b91b9d67a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 5 Jul 2020 16:30:26 +0800
Subject: [PATCH 11/87] [td-805] opt query/launch perf

---
 src/inc/tsdb.h            |   4 +-
 src/query/inc/qExecutor.h |   9 +-
 src/query/src/qExecutor.c | 178 +++++++++++++++++++++++++-------------
 src/query/src/qUtil.c     |   4 +-
 src/tsdb/inc/tsdbMain.h   |  28 +++++-
 src/tsdb/src/tsdbMeta.c   |  24 -----
 6 files changed, 155 insertions(+), 92 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index e2fec9b3dd..f68caf1a60 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -108,7 +108,9 @@ void tsdbClearTableCfg(STableCfg *config);
 
 void* tsdbGetTableTagVal(const void* pTable, int32_t colId, int16_t type, int16_t bytes);
 char* tsdbGetTableName(void *pTable);
-STableId tsdbGetTableId(void *pTable);
+
+#define TSDB_TABLEID(_table) ((STableId*) (_table))
+
 STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
 
 int   tsdbCreateTable(TSDB_REPO_T *repo, STableCfg *pCfg);
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 3aa1b60be5..73124b8fc6 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -154,6 +154,7 @@ typedef struct SQuery {
 } SQuery;
 
 typedef struct SQueryRuntimeEnv {
+  jmp_buf              env;
   SResultInfo*         resultInfo;       // todo refactor to merge with SWindowResInfo
   SQuery*              pQuery;
   SQLFunctionCtx*      pCtx;
@@ -169,6 +170,8 @@ typedef struct SQueryRuntimeEnv {
   void*                pSecQueryHandle;  // another thread for
   bool                 stableQuery;      // super table query or not
   bool                 topBotQuery;      // false
+  bool                 groupbyNormalCol; // denote if this is a groupby normal column query
+  bool                 hasTagResults;    // if there are tag values in final result or not
   int32_t              prevGroupId;      // previous executed group id
   SDiskbasedResultBuf* pResultBuf;       // query result buffer based on blocked-wised disk file
 } SQueryRuntimeEnv;
@@ -197,8 +200,10 @@ typedef struct SQInfo {
    */
   int32_t          tableIndex;
   int32_t          numOfGroupResultPages;
-  _qinfo_free_fn_t freeFn;
-  jmp_buf          env;
+  _qinfo_free_fn_t freeFn;  //todo remove it
+
+  void*     pBuf; // allocated buffer for STableQueryInfo, sizeof(STableQueryInfo)*numOfTables;
+
 } SQInfo;
 
 #endif  // TDENGINE_QUERYEXECUTOR_H
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 1882aa1850..ad56de9eb1 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -99,6 +99,16 @@ static UNUSED_FUNC void *u_malloc (size_t __size) {
   }
 }
 
+static UNUSED_FUNC void* u_calloc(size_t num, size_t __size) {
+  uint32_t v = rand();
+  if (v % 5 <= 1) {
+    return NULL;
+  } else {
+    return calloc(num, __size);
+  }
+}
+
+#define calloc  u_calloc
 #define malloc  u_malloc
 #endif
 
@@ -108,6 +118,7 @@ static UNUSED_FUNC void *u_malloc (size_t __size) {
 
 static void setQueryStatus(SQuery *pQuery, int8_t status);
 
+#define QUERY_IS_INTERVAL_QUERY(_q) ((_q)->intervalTime > 0)
 static bool isIntervalQuery(SQuery *pQuery) { return pQuery->intervalTime > 0; }
 
 // todo move to utility
@@ -313,6 +324,24 @@ static bool isTopBottomQuery(SQuery *pQuery) {
   return false;
 }
 
+static bool hasTagValOutput(SQuery* pQuery) {
+  SExprInfo *pExprInfo = &pQuery->pSelectExpr[0];
+  if (pQuery->numOfOutput == 1 && pExprInfo->base.functionId == TSDB_FUNC_TS_COMP) {
+    return true;
+  } else {  // set tag value, by which the results are aggregated.
+    for (int32_t idx = 0; idx < pQuery->numOfOutput; ++idx) {
+      SExprInfo *pLocalExprInfo = &pQuery->pSelectExpr[idx];
+
+      // ts_comp column required the tag value for join filter
+      if (TSDB_COL_IS_TAG(pLocalExprInfo->base.colInfo.flag)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, int32_t numOfCols, int32_t index) {
   // for a tag column, no corresponding field info
   SColIndex *pColIndex = &pQuery->pSelectExpr[index].base.colInfo;
@@ -786,8 +815,8 @@ static char *getDataBlock(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas
     return NULL;
   }
   char *dataBlock = NULL;
-  SQuery *pQuery = pRuntimeEnv->pQuery;
 
+  SQuery *pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
   int32_t functionId = pQuery->pSelectExpr[col].base.functionId;
@@ -806,6 +835,10 @@ static char *getDataBlock(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas
     sas->numOfCols = pQuery->numOfCols;
     sas->data    = calloc(pQuery->numOfCols, POINTER_BYTES);
 
+    if (sas->data == NULL) {
+      longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+    }
+
     // here the pQuery->colList and sas->colList are identical
     int32_t numOfCols = taosArrayGetSize(pDataBlock);
     for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
@@ -859,6 +892,9 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
   }
 
   SArithmeticSupport *sasArray = calloc((size_t)pQuery->numOfOutput, sizeof(SArithmeticSupport));
+  if (sasArray == NULL) {
+    longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
 
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     char *dataBlock = getDataBlock(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
@@ -866,7 +902,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
   }
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
-  if (isIntervalQuery(pQuery) && tsCols != NULL) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) && tsCols != NULL) {
     int32_t offset = GET_COL_DATA_POS(pQuery, 0, step);
     TSKEY   ts = tsCols[offset];
 
@@ -1083,8 +1119,12 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
   SColumnInfoData* pColumnInfoData = (SColumnInfoData *)taosArrayGet(pDataBlock, 0);
 
   TSKEY  *tsCols = (pColumnInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP)? (TSKEY*) pColumnInfoData->pData:NULL;
-  bool    groupbyColumnValue = isGroupbyNormalCol(pQuery->pGroupbyExpr);
+  bool    groupbyColumnValue = pRuntimeEnv->groupbyNormalCol;
+
   SArithmeticSupport *sasArray = calloc((size_t)pQuery->numOfOutput, sizeof(SArithmeticSupport));
+  if (sasArray == NULL) {
+    longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
 
   int16_t type = 0;
   int16_t bytes = 0;
@@ -1230,7 +1270,7 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
   STableQueryInfo* pTableQInfo = pQuery->current;
   SWindowResInfo*  pWindowResInfo = &pRuntimeEnv->windowResInfo;
   
-  if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+  if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL || pRuntimeEnv->groupbyNormalCol) {
     rowwiseApplyFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pWindowResInfo, pDataBlock);
   } else {
     blockwiseApplyFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pWindowResInfo, searchFn, pDataBlock);
@@ -1351,14 +1391,16 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* inputData, TSKEY
 }
 
 // set the output buffer for the selectivity + tag query
-static void setCtxTagColumnInfo(SQuery *pQuery, SQLFunctionCtx *pCtx) {
+static void setCtxTagColumnInfo(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx) {
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+
   if (isSelectivityWithTagsQuery(pQuery)) {
     int32_t num = 0;
     int16_t tagLen = 0;
     
     SQLFunctionCtx *p = NULL;
     SQLFunctionCtx **pTagCtx = calloc(pQuery->numOfOutput, POINTER_BYTES);
-    
+
     for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
       SSqlFuncMsg *pSqlFuncMsg = &pQuery->pSelectExpr[i].base;
       
@@ -1385,7 +1427,7 @@ static void setCtxTagColumnInfo(SQuery *pQuery, SQLFunctionCtx *pCtx) {
   }
 }
 
-static void setWindowResultInfo(SResultInfo *pResultInfo, SQuery *pQuery, bool isStableQuery) {
+static FORCE_INLINE void setWindowResultInfo(SResultInfo *pResultInfo, SQuery *pQuery, bool isStableQuery) {
   for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     assert(pQuery->pSelectExpr[i].interBytes <= DEFAULT_INTERN_BUF_PAGE_SIZE);
     
@@ -1476,7 +1518,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order
     resetCtxOutputBuf(pRuntimeEnv);
   }
 
-  setCtxTagColumnInfo(pQuery, pRuntimeEnv->pCtx);
+  setCtxTagColumnInfo(pRuntimeEnv, pRuntimeEnv->pCtx);
   return TSDB_CODE_SUCCESS;
 
 _clean:
@@ -2116,7 +2158,7 @@ static void ensureOutputBufferSimple(SQueryRuntimeEnv* pRuntimeEnv, int32_t capa
 static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBlockInfo) {
   // in case of prj/diff query, ensure the output buffer is sufficient to accommodate the results of current block
   SQuery* pQuery = pRuntimeEnv->pQuery;
-  if (!isIntervalQuery(pQuery) && !isGroupbyNormalCol(pQuery->pGroupbyExpr) && !isFixedOutputQuery(pQuery)) {
+  if (!QUERY_IS_INTERVAL_QUERY(pQuery) && !pRuntimeEnv->groupbyNormalCol && !isFixedOutputQuery(pQuery)) {
     SResultRec *pRec = &pQuery->rec;
     
     if (pQuery->rec.capacity - pQuery->rec.rows < pBlockInfo->rows) {
@@ -2170,7 +2212,7 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
 
     // todo extract methods
-    if (isIntervalQuery(pQuery) && pRuntimeEnv->windowResInfo.prevSKey == TSKEY_INITIAL_VAL) {
+    if (QUERY_IS_INTERVAL_QUERY(pQuery) && pRuntimeEnv->windowResInfo.prevSKey == TSKEY_INITIAL_VAL) {
       STimeWindow realWin = TSWINDOW_INITIALIZER, w = TSWINDOW_INITIALIZER;
       SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
 
@@ -2216,7 +2258,7 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     setQueryStatus(pQuery, QUERY_COMPLETED);
   }
 
-  if (isIntervalQuery(pQuery) && IS_MASTER_SCAN(pRuntimeEnv)) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) && IS_MASTER_SCAN(pRuntimeEnv)) {
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
       int32_t step = QUERY_IS_ASC_QUERY(pQuery) ? QUERY_ASC_FORWARD_STEP : QUERY_DESC_FORWARD_STEP;
 
@@ -2637,7 +2679,7 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
     tfree(pTableList);
 
     qError("QInfo:%p failed alloc memory", pQInfo);
-    longjmp(pQInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+    longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
   // todo opt for the case of one table per group
@@ -2645,7 +2687,7 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
   for (int32_t i = 0; i < size; ++i) {
     STableQueryInfo *item = taosArrayGetP(pGroup, i);
 
-    SIDList list = getDataBufPagesIdList(pRuntimeEnv->pResultBuf, tsdbGetTableId(item->pTable).tid);
+    SIDList list = getDataBufPagesIdList(pRuntimeEnv->pResultBuf, TSDB_TABLEID(item->pTable)->tid);
     if (list.size > 0 && item->windowResInfo.size > 0) {
       pTableList[numOfTables] = item;
       numOfTables += 1;
@@ -2668,6 +2710,10 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
   tLoserTreeCreate(&pTree, numOfTables, &cs, tableResultComparFn);
 
   SResultInfo *pResultInfo = calloc(pQuery->numOfOutput, sizeof(SResultInfo));
+  if (pResultInfo == NULL) {
+    longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
   setWindowResultInfo(pResultInfo, pQuery, pRuntimeEnv->stableQuery);
   resetMergeResultBuf(pQuery, pRuntimeEnv->pCtx, pResultInfo);
 
@@ -2868,7 +2914,7 @@ void disableFuncInReverseScan(SQInfo *pQInfo) {
 
   // group by normal columns and interval query on normal table
   SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
-  if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
     disableFuncInReverseScanImpl(pQInfo, pWindowResInfo, order);
   } else {  // for simple result of table query,
     for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {  // todo refactor
@@ -3043,7 +3089,7 @@ bool needScanDataBlocksAgain(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   bool toContinue = false;
-  if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
     // for each group result, call the finalize function for each column
     SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
 
@@ -3235,10 +3281,10 @@ void scanOneTableDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
 void finalizeQueryResult(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
-  if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
     // for each group result, call the finalize function for each column
     SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
-    if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+    if (pRuntimeEnv->groupbyNormalCol) {
       closeAllTimeWindow(pWindowResInfo);
     }
 
@@ -3280,10 +3326,10 @@ static bool hasMainOutput(SQuery *pQuery) {
   return false;
 }
 
-static STableQueryInfo *createTableQueryInfo( SQueryRuntimeEnv *pRuntimeEnv, void* pTable, STimeWindow win) {
+static STableQueryInfo *createTableQueryInfo(SQueryRuntimeEnv *pRuntimeEnv, void* pTable, STimeWindow win, void* buf) {
   SQuery* pQuery = pRuntimeEnv->pQuery;
 
-  STableQueryInfo *pTableQueryInfo = calloc(1, sizeof(STableQueryInfo));
+  STableQueryInfo *pTableQueryInfo = buf;//calloc(1, sizeof(STableQueryInfo));
 
   pTableQueryInfo->win = win;
   pTableQueryInfo->lastKey = win.skey;
@@ -3294,7 +3340,8 @@ static STableQueryInfo *createTableQueryInfo( SQueryRuntimeEnv *pRuntimeEnv, voi
   int32_t initialSize      = 1;
   int32_t initialThreshold = 1;
 
-  if (isIntervalQuery(pQuery) || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+  // set more initial size of interval/groupby query
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) || pRuntimeEnv->groupbyNormalCol) {
     initialSize = 20;
     initialThreshold = 100;
   }
@@ -3309,7 +3356,6 @@ void destroyTableQueryInfo(STableQueryInfo *pTableQueryInfo, int32_t numOfCols)
   }
 
   cleanupTimeWindowInfo(&pTableQueryInfo->windowResInfo, numOfCols);
-  free(pTableQueryInfo);
 }
 
 #define SET_CURRENT_QUERY_TABLE_INFO(_runtime, _tableInfo)                                      \
@@ -3322,7 +3368,6 @@ void destroyTableQueryInfo(STableQueryInfo *pTableQueryInfo, int32_t numOfCols)
 
 /**
  * set output buffer for different group
- * TODO opt performance if current group is identical to previous group
  * @param pRuntimeEnv
  * @param pDataBlockInfo
  */
@@ -3333,7 +3378,10 @@ void setExecutionContext(SQInfo *pQInfo, int32_t groupIndex, TSKEY nextKey) {
 
   // lastKey needs to be updated
   pTableQueryInfo->lastKey = nextKey;
-  setAdditionalInfo(pQInfo, pTableQueryInfo->pTable, pTableQueryInfo);
+
+  if (pRuntimeEnv->hasTagResults || pRuntimeEnv->pTSBuf != NULL) {
+    setAdditionalInfo(pQInfo, pTableQueryInfo->pTable, pTableQueryInfo);
+  }
 
   if (pRuntimeEnv->prevGroupId != INT32_MIN && pRuntimeEnv->prevGroupId == groupIndex) {
     return;
@@ -3522,7 +3570,7 @@ static int32_t getNumOfSubset(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
   int32_t totalSubset = 0;
-  if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || (isIntervalQuery(pQuery))) {
+  if (pQInfo->runtimeEnv.groupbyNormalCol || (isIntervalQuery(pQuery))) {
     totalSubset = numOfClosedTimeWindow(&pQInfo->runtimeEnv.windowResInfo);
   } else {
     totalSubset = GET_NUM_OF_TABLEGROUP(pQInfo);
@@ -3653,7 +3701,7 @@ void stableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *
   SWindowResInfo * pWindowResInfo = &pTableQueryInfo->windowResInfo;
   pQuery->pos = QUERY_IS_ASC_QUERY(pQuery)? 0 : pDataBlockInfo->rows - 1;
 
-  if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+  if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL || pRuntimeEnv->groupbyNormalCol) {
     rowwiseApplyFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pWindowResInfo, pDataBlock);
   } else {
     blockwiseApplyFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pWindowResInfo, searchFn, pDataBlock);
@@ -3695,7 +3743,7 @@ bool queryHasRemainResults(SQueryRuntimeEnv* pRuntimeEnv) {
   } else {
     // there are results waiting for returned to client.
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED) &&
-        (isGroupbyNormalCol(pQuery->pGroupbyExpr) || isIntervalQuery(pQuery)) &&
+        (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) &&
         (pRuntimeEnv->windowResInfo.size > 0)) {
       return true;
     }
@@ -4100,6 +4148,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
   pRuntimeEnv->cur.vgroupIndex = -1;
   pRuntimeEnv->stableQuery = isSTableQuery;
   pRuntimeEnv->prevGroupId = INT32_MIN;
+  pRuntimeEnv->groupbyNormalCol = isGroupbyNormalCol(pQuery->pGroupbyExpr);
 
   if (pTsBuf != NULL) {
     int16_t order = (pQuery->order.order == pRuntimeEnv->pTSBuf->tsOrder) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
@@ -4124,7 +4173,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
     if (pQuery->intervalTime == 0) {
       int16_t type = TSDB_DATA_TYPE_NULL;
 
-      if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // group by columns not tags;
+      if (pRuntimeEnv->groupbyNormalCol) {  // group by columns not tags;
         type = getGroupbyColumnType(pQuery, pQuery->pGroupbyExpr);
       } else {
         type = TSDB_DATA_TYPE_INT;  // group id
@@ -4133,7 +4182,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
       initWindowResInfo(&pRuntimeEnv->windowResInfo, pRuntimeEnv, 512, 4096, type);
     }
 
-  } else if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || isIntervalQuery(pQuery)) {
+  } else if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
     int32_t rows = getInitialPageNum(pQInfo);
     code = createDiskbasedResultBuffer(&pRuntimeEnv->pResultBuf, rows, pQuery->rowSize, pQInfo);
     if (code != TSDB_CODE_SUCCESS) {
@@ -4141,7 +4190,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
     }
 
     int16_t type = TSDB_DATA_TYPE_NULL;
-    if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+    if (pRuntimeEnv->groupbyNormalCol) {
       type = getGroupbyColumnType(pQuery, pQuery->pGroupbyExpr);
     } else {
       type = TSDB_DATA_TYPE_TIMESTAMP;
@@ -4159,8 +4208,9 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
 
   // todo refactor
   pRuntimeEnv->topBotQuery = isTopBottomQuery(pQuery);
-  setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
+  pRuntimeEnv->hasTagResults = hasTagValOutput(pQuery);
 
+  setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -4201,7 +4251,7 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
     SDataStatis *pStatis = NULL;
     SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
 
-    if (!isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
+    if (!pRuntimeEnv->groupbyNormalCol) {
       if (!isIntervalQuery(pQuery)) {
         int32_t step = QUERY_IS_ASC_QUERY(pQuery)? 1:-1;
         setExecutionContext(pQInfo, (*pTableQueryInfo)->groupIndex, blockInfo.window.ekey + step);
@@ -4233,9 +4283,9 @@ static bool multiTableMultioutputHelper(SQInfo *pQInfo, int32_t index) {
 
   setTagVal(pRuntimeEnv, pCheckInfo->pTable, pQInfo->tsdb);
 
-  STableId id = tsdbGetTableId(pCheckInfo->pTable);
+  STableId* id = TSDB_TABLEID(pCheckInfo->pTable);
   qDebug("QInfo:%p query on (%d): uid:%" PRIu64 ", tid:%d, qrange:%" PRId64 "-%" PRId64, pQInfo, index,
-         id.uid, id.tid, pCheckInfo->lastKey, pCheckInfo->win.ekey);
+         id->uid, id->tid, pCheckInfo->lastKey, pCheckInfo->win.ekey);
 
   STsdbQueryCond cond = {
       .twindow   = {pCheckInfo->lastKey, pCheckInfo->win.ekey},
@@ -4364,7 +4414,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
         break;
       }
     }
-  } else if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) { // group-by on normal columns query
+  } else if (pRuntimeEnv->groupbyNormalCol) { // group-by on normal columns query
     while (pQInfo->groupIndex < numOfGroups) {
       SArray* group = taosArrayGetP(pQInfo->tableGroupInfo.pGroupList, pQInfo->groupIndex);
 
@@ -4502,11 +4552,11 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
          */
         pQInfo->tableIndex++;
 
-        STableIdInfo tidInfo;
-        STableId id = tsdbGetTableId(pQuery->current->pTable);
+        STableIdInfo tidInfo = {0};
 
-        tidInfo.uid = id.uid;
-        tidInfo.tid = id.tid;
+        STableId* id = TSDB_TABLEID(pQuery->current->pTable);
+        tidInfo.uid = id->uid;
+        tidInfo.tid = id->tid;
         tidInfo.key = pQuery->current->lastKey;
         taosArrayPush(pQInfo->arrTableIdInfo, &tidInfo);
 
@@ -4680,7 +4730,7 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
     return;
   }
 
-  if (isIntervalQuery(pQuery) || isSumAvgRateQuery(pQuery)) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) || isSumAvgRateQuery(pQuery)) {
     if (mergeIntoGroupResult(pQInfo) == TSDB_CODE_SUCCESS) {
       copyResToQueryResultBuf(pQInfo, pQuery);
 
@@ -4777,10 +4827,10 @@ static void tableMultiOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
         pQuery->current->lastKey, pQuery->window.ekey);
   } else if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
     STableIdInfo tidInfo;
-    STableId id = tsdbGetTableId(pQuery->current);
+    STableId* id = TSDB_TABLEID(pQuery->current);
 
-    tidInfo.uid = id.uid;
-    tidInfo.tid = id.tid;
+    tidInfo.uid = id->uid;
+    tidInfo.tid = id->tid;
     tidInfo.key = pQuery->current->lastKey;
     taosArrayPush(pQInfo->arrTableIdInfo, &tidInfo);
   }
@@ -4870,7 +4920,7 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
   }
 
   // all data scanned, the group by normal column can return
-  if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // todo refactor with merge interval time result
+  if (pRuntimeEnv->groupbyNormalCol) {  // todo refactor with merge interval time result
     pQInfo->groupIndex = 0;
     pQuery->rec.rows = 0;
     copyFromWindowResToSData(pQInfo, pRuntimeEnv->windowResInfo.pResult);
@@ -4931,7 +4981,7 @@ static void tableQueryImpl(SQInfo *pQInfo) {
   STableQueryInfo* item = taosArrayGetP(g, 0);
   
   // group by normal column, sliding window query, interval query are handled by interval query processor
-  if (isIntervalQuery(pQuery) || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // interval (down sampling operation)
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) || pRuntimeEnv->groupbyNormalCol) {  // interval (down sampling operation)
     tableIntervalProcess(pQInfo, item);
   } else if (isFixedOutputQuery(pQuery)) {
     tableFixedOutputProcess(pQInfo, item);
@@ -4946,18 +4996,19 @@ static void tableQueryImpl(SQInfo *pQInfo) {
 }
 
 static void stableQueryImpl(SQInfo *pQInfo) {
-  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQuery *pQuery = pRuntimeEnv->pQuery;
   pQuery->rec.rows = 0;
 
   int64_t st = taosGetTimestampUs();
 
-  if (isIntervalQuery(pQuery) ||
-      (isFixedOutputQuery(pQuery) && (!isPointInterpoQuery(pQuery)) && !isGroupbyNormalCol(pQuery->pGroupbyExpr) &&
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) ||
+      (isFixedOutputQuery(pQuery) && (!isPointInterpoQuery(pQuery)) && !pRuntimeEnv->groupbyNormalCol &&
       !isFirstLastRowQuery(pQuery))) {
     multiTableQueryProcess(pQInfo);
   } else {
     assert((pQuery->checkBuffer == 1 && pQuery->intervalTime == 0) || isPointInterpoQuery(pQuery) ||
-            isFirstLastRowQuery(pQuery) || isGroupbyNormalCol(pQuery->pGroupbyExpr));
+            isFirstLastRowQuery(pQuery) || pRuntimeEnv->groupbyNormalCol);
 
     sequentialTableProcess(pQInfo);
   }
@@ -5652,28 +5703,33 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
   STimeWindow window = pQueryMsg->window;
   taosArraySort(pTableIdList, compareTableIdInfo);
 
+  // TODO optimize the STableQueryInfo malloc strategy
+  pQInfo->pBuf = calloc(pTableGroupInfo->numOfTables, sizeof(STableQueryInfo));
+  int32_t index = 0;
+
   for(int32_t i = 0; i < numOfGroups; ++i) {
     SArray* pa = taosArrayGetP(pTableGroupInfo->pGroupList, i);
-    size_t s = taosArrayGetSize(pa);
 
+    size_t s = taosArrayGetSize(pa);
     SArray* p1 = taosArrayInit(s, POINTER_BYTES);
 
     for(int32_t j = 0; j < s; ++j) {
       void* pTable = taosArrayGetP(pa, j);
+      STableId* id = TSDB_TABLEID(pTable);
 
-      // NOTE: compare STableIdInfo with STableId
-      STableId id = tsdbGetTableId(pTable);
-      STableIdInfo* pTableId = taosArraySearch(pTableIdList, &id, compareTableIdInfo);
+      STableIdInfo* pTableId = taosArraySearch(pTableIdList, id, compareTableIdInfo);
       if (pTableId != NULL ) {
         window.skey = pTableId->key;
       } else {
         window.skey = pQueryMsg->window.skey;
       }
 
-      STableQueryInfo* item = createTableQueryInfo(&pQInfo->runtimeEnv, pTable, window);
+      void* buf = pQInfo->pBuf + index * sizeof(STableQueryInfo);
+      STableQueryInfo* item = createTableQueryInfo(&pQInfo->runtimeEnv, pTable, window, buf);
       item->groupIndex = i;
       taosArrayPush(p1, &item);
-      taosHashPut(pQInfo->tableqinfoGroupInfo.map, &id.tid, sizeof(id.tid), &item, POINTER_BYTES);
+      taosHashPut(pQInfo->tableqinfoGroupInfo.map, &id->tid, sizeof(id->tid), &item, POINTER_BYTES);
+      index += 1;
     }
 
     taosArrayPush(pQInfo->tableqinfoGroupInfo.pGroupList, &p1);
@@ -5817,6 +5873,7 @@ static void freeQInfo(SQInfo *pQInfo) {
     taosArrayDestroy(p);
   }
 
+  tfree(pQInfo->pBuf);
   taosArrayDestroy(pQInfo->tableqinfoGroupInfo.pGroupList);
   taosHashCleanup(pQInfo->tableqinfoGroupInfo.map);
   tsdbDestoryTableGroup(&pQInfo->tableGroupInfo);
@@ -6093,7 +6150,8 @@ void qTableQuery(qinfo_t qinfo) {
     return;
   }
 
-  int32_t ret = setjmp(pQInfo->env);
+  int32_t ret = setjmp(pQInfo->runtimeEnv.env);
+
   // error occurs, record the error code and return to client
   if (ret != TSDB_CODE_SUCCESS) {
     pQInfo->code = ret;
@@ -6276,13 +6334,13 @@ static void buildTagQueryResult(SQInfo* pQInfo) {
       varDataSetLen(output, rsize - VARSTR_HEADER_SIZE);
 
       output = varDataVal(output);
-      STableId id = tsdbGetTableId(item->pTable);
+      STableId* id = TSDB_TABLEID(item->pTable);
 
-      *(int64_t *)output = id.uid;  // memory align problem, todo serialize
-      output += sizeof(id.uid);
+      *(int64_t *)output = id->uid;  // memory align problem, todo serialize
+      output += sizeof(id->uid);
 
-      *(int32_t *)output = id.tid;
-      output += sizeof(id.tid);
+      *(int32_t *)output = id->tid;
+      output += sizeof(id->tid);
 
       *(int32_t *)output = pQInfo->vgId;
       output += sizeof(pQInfo->vgId);
diff --git a/src/query/src/qUtil.c b/src/query/src/qUtil.c
index d7725f561d..9541f283f0 100644
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
@@ -32,7 +32,6 @@ int32_t initWindowResInfo(SWindowResInfo *pWindowResInfo, SQueryRuntimeEnv *pRun
   pWindowResInfo->threshold = threshold;
   
   pWindowResInfo->type = type;
-  
   _hash_fn_t fn = taosGetDefaultHashFunction(type);
   pWindowResInfo->hashList = taosHashInit(threshold, fn, false);
   
@@ -54,7 +53,8 @@ void destroyTimeWindowRes(SWindowResult *pWindowRes, int32_t nOutputCols) {
   if (pWindowRes == NULL) {
     return;
   }
-  
+
+  // TODO opt malloc strategy
   for (int32_t i = 0; i < nOutputCols; ++i) {
     free(pWindowRes->resultInfo[i].interResultBuf);
   }
diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index 3ae88c3141..e1bed01255 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -47,9 +47,9 @@ extern int tsdbDebugFlag;
 // Definitions
 // ------------------ tsdbMeta.c
 typedef struct STable {
+  STableId       tableId;
   ETableType     type;
   tstr*          name;  // NOTE: there a flexible string here
-  STableId       tableId;
   uint64_t       suid;
   struct STable* pSuper;  // super table pointer
   uint8_t        numOfSchemas;
@@ -294,14 +294,36 @@ typedef struct {
 #define TABLE_SUID(t) (t)->suid
 #define TABLE_LASTKEY(t) (t)->lastKey
 
+static FORCE_INLINE STSchema *tsdbGetTableSchema(STable *pTable) {
+  if (pTable->type == TSDB_CHILD_TABLE) {  // check child table first
+    STable *pSuper = pTable->pSuper;
+    if (pSuper == NULL) return NULL;
+    return pSuper->schema[pSuper->numOfSchemas - 1];
+  } else if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) {
+    return pTable->schema[pTable->numOfSchemas - 1];
+  } else {
+    return NULL;
+  }
+}
+
+static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {
+  if (pTable->type == TSDB_CHILD_TABLE) {  // check child table first
+    STable *pSuper = pTable->pSuper;
+    if (pSuper == NULL) return NULL;
+    return pSuper->tagSchema;
+  } else if (pTable->type == TSDB_SUPER_TABLE) {
+    return pTable->tagSchema;
+  } else {
+    return NULL;
+  }
+}
+
 STsdbMeta* tsdbNewMeta(STsdbCfg* pCfg);
 void       tsdbFreeMeta(STsdbMeta* pMeta);
 int        tsdbOpenMeta(STsdbRepo* pRepo);
 int        tsdbCloseMeta(STsdbRepo* pRepo);
-STSchema*  tsdbGetTableSchema(STable* pTable);
 STable*    tsdbGetTableByUid(STsdbMeta* pMeta, uint64_t uid);
 STSchema*  tsdbGetTableSchemaByVersion(STable* pTable, int16_t version);
-STSchema*  tsdbGetTableTagSchema(STable* pTable);
 int        tsdbUpdateTable(STsdbRepo* pRepo, STable* pTable, STableCfg* pCfg);
 int        tsdbWLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbRLockRepoMeta(STsdbRepo* pRepo);
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index cbbf51d862..ad25b7f675 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -449,18 +449,6 @@ int tsdbCloseMeta(STsdbRepo *pRepo) {
   return 0;
 }
 
-STSchema *tsdbGetTableSchema(STable *pTable) {
-  if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) {
-    return pTable->schema[pTable->numOfSchemas - 1];
-  } else if (pTable->type == TSDB_CHILD_TABLE) {
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->schema[pSuper->numOfSchemas - 1];
-  } else {
-    return NULL;
-  }
-}
-
 STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
   void *ptr = taosHashGet(pMeta->uidMap, (char *)(&uid), sizeof(uid));
 
@@ -480,18 +468,6 @@ STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t version) {
   return *(STSchema **)ptr;
 }
 
-STSchema *tsdbGetTableTagSchema(STable *pTable) {
-  if (pTable->type == TSDB_SUPER_TABLE) {
-    return pTable->tagSchema;
-  } else if (pTable->type == TSDB_CHILD_TABLE) {
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->tagSchema;
-  } else {
-    return NULL;
-  }
-}
-
 int tsdbUpdateTable(STsdbRepo *pRepo, STable *pTable, STableCfg *pCfg) {
   // TODO: this function can only be called when there is no query and commit on this table
   ASSERT(TABLE_TYPE(pTable) != TSDB_CHILD_TABLE);

From 8559032b5fe999ede530d8bf37817585859ffbeb Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Sun, 5 Jul 2020 19:22:55 +0800
Subject: [PATCH 12/87] finish change table function

---
 src/inc/tsdb.h             |   2 +-
 src/tsdb/inc/tsdbMain.h    |   3 +-
 src/tsdb/src/tsdbMeta.c    | 238 +++++++++++++++++--------------------
 src/vnode/src/vnodeWrite.c |   2 +-
 4 files changed, 111 insertions(+), 134 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index e2fec9b3dd..ec981a7962 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -113,7 +113,7 @@ STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
 
 int   tsdbCreateTable(TSDB_REPO_T *repo, STableCfg *pCfg);
 int   tsdbDropTable(TSDB_REPO_T *pRepo, STableId tableId);
-int   tsdbUpdateTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg);
+int   tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg);
 TSKEY tsdbGetTableLastKey(TSDB_REPO_T *repo, uint64_t uid);
 void  tsdbStartStream(TSDB_REPO_T *repo);
 
diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index f431830d94..b736b8824c 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -302,7 +302,7 @@ STSchema*  tsdbGetTableSchema(STable* pTable);
 STable*    tsdbGetTableByUid(STsdbMeta* pMeta, uint64_t uid);
 STSchema*  tsdbGetTableSchemaByVersion(STable* pTable, int16_t version);
 STSchema*  tsdbGetTableTagSchema(STable* pTable);
-int        tsdbUpdateTable(STsdbRepo* pRepo, STable* pTable, STableCfg* pCfg);
+// int        tsdbUpdateTable(STsdbRepo* pRepo, STable* pTable, STableCfg* pCfg);
 int        tsdbWLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbRLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbUnlockRepoMeta(STsdbRepo* pRepo);
@@ -321,7 +321,6 @@ static FORCE_INLINE int tsdbCompareSchemaVersion(const void *key1, const void *k
 }
 
 static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock, bool copy, int16_t version) {
-  ASSERT(TABLE_TYPE(pTable) != TSDB_SUPER_TABLE);
   STable*   pDTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
   STSchema* pSchema = NULL;
   STSchema* pTSchema = NULL;
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index a473f86fa0..d474db876c 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -29,10 +29,9 @@ static void    tsdbOrgMeta(void *pHandle);
 static char *  getTagIndexKey(const void *pData);
 static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper);
 static void    tsdbFreeTable(STable *pTable);
-static int     tsdbUpdateTableTagSchema(STable *pTable, STSchema *newSchema);
-static int     tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx);
+static int     tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx, bool lock);
 static void    tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFromIdx, bool lock);
-static int     tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable);
+static int     tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable, bool refSuper);
 static int     tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable);
 static int     tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t tid);
 static int     tsdbTableSetSchema(STableCfg *config, STSchema *pSchema, bool dup);
@@ -76,7 +75,7 @@ int tsdbCreateTable(TSDB_REPO_T *repo, STableCfg *pCfg) {
       // TODO
       if (super->type != TSDB_SUPER_TABLE) return -1;
       if (super->tableId.uid != pCfg->superUid) return -1;
-      tsdbUpdateTable(pRepo, super, pCfg);
+      // tsdbUpdateTable(pRepo, super, pCfg);
     }
   }
 
@@ -84,10 +83,18 @@ int tsdbCreateTable(TSDB_REPO_T *repo, STableCfg *pCfg) {
   if (table == NULL) goto _err;
 
   // Register to meta
+  tsdbWLockRepoMeta(pRepo);
   if (newSuper) {
-    if (tsdbAddTableToMeta(pRepo, super, true) < 0) goto _err;
+    if (tsdbAddTableToMeta(pRepo, super, true, false) < 0) {
+      tsdbUnlockRepoMeta(pRepo);
+      goto _err;
+    }
   }
-  if (tsdbAddTableToMeta(pRepo, table, true) < 0) goto _err;
+  if (tsdbAddTableToMeta(pRepo, table, true, false) < 0) {
+    tsdbUnlockRepoMeta(pRepo);
+    goto _err;
+  }
+  tsdbUnlockRepoMeta(pRepo);
 
   // Write to memtable action
   int   tlen1 = (newSuper) ? tsdbGetTableEncodeSize(TSDB_UPDATE_META, super) : 0;
@@ -255,7 +262,7 @@ _err:
   return NULL;
 }
 
-static int32_t colIdCompar(const void* left, const void* right) {
+static UNUSED_FUNC int32_t colIdCompar(const void* left, const void* right) {
   int16_t colId = *(int16_t*) left;
   STColumn* p2 = (STColumn*) right;
 
@@ -266,9 +273,10 @@ static int32_t colIdCompar(const void* left, const void* right) {
   return (colId < p2->colId)? -1:1;
 }
 
-int tsdbUpdateTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
+int tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
   STsdbRepo *pRepo = (STsdbRepo *)repo;
   STsdbMeta *pMeta = pRepo->tsdbMeta;
+  STSchema * pNewSchema = NULL;
 
   pMsg->uid = htobe64(pMsg->uid);
   pMsg->tid = htonl(pMsg->tid);
@@ -277,78 +285,105 @@ int tsdbUpdateTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
   pMsg->tagValLen = htonl(pMsg->tagValLen);
   pMsg->numOfTags = htons(pMsg->numOfTags);
   pMsg->schemaLen = htonl(pMsg->schemaLen);
-  assert(pMsg->schemaLen == sizeof(STColumn) * pMsg->numOfTags);
-
-  char* d = pMsg->data;
-  for(int32_t i = 0; i < pMsg->numOfTags; ++i) {
-    STColumn* pCol = (STColumn*) d;
-    pCol->colId = htons(pCol->colId);
-    pCol->bytes = htons(pCol->bytes);
-    pCol->offset = 0;
-
-    d += sizeof(STColumn);
+  for (int i = 0; i < pMsg->numOfTags; i++) {
+    STColumn *pTCol = (STColumn *)pMsg->data + i;
+    pTCol->bytes = htons(pTCol->bytes);
+    pTCol->colId = htons(pTCol->colId);
   }
 
   STable *pTable = tsdbGetTableByUid(pMeta, pMsg->uid);
-  if (pTable == NULL) {
-    terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
-    return -1;
-  }
-  if (TABLE_TID(pTable) != pMsg->tid) {
+  if (pTable == NULL || TABLE_TID(pTable) != pMsg->tid) {
+    tsdbError("vgId:%d failed to update table tag value since invalid table id %d uid %" PRIu64, REPO_ID(pRepo),
+              pMsg->tid, pMsg->uid);
     terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
     return -1;
   }
 
   if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
-    tsdbError("vgId:%d failed to update tag value of table %s since its type is %d", REPO_ID(pRepo),
-              TABLE_CHAR_NAME(pTable), TABLE_TYPE(pTable));
+    tsdbError("vgId:%d try to update tag value of a non-child table, invalid action", REPO_ID(pRepo));
     terrno = TSDB_CODE_TDB_INVALID_ACTION;
     return -1;
   }
 
-  if (schemaVersion(tsdbGetTableTagSchema(pTable)) < pMsg->tversion) {
-    tsdbDebug("vgId:%d server tag version %d is older than client tag version %d, try to config", REPO_ID(pRepo),
-              schemaVersion(tsdbGetTableTagSchema(pTable)), pMsg->tversion);
-    void *msg = (*pRepo->appH.configFunc)(pRepo->config.tsdbId, pMsg->tid);
-    if (msg == NULL) return -1;
-
-    // Deal with error her
-    STableCfg *pTableCfg = tsdbCreateTableCfgFromMsg(msg);
-    STable *   super = tsdbGetTableByUid(pMeta, pTableCfg->superUid);
-    ASSERT(super != NULL);
-
-    int32_t code = tsdbUpdateTable(pRepo, super, pTableCfg);
-    if (code != TSDB_CODE_SUCCESS) {
-      tsdbClearTableCfg(pTableCfg);
-      return code;
-    }
-    tsdbClearTableCfg(pTableCfg);
-    rpcFreeCont(msg);
-  }
-
-  STSchema *pTagSchema = tsdbGetTableTagSchema(pTable);
-
-  if (schemaVersion(pTagSchema) > pMsg->tversion) {
+  if (schemaVersion(pTable->pSuper->tagSchema) > pMsg->tversion) {
     tsdbError(
         "vgId:%d failed to update tag value of table %s since version out of date, client tag version %d server tag "
         "version %d",
         REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), pMsg->tversion, schemaVersion(pTable->tagSchema));
-    return TSDB_CODE_TDB_TAG_VER_OUT_OF_DATE;
+    terrno = TSDB_CODE_TDB_TAG_VER_OUT_OF_DATE;
+    return -1;
   }
-  if (schemaColAt(pTagSchema, DEFAULT_TAG_INDEX_COLUMN)->colId == pMsg->colId) {
+
+  if (schemaVersion(pTable->pSuper->tagSchema) < pMsg->tversion) {  // tag schema out of data,
+    tsdbDebug("vgId:%d need to update tag schema of table %s tid %d uid %" PRIu64
+              " since out of date, current version %d new version %d",
+              REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable),
+              schemaVersion(pTable->pSuper->tagSchema), pMsg->tversion);
+
+    STSchemaBuilder schemaBuilder = {0};
+
+    STColumn *pTCol = (STColumn *)pMsg->data;
+    ASSERT(pMsg->schemaLen % sizeof(STColumn) == 0 && pTCol[0].colId == colColId(schemaColAt(pTable->pSuper->tagSchema, 0)));
+    if (tdInitTSchemaBuilder(&schemaBuilder, pMsg->tversion) < 0) {
+      tsdbDebug("vgId:%d failed to update tag schema of table %s tid %d uid %" PRIu64 " since out of memory",
+                REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable));
+      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+      return -1;
+    }
+    for (int i = 0; i < (pMsg->schemaLen / sizeof(STColumn)); i++) {
+      if (tdAddColToSchema(&schemaBuilder, pTCol[i].type, pTCol[i].colId, pTCol[i].bytes) < 0) {
+        tdDestroyTSchemaBuilder(&schemaBuilder);
+        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+        return -1;
+      }
+    }
+    pNewSchema = tdGetSchemaFromBuilder(&schemaBuilder);
+    if (pNewSchema == NULL) {
+      tdDestroyTSchemaBuilder(&schemaBuilder);
+      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+      return -1;
+    }
+    tdDestroyTSchemaBuilder(&schemaBuilder);
+  }
+
+  // Chage in memory
+  if (pNewSchema != NULL) { // change super table tag schema
+    taosWLockLatch(&(pTable->pSuper->latch));
+    STSchema *pOldSchema = pTable->pSuper->tagSchema;
+    pTable->pSuper->tagSchema = pNewSchema;
+    tdFreeSchema(pOldSchema);
+    taosWUnLockLatch(&(pTable->pSuper->latch));
+  }
+
+  bool      isChangeIndexCol = (pMsg->colId == colColId(schemaColAt(pTable->pSuper->tagSchema, 0)));
+  STColumn *pCol = bsearch(&(pMsg->colId), pMsg->data, pMsg->numOfTags, sizeof(STColumn), colIdCompar);
+  ASSERT(pCol != NULL);
+
+  if (isChangeIndexCol) {
+    tsdbWLockRepoMeta(pRepo);
     tsdbRemoveTableFromIndex(pMeta, pTable);
   }
-  // TODO: remove table from index if it is the first column of tag
-
-  // TODO: convert the tag schema from client, and then extract the type and bytes from schema according to colId
-  STColumn* res = bsearch(&pMsg->colId, pMsg->data, pMsg->numOfTags, sizeof(STColumn), colIdCompar);
-  assert(res != NULL);
-
-  tdSetKVRowDataOfCol(&pTable->tagVal, pMsg->colId, res->type, pMsg->data + pMsg->schemaLen);
-  if (schemaColAt(pTagSchema, DEFAULT_TAG_INDEX_COLUMN)->colId == pMsg->colId) {
-    tsdbAddTableIntoIndex(pMeta, pTable);
+  taosWLockLatch(&(pTable->latch));
+  tdSetKVRowDataOfCol(&(pTable->tagVal), pMsg->colId, pCol->type, POINTER_SHIFT(pMsg->data, pMsg->schemaLen));
+  taosWUnLockLatch(&(pTable->latch));
+  if (isChangeIndexCol) {
+    tsdbAddTableIntoIndex(pMeta, pTable, false);
+    tsdbUnlockRepoMeta(pRepo);
   }
-  return TSDB_CODE_SUCCESS;
+
+  // Update on file
+  int tlen1 = (pNewSchema) ? tsdbGetTableEncodeSize(TSDB_UPDATE_META, pTable->pSuper) : 0;
+  int tlen2 = tsdbGetTableEncodeSize(TSDB_UPDATE_META, pTable);
+  void *buf = tsdbAllocBytes(pRepo, tlen1+tlen2);
+  ASSERT(buf != NULL);
+  if (pNewSchema) {
+    void *pBuf = tsdbInsertTableAct(pRepo, TSDB_UPDATE_META, buf, pTable->pSuper);
+    ASSERT(POINTER_DISTANCE(pBuf, buf) == tlen1);
+    buf = pBuf;
+  }
+  tsdbInsertTableAct(pRepo, TSDB_UPDATE_META, buf, pTable);
+
+  return 0;
 }
 
 // ------------------ INTERNAL FUNCTIONS ------------------
@@ -449,7 +484,7 @@ int tsdbCloseMeta(STsdbRepo *pRepo) {
   return 0;
 }
 
-STSchema *tsdbGetTableSchema(STable *pTable) { return tsdbGetTableSchemaImpl(pTable, true, true, -1); }
+STSchema *tsdbGetTableSchema(STable *pTable) { return tsdbGetTableSchemaImpl(pTable, true, false, -1); }
 
 STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
   void *ptr = taosHashGet(pMeta->uidMap, (char *)(&uid), sizeof(uid));
@@ -460,7 +495,7 @@ STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
 }
 
 STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t version) {
-  return tsdbGetTableSchemaImpl(pTable, true, true, version);
+  return tsdbGetTableSchemaImpl(pTable, true, false, version);
 }
 
 STSchema *tsdbGetTableTagSchema(STable *pTable) {
@@ -475,48 +510,6 @@ STSchema *tsdbGetTableTagSchema(STable *pTable) {
   }
 }
 
-int tsdbUpdateTable(STsdbRepo *pRepo, STable *pTable, STableCfg *pCfg) {
-  // TODO: this function can only be called when there is no query and commit on this table
-  ASSERT(TABLE_TYPE(pTable) != TSDB_CHILD_TABLE);
-  bool       changed = false;
-  STsdbMeta *pMeta = pRepo->tsdbMeta;
-
-  if ((pTable->type == TSDB_SUPER_TABLE) && (schemaVersion(pTable->tagSchema) < schemaVersion(pCfg->tagSchema))) {
-    if (tsdbUpdateTableTagSchema(pTable, pCfg->tagSchema) < 0) {
-      tsdbError("vgId:%d failed to update table %s tag schema since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-                tstrerror(terrno));
-      return -1;
-    }
-    changed = true;
-  }
-
-  STSchema *pTSchema = tsdbGetTableSchema(pTable);
-  if (schemaVersion(pTSchema) < schemaVersion(pCfg->schema)) {
-    if (pTable->numOfSchemas < TSDB_MAX_TABLE_SCHEMAS) {
-      pTable->schema[pTable->numOfSchemas++] = tdDupSchema(pCfg->schema);
-    } else {
-      ASSERT(pTable->numOfSchemas == TSDB_MAX_TABLE_SCHEMAS);
-      STSchema *tSchema = tdDupSchema(pCfg->schema);
-      tdFreeSchema(pTable->schema[0]);
-      memmove(pTable->schema, pTable->schema + 1, sizeof(STSchema *) * (TSDB_MAX_TABLE_SCHEMAS - 1));
-      pTable->schema[pTable->numOfSchemas - 1] = tSchema;
-    }
-
-    pMeta->maxRowBytes = MAX(pMeta->maxRowBytes, dataRowMaxBytesFromSchema(pCfg->schema));
-    pMeta->maxCols = MAX(pMeta->maxCols, schemaNCols(pCfg->schema));
-
-    changed = true;
-  }
-
-  if (changed) {
-    int   tlen = tsdbGetTableEncodeSize(TSDB_UPDATE_META, pTable);
-    void *buf = tsdbAllocBytes(pRepo, tlen);
-    tsdbInsertTableAct(pRepo, TSDB_UPDATE_META, buf, pTable);
-  }
-
-  return 0;
-}
-
 int tsdbWLockRepoMeta(STsdbRepo *pRepo) {
   int code = pthread_rwlock_wrlock(&(pRepo->tsdbMeta->rwLock));
   if (code != 0) {
@@ -607,7 +600,7 @@ static int tsdbRestoreTable(void *pHandle, void *cont, int contLen) {
 
   tsdbDecodeTable(cont, &pTable);
 
-  if (tsdbAddTableToMeta(pRepo, pTable, false) < 0) {
+  if (tsdbAddTableToMeta(pRepo, pTable, false, false) < 0) {
     tsdbFreeTable(pTable);
     return -1;
   }
@@ -625,7 +618,7 @@ static void tsdbOrgMeta(void *pHandle) {
   for (int i = 1; i < pCfg->maxTables; i++) {
     STable *pTable = pMeta->tables[i];
     if (pTable != NULL && pTable->type == TSDB_CHILD_TABLE) {
-      tsdbAddTableIntoIndex(pMeta, pTable);
+      tsdbAddTableIntoIndex(pMeta, pTable, true);
     }
   }
 }
@@ -735,7 +728,7 @@ _err:
 
 static void tsdbFreeTable(STable *pTable) {
   if (pTable) {
-    tsdbDebug("table %s is destroyed", TABLE_CHAR_NAME(pTable));
+    if (pTable->name != NULL) tsdbDebug("table %s is destroyed", TABLE_CHAR_NAME(pTable));
     tfree(TABLE_NAME(pTable));
     if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
       for (int i = 0; i < TSDB_MAX_TABLE_SCHEMAS; i++) {
@@ -755,25 +748,10 @@ static void tsdbFreeTable(STable *pTable) {
   }
 }
 
-static int tsdbUpdateTableTagSchema(STable *pTable, STSchema *newSchema) {
-  ASSERT(pTable->type == TSDB_SUPER_TABLE);
-  ASSERT(schemaVersion(pTable->tagSchema) < schemaVersion(newSchema));
-  STSchema *pOldSchema = pTable->tagSchema;
-  STSchema *pNewSchema = tdDupSchema(newSchema);
-  if (pNewSchema == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return -1;
-  }
-  pTable->tagSchema = pNewSchema;
-  tdFreeSchema(pOldSchema);
-
-  return 0;
-}
-
-static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx) {
+static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx, bool lock) {
   STsdbMeta *pMeta = pRepo->tsdbMeta;
 
-  if (addIdx && tsdbWLockRepoMeta(pRepo) < 0) {
+  if (lock && tsdbWLockRepoMeta(pRepo) < 0) {
     tsdbError("vgId:%d failed to add table %s to meta since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
               tstrerror(terrno));
     return -1;
@@ -788,7 +766,7 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx) {
     }
   } else {
     if (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE && addIdx) {  // add STABLE to the index
-      if (tsdbAddTableIntoIndex(pMeta, pTable) < 0) {
+      if (tsdbAddTableIntoIndex(pMeta, pTable, true) < 0) {
         tsdbDebug("vgId:%d failed to add table %s to meta while add table to index since %s", REPO_ID(pRepo),
                   TABLE_CHAR_NAME(pTable), tstrerror(terrno));
         goto _err;
@@ -812,7 +790,7 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx) {
     if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
   }
 
-  if (addIdx && tsdbUnlockRepoMeta(pRepo) < 0) return -1;
+  if (lock && tsdbUnlockRepoMeta(pRepo) < 0) return -1;
   if (TABLE_TYPE(pTable) == TSDB_STREAM_TABLE && addIdx) {
     pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), pTable->sql,
                                                    tsdbGetTableSchemaImpl(pTable, false, false, -1));
@@ -824,7 +802,7 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx) {
 
 _err:
   tsdbRemoveTableFromMeta(pRepo, pTable, false, false);
-  if (addIdx) tsdbUnlockRepoMeta(pRepo);
+  if (lock) tsdbUnlockRepoMeta(pRepo);
   return -1;
 }
 
@@ -881,7 +859,7 @@ static void tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFro
   tsdbUnRefTable(pTable);
 }
 
-static int tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable) {
+static int tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable, bool refSuper) {
   ASSERT(pTable->type == TSDB_CHILD_TABLE && pTable != NULL);
   STable *pSTable = tsdbGetTableByUid(pMeta, TABLE_SUID(pTable));
   ASSERT(pSTable != NULL);
@@ -905,7 +883,7 @@ static int tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable) {
   memcpy(SL_GET_NODE_DATA(pNode), &pTable, sizeof(STable *));
 
   tSkipListPut(pSTable->pIndex, pNode);
-  T_REF_INC(pSTable);
+  if (refSuper) T_REF_INC(pSTable);
   return 0;
 }
 
@@ -1273,4 +1251,4 @@ static int tsdbRmTableFromMeta(STsdbRepo *pRepo, STable *pTable) {
   }
 
   return 0;
-}
+}
\ No newline at end of file
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index 171557acb6..f13598875a 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -158,7 +158,7 @@ static int32_t vnodeProcessDropStableMsg(SVnodeObj *pVnode, void *pCont, SRspRet
 }
 
 static int32_t vnodeProcessUpdateTagValMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {
-  if (tsdbUpdateTagValue(pVnode->tsdb, (SUpdateTableTagValMsg *)pCont) < 0) {
+  if (tsdbUpdateTableTagValue(pVnode->tsdb, (SUpdateTableTagValMsg *)pCont) < 0) {
     return terrno;
   }
   return TSDB_CODE_SUCCESS;

From 5c2b0097a770f6e889485eaaf5471f3c0e551d3d Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 6 Jul 2020 03:33:11 +0000
Subject: [PATCH 13/87] Minor tweak of crash_gen tool

---
 src/wal/src/walMain.c     |  1 +
 tests/pytest/crash_gen.py | 19 +++++++++++++++----
 tests/pytest/crash_gen.sh |  2 +-
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/wal/src/walMain.c b/src/wal/src/walMain.c
index e079653ab3..ae4beabb37 100644
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
@@ -196,6 +196,7 @@ void walFsync(void *handle) {
   if (pWal == NULL) return;
 
   if (pWal->level == TAOS_WAL_FSYNC && pWal->fd >=0) {
+    printf("WAL-SYNC executed\n");
     if (fsync(pWal->fd) < 0) {
       wError("wal:%s, fsync failed(%s)", pWal->name, strerror(errno));
     }
diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 9d3c66b97f..a6e2414262 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python3.7
+#-----!/usr/bin/python3.7
 ###################################################################
 #           Copyright (c) 2016 by TAOS Technologies, Inc.
 #                     All rights reserved.
@@ -25,6 +25,7 @@ if sys.version_info[0] < 3:
 import getopt
 import argparse
 import copy
+import requests
 
 import threading
 import random
@@ -1061,8 +1062,11 @@ class DbManager():
 
     def getNextTick(self):
         with self._lock: # prevent duplicate tick
-            self._lastTick += datetime.timedelta(0, 1) # add one second to it
-            return self._lastTick
+            if Dice.throw(10) == 0 : # 1 in 10 chance
+                return self._lastTick + datetime.timedelta(0, -100)
+            else: # regular
+                self._lastTick += datetime.timedelta(0, 1) # add one second to it
+                return self._lastTick
 
     def getNextInt(self):
         with self._lock:
@@ -1220,7 +1224,12 @@ class Task():
                     # sys.exit(-1)
                     self._err = err
                     self._aborted = True
-        except:
+        except Exception as e :
+            self.logInfo("Non-TAOS exception encountered")
+            self._err = e 
+            self._aborted = True
+            traceback.print_exc()
+        except :
             self.logDebug("[=] Unexpected exception, SQL: {}".format(self._lastSql))
             raise
         self._execStats.endTaskType(self.__class__.__name__, self.isSuccess())
@@ -1699,6 +1708,8 @@ class ClientManager:
         dbc = dbManager.getDbConn()
         if dbc.query("show databases") == 0 : # no databae
             return
+        if dbc.query("show tables") == 0 : # no tables
+            return
 
         dbc.execute("use db")
         sTbName = dbManager.getFixedSuperTableName()        
diff --git a/tests/pytest/crash_gen.sh b/tests/pytest/crash_gen.sh
index c845b39764..de80361aa3 100755
--- a/tests/pytest/crash_gen.sh
+++ b/tests/pytest/crash_gen.sh
@@ -38,4 +38,4 @@ export PYTHONPATH=$(pwd)/../../src/connector/python/linux/python3
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/../../build/build/lib
 
 # Now we are all let, and let's see if we can find a crash. Note we pass all params
-./crash_gen.py $@
+python3 ./crash_gen.py $@

From a74e3bff4d004e568d288cb37cf8d286037fdb9f Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 6 Jul 2020 03:34:03 +0000
Subject: [PATCH 14/87] reverting a mistaken change

---
 src/wal/src/walMain.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/wal/src/walMain.c b/src/wal/src/walMain.c
index ae4beabb37..e079653ab3 100644
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
@@ -196,7 +196,6 @@ void walFsync(void *handle) {
   if (pWal == NULL) return;
 
   if (pWal->level == TAOS_WAL_FSYNC && pWal->fd >=0) {
-    printf("WAL-SYNC executed\n");
     if (fsync(pWal->fd) < 0) {
       wError("wal:%s, fsync failed(%s)", pWal->name, strerror(errno));
     }

From ed458e104b6dcc66eda7af16460d72d77a58b748 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 11:41:20 +0800
Subject: [PATCH 15/87] [td-225] refactor code.

---
 src/client/src/tscLocalMerge.c |  8 +++-----
 src/common/inc/tname.h         |  2 ++
 src/common/src/tname.c         | 30 +++++++++++++++++++++++++++
 src/query/inc/qfill.h          |  2 --
 src/query/src/qExecutor.c      | 23 +++++++++------------
 src/query/src/qfill.c          | 37 +---------------------------------
 src/vnode/src/vnodeRead.c      |  2 +-
 7 files changed, 47 insertions(+), 57 deletions(-)

diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 8919d872a6..13523818d1 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -364,7 +364,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
   
   TSKEY stime = MIN(pQueryInfo->window.skey, pQueryInfo->window.ekey);
   int64_t revisedSTime =
-      taosGetIntervalStartTimestamp(stime, pQueryInfo->intervalTime, pQueryInfo->slidingTimeUnit, tinfo.precision);
+      taosGetIntervalStartTimestamp(stime, pQueryInfo->slidingTime, pQueryInfo->intervalTime, pQueryInfo->slidingTimeUnit, tinfo.precision);
   
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
     SFillColInfo* pFillCol = createFillColInfo(pQueryInfo);
@@ -831,7 +831,7 @@ void savePrevRecordAndSetupInterpoInfo(SLocalReducer *pLocalReducer, SQueryInfo
   if (pFillInfo != NULL) {
     int64_t stime = (pQueryInfo->window.skey < pQueryInfo->window.ekey) ? pQueryInfo->window.skey : pQueryInfo->window.ekey;
     int64_t revisedSTime =
-        taosGetIntervalStartTimestamp(stime, pQueryInfo->slidingTime, pQueryInfo->slidingTimeUnit, tinfo.precision);
+        taosGetIntervalStartTimestamp(stime, pQueryInfo->slidingTime, pQueryInfo->intervalTime, pQueryInfo->slidingTimeUnit, tinfo.precision);
   
     taosResetFillInfo(pFillInfo, revisedSTime);
   }
@@ -1301,9 +1301,7 @@ static void resetEnvForNewResultset(SSqlRes *pRes, SSqlCmd *pCmd, SLocalReducer
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
     TSKEY skey = MIN(pQueryInfo->window.skey, pQueryInfo->window.ekey);
     int64_t newTime =
-        taosGetIntervalStartTimestamp(skey, pQueryInfo->intervalTime, pQueryInfo->slidingTimeUnit, precision);
-//    taosResetFillInfo(pLocalReducer->pFillInfo, pQueryInfo->order.order, newTime,
-//                        pQueryInfo->groupbyExpr.numOfGroupCols, 4096, 0, NULL, pLocalReducer->rowSize);
+        taosGetIntervalStartTimestamp(skey, pQueryInfo->slidingTime, pQueryInfo->intervalTime, pQueryInfo->slidingTimeUnit, precision);
     taosResetFillInfo(pLocalReducer->pFillInfo, newTime);
   }
 }
diff --git a/src/common/inc/tname.h b/src/common/inc/tname.h
index 10d725db32..25f78cde7e 100644
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -29,4 +29,6 @@ bool tscValidateTableNameLength(size_t len);
 
 SColumnFilterInfo* tscFilterInfoClone(const SColumnFilterInfo* src, int32_t numOfFilters);
 
+int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, int64_t intervalTime, char timeUnit, int16_t precision);
+
 #endif  // TDENGINE_NAME_H
diff --git a/src/common/src/tname.c b/src/common/src/tname.c
index 295015d466..b3ff15f936 100644
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -75,3 +75,33 @@ SColumnFilterInfo* tscFilterInfoClone(const SColumnFilterInfo* src, int32_t numO
 
   return pFilter;
 }
+
+int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, int64_t intervalTime, char timeUnit, int16_t precision) {
+  if (slidingTime == 0) {
+    return startTime;
+  }
+
+  int64_t start = ((startTime - intervalTime) / slidingTime + 1) * slidingTime;
+  if (!(timeUnit == 'a' || timeUnit == 'm' || timeUnit == 's' || timeUnit == 'h')) {
+    /*
+     * here we revised the start time of day according to the local time zone,
+     * but in case of DST, the start time of one day need to be dynamically decided.
+     */
+    // todo refactor to extract function that is available for Linux/Windows/Mac platform
+#if defined(WINDOWS) && _MSC_VER >= 1900
+    // see https://docs.microsoft.com/en-us/cpp/c-runtime-library/daylight-dstbias-timezone-and-tzname?view=vs-2019
+    int64_t timezone = _timezone;
+    int32_t daylight = _daylight;
+    char**  tzname = _tzname;
+#endif
+
+    int64_t t = (precision == TSDB_TIME_PRECISION_MILLI) ? MILLISECOND_PER_SECOND : MILLISECOND_PER_SECOND * 1000L;
+    start += timezone * t;
+  }
+
+  int64_t end = start + intervalTime - 1;
+  if (end < startTime) {
+    start += slidingTime;
+  }
+  return start;
+}
diff --git a/src/query/inc/qfill.h b/src/query/inc/qfill.h
index da1cd8e5de..ee5974708a 100644
--- a/src/query/inc/qfill.h
+++ b/src/query/inc/qfill.h
@@ -60,8 +60,6 @@ typedef struct SPoint {
   void *  val;
 } SPoint;
 
-int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, char timeUnit, int16_t precision);
-
 SFillInfo* taosInitFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
                             int64_t slidingTime, int8_t slidingUnit, int8_t precision, int32_t fillType,
                             SFillColInfo* pFillCol);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index ad56de9eb1..118a675055 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1681,8 +1681,7 @@ static bool onlyQueryTags(SQuery* pQuery) {
 void getAlignQueryTimeWindow(SQuery *pQuery, int64_t key, int64_t keyFirst, int64_t keyLast, STimeWindow *realWin, STimeWindow *win) {
   assert(key >= keyFirst && key <= keyLast && pQuery->slidingTime <= pQuery->intervalTime);
 
-  win->skey = taosGetIntervalStartTimestamp(key, pQuery->slidingTime, pQuery->slidingTimeUnit, pQuery->precision);
-
+  win->skey = taosGetIntervalStartTimestamp(key, pQuery->slidingTime, pQuery->intervalTime, pQuery->slidingTimeUnit, pQuery->precision);
   if (keyFirst > (INT64_MAX - pQuery->intervalTime)) {
     /*
      * if the realSkey > INT64_MAX - pQuery->intervalTime, the query duration between
@@ -3664,11 +3663,11 @@ void copyFromWindowResToSData(SQInfo *pQInfo, SWindowResult *result) {
   assert(pQuery->rec.rows <= pQuery->rec.capacity);
 }
 
-static UNUSED_FUNC void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, STableQueryInfo *pTableQueryInfo) {
+static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, STableQueryInfo *pTableQueryInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   // update the number of result for each, only update the number of rows for the corresponding window result.
-  if (pQuery->intervalTime == 0) {
+  if (!QUERY_IS_INTERVAL_QUERY(pQuery)) {
 
     for (int32_t i = 0; i < pRuntimeEnv->windowResInfo.size; ++i) {
       SWindowResult *pResult = &pRuntimeEnv->windowResInfo.pResult[i];
@@ -3682,14 +3681,6 @@ static UNUSED_FUNC void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, S
         pResult->numOfRows = MAX(pResult->numOfRows, pResult->resultInfo[j].numOfRes);
       }
     }
-
-//    int32_t g = pTableQueryInfo->groupIndex;
-//    assert(pRuntimeEnv->windowResInfo.size > 0);
-//
-//    SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, &pRuntimeEnv->windowResInfo, (char *)&g, sizeof(g));
-//    if (pWindowRes->numOfRows == 0) {
-//      pWindowRes->numOfRows = getNumOfResult(pRuntimeEnv);
-//    }
   }
 }
 
@@ -4258,7 +4249,10 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
       } else {  // interval query
         TSKEY nextKey = blockInfo.window.skey;
         setIntervalQueryRange(pQInfo, nextKey);
-        /*int32_t ret = */setAdditionalInfo(pQInfo, (*pTableQueryInfo)->pTable, *pTableQueryInfo);
+
+        if (pRuntimeEnv->hasTagResults || pRuntimeEnv->pTSBuf != NULL) {
+          setAdditionalInfo(pQInfo, (*pTableQueryInfo)->pTable, *pTableQueryInfo);
+        }
       }
     }
 
@@ -4658,6 +4652,8 @@ static void doRestoreContext(SQInfo *pQInfo) {
 static void doCloseAllTimeWindowAfterScan(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
+  int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
+
   if (isIntervalQuery(pQuery)) {
     size_t numOfGroup = GET_NUM_OF_TABLEGROUP(pQInfo);
     for (int32_t i = 0; i < numOfGroup; ++i) {
@@ -4667,6 +4663,7 @@ static void doCloseAllTimeWindowAfterScan(SQInfo *pQInfo) {
       for (int32_t j = 0; j < num; ++j) {
         STableQueryInfo* item = taosArrayGetP(group, j);
         closeAllTimeWindow(&item->windowResInfo);
+        removeRedundantWindow(&item->windowResInfo, item->lastKey - step, step);
       }
     }
   } else {  // close results for group result
diff --git a/src/query/src/qfill.c b/src/query/src/qfill.c
index 4cb3779166..eebe9a976b 100644
--- a/src/query/src/qfill.c
+++ b/src/query/src/qfill.c
@@ -22,41 +22,6 @@
 
 #define FILL_IS_ASC_FILL(_f) ((_f)->order == TSDB_ORDER_ASC)
 
-int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, char timeUnit, int16_t precision) {
-  if (slidingTime == 0) {
-    return startTime;
-  }
-
-  if (timeUnit == 'a' || timeUnit == 'm' || timeUnit == 's' || timeUnit == 'h') {
-    return (startTime / slidingTime) * slidingTime;
-  } else {
-    /*
-     * here we revised the start time of day according to the local time zone,
-     * but in case of DST, the start time of one day need to be dynamically decided.
-     *
-     * TODO dynamically decide the start time of a day, move to common module
-     */
-
-    // todo refactor to extract function that is available for Linux/Windows/Mac platform
-#if defined(WINDOWS) && _MSC_VER >= 1900
-    // see https://docs.microsoft.com/en-us/cpp/c-runtime-library/daylight-dstbias-timezone-and-tzname?view=vs-2019
-    int64_t timezone = _timezone;
-    int32_t daylight = _daylight;
-    char**  tzname = _tzname;
-#endif
-
-    int64_t t = (precision == TSDB_TIME_PRECISION_MILLI) ? MILLISECOND_PER_SECOND : MILLISECOND_PER_SECOND * 1000L;
-
-    int64_t revStartime = (startTime / slidingTime) * slidingTime + timezone * t;
-    int64_t revEndtime = revStartime + slidingTime - 1;
-    if (revEndtime < startTime) {
-      revStartime += slidingTime;
-    }
-
-    return revStartime;
-  }
-}
-
 SFillInfo* taosInitFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
     int64_t slidingTime, int8_t slidingUnit, int8_t precision, int32_t fillType, SFillColInfo* pFillCol) {
   if (fillType == TSDB_FILL_NONE) {
@@ -128,7 +93,7 @@ static TSKEY taosGetRevisedEndKey(TSKEY ekey, int32_t order, int64_t timeInterva
   if (order == TSDB_ORDER_ASC) {
     return ekey;
   } else {
-    return taosGetIntervalStartTimestamp(ekey, timeInterval, slidingTimeUnit, precision);
+    return taosGetIntervalStartTimestamp(ekey, timeInterval, timeInterval, slidingTimeUnit, precision);
   }
 }
 
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 354caf2af5..9938b34741 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -110,13 +110,13 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
 
     // current connect is broken
     if (code == TSDB_CODE_SUCCESS) {
-      // add lock here
       handle = qRegisterQInfo(pVnode->qMgmt, pQInfo);
       if (handle == NULL) {  // failed to register qhandle
         pRsp->code = TSDB_CODE_QRY_INVALID_QHANDLE;
 
         qKillQuery(pQInfo);
         qKillQuery(pQInfo);
+        pQInfo = NULL;
       } else {
         assert(*handle == pQInfo);
         pRsp->qhandle = htobe64((uint64_t) (handle));

From 5686d65bacec8b7f542bd9a1cdc424a194a9a074 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 6 Jul 2020 05:10:32 +0000
Subject: [PATCH 16/87] Added return code to crash_gen tool

---
 tests/pytest/crash_gen.py | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index a6e2414262..49c428b7f1 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -327,6 +327,12 @@ class ThreadCoordinator:
     def printStats(self):
         self._execStats.printStats()
 
+    def isFailed(self):
+        return self._execStats.isFailed()
+
+    def getExecStats(self):
+        return self._execStats
+
     def tapAllThreads(self): # in a deterministic manner
         wakeSeq = []
         for i in range(self._pool.numThreads): # generate a random sequence
@@ -1007,7 +1013,7 @@ class DbManager():
             # print("Error type: {}, msg: {}, value: {}".format(type(err), err.msg, err))
             if ( err.msg == 'client disconnected' ): # cannot open DB connection
                 print("Cannot establish DB connection, please re-run script without parameter, and follow the instructions.")
-                sys.exit()
+                sys.exit(2)
             else:
                 raise            
         except:
@@ -1267,6 +1273,12 @@ class ExecutionStats:
         self._failed = False
         self._failureReason = None
 
+    def __str__(self):
+        return "[ExecStats: _failed={}, _failureReason={}".format(self._failed, self._failureReason)
+
+    def isFailed(self):
+        return self._failed == True
+
     def startExec(self):
         self._execStartTime = time.time()
 
@@ -1743,7 +1755,11 @@ class ClientManager:
         self.tc = ThreadCoordinator(thPool, dbManager)
         
         self.tc.run()
+        # print("exec stats: {}".format(self.tc.getExecStats()))
+        # print("TC failed = {}".format(self.tc.isFailed()))
         self.conclude()
+        # print("TC failed (2) = {}".format(self.tc.isFailed()))
+        return 1 if self.tc.isFailed() else 0 # Linux return code: ref https://shapeshed.com/unix-exit-codes/
 
     def conclude(self):
         self.tc.printStats()
@@ -1758,7 +1774,7 @@ class MainExec:
     @classmethod
     def runClient(cls):
         clientManager = ClientManager()
-        clientManager.run()
+        return clientManager.run()
 
     @classmethod
     def runService(cls):
@@ -1863,10 +1879,12 @@ def main():
     if gConfig.run_tdengine : # run server
         MainExec.runService()
     else :
-        MainExec.runClient()
+        return MainExec.runClient()
 
     
     # logger.info("Crash_Gen execution finished")
 
 if __name__ == "__main__":
-    main()
+    exitCode = main()
+    # print("Exiting with code: {}".format(exitCode))
+    sys.exit(exitCode)

From b8bfbc9058b99b6c46c65fb85b935dd5ebfb7339 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 13:13:53 +0800
Subject: [PATCH 17/87] [td-225] fix bugs in sliding query

---
 src/query/src/qExecutor.c | 38 +++++++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 118a675055..ad92d60e21 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -685,26 +685,24 @@ static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStat
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
-  if (IS_MASTER_SCAN(pRuntimeEnv) || pStatus->closed) {
-    for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
-      int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
+  for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
+    int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
 
-      pCtx[k].nStartQueryTimestamp = pWin->skey;
-      pCtx[k].size = forwardStep;
-      pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
+    pCtx[k].nStartQueryTimestamp = pWin->skey;
+    pCtx[k].size = forwardStep;
+    pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
 
-      if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
-        pCtx[k].ptsList = &tsBuf[offset];
-      }
+    if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
+      pCtx[k].ptsList = &tsBuf[offset];
+    }
 
-      // not a whole block involved in query processing, statistics data can not be used
-      if (forwardStep != numOfTotal) {
-        pCtx[k].preAggVals.isSet = false;
-      }
-      
-      if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
-        aAggs[functionId].xFunction(&pCtx[k]);
-      }
+    // not a whole block involved in query processing, statistics data can not be used
+    if (forwardStep != numOfTotal) {
+      pCtx[k].preAggVals.isSet = false;
+    }
+
+    if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
+      aAggs[functionId].xFunction(&pCtx[k]);
     }
   }
 }
@@ -1086,6 +1084,11 @@ static int32_t doTSJoinFilter(SQueryRuntimeEnv *pRuntimeEnv, int32_t offset) {
 static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t functionId) {
   SResultInfo *pResInfo = GET_RES_INFO(pCtx);
   SQuery* pQuery = pRuntimeEnv->pQuery;
+
+  // in case of timestamp column, always generated results.
+  if (functionId == TSDB_FUNC_TS) {
+    return true;
+  }
   
   if (pResInfo->complete || functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
     return false;
@@ -4716,6 +4719,7 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
     qDebug("QInfo:%p reversed scan completed, elapsed time: %" PRId64 "ms", pQInfo, el);
 
     doRestoreContext(pQInfo);
+    doCloseAllTimeWindowAfterScan(pQInfo);
   } else {
     qDebug("QInfo:%p no need to do reversed scan, query completed", pQInfo);
   }

From 1761b011071d8d72ff575a0a5f451e3378d6fda3 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 13:14:20 +0800
Subject: [PATCH 18/87] [td-225] fix bugs in sliding query

---
 src/query/src/qExecutor.c | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index ad92d60e21..849453527e 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -712,14 +712,12 @@ static void doRowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStatus
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
-  if (IS_MASTER_SCAN(pRuntimeEnv) || pStatus->closed) {
-    for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
-      pCtx[k].nStartQueryTimestamp = pWin->skey;
+  for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
+    pCtx[k].nStartQueryTimestamp = pWin->skey;
 
-      int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
-      if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
-        aAggs[functionId].xFunctionF(&pCtx[k], offset);
-      }
+    int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
+    if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
+      aAggs[functionId].xFunctionF(&pCtx[k], offset);
     }
   }
 }

From de1d615f7a12a5404b84f1d9e7e845e14d1c7369 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 06:18:28 +0000
Subject: [PATCH 19/87] confirm forward from slave

---
 src/dnode/src/dnodeVWrite.c | 5 +++++
 src/inc/vnode.h             | 1 +
 src/vnode/src/vnodeMain.c   | 3 ++-
 src/vnode/src/vnodeWrite.c  | 5 +++++
 4 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c
index b20e6c9749..d439dd985e 100644
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@@ -247,6 +247,11 @@ static void *dnodeProcessWriteQueue(void *param) {
       if (type == TAOS_QTYPE_RPC) {
         pWrite = (SWriteMsg *)item;
         dnodeSendRpcVnodeWriteRsp(pVnode, item, pWrite->rpcMsg.code); 
+      } else if (type == TAOS_QTYPE_FWD) {
+        pHead = (SWalHead *)item;
+        vnodeConfirmForward(pVnode, pHead->version, 0);
+        taosFreeQitem(item);
+        vnodeRelease(pVnode);
       } else {
         taosFreeQitem(item);
         vnodeRelease(pVnode);
diff --git a/src/inc/vnode.h b/src/inc/vnode.h
index a034bc5706..f1cd7486a4 100644
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
@@ -60,6 +60,7 @@ void*   vnodeGetWal(void *pVnode);
 int32_t vnodeProcessWrite(void *pVnode, int qtype, void *pHead, void *item);
 int32_t vnodeGetVnodeList(int32_t vnodeList[], int32_t *numOfVnodes);
 void    vnodeBuildStatusMsg(void *param);
+void    vnodeConfirmForward(void *param, uint64_t version, int32_t code);
 void    vnodeSetAccess(SDMVgroupAccess *pAccess, int32_t numOfVnodes);
 void    vnodeCleanupResources();
 
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 0050de3399..5bd206beec 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -779,7 +779,8 @@ static int32_t vnodeReadCfg(SVnodeObj *pVnode) {
     vError("vgId: %d, failed to read vnode cfg, quorum not found", pVnode->vgId);
     goto PARSE_OVER;
   }
-  pVnode->syncCfg.quorum = (int8_t)quorum->valueint;
+  //pVnode->syncCfg.quorum = (int8_t)quorum->valueint;
+  pVnode->syncCfg.quorum = 2; 
 
   cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
   if (!nodeInfos || nodeInfos->type != cJSON_Array) {
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index 171557acb6..e44436c8b7 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -89,6 +89,11 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
   return syncCode;
 }
 
+void vnodeConfirmForward(void *param, uint64_t version, int32_t code) {
+  SVnodeObj *pVnode = (SVnodeObj *)param;
+  syncConfirmForward(pVnode->sync, version, code);
+}
+
 static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {
   int32_t code = TSDB_CODE_SUCCESS;
 

From 67c62ee687d6409db41c4d299d8db42a8e917114 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 06:20:11 +0000
Subject: [PATCH 20/87] remove a debug line

---
 src/vnode/src/vnodeMain.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 5bd206beec..0050de3399 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -779,8 +779,7 @@ static int32_t vnodeReadCfg(SVnodeObj *pVnode) {
     vError("vgId: %d, failed to read vnode cfg, quorum not found", pVnode->vgId);
     goto PARSE_OVER;
   }
-  //pVnode->syncCfg.quorum = (int8_t)quorum->valueint;
-  pVnode->syncCfg.quorum = 2; 
+  pVnode->syncCfg.quorum = (int8_t)quorum->valueint;
 
   cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
   if (!nodeInfos || nodeInfos->type != cJSON_Array) {

From bbd0241a9579757c2c6ce85db26e56b98302fa22 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 6 Jul 2020 06:24:28 +0000
Subject: [PATCH 21/87] [TD-855] memory leak while alter vgroup

---
 src/mnode/src/mnodeVgroup.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index 9a041aa4fd..b763c62640 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -165,6 +165,8 @@ static int32_t mnodeVgroupActionUpdate(SSdbOper *pOper) {
       }
       mnodeDecDnodeRef(pDnode);
     }
+
+    free(pNew);
   }
 
   mnodeVgroupUpdateIdPool(pVgroup);

From b1f85ec0118c378991e7e430b92ed608cf969c9b Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 14:47:24 +0800
Subject: [PATCH 22/87] [td-225] fix bugs in sliding query

---
 src/client/src/tscSQLParser.c | 10 ++++++----
 src/inc/taosmsg.h             |  2 ++
 src/query/src/qExecutor.c     |  3 +--
 src/query/src/qUtil.c         | 33 ++++++++++++++++++++++++---------
 src/query/src/qextbuffer.c    |  3 ++-
 src/tsdb/src/tsdbMeta.c       |  2 ++
 6 files changed, 37 insertions(+), 16 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 2b325afa7c..22e91bd658 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -4487,10 +4487,12 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) pCmd->payload;
     pUpdateMsg->head.vgId = htonl(pTableMeta->vgroupInfo.vgId);
-    pUpdateMsg->tid = htonl(pTableMeta->sid);
-    pUpdateMsg->uid = htobe64(pTableMeta->uid);
-    pUpdateMsg->colId = htons(pTagsSchema->colId);
-    pUpdateMsg->tversion = htons(pTableMeta->tversion);
+    pUpdateMsg->tid       = htonl(pTableMeta->sid);
+    pUpdateMsg->uid       = htobe64(pTableMeta->uid);
+    pUpdateMsg->colId     = htons(pTagsSchema->colId);
+    pUpdateMsg->type      = htons(pTagsSchema->type);
+    pUpdateMsg->bytes     = htons(pTagsSchema->bytes);
+    pUpdateMsg->tversion  = htons(pTableMeta->tversion);
     pUpdateMsg->numOfTags = htons(numOfTags);
     pUpdateMsg->schemaLen = htonl(schemaLen);
 
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 6155f08e76..1849797970 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -285,6 +285,8 @@ typedef struct {
   int32_t   tid;
   int16_t   tversion;
   int16_t   colId;
+  int16_t   type;
+  int16_t   bytes;
   int32_t   tagValLen;
   int16_t   numOfTags;
   int32_t   schemaLen;
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 849453527e..7fe59fc443 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1099,7 +1099,6 @@ static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
   // todo add comments
   if ((functionId == TSDB_FUNC_LAST_DST || functionId == TSDB_FUNC_LAST)) {
     return pCtx->param[0].i64Key == pQuery->order.order;
-//    return !QUERY_IS_ASC_QUERY(pQuery);
   }
 
   // in the supplementary scan, only the following functions need to be executed
@@ -4716,8 +4715,8 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
     el = scanMultiTableDataBlocks(pQInfo);
     qDebug("QInfo:%p reversed scan completed, elapsed time: %" PRId64 "ms", pQInfo, el);
 
-    doRestoreContext(pQInfo);
     doCloseAllTimeWindowAfterScan(pQInfo);
+    doRestoreContext(pQInfo);
   } else {
     qDebug("QInfo:%p no need to do reversed scan, query completed", pQInfo);
   }
diff --git a/src/query/src/qUtil.c b/src/query/src/qUtil.c
index 9541f283f0..3b2b2bfff0 100644
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
@@ -180,19 +180,34 @@ void closeAllTimeWindow(SWindowResInfo *pWindowResInfo) {
 
 /*
  * remove the results that are not the FIRST time window that spreads beyond the
- * the last qualified time stamp in case of sliding query, which the sliding time is not equalled to the interval time
+ * the last qualified time stamp in case of sliding query, which the sliding time is not equalled to the interval time.
+ * NOTE: remove redundant, only when the result set order equals to traverse order
  */
 void removeRedundantWindow(SWindowResInfo *pWindowResInfo, TSKEY lastKey, int32_t order) {
   assert(pWindowResInfo->size >= 0 && pWindowResInfo->capacity >= pWindowResInfo->size);
-  
-  int32_t i = 0;
-  while (i < pWindowResInfo->size &&
-      ((pWindowResInfo->pResult[i].window.ekey < lastKey && order == QUERY_ASC_FORWARD_STEP) ||
-          (pWindowResInfo->pResult[i].window.skey > lastKey && order == QUERY_DESC_FORWARD_STEP))) {
-    ++i;
+  if (pWindowResInfo->size <= 1) {
+    return;
   }
-  
-  //  assert(i < pWindowResInfo->size);
+
+  // get the result order
+  int32_t resultOrder = (pWindowResInfo->pResult[0].window.skey < pWindowResInfo->pResult[1].window.skey)?
+                         TSDB_ORDER_ASC:TSDB_ORDER_DESC;
+
+  if (order != resultOrder) {
+    return;
+  }
+
+  int32_t i = 0;
+  if (order == QUERY_ASC_FORWARD_STEP) {
+    while (i < pWindowResInfo->size && (pWindowResInfo->pResult[i].window.ekey < lastKey)) {
+      ++i;
+    }
+  } else if (order == QUERY_DESC_FORWARD_STEP) {
+    while (i < pWindowResInfo->size && (pWindowResInfo->pResult[i].window.skey > lastKey)) {
+      ++i;
+    }
+  }
+
   if (i < pWindowResInfo->size) {
     pWindowResInfo->size = (i + 1);
   }
diff --git a/src/query/src/qextbuffer.c b/src/query/src/qextbuffer.c
index ce3f60c072..afcf902123 100644
--- a/src/query/src/qextbuffer.c
+++ b/src/query/src/qextbuffer.c
@@ -118,7 +118,7 @@ static bool tExtMemBufferAlloc(tExtMemBuffer *pMemBuffer) {
    * To flush data to disk to accommodate more data
    */
   if (pMemBuffer->numOfInMemPages > 0 && pMemBuffer->numOfInMemPages == pMemBuffer->inMemCapacity) {
-    if (!tExtMemBufferFlush(pMemBuffer)) {
+    if (tExtMemBufferFlush(pMemBuffer) != 0) {
       return false;
     }
   }
@@ -268,6 +268,7 @@ int32_t tExtMemBufferFlush(tExtMemBuffer *pMemBuffer) {
     size_t retVal = fwrite((char *)&(first->item), pMemBuffer->pageSize, 1, pMemBuffer->file);
     if (retVal <= 0) {  // failed to write to buffer, may be not enough space
       ret = TAOS_SYSTEM_ERROR(errno);
+      return ret;
     }
 
     pMemBuffer->fileMeta.numOfElemsInFile += first->item.num;
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index ad25b7f675..8b79d95af1 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -274,6 +274,8 @@ int tsdbUpdateTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
   pMsg->tid = htonl(pMsg->tid);
   pMsg->tversion  = htons(pMsg->tversion);
   pMsg->colId     = htons(pMsg->colId);
+  pMsg->type      = htons(pMsg->type);
+  pMsg->bytes     = htons(pMsg->bytes);
   pMsg->tagValLen = htonl(pMsg->tagValLen);
   pMsg->numOfTags = htons(pMsg->numOfTags);
   pMsg->schemaLen = htonl(pMsg->schemaLen);

From 4ad14a8bef8b60be89368a2da81747a4d767dd22 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 6 Jul 2020 07:00:05 +0000
Subject: [PATCH 23/87] [TD-856] add dump to log types

---
 src/client/inc/tscLog.h               | 4 +---
 src/client/src/TSDBJNIConnector.c     | 3 ---
 src/client/src/tscAsync.c             | 2 +-
 src/client/src/tscPrepare.c           | 2 +-
 src/client/src/tscStream.c            | 2 +-
 src/common/inc/tulog.h                | 3 ---
 src/common/src/tglobal.c              | 2 +-
 src/plugins/http/inc/httpLog.h        | 4 +---
 src/plugins/http/src/httpHandle.c     | 6 +++---
 src/plugins/http/src/httpServer.c     | 6 +++---
 src/plugins/http/src/httpSql.c        | 6 +++---
 src/plugins/monitor/src/monitorMain.c | 3 ---
 src/plugins/mqtt/inc/mqttLog.h        | 3 ---
 src/rpc/inc/rpcLog.h                  | 4 +---
 src/rpc/src/rpcMain.c                 | 4 ++--
 src/util/inc/tlog.h                   | 1 +
 16 files changed, 19 insertions(+), 36 deletions(-)

diff --git a/src/client/inc/tscLog.h b/src/client/inc/tscLog.h
index c395951742..94adcfe17a 100644
--- a/src/client/inc/tscLog.h
+++ b/src/client/inc/tscLog.h
@@ -31,9 +31,7 @@ extern int32_t tscEmbedded;
 #define tscInfo(...)  { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC INFO  ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}
 #define tscDebug(...) { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSC DEBUG ", cDebugFlag, __VA_ARGS__); }}
 #define tscTrace(...) { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC TRACE ", cDebugFlag, __VA_ARGS__); }}
-
-#define tscDebugDump(...) { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC DEBUG ", cDebugFlag, __VA_ARGS__); }}
-#define tscTraceDump(...) { if (cDebugFlag & DEBUG_TRACE) { taosPrintLongString("TSC TRACE ", cDebugFlag, __VA_ARGS__); }}
+#define tscDebugL(...){ if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC DEBUG ", cDebugFlag, __VA_ARGS__); }}
 
 #ifdef __cplusplus
 }
diff --git a/src/client/src/TSDBJNIConnector.c b/src/client/src/TSDBJNIConnector.c
index d070fad11b..eb9b1cb479 100644
--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -29,9 +29,6 @@
 #define jniDebug(...) { if (jniDebugFlag & DEBUG_DEBUG) { taosPrintLog("JNI DEBUG ", jniDebugFlag, __VA_ARGS__); }}
 #define jniTrace(...) { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI TRACE ", jniDebugFlag, __VA_ARGS__); }}
 
-#define jniDebugDump(...) { if (jniDebugFlag & DEBUG_DEBUG) { taosPrintLongString("JNI DEBUG ", jniDebugFlag, __VA_ARGS__); }}
-#define jniTraceDump(...) { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLongString("JNI DEBUG ", jniDebugFlag, __VA_ARGS__); }}
-
 int __init = 0;
 
 JavaVM *g_vm = NULL;
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 3fed3e4d67..45d3d3caa3 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -55,7 +55,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
 
   strtolower(pSql->sqlstr, sqlstr);
 
-  tscDebugDump("%p SQL: %s", pSql, pSql->sqlstr);
+  tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
   pSql->cmd.curSql = pSql->sqlstr;
 
   int32_t code = tsParseSql(pSql, true);
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 22b6be1c57..9f0d1a26ab 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -538,7 +538,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   pRes->numOfRows = 1;
   
   strtolower(pSql->sqlstr, sql);
-  tscDebugDump("%p SQL: %s", pSql, pSql->sqlstr);
+  tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
 
   if (tscIsInsertData(pSql->sqlstr)) {  
     pStmt->isInsert = true;
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index a6d111dbc7..cc703e0f93 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -503,7 +503,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   }
   strtolower(pSql->sqlstr, sqlstr);
 
-  tscDebugDump("%p SQL: %s", pSql, pSql->sqlstr);
+  tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
   tsem_init(&pSql->rspSem, 0, 0);
 
   int32_t code = tsParseSql(pSql, true);
diff --git a/src/common/inc/tulog.h b/src/common/inc/tulog.h
index 63c838be69..6365b21ef9 100644
--- a/src/common/inc/tulog.h
+++ b/src/common/inc/tulog.h
@@ -32,9 +32,6 @@ extern int32_t tscEmbedded;
 #define uDebug(...) { if (uDebugFlag & DEBUG_DEBUG) { taosPrintLog("UTL DEBUG ", uDebugFlag, __VA_ARGS__); }}
 #define uTrace(...) { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL TRACE ", uDebugFlag, __VA_ARGS__); }}
 
-#define uDebugDump(...) { if (uDebugFlag & DEBUG_DEBUG) { taosPrintLongString("UTL DEBUG ", uDebugFlag, __VA_ARGS__); }}
-#define uTraceDump(...) { if (uDebugFlag & DEBUG_TRACE) { taosPrintLongString("UTL TRACE ", uDebugFlag, __VA_ARGS__); }}
-
 #define pError(...) { taosPrintLog("APP ERROR ", 255, __VA_ARGS__); }  
 #define pPrint(...) { taosPrintLog("APP INFO  ", 255, __VA_ARGS__); }  
 
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 67c104878a..684fb71af9 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -1210,7 +1210,7 @@ void taosInitGlobalCfg() {
 }
 
 bool taosCheckGlobalCfg() {
-  if (debugFlag & DEBUG_TRACE || debugFlag & DEBUG_DEBUG) {
+  if (debugFlag & DEBUG_TRACE || debugFlag & DEBUG_DEBUG || debugFlag & DEBUG_DUMP) {
     taosSetAllDebugFlag();
   }
   
diff --git a/src/plugins/http/inc/httpLog.h b/src/plugins/http/inc/httpLog.h
index 3712360a1c..f4c20a40d5 100644
--- a/src/plugins/http/inc/httpLog.h
+++ b/src/plugins/http/inc/httpLog.h
@@ -26,8 +26,6 @@ extern int32_t httpDebugFlag;
 #define httpInfo(...)  { if (httpDebugFlag & DEBUG_INFO)  { taosPrintLog("HTP INFO  ", 255, __VA_ARGS__); }}
 #define httpDebug(...) { if (httpDebugFlag & DEBUG_DEBUG) { taosPrintLog("HTP DEBUG ", httpDebugFlag, __VA_ARGS__); }}
 #define httpTrace(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLog("HTP TRACE ", httpDebugFlag, __VA_ARGS__); }}
-
-#define httpDebugDump(...) { if (httpDebugFlag & DEBUG_DEBUG) { taosPrintLongString("HTP DEBUG ", httpDebugFlag, __VA_ARGS__); }}
-#define httpTraceDump(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLongString("HTP TRACE ", httpDebugFlag, __VA_ARGS__); }}
+#define httpTraceL(...){ if (httpDebugFlag & DEBUG_TRACE) { taosPrintLongString("HTP TRACE ", httpDebugFlag, __VA_ARGS__); }}
 
 #endif
diff --git a/src/plugins/http/src/httpHandle.c b/src/plugins/http/src/httpHandle.c
index 056fe425d4..a89ea7d8f1 100644
--- a/src/plugins/http/src/httpHandle.c
+++ b/src/plugins/http/src/httpHandle.c
@@ -313,9 +313,9 @@ bool httpParseRequest(HttpContext* pContext) {
     return true;
   }
 
-  httpTraceDump("context:%p, fd:%d, ip:%s, thread:%s, numOfFds:%d, read size:%d, raw data:\n%s", pContext, pContext->fd,
-                pContext->ipstr, pContext->pThread->label, pContext->pThread->numOfFds, pContext->parser.bufsize,
-                pContext->parser.buffer);
+  httpTraceL("context:%p, fd:%d, ip:%s, thread:%s, numOfFds:%d, read size:%d, raw data:\n%s", pContext, pContext->fd,
+            pContext->ipstr, pContext->pThread->label, pContext->pThread->numOfFds, pContext->parser.bufsize,
+            pContext->parser.buffer);
 
   if (!httpGetHttpMethod(pContext)) {
     return false;
diff --git a/src/plugins/http/src/httpServer.c b/src/plugins/http/src/httpServer.c
index a5009c2347..d7d7da6668 100644
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
@@ -108,7 +108,7 @@ bool httpReadDataImp(HttpContext *pContext) {
 
 static bool httpDecompressData(HttpContext *pContext) {
   if (pContext->contentEncoding != HTTP_COMPRESS_GZIP) {
-    httpTraceDump("context:%p, fd:%d, ip:%s, content:%s", pContext, pContext->fd, pContext->ipstr, pContext->parser.data.pos);
+    httpTraceL("context:%p, fd:%d, ip:%s, content:%s", pContext, pContext->fd, pContext->ipstr, pContext->parser.data.pos);
     return true;
   }
 
@@ -124,8 +124,8 @@ static bool httpDecompressData(HttpContext *pContext) {
   if (ret == 0) {
     memcpy(pContext->parser.data.pos, decompressBuf, decompressBufLen);
     pContext->parser.data.pos[decompressBufLen] = 0;
-    httpTraceDump("context:%p, fd:%d, ip:%s, rawSize:%d, decompressSize:%d, content:%s",
-              pContext, pContext->fd, pContext->ipstr, pContext->parser.data.len, decompressBufLen,  decompressBuf);
+    httpTraceL("context:%p, fd:%d, ip:%s, rawSize:%d, decompressSize:%d, content:%s", pContext, pContext->fd,
+              pContext->ipstr, pContext->parser.data.len, decompressBufLen, decompressBuf);
     pContext->parser.data.len = decompressBufLen;
   } else {
     httpError("context:%p, fd:%d, ip:%s, failed to decompress data, rawSize:%d, error:%d",
diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c
index 9d3efca01d..7a8f851e33 100644
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
@@ -166,7 +166,7 @@ void httpProcessMultiSql(HttpContext *pContext) {
   HttpSqlCmd *cmd = multiCmds->cmds + multiCmds->pos;
 
   char *sql = httpGetCmdsString(pContext, cmd->sql);
-  httpTraceDump("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, start query, sql:%s", pContext, pContext->fd,
+  httpDump("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, start query, sql:%s", pContext, pContext->fd,
            pContext->ipstr, pContext->user, multiCmds->pos, sql);
   taosNotePrintHttp(sql);
   taos_query_a(pContext->session->taos, sql, httpProcessMultiSqlCallBack, (void *)pContext);
@@ -306,8 +306,8 @@ void httpProcessSingleSqlCmd(HttpContext *pContext) {
     return;
   }
 
-  httpTraceDump("context:%p, fd:%d, ip:%s, user:%s, start query, sql:%s", pContext, pContext->fd, pContext->ipstr,
-           pContext->user, sql);
+  httpTraceL("context:%p, fd:%d, ip:%s, user:%s, start query, sql:%s", pContext, pContext->fd, pContext->ipstr,
+            pContext->user, sql);
   taosNotePrintHttp(sql);
   taos_query_a(pSession->taos, sql, httpProcessSingleSqlCallBack, (void *)pContext);
 }
diff --git a/src/plugins/monitor/src/monitorMain.c b/src/plugins/monitor/src/monitorMain.c
index 11b701e0ea..36468b3fdb 100644
--- a/src/plugins/monitor/src/monitorMain.c
+++ b/src/plugins/monitor/src/monitorMain.c
@@ -35,9 +35,6 @@
 #define monitorDebug(...) { if (monitorDebugFlag & DEBUG_DEBUG) { taosPrintLog("MON DEBUG ", monitorDebugFlag, __VA_ARGS__); }}
 #define monitorTrace(...) { if (monitorDebugFlag & DEBUG_TRACE) { taosPrintLog("MON TRACE ", monitorDebugFlag, __VA_ARGS__); }}
 
-#define monitorDebugDump(...) { if (monitorDebugFlag & DEBUG_DEBUG) { taosPrintLongString("MON DEBUG ", monitorDebugFlag, __VA_ARGS__); }}
-#define monitorTraceDump(...) { if (monitorDebugFlag & DEBUG_TRACE) { taosPrintLongString("MON TRACE ", monitorDebugFlag, __VA_ARGS__); }}
-
 #define SQL_LENGTH     1024
 #define LOG_LEN_STR    100
 #define IP_LEN_STR     18
diff --git a/src/plugins/mqtt/inc/mqttLog.h b/src/plugins/mqtt/inc/mqttLog.h
index c0515c2c26..5d5f98a13b 100644
--- a/src/plugins/mqtt/inc/mqttLog.h
+++ b/src/plugins/mqtt/inc/mqttLog.h
@@ -27,7 +27,4 @@ extern int32_t mqttDebugFlag;
 #define mqttDebug(...) { if (mqttDebugFlag & DEBUG_DEBUG) { taosPrintLog("MQT DEBUG ", mqttDebugFlag, __VA_ARGS__); }}
 #define mqttTrace(...) { if (mqttDebugFlag & DEBUG_TRACE) { taosPrintLog("MQT TRACE ", mqttDebugFlag, __VA_ARGS__); }}
 
-#define mqttDebugDump(...) { if (mqttDebugFlag & DEBUG_DEBUG) { taosPrintLongString("MQT DEBUG ", mqttDebugFlag, __VA_ARGS__); }}
-#define mqttTraceDump(...) { if (mqttDebugFlag & DEBUG_TRACE) { taosPrintLongString("MQT DEBUG ", mqttDebugFlag, __VA_ARGS__); }}
-
 #endif
diff --git a/src/rpc/inc/rpcLog.h b/src/rpc/inc/rpcLog.h
index 0504ddac43..f0f5c84ff9 100644
--- a/src/rpc/inc/rpcLog.h
+++ b/src/rpc/inc/rpcLog.h
@@ -31,9 +31,7 @@ extern int32_t tscEmbedded;
 #define tInfo(...)  { if (rpcDebugFlag & DEBUG_INFO)  { taosPrintLog("RPC INFO  ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
 #define tDebug(...) { if (rpcDebugFlag & DEBUG_DEBUG) { taosPrintLog("RPC DEBUG ", rpcDebugFlag, __VA_ARGS__); }}
 #define tTrace(...) { if (rpcDebugFlag & DEBUG_TRACE) { taosPrintLog("RPC TRACE ", rpcDebugFlag, __VA_ARGS__); }}
-
-#define tDebugDump(x, y) { if (rpcDebugFlag & DEBUG_DEBUG)  { taosDumpData((unsigned char *)x, y); }}
-#define tTraceDump(x, y) { if (rpcDebugFlag & DEBUG_TRACE)  { taosDumpData((unsigned char *)x, y); }}
+#define tDump(x, y) { if (rpcDebugFlag & DEBUG_DUMP)  { taosDumpData((unsigned char *)x, y); }}
 
 #ifdef __cplusplus
 }
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index c05c8c76e1..6a293520e5 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -973,7 +973,7 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
   SRpcInfo  *pRpc = (SRpcInfo *)pRecv->shandle;
   SRpcConn  *pConn = (SRpcConn *)pRecv->thandle;
 
-  tTraceDump(pRecv->msg, pRecv->msgLen);
+  tDump(pRecv->msg, pRecv->msgLen);
 
   // underlying UDP layer does not know it is server or client
   pRecv->connType = pRecv->connType | pRpc->connType;  
@@ -1247,7 +1247,7 @@ static void rpcSendMsgToPeer(SRpcConn *pConn, void *msg, int msgLen) {
     tError("%s, failed to send, msgLen:%d written:%d, reason:%s", pConn->info, msgLen, writtenLen, strerror(errno));
   }
  
-  tTraceDump(msg, msgLen);
+  tDump(msg, msgLen);
 }
 
 static void rpcProcessConnError(void *param, void *id) {
diff --git a/src/util/inc/tlog.h b/src/util/inc/tlog.h
index af4e6ae1c2..1f6a81d4b4 100644
--- a/src/util/inc/tlog.h
+++ b/src/util/inc/tlog.h
@@ -26,6 +26,7 @@ extern "C" {
 #define DEBUG_INFO  DEBUG_WARN
 #define DEBUG_DEBUG 4U
 #define DEBUG_TRACE 8U
+#define DEBUG_DUMP  16U
 
 #define DEBUG_SCREEN 64U
 #define DEBUG_FILE   128U

From 04cbccd9a156c0f809f32f5117a5e8f15750a505 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 6 Jul 2020 07:02:43 +0000
Subject: [PATCH 24/87] [TD-856]

---
 src/plugins/http/src/httpSql.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c
index 7a8f851e33..c43d928d1b 100644
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
@@ -166,8 +166,8 @@ void httpProcessMultiSql(HttpContext *pContext) {
   HttpSqlCmd *cmd = multiCmds->cmds + multiCmds->pos;
 
   char *sql = httpGetCmdsString(pContext, cmd->sql);
-  httpDump("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, start query, sql:%s", pContext, pContext->fd,
-           pContext->ipstr, pContext->user, multiCmds->pos, sql);
+  httpTraceL("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, start query, sql:%s", pContext, pContext->fd,
+             pContext->ipstr, pContext->user, multiCmds->pos, sql);
   taosNotePrintHttp(sql);
   taos_query_a(pContext->session->taos, sql, httpProcessMultiSqlCallBack, (void *)pContext);
 }

From c86b6877e9a10c2f478730453e91ef4d034001e4 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 16:09:44 +0800
Subject: [PATCH 25/87] [td-225] handle TSDB_CODE_TDB_TABLE_RECONFIGURE code.

---
 src/client/src/tscAsync.c  | 2 +-
 src/client/src/tscServer.c | 9 +++++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 3fed3e4d67..1ac013d51e 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -471,7 +471,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
         }
 
         // in case of insert, redo parsing the sql string and build new submit data block for two reasons:
-        // 1. the table Id(tid & uid) may have been update, the submit block needs to be updated
+        // 1. the table Id(tid & uid) may have been update, the submit block needs to be updated accordingly.
         // 2. vnode may need the schema information along with submit block to update its local table schema.
         if (pCmd->command == TSDB_SQL_INSERT) {
           tscDebug("%p redo parse sql string to build submit block", pSql);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index d73983e77c..584e70ba6c 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -247,7 +247,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
   } else {
     STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
     if (rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID || 
-        rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
+        rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
       if (pCmd->command == TSDB_SQL_CONNECT) {
         rpcMsg->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
         rpcFreeCont(rpcMsg->pCont);
@@ -260,7 +260,12 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
         // get table meta query will not retry, do nothing
       } else {
         tscWarn("%p it shall renew table meta, code:%s, retry:%d", pSql, tstrerror(rpcMsg->code), ++pSql->retry);
-        
+
+        // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
+        if (rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+          pSql->cmd.submitSchema = 1;
+        }
+
         pSql->res.code = rpcMsg->code;  // keep the previous error code
         if (pSql->retry > pSql->maxRetry) {
           tscError("%p max retry %d reached, give up", pSql, pSql->maxRetry);

From 6e06701aad9b5648d32af47411e36673fd38d9e6 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Mon, 6 Jul 2020 16:35:13 +0800
Subject: [PATCH 26/87] fix unitiailized error

---
 src/query/src/qExecutor.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index bd8c9951e1..d41c9fbba8 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -2173,6 +2173,7 @@ static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pB
         if (tmp == NULL) {  // todo handle the oom
           assert(0);
         } else {
+          memset(tmp + sizeof(tFilePage) + bytes * pRec->rows, 0, (newSize - pRec->rows) * bytes);
           pQuery->sdata[i] = (tFilePage *)tmp;
         }
         

From 159f6230e0cdec81d39bb09f41cc46c6fc11659e Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 09:36:43 +0000
Subject: [PATCH 27/87] memory leak if response is not received

---
 src/rpc/src/rpcMain.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 6a293520e5..fc74ca0cea 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -601,11 +601,10 @@ static void rpcReleaseConn(SRpcConn *pConn) {
     taosHashRemove(pRpc->hash, hashstr, size);
     rpcFreeMsg(pConn->pRspMsg); // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
-  
-    if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   } 
 
   // memset could not be used, since lockeBy can not be reset
+  if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   pConn->inType = 0;
   pConn->outType = 0;
   pConn->inTranId = 0;
@@ -959,6 +958,7 @@ static void rpcProcessBrokenLink(SRpcConn *pConn) {
   if (pConn->outType) {
     SRpcReqContext *pContext = pConn->pContext;
     pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+    pConn->pReq = NULL;
     taosTmrStart(rpcProcessConnError, 0, pContext, pRpc->tmrCtrl);
   }
 
@@ -1061,6 +1061,7 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead) {
     SRpcReqContext *pContext = pConn->pContext;
     rpcMsg.handle = pContext;
     pConn->pContext = NULL;
+    pConn->pReq = NULL;
 
     // for UDP, port may be changed by server, the port in ipSet shall be used for cache
     if (pHead->code != TSDB_CODE_RPC_TOO_SLOW) {
@@ -1297,6 +1298,7 @@ static void rpcProcessRetryTimer(void *param, void *tmrId) {
       tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, taosMsg[pConn->outType], pConn->peerFqdn, pConn->peerPort);
       if (pConn->pContext) {
         pConn->pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+        pConn->pReq = NULL;
         taosTmrStart(rpcProcessConnError, 0, pConn->pContext, pRpc->tmrCtrl);
         rpcReleaseConn(pConn);
       }

From 6a150f018833a753351e431ffcbc037918f477c2 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 6 Jul 2020 18:30:44 +0800
Subject: [PATCH 28/87] [td-225] opt query perf.

---
 src/inc/tsdb.h            |  3 +-
 src/query/src/qExecutor.c | 63 ++++++++++++++++++++-------------------
 src/tsdb/src/tsdbRead.c   | 32 ++++++++++----------
 3 files changed, 50 insertions(+), 48 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index f68caf1a60..6a6341a522 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -235,9 +235,10 @@ bool tsdbNextDataBlock(TsdbQueryHandleT *pQueryHandle);
  * Get current data block information
  *
  * @param pQueryHandle
+ * @param pBlockInfo
  * @return
  */
-SDataBlockInfo tsdbRetrieveDataBlockInfo(TsdbQueryHandleT *pQueryHandle);
+void tsdbRetrieveDataBlockInfo(TsdbQueryHandleT *pQueryHandle, SDataBlockInfo* pBlockInfo);
 
 /**
  *
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 7fe59fc443..1728019e61 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -119,7 +119,6 @@ static UNUSED_FUNC void* u_calloc(size_t num, size_t __size) {
 static void setQueryStatus(SQuery *pQuery, int8_t status);
 
 #define QUERY_IS_INTERVAL_QUERY(_q) ((_q)->intervalTime > 0)
-static bool isIntervalQuery(SQuery *pQuery) { return pQuery->intervalTime > 0; }
 
 // todo move to utility
 static int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *group);
@@ -562,7 +561,7 @@ static int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t sea
  */
 static int32_t doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey, SWindowResInfo *pWindowResInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
-  if (pRuntimeEnv->scanFlag != MASTER_SCAN || (!isIntervalQuery(pQuery))) {
+  if (pRuntimeEnv->scanFlag != MASTER_SCAN || (!QUERY_IS_INTERVAL_QUERY(pQuery))) {
     return pWindowResInfo->size;
   }
 
@@ -1178,7 +1177,7 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
     }
 
     // interval window query
-    if (isIntervalQuery(pQuery)) {
+    if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
       // decide the time window according to the primary timestamp
       int64_t     ts = tsCols[offset];
       STimeWindow win = getActiveTimeWindow(pWindowResInfo, ts, pQuery);
@@ -1282,7 +1281,7 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
 
   // interval query with limit applied
   int32_t numOfRes = 0;
-  if (isIntervalQuery(pQuery)) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
     numOfRes = doCheckQueryCompleted(pRuntimeEnv, lastKey, pWindowResInfo);
   } else {
     numOfRes = getNumOfResult(pRuntimeEnv);
@@ -1868,7 +1867,7 @@ static int32_t getInitialPageNum(SQInfo *pQInfo) {
 
   if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
     num = 128;
-  } else if (isIntervalQuery(pQuery)) {  // time window query, allocate one page for each table
+  } else if (QUERY_IS_INTERVAL_QUERY(pQuery)) {  // time window query, allocate one page for each table
     size_t s = pQInfo->tableqinfoGroupInfo.numOfTables;
     num = MAX(s, INITIAL_RESULT_ROWS_VALUE);
   } else {    // for super table query, one page for each subset
@@ -2018,7 +2017,7 @@ SArray *loadDataBlockOnDemand(SQueryRuntimeEnv *pRuntimeEnv, void* pQueryHandle,
       r |= aAggs[functionId].dataReqFunc(&pRuntimeEnv->pCtx[i], pQuery->window.skey, pQuery->window.ekey, colId);
     }
 
-    if (pRuntimeEnv->pTSBuf > 0 || isIntervalQuery(pQuery)) {
+    if (pRuntimeEnv->pTSBuf > 0 || QUERY_IS_INTERVAL_QUERY(pQuery)) {
       r |= BLK_DATA_ALL_NEEDED;
     }
   }
@@ -2202,13 +2201,15 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
          pQuery->order.order);
 
   TsdbQueryHandleT pQueryHandle = IS_MASTER_SCAN(pRuntimeEnv)? pRuntimeEnv->pQueryHandle : pRuntimeEnv->pSecQueryHandle;
+  SDataBlockInfo blockInfo = {0};
+
   while (tsdbNextDataBlock(pQueryHandle)) {
     summary->totalBlocks += 1;
     if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
       return 0;
     }
 
-    SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
+    tsdbRetrieveDataBlockInfo(pQueryHandle, &blockInfo);
 
     // todo extract methods
     if (QUERY_IS_INTERVAL_QUERY(pQuery) && pRuntimeEnv->windowResInfo.prevSKey == TSKEY_INITIAL_VAL) {
@@ -2913,7 +2914,7 @@ void disableFuncInReverseScan(SQInfo *pQInfo) {
 
   // group by normal columns and interval query on normal table
   SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
-  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     disableFuncInReverseScanImpl(pQInfo, pWindowResInfo, order);
   } else {  // for simple result of table query,
     for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {  // todo refactor
@@ -3088,7 +3089,7 @@ bool needScanDataBlocksAgain(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   bool toContinue = false;
-  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     // for each group result, call the finalize function for each column
     SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
 
@@ -3280,7 +3281,7 @@ void scanOneTableDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
 void finalizeQueryResult(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
-  if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
+  if (pRuntimeEnv->groupbyNormalCol || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     // for each group result, call the finalize function for each column
     SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
     if (pRuntimeEnv->groupbyNormalCol) {
@@ -3326,9 +3327,9 @@ static bool hasMainOutput(SQuery *pQuery) {
 }
 
 static STableQueryInfo *createTableQueryInfo(SQueryRuntimeEnv *pRuntimeEnv, void* pTable, STimeWindow win, void* buf) {
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQuery *pQuery = pRuntimeEnv->pQuery;
 
-  STableQueryInfo *pTableQueryInfo = buf;//calloc(1, sizeof(STableQueryInfo));
+  STableQueryInfo *pTableQueryInfo = buf;
 
   pTableQueryInfo->win = win;
   pTableQueryInfo->lastKey = win.skey;
@@ -3336,16 +3337,14 @@ static STableQueryInfo *createTableQueryInfo(SQueryRuntimeEnv *pRuntimeEnv, void
   pTableQueryInfo->pTable = pTable;
   pTableQueryInfo->cur.vgroupIndex = -1;
 
-  int32_t initialSize      = 1;
-  int32_t initialThreshold = 1;
-
   // set more initial size of interval/groupby query
   if (QUERY_IS_INTERVAL_QUERY(pQuery) || pRuntimeEnv->groupbyNormalCol) {
-    initialSize = 20;
-    initialThreshold = 100;
+    int32_t initialSize = 20;
+    int32_t initialThreshold = 100;
+    initWindowResInfo(&pTableQueryInfo->windowResInfo, pRuntimeEnv, initialSize, initialThreshold, TSDB_DATA_TYPE_INT);
+  } else { // in other aggregate query, do not initialize the windowResInfo
   }
 
-  initWindowResInfo(&pTableQueryInfo->windowResInfo, pRuntimeEnv, initialSize, initialThreshold, TSDB_DATA_TYPE_INT);
   return pTableQueryInfo;
 }
 
@@ -3569,7 +3568,7 @@ static int32_t getNumOfSubset(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
   int32_t totalSubset = 0;
-  if (pQInfo->runtimeEnv.groupbyNormalCol || (isIntervalQuery(pQuery))) {
+  if (pQInfo->runtimeEnv.groupbyNormalCol || (QUERY_IS_INTERVAL_QUERY(pQuery))) {
     totalSubset = numOfClosedTimeWindow(&pQInfo->runtimeEnv.windowResInfo);
   } else {
     totalSubset = GET_NUM_OF_TABLEGROUP(pQInfo);
@@ -3734,7 +3733,7 @@ bool queryHasRemainResults(SQueryRuntimeEnv* pRuntimeEnv) {
   } else {
     // there are results waiting for returned to client.
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED) &&
-        (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) &&
+        (pRuntimeEnv->groupbyNormalCol || QUERY_IS_INTERVAL_QUERY(pQuery)) &&
         (pRuntimeEnv->windowResInfo.size > 0)) {
       return true;
     }
@@ -3917,12 +3916,13 @@ void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
   STableQueryInfo* pTableQueryInfo = pQuery->current;
   TsdbQueryHandleT pQueryHandle = pRuntimeEnv->pQueryHandle;
 
+  SDataBlockInfo blockInfo = {0};
   while (tsdbNextDataBlock(pQueryHandle)) {
     if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
       return;
     }
 
-    SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
+    tsdbRetrieveDataBlockInfo(pQueryHandle, &blockInfo);
 
     if (pQuery->limit.offset > blockInfo.rows) {
       pQuery->limit.offset -= blockInfo.rows;
@@ -3959,8 +3959,9 @@ static bool skipTimeInterval(SQueryRuntimeEnv *pRuntimeEnv, TSKEY* start) {
   SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
   STableQueryInfo *pTableQueryInfo = pQuery->current;
 
+  SDataBlockInfo blockInfo = {0};
   while (tsdbNextDataBlock(pRuntimeEnv->pQueryHandle)) {
-    SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pRuntimeEnv->pQueryHandle);
+    tsdbRetrieveDataBlockInfo(pRuntimeEnv->pQueryHandle, &blockInfo);
 
     if (QUERY_IS_ASC_QUERY(pQuery)) {
       if (pWindowResInfo->prevSKey == TSKEY_INITIAL_VAL) {
@@ -4066,7 +4067,7 @@ static void setupQueryHandle(void* tsdb, SQInfo* pQInfo, bool isSTableQuery) {
     return;
   }
 
-  if (isSTableQuery && (!isIntervalQuery(pQuery)) && (!isFixedOutputQuery(pQuery))) {
+  if (isSTableQuery && (!QUERY_IS_INTERVAL_QUERY(pQuery)) && (!isFixedOutputQuery(pQuery))) {
     return;
   }
 
@@ -4080,7 +4081,7 @@ static void setupQueryHandle(void* tsdb, SQInfo* pQInfo, bool isSTableQuery) {
   if (!isSTableQuery
     && (pQInfo->tableqinfoGroupInfo.numOfTables == 1)
     && (cond.order == TSDB_ORDER_ASC) 
-    && (!isIntervalQuery(pQuery))
+    && (!QUERY_IS_INTERVAL_QUERY(pQuery))
     && (!isGroupbyNormalCol(pQuery->pGroupbyExpr))
     && (!isFixedOutputQuery(pQuery))
   ) {
@@ -4173,7 +4174,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, void *tsdb, int32_t vgId, bo
       initWindowResInfo(&pRuntimeEnv->windowResInfo, pRuntimeEnv, 512, 4096, type);
     }
 
-  } else if (pRuntimeEnv->groupbyNormalCol || isIntervalQuery(pQuery)) {
+  } else if (pRuntimeEnv->groupbyNormalCol || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     int32_t rows = getInitialPageNum(pQInfo);
     code = createDiskbasedResultBuffer(&pRuntimeEnv->pResultBuf, rows, pQuery->rowSize, pQInfo);
     if (code != TSDB_CODE_SUCCESS) {
@@ -4224,13 +4225,15 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
   int64_t st = taosGetTimestampMs();
 
   TsdbQueryHandleT pQueryHandle = IS_MASTER_SCAN(pRuntimeEnv)? pRuntimeEnv->pQueryHandle : pRuntimeEnv->pSecQueryHandle;
+  SDataBlockInfo blockInfo = {0};
+
   while (tsdbNextDataBlock(pQueryHandle)) {
     summary->totalBlocks += 1;
     if (isQueryKilled(pQInfo)) {
       break;
     }
 
-    SDataBlockInfo  blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
+    tsdbRetrieveDataBlockInfo(pQueryHandle, &blockInfo);
     STableQueryInfo **pTableQueryInfo = (STableQueryInfo**) taosHashGet(pQInfo->tableqinfoGroupInfo.map, &blockInfo.tid, sizeof(blockInfo.tid));
     if(pTableQueryInfo == NULL) {
       break;
@@ -4243,7 +4246,7 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
     SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
 
     if (!pRuntimeEnv->groupbyNormalCol) {
-      if (!isIntervalQuery(pQuery)) {
+      if (!QUERY_IS_INTERVAL_QUERY(pQuery)) {
         int32_t step = QUERY_IS_ASC_QUERY(pQuery)? 1:-1;
         setExecutionContext(pQInfo, (*pTableQueryInfo)->groupIndex, blockInfo.window.ekey + step);
       } else {  // interval query
@@ -4654,7 +4657,7 @@ static void doCloseAllTimeWindowAfterScan(SQInfo *pQInfo) {
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
 
-  if (isIntervalQuery(pQuery)) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
     size_t numOfGroup = GET_NUM_OF_TABLEGROUP(pQInfo);
     for (int32_t i = 0; i < numOfGroup; ++i) {
       SArray *group = GET_TABLEGROUP(pQInfo, i);
@@ -4680,7 +4683,7 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
      * if the groupIndex > 0, the query process must be completed yet, we only need to
      * copy the data into output buffer
      */
-    if (isIntervalQuery(pQuery)) {
+    if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
       copyResToQueryResultBuf(pQInfo, pQuery);
 #ifdef _DEBUG_VIEW
       displayInterResult(pQuery->sdata, pRuntimeEnv, pQuery->sdata[0]->num);
@@ -4889,7 +4892,7 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
   while (1) {
     tableIntervalProcessImpl(pRuntimeEnv, newStartKey);
 
-    if (isIntervalQuery(pQuery)) {
+    if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
       pQInfo->groupIndex = 0;  // always start from 0
       pQuery->rec.rows = 0;
       copyFromWindowResToSData(pQInfo, pRuntimeEnv->windowResInfo.pResult);
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 6a9c8e1ff6..b79fc10c63 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -249,8 +249,6 @@ static bool initTableMemIterator(STsdbQueryHandle* pHandle, STableCheckInfo* pCh
   pCheckInfo->initBuf = true;
   int32_t order = pHandle->order;
 
-//  tsdbTakeMemSnapshot(pHandle->pTsdb, &pCheckInfo->mem, &pCheckInfo->imem);
-
   // no data in buffer, abort
   if (pHandle->mem == NULL && pHandle->imem == NULL) {
     return false;
@@ -392,8 +390,11 @@ static bool hasMoreDataInCache(STsdbQueryHandle* pHandle) {
 
   STable* pTable = pCheckInfo->pTableObj;
   assert(pTable != NULL);
-  
-  initTableMemIterator(pHandle, pCheckInfo);
+
+  if (!pCheckInfo->initBuf) {
+    initTableMemIterator(pHandle, pCheckInfo);
+  }
+
   SDataRow row = getSDataRowInTableMem(pCheckInfo);
   if (row == NULL) {
     return false;
@@ -1477,7 +1478,8 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
   
   size_t numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   assert(numOfTables > 0);
-  
+
+  SDataBlockInfo blockInfo = {0};
   if (pQueryHandle->type == TSDB_QUERY_TYPE_EXTERNAL) {
     pQueryHandle->type = TSDB_QUERY_TYPE_ALL;
     pQueryHandle->order = TSDB_ORDER_DESC;
@@ -1487,7 +1489,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
     }
     
     SArray* sa = getDefaultLoadColumns(pQueryHandle, true);
-    /*SDataBlockInfo* pBlockInfo =*/ tsdbRetrieveDataBlockInfo(pHandle);
+    /*SDataBlockInfo* pBlockInfo =*/ tsdbRetrieveDataBlockInfo(pHandle, &blockInfo);
     /*SArray *pDataBlock = */tsdbRetrieveDataBlock(pHandle, sa);
   
     if (pQueryHandle->cur.win.ekey == pQueryHandle->window.skey) {
@@ -1558,7 +1560,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
       bool ret = tsdbNextDataBlock((void*) pSecQueryHandle);
       assert(ret);
 
-      /*SDataBlockInfo* pBlockInfo =*/ tsdbRetrieveDataBlockInfo((void*) pSecQueryHandle);
+      /*SDataBlockInfo* pBlockInfo =*/ tsdbRetrieveDataBlockInfo((void*) pSecQueryHandle, &blockInfo);
       /*SArray *pDataBlock = */tsdbRetrieveDataBlock((void*) pSecQueryHandle, sa);
   
       for (int32_t i = 0; i < numOfCols; ++i) {
@@ -1750,7 +1752,7 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
   return numOfRows;
 }
 
-SDataBlockInfo tsdbRetrieveDataBlockInfo(TsdbQueryHandleT* pQueryHandle) {
+void tsdbRetrieveDataBlockInfo(TsdbQueryHandleT* pQueryHandle, SDataBlockInfo* pDataBlockInfo) {
   STsdbQueryHandle* pHandle = (STsdbQueryHandle*)pQueryHandle;
   SQueryFilePos* cur = &pHandle->cur;
   STable* pTable = NULL;
@@ -1763,16 +1765,12 @@ SDataBlockInfo tsdbRetrieveDataBlockInfo(TsdbQueryHandleT* pQueryHandle) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pHandle->pTableCheckInfo, pHandle->activeIndex);
     pTable = pCheckInfo->pTableObj;
   }
-  
-  SDataBlockInfo blockInfo = {
-      .uid = pTable->tableId.uid,
-      .tid = pTable->tableId.tid,
-      .rows = cur->rows,
-      .window = cur->win,
-      .numOfCols = QH_GET_NUM_OF_COLS(pHandle),
-  };
 
-  return blockInfo;
+  pDataBlockInfo->uid = pTable->tableId.uid;
+  pDataBlockInfo->tid = pTable->tableId.tid;
+  pDataBlockInfo->rows = cur->rows;
+  pDataBlockInfo->window = cur->win;
+  pDataBlockInfo->numOfCols = QH_GET_NUM_OF_COLS(pHandle);
 }
 
 /*

From 4a54b80c35374d293e68f33fa47733be492f9601 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Mon, 6 Jul 2020 18:37:27 +0800
Subject: [PATCH 29/87] update table schema and tag value

---
 src/client/src/tscSQLParser.c |  2 +-
 src/inc/taosmsg.h             |  2 +-
 src/tsdb/inc/tsdbMain.h       | 42 +++++++++++++----------------------
 src/tsdb/src/tsdbMeta.c       | 21 +++---------------
 4 files changed, 21 insertions(+), 46 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 22e91bd658..ea88e4a935 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -4490,7 +4490,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     pUpdateMsg->tid       = htonl(pTableMeta->sid);
     pUpdateMsg->uid       = htobe64(pTableMeta->uid);
     pUpdateMsg->colId     = htons(pTagsSchema->colId);
-    pUpdateMsg->type      = htons(pTagsSchema->type);
+    pUpdateMsg->type      = pTagsSchema->type;
     pUpdateMsg->bytes     = htons(pTagsSchema->bytes);
     pUpdateMsg->tversion  = htons(pTableMeta->tversion);
     pUpdateMsg->numOfTags = htons(numOfTags);
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 65cabe6bc1..8c987b6ef1 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -284,7 +284,7 @@ typedef struct {
   int32_t   tid;
   int16_t   tversion;
   int16_t   colId;
-  int16_t   type;
+  int8_t    type;
   int16_t   bytes;
   int32_t   tagValLen;
   int16_t   numOfTags;
diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index b84a2c1243..d856650b0e 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -294,38 +294,12 @@ typedef struct {
 #define TABLE_SUID(t) (t)->suid
 #define TABLE_LASTKEY(t) (t)->lastKey
 
-static FORCE_INLINE STSchema *tsdbGetTableSchema(STable *pTable) {
-  if (pTable->type == TSDB_CHILD_TABLE) {  // check child table first
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->schema[pSuper->numOfSchemas - 1];
-  } else if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) {
-    return pTable->schema[pTable->numOfSchemas - 1];
-  } else {
-    return NULL;
-  }
-}
-
-static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {
-  if (pTable->type == TSDB_CHILD_TABLE) {  // check child table first
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->tagSchema;
-  } else if (pTable->type == TSDB_SUPER_TABLE) {
-    return pTable->tagSchema;
-  } else {
-    return NULL;
-  }
-}
-
 STsdbMeta* tsdbNewMeta(STsdbCfg* pCfg);
 void       tsdbFreeMeta(STsdbMeta* pMeta);
 int        tsdbOpenMeta(STsdbRepo* pRepo);
 int        tsdbCloseMeta(STsdbRepo* pRepo);
 STable*    tsdbGetTableByUid(STsdbMeta* pMeta, uint64_t uid);
 STSchema*  tsdbGetTableSchemaByVersion(STable* pTable, int16_t version);
-STSchema*  tsdbGetTableTagSchema(STable* pTable);
-// int        tsdbUpdateTable(STsdbRepo* pRepo, STable* pTable, STableCfg* pCfg);
 int        tsdbWLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbRLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbUnlockRepoMeta(STsdbRepo* pRepo);
@@ -374,6 +348,22 @@ _exit:
   return pSchema;
 }
 
+static FORCE_INLINE STSchema* tsdbGetTableSchema(STable* pTable) {
+  return tsdbGetTableSchemaImpl(pTable, false, false, -1);
+}
+
+static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {
+  if (pTable->type == TSDB_CHILD_TABLE) {  // check child table first
+    STable *pSuper = pTable->pSuper;
+    if (pSuper == NULL) return NULL;
+    return pSuper->tagSchema;
+  } else if (pTable->type == TSDB_SUPER_TABLE) {
+    return pTable->tagSchema;
+  } else {
+    return NULL;
+  }
+}
+
 // ------------------ tsdbBuffer.c
 STsdbBufPool* tsdbNewBufPool();
 void          tsdbFreeBufPool(STsdbBufPool* pBufPool);
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 14da6cb456..be9b8f7519 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -282,7 +282,6 @@ int tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
   pMsg->tid = htonl(pMsg->tid);
   pMsg->tversion  = htons(pMsg->tversion);
   pMsg->colId     = htons(pMsg->colId);
-  pMsg->type      = htons(pMsg->type);
   pMsg->bytes     = htons(pMsg->bytes);
   pMsg->tagValLen = htonl(pMsg->tagValLen);
   pMsg->numOfTags = htons(pMsg->numOfTags);
@@ -358,15 +357,15 @@ int tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
   }
 
   bool      isChangeIndexCol = (pMsg->colId == colColId(schemaColAt(pTable->pSuper->tagSchema, 0)));
-  STColumn *pCol = bsearch(&(pMsg->colId), pMsg->data, pMsg->numOfTags, sizeof(STColumn), colIdCompar);
-  ASSERT(pCol != NULL);
+  // STColumn *pCol = bsearch(&(pMsg->colId), pMsg->data, pMsg->numOfTags, sizeof(STColumn), colIdCompar);
+  // ASSERT(pCol != NULL);
 
   if (isChangeIndexCol) {
     tsdbWLockRepoMeta(pRepo);
     tsdbRemoveTableFromIndex(pMeta, pTable);
   }
   taosWLockLatch(&(pTable->latch));
-  tdSetKVRowDataOfCol(&(pTable->tagVal), pMsg->colId, pCol->type, POINTER_SHIFT(pMsg->data, pMsg->schemaLen));
+  tdSetKVRowDataOfCol(&(pTable->tagVal), pMsg->colId, pMsg->type, POINTER_SHIFT(pMsg->data, pMsg->schemaLen));
   taosWUnLockLatch(&(pTable->latch));
   if (isChangeIndexCol) {
     tsdbAddTableIntoIndex(pMeta, pTable, false);
@@ -486,8 +485,6 @@ int tsdbCloseMeta(STsdbRepo *pRepo) {
   return 0;
 }
 
-STSchema *tsdbGetTableSchema(STable *pTable) { return tsdbGetTableSchemaImpl(pTable, true, false, -1); }
-
 STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
   void *ptr = taosHashGet(pMeta->uidMap, (char *)(&uid), sizeof(uid));
 
@@ -500,18 +497,6 @@ STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t version) {
   return tsdbGetTableSchemaImpl(pTable, true, false, version);
 }
 
-STSchema *tsdbGetTableTagSchema(STable *pTable) {
-  if (pTable->type == TSDB_SUPER_TABLE) {
-    return pTable->tagSchema;
-  } else if (pTable->type == TSDB_CHILD_TABLE) {
-    STable *pSuper = pTable->pSuper;
-    if (pSuper == NULL) return NULL;
-    return pSuper->tagSchema;
-  } else {
-    return NULL;
-  }
-}
-
 int tsdbWLockRepoMeta(STsdbRepo *pRepo) {
   int code = pthread_rwlock_wrlock(&(pRepo->tsdbMeta->rwLock));
   if (code != 0) {

From 1ffdeae097ce229d06780ceea7fe1336541e603c Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Mon, 6 Jul 2020 18:59:54 +0800
Subject: [PATCH 30/87] update table

---
 src/client/src/tscUtil.c | 4 ++--
 src/tsdb/src/tsdbMain.c  | 6 ++----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 74d41304a4..791073f7a8 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -663,7 +663,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
     }
 
     SSubmitBlk* pBlocks = (SSubmitBlk*) pOneTableBlock->pData;
-    int64_t destSize = dataBuf->size + pOneTableBlock->size + pBlocks->numOfRows * expandSize;
+    int64_t destSize = dataBuf->size + pOneTableBlock->size + pBlocks->numOfRows * expandSize + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
 
     if (dataBuf->nAllocSize < destSize) {
       while (dataBuf->nAllocSize < destSize) {
@@ -691,7 +691,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
     tscDebug("%p tableId:%s, sid:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pSql, pOneTableBlock->tableId,
         pBlocks->tid, pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->data), GET_INT64_VAL(ekey));
 
-    int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + expandSize);
+    int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + expandSize) + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
 
     pBlocks->tid = htonl(pBlocks->tid);
     pBlocks->uid = htobe64(pBlocks->uid);
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 7f8144db13..6b31600705 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -166,12 +166,10 @@ int32_t tsdbInsertData(TSDB_REPO_T *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *
   SSubmitMsgIter msgIter = {0};
 
   if (tsdbScanAndConvertSubmitMsg(pRepo, pMsg) < 0) {
-    if (terrno == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
-      return 0;
-    } else {
+    if (terrno != TSDB_CODE_TDB_TABLE_RECONFIGURE) {
       tsdbError("vgId:%d failed to insert data since %s", REPO_ID(pRepo), tstrerror(terrno));
-      return -1;
     }
+    return -1;
   }
 
   if (tsdbInitSubmitMsgIter(pMsg, &msgIter) < 0) {

From 58ecd5c3348664566e9a1befb30babcd32393837 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 12:42:50 +0000
Subject: [PATCH 31/87] submit memory leak for wal or forward case

---
 src/dnode/src/dnodeVWrite.c |  5 ++++-
 src/rpc/src/rpcMain.c       |  7 ++++---
 src/vnode/src/vnodeWrite.c  | 19 +++++++++----------
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c
index d439dd985e..546e8cecb9 100644
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@@ -210,6 +210,7 @@ static void *dnodeProcessWriteQueue(void *param) {
   int32_t       numOfMsgs;
   int           type;
   void         *pVnode, *item;
+  SRspRet      *pRspRet;
 
   dDebug("write worker:%d is running", pWorker->workerId);
 
@@ -222,9 +223,11 @@ static void *dnodeProcessWriteQueue(void *param) {
 
     for (int32_t i = 0; i < numOfMsgs; ++i) {
       pWrite = NULL;
+      pRspRet = NULL;
       taosGetQitem(pWorker->qall, &type, &item);
       if (type == TAOS_QTYPE_RPC) {
         pWrite = (SWriteMsg *)item;
+        pRspRet = &pWrite->rspRet;
         pHead = (SWalHead *)(pWrite->pCont - sizeof(SWalHead));
         pHead->msgType = pWrite->rpcMsg.msgType;
         pHead->version = 0;
@@ -234,7 +237,7 @@ static void *dnodeProcessWriteQueue(void *param) {
         pHead = (SWalHead *)item;
       }
 
-      int32_t code = vnodeProcessWrite(pVnode, type, pHead, item);
+      int32_t code = vnodeProcessWrite(pVnode, type, pHead, pRspRet);
       if (pWrite) pWrite->rpcMsg.code = code;
     }
 
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index fc74ca0cea..96066b8b9d 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -538,6 +538,7 @@ void rpcCancelRequest(void *handle) {
 
   if (pContext->pConn) {
     tDebug("%s, app trys to cancel request", pContext->pConn->info);
+    pContext->pConn->pReqMsg = NULL;  
     rpcCloseConn(pContext->pConn);
     pContext->pConn = NULL;
     rpcFreeCont(pContext->pCont);
@@ -958,7 +959,7 @@ static void rpcProcessBrokenLink(SRpcConn *pConn) {
   if (pConn->outType) {
     SRpcReqContext *pContext = pConn->pContext;
     pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
-    pConn->pReq = NULL;
+    pConn->pReqMsg = NULL;
     taosTmrStart(rpcProcessConnError, 0, pContext, pRpc->tmrCtrl);
   }
 
@@ -1061,7 +1062,7 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead) {
     SRpcReqContext *pContext = pConn->pContext;
     rpcMsg.handle = pContext;
     pConn->pContext = NULL;
-    pConn->pReq = NULL;
+    pConn->pReqMsg = NULL;
 
     // for UDP, port may be changed by server, the port in ipSet shall be used for cache
     if (pHead->code != TSDB_CODE_RPC_TOO_SLOW) {
@@ -1298,7 +1299,7 @@ static void rpcProcessRetryTimer(void *param, void *tmrId) {
       tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, taosMsg[pConn->outType], pConn->peerFqdn, pConn->peerPort);
       if (pConn->pContext) {
         pConn->pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
-        pConn->pReq = NULL;
+        pConn->pReqMsg = NULL;
         taosTmrStart(rpcProcessConnError, 0, pConn->pContext, pRpc->tmrCtrl);
         rpcReleaseConn(pConn);
       }
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index e44436c8b7..3dc2f43fc8 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -97,18 +97,17 @@ void vnodeConfirmForward(void *param, uint64_t version, int32_t code) {
 static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {
   int32_t code = TSDB_CODE_SUCCESS;
 
-  // save insert result into item
-
   vTrace("vgId:%d, submit msg is processed", pVnode->vgId);
-  
-  pRet->len = sizeof(SShellSubmitRspMsg);
-  pRet->rsp = rpcMallocCont(pRet->len);
-  SShellSubmitRspMsg *pRsp = pRet->rsp;
+
+  // save insert result into item
+  SShellSubmitRspMsg *pRsp = NULL;
+  if (pRet) {  
+    pRet->len = sizeof(SShellSubmitRspMsg);
+    pRet->rsp = rpcMallocCont(pRet->len);
+    pRsp = pRet->rsp;
+  }
+
   if (tsdbInsertData(pVnode->tsdb, pCont, pRsp) < 0) code = terrno;
-  pRsp->numOfFailedBlocks = 0; //TODO
-  //pRet->len += pRsp->numOfFailedBlocks * sizeof(SShellSubmitRspBlock); //TODO
-  pRsp->code              = 0;
-  pRsp->numOfRows         = htonl(1);
   
   return code;
 }

From 87e80f8f9873e47915c76c506ef59474aa4a3385 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 13:24:31 +0000
Subject: [PATCH 32/87] dont free pReqMsg until a good solution is found

---
 src/rpc/src/rpcMain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 96066b8b9d..d14a98ab30 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -602,10 +602,10 @@ static void rpcReleaseConn(SRpcConn *pConn) {
     taosHashRemove(pRpc->hash, hashstr, size);
     rpcFreeMsg(pConn->pRspMsg); // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
+    if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   } 
 
   // memset could not be used, since lockeBy can not be reset
-  if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   pConn->inType = 0;
   pConn->outType = 0;
   pConn->inTranId = 0;

From dc7e5963d8e40ce2e6f916a311968f5d72357edb Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 6 Jul 2020 21:41:11 +0800
Subject: [PATCH 33/87] revert code

---
 src/rpc/src/rpcMain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 96066b8b9d..d14a98ab30 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -602,10 +602,10 @@ static void rpcReleaseConn(SRpcConn *pConn) {
     taosHashRemove(pRpc->hash, hashstr, size);
     rpcFreeMsg(pConn->pRspMsg); // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
+    if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   } 
 
   // memset could not be used, since lockeBy can not be reset
-  if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   pConn->inType = 0;
   pConn->outType = 0;
   pConn->inTranId = 0;

From ffc98a26b8c88a72b0862316d902f7ed2640ae39 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 14:08:38 +0000
Subject: [PATCH 34/87] check vnode status before alter or build status

---
 src/inc/taoserror.h        |  3 ++-
 src/vnode/src/vnodeMain.c  | 11 ++++++++++-
 src/vnode/src/vnodeRead.c  |  6 +++---
 src/vnode/src/vnodeWrite.c |  4 ++--
 4 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 4a7d86c434..388e22a561 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -180,7 +180,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_DISK_PERMISSIONS,      0, 0x0506, "vnode no d
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_SUCH_FILE_OR_DIR,      0, 0x0507, "vnode no such file or directory")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_OUT_OF_MEMORY,            0, 0x0508, "vnode out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_APP_ERROR,                0, 0x0509, "vnode app error")
-TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            0, 0x0214, "vnode no write auth")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_INVALID_STATUS,           0, 0x0510, "vnode not in ready state")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            0, 0x0511, "vnode no write auth")
 
 // tsdb
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_ID,         0, 0x0600, "tsdb invalid table id")
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index b469a5836e..bdc3b69d84 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -162,6 +162,12 @@ int32_t vnodeAlter(void *param, SMDCreateVnodeMsg *pVnodeCfg) {
   SVnodeObj *pVnode = param;
   pVnode->status = TAOS_VN_STATUS_UPDATING;
 
+  if (pVnode->status != TAOS_VN_STATUS_READY) 
+    return TSDB_CODE_VND_INVALID_STATUS;
+
+  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED)
+    return TSDB_CODE_VND_INVALID_STATUS;
+
   int32_t code = vnodeSaveCfg(pVnodeCfg);
   if (code != TSDB_CODE_SUCCESS) return code; 
 
@@ -408,8 +414,11 @@ void *vnodeGetWal(void *pVnode) {
 }
 
 static void vnodeBuildVloadMsg(SVnodeObj *pVnode, SDMStatusMsg *pStatus) {
-  if (pVnode->status == TAOS_VN_STATUS_DELETING) return;
+  if (pVnode->status != TAOS_VN_STATUS_READY) return;
   if (pStatus->openVnodes >= TSDB_MAX_VNODES) return;
+  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) return;
+  if (pVnode->tsdb == NULL) return;
+
   int64_t totalStorage, compStorage, pointsWritten = 0;
   tsdbReportStat(pVnode->tsdb, &pointsWritten, &totalStorage, &compStorage);
 
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 9938b34741..cbce3f6cf2 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -46,9 +46,9 @@ int32_t vnodeProcessRead(void *param, SReadMsg *pReadMsg) {
     return TSDB_CODE_VND_MSG_NOT_PROCESSED;
   }
 
-  if (pVnode->status == TAOS_VN_STATUS_DELETING || pVnode->status == TAOS_VN_STATUS_CLOSING) {
+  if (pVnode->status != TAOS_VN_STATUS_READY) {
     vDebug("vgId:%d, msgType:%s not processed, vnode status is %d", pVnode->vgId, taosMsg[msgType], pVnode->status);
-    return TSDB_CODE_VND_INVALID_VGROUP_ID; 
+    return TSDB_CODE_VND_INVALID_STATUS; 
   }
 
   // TODO: Later, let slave to support query
@@ -225,4 +225,4 @@ int32_t vnodeNotifyCurrentQhandle(void* handle, void* qhandle, int32_t vgId) {
 
   vDebug("QInfo:%p register qhandle to connect:%p", qhandle, handle);
   return rpcReportProgress(handle, (char*) killQueryMsg, sizeof(SRetrieveTableMsg));
-}
\ No newline at end of file
+}
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index 3dc2f43fc8..cc522c5d5a 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -58,10 +58,10 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
 
   if (pHead->version == 0) { // from client or CQ 
     if (pVnode->status != TAOS_VN_STATUS_READY) 
-      return TSDB_CODE_VND_INVALID_VGROUP_ID;  // it may be in deleting or closing state
+      return TSDB_CODE_VND_INVALID_STATUS;  // it may be in deleting or closing state
 
     if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER)
-      return TSDB_CODE_RPC_NOT_READY;
+      return TSDB_CODE_VND_INVALID_STATUS;
 
     // assign version
     pVnode->version++;

From afae27cf9bcf1e1c155595f8ee8b62f53f2cca54 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Mon, 6 Jul 2020 22:13:21 +0800
Subject: [PATCH 35/87] fix alter table coredump

---
 src/tsdb/src/tsdbMeta.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index be9b8f7519..9ebd63ba7e 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -552,6 +552,7 @@ void tsdbUnRefTable(STable *pTable) {
 
 void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema, bool insertAct) {
   ASSERT(TABLE_TYPE(pTable) != TSDB_STREAM_TABLE && TABLE_TYPE(pTable) != TSDB_SUPER_TABLE);
+  STsdbMeta *pMeta = pRepo->tsdbMeta;
 
   STable *pCTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
   ASSERT(schemaVersion(pSchema) > schemaVersion(pCTable->schema[pCTable->numOfSchemas - 1]));
@@ -565,6 +566,9 @@ void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema,
     memmove(pCTable->schema, pCTable->schema + 1, sizeof(STSchema *) * (TSDB_MAX_TABLE_SCHEMAS - 1));
     pCTable->schema[pCTable->numOfSchemas - 1] = pSchema;
   }
+
+  if (schemaNCols(pSchema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(pSchema);
+  if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
   taosWUnLockLatch(&(pCTable->latch));
 
   if (insertAct) {

From b03ed5253def8a6f78041f01d77db872549dbdd4 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 6 Jul 2020 14:16:01 +0000
Subject: [PATCH 36/87] [TD-860] change sync confirm in sdb

---
 src/dnode/src/dnodeMWrite.c |   6 +-
 src/mnode/src/mnodeSdb.c    | 112 +++++++++++++++++-------------------
 2 files changed, 56 insertions(+), 62 deletions(-)

diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c
index 90d857155a..a6aed29e3b 100644
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
@@ -131,8 +131,8 @@ static void dnodeFreeMnodeWriteMsg(SMnodeMsg *pWrite) {
   taosFreeQitem(pWrite);
 }
 
-void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) {
-  SMnodeMsg *pWrite = pRaw;
+void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code) {
+  SMnodeMsg *pWrite = pMsg;
   if (pWrite == NULL) return;
   if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return;
   if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) {
@@ -140,6 +140,8 @@ void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) {
     return;
   }
 
+  if (code > 0) return;
+
   SRpcMsg rpcRsp = {
     .handle  = pWrite->rpcMsg.handle,
     .pCont   = pWrite->rpcRsp.rsp,
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 761dce6720..cdcb426ba2 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -72,8 +72,6 @@ typedef struct {
   void *     sync;
   void *     wal;
   SSyncCfg   cfg;
-  sem_t      sem;
-  int32_t    code;
   int32_t    numOfTables;
   SSdbTable *tableList[SDB_TABLE_MAX];
   pthread_mutex_t mutex;
@@ -244,27 +242,19 @@ static void sdbNotifyRole(void *ahandle, int8_t role) {
   sdbUpdateMnodeRoles();
 }
 
+FORCE_INLINE
 static void sdbConfirmForward(void *ahandle, void *param, int32_t code) {
-  tsSdbObj.code = code;
-  sem_post(&tsSdbObj.sem);
-  sdbDebug("forward request confirmed, version:%" PRIu64 ", result:%s", (int64_t)param, tstrerror(code));
-}
+  SMnodeMsg *pMsg = param;
 
- static int32_t sdbForwardToPeer(SWalHead *pHead) {
-  if (tsSdbObj.sync == NULL) return TSDB_CODE_SUCCESS;
-
-  int32_t code = syncForwardToPeer(tsSdbObj.sync, pHead, (void*)pHead->version, TAOS_QTYPE_RPC);
-  if (code > 0) {
-    sdbDebug("forward request is sent, version:%" PRIu64 ", code:%d", pHead->version, code);
-    sem_wait(&tsSdbObj.sem);
-    return tsSdbObj.code;
-  } 
-  return code;
+  if (pMsg) {
+    sdbDebug("app:%p:%p, forward request is confirmed, result:%s", pMsg->rpcMsg.ahandle, pMsg, tstrerror(code));
+  }
+  dnodeSendRpcMnodeWriteRsp(pMsg, code);
 }
 
 void sdbUpdateSync() {
   SSyncCfg syncCfg = {0};
-  int32_t index = 0;
+  int32_t  index = 0;
 
   SDMMnodeInfos *mnodes = dnodeGetMnodeInfos();
   for (int32_t i = 0; i < mnodes->nodeNum; ++i) {
@@ -298,7 +288,7 @@ void sdbUpdateSync() {
   }
 
   syncCfg.replica = index;
-  syncCfg.quorum = (syncCfg.replica == 1) ? 1:2;
+  syncCfg.quorum = (syncCfg.replica == 1) ? 1 : 2;
 
   bool hasThisDnode = false;
   for (int32_t i = 0; i < syncCfg.replica; ++i) {
@@ -325,10 +315,10 @@ void sdbUpdateSync() {
   syncInfo.getWalInfo = sdbGetWalInfo;
   syncInfo.getFileInfo = sdbGetFileInfo;
   syncInfo.writeToCache = sdbWriteToQueue;
-  syncInfo.confirmForward = sdbConfirmForward; 
+  syncInfo.confirmForward = sdbConfirmForward;
   syncInfo.notifyRole = sdbNotifyRole;
   tsSdbObj.cfg = syncCfg;
-  
+
   if (tsSdbObj.sync) {
     syncReconfig(tsSdbObj.sync, &syncCfg);
   } else {
@@ -339,7 +329,6 @@ void sdbUpdateSync() {
 
 int32_t sdbInit() {
   pthread_mutex_init(&tsSdbObj.mutex, NULL);
-  sem_init(&tsSdbObj.sem, 0, 0);
 
   if (sdbInitWriteWorker() != 0) {
     return -1;
@@ -379,7 +368,6 @@ void sdbCleanUp() {
     tsSdbObj.wal = NULL;
   }
   
-  sem_destroy(&tsSdbObj.sem);
   pthread_mutex_destroy(&tsSdbObj.mutex);
 }
 
@@ -513,24 +501,22 @@ static int sdbWrite(void *param, void *data, int type) {
   assert(pTable != NULL);
 
   pthread_mutex_lock(&tsSdbObj.mutex);
+  
   if (pHead->version == 0) {
-     // assign version
+    // assign version
     tsSdbObj.version++;
     pHead->version = tsSdbObj.version;
   } else {
     // for data from WAL or forward, version may be smaller
     if (pHead->version <= tsSdbObj.version) {
       pthread_mutex_unlock(&tsSdbObj.mutex);
-      if (type == TAOS_QTYPE_FWD && tsSdbObj.sync != NULL) {
-        sdbDebug("forward request is received, version:%" PRIu64 " confirm it", pHead->version);
-        syncConfirmForward(tsSdbObj.sync, pHead->version, TSDB_CODE_SUCCESS);
-      }
+      sdbDebug("table:%s, failed to restore %s record:%s from source(%d), version:%" PRId64 " too large, sdb version:%" PRId64,
+               pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), type, pHead->version, tsSdbObj.version);
       return TSDB_CODE_SUCCESS;
     } else if (pHead->version != tsSdbObj.version + 1) {
       pthread_mutex_unlock(&tsSdbObj.mutex);
-      sdbError("table:%s, failed to restore %s record:%s from wal, version:%" PRId64 " too large, sdb version:%" PRId64,
-               pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version,
-               tsSdbObj.version);
+      sdbError("table:%s, failed to restore %s record:%s from source(%d), version:%" PRId64 " too large, sdb version:%" PRId64,
+               pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), type, pHead->version, tsSdbObj.version);
       return TSDB_CODE_MND_APP_ERROR;
     } else {
       tsSdbObj.version = pHead->version;
@@ -543,27 +529,33 @@ static int sdbWrite(void *param, void *data, int type) {
     return code;
   }
   
-  code = sdbForwardToPeer(pHead);
+  
+  // forward to peers, even it is WAL/FWD, it shall be called to update version in sync 
+  void *mhandle = NULL;
+  if (pOper != NULL) mhandle = pOper->pMsg;
+  int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, mhandle, TAOS_QTYPE_RPC);
   pthread_mutex_unlock(&tsSdbObj.mutex);
 
+  if (syncCode < 0) {
+    sdbDebug("table:%s, failed to forward request, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
+             tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    return syncCode;
+  } else if (syncCode > 0) {
+    sdbDebug("table:%s, forward request is sent, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
+             tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+  } else {}
+
   // from app, oper is created
   if (pOper != NULL) {
-    sdbTrace("record from app is disposed, table:%s action:%s record:%s version:%" PRIu64 " result:%s",
-             pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version,
-             tstrerror(code));
-    return code;
+    sdbDebug("table:%s, record from app is disposed, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
+             tstrerror(code), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    return syncCode;
+  } else {
+    sdbDebug("table:%s, record from wal/fwd is disposed, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
+             tstrerror(code), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
   }
 
   // from wal or forward msg, oper not created, should add into hash
-  if (tsSdbObj.sync != NULL) {
-    sdbTrace("record from wal forward is disposed, table:%s action:%s record:%s version:%" PRIu64 " confirm it",
-             pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-    syncConfirmForward(tsSdbObj.sync, pHead->version, code);
-  } else {
-    sdbTrace("record from wal restore is disposed, table:%s action:%s record:%s version:%" PRIu64, pTable->tableName,
-             sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-  }
-
   if (action == SDB_ACTION_INSERT) {
     SSdbOper oper = {.rowSize = pHead->len, .rowData = pHead->cont, .table = pTable};
     code = (*pTable->decodeFp)(&oper);
@@ -944,17 +936,16 @@ static void *sdbWorkerFp(void *param) {
       if (type == TAOS_QTYPE_RPC) {
         pOper = (SSdbOper *)item;
         pHead = (void *)pOper + sizeof(SSdbOper) + SDB_SYNC_HACK;
+        if (pOper->pMsg != NULL) {
+          sdbDebug("app:%p:%p, table:%s record:%p:%s version:%" PRIu64 ", will be processed in sdb queue",
+                   pOper->pMsg->rpcMsg.ahandle, pOper->pMsg, ((SSdbTable *)pOper->table)->tableName, pOper->pObj,
+                   sdbGetKeyStr(pOper->table, pHead->cont), pHead->version);
+        }
       } else {
         pHead = (SWalHead *)item;
         pOper = NULL;
       }
 
-      if (pOper != NULL && pOper->pMsg != NULL) {
-        sdbDebug("app:%p:%p, table:%s record:%p:%s version:%" PRIu64 ", will be processed in sdb queue",
-                 pOper->pMsg->rpcMsg.ahandle, pOper->pMsg, ((SSdbTable *)pOper->table)->tableName, pOper->pObj,
-                 sdbGetKeyStr(pOper->table, pHead->cont), pHead->version);
-      }
-
       int32_t code = sdbWrite(pOper, pHead, type);
       if (pOper) pOper->retCode = code;
     }
@@ -965,23 +956,24 @@ static void *sdbWorkerFp(void *param) {
     taosResetQitems(tsSdbWriteQall);
     for (int32_t i = 0; i < numOfMsgs; ++i) {
       taosGetQitem(tsSdbWriteQall, &type, &item);
+
       if (type == TAOS_QTYPE_RPC) {
         pOper = (SSdbOper *)item;
-        if (pOper != NULL && pOper->cb != NULL) {
+        if (pOper == NULL) {
+          taosFreeQitem(item);
+          continue;
+        }
+
+        if (pOper->cb != NULL) {
           sdbTrace("app:%p:%p, will do callback func, index:%d", pOper->pMsg->rpcMsg.ahandle, pOper->pMsg, i);
           pOper->retCode = (*pOper->cb)(pOper->pMsg, pOper->retCode);
         }
 
-        if (pOper != NULL && pOper->pMsg != NULL) {
-          sdbTrace("app:%p:%p, msg is processed, result:%s", pOper->pMsg->rpcMsg.ahandle, pOper->pMsg,
-                   tstrerror(pOper->retCode));
-        }
-
-        if (pOper != NULL) {
-          sdbDecRef(pOper->table, pOper->pObj);
-        }
-
         dnodeSendRpcMnodeWriteRsp(pOper->pMsg, pOper->retCode);
+        sdbDecRef(pOper->table, pOper->pObj);
+      } else if (type == TAOS_QTYPE_FWD) {
+        syncConfirmForward(tsSdbObj.sync, pHead->version, TSDB_CODE_SUCCESS);
+      } else {
       }
       taosFreeQitem(item);
     }

From 0568c10c4eb01e2f8b4de3dcf5b146829aed44c9 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 23:11:36 +0000
Subject: [PATCH 37/87] status check not right

---
 src/inc/taoserror.h        | 3 ++-
 src/vnode/src/vnodeMain.c  | 7 ++++---
 src/vnode/src/vnodeWrite.c | 2 +-
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 388e22a561..e90bcf3d88 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -181,7 +181,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_SUCH_FILE_OR_DIR,      0, 0x0507, "vnode no s
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_OUT_OF_MEMORY,            0, 0x0508, "vnode out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_APP_ERROR,                0, 0x0509, "vnode app error")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_INVALID_STATUS,           0, 0x0510, "vnode not in ready state")
-TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            0, 0x0511, "vnode no write auth")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_NOT_SYNCED,               0, 0x0511, "vnode not in synced state")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            0, 0x0512, "vnode no write auth")
 
 // tsdb
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_ID,         0, 0x0600, "tsdb invalid table id")
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index bdc3b69d84..0ee4ef4837 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -160,13 +160,14 @@ int32_t vnodeDrop(int32_t vgId) {
 
 int32_t vnodeAlter(void *param, SMDCreateVnodeMsg *pVnodeCfg) {
   SVnodeObj *pVnode = param;
-  pVnode->status = TAOS_VN_STATUS_UPDATING;
 
   if (pVnode->status != TAOS_VN_STATUS_READY) 
     return TSDB_CODE_VND_INVALID_STATUS;
 
-  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED)
-    return TSDB_CODE_VND_INVALID_STATUS;
+  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) 
+    return TSDB_CODE_VND_NOT_SYNCED;
+
+  pVnode->status = TAOS_VN_STATUS_UPDATING;
 
   int32_t code = vnodeSaveCfg(pVnodeCfg);
   if (code != TSDB_CODE_SUCCESS) return code; 
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index cc522c5d5a..031915809e 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -61,7 +61,7 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
       return TSDB_CODE_VND_INVALID_STATUS;  // it may be in deleting or closing state
 
     if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER)
-      return TSDB_CODE_VND_INVALID_STATUS;
+      return TSDB_CODE_RPC_NOT_READY;
 
     // assign version
     pVnode->version++;

From 6b3d0a18385bc024d8324bf93fbb960c1d0e8f5a Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 6 Jul 2020 23:31:07 +0000
Subject: [PATCH 38/87] free pReqMsg if outType is not 0

---
 src/rpc/src/rpcMain.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index d14a98ab30..e432e47e36 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -603,7 +603,10 @@ static void rpcReleaseConn(SRpcConn *pConn) {
     rpcFreeMsg(pConn->pRspMsg); // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
     if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
-  } 
+  } else {
+    if (pConn->outType && pConn->pReqMsg) 
+      rpcFreeCont(pConn->pReqMsg);
+  }
 
   // memset could not be used, since lockeBy can not be reset
   pConn->inType = 0;

From 96da5e233e63bba4297853a3767b2a6ec2998da7 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 10:56:58 +0800
Subject: [PATCH 39/87] [td-225] fix bugs in sliding query.

---
 src/common/src/tname.c    |   2 +-
 src/query/src/qExecutor.c | 147 +++++++++++++++++++++++---------------
 src/query/src/qUtil.c     |   3 +-
 3 files changed, 91 insertions(+), 61 deletions(-)

diff --git a/src/common/src/tname.c b/src/common/src/tname.c
index b3ff15f936..c8910a7867 100644
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -81,7 +81,7 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, in
     return startTime;
   }
 
-  int64_t start = ((startTime - intervalTime) / slidingTime + 1) * slidingTime;
+  int64_t start = ((startTime - slidingTime) / slidingTime + 1) * slidingTime;
   if (!(timeUnit == 'a' || timeUnit == 'm' || timeUnit == 's' || timeUnit == 'h')) {
     /*
      * here we revised the start time of day according to the local time zone,
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 37c21e069b..110cd23370 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -396,34 +396,38 @@ static bool hasNullValue(SQuery *pQuery, int32_t col, int32_t numOfCols, SDataSt
 }
 
 static SWindowResult *doSetTimeWindowFromKey(SQueryRuntimeEnv *pRuntimeEnv, SWindowResInfo *pWindowResInfo, char *pData,
-                                             int16_t bytes) {
+                                             int16_t bytes, bool masterscan) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   int32_t *p1 = (int32_t *) taosHashGet(pWindowResInfo->hashList, pData, bytes);
   if (p1 != NULL) {
     pWindowResInfo->curIndex = *p1;
-  } else {  // more than the capacity, reallocate the resources
-    if (pWindowResInfo->size >= pWindowResInfo->capacity) {
-      int64_t newCap = pWindowResInfo->capacity * 2;
+  } else {
+    if (masterscan) {  // more than the capacity, reallocate the resources
+      if (pWindowResInfo->size >= pWindowResInfo->capacity) {
+        int64_t newCap = pWindowResInfo->capacity * 2;
 
-      char *t = realloc(pWindowResInfo->pResult, newCap * sizeof(SWindowResult));
-      if (t != NULL) {
-        pWindowResInfo->pResult = (SWindowResult *)t;
-        memset(&pWindowResInfo->pResult[pWindowResInfo->capacity], 0, sizeof(SWindowResult) * pWindowResInfo->capacity);
-      } else {
-        // todo
+        char *t = realloc(pWindowResInfo->pResult, newCap * sizeof(SWindowResult));
+        if (t != NULL) {
+          pWindowResInfo->pResult = (SWindowResult *)t;
+          memset(&pWindowResInfo->pResult[pWindowResInfo->capacity], 0, sizeof(SWindowResult) * pWindowResInfo->capacity);
+        } else {
+          // todo
+        }
+
+        for (int32_t i = pWindowResInfo->capacity; i < newCap; ++i) {
+          SPosInfo pos = {-1, -1};
+          createQueryResultInfo(pQuery, &pWindowResInfo->pResult[i], pRuntimeEnv->stableQuery, &pos);
+        }
+        pWindowResInfo->capacity = newCap;
       }
 
-      for (int32_t i = pWindowResInfo->capacity; i < newCap; ++i) {
-        SPosInfo pos = {-1, -1};
-        createQueryResultInfo(pQuery, &pWindowResInfo->pResult[i], pRuntimeEnv->stableQuery, &pos);
-      }
-      pWindowResInfo->capacity = newCap;
+      // add a new result set for a new group
+      pWindowResInfo->curIndex = pWindowResInfo->size++;
+      taosHashPut(pWindowResInfo->hashList, pData, bytes, (char *)&pWindowResInfo->curIndex, sizeof(int32_t));
+    } else {
+      return NULL;
     }
-
-    // add a new result set for a new group
-    pWindowResInfo->curIndex = pWindowResInfo->size++;
-    taosHashPut(pWindowResInfo->hashList, pData, bytes, (char *)&pWindowResInfo->curIndex, sizeof(int32_t));
   }
 
   return getWindowResult(pWindowResInfo, pWindowResInfo->curIndex);
@@ -510,15 +514,19 @@ static int32_t addNewWindowResultBuf(SWindowResult *pWindowRes, SDiskbasedResult
 }
 
 static int32_t setWindowOutputBufByKey(SQueryRuntimeEnv *pRuntimeEnv, SWindowResInfo *pWindowResInfo, int32_t sid,
-                                       STimeWindow *win) {
+                                       STimeWindow *win, bool masterscan, bool* newWind) {
   assert(win->skey <= win->ekey);
   SDiskbasedResultBuf *pResultBuf = pRuntimeEnv->pResultBuf;
 
-  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, pWindowResInfo, (char *)&win->skey, TSDB_KEYSIZE);
+  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, pWindowResInfo, (char *)&win->skey,
+      TSDB_KEYSIZE, masterscan);
   if (pWindowRes == NULL) {
-    return -1;
+    *newWind = false;
+
+    return masterscan? -1:0;
   }
 
+  *newWind = true;
   // not assign result buffer yet, add new result buffer
   if (pWindowRes->pos.pageId == -1) {
     int32_t ret = addNewWindowResultBuf(pWindowRes, pResultBuf, sid, pRuntimeEnv->numOfRowsPerPage);
@@ -685,24 +693,26 @@ static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStat
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
-  for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
-    int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
+  if (IS_MASTER_SCAN(pRuntimeEnv) || pStatus->closed) {
+    for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
+      int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
 
-    pCtx[k].nStartQueryTimestamp = pWin->skey;
-    pCtx[k].size = forwardStep;
-    pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
+      pCtx[k].nStartQueryTimestamp = pWin->skey;
+      pCtx[k].size = forwardStep;
+      pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
 
-    if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
-      pCtx[k].ptsList = &tsBuf[offset];
-    }
+      if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
+        pCtx[k].ptsList = &tsBuf[offset];
+      }
 
-    // not a whole block involved in query processing, statistics data can not be used
-    if (forwardStep != numOfTotal) {
-      pCtx[k].preAggVals.isSet = false;
-    }
+      // not a whole block involved in query processing, statistics data can not be used
+      if (forwardStep != numOfTotal) {
+        pCtx[k].preAggVals.isSet = false;
+      }
 
-    if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
-      aAggs[functionId].xFunction(&pCtx[k]);
+      if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
+        aAggs[functionId].xFunction(&pCtx[k]);
+      }
     }
   }
 }
@@ -712,12 +722,14 @@ static void doRowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStatus
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
-  for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
-    pCtx[k].nStartQueryTimestamp = pWin->skey;
+  if (IS_MASTER_SCAN(pRuntimeEnv) || pStatus->closed) {
+    for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
+      pCtx[k].nStartQueryTimestamp = pWin->skey;
 
-    int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
-    if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
-      aAggs[functionId].xFunctionF(&pCtx[k], offset);
+      int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
+      if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
+        aAggs[functionId].xFunctionF(&pCtx[k], offset);
+      }
     }
   }
 }
@@ -879,7 +891,8 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
                                        SDataBlockInfo *pDataBlockInfo, SWindowResInfo *pWindowResInfo,
                                        __block_search_fn_t searchFn, SArray *pDataBlock) {
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
-  
+  bool masterScan = IS_MASTER_SCAN(pRuntimeEnv);
+
   SQuery *pQuery = pRuntimeEnv->pQuery;
   TSKEY  *tsCols = NULL;
   if (pDataBlock != NULL) {
@@ -902,18 +915,21 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
     int32_t offset = GET_COL_DATA_POS(pQuery, 0, step);
     TSKEY   ts = tsCols[offset];
 
+    bool hasTimeWindow = false;
     STimeWindow win = getActiveTimeWindow(pWindowResInfo, ts, pQuery);
-    if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &win) != TSDB_CODE_SUCCESS) {
+    if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &win, masterScan, &hasTimeWindow) != TSDB_CODE_SUCCESS) {
       tfree(sasArray);
       return;
     }
 
-    TSKEY   ekey = reviseWindowEkey(pQuery, &win);
-    int32_t forwardStep =
-        getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, tsCols, pQuery->pos, ekey, searchFn, true);
+    if (hasTimeWindow) {
+      TSKEY   ekey = reviseWindowEkey(pQuery, &win);
+      int32_t forwardStep =
+          getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, tsCols, pQuery->pos, ekey, searchFn, true);
 
-    SWindowStatus *pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
-    doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &win, pQuery->pos, forwardStep, tsCols, pDataBlockInfo->rows);
+      SWindowStatus *pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
+      doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &win, pQuery->pos, forwardStep, tsCols, pDataBlockInfo->rows);
+    }
 
     int32_t     index = pWindowResInfo->curIndex;
     STimeWindow nextWin = win;
@@ -925,14 +941,19 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
       }
 
       // null data, failed to allocate more memory buffer
-      if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &nextWin) != TSDB_CODE_SUCCESS) {
+      bool hasTimeWindow = false;
+      if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &nextWin, masterScan, &hasTimeWindow) != TSDB_CODE_SUCCESS) {
         break;
       }
 
-      ekey = reviseWindowEkey(pQuery, &nextWin);
-      forwardStep = getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, tsCols, startPos, ekey, searchFn, true);
+      if (!hasTimeWindow) {
+        continue;
+      }
 
-      pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
+      TSKEY ekey = reviseWindowEkey(pQuery, &nextWin);
+      int32_t forwardStep = getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, tsCols, startPos, ekey, searchFn, true);
+
+      SWindowStatus* pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
       doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &nextWin, startPos, forwardStep, tsCols, pDataBlockInfo->rows);
     }
 
@@ -982,7 +1003,7 @@ static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, char *pDat
   }
 
 //  assert(pRuntimeEnv->windowResInfo.hashList->size <= 2);
-  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, &pRuntimeEnv->windowResInfo, pData, bytes);
+  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, &pRuntimeEnv->windowResInfo, pData, bytes, true);
   if (pWindowRes == NULL) {
     return -1;
   }
@@ -1112,6 +1133,7 @@ static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
 static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pStatis, SDataBlockInfo *pDataBlockInfo,
     SWindowResInfo *pWindowResInfo, SArray *pDataBlock) {
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
+  bool masterScan = IS_MASTER_SCAN(pRuntimeEnv);
 
   SQuery *pQuery = pRuntimeEnv->pQuery;
   STableQueryInfo* item = pQuery->current;
@@ -1183,11 +1205,16 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
       int64_t     ts = tsCols[offset];
       STimeWindow win = getActiveTimeWindow(pWindowResInfo, ts, pQuery);
 
-      int32_t ret = setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &win);
+      bool hasTimeWindow = false;
+      int32_t ret = setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &win, masterScan, &hasTimeWindow);
       if (ret != TSDB_CODE_SUCCESS) {  // null data, too many state code
         continue;
       }
 
+      if (!hasTimeWindow) {
+        continue;
+      }
+
       SWindowStatus *pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
       doRowwiseApplyFunctions(pRuntimeEnv, pStatus, &win, offset);
 
@@ -1207,12 +1234,15 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
         }
 
         // null data, failed to allocate more memory buffer
-        if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &nextWin) != TSDB_CODE_SUCCESS) {
+        bool hasTimeWindow = false;
+        if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo->tid, &nextWin, masterScan, &hasTimeWindow) != TSDB_CODE_SUCCESS) {
           break;
         }
 
-        pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
-        doRowwiseApplyFunctions(pRuntimeEnv, pStatus, &nextWin, offset);
+        if (hasTimeWindow) {
+          pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
+          doRowwiseApplyFunctions(pRuntimeEnv, pStatus, &nextWin, offset);
+        }
       }
 
       pWindowResInfo->curIndex = index;
@@ -3388,7 +3418,8 @@ void setExecutionContext(SQInfo *pQInfo, int32_t groupIndex, TSKEY nextKey) {
   }
 
   int32_t GROUPRESULTID = 1;
-  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, pWindowResInfo, (char *)&groupIndex, sizeof(groupIndex));
+  SWindowResult *pWindowRes = doSetTimeWindowFromKey(pRuntimeEnv, pWindowResInfo, (char *)&groupIndex,
+      sizeof(groupIndex), true);
   if (pWindowRes == NULL) {
     return;
   }
diff --git a/src/query/src/qUtil.c b/src/query/src/qUtil.c
index 3b2b2bfff0..03574388b7 100644
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
@@ -190,8 +190,7 @@ void removeRedundantWindow(SWindowResInfo *pWindowResInfo, TSKEY lastKey, int32_
   }
 
   // get the result order
-  int32_t resultOrder = (pWindowResInfo->pResult[0].window.skey < pWindowResInfo->pResult[1].window.skey)?
-                         TSDB_ORDER_ASC:TSDB_ORDER_DESC;
+  int32_t resultOrder = (pWindowResInfo->pResult[0].window.skey < pWindowResInfo->pResult[1].window.skey)? 1:-1;
 
   if (order != resultOrder) {
     return;

From d37ab181d06a71829ccbfa34a7ebeedb1afd871f Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 11:23:03 +0800
Subject: [PATCH 40/87] change rpcFreeCont to rpcFreeMsg

---
 src/rpc/src/rpcMain.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index e432e47e36..0d5b80e8f3 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -602,10 +602,13 @@ static void rpcReleaseConn(SRpcConn *pConn) {
     taosHashRemove(pRpc->hash, hashstr, size);
     rpcFreeMsg(pConn->pRspMsg); // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
-    if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
+  
+    // if server has ever reported progress, free content
+    if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);  // do not use rpcFreeMsg
   } else {
+    // if there is an outgoing message, free it
     if (pConn->outType && pConn->pReqMsg) 
-      rpcFreeCont(pConn->pReqMsg);
+      rpcFreeMsg(pConn->pReqMsg);
   }
 
   // memset could not be used, since lockeBy can not be reset

From a2e97d8ec29e6bd29087428fcf64baf07ba2384f Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 03:36:59 +0000
Subject: [PATCH 41/87] [TD-860]

---
 src/dnode/src/dnodeMWrite.c |  2 --
 src/mnode/src/mnodeSdb.c    | 48 ++++++++++++++++++++-----------------
 2 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c
index a6aed29e3b..b53c66e00c 100644
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
@@ -140,8 +140,6 @@ void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code) {
     return;
   }
 
-  if (code > 0) return;
-
   SRpcMsg rpcRsp = {
     .handle  = pWrite->rpcMsg.handle,
     .pCont   = pWrite->rpcRsp.rsp,
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index cdcb426ba2..70354cf550 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -244,12 +244,20 @@ static void sdbNotifyRole(void *ahandle, int8_t role) {
 
 FORCE_INLINE
 static void sdbConfirmForward(void *ahandle, void *param, int32_t code) {
-  SMnodeMsg *pMsg = param;
+  if (code > 0) return;
 
-  if (pMsg) {
-    sdbDebug("app:%p:%p, forward request is confirmed, result:%s", pMsg->rpcMsg.ahandle, pMsg, tstrerror(code));
+  assert(param);
+
+  SSdbOper * pOper = param;
+  SMnodeMsg *pMsg = pOper->pMsg;
+
+  if (pOper->cb != NULL) {
+    sdbDebug("app:%p:%p, is confirmed and will do callback func", pMsg->rpcMsg.ahandle, pMsg);
+    pOper->retCode = (*pOper->cb)(pMsg, code);
   }
-  dnodeSendRpcMnodeWriteRsp(pMsg, code);
+
+  dnodeSendRpcMnodeWriteRsp(pMsg, pOper->retCode);
+  taosFreeQitem(pOper);
 }
 
 void sdbUpdateSync() {
@@ -529,7 +537,6 @@ static int sdbWrite(void *param, void *data, int type) {
     return code;
   }
   
-  
   // forward to peers, even it is WAL/FWD, it shall be called to update version in sync 
   void *mhandle = NULL;
   if (pOper != NULL) mhandle = pOper->pMsg;
@@ -541,18 +548,19 @@ static int sdbWrite(void *param, void *data, int type) {
              tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
     return syncCode;
   } else if (syncCode > 0) {
-    sdbDebug("table:%s, forward request is sent, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
-             tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-  } else {}
+    sdbDebug("table:%s, forward request is sent, syncCode:%d action:%s record:%s version:%" PRId64, pTable->tableName,
+             syncCode, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+  } else {
+  }
 
   // from app, oper is created
   if (pOper != NULL) {
-    sdbDebug("table:%s, record from app is disposed, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
-             tstrerror(code), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    sdbDebug("table:%s, record from app is disposed, action:%s record:%s version:%" PRId64, pTable->tableName,
+             sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
     return syncCode;
   } else {
-    sdbDebug("table:%s, record from wal/fwd is disposed, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
-             tstrerror(code), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    sdbDebug("table:%s, record from wal/fwd is disposed, action:%s record:%s version:%" PRId64, pTable->tableName,
+             sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
   }
 
   // from wal or forward msg, oper not created, should add into hash
@@ -619,7 +627,7 @@ int32_t sdbInsertRow(SSdbOper *pOper) {
   memcpy(pNewOper, pOper, sizeof(SSdbOper));
 
   if (pNewOper->pMsg != NULL) {
-    sdbDebug("app:%p:%p, table:%s record:%p:%s, insert action is add to sdb queue, ", pNewOper->pMsg->rpcMsg.ahandle,
+    sdbDebug("app:%p:%p, table:%s record:%p:%s, insert action is add to sdb queue", pNewOper->pMsg->rpcMsg.ahandle,
              pNewOper->pMsg, pTable->tableName, pOper->pObj, sdbGetKeyStrFromObj(pTable, pOper->pObj));
   }
 
@@ -669,7 +677,7 @@ int32_t sdbDeleteRow(SSdbOper *pOper) {
   memcpy(pNewOper, pOper, sizeof(SSdbOper));
 
   if (pNewOper->pMsg != NULL) {
-    sdbDebug("app:%p:%p, table:%s record:%p:%s, delete action is add to sdb queue, ", pNewOper->pMsg->rpcMsg.ahandle,
+    sdbDebug("app:%p:%p, table:%s record:%p:%s, delete action is add to sdb queue", pNewOper->pMsg->rpcMsg.ahandle,
              pNewOper->pMsg, pTable->tableName, pOper->pObj, sdbGetKeyStrFromObj(pTable, pOper->pObj));
   }
 
@@ -719,7 +727,7 @@ int32_t sdbUpdateRow(SSdbOper *pOper) {
   memcpy(pNewOper, pOper, sizeof(SSdbOper));
 
   if (pNewOper->pMsg != NULL) {
-    sdbDebug("app:%p:%p, table:%s record:%p:%s, update action is add to sdb queue, ", pNewOper->pMsg->rpcMsg.ahandle,
+    sdbDebug("app:%p:%p, table:%s record:%p:%s, update action is add to sdb queue", pNewOper->pMsg->rpcMsg.ahandle,
              pNewOper->pMsg, pTable->tableName, pOper->pObj, sdbGetKeyStrFromObj(pTable, pOper->pObj));
   }
 
@@ -964,18 +972,14 @@ static void *sdbWorkerFp(void *param) {
           continue;
         }
 
-        if (pOper->cb != NULL) {
-          sdbTrace("app:%p:%p, will do callback func, index:%d", pOper->pMsg->rpcMsg.ahandle, pOper->pMsg, i);
-          pOper->retCode = (*pOper->cb)(pOper->pMsg, pOper->retCode);
-        }
-
-        dnodeSendRpcMnodeWriteRsp(pOper->pMsg, pOper->retCode);
         sdbDecRef(pOper->table, pOper->pObj);
+        sdbConfirmForward(NULL, pOper, pOper->retCode);
       } else if (type == TAOS_QTYPE_FWD) {
         syncConfirmForward(tsSdbObj.sync, pHead->version, TSDB_CODE_SUCCESS);
+        taosFreeQitem(item);
       } else {
+        taosFreeQitem(item);
       }
-      taosFreeQitem(item);
     }
   }
 

From e6f810190899bc009c72487f3d65823a6b2ca4eb Mon Sep 17 00:00:00 2001
From: dengyihao <luomoxyz@126.com>
Date: Tue, 7 Jul 2020 11:41:32 +0800
Subject: [PATCH 42/87] support cancel query

---
 src/client/src/tscServer.c |  5 +++--
 src/client/src/tscSql.c    |  9 ++++-----
 src/vnode/src/vnodeRead.c  | 10 ++++------
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 584e70ba6c..b2482a90ca 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -438,8 +438,9 @@ void tscKillSTableQuery(SSqlObj *pSql) {
      * here, we cannot set the command = TSDB_SQL_KILL_QUERY. Otherwise, it may cause
      * sub-queries not correctly released and master sql object of super table query reaches an abnormal state.
      */
-    pSql->pSubs[i]->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
-    rpcCancelRequest(pSql->pSubs[i]->pRpcCtx);
+    rpcCancelRequest(pSub->pRpcCtx);
+    pSub->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
+    tscQueueAsyncRes(pSub);
   }
 
   /*
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8fbc1f0109..f9f93b3f89 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -617,19 +617,18 @@ void taos_stop_query(TAOS_RES *res) {
   if (pSql->signature != pSql) return;
   tscDebug("%p start to cancel query", res);
 
-  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     tscKillSTableQuery(pSql);
-    return;
   }
 
-  if (pSql->cmd.command >= TSDB_SQL_LOCAL) {
-    return;
+  if (pSql->cmd.command < TSDB_SQL_LOCAL) {
+    rpcCancelRequest(pSql->pRpcCtx);
   }
+  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
+  tscQueueAsyncRes(pSql);
 
-  rpcCancelRequest(pSql->pRpcCtx);
   tscDebug("%p query is cancelled", res);
 }
 
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index c8a6a4ce4e..8665aa01cb 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -135,7 +135,9 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
     } else {
       assert(pQInfo == NULL);
     }
-
+    if (handle != NULL) {
+      dnodePutItemIntoReadQueue(pVnode, handle);
+    }
     vDebug("vgId:%d, QInfo:%p, dnode query msg disposed", vgId, pQInfo);
   } else {
     assert(pCont != NULL);
@@ -146,14 +148,10 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
     } else {
       vDebug("vgId:%d, QInfo:%p, dnode query msg in progress", pVnode->vgId, *(void**) pCont);
       code = TSDB_CODE_VND_ACTION_IN_PROGRESS;
+      qTableQuery(*handle); // do execute query
     }
-  }
-
-  if (handle != NULL) {
-    qTableQuery(*handle); // do execute query
     qReleaseQInfo(pVnode->qMgmt, (void**) &handle, false);
   }
-
   return code;
 }
 

From c3a14568b6767313a94a49dcbd95fc89ab1225b4 Mon Sep 17 00:00:00 2001
From: haojun Liao <hjxilinx@users.noreply.github.com>
Date: Tue, 7 Jul 2020 11:51:50 +0800
Subject: [PATCH 43/87] Update TAOS SQL.md

---
 documentation/webdocs/markdowndocs/TAOS SQL.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/documentation/webdocs/markdowndocs/TAOS SQL.md b/documentation/webdocs/markdowndocs/TAOS SQL.md
index 72e41dbec4..c0d35e9afc 100644
--- a/documentation/webdocs/markdowndocs/TAOS SQL.md	
+++ b/documentation/webdocs/markdowndocs/TAOS SQL.md	
@@ -412,7 +412,7 @@ TDengine supports aggregations over numerical values, they are listed below:
     SELECT PERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause]
     ```
     Function: the value of the specified column below which `P` percent of the data points fall.  
-    Return Data Type: the same data type.  
+    Return Data Type: double.  
     Applicable Data Types: all types except `timestamp`, `binary`, `nchar`, `bool`. 
     Applied to: table/STable.  
     Note: The range of `P` is `[0, 100]`. When `P=0` , `PERCENTILE` returns the equal value as `MIN`; when `P=100`, `PERCENTILE` returns the equal value as `MAX`. 
@@ -446,7 +446,7 @@ TDengine supports aggregations over numerical values, they are listed below:
     SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause]
     ```
     Function: return the difference between the maximum and the mimimum value.  
-    Return Data Type: the same data type.  
+    Return Data Type: double.  
     Applicable Data Types: all types except `timestamp`, `binary`, `nchar`, `bool`.  
     Applied to: table/STable.  
     Note: spread gives the range of data variation in a table/supertable; it is equivalent to `MAX()` - `MIN()`

From 94e50c413ea0f811f484b1badc794ebe62076598 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 03:54:18 +0000
Subject: [PATCH 44/87] [TD-860]

---
 src/mnode/src/mnodeSdb.c | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 70354cf550..0f657bdde8 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -244,19 +244,26 @@ static void sdbNotifyRole(void *ahandle, int8_t role) {
 
 FORCE_INLINE
 static void sdbConfirmForward(void *ahandle, void *param, int32_t code) {
-  if (code > 0) return;
-
   assert(param);
-
   SSdbOper * pOper = param;
   SMnodeMsg *pMsg = pOper->pMsg;
 
-  if (pOper->cb != NULL) {
-    sdbDebug("app:%p:%p, is confirmed and will do callback func", pMsg->rpcMsg.ahandle, pMsg);
-    pOper->retCode = (*pOper->cb)(pMsg, code);
+  if (code > 0) {
+    if (pMsg != NULL) {
+      sdbDebug("app:%p:%p, waiting for slave to confirm this operation", pMsg->rpcMsg.ahandle, pMsg);
+    }
+    return;
   }
 
-  dnodeSendRpcMnodeWriteRsp(pMsg, pOper->retCode);
+  if (pMsg != NULL) {
+    sdbDebug("app:%p:%p, is confirmed and will do callback func, code:%s", pMsg->rpcMsg.ahandle, pMsg, tstrerror(code));
+  }
+
+  if (pOper->cb != NULL) {
+    code = (*pOper->cb)(pMsg, code);
+  }
+
+  dnodeSendRpcMnodeWriteRsp(pMsg, code);
   taosFreeQitem(pOper);
 }
 
@@ -538,9 +545,7 @@ static int sdbWrite(void *param, void *data, int type) {
   }
   
   // forward to peers, even it is WAL/FWD, it shall be called to update version in sync 
-  void *mhandle = NULL;
-  if (pOper != NULL) mhandle = pOper->pMsg;
-  int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, mhandle, TAOS_QTYPE_RPC);
+  int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
   pthread_mutex_unlock(&tsSdbObj.mutex);
 
   if (syncCode < 0) {

From 168d9ce4bc4e3f2a54abc874871e214cc4f51164 Mon Sep 17 00:00:00 2001
From: haojun Liao <hjxilinx@users.noreply.github.com>
Date: Tue, 7 Jul 2020 12:02:06 +0800
Subject: [PATCH 45/87] Update TAOS SQL-ch.md

---
 documentation/webdocs/markdowndocs/TAOS SQL-ch.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md
index 0be39ab8e4..343ce80422 100644
--- a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md	
+++ b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md	
@@ -480,9 +480,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **LEASTSQUARES**
     ```mysql
-    SELECT LEASTSQUARES(field_name) FROM tb_name [WHERE clause]
+    SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause]
     ```
-    功能说明：统计表中某列的值是主键（时间戳）的拟合直线方程。  
+    功能说明：统计表中某列的值是主键（时间戳）的拟合直线方程。start_val是自变量初始值，step_val是自变量的步长值。  
     返回结果数据类型：字符串表达式（斜率, 截距）。  
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。  
     说明：自变量是时间戳，因变量是该列的值。  

From 09c89d94125014f0c2d506c2e6e4dc7a42cd89bd Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 12:59:24 +0800
Subject: [PATCH 46/87] [td-225] handle the case where no qualified ts exists
 during join query process.

---
 src/client/src/tscSubquery.c         | 58 +++++++++-------------------
 tests/script/general/parser/join.sim | 12 ++++++
 2 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 0243d115f0..c052482edf 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -57,10 +57,15 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSupporter* pSupporter1, SJ
   pSubQueryInfo1->tsBuf = output1;
   pSubQueryInfo2->tsBuf = output2;
 
+  // no result generated, return directly
+  if (pSupporter1->pTSBuf == NULL || pSupporter2->pTSBuf == NULL) {
+    tscDebug("%p at least one ts-comp is empty, 0 for secondary query after ts blocks intersecting", pSql);
+    return 0;
+  }
+
   tsBufResetPos(pSupporter1->pTSBuf);
   tsBufResetPos(pSupporter2->pTSBuf);
 
-  // TODO add more details information
   if (!tsBufNextPos(pSupporter1->pTSBuf)) {
     tsBufFlush(output1);
     tsBufFlush(output2);
@@ -420,43 +425,6 @@ static void updateQueryTimeRange(SQueryInfo* pQueryInfo, STimeWindow* win) {
   pQueryInfo->window = *win;
 }
 
-static UNUSED_FUNC void tSIntersectionAndLaunchSecQuery(SJoinSupporter* pSupporter, SSqlObj* pSql) {
-  SSqlObj* pParentSql = pSupporter->pObj;
-  SQueryInfo* pParentQueryInfo = tscGetQueryInfoDetail(&pParentSql->cmd, pParentSql->cmd.clauseIndex);
-  
-//  if (tscNonOrderedProjectionQueryOnSTable(pParentQueryInfo, 0)) {
-//    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-//    assert(pQueryInfo->numOfTables == 1);
-//
-//    // for projection query, need to try next vnode
-////        int32_t totalVnode = pTableMetaInfo->pMetricMeta->numOfVnodes;
-//    int32_t totalVnode = 0;
-//    if ((++pTableMetaInfo->vgroupIndex) < totalVnode) {
-//      tscDebug("%p current vnode:%d exhausted, try next:%d. total vnode:%d. current numOfRes:%d", pSql,
-//               pTableMetaInfo->vgroupIndex - 1, pTableMetaInfo->vgroupIndex, totalVnode, pRes->numOfTotal);
-//
-//      pSql->cmd.command = TSDB_SQL_SELECT;
-//      pSql->fp = tscJoinQueryCallback;
-//      tscProcessSql(pSql);
-//
-//      return;
-//    }
-//  }
-
-    SJoinSupporter* p1 = pParentSql->pSubs[0]->param;
-    SJoinSupporter* p2 = pParentSql->pSubs[1]->param;
-    
-    STimeWindow win = TSWINDOW_INITIALIZER;
-    int64_t num = doTSBlockIntersect(pParentSql, p1, p2, &win);
-    if (num <= 0) {  // no result during ts intersect
-      tscDebug("%p free all sub SqlObj and quit", pParentSql);
-      freeJoinSubqueryObj(pParentSql);
-    } else {
-      updateQueryTimeRange(pParentQueryInfo, &win);
-      tscLaunchRealSubqueries(pParentSql);
-    }
-}
-
 int32_t tscCompareTidTags(const void* p1, const void* p2) {
   const STidTags* t1 = (const STidTags*) varDataVal(p1);
   const STidTags* t2 = (const STidTags*) varDataVal(p2);
@@ -713,9 +681,16 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SArray *s1 = NULL, *s2 = NULL;
   getIntersectionOfTableTuple(pQueryInfo, pParentSql, &s1, &s2);
   if (taosArrayGetSize(s1) == 0 || taosArrayGetSize(s2) == 0) {  // no results,return.
-    tscDebug("%p free all sub SqlObj and quit", pParentSql);
+    taosArrayDestroy(s1);
+    taosArrayDestroy(s2);
+
+    tscDebug("%p tag intersect does not generated qualified tables for join, free all sub SqlObj and quit", pParentSql);
     freeJoinSubqueryObj(pParentSql);
 
+    // set no result command
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+    (*pParentSql->fp)(pSql->param, pParentSql, 0);
+
   } else {
     // proceed to for ts_comp query
     SSqlCmd* pSubCmd1 = &pParentSql->pSubs[0]->cmd;
@@ -846,7 +821,10 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   if (num <= 0) {  // no result during ts intersect
     tscDebug("%p no results generated in ts intersection, free all sub SqlObj and quit", pParentSql);
     freeJoinSubqueryObj(pParentSql);
-    
+
+    // set no result command
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+    (*pParentSql->fp)(pSql->param, pParentSql, 0);
     return;
   }
 
diff --git a/tests/script/general/parser/join.sim b/tests/script/general/parser/join.sim
index 1bce6f1950..69932e1e1c 100644
--- a/tests/script/general/parser/join.sim
+++ b/tests/script/general/parser/join.sim
@@ -447,4 +447,16 @@ sql insert into um2 using m2 tags(9) values(1000001, 10)(2000000, 20);
 
 sql_error select count(*) from m1,m2 where m1.a=m2.a and m1.ts=m2.ts;
 
+#empty table join test, add for no result join test
+create database ux1;
+use ux1;
+create table m1(ts timestamp, k int) tags(a binary(12), b int);
+create table tm0 using m1 tags('abc', 1);
+
+create table m2(ts timestamp, k int) tags(a int, b binary(12));
+create table tm2 using m2 tags(2, 'abc');
+select count(*) from tm0, tm2 where tm0.ts=tm2.ts;
+select count(*) from m1, m2 where m1.ts=m2.ts and m1.b=m2.a
+drop database ux1;
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From aaaf7c2108f4592873b12ec2c3432dba088b72b3 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 13:04:03 +0800
Subject: [PATCH 47/87] [td-225] fix memeory leaks.

---
 src/client/src/tscSubquery.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index c052482edf..47f2ba855e 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -215,6 +215,7 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
     pSupporter->f = NULL;
   }
 
+  tfree(pSupporter->pIdTagList);
   tscTagCondRelease(&pSupporter->tagCond);
   free(pSupporter);
 }
@@ -681,16 +682,12 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SArray *s1 = NULL, *s2 = NULL;
   getIntersectionOfTableTuple(pQueryInfo, pParentSql, &s1, &s2);
   if (taosArrayGetSize(s1) == 0 || taosArrayGetSize(s2) == 0) {  // no results,return.
-    taosArrayDestroy(s1);
-    taosArrayDestroy(s2);
-
     tscDebug("%p tag intersect does not generated qualified tables for join, free all sub SqlObj and quit", pParentSql);
     freeJoinSubqueryObj(pParentSql);
 
     // set no result command
     pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
-    (*pParentSql->fp)(pSql->param, pParentSql, 0);
-
+    (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
   } else {
     // proceed to for ts_comp query
     SSqlCmd* pSubCmd1 = &pParentSql->pSubs[0]->cmd;
@@ -824,7 +821,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
     // set no result command
     pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
-    (*pParentSql->fp)(pSql->param, pParentSql, 0);
+    (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
     return;
   }
 

From 4630ba5d037c50b35a658457538a359bc26f2de2 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Tue, 7 Jul 2020 14:16:30 +0800
Subject: [PATCH 48/87] TD-541

---
 src/tsdb/inc/tsdbMain.h     | 3 +--
 src/tsdb/src/tsdbRWHelper.c | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index d856650b0e..4cd2f45917 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -195,7 +195,6 @@ typedef struct {
 typedef struct {
   uint32_t len;
   uint32_t offset;
-  // uint32_t padding;
   uint32_t hasLast : 2;
   uint32_t numOfBlocks : 30;
   uint64_t uid;
@@ -224,7 +223,7 @@ typedef struct {
 
 typedef struct {
   int16_t colId;
-  int16_t len;
+  int32_t len;
   int32_t type : 8;
   int32_t offset : 24;
   int64_t sum;
diff --git a/src/tsdb/src/tsdbRWHelper.c b/src/tsdb/src/tsdbRWHelper.c
index 9e87a1f587..0fc94c07a8 100644
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
@@ -703,6 +703,7 @@ static int tsdbWriteBlockToFile(SRWHelper *pHelper, SFile *pFile, SDataCols *pDa
     }
 
     // Add checksum
+    ASSERT(pCompCol->len > 0);
     pCompCol->len += sizeof(TSCKSUM);
     taosCalcChecksumAppend(0, (uint8_t *)tptr, pCompCol->len);
 

From 12a5458eccf412cff4470f53233a45c46da8016a Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Tue, 7 Jul 2020 14:34:18 +0800
Subject: [PATCH 49/87] adjust load data interface for read

---
 src/tsdb/inc/tsdbMain.h     |  5 +++--
 src/tsdb/src/tsdbRWHelper.c | 17 +++++++++--------
 src/tsdb/src/tsdbRead.c     |  2 +-
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index 4cd2f45917..7d1a5a52de 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -437,8 +437,9 @@ int   tsdbLoadCompIdx(SRWHelper* pHelper, void* target);
 int   tsdbLoadCompInfo(SRWHelper* pHelper, void* target);
 int   tsdbLoadCompData(SRWHelper* phelper, SCompBlock* pcompblock, void* target);
 void  tsdbGetDataStatis(SRWHelper* pHelper, SDataStatis* pStatis, int numOfCols);
-int   tsdbLoadBlockDataCols(SRWHelper* pHelper, SCompBlock* pCompBlock, int16_t* colIds, int numOfColIds);
-int   tsdbLoadBlockData(SRWHelper* pHelper, SCompBlock* pCompBlock);
+int   tsdbLoadBlockDataCols(SRWHelper* pHelper, SCompBlock* pCompBlock, SCompInfo* pCompInfo, int16_t* colIds,
+                            int numOfColIds);
+int   tsdbLoadBlockData(SRWHelper* pHelper, SCompBlock* pCompBlock, SCompInfo* pCompInfo);
 
 // ------------------ tsdbMain.c
 #define REPO_ID(r) (r)->config.tsdbId
diff --git a/src/tsdb/src/tsdbRWHelper.c b/src/tsdb/src/tsdbRWHelper.c
index 0fc94c07a8..326da07a36 100644
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
@@ -318,7 +318,7 @@ int tsdbMoveLastBlockIfNeccessary(SRWHelper *pHelper) {
     ASSERT(pCompBlock->last);
 
     if (pCompBlock->numOfSubBlocks > 1) {
-      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, pIdx->numOfBlocks - 1)) < 0) return -1;
+      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, pIdx->numOfBlocks - 1), NULL) < 0) return -1;
       ASSERT(pHelper->pDataCols[0]->numOfRows > 0 && pHelper->pDataCols[0]->numOfRows < pCfg->minRowsPerFileBlock);
       if (tsdbWriteBlockToFile(pHelper, &(pHelper->files.nLastF), pHelper->pDataCols[0],
                                pHelper->pDataCols[0]->numOfRows, &compBlock, true, true) < 0)
@@ -577,11 +577,12 @@ void tsdbGetDataStatis(SRWHelper *pHelper, SDataStatis *pStatis, int numOfCols)
   }
 }
 
-int tsdbLoadBlockDataCols(SRWHelper *pHelper, SCompBlock *pCompBlock, int16_t *colIds, int numOfColIds) {
+int tsdbLoadBlockDataCols(SRWHelper *pHelper, SCompBlock *pCompBlock, SCompInfo *pCompInfo, int16_t *colIds, int numOfColIds) {
   ASSERT(pCompBlock->numOfSubBlocks >= 1);  // Must be super block
 
   int numOfSubBlocks = pCompBlock->numOfSubBlocks;
-  if (numOfSubBlocks > 1) pCompBlock = (SCompBlock *)POINTER_SHIFT(pHelper->pCompInfo, pCompBlock->offset);
+  if (numOfSubBlocks > 1)
+    pCompBlock = (SCompBlock *)POINTER_SHIFT((pCompInfo == NULL) ? pHelper->pCompInfo : pCompInfo, pCompBlock->offset);
 
   tdResetDataCols(pHelper->pDataCols[0]);
   if (tsdbLoadBlockDataColsImpl(pHelper, pCompBlock, pHelper->pDataCols[0], colIds, numOfColIds) < 0) goto _err;
@@ -598,10 +599,10 @@ _err:
   return -1;
 }
 
-int tsdbLoadBlockData(SRWHelper *pHelper, SCompBlock *pCompBlock) {
-
+int tsdbLoadBlockData(SRWHelper *pHelper, SCompBlock *pCompBlock, SCompInfo *pCompInfo) {
   int numOfSubBlock = pCompBlock->numOfSubBlocks;
-  if (numOfSubBlock > 1) pCompBlock = (SCompBlock *)POINTER_SHIFT(pHelper->pCompInfo, pCompBlock->offset);
+  if (numOfSubBlock > 1)
+    pCompBlock = (SCompBlock *)POINTER_SHIFT((pCompInfo == NULL) ? pHelper->pCompInfo : pCompInfo, pCompBlock->offset);
 
   tdResetDataCols(pHelper->pDataCols[0]);
   if (tsdbLoadBlockDataImpl(pHelper, pCompBlock, pHelper->pDataCols[0]) < 0) goto _err;
@@ -793,7 +794,7 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
       if (tsdbAddSubBlock(pHelper, &compBlock, blkIdx, rowsWritten) < 0) goto _err;
     } else {
       // Load
-      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, blkIdx)) < 0) goto _err;
+      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, blkIdx), NULL) < 0) goto _err;
       ASSERT(pHelper->pDataCols[0]->numOfRows <= blockAtIdx(pHelper, blkIdx)->numOfRows);
       // Merge
       if (tdMergeDataCols(pHelper->pDataCols[0], pDataCols, rowsWritten) < 0) goto _err;
@@ -849,7 +850,7 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
       if (tsdbAddSubBlock(pHelper, &compBlock, blkIdx, rowsWritten) < 0) goto _err;
     } else {  // Load-Merge-Write
       // Load
-      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, blkIdx)) < 0) goto _err;
+      if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, blkIdx), NULL) < 0) goto _err;
       if (blockAtIdx(pHelper, blkIdx)->last) pHelper->hasOldLastBlock = false;
 
       rowsWritten = rows3;
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 6a9c8e1ff6..7bd0639578 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -594,7 +594,7 @@ static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlo
 
   tdInitDataCols(pCheckInfo->pDataCols, tsdbGetTableSchema(pCheckInfo->pTableObj));
 
-  if (tsdbLoadBlockData(&(pQueryHandle->rhelper), pBlock) == 0) {
+  if (tsdbLoadBlockData(&(pQueryHandle->rhelper), pBlock, pCheckInfo->pCompInfo) == 0) {
     SDataBlockLoadInfo* pBlockLoadInfo = &pQueryHandle->dataBlockLoadInfo;
 
     pBlockLoadInfo->fileGroup = pQueryHandle->pFileGroup;

From 7c6671912864f25689d15724705758e6c33119e5 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Tue, 7 Jul 2020 14:42:27 +0800
Subject: [PATCH 50/87] add python test to cover "alter dnode"

[TD-868]
---
 tests/pytest/alter/alter_table_crash.py       |   1 +
 tests/pytest/client/client.py                 |   3 +
 tests/pytest/fulltest.sh                      |   4 +-
 tests/pytest/insert/writeDBNonStop.py         |   5 +-
 tests/pytest/query/filterAllIntTypes.py       |  44 ++++--
 tests/pytest/query/queryJoin.py               |   4 +-
 tests/pytest/query/queryMetaData.py           |  78 +++++++++--
 tests/pytest/query/queryMetaPerformace.py     | 130 ++++++++++++++----
 tests/pytest/query/select_last_crash.py       |   5 +-
 .../random-test-multi-threading-3.py          |   1 -
 tests/pytest/regressiontest.sh                |   4 +-
 tests/pytest/smoketest.sh                     |   8 +-
 tests/pytest/util/sql.py                      |   2 +-
 13 files changed, 215 insertions(+), 74 deletions(-)

diff --git a/tests/pytest/alter/alter_table_crash.py b/tests/pytest/alter/alter_table_crash.py
index aefe9ff26e..d1af022e35 100644
--- a/tests/pytest/alter/alter_table_crash.py
+++ b/tests/pytest/alter/alter_table_crash.py
@@ -78,5 +78,6 @@ class TDTestCase:
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
 
+
 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/client/client.py b/tests/pytest/client/client.py
index 21df7e6a86..9bb1887216 100644
--- a/tests/pytest/client/client.py
+++ b/tests/pytest/client/client.py
@@ -40,6 +40,9 @@ class TDTestCase:
         ret = tdSql.query('select server_status() as result')
         tdSql.checkData(0, 0, 1)
 
+        ret = tdSql.execute('alter dnode 127.0.0.1 debugFlag 135')
+        tdLog.info("alter dnode ret: %d" % ret)
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 066dda5d97..b98e5c3d39 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -1,7 +1,6 @@
 #!/bin/bash
 ulimit -c unlimited
 
-python3 ./test.py -f client/client.py
 python3 ./test.py -f insert/basic.py
 python3 ./test.py -f insert/int.py
 python3 ./test.py -f insert/float.py
@@ -151,3 +150,6 @@ python3 ./test.py -f stream/stream2.py
 
 #alter table
 python3 ./test.py -f alter/alter_table_crash.py
+
+# client
+python3 ./test.py -f client/client.py
diff --git a/tests/pytest/insert/writeDBNonStop.py b/tests/pytest/insert/writeDBNonStop.py
index c89853ffb6..bdc93f0469 100644
--- a/tests/pytest/insert/writeDBNonStop.py
+++ b/tests/pytest/insert/writeDBNonStop.py
@@ -67,7 +67,7 @@ class DBWriteNonStop:
                 self.cursor.execute(
                     "select first(ts), last(ts), min(speed), max(speed), avg(speed), count(*) from st")
                 data = self.cursor.fetchall()
-                end = datetime.now()                
+                end = datetime.now()
                 self.writeDataToCSVFile(data, (end - start).seconds)
             time.sleep(.001)
 
@@ -75,8 +75,9 @@ class DBWriteNonStop:
         self.cursor.close()
         self.conn.close()
 
+
 test = DBWriteNonStop()
 test.connectDB()
 test.createTable()
 test.insertData()
-test.closeConn()
\ No newline at end of file
+test.closeConn()
diff --git a/tests/pytest/query/filterAllIntTypes.py b/tests/pytest/query/filterAllIntTypes.py
index a2bab63c88..4d91168dae 100644
--- a/tests/pytest/query/filterAllIntTypes.py
+++ b/tests/pytest/query/filterAllIntTypes.py
@@ -89,17 +89,25 @@ class TDTestCase:
             tdSql.checkRows(101)
 
             # range for int type on column
-            tdSql.query("select * from st%s where num > 50 and num < 100" % curType)
-            tdSql.checkRows(49) 
+            tdSql.query(
+                "select * from st%s where num > 50 and num < 100" %
+                curType)
+            tdSql.checkRows(49)
 
-            tdSql.query("select * from st%s where num >= 50 and num < 100" % curType)
-            tdSql.checkRows(50) 
+            tdSql.query(
+                "select * from st%s where num >= 50 and num < 100" %
+                curType)
+            tdSql.checkRows(50)
 
-            tdSql.query("select * from st%s where num > 50 and num <= 100" % curType)
-            tdSql.checkRows(50) 
+            tdSql.query(
+                "select * from st%s where num > 50 and num <= 100" %
+                curType)
+            tdSql.checkRows(50)
 
-            tdSql.query("select * from st%s where num >= 50 and num <= 100" % curType)
-            tdSql.checkRows(51) 
+            tdSql.query(
+                "select * from st%s where num >= 50 and num <= 100" %
+                curType)
+            tdSql.checkRows(51)
 
             # > for int type on tag
             tdSql.query("select * from st%s where id > 5" % curType)
@@ -135,16 +143,22 @@ class TDTestCase:
 
             # range for int type on tag
             tdSql.query("select * from st%s where id > 5 and id < 7" % curType)
-            tdSql.checkRows(10) 
+            tdSql.checkRows(10)
 
-            tdSql.query("select * from st%s where id >= 5 and id < 7" % curType)
-            tdSql.checkRows(20) 
+            tdSql.query(
+                "select * from st%s where id >= 5 and id < 7" %
+                curType)
+            tdSql.checkRows(20)
 
-            tdSql.query("select * from st%s where id > 5 and id <= 7" % curType)
-            tdSql.checkRows(20) 
+            tdSql.query(
+                "select * from st%s where id > 5 and id <= 7" %
+                curType)
+            tdSql.checkRows(20)
 
-            tdSql.query("select * from st%s where id >= 5 and id <= 7" % curType)
-            tdSql.checkRows(30) 
+            tdSql.query(
+                "select * from st%s where id >= 5 and id <= 7" %
+                curType)
+            tdSql.checkRows(30)
 
             print(
                 "======= Verify filter for %s type finished =========" %
diff --git a/tests/pytest/query/queryJoin.py b/tests/pytest/query/queryJoin.py
index 6d135e1006..6ea240a334 100644
--- a/tests/pytest/query/queryJoin.py
+++ b/tests/pytest/query/queryJoin.py
@@ -77,7 +77,7 @@ class TDTestCase:
         # join queries
         tdSql.query(
             "select * from stb_p, stb_t where stb_p.ts=stb_t.ts and stb_p.id = stb_t.id")
-        tdSql.checkRows(6)        
+        tdSql.checkRows(6)
 
         tdSql.error(
             "select ts, pressure, temperature, id, dscrption from stb_p, stb_t where stb_p.ts=stb_t.ts and stb_p.id = stb_t.id")
@@ -108,7 +108,7 @@ class TDTestCase:
 
         tdSql.query("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_t.id, stb_p.dscrption, stb_p.pressure from stb_p, stb_t where stb_p.ts=stb_t.ts and stb_p.id = stb_t.id")
         tdSql.checkRows(6)
-        
+
         tdSql.query("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_t.id, stb_p.dscrption, stb_p.pressure from stb_p, stb_t where stb_p.ts=stb_t.ts and stb_p.id = stb_t.id")
         tdSql.checkRows(6)
 
diff --git a/tests/pytest/query/queryMetaData.py b/tests/pytest/query/queryMetaData.py
index 7b95e4a81c..67df20cb9a 100755
--- a/tests/pytest/query/queryMetaData.py
+++ b/tests/pytest/query/queryMetaData.py
@@ -55,9 +55,9 @@ class MetadataQuery:
 
     def createTablesAndInsertData(self, threadID):
         cursor = self.connectDB()
-        cursor.execute("use test")        
+        cursor.execute("use test")
 
-        tablesPerThread = int (self.tables / self.numOfTherads)
+        tablesPerThread = int(self.tables / self.numOfTherads)
         base = threadID * tablesPerThread
         for i in range(tablesPerThread):
             cursor.execute(
@@ -68,24 +68,72 @@ class MetadataQuery:
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d',
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d',
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d')''' %
-                (base + i + 1, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100))
-            
+                (base + i + 1, (base + i) %
+                 100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100))
+
             cursor.execute(
                 "insert into t%d values(%d, 1) (%d, 2) (%d, 3) (%d, 4) (%d, 5)" %
                 (base + i + 1, self.ts + 1, self.ts + 2, self.ts + 3, self.ts + 4, self.ts + 5))
-        cursor.close()        
+        cursor.close()
 
     def queryData(self, query):
         cursor = self.connectDB()
         cursor.execute("use test")
 
-        print("================= query tag data =================")    
+        print("================= query tag data =================")
         startTime = datetime.now()
         cursor.execute(query)
         cursor.fetchall()
@@ -107,15 +155,15 @@ if __name__ == '__main__':
     print(
         "================= Create %d tables and insert %d records into each table =================" %
         (t.tables, t.records))
-    startTime = datetime.now()    
+    startTime = datetime.now()
     threads = []
     for i in range(t.numOfTherads):
         thread = threading.Thread(
             target=t.createTablesAndInsertData, args=(i,))
         thread.start()
         threads.append(thread)
-    
-    for th in threads:        
+
+    for th in threads:
         th.join()
 
     endTime = datetime.now()
diff --git a/tests/pytest/query/queryMetaPerformace.py b/tests/pytest/query/queryMetaPerformace.py
index 0570311b08..8ab7105c9d 100644
--- a/tests/pytest/query/queryMetaPerformace.py
+++ b/tests/pytest/query/queryMetaPerformace.py
@@ -19,6 +19,7 @@ import time
 from datetime import datetime
 import numpy as np
 
+
 class MyThread(threading.Thread):
 
     def __init__(self, func, args=()):
@@ -35,17 +36,23 @@ class MyThread(threading.Thread):
         except Exception:
             return None
 
+
 class MetadataQuery:
     def initConnection(self):
         self.tables = 100
         self.records = 10
-        self.numOfTherads =5 
+        self.numOfTherads = 5
         self.ts = 1537146000000
         self.host = "127.0.0.1"
         self.user = "root"
         self.password = "taosdata"
         self.config = "/etc/taos"
-        self.conn = taos.connect( self.host, self.user, self.password, self.config)
+        self.conn = taos.connect(
+            self.host,
+            self.user,
+            self.password,
+            self.config)
+
     def connectDB(self):
         return self.conn.cursor()
 
@@ -69,7 +76,7 @@ class MetadataQuery:
         cursor.execute("use test")
         base = threadID * self.tables
 
-        tablesPerThread = int (self.tables / self.numOfTherads)
+        tablesPerThread = int(self.tables / self.numOfTherads)
         for i in range(tablesPerThread):
             cursor.execute(
                 '''create table t%d using meters tags(
@@ -79,20 +86,69 @@ class MetadataQuery:
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d',
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d',
                 %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d')''' %
-                (base + i + 1, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100, 
-                (base + i) %100, (base + i) %10000, (base + i) %1000000, (base + i) %100000000, (base + i) %100 * 1.1, (base + i) %100 * 2.3, (base + i) %2, (base + i) %100, (base + i) %100))
+                (base + i + 1, (base + i) %
+                 100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    100, (base + i) %
+                    10000, (base + i) %
+                    1000000, (base + i) %
+                    100000000, (base + i) %
+                    100 * 1.1, (base + i) %
+                    100 * 2.3, (base + i) %
+                    2, (base + i) %
+                    100, (base + i) %
+                    100))
             for j in range(self.records):
                 cursor.execute(
                     "insert into t%d values(%d, %d)" %
                     (base + i + 1, self.ts + j, j))
         cursor.close()
-    def queryWithTagId(self, threadId, tagId, queryNum): 
-        print("---------thread%d start-----------"%threadId)
+
+    def queryWithTagId(self, threadId, tagId, queryNum):
+        print("---------thread%d start-----------" % threadId)
         query = '''select tgcol1, tgcol2, tgcol3, tgcol4, tgcol5, tgcol6, tgcol7, tgcol8, tgcol9,
                 tgcol10, tgcol11, tgcol12, tgcol13, tgcol14, tgcol15, tgcol16, tgcol17, tgcol18,
                 tgcol19, tgcol20, tgcol21, tgcol22, tgcol23, tgcol24, tgcol25, tgcol26, tgcol27,
@@ -103,18 +159,19 @@ class MetadataQuery:
         latancy = []
         cursor = self.connectDB()
         cursor.execute("use test")
-        for i in range(queryNum): 
+        for i in range(queryNum):
             startTime = time.time()
-            cursor.execute(query.format(id = tagId, condition = i))
+            cursor.execute(query.format(id=tagId, condition=i))
             cursor.fetchall()
-            latancy.append((time.time() - startTime)) 
-        print("---------thread%d end-----------"%threadId)
+            latancy.append((time.time() - startTime))
+        print("---------thread%d end-----------" % threadId)
         return latancy
+
     def queryData(self, query):
         cursor = self.connectDB()
         cursor.execute("use test")
 
-        print("================= query tag data =================")    
+        print("================= query tag data =================")
         startTime = datetime.now()
         cursor.execute(query)
         cursor.fetchall()
@@ -124,7 +181,7 @@ class MetadataQuery:
             (endTime - startTime).seconds)
 
         cursor.close()
-        #self.conn.close()
+        # self.conn.close()
 
 
 if __name__ == '__main__':
@@ -132,18 +189,33 @@ if __name__ == '__main__':
     t = MetadataQuery()
     t.initConnection()
 
-    latancys = [] 
-    threads =  []
+    latancys = []
+    threads = []
     tagId = 1
-    queryNum = 1000 
+    queryNum = 1000
     for i in range(t.numOfTherads):
-        thread = MyThread(t.queryWithTagId, args = (i, tagId, queryNum))
-        threads.append(thread) 
+        thread = MyThread(t.queryWithTagId, args=(i, tagId, queryNum))
+        threads.append(thread)
         thread.start()
-    for i in range(t.numOfTherads):  
+    for i in range(t.numOfTherads):
         threads[i].join()
-        latancys.extend(threads[i].get_result()) 
-    print("Total query: %d"%(queryNum * t.numOfTherads))    
-    print("statistic(s): mean= %f, P50 = %f, P75 = %f, P95 = %f, P99 = %f"
-            %(sum(latancys)/(queryNum * t.numOfTherads), np.percentile(latancys, 50), np.percentile(latancys, 75), np.percentile(latancys, 95), np.percentile(latancys, 99)))  
-
+        latancys.extend(threads[i].get_result())
+    print("Total query: %d" % (queryNum * t.numOfTherads))
+    print(
+        "statistic(s): mean= %f, P50 = %f, P75 = %f, P95 = %f, P99 = %f" %
+        (sum(latancys) /
+         (
+            queryNum *
+            t.numOfTherads),
+            np.percentile(
+            latancys,
+            50),
+            np.percentile(
+            latancys,
+            75),
+            np.percentile(
+            latancys,
+            95),
+            np.percentile(
+            latancys,
+            99)))
diff --git a/tests/pytest/query/select_last_crash.py b/tests/pytest/query/select_last_crash.py
index 9aeb122f82..02cf286dbd 100644
--- a/tests/pytest/query/select_last_crash.py
+++ b/tests/pytest/query/select_last_crash.py
@@ -23,7 +23,6 @@ class TDTestCase:
         tdLog.debug("start to execute %s" % __file__)
         tdSql.init(conn.cursor())
 
-        
         self.rowNum = 5000
         self.ts = 1537146000000
 
@@ -36,7 +35,9 @@ class TDTestCase:
             "create table t1 using st tags('dev_001')")
 
         for i in range(self.rowNum):
-            tdSql.execute("insert into t1 values(%d, 'taosdata%d', %d)" % (self.ts + i, i + 1, i + 1))
+            tdSql.execute(
+                "insert into t1 values(%d, 'taosdata%d', %d)" %
+                (self.ts + i, i + 1, i + 1))
 
         tdSql.query("select last(*) from st")
         tdSql.checkRows(1)
diff --git a/tests/pytest/random-test/random-test-multi-threading-3.py b/tests/pytest/random-test/random-test-multi-threading-3.py
index 7079a5c118..a8e2c26ae5 100644
--- a/tests/pytest/random-test/random-test-multi-threading-3.py
+++ b/tests/pytest/random-test/random-test-multi-threading-3.py
@@ -330,7 +330,6 @@ class Test (Thread):
                     self.q.put(-1)
                     tdLog.exit("second thread failed, first thread exit too")
 
-
         elif (self.threadId == 2):
             while True:
                 self.dbEvent.wait()
diff --git a/tests/pytest/regressiontest.sh b/tests/pytest/regressiontest.sh
index eada5f67f7..cf53f74083 100755
--- a/tests/pytest/regressiontest.sh
+++ b/tests/pytest/regressiontest.sh
@@ -1,7 +1,6 @@
 #!/bin/bash
 ulimit -c unlimited
 
-python3 ./test.py -f client/client.py
 python3 ./test.py -f insert/basic.py
 python3 ./test.py -f insert/int.py
 python3 ./test.py -f insert/float.py
@@ -146,4 +145,5 @@ python3 ./test.py -f stream/stream2.py
 #alter table
 python3 ./test.py -f alter/alter_table_crash.py
 
-
+# client
+python3 ./test.py -f client/client.py
diff --git a/tests/pytest/smoketest.sh b/tests/pytest/smoketest.sh
index 6b21912dd5..7c14b673e5 100755
--- a/tests/pytest/smoketest.sh
+++ b/tests/pytest/smoketest.sh
@@ -1,10 +1,6 @@
 #!/bin/bash
 ulimit -c unlimited
 
-# client
-python3 ./test.py $1 -f client/client.py
-python3 ./test.py $1 -s && sleep 1
-
 # insert
 python3 ./test.py $1 -f insert/basic.py
 python3 ./test.py $1 -s && sleep 1
@@ -35,3 +31,7 @@ python3 ./test.py $1 -s && sleep 1
 python3 ./test.py $1 -f query/filter.py
 python3 ./test.py $1 -s && sleep 1
 
+# client
+python3 ./test.py $1 -f client/client.py
+python3 ./test.py $1 -s && sleep 1
+
diff --git a/tests/pytest/util/sql.py b/tests/pytest/util/sql.py
index dc0366b214..d6644df3ac 100644
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
@@ -198,7 +198,7 @@ class TDSql:
                 "%s failed: sql:%s, affectedRows:%d != expect:%d" %
                 (callerFilename, self.sql, self.affectedRows, expectAffectedRows))
         tdLog.info("sql:%s, affectedRows:%d == expect:%d" %
-                   (self.sql, self.affectedRows, expectAffectedRows))    
+                   (self.sql, self.affectedRows, expectAffectedRows))
 
 
 tdSql = TDSql()

From c7f1851ff79f9a8dbeb9765feb3eda4d49723579 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Tue, 7 Jul 2020 14:44:06 +0800
Subject: [PATCH 51/87] fix more

---
 src/tsdb/src/tsdbRead.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 7bd0639578..9ca78533ba 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -592,7 +592,10 @@ static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlo
     pCheckInfo->pDataCols = tdNewDataCols(pMeta->maxRowBytes, pMeta->maxCols, pRepo->config.maxRowsPerFileBlock);
   }
 
-  tdInitDataCols(pCheckInfo->pDataCols, tsdbGetTableSchema(pCheckInfo->pTableObj));
+  STSchema* pSchema = tsdbGetTableSchema(pCheckInfo->pTableObj);
+  tdInitDataCols(pCheckInfo->pDataCols, pSchema);
+  tdInitDataCols(pQueryHandle->rhelper.pDataCols[0], pSchema);
+  tdInitDataCols(pQueryHandle->rhelper.pDataCols[1], pSchema);
 
   if (tsdbLoadBlockData(&(pQueryHandle->rhelper), pBlock, pCheckInfo->pCompInfo) == 0) {
     SDataBlockLoadInfo* pBlockLoadInfo = &pQueryHandle->dataBlockLoadInfo;

From 3dc3a58c59c116c411f900c4d89ca41c1ba85292 Mon Sep 17 00:00:00 2001
From: Ping Xiao <xiaopingcs@outlook.com>
Date: Tue, 7 Jul 2020 14:24:05 +0800
Subject: [PATCH 52/87] TD-867: Remove unsupported python test cases

---
 tests/pytest/query/filterCombo.py       |  3 +--
 tests/pytest/query/queryNormal.py       | 21 ++++++++-------------
 tests/pytest/query/select_last_crash.py |  6 +-----
 tests/pytest/regressiontest.sh          |  3 +++
 4 files changed, 13 insertions(+), 20 deletions(-)

diff --git a/tests/pytest/query/filterCombo.py b/tests/pytest/query/filterCombo.py
index f72b913c92..e769addb52 100644
--- a/tests/pytest/query/filterCombo.py
+++ b/tests/pytest/query/filterCombo.py
@@ -52,8 +52,7 @@ class TDTestCase:
 
         # illegal condition
         tdSql.error(
-            "select * from db.st where ts != '2020-05-13 10:00:00.002' OR tagtype < 2")
-        tdSql.error("select * from db.st where tagtype <> 1 OR tagtype < 2")
+            "select * from db.st where ts != '2020-05-13 10:00:00.002' OR tagtype < 2")        
 
     def stop(self):
         tdSql.close()
diff --git a/tests/pytest/query/queryNormal.py b/tests/pytest/query/queryNormal.py
index 814c627d89..712a56d2d7 100644
--- a/tests/pytest/query/queryNormal.py
+++ b/tests/pytest/query/queryNormal.py
@@ -36,18 +36,17 @@ class TDTestCase:
             "insert into tb2 using stb1 tags(2,'tb2', '表2') values ('2020-04-18 15:00:02.000', 3, 2.1), ('2020-04-18 15:00:03.000', 4, 2.2)")
 
         # inner join --- bug
-        tdSql.query("select * from tb1 a, tb2 b where a.ts = b.ts")
-        tdSql.checkRows(1)
+        tdSql.error("select * from tb1 a, tb2 b where a.ts = b.ts")        
 
         # join 3 tables -- bug exists
-        tdSql.query("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_p.id, stb_p.dscrption, stb_p.pressure,stb_v.velocity from stb_p, stb_t, stb_v where stb_p.ts=stb_t.ts and stb_p.ts=stb_v.ts and stb_p.id = stb_t.id")
+        tdSql.error("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_p.id, stb_p.dscrption, stb_p.pressure,stb_v.velocity from stb_p, stb_t, stb_v where stb_p.ts=stb_t.ts and stb_p.ts=stb_v.ts and stb_p.id = stb_t.id")
 
         # query show stable
         tdSql.query("show stables")
         tdSql.checkRows(1)
 
         # query show tables
-        tdSql.query("show table")
+        tdSql.query("show tables")
         tdSql.checkRows(2)
 
         # query count
@@ -71,16 +70,13 @@ class TDTestCase:
         tdSql.checkRows(2)
 
         # query first ... as
-        tdSql.query("select first(*) as begin from stb1")
-        tdSql.checkData(0, 1, 1)
+        tdSql.error("select first(*) as begin from stb1")        
 
         # query last ... as
-        tdSql.query("select last(*) as end from stb1")
-        tdSql.checkData(0, 1, 4)
+        tdSql.error("select last(*) as end from stb1")
 
         # query last_row ... as
-        tdSql.query("select last_row(*) as end from stb1")
-        tdSql.checkData(0, 1, 4)
+        tdSql.error("select last_row(*) as end from stb1")        
 
         # query group .. by
         tdSql.query("select sum(c1), t2 from stb1 group by t2")
@@ -95,8 +91,7 @@ class TDTestCase:
         tdSql.checkRows(1)
 
         # query ... alias for table ---- bug
-        tdSql.query("select t.ts from tb1 t")
-        tdSql.checkRows(2)
+        tdSql.error("select t.ts from tb1 t")        
 
         # query ... tbname
         tdSql.query("select tbname from stb1")
@@ -104,7 +99,7 @@ class TDTestCase:
 
         # query ... tbname count  ---- bug
         tdSql.query("select count(tbname) from stb1")
-        tdSql.checkRows(2)
+        tdSql.checkData(0, 0, 2)
 
         # query ... select database ---- bug
         tdSql.query("SELECT database()")
diff --git a/tests/pytest/query/select_last_crash.py b/tests/pytest/query/select_last_crash.py
index 9aeb122f82..e49002716e 100644
--- a/tests/pytest/query/select_last_crash.py
+++ b/tests/pytest/query/select_last_crash.py
@@ -40,11 +40,7 @@ class TDTestCase:
 
         tdSql.query("select last(*) from st")
         tdSql.checkRows(1)
-
-        print(
-            "======= Verify filter for %s type finished =========" %
-            curType)
-
+        
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/pytest/regressiontest.sh b/tests/pytest/regressiontest.sh
index eada5f67f7..4b748b4f40 100755
--- a/tests/pytest/regressiontest.sh
+++ b/tests/pytest/regressiontest.sh
@@ -138,6 +138,9 @@ python3 ./test.py -f query/filterOtherTypes.py
 python3 ./test.py -f query/queryError.py
 python3 ./test.py -f query/querySort.py
 python3 ./test.py -f query/queryJoin.py
+python3 ./test.py -f query/filterCombo.py
+python3 ./test.py -f query/queryNormal.py
+python3 ./test.py -f query/select_last_crash.py
 
 #stream
 python3 ./test.py -f stream/stream1.py

From 8292c490ef17e701d5aad146515aa5e194edeb11 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 14:52:47 +0800
Subject: [PATCH 53/87] [TD-853] still need report status when unsynced

---
 src/mnode/src/mnodeDnode.c  |  2 +-
 src/mnode/src/mnodeVgroup.c |  7 +++++++
 src/vnode/src/vnodeMain.c   | 14 ++++++++++----
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c
index c1b8256a06..4707616ba8 100644
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -334,7 +334,7 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) {
   if (pStatus->dnodeId == 0) {
     mDebug("dnode:%d %s, first access", pDnode->dnodeId, pDnode->dnodeEp);
   } else {
-    //mDebug("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess);
+    mTrace("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess);
   }
  
   int32_t openVnodes = htons(pStatus->openVnodes);
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index b763c62640..3a9076335a 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -171,6 +171,12 @@ static int32_t mnodeVgroupActionUpdate(SSdbOper *pOper) {
 
   mnodeVgroupUpdateIdPool(pVgroup);
 
+  // reset vgid status on vgroup changed
+  mDebug("vgId:%d, reset sync status to unsynced", pVgroup->vgId);
+  for (int32_t v = 0; v < pVgroup->numOfVnodes; ++v) {
+    pVgroup->vnodeGid[v].role = TAOS_SYNC_ROLE_UNSYNCED;
+  }
+
   mnodeDecVgroupRef(pVgroup);
 
   mDebug("vgId:%d, is updated, numOfVnode:%d", pVgroup->vgId, pVgroup->numOfVnodes);
@@ -302,6 +308,7 @@ void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVl
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
     if (pVgid->pDnode == pDnode) {
+      mTrace("dnode:%d, receive status from dnode, vgId:%d status is %d", pVgroup->vgId, pDnode->dnodeId, pVgid->role);
       pVgid->role = pVload->role;
       if (pVload->role == TAOS_SYNC_ROLE_MASTER) {
         pVgroup->inUse = i;
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 0ee4ef4837..1c96ba543c 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -415,13 +415,19 @@ void *vnodeGetWal(void *pVnode) {
 }
 
 static void vnodeBuildVloadMsg(SVnodeObj *pVnode, SDMStatusMsg *pStatus) {
+  int64_t totalStorage = 0;
+  int64_t compStorage = 0;
+  int64_t pointsWritten = 0;
+
   if (pVnode->status != TAOS_VN_STATUS_READY) return;
   if (pStatus->openVnodes >= TSDB_MAX_VNODES) return;
-  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) return;
-  if (pVnode->tsdb == NULL) return;
 
-  int64_t totalStorage, compStorage, pointsWritten = 0;
-  tsdbReportStat(pVnode->tsdb, &pointsWritten, &totalStorage, &compStorage);
+  // still need report status when unsynced
+  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) {
+  } else if (pVnode->tsdb == NULL) {
+  } else {
+    tsdbReportStat(pVnode->tsdb, &pointsWritten, &totalStorage, &compStorage);
+  }
 
   SVnodeLoad *pLoad = &pStatus->load[pStatus->openVnodes++];
   pLoad->vgId = htonl(pVnode->vgId);

From ef58297a87980f8f58b36cec3d0ea537c80377fd Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 15:21:58 +0800
Subject: [PATCH 54/87] [td-225] refactor qhandle mgmt

---
 src/vnode/src/vnodeRead.c | 101 +++++++++++++++++++++-----------------
 1 file changed, 55 insertions(+), 46 deletions(-)

diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 9938b34741..57dbf4dede 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -94,10 +94,10 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
   }
 
   int32_t code = TSDB_CODE_SUCCESS;
-  qinfo_t pQInfo = NULL;
   void**  handle = NULL;
 
   if (contLen != 0) {
+    qinfo_t pQInfo = NULL;
     code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, pVnode, NULL, &pQInfo);
 
     SQueryTableRsp *pRsp = (SQueryTableRsp *) rpcMallocCont(sizeof(SQueryTableRsp));
@@ -116,19 +116,19 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
 
         qKillQuery(pQInfo);
         qKillQuery(pQInfo);
-        pQInfo = NULL;
       } else {
         assert(*handle == pQInfo);
         pRsp->qhandle = htobe64((uint64_t) (handle));
       }
 
+      pQInfo = NULL;
       if (handle != NULL && vnodeNotifyCurrentQhandle(pReadMsg->rpcMsg.handle, handle, pVnode->vgId) != TSDB_CODE_SUCCESS) {
-        vError("vgId:%d, QInfo:%p, query discarded since link is broken, %p", pVnode->vgId, pQInfo, pReadMsg->rpcMsg.handle);
+        vError("vgId:%d, QInfo:%p, query discarded since link is broken, %p", pVnode->vgId, *handle, pReadMsg->rpcMsg.handle);
         pRsp->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
 
         // NOTE: there two refcount, needs to kill twice
         // query has not been put into qhandle pool, kill it directly.
-        qKillQuery(pQInfo);
+        qKillQuery(*handle);
         qReleaseQInfo(pVnode->qMgmt, (void**) &handle, true);
         return pRsp->code;
       }
@@ -139,16 +139,18 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
     vDebug("vgId:%d, QInfo:%p, dnode query msg disposed", vgId, pQInfo);
   } else {
     assert(pCont != NULL);
-    pQInfo = *(void**)(pCont);
-    handle = pCont;
-    code = TSDB_CODE_VND_ACTION_IN_PROGRESS;
-
-    vDebug("vgId:%d, QInfo:%p, dnode query msg in progress", pVnode->vgId, pQInfo);
+    handle = qAcquireQInfo(pVnode->qMgmt, (void**) pCont);
+    if (handle == NULL) {
+      vWarn("QInfo:%p invalid qhandle in continuing exec query, conn:%p", *(void**) pCont, pReadMsg->rpcMsg.handle);
+      code = TSDB_CODE_QRY_INVALID_QHANDLE;
+    } else {
+      vDebug("vgId:%d, QInfo:%p, dnode query msg in progress", pVnode->vgId, *(void**) pCont);
+      code = TSDB_CODE_VND_ACTION_IN_PROGRESS;
+    }
   }
 
-  if (pQInfo != NULL) {
-    qTableQuery(pQInfo); // do execute query
-    assert(handle != NULL);
+  if (handle != NULL) {
+    qTableQuery(*handle); // do execute query
     qReleaseQInfo(pVnode->qMgmt, (void**) &handle, false);
   }
 
@@ -160,57 +162,64 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
   SRspRet *pRet = &pReadMsg->rspRet;
 
   SRetrieveTableMsg *pRetrieve = pCont;
-  void **pQInfo = (void*) htobe64(pRetrieve->qhandle);
+  pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
   pRetrieve->free = htons(pRetrieve->free);
 
-  vDebug("vgId:%d, QInfo:%p, retrieve msg is disposed", pVnode->vgId, *pQInfo);
+  vDebug("vgId:%d, QInfo:%p, retrieve msg is disposed", pVnode->vgId, *(void**) pRetrieve->qhandle);
 
   memset(pRet, 0, sizeof(SRspRet));
-  int32_t ret = 0;
 
-  void** handle = qAcquireQInfo(pVnode->qMgmt, pQInfo);
-  if (handle == NULL || handle != pQInfo) {
-    ret = TSDB_CODE_QRY_INVALID_QHANDLE;
+  int32_t code = TSDB_CODE_SUCCESS;
+  void** handle = qAcquireQInfo(pVnode->qMgmt, (void**) pRetrieve->qhandle);
+  if (handle == NULL || handle != (void**) pRetrieve->qhandle) {
+    code = TSDB_CODE_QRY_INVALID_QHANDLE;
+    vDebug("vgId:%d, invalid qhandle in fetch result, QInfo:%p", pVnode->vgId, *(void**) pRetrieve->qhandle);
+
+    pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
+    pRet->len = sizeof(SRetrieveTableRsp);
+
+    memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
+    SRetrieveTableRsp* pRsp = pRet->rsp;
+    pRsp->numOfRows = 0;
+    pRsp->completed = true;
+    pRsp->useconds  = 0;
+
+    return code;
   }
 
   if (pRetrieve->free == 1) {
-    if (ret == TSDB_CODE_SUCCESS) {
-      vDebug("vgId:%d, QInfo:%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, pQInfo);
-      qReleaseQInfo(pVnode->qMgmt, (void**) &handle, true);
+    vDebug("vgId:%d, QInfo:%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, *handle);
+    qReleaseQInfo(pVnode->qMgmt, (void**) &handle, true);
 
-      pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
-      pRet->len = sizeof(SRetrieveTableRsp);
+    pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
+    pRet->len = sizeof(SRetrieveTableRsp);
 
-      memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
-      SRetrieveTableRsp* pRsp = pRet->rsp;
-      pRsp->numOfRows = 0;
-      pRsp->completed = true;
-      pRsp->useconds  = 0;
-    } else { // todo handle error
-      qReleaseQInfo(pVnode->qMgmt, (void**) &handle, true);
-    }
-    return ret;
+    memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
+    SRetrieveTableRsp* pRsp = pRet->rsp;
+    pRsp->numOfRows = 0;
+    pRsp->completed = true;
+    pRsp->useconds  = 0;
+
+    return code;
   }
 
-  int32_t code = qRetrieveQueryResultInfo(*pQInfo);
-  if (code != TSDB_CODE_SUCCESS || ret != TSDB_CODE_SUCCESS) {
-    //TODO
+  bool freeHandle = true;
+  code = qRetrieveQueryResultInfo(*handle);
+  if (code != TSDB_CODE_SUCCESS) {
+    //TODO handle malloc failure
     pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
     memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
-
-  } else {
-    // todo check code and handle error in build result set
-    code = qDumpRetrieveResult(*pQInfo, (SRetrieveTableRsp **)&pRet->rsp, &pRet->len);
-
-    if (qHasMoreResultsToRetrieve(*handle)) {
-      dnodePutItemIntoReadQueue(pVnode, handle);
-      pRet->qhandle = handle;
-      code = TSDB_CODE_SUCCESS;
-    } else { // no further execution invoked, release the ref to vnode
-      qReleaseQInfo(pVnode->qMgmt, (void**) &handle, true);
+  } else { // if failed to dump result, free qhandle immediately
+    if ((code = qDumpRetrieveResult(*handle, (SRetrieveTableRsp **)&pRet->rsp, &pRet->len)) == TSDB_CODE_SUCCESS) {
+      if (qHasMoreResultsToRetrieve(*handle)) {
+        dnodePutItemIntoReadQueue(pVnode, handle);
+        pRet->qhandle = handle;
+        freeHandle = false;
+      }
     }
   }
 
+  qReleaseQInfo(pVnode->qMgmt, (void**) &handle, freeHandle);
   return code;
 }
 

From fbf91959d11d417130e4d1d7cb15120b7ff5c0d3 Mon Sep 17 00:00:00 2001
From: dengyihao <luomoxyz@126.com>
Date: Tue, 7 Jul 2020 15:30:30 +0800
Subject: [PATCH 55/87] bugfix

---
 src/vnode/src/vnodeRead.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 8665aa01cb..fa65a56c81 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -137,6 +137,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SReadMsg *pReadMsg) {
     }
     if (handle != NULL) {
       dnodePutItemIntoReadQueue(pVnode, handle);
+      qReleaseQInfo(pVnode->qMgmt, (void**) &handle, false);
     }
     vDebug("vgId:%d, QInfo:%p, dnode query msg disposed", vgId, pQInfo);
   } else {

From fe91d3d978f5e267f0b4b71f39d430603565db67 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 15:35:46 +0800
Subject: [PATCH 56/87] [td-225] fix compiler error

---
 src/tsdb/src/tsdbRead.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index b79fc10c63..6dccb4194e 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -1479,7 +1479,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
   size_t numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   assert(numOfTables > 0);
 
-  SDataBlockInfo blockInfo = {0};
+  SDataBlockInfo blockInfo = {{0}, 0};
   if (pQueryHandle->type == TSDB_QUERY_TYPE_EXTERNAL) {
     pQueryHandle->type = TSDB_QUERY_TYPE_ALL;
     pQueryHandle->order = TSDB_ORDER_DESC;

From 9d652bed82cb9c259694371fd515c97527016f3c Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 15:58:26 +0800
Subject: [PATCH 57/87] [td-225] refactor code and fix error sim script.

---
 src/query/inc/qast.h                 |  13 +--
 src/query/src/qast.c                 | 140 ++++-----------------------
 src/tsdb/src/tsdbRead.c              |   7 +-
 src/{query => util}/inc/tlosertree.h |   0
 src/{query => util}/src/tlosertree.c |   6 +-
 tests/script/general/parser/join.sim |  19 ++--
 6 files changed, 41 insertions(+), 144 deletions(-)
 rename src/{query => util}/inc/tlosertree.h (100%)
 rename src/{query => util}/src/tlosertree.c (97%)

diff --git a/src/query/inc/qast.h b/src/query/inc/qast.h
index 410b2ac9d2..918604f8c9 100644
--- a/src/query/inc/qast.h
+++ b/src/query/inc/qast.h
@@ -16,16 +16,16 @@
 #ifndef TDENGINE_TAST_H
 #define TDENGINE_TAST_H
 
-#include <tbuffer.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <tskiplist.h>
 #include "os.h"
 
 #include "taosmsg.h"
 #include "taosdef.h"
+#include "tskiplist.h"
+#include "tbuffer.h"
 #include "tvariant.h"
 
 struct tExprNode;
@@ -75,10 +75,6 @@ typedef struct tExprNode {
   };
 } tExprNode;
 
-void tSQLBinaryExprFromString(tExprNode **pExpr, SSchema *pSchema, int32_t numOfCols, char *src, int32_t len);
-
-void tSQLBinaryExprToString(tExprNode *pExpr, char *dst, int32_t *len);
-
 void tExprTreeDestroy(tExprNode **pExprs, void (*fp)(void*));
 
 void tExprTreeTraverse(tExprNode *pExpr, SSkipList *pSkipList, SArray *result, SExprTraverseSupp *param);
@@ -86,12 +82,9 @@ void tExprTreeTraverse(tExprNode *pExpr, SSkipList *pSkipList, SArray *result, S
 void tExprTreeCalcTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput, void *param, int32_t order,
                                 char *(*cb)(void *, const char*, int32_t));
 
-// todo refactor: remove it
-void tSQLBinaryExprTrv(tExprNode *pExprs, SArray* res);
-
 uint8_t getBinaryExprOptr(SSQLToken *pToken);
 
-void       tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *));
+void tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *));
 void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
 
 tExprNode* exprTreeFromBinary(const void* data, size_t size);
diff --git a/src/query/src/qast.c b/src/query/src/qast.c
index 721cd8ae5a..c7868a0ccb 100644
--- a/src/query/src/qast.c
+++ b/src/query/src/qast.c
@@ -327,104 +327,6 @@ static tExprNode *createSyntaxTree(SSchema *pSchema, int32_t numOfCols, char *st
   }
 }
 
-void tSQLBinaryExprFromString(tExprNode **pExpr, SSchema *pSchema, int32_t numOfCols, char *src, int32_t len) {
-  *pExpr = NULL;
-  
-  if (len <= 0 || src == NULL || pSchema == NULL || numOfCols <= 0) {
-    return;
-  }
-
-  int32_t pos = 0;
-  
-  *pExpr = createSyntaxTree(pSchema, numOfCols, src, &pos);
-  if (*pExpr != NULL) {
-    assert((*pExpr)->nodeType == TSQL_NODE_EXPR);
-  }
-}
-
-int32_t tSQLBinaryExprToStringImpl(tExprNode *pNode, char *dst, uint8_t type) {
-  int32_t len = 0;
-  if (type == TSQL_NODE_EXPR) {
-    *dst = '(';
-    tSQLBinaryExprToString(pNode, dst + 1, &len);
-    len += 2;
-    *(dst + len - 1) = ')';
-  } else if (type == TSQL_NODE_COL) {
-    len = sprintf(dst, "%s", pNode->pSchema->name);
-  } else {
-    len = tVariantToString(pNode->pVal, dst);
-  }
-  return len;
-}
-
-// TODO REFACTOR WITH SQL PARSER
-static char *tSQLOptrToString(uint8_t optr, char *dst) {
-  switch (optr) {
-    case TSDB_RELATION_LESS: {
-      *dst = '<';
-      dst += 1;
-      break;
-    }
-    case TSDB_RELATION_LESS_EQUAL: {
-      *dst = '<';
-      *(dst + 1) = '=';
-      dst += 2;
-      break;
-    }
-    case TSDB_RELATION_EQUAL: {
-      *dst = '=';
-      dst += 1;
-      break;
-    }
-    case TSDB_RELATION_GREATER: {
-      *dst = '>';
-      dst += 1;
-      break;
-    }
-    case TSDB_RELATION_GREATER_EQUAL: {
-      *dst = '>';
-      *(dst + 1) = '=';
-      dst += 2;
-      break;
-    }
-    case TSDB_RELATION_NOT_EQUAL: {
-      *dst = '<';
-      *(dst + 1) = '>';
-      dst += 2;
-      break;
-    }
-    case TSDB_RELATION_OR: {
-      memcpy(dst, "or", 2);
-      dst += 2;
-      break;
-    }
-    case TSDB_RELATION_AND: {
-      memcpy(dst, "and", 3);
-      dst += 3;
-      break;
-    }
-    default:;
-  }
-  return dst;
-}
-
-void tSQLBinaryExprToString(tExprNode *pExpr, char *dst, int32_t *len) {
-  if (pExpr == NULL) {
-    *dst = 0;
-    *len = 0;
-    return;
-  }
-
-  int32_t lhs = tSQLBinaryExprToStringImpl(pExpr->_node.pLeft, dst, pExpr->_node.pLeft->nodeType);
-  dst += lhs;
-  *len = lhs;
-
-  char *start = tSQLOptrToString(pExpr->_node.optr, dst);
-  *len += (start - dst);
-
-  *len += tSQLBinaryExprToStringImpl(pExpr->_node.pRight, start, pExpr->_node.pRight->nodeType);
-}
-
 static void UNUSED_FUNC destroySyntaxTree(tExprNode *pNode) { tExprNodeDestroy(pNode, NULL); }
 
 void tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *)) {
@@ -976,27 +878,27 @@ void tExprTreeCalcTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput,
   free(pRightOutput);
 }
 
-void tSQLBinaryExprTrv(tExprNode *pExprs, SArray* res) {
-  if (pExprs == NULL) {
-    return;
-  }
-
-  tExprNode *pLeft = pExprs->_node.pLeft;
-  tExprNode *pRight = pExprs->_node.pRight;
-
-  // recursive traverse left child branch
-  if (pLeft->nodeType == TSQL_NODE_EXPR) {
-    tSQLBinaryExprTrv(pLeft, res);
-  } else if (pLeft->nodeType == TSQL_NODE_COL) {
-    taosArrayPush(res, &pLeft->pSchema->colId);
-  }
-
-  if (pRight->nodeType == TSQL_NODE_EXPR) {
-    tSQLBinaryExprTrv(pRight, res);
-  } else if (pRight->nodeType == TSQL_NODE_COL) {
-    taosArrayPush(res, &pRight->pSchema->colId);
-  }
-}
+//void tSQLBinaryExprTrv(tExprNode *pExprs, SArray* res) {
+//  if (pExprs == NULL) {
+//    return;
+//  }
+//
+//  tExprNode *pLeft = pExprs->_node.pLeft;
+//  tExprNode *pRight = pExprs->_node.pRight;
+//
+//  // recursive traverse left child branch
+//  if (pLeft->nodeType == TSQL_NODE_EXPR) {
+//    tSQLBinaryExprTrv(pLeft, res);
+//  } else if (pLeft->nodeType == TSQL_NODE_COL) {
+//    taosArrayPush(res, &pLeft->pSchema->colId);
+//  }
+//
+//  if (pRight->nodeType == TSQL_NODE_EXPR) {
+//    tSQLBinaryExprTrv(pRight, res);
+//  } else if (pRight->nodeType == TSQL_NODE_COL) {
+//    taosArrayPush(res, &pRight->pSchema->colId);
+//  }
+//}
 
 static void exprTreeToBinaryImpl(SBufferWriter* bw, tExprNode* expr) {
   tbufWriteUint8(bw, expr->nodeType);
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 6dccb4194e..a552efc2b1 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -22,7 +22,7 @@
 #include "exception.h"
 
 #include "../../../query/inc/qast.h"  // todo move to common module
-#include "../../../query/inc/tlosertree.h"  // todo move to util module
+#include "tlosertree.h"
 #include "tsdb.h"
 #include "tsdbMain.h"
 
@@ -577,6 +577,8 @@ static SArray* getDefaultLoadColumns(STsdbQueryHandle* pQueryHandle, bool loadTS
 
 static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock, STableCheckInfo* pCheckInfo) {
   STsdbRepo *pRepo = pQueryHandle->pTsdb;
+
+  // TODO refactor
   SCompData* data = calloc(1, sizeof(SCompData) + sizeof(SCompCol) * pBlock->numOfCols);
 
   data->numOfCols = pBlock->numOfCols;
@@ -606,8 +608,9 @@ static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlo
   }
 
   SDataCols* pCols = pQueryHandle->rhelper.pDataCols[0];
-  assert(pCols->numOfRows != 0);
+  assert(pCols->numOfRows != 0 && pCols->numOfRows <= pBlock->numOfRows);
 
+  pBlock->numOfRows = pCols->numOfRows;
   taosArrayDestroy(sa);
   tfree(data);
 
diff --git a/src/query/inc/tlosertree.h b/src/util/inc/tlosertree.h
similarity index 100%
rename from src/query/inc/tlosertree.h
rename to src/util/inc/tlosertree.h
diff --git a/src/query/src/tlosertree.c b/src/util/src/tlosertree.c
similarity index 97%
rename from src/query/src/tlosertree.c
rename to src/util/src/tlosertree.c
index 5d471bb927..fa7e4fc340 100644
--- a/src/query/src/tlosertree.c
+++ b/src/util/src/tlosertree.c
@@ -13,10 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "tlosertree.h"
 #include "os.h"
 #include "taosmsg.h"
-#include "tlosertree.h"
-#include "queryLog.h"
+#include "tulog.h"
 
 // set initial value for loser tree
 void tLoserTreeInit(SLoserTreeInfo* pTree) {
@@ -45,7 +45,7 @@ uint32_t tLoserTreeCreate(SLoserTreeInfo** pTree, int32_t numOfEntries, void* pa
 
   *pTree = (SLoserTreeInfo*)calloc(1, sizeof(SLoserTreeInfo) + sizeof(SLoserTreeNode) * totalEntries);
   if ((*pTree) == NULL) {
-    qError("allocate memory for loser-tree failed. reason:%s", strerror(errno));
+    uError("allocate memory for loser-tree failed. reason:%s", strerror(errno));
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
   }
 
diff --git a/tests/script/general/parser/join.sim b/tests/script/general/parser/join.sim
index 69932e1e1c..8d686366b7 100644
--- a/tests/script/general/parser/join.sim
+++ b/tests/script/general/parser/join.sim
@@ -448,15 +448,14 @@ sql insert into um2 using m2 tags(9) values(1000001, 10)(2000000, 20);
 sql_error select count(*) from m1,m2 where m1.a=m2.a and m1.ts=m2.ts;
 
 #empty table join test, add for no result join test
-create database ux1;
-use ux1;
-create table m1(ts timestamp, k int) tags(a binary(12), b int);
-create table tm0 using m1 tags('abc', 1);
-
-create table m2(ts timestamp, k int) tags(a int, b binary(12));
-create table tm2 using m2 tags(2, 'abc');
-select count(*) from tm0, tm2 where tm0.ts=tm2.ts;
-select count(*) from m1, m2 where m1.ts=m2.ts and m1.b=m2.a
-drop database ux1;
+sql create database ux1;
+sql use ux1;
+sql create table m1(ts timestamp, k int) tags(a binary(12), b int);
+sql create table tm0 using m1 tags('abc', 1);
+sql create table m2(ts timestamp, k int) tags(a int, b binary(12));
+sql create table tm2 using m2 tags(2, 'abc');
+sql select count(*) from tm0, tm2 where tm0.ts=tm2.ts;
+sql select count(*) from m1, m2 where m1.ts=m2.ts and m1.b=m2.a
+sql drop database ux1;
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From a9ec970d12437c00c17fdb47b9c2c3aa92ffe685 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 16:39:01 +0800
Subject: [PATCH 58/87] [td-225] refactor code.

---
 src/client/inc/tschemautil.h         |  2 --
 src/client/src/tscFunctionImpl.c     |  2 +-
 src/client/src/tscSQLParser.c        | 12 +++++-----
 src/client/src/tscSchemaUtil.c       | 22 ------------------
 src/client/src/tscSubquery.c         |  6 ++---
 src/client/src/tscUtil.c             | 10 ++++----
 src/common/inc/tname.h               |  3 +++
 src/{query => common}/inc/tvariant.h |  0
 src/common/src/tname.c               | 23 +++++++++++++++++++
 src/{query => common}/src/tvariant.c |  0
 src/query/src/qExecutor.c            |  6 ++---
 src/query/src/qast.c                 | 24 ++++++++++----------
 src/tsdb/src/tsdbMeta.c              |  5 ----
 src/tsdb/src/tsdbRead.c              | 34 +++++++++++++++-------------
 14 files changed, 74 insertions(+), 75 deletions(-)
 rename src/{query => common}/inc/tvariant.h (100%)
 rename src/{query => common}/src/tvariant.c (100%)

diff --git a/src/client/inc/tschemautil.h b/src/client/inc/tschemautil.h
index 99ffa4e766..67942ad42a 100644
--- a/src/client/inc/tschemautil.h
+++ b/src/client/inc/tschemautil.h
@@ -110,8 +110,6 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
 //todo tags value as well as the table id structure needs refactor
 char *tsGetTagsValue(STableMeta *pMeta);
 
-void extractTableNameFromToken(SSQLToken *pToken, SSQLToken* pTable);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index afdad05b43..0917a3b19c 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -14,7 +14,6 @@
  */
 
 #include "os.h"
-#include "qast.h"
 #include "qextbuffer.h"
 #include "qfill.h"
 #include "qhistogram.h"
@@ -23,6 +22,7 @@
 #include "qtsbuf.h"
 #include "taosdef.h"
 #include "taosmsg.h"
+#include "qast.h"
 #include "tscLog.h"
 #include "tscSubquery.h"
 #include "tscompression.h"
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index ea88e4a935..ec4f77b13e 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -18,19 +18,19 @@
 #define _DEFAULT_SOURCE
 
 #include "os.h"
-#include "qast.h"
 #include "taos.h"
 #include "taosmsg.h"
-#include "tstoken.h"
-#include "tstrbuild.h"
-#include "ttime.h"
+#include "qast.h"
+#include "tcompare.h"
+#include "tname.h"
 #include "tscLog.h"
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
+#include "tstoken.h"
+#include "tstrbuild.h"
+#include "ttime.h"
 #include "ttokendef.h"
-#include "tname.h"
-#include "tcompare.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
 
diff --git a/src/client/src/tscSchemaUtil.c b/src/client/src/tscSchemaUtil.c
index da06e3e5e2..934a562387 100644
--- a/src/client/src/tscSchemaUtil.c
+++ b/src/client/src/tscSchemaUtil.c
@@ -215,25 +215,3 @@ __attribute__ ((unused)) static FORCE_INLINE size_t copy(char* dst, const char*
   return len;
 }
 
-/*
- * tablePrefix.columnName
- * extract table name and save it in pTable, with only column name in pToken
- */
-void extractTableNameFromToken(SSQLToken* pToken, SSQLToken* pTable) {
-  const char sep = TS_PATH_DELIMITER[0];
-
-  if (pToken == pTable || pToken == NULL || pTable == NULL) {
-    return;
-  }
-
-  char* r = strnchr(pToken->z, sep, pToken->n, false);
-
-  if (r != NULL) {  // record the table name token
-    pTable->n = r - pToken->z;
-    pTable->z = pToken->z;
-
-    r += 1;
-    pToken->n -= (r - pToken->z);
-    pToken->z = r;
-  }
-}
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 47f2ba855e..b5b659de0c 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -14,12 +14,12 @@
  */
 #include "os.h"
 
-#include "tscSubquery.h"
+#include "qtsbuf.h"
 #include "qast.h"
 #include "tcompare.h"
-#include "tschemautil.h"
-#include "qtsbuf.h"
 #include "tscLog.h"
+#include "tscSubquery.h"
+#include "tschemautil.h"
 #include "tsclient.h"
 
 typedef struct SInsertSupporter {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 791073f7a8..ed9822eea9 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -14,21 +14,21 @@
  */
 
 #include "os.h"
-#include "qast.h"
+#include "hash.h"
+#include "tscUtil.h"
 #include "taosmsg.h"
+#include "qast.h"
 #include "tcache.h"
 #include "tkey.h"
 #include "tmd5.h"
-#include "tscProfile.h"
 #include "tscLocalMerge.h"
+#include "tscLog.h"
+#include "tscProfile.h"
 #include "tscSubquery.h"
 #include "tschemautil.h"
 #include "tsclient.h"
 #include "ttimer.h"
 #include "ttokendef.h"
-#include "tscLog.h"
-#include "tscUtil.h"
-#include "hash.h"
 
 static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
 static void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool removeFromCache);
diff --git a/src/common/inc/tname.h b/src/common/inc/tname.h
index 25f78cde7e..2263a5dae1 100644
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -3,6 +3,7 @@
 
 #include "os.h"
 #include "taosmsg.h"
+#include "tstoken.h"
 
 typedef struct SDataStatis {
   int16_t colId;
@@ -23,6 +24,8 @@ void extractTableName(const char *tableId, char *name);
 
 char* extractDBName(const char *tableId, char *name);
 
+void extractTableNameFromToken(SSQLToken *pToken, SSQLToken* pTable);
+
 SSchema tGetTableNameColumnSchema();
 
 bool tscValidateTableNameLength(size_t len);
diff --git a/src/query/inc/tvariant.h b/src/common/inc/tvariant.h
similarity index 100%
rename from src/query/inc/tvariant.h
rename to src/common/inc/tvariant.h
diff --git a/src/common/src/tname.c b/src/common/src/tname.c
index c8910a7867..dd0107bf38 100644
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -105,3 +105,26 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, in
   }
   return start;
 }
+
+/*
+ * tablePrefix.columnName
+ * extract table name and save it in pTable, with only column name in pToken
+ */
+void extractTableNameFromToken(SSQLToken* pToken, SSQLToken* pTable) {
+  const char sep = TS_PATH_DELIMITER[0];
+
+  if (pToken == pTable || pToken == NULL || pTable == NULL) {
+    return;
+  }
+
+  char* r = strnchr(pToken->z, sep, pToken->n, false);
+
+  if (r != NULL) {  // record the table name token
+    pTable->n = r - pToken->z;
+    pTable->z = pToken->z;
+
+    r += 1;
+    pToken->n -= (r - pToken->z);
+    pToken->z = r;
+  }
+}
diff --git a/src/query/src/tvariant.c b/src/common/src/tvariant.c
similarity index 100%
rename from src/query/src/tvariant.c
rename to src/common/src/tvariant.c
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 110cd23370..5b14c4f0f4 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -18,18 +18,18 @@
 #include "qfill.h"
 #include "taosmsg.h"
 
+#include "exception.h"
 #include "hash.h"
 #include "qExecutor.h"
 #include "qUtil.h"
-#include "qast.h"
 #include "qresultBuf.h"
 #include "query.h"
 #include "queryLog.h"
+#include "qast.h"
+#include "tfile.h"
 #include "tlosertree.h"
-#include "exception.h"
 #include "tscompression.h"
 #include "ttime.h"
-#include "tfile.h"
 
 /**
  * check if the primary column is load by default, otherwise, the program will
diff --git a/src/query/src/qast.c b/src/query/src/qast.c
index c7868a0ccb..ffd339f111 100644
--- a/src/query/src/qast.c
+++ b/src/query/src/qast.c
@@ -13,25 +13,26 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+
 #include "os.h"
-#include "tulog.h"
-#include "tutil.h"
-#include "tbuffer.h"
+
+#include "tname.h"
 #include "qast.h"
-#include "tcompare.h"
+#include "tsdb.h"
+#include "exception.h"
 #include "qsqlparser.h"
 #include "qsyntaxtreefunction.h"
 #include "taosdef.h"
 #include "taosmsg.h"
+#include "tarray.h"
+#include "tbuffer.h"
+#include "tcompare.h"
+#include "tskiplist.h"
 #include "tsqlfunction.h"
 #include "tstoken.h"
 #include "ttokendef.h"
-#include "tschemautil.h"
-#include "tarray.h"
-#include "tskiplist.h"
-#include "queryLog.h"
-#include "tsdbMain.h"
-#include "exception.h"
+#include "tulog.h"
+#include "tutil.h"
 
 /*
  *
@@ -675,8 +676,7 @@ static void tQueryIndexlessColumn(SSkipList* pSkipList, tQueryInfo* pQueryInfo,
     SSkipListNode *pNode = tSkipListIterGet(iter);
     char *         pData = SL_GET_NODE_DATA(pNode);
 
-    // todo refactor:
-    tstr *name = (*(STable **)pData)->name;
+    tstr *name = (tstr*) tsdbGetTableName(*(void**) pData);
     // todo speed up by using hash
     if (pQueryInfo->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
       if (pQueryInfo->optr == TSDB_RELATION_IN) {
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 9ebd63ba7e..84c1c8e7d1 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -192,11 +192,6 @@ char *tsdbGetTableName(void* pTable) {
   }
 }
 
-STableId tsdbGetTableId(void *pTable) {
-  assert(pTable);
-  return ((STable*)pTable)->tableId;
-}
-
 STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg) {
   if (pMsg == NULL) return NULL;
 
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 39176f339b..a4e0151f89 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -122,7 +122,7 @@ static void changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
 static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SCompBlock* pBlock,
                                    SArray* sa);
 static int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order);
-static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int maxRowsToRead, TSKEY* skey, TSKEY* ekey,
+static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int maxRowsToRead, STimeWindow* win,
                                  STsdbQueryHandle* pQueryHandle);
 
 static void tsdbInitDataBlockLoadInfo(SDataBlockLoadInfo* pBlockLoadInfo) {
@@ -412,8 +412,7 @@ static bool hasMoreDataInCache(STsdbQueryHandle* pHandle) {
   
   int32_t step = ASCENDING_TRAVERSE(pHandle->order)? 1:-1;
   STimeWindow* win = &pHandle->cur.win;
-  pHandle->cur.rows = tsdbReadRowsFromCache(pCheckInfo, pHandle->window.ekey,
-                                    pHandle->outputCapacity, &win->skey, &win->ekey, pHandle);  // todo refactor API
+  pHandle->cur.rows = tsdbReadRowsFromCache(pCheckInfo, pHandle->window.ekey, pHandle->outputCapacity, win, pHandle);
   
   // update the last key value
   pCheckInfo->lastKey = win->ekey + step;
@@ -643,7 +642,7 @@ static void handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock*
       int32_t step = ASCENDING_TRAVERSE(pQueryHandle->order) ? 1 : -1;
 
       cur->rows = tsdbReadRowsFromCache(pCheckInfo, binfo.window.skey - step,
-                                        pQueryHandle->outputCapacity, &cur->win.skey, &cur->win.ekey, pQueryHandle);
+                                        pQueryHandle->outputCapacity, &cur->win, pQueryHandle);
       pQueryHandle->realNumOfRows = cur->rows;
 
       // update the last key value
@@ -1244,7 +1243,6 @@ static int32_t dataBlockOrderCompar(const void* pLeft, const void* pRight, void*
   //    assert(pLeftBlockInfoEx->compBlock->offset != pRightBlockInfoEx->compBlock->offset);
   if (pLeftBlockInfoEx->compBlock->offset == pRightBlockInfoEx->compBlock->offset &&
       pLeftBlockInfoEx->compBlock->last == pRightBlockInfoEx->compBlock->last) {
-    // todo add more information
     tsdbError("error in header file, two block with same offset:%" PRId64, (int64_t)pLeftBlockInfoEx->compBlock->offset);
   }
 
@@ -1701,11 +1699,11 @@ static void changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle) {
   pQueryHandle->window = (STimeWindow) {info.lastKey, TSKEY_INITIAL_VAL};
 }
 
-static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int maxRowsToRead, TSKEY* skey, TSKEY* ekey,
+static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int maxRowsToRead, STimeWindow* win,
                                  STsdbQueryHandle* pQueryHandle) {
   int     numOfRows = 0;
   int32_t numOfCols = taosArrayGetSize(pQueryHandle->pColumns);
-  *skey = TSKEY_INITIAL_VAL;
+  win->skey = TSKEY_INITIAL_VAL;
 
   int64_t st = taosGetTimestampUs();
   STsdbMeta* pMeta = tsdbGetMeta(pQueryHandle->pTsdb);
@@ -1725,11 +1723,11 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
       break;
     }
 
-    if (*skey == INT64_MIN) {
-      *skey = key;
+    if (win->skey == INT64_MIN) {
+      win->skey = key;
     }
 
-    *ekey = key;
+    win->ekey = key;
     copyOneRowFromMem(pQueryHandle, maxRowsToRead, numOfRows, row, pMeta, numOfCols, pTable);
 
     if (++numOfRows >= maxRowsToRead) {
@@ -1978,9 +1976,9 @@ int32_t tableGroupComparFn(const void *p1, const void *p2, const void *param) {
     int32_t type = 0;
     int32_t bytes = 0;
     
-    if (colIndex == TSDB_TBNAME_COLUMN_INDEX) {  // todo refactor extract method , to queryExecutor to generate tags values
-      f1 = (char*) pTable1->name;
-      f2 = (char*) pTable2->name;
+    if (colIndex == TSDB_TBNAME_COLUMN_INDEX) {
+      f1 = (char*) TABLE_NAME(pTable1);
+      f2 = (char*) TABLE_NAME(pTable2);
       type = TSDB_DATA_TYPE_BINARY;
       bytes = tGetTableNameColumnSchema().bytes;
     } else {
@@ -2089,13 +2087,17 @@ bool indexedNodeFilterFp(const void* pNode, void* param) {
   char*  val = NULL;
 
   if (pInfo->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
-    val = (char*) pTable->name;
+    val = (char*) TABLE_NAME(pTable);
   } else {
     val = tdGetKVRowValOfCol(pTable->tagVal, pInfo->sch.colId);
   }
   
-  //todo :the val is possible to be null, so check it out carefully
-  int32_t ret = pInfo->compare(val, pInfo->q);
+  int32_t ret = 0;
+  if (val == NULL) { //the val is possible to be null, so check it out carefully
+    ret = -1; // val is missing in table tags value pairs
+  } else {
+    ret = pInfo->compare(val, pInfo->q);
+  }
 
   switch (pInfo->optr) {
     case TSDB_RELATION_EQUAL: {

From d016001bb8ab3dd92fc31d4fe54b6c753aaca7f1 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 16:55:45 +0800
Subject: [PATCH 59/87] [td-225] fix compiler error.

---
 src/query/src/qExecutor.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 5b14c4f0f4..41f2cbe9bd 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -49,6 +49,8 @@
 #define GET_COL_DATA_POS(query, index, step) ((query)->pos + (index) * (step))
 #define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
 
+#define SDATA_BLOCK_INITIALIZER (SDataBlockInfo) {{0}, 0}
+
 /* get the qinfo struct address from the query struct address */
 #define GET_COLUMN_BYTES(query, colidx) \
   ((query)->colList[(query)->pSelectExpr[colidx].base.colInfo.colIndex].bytes)
@@ -2233,8 +2235,8 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
          pQuery->order.order);
 
   TsdbQueryHandleT pQueryHandle = IS_MASTER_SCAN(pRuntimeEnv)? pRuntimeEnv->pQueryHandle : pRuntimeEnv->pSecQueryHandle;
-  SDataBlockInfo blockInfo = {0};
 
+  SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER;
   while (tsdbNextDataBlock(pQueryHandle)) {
     summary->totalBlocks += 1;
     if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
@@ -3949,7 +3951,7 @@ void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
   STableQueryInfo* pTableQueryInfo = pQuery->current;
   TsdbQueryHandleT pQueryHandle = pRuntimeEnv->pQueryHandle;
 
-  SDataBlockInfo blockInfo = {0};
+  SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER;
   while (tsdbNextDataBlock(pQueryHandle)) {
     if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
       return;
@@ -3992,7 +3994,7 @@ static bool skipTimeInterval(SQueryRuntimeEnv *pRuntimeEnv, TSKEY* start) {
   SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
   STableQueryInfo *pTableQueryInfo = pQuery->current;
 
-  SDataBlockInfo blockInfo = {0};
+  SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER;
   while (tsdbNextDataBlock(pRuntimeEnv->pQueryHandle)) {
     tsdbRetrieveDataBlockInfo(pRuntimeEnv->pQueryHandle, &blockInfo);
 
@@ -4258,7 +4260,7 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
   int64_t st = taosGetTimestampMs();
 
   TsdbQueryHandleT pQueryHandle = IS_MASTER_SCAN(pRuntimeEnv)? pRuntimeEnv->pQueryHandle : pRuntimeEnv->pSecQueryHandle;
-  SDataBlockInfo blockInfo = {0};
+  SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER;
 
   while (tsdbNextDataBlock(pQueryHandle)) {
     summary->totalBlocks += 1;

From e35d89a4b47a2a315d463b32e381e0416735e5af Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 09:56:20 +0000
Subject: [PATCH 60/87] [TD-860] add processed count for sdb sync

---
 src/mnode/inc/mnodeSdb.h |  1 +
 src/mnode/src/mnodeSdb.c | 54 ++++++++++++++++++++--------------------
 2 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/src/mnode/inc/mnodeSdb.h b/src/mnode/inc/mnodeSdb.h
index ca2fffe24c..eec6d45e23 100644
--- a/src/mnode/inc/mnodeSdb.h
+++ b/src/mnode/inc/mnodeSdb.h
@@ -53,6 +53,7 @@ typedef struct {
   void *   rowData;
   int32_t  rowSize;
   int32_t  retCode; // for callback in sdb queue
+  int32_t  processedCount; // for sync fwd callback
   int32_t  (*cb)(struct SMnodeMsg *pMsg, int32_t code);
   struct SMnodeMsg *pMsg;
 } SSdbOper;
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 0f657bdde8..4aed820958 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -247,20 +247,22 @@ static void sdbConfirmForward(void *ahandle, void *param, int32_t code) {
   assert(param);
   SSdbOper * pOper = param;
   SMnodeMsg *pMsg = pOper->pMsg;
+  if (code <= 0) pOper->retCode = code;
 
-  if (code > 0) {
+  int32_t processedCount = atomic_add_fetch_32(&pOper->processedCount, 1);
+  if (processedCount <= 1) {
     if (pMsg != NULL) {
-      sdbDebug("app:%p:%p, waiting for slave to confirm this operation", pMsg->rpcMsg.ahandle, pMsg);
+      sdbDebug("app:%p:%p, waiting for confirm this operation, count:%d", pMsg->rpcMsg.ahandle, pMsg, processedCount);
     }
     return;
   }
 
   if (pMsg != NULL) {
-    sdbDebug("app:%p:%p, is confirmed and will do callback func, code:%s", pMsg->rpcMsg.ahandle, pMsg, tstrerror(code));
+    sdbDebug("app:%p:%p, is confirmed and will do callback func", pMsg->rpcMsg.ahandle, pMsg);
   }
 
   if (pOper->cb != NULL) {
-    code = (*pOper->cb)(pMsg, code);
+    code = (*pOper->cb)(pMsg, pOper->retCode);
   }
 
   dnodeSendRpcMnodeWriteRsp(pMsg, code);
@@ -543,31 +545,34 @@ static int sdbWrite(void *param, void *data, int type) {
     pthread_mutex_unlock(&tsSdbObj.mutex);
     return code;
   }
-  
-  // forward to peers, even it is WAL/FWD, it shall be called to update version in sync 
-  int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
-  pthread_mutex_unlock(&tsSdbObj.mutex);
 
-  if (syncCode < 0) {
-    sdbDebug("table:%s, failed to forward request, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
-             tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-    return syncCode;
-  } else if (syncCode > 0) {
-    sdbDebug("table:%s, forward request is sent, syncCode:%d action:%s record:%s version:%" PRId64, pTable->tableName,
-             syncCode, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-  } else {
-  }
+  pthread_mutex_unlock(&tsSdbObj.mutex);
 
   // from app, oper is created
   if (pOper != NULL) {
-    sdbDebug("table:%s, record from app is disposed, action:%s record:%s version:%" PRId64, pTable->tableName,
-             sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    // forward to peers
+    int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
+    if (syncCode <= 0) atomic_add_fetch_32(&pOper->processedCount, 1);
+
+    if (syncCode < 0) {
+      sdbError("table:%s, failed to forward request, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
+               tstrerror(syncCode), sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    } else if (syncCode > 0) {
+      sdbDebug("table:%s, forward request is sent, action:%s record:%s version:%" PRId64, pTable->tableName,
+               sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    } else {
+      sdbTrace("table:%s, no need to send fwd request, action:%s record:%s version:%" PRId64, pTable->tableName,
+               sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+    }
     return syncCode;
-  } else {
-    sdbDebug("table:%s, record from wal/fwd is disposed, action:%s record:%s version:%" PRId64, pTable->tableName,
-             sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
   }
 
+  sdbDebug("table:%s, record from wal/fwd is disposed, action:%s record:%s version:%" PRId64, pTable->tableName,
+           sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version);
+
+  // even it is WAL/FWD, it shall be called to update version in sync
+  syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
+
   // from wal or forward msg, oper not created, should add into hash
   if (action == SDB_ACTION_INSERT) {
     SSdbOper oper = {.rowSize = pHead->len, .rowData = pHead->cont, .table = pTable};
@@ -972,11 +977,6 @@ static void *sdbWorkerFp(void *param) {
 
       if (type == TAOS_QTYPE_RPC) {
         pOper = (SSdbOper *)item;
-        if (pOper == NULL) {
-          taosFreeQitem(item);
-          continue;
-        }
-
         sdbDecRef(pOper->table, pOper->pObj);
         sdbConfirmForward(NULL, pOper, pOper->retCode);
       } else if (type == TAOS_QTYPE_FWD) {

From 4f13c53acfc8c10afc84ea00344fdae4e79453fa Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 10:36:57 +0000
Subject: [PATCH 61/87] [TD-860] ret code for sdb

---
 src/mnode/src/mnodeSdb.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 4aed820958..9f46a77483 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -262,10 +262,10 @@ static void sdbConfirmForward(void *ahandle, void *param, int32_t code) {
   }
 
   if (pOper->cb != NULL) {
-    code = (*pOper->cb)(pMsg, pOper->retCode);
+    pOper->retCode = (*pOper->cb)(pMsg, pOper->retCode);
   }
 
-  dnodeSendRpcMnodeWriteRsp(pMsg, code);
+  dnodeSendRpcMnodeWriteRsp(pMsg, pOper->retCode);
   taosFreeQitem(pOper);
 }
 
@@ -552,7 +552,7 @@ static int sdbWrite(void *param, void *data, int type) {
   if (pOper != NULL) {
     // forward to peers
     int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
-    if (syncCode <= 0) atomic_add_fetch_32(&pOper->processedCount, 1);
+    if (syncCode > 0) pOper->processedCount = 0;
 
     if (syncCode < 0) {
       sdbError("table:%s, failed to forward request, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,
@@ -953,6 +953,7 @@ static void *sdbWorkerFp(void *param) {
       taosGetQitem(tsSdbWriteQall, &type, &item);
       if (type == TAOS_QTYPE_RPC) {
         pOper = (SSdbOper *)item;
+        pOper->processedCount = 1;
         pHead = (void *)pOper + sizeof(SSdbOper) + SDB_SYNC_HACK;
         if (pOper->pMsg != NULL) {
           sdbDebug("app:%p:%p, table:%s record:%p:%s version:%" PRIu64 ", will be processed in sdb queue",
@@ -965,7 +966,7 @@ static void *sdbWorkerFp(void *param) {
       }
 
       int32_t code = sdbWrite(pOper, pHead, type);
-      if (pOper) pOper->retCode = code;
+      if (pOper && code <= 0) pOper->retCode = code;
     }
 
     walFsync(tsSdbObj.wal);

From bb34d8352067cd54389d66becde5ba82fc11034e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 7 Jul 2020 18:53:25 +0800
Subject: [PATCH 62/87] [td-225] fix compiler error.

---
 src/query/tests/astTest.cpp | 83 ++++++++++++++++++-------------------
 1 file changed, 41 insertions(+), 42 deletions(-)

diff --git a/src/query/tests/astTest.cpp b/src/query/tests/astTest.cpp
index 15eb780021..df27087216 100644
--- a/src/query/tests/astTest.cpp
+++ b/src/query/tests/astTest.cpp
@@ -1,11 +1,10 @@
 #include <gtest/gtest.h>
-#include <qast.h>
 #include <sys/time.h>
 #include <cassert>
 #include <iostream>
 
-#include "qast.h"
 #include "taosmsg.h"
+#include "qast.h"
 #include "tsdb.h"
 #include "tskiplist.h"
 
@@ -24,8 +23,6 @@ static void initSchema_binary(SSchema *schema, int32_t numOfCols);
 static SSkipList *createSkipList(SSchema *pSchema, int32_t numOfTags);
 static SSkipList *createSkipList_binary(SSchema *pSchema, int32_t numOfTags);
 
-static void testQueryStr(SSchema *schema, int32_t numOfCols, char *sql, SSkipList *pSkipList, ResultObj *expectedVal);
-
 static void dropMeter(SSkipList *pSkipList);
 
 static void Right2LeftTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
@@ -239,44 +236,45 @@ static void initSchema(SSchema *schema, int32_t numOfCols) {
 //  return pSkipList;
 //}
 
-static void testQueryStr(SSchema *schema, int32_t numOfCols, char *sql, SSkipList *pSkipList, ResultObj *pResult) {
-  tExprNode *pExpr = NULL;
-  tSQLBinaryExprFromString(&pExpr, schema, numOfCols, sql, strlen(sql));
-
-  char    str[512] = {0};
-  int32_t len = 0;
-  if (pExpr == NULL) {
-    printf("-----error in parse syntax:%s\n\n", sql);
-    assert(pResult == NULL);
-    return;
-  }
-
-  tSQLBinaryExprToString(pExpr, str, &len);
-  printf("expr is: %s\n", str);
-
-  SArray *result = NULL;
-  //  tExprTreeTraverse(pExpr, pSkipList, result, SSkipListNodeFilterCallback, &result);
-  //  printf("the result is:%lld\n", result.num);
-  //
-  //  bool findResult = false;
-  //  for (int32_t i = 0; i < result.num; ++i) {
-  //    STabObj *pm = (STabObj *)result.pRes[i];
-  //    printf("meterid:%s,\t", pm->meterId);
-  //
-  //    for (int32_t j = 0; j < pResult->numOfResult; ++j) {
-  //      if (strcmp(pm->meterId, pResult->resultName[j]) == 0) {
-  //        findResult = true;
-  //        break;
-  //      }
-  //    }
-  //    assert(findResult == true);
-  //    findResult = false;
-  //  }
-
-  printf("\n\n");
-  tExprTreeDestroy(&pExpr, NULL);
-}
+//static void testQueryStr(SSchema *schema, int32_t numOfCols, char *sql, SSkipList *pSkipList, ResultObj *pResult) {
+//  tExprNode *pExpr = NULL;
+//  tSQLBinaryExprFromString(&pExpr, schema, numOfCols, sql, strlen(sql));
+//
+//  char    str[512] = {0};
+//  int32_t len = 0;
+//  if (pExpr == NULL) {
+//    printf("-----error in parse syntax:%s\n\n", sql);
+//    assert(pResult == NULL);
+//    return;
+//  }
+//
+//  tSQLBinaryExprToString(pExpr, str, &len);
+//  printf("expr is: %s\n", str);
+//
+//  SArray *result = NULL;
+//  //  tExprTreeTraverse(pExpr, pSkipList, result, SSkipListNodeFilterCallback, &result);
+//  //  printf("the result is:%lld\n", result.num);
+//  //
+//  //  bool findResult = false;
+//  //  for (int32_t i = 0; i < result.num; ++i) {
+//  //    STabObj *pm = (STabObj *)result.pRes[i];
+//  //    printf("meterid:%s,\t", pm->meterId);
+//  //
+//  //    for (int32_t j = 0; j < pResult->numOfResult; ++j) {
+//  //      if (strcmp(pm->meterId, pResult->resultName[j]) == 0) {
+//  //        findResult = true;
+//  //        break;
+//  //      }
+//  //    }
+//  //    assert(findResult == true);
+//  //    findResult = false;
+//  //  }
+//
+//  printf("\n\n");
+//  tExprTreeDestroy(&pExpr, NULL);
+//}
 
+#if 0
 static void Left2RightTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
   char str[256] = {0};
 
@@ -632,4 +630,5 @@ void exprSerializeTest2() {
 }  // namespace
 TEST(testCase, astTest) {
 //  exprSerializeTest2();
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file

From 453715c789546e888d5614f4a4658e232ccd2c7f Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 11:10:52 +0000
Subject: [PATCH 63/87] [TD-860] definite lost while update dnode

---
 src/mnode/src/mnodeDnode.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c
index 4707616ba8..804a64be08 100644
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -88,13 +88,13 @@ static int32_t mnodeDnodeActionDelete(SSdbOper *pOper) {
 }
 
 static int32_t mnodeDnodeActionUpdate(SSdbOper *pOper) {
-  SDnodeObj *pDnode = pOper->pObj;
-  SDnodeObj *pSaved = mnodeGetDnode(pDnode->dnodeId);
-  if (pSaved != NULL && pDnode != pSaved) {
-    memcpy(pSaved, pDnode, pOper->rowSize);
-    free(pDnode);
-    mnodeDecDnodeRef(pSaved);
+  SDnodeObj *pNew = pOper->pObj;
+  SDnodeObj *pDnode = mnodeGetDnode(pNew->dnodeId);
+  if (pDnode != NULL && pNew != pDnode) {
+    memcpy(pDnode, pNew, pOper->rowSize);
+    free(pNew);
   }
+  mnodeDecDnodeRef(pDnode);
 
   return TSDB_CODE_SUCCESS;
 }

From 566b286084eec3958f027386d0867ff7b6d26a68 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 7 Jul 2020 11:23:44 +0000
Subject: [PATCH 64/87] [TD-860] invalid write in sdb

---
 src/mnode/src/mnodeSdb.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 9f46a77483..0c2e478a07 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -551,8 +551,9 @@ static int sdbWrite(void *param, void *data, int type) {
   // from app, oper is created
   if (pOper != NULL) {
     // forward to peers
+    pOper->processedCount = 0;
     int32_t syncCode = syncForwardToPeer(tsSdbObj.sync, pHead, pOper, TAOS_QTYPE_RPC);
-    if (syncCode > 0) pOper->processedCount = 0;
+    if (syncCode <= 0) pOper->processedCount = 1;
 
     if (syncCode < 0) {
       sdbError("table:%s, failed to forward request, result:%s action:%s record:%s version:%" PRId64, pTable->tableName,

From 7e792f465d7124fa0ed3a528f884f7ddc212f1de Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Tue, 7 Jul 2020 06:30:08 -0700
Subject: [PATCH 65/87] dont use sleep

---
 src/rpc/test/rclient.c |  1 +
 src/rpc/test/rserver.c | 21 ++++++---------------
 2 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/src/rpc/test/rclient.c b/src/rpc/test/rclient.c
index e51b54e299..f8dbbedb11 100644
--- a/src/rpc/test/rclient.c
+++ b/src/rpc/test/rclient.c
@@ -156,6 +156,7 @@ int main(int argc, char *argv[]) {
   }
 
   tInfo("client is initialized");
+  tInfo("threads:%d msgSize:%d requests:%d", appThreads, msgSize, numOfReqs);
 
   gettimeofday(&systemTime, NULL);
   startTime = systemTime.tv_sec*1000000 + systemTime.tv_usec;
diff --git a/src/rpc/test/rserver.c b/src/rpc/test/rserver.c
index 1ac9409a57..d06e9df64b 100644
--- a/src/rpc/test/rserver.c
+++ b/src/rpc/test/rserver.c
@@ -24,23 +24,21 @@ int msgSize = 128;
 int commit = 0;
 int dataFd = -1;
 void *qhandle = NULL;
+void *qset = NULL;
 
 void processShellMsg() {
   static int num = 0;
   taos_qall  qall;
   SRpcMsg   *pRpcMsg, rpcMsg;
   int        type;
+  void      *pvnode;
  
   qall = taosAllocateQall();
 
   while (1) {
-    int numOfMsgs = taosReadAllQitems(qhandle, qall);
-    if (numOfMsgs <= 0) {
-      usleep(100);
-      continue;
-    }     
-
+    int numOfMsgs = taosReadAllQitemsFromQset(qset, qall, &pvnode);
     tDebug("%d shell msgs are received", numOfMsgs);
+    if (numOfMsgs <= 0) break;
 
     for (int i=0; i<numOfMsgs; ++i) {
       taosGetQitem(qall, &type, (void **)&pRpcMsg);
@@ -82,15 +80,6 @@ void processShellMsg() {
   }
 
   taosFreeQall(qall);
-/*
-  SRpcIpSet ipSet;
-  ipSet.numOfIps = 1;
-  ipSet.index = 0;
-  ipSet.port = 7000;
-  ipSet.ip[0] = inet_addr("192.168.0.2");
-
-  rpcSendRedirectRsp(ahandle, &ipSet);
-*/
 
 }
 
@@ -189,6 +178,8 @@ int main(int argc, char *argv[]) {
   }
 
   qhandle = taosOpenQueue(sizeof(SRpcMsg));
+  qset = taosOpenQset();
+  taosAddIntoQset(qset, qhandle, NULL);
 
   processShellMsg();
 

From 4e1b99537238edb03442b673f8267dccb1b1044d Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 09:01:50 +0800
Subject: [PATCH 66/87] [TD-872]

---
 src/kit/taosdemo/taosdemo.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 9a5aedcdb7..6ba420514b 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -520,9 +520,8 @@ int main(int argc, char *argv[]) {
     snprintf(command, BUFFER_SIZE, "create table if not exists %s.meters (ts timestamp%s tags (areaid int, loc binary(10))", db_name, cols);
     queryDB(taos, command);
     printf("meters created!\n");
-
-    taos_close(taos);
   }
+  taos_close(taos);
   
   /* Wait for table to create  */
   multiThreadCreateTable(cols, use_metric, threads, ntables, db_name, tb_prefix, ip_addr, port, user, pass);
@@ -792,9 +791,6 @@ void * createTable(void *sarg)
       snprintf(command, BUFFER_SIZE, "create table if not exists %s.%s%d (ts timestamp%s;", winfo->db_name, winfo->tb_prefix, i, winfo->cols);
       queryDB(winfo->taos, command);
     }
-
-    taos_close(winfo->taos);
-
   } else {
     /* Create all the tables; */
     printf("Creating table from %d to %d\n", winfo->start_table_id, winfo->end_table_id);
@@ -812,7 +808,6 @@ void * createTable(void *sarg)
     }
       queryDB(winfo->taos, command);
     }
-    taos_close(winfo->taos);
   }
 
   return NULL;

From 4dadf6ad649ba8aebda5e652dc61535a3447b846 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 09:05:18 +0800
Subject: [PATCH 67/87] [fix bug: no free pSql]

---
 src/kit/shell/src/shellImport.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/kit/shell/src/shellImport.c b/src/kit/shell/src/shellImport.c
index ba123ac2d4..a440db7301 100644
--- a/src/kit/shell/src/shellImport.c
+++ b/src/kit/shell/src/shellImport.c
@@ -206,9 +206,10 @@ static void shellSourceFile(TAOS *con, char *fptr) {
     
     if (code != 0) {
       fprintf(stderr, "DB error: %s: %s (%d)\n", taos_errstr(con), fname, lineNo);
-      /* free local resouce: allocated memory/metric-meta refcnt */
-      taos_free_result(pSql);
     }
+    
+    /* free local resouce: allocated memory/metric-meta refcnt */
+    taos_free_result(pSql);
 
     memset(cmd, 0, MAX_COMMAND_SIZE);
     cmd_len = 0;

From a54a425c753719e3366ce9e579745d44aea00f5e Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 10:33:11 +0800
Subject: [PATCH 68/87] failed to create table in tsdb while sync failed

---
 src/mnode/src/mnodeTable.c  | 26 +++++++++++++++++++-------
 src/mnode/src/mnodeVgroup.c | 18 ++++++++++++------
 2 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 47add8f7a3..5c32130925 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -783,9 +783,15 @@ static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) {
 
 static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
   SSuperTableObj *pTable = (SSuperTableObj *)pMsg->pTable;
-  if (pTable != NULL) {
-    mLInfo("app:%p:%p, stable:%s, is created in sdb, result:%s", pMsg->rpcMsg.ahandle, pMsg, pTable->info.tableId,
-            tstrerror(code));
+  assert(pTable);
+
+  if (code == TSDB_CODE_SUCCESS) {
+    mLInfo("stable:%s, is created in sdb", pTable->info.tableId);
+  } else {
+    mError("app:%p:%p, stable:%s, failed to create in sdb, reason:%s", pMsg->rpcMsg.ahandle, pMsg, pTable->info.tableId,
+           tstrerror(code));
+    SSdbOper desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .table = tsSuperTableSdb};
+    sdbDeleteRow(&desc);
   }
 
   return code;
@@ -1561,10 +1567,16 @@ static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
   SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable;
   assert(pTable);
 
-  mDebug("app:%p:%p, table:%s, create table in id:%d, uid:%" PRIu64 ", result:%s", pMsg->rpcMsg.ahandle, pMsg,
-         pTable->info.tableId, pTable->sid, pTable->uid, tstrerror(code));
-
-  if (code != TSDB_CODE_SUCCESS) return code;
+  if (code == TSDB_CODE_SUCCESS) {
+    mDebug("app:%p:%p, table:%s, create table in sid:%d, uid:%" PRIu64, pMsg->rpcMsg.ahandle, pMsg, pTable->info.tableId,
+           pTable->sid, pTable->uid);
+  } else {
+    mError("app:%p:%p, table:%s, failed to create table sid:%d, uid:%" PRIu64 ", reason:%s", pMsg->rpcMsg.ahandle, pMsg,
+           pTable->info.tableId, pTable->sid, pTable->uid, tstrerror(code));
+    SSdbOper desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .table = tsChildTableSdb};
+    sdbDeleteRow(&desc);
+    return code;
+  }
 
   SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
   SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, pTable);
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index 3a9076335a..8fb1b749c2 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -348,17 +348,23 @@ void *mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup) {
 }
 
 static int32_t mnodeCreateVgroupCb(SMnodeMsg *pMsg, int32_t code) {
+  SVgObj *pVgroup = pMsg->pVgroup;
+  SDbObj *pDb = pMsg->pDb;
+  assert(pVgroup);
+
   if (code != TSDB_CODE_SUCCESS) {
-    pMsg->pVgroup = NULL;
+    mError("app:%p:%p, vgId:%d, failed to create in sdb, reason:%s", pMsg->rpcMsg.ahandle, pMsg, pVgroup->vgId,
+           tstrerror(code));
+    SSdbOper desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .table = tsVgroupSdb};
+    sdbDeleteRow(&desc);
     return code;
   }
 
-  SVgObj *pVgroup = pMsg->pVgroup;
-  SDbObj *pDb = pMsg->pDb;
-
-  mInfo("vgId:%d, is created in mnode, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
+  mInfo("app:%p:%p, vgId:%d, is created in mnode, db:%s replica:%d", pMsg->rpcMsg.ahandle, pMsg, pVgroup->vgId,
+        pDb->name, pVgroup->numOfVnodes);
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    mInfo("vgId:%d, index:%d, dnode:%d", pVgroup->vgId, i, pVgroup->vnodeGid[i].dnodeId);
+    mInfo("app:%p:%p, vgId:%d, index:%d, dnode:%d", pMsg->rpcMsg.ahandle, pMsg, pVgroup->vgId, i,
+          pVgroup->vnodeGid[i].dnodeId);
   }
 
   mnodeIncVgroupRef(pVgroup);

From 354dd93d2bbd2fc724e11aa63dda5c2ef75dd09c Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 10:44:41 +0800
Subject: [PATCH 69/87] [add cluster sim cases]

---
 tests/script/unique/cluster/client1_0.sim    |  16 +
 tests/script/unique/cluster/cluster_main.sim | 494 +++++++++++++++++++
 2 files changed, 510 insertions(+)
 create mode 100644 tests/script/unique/cluster/client1_0.sim
 create mode 100644 tests/script/unique/cluster/cluster_main.sim

diff --git a/tests/script/unique/cluster/client1_0.sim b/tests/script/unique/cluster/client1_0.sim
new file mode 100644
index 0000000000..f7ed46436e
--- /dev/null
+++ b/tests/script/unique/cluster/client1_0.sim
@@ -0,0 +1,16 @@
+sql connect
+
+$db = db1
+$stb = stb1
+print =============== client1_0:
+
+sql use $db
+
+$tblNum = 1000
+
+$i = 1
+while $i < $tblNum
+  $tb = tb . $i
+  sql create table $tb using $stb tags ($i, 'abcd')
+  $i = $i + 1
+endw 
diff --git a/tests/script/unique/cluster/cluster_main.sim b/tests/script/unique/cluster/cluster_main.sim
new file mode 100644
index 0000000000..5b356948ea
--- /dev/null
+++ b/tests/script/unique/cluster/cluster_main.sim
@@ -0,0 +1,494 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/deploy.sh -n dnode2 -i 2
+system sh/deploy.sh -n dnode3 -i 3
+system sh/deploy.sh -n dnode4 -i 4
+
+system sh/cfg.sh -n dnode1 -c numOfMnodes -v 3
+system sh/cfg.sh -n dnode2 -c numOfMnodes -v 3
+system sh/cfg.sh -n dnode3 -c numOfMnodes -v 3
+system sh/cfg.sh -n dnode4 -c numOfMnodes -v 3
+
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
+system sh/cfg.sh -n dnode4 -c walLevel -v 1
+
+system sh/cfg.sh -n dnode1 -c balanceInterval -v 10
+system sh/cfg.sh -n dnode2 -c balanceInterval -v 10
+system sh/cfg.sh -n dnode3 -c balanceInterval -v 10
+system sh/cfg.sh -n dnode4 -c balanceInterval -v 10
+
+system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode4 -c numOfTotalVnodes -v 4
+
+system sh/cfg.sh -n dnode1 -c alternativeRole -v 0
+system sh/cfg.sh -n dnode2 -c alternativeRole -v 0
+system sh/cfg.sh -n dnode3 -c alternativeRole -v 0
+system sh/cfg.sh -n dnode4 -c alternativeRole -v 0
+
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 1000
+system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 1000
+system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 1000
+system sh/cfg.sh -n dnode4 -c maxtablesPerVnode -v 1000
+
+system sh/cfg.sh -n dnode1 -c arbitrator -v $arbitrator
+system sh/cfg.sh -n dnode2 -c arbitrator -v $arbitrator
+system sh/cfg.sh -n dnode3 -c arbitrator -v $arbitrator
+system sh/cfg.sh -n dnode4 -c arbitrator -v $arbitrator
+
+print ============== step0: start tarbitrator
+system sh/exec_tarbitrator.sh -s start
+
+print ============== step1: start dnode1/dnode2/dnode3
+system sh/exec.sh -n dnode1 -s start
+system sh/exec.sh -n dnode2 -s start
+system sh/exec.sh -n dnode3 -s start
+sleep 3000
+sql connect
+sql create dnode $hostname2
+sql create dnode $hostname3
+sleep 3000
+
+print ============== step2: create db1 with replica 3
+$db = db1
+print create database $db replica 3
+#sql create database $db replica 3 maxTables $totalTableNum
+sql create database $db replica 3
+sql use $db
+
+print ============== step3: create stable stb1
+$stb = stb1
+sql create table $stb (ts timestamp, c1 int, c2 int) tags(t1 int, t2 binary(8))
+
+print ============== step4: start 10 client1/ 10 client2/ 10 client3/ 10 client4/ 1 client5
+run_back unique/cluster/client1_0.sim
+#run_back unique/cluster/client1_1.sim
+#run_back unique/big_cluster/client1_2.sim
+#run_back unique/big_cluster/client1_3.sim
+#run_back unique/big_cluster/client1_4.sim
+#run_back unique/big_cluster/client1_5.sim
+#run_back unique/big_cluster/client1_6.sim
+#run_back unique/big_cluster/client1_7.sim
+#run_back unique/big_cluster/client1_8.sim
+#run_back unique/big_cluster/client1_9.sim
+
+
+print wait for a while to let clients start insert data
+sleep 5000    
+
+$loop_cnt = 0
+loop_cluster_do:
+print **** **** **** START loop cluster do **** **** **** ****
+print ============== step5: start dnode4 and add into cluster, then wait dnode4 ready
+system sh/exec.sh -n dnode4 -s start
+sql create dnode $hostname4
+
+wait_dnode4_ready_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 4 then
+  sleep 2000
+  goto wait_dnode4_ready_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+#$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode4Status = $data4_4 
+elif $loop_cnt == 1 then
+  $dnode4Status = $data4_6 
+elif $loop_cnt == 2 then
+  $dnode4Status = $data4_8 
+else then
+  print **** **** **** END loop cluster do 2**** **** **** ****
+  return
+endi
+
+if $dnode4Status != ready then
+  sleep 2000
+  goto wait_dnode4_ready_0
+endi
+
+
+print ============== step6: stop and drop dnode1, then remove data dir of dnode1 
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+$cnt = 0
+wait_dnode1_offline_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 4 then
+  sleep 2000
+  goto wait_dnode1_offline_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+ 
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode1Status = $data4_1 
+elif $loop_cnt == 1 then
+  $dnode1Status = $data4_5 
+elif $loop_cnt == 2 then
+  $dnode1Status = $data4_7 
+elif $loop_cnt == 3 then
+  $dnode1Status = $data4_9 
+else then
+  print **** **** **** END loop cluster do 1**** **** **** ****
+  return
+endi
+
+if $dnode1Status != offline then
+  sleep 2000
+  goto wait_dnode1_offline_0
+endi
+
+sql drop dnode $hostname1
+system rm -rf ../../../sim/dnode1
+
+
+print ============== step7: stop dnode2, because mnodes < 50%, so clusert don't provide services
+system sh/exec.sh -n dnode2 -s stop -x SIGINT
+
+sql show dnodes -x wait_dnode2_offline_0
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode2_offline_0
+endi
+wait_dnode2_offline_0:
+
+#$cnt = 0
+#wait_dnode2_offline_0:
+#$cnt = $cnt + 1
+#if $cnt == 10 then
+#  return -1
+#endi
+#sql show dnodes -x wait_dnode2_offline_0
+#if $rows != 3 then
+#  sleep 2000
+#  goto wait_dnode2_offline_0
+#endi
+#print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+#print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+#print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+#print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+#$dnode1Status = $data4_1  
+#$dnode2Status = $data4_2
+#$dnode3Status = $data4_3  
+#$dnode4Status = $data4_4 
+#
+#if $dnode2Status != offline then
+#  sleep 2000
+#  goto wait_dnode1_offline_0
+#endi
+
+print ============== step8: restart dnode2, then wait sync end
+system sh/exec.sh -n dnode2 -s start
+
+$cnt = 0
+wait_dnode2_ready_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode2_ready_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+$dnode4Status = $data4_4 
+
+if $dnode2Status != ready then
+  sleep 2000
+  goto wait_dnode2_ready_0
+endi
+
+
+print ============== step9: stop dnode3, then wait sync end
+system sh/exec.sh -n dnode3 -s stop -x SIGINT
+
+$cnt = 0
+wait_dnode3_offline_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode3_offline_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+$dnode4Status = $data4_4 
+
+if $dnode3Status != offline then
+  sleep 2000
+  goto wait_dnode3_offline_0
+endi
+
+print ============== step10: restart dnode3, then wait sync end
+system sh/exec.sh -n dnode3 -s start
+
+$cnt = 0
+wait_dnode3_ready_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode3_ready_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+$dnode4Status = $data4_4 
+
+if $dnode3Status != ready then
+  sleep 2000
+  goto wait_dnode3_ready_0
+endi
+
+print ============== step11: stop dnode4, then wait sync end
+system sh/exec.sh -n dnode4 -s stop -x SIGINT
+
+$cnt = 0
+wait_dnode4_offline_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode4_offline_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+#$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode4Status = $data4_4 
+elif $loop_cnt == 1 then
+  $dnode4Status = $data4_6 
+elif $loop_cnt == 2 then
+  $dnode4Status = $data4_8 
+else then
+  print **** **** **** END loop cluster do 2**** **** **** ****
+  return
+endi
+
+if $dnode4Status != offline then
+  sleep 2000
+  goto wait_dnode4_offline_0
+endi
+
+print ============== step12: restart dnode4, then wait sync end
+system sh/exec.sh -n dnode4 -s start
+
+$cnt = 0
+wait_dnode4_ready_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode4_ready_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+#$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode4Status = $data4_4 
+elif $loop_cnt == 1 then
+  $dnode4Status = $data4_6 
+elif $loop_cnt == 2 then
+  $dnode4Status = $data4_8 
+else then
+  print **** **** **** END loop cluster do 2**** **** **** ****
+  return
+endi
+
+if $dnode4Status != ready then
+  sleep 2000
+  goto wait_dnode4_ready_0
+endi
+
+print ============== step13: alter replica 2
+sql alter database $db replica 2
+sql show database
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+
+if $data0_5 != 2 then
+  print rplica is not modify to 2, error!!!!!!
+  return
+endi
+
+print ============== step14: stop and drop dnode4, then remove data dir of dnode4 
+system sh/exec.sh -n dnode4 -s stop -x SIGINT
+
+$cnt = 0
+wait_dnode4_offline_1:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode4_offline_1
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+ 
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+#$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode4Status = $data4_4 
+elif $loop_cnt == 1 then
+  $dnode4Status = $data4_6 
+elif $loop_cnt == 2 then
+  $dnode4Status = $data4_8 
+else then
+  print **** **** **** END loop cluster do 2**** **** **** ****
+  return
+endi
+
+if $dnode4Status != offline then
+  sleep 2000
+  goto wait_dnode4_offline_1
+endi
+
+sql drop dnode $hostname4
+system rm -rf ../../../sim/dnode4
+
+
+print ============== step15: alter replica 1
+sql alter database $db replica 1
+sql show database
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+
+if $data0_5 != 1 then
+  print rplica is not modify to 1, error!!!!!!
+  return
+endi
+
+
+print ============== step16: alter replica 2
+sql alter database $db replica 1
+sql show database
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+
+if $data0_5 != 2 then
+  print rplica is not modify to 2, error!!!!!!
+  return
+endi
+
+print ============== step17: start dnode1 and add into cluster, then wait dnode1 ready
+system sh/exec.sh -n dnode1 -s start
+sql create dnode $hostname1
+
+wait_dnode1_ready_0:
+$cnt = $cnt + 1
+if $cnt == 10 then
+  return -1
+endi
+sql show dnodes
+if $rows != 3 then
+  sleep 2000
+  goto wait_dnode1_ready_0
+endi
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+print $data0_2  $data1_2  $data2_2  $data3_2  $data4_2
+print $data0_3  $data1_3  $data2_3  $data3_3  $data4_3
+print $data0_4  $data1_4  $data2_4  $data3_4  $data4_4
+#$dnode1Status = $data4_1  
+$dnode2Status = $data4_2
+$dnode3Status = $data4_3  
+$dnode4Status = $data4_4 
+
+if $loop_cnt == 0 then
+  $dnode1Status = $data4_1 
+elif $loop_cnt == 1 then
+  $dnode1Status = $data4_5 
+elif $loop_cnt == 2 then
+  $dnode1Status = $data4_7 
+elif $loop_cnt == 3 then
+  $dnode1Status = $data4_9 
+else then
+  print **** **** **** END loop cluster do 3**** **** **** ****
+  return
+endi
+
+if $dnode1Status != ready then
+  sleep 2000
+  goto wait_dnode1_ready_0
+endi
+
+print ============== step18: alter replica 3
+sql alter database $db replica 3
+sql show database
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1
+
+if $data0_5 != 3 then
+  print rplica is not modify to 3, error!!!!!!
+  return
+endi
+
+$loop_cnt = $loop_cnt + 1
+goto loop_cluster_do

From fb55414c64961698a43d1ae213ab65bee2a6ecd4 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 11:48:01 +0800
Subject: [PATCH 70/87] [coverity scan]

---
 src/kit/taosdemo/taosdemo.c               |   10 +
 src/kit/taosdump/taosdump.c               | 1950 ++++++++++++++-------
 src/kit/taosmigrate/taosmigrate.c         |    1 +
 src/kit/taosmigrate/taosmigrateMnodeWal.c |    6 +
 src/kit/taosmigrate/taosmigrateVnodeCfg.c |    2 +
 5 files changed, 1356 insertions(+), 613 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 6ba420514b..317da97fd3 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -870,6 +870,11 @@ void *readTable(void *sarg) {
   int64_t sTime = rinfo->start_time;
   char *tb_prefix = rinfo->tb_prefix;
   FILE *fp = fopen(rinfo->fp, "a");
+  if (NULL == fp) {
+    printf("fopen %s fail, reason:%s.\n", rinfo->fp, strerror(errno));
+    return NULL;
+  }
+  
   int num_of_DPT = rinfo->nrecords_per_table;
   int num_of_tables = rinfo->end_table_id - rinfo->start_table_id + 1;
   int totalData = num_of_DPT * num_of_tables;
@@ -925,6 +930,11 @@ void *readMetric(void *sarg) {
   TAOS *taos = rinfo->taos;
   char command[BUFFER_SIZE] = "\0";
   FILE *fp = fopen(rinfo->fp, "a");
+  if (NULL == fp) {
+    printf("fopen %s fail, reason:%s.\n", rinfo->fp, strerror(errno));
+    return NULL;
+  }
+  
   int num_of_DPT = rinfo->nrecords_per_table;
   int num_of_tables = rinfo->end_table_id - rinfo->start_table_id + 1;
   int totalData = num_of_DPT * num_of_tables;
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index 0b1890c5ab..70f18b32bd 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -27,19 +27,18 @@
 #include <unistd.h>
 #include <wordexp.h>
 #include <iconv.h>
+#include <time.h>
 
 #include "taos.h"
-#include "taosmsg.h"
-#include "tsclient.h"
 #include "taosdef.h"
+#include "taosmsg.h"
+#include "tglobal.h"
+#include "tsclient.h"
+#include "tsdb.h"
 #include "tutil.h"
 
-#include "tglobal.h"
-
 #define COMMAND_SIZE 65536
-#define DEFAULT_DUMP_FILE "taosdump.sql"
-
-#define MAX_DBS  100
+//#define DEFAULT_DUMP_FILE "taosdump.sql"
 
 int  converStringToReadable(char *str, int size, char *buf, int bufsize);
 int  convertNCharToReadable(char *str, int size, char *buf, int bufsize);
@@ -90,21 +89,21 @@ enum _describe_table_index {
 };
 
 typedef struct {
-  char field[TSDB_COL_NAME_LEN];
+  char field[TSDB_COL_NAME_LEN + 1];
   char type[16];
   int length;
   char note[128];
 } SColDes;
 
 typedef struct {
-  char name[TSDB_COL_NAME_LEN];
+  char name[TSDB_COL_NAME_LEN + 1];
   SColDes cols[];
 } STableDef;
 
 extern char version[];
 
 typedef struct {
-  char name[TSDB_DB_NAME_LEN];
+  char name[TSDB_DB_NAME_LEN + 1];
   int32_t replica;
   int32_t days;
   int32_t keep;
@@ -119,8 +118,8 @@ typedef struct {
 } SDbInfo;
 
 typedef struct {
-  char name[TSDB_TABLE_NAME_LEN];
-  char metric[TSDB_TABLE_NAME_LEN];
+  char name[TSDB_TABLE_NAME_LEN + 1];
+  char metric[TSDB_TABLE_NAME_LEN + 1];
 } STableRecord;
 
 typedef struct {
@@ -128,6 +127,16 @@ typedef struct {
   STableRecord tableRecord;
 } STableRecordInfo;
 
+typedef struct {
+  pthread_t threadID;
+  int32_t   threadIndex;
+  int32_t   totalThreads;
+  char      dbName[TSDB_TABLE_NAME_LEN + 1];
+  void     *taosCon;
+} SThreadParaObj;
+
+static int64_t totalDumpOutRows = 0;
+
 SDbInfo **dbInfos = NULL;
 
 const char *argp_program_version = version;
@@ -142,7 +151,7 @@ static char doc[] = "";
 /*         to force a line-break, e.g.\n<-- here."; */
 
 /* A description of the arguments we accept. */
-static char args_doc[] = "dbname [tbname ...]\n--databases dbname ...\n--all-databases\n-i input_file";
+static char args_doc[] = "dbname [tbname ...]\n--databases dbname ...\n--all-databases\n-i inpath\n-o outpath";
 
 /* Keys for options without short-options. */
 #define OPT_ABORT 1 /* –abort */
@@ -150,60 +159,68 @@ static char args_doc[] = "dbname [tbname ...]\n--databases dbname ...\n--all-dat
 /* The options we understand. */
 static struct argp_option options[] = {
   // connection option
-  {"host",          'h', "HOST",       0, "Server host dumping data from. Default is localhost.",     0},
-  {"user",          'u', "USER",       0, "User name used to connect to server. Default is root.",    0},
-  {"password",      'p', "PASSWORD",   0, "User password to connect to server. Default is taosdata.", 0},
-  {"port",          'P', "PORT",       0, "Port to connect",                                          0},
+  {"host",          'h', "HOST",        0,  "Server host dumping data from. Default is localhost.",        0},
+  {"user",          'u', "USER",        0,  "User name used to connect to server. Default is root.",       0},
+  {"password",      'p', "PASSWORD",    0,  "User password to connect to server. Default is taosdata.",    0},
+  {"port",          'P', "PORT",        0,  "Port to connect",                                             0},
+  {"cversion",      'v', "CVERION",     0,  "client version",                                              0},
+  {"mysqlFlag",     'q', "MYSQLFLAG",   0,  "mysqlFlag, Default is 0",                                     0},
   // input/output file
-  {"output",        'o', "OUTPUT",     0, "Output file name.",                                        1},
-  {"input",         'i', "INPUT",      0, "Input file name.",                                         1},
-  {"config",        'c', "CONFIG_DIR", 0, "Configure directory. Default is /etc/taos/taos.cfg.",      1},
-  {"encode", 'e', "ENCODE", 0, "Input file encoding.", 1},
+  {"outpath",       'o', "OUTPATH",     0,  "Output file path.",                                          1},
+  {"inpath",        'i', "INPATH",      0,  "Input file path.",                                           1},
+  {"config",        'c', "CONFIG_DIR",  0,  "Configure directory. Default is /etc/taos/taos.cfg.",        1},
+  {"encode",        'e', "ENCODE",      0,  "Input file encoding.",                                       1},
   // dump unit options
-  {"all-databases", 'A', 0,            0, "Dump all databases.",                                      2},
-  {"databases",     'B', 0,            0, "Dump assigned databases",                                  2},
+  {"all-databases", 'A', 0,             0,  "Dump all databases.",                                         2},
+  {"databases",     'B', 0,             0,  "Dump assigned databases",                                     2},
   // dump format options
-  {"schemaonly",    's', 0,            0, "Only dump schema.",                                        3},
-  {"with-property", 'M', 0,            0, "Dump schema with properties.",                             3},
-  {"start-time",    'S', "START_TIME", 0, "Start time to dump.",                                      3},
-  {"end-time",      'E', "END_TIME",   0, "End time to dump.",                                        3},
-  {"data-batch",    'N', "DATA_BATCH", 0, "Number of data point per insert statement. Default is 1.", 3},
-  {"allow-sys",     'a', 0,            0, "Allow to dump sys database",                               3},
+  {"schemaonly",    's', 0,             0,  "Only dump schema.",                                           3},
+  {"with-property", 'M', 0,             0,  "Dump schema with properties.",                                3},
+  {"start-time",    'S', "START_TIME",  0,  "Start time to dump.",                                         3},
+  {"end-time",      'E', "END_TIME",    0,  "End time to dump.",                                           3},
+  {"data-batch",    'N', "DATA_BATCH",  0,  "Number of data point per insert statement. Default is 1.",    3},
+  {"table-batch",   'T', "TABLE_BATCH", 0,  "Number of table dumpout into one output file. Default is 1.", 3},
+  {"thread_num",    't', "THREAD_NUM",  0,  "Number of thread for dump in file. Default is 5.",            3},  
+  {"allow-sys",     'a', 0,             0,  "Allow to dump sys database",                                  3},
   {0}};
 
 /* Used by main to communicate with parse_opt. */
-typedef struct SDumpArguments {
+struct arguments {
   // connection option
-  char *host;
-  char *user;
-  char *password;
-  uint16_t port;
+  char    *host;
+  char    *user;
+  char    *password;
+  uint16_t port;  
+  char     cversion[TSDB_FILENAME_LEN+1];
+  uint16_t mysqlFlag;
   // output file
-  char output[TSDB_FILENAME_LEN];
-  char input[TSDB_FILENAME_LEN];
-  char *encode;
+  char     outpath[TSDB_FILENAME_LEN+1];
+  char     inpath[TSDB_FILENAME_LEN+1];
+  char    *encode;
   // dump unit option
-  bool all_databases;
-  bool databases;
+  bool     all_databases;
+  bool     databases;
   // dump format option
-  bool schemaonly;
-  bool with_property;
-  int64_t start_time;
-  int64_t end_time;
-  int data_batch;
-  bool allow_sys;
+  bool     schemaonly;
+  bool     with_property;
+  int64_t  start_time;
+  int64_t  end_time;
+  int32_t  data_batch;
+  int32_t  table_batch; // num of table which will be dump into one output file.
+  bool     allow_sys;
   // other options
-  int abort;
-  char **arg_list;
-  int arg_list_len;
-  bool isDumpIn;
-} SDumpArguments;
+  int32_t  thread_num;
+  int      abort;
+  char   **arg_list;
+  int      arg_list_len;
+  bool     isDumpIn;
+};
 
 /* Parse a single option. */
 static error_t parse_opt(int key, char *arg, struct argp_state *state) {
   /* Get the input argument from argp_parse, which we
      know is a pointer to our arguments structure. */
-  SDumpArguments *arguments = state->input;
+  struct arguments *arguments = state->input;
   wordexp_t full_path;
 
   switch (key) {
@@ -223,13 +240,24 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     case 'P':
       arguments->port = atoi(arg);
       break;
-    // output file
+    case 'q':
+      arguments->mysqlFlag = atoi(arg);
+      break;
+    case 'v':
+      if (wordexp(arg, &full_path, 0) != 0) {
+        fprintf(stderr, "Invalid client vesion %s\n", arg);
+        return -1;
+      }
+      strcpy(arguments->cversion, full_path.we_wordv[0]);
+      wordfree(&full_path);
+      break;
+    // output file path
     case 'o':
       if (wordexp(arg, &full_path, 0) != 0) {
         fprintf(stderr, "Invalid path %s\n", arg);
         return -1;
       }
-      tstrncpy(arguments->output, full_path.we_wordv[0], TSDB_FILENAME_LEN);
+      strcpy(arguments->outpath, full_path.we_wordv[0]);
       wordfree(&full_path);
       break;
     case 'i':
@@ -238,7 +266,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
         fprintf(stderr, "Invalid path %s\n", arg);
         return -1;
       }
-      tstrncpy(arguments->input, full_path.we_wordv[0], TSDB_FILENAME_LEN);
+      strcpy(arguments->inpath, full_path.we_wordv[0]);
       wordfree(&full_path);
       break;
     case 'c':
@@ -246,7 +274,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
         fprintf(stderr, "Invalid path %s\n", arg);
         return -1;
       }
-      tstrncpy(configDir, full_path.we_wordv[0], TSDB_FILENAME_LEN);
+      strcpy(configDir, full_path.we_wordv[0]);
       wordfree(&full_path);
       break;
     case 'e':
@@ -276,13 +304,19 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     case 'N':
       arguments->data_batch = atoi(arg);
       break;
+    case 'T':
+      arguments->table_batch = atoi(arg);
+      break;
+    case 't':
+      arguments->thread_num = atoi(arg);
+      break;
     case OPT_ABORT:
       arguments->abort = 1;
       break;
     case ARGP_KEY_ARG:
-      arguments->arg_list = &state->argv[state->next - 1];
+      arguments->arg_list     = &state->argv[state->next - 1];
       arguments->arg_list_len = state->argc - state->next + 1;
-      state->next = state->argc;
+      state->next             = state->argc;
       break;
 
     default:
@@ -294,52 +328,70 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
 /* Our argp parser. */
 static struct argp argp = {options, parse_opt, args_doc, doc};
 
-TAOS *taos = NULL;
-char *command = NULL;
-char *lcommand = NULL;
-char *buffer = NULL;
-
-int taosDumpOut(SDumpArguments *arguments);
-
-int taosDumpIn(SDumpArguments *arguments);
-
+int taosDumpOut(struct arguments *arguments);
+int taosDumpIn(struct arguments *arguments);
 void taosDumpCreateDbClause(SDbInfo *dbInfo, bool isDumpProperty, FILE *fp);
-
-int taosDumpDb(SDbInfo *dbInfo, SDumpArguments *arguments, FILE *fp);
-
-void taosDumpCreateTableClause(STableDef *tableDes, int numOfCols, SDumpArguments *arguments, FILE *fp);
-
-void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols, SDumpArguments *arguments,
-                                   FILE *fp);
-
-int32_t taosDumpTable(char *table, char *metric, SDumpArguments *arguments, FILE *fp);
-
-int32_t taosDumpMetric(char *metric, SDumpArguments *arguments, FILE *fp);
-
-int taosDumpTableData(FILE *fp, char *tbname, SDumpArguments *arguments);
-
-int taosCheckParam(SDumpArguments *arguments);
-
+int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *taosCon);
+int32_t taosDumpStable(char *table, FILE *fp, TAOS* taosCon);
+void taosDumpCreateTableClause(STableDef *tableDes, int numOfCols, FILE *fp);
+void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols, FILE *fp);
+int32_t taosDumpTable(char *table, char *metric, struct arguments *arguments, FILE *fp, TAOS* taosCon);
+int taosDumpTableData(FILE *fp, char *tbname, struct arguments *arguments, TAOS* taosCon);
+int taosCheckParam(struct arguments *arguments);
 void taosFreeDbInfos();
+static void taosStartDumpOutWorkThreads(struct arguments* args, int32_t  numOfThread, char *dbName);
+
+struct arguments tsArguments = {
+  // connection option
+  NULL, 
+  "root", 
+  "taosdata", 
+  0,
+  "",
+  0,
+  // outpath and inpath
+  "", 
+  "", 
+  NULL,
+  // dump unit option
+  false, 
+  false,
+  // dump format option
+  false, 
+  false, 
+  0, 
+  INT64_MAX, 
+  1,
+  1,
+  false,
+  // other options
+  5,
+  0,
+  NULL, 
+  0, 
+  false
+};
+
+int queryDB(TAOS *taos, char *command) {
+  TAOS_RES *pSql = NULL;
+  int32_t   code = -1;
+    
+  pSql = taos_query(taos, command);
+  code = taos_errno(pSql);
+  if (code) {
+    fprintf(stderr, "sql error: %s, reason:%s\n", command, taos_errstr(pSql));
+  } 
+  taos_free_result(pSql);
+  return code;
+}
 
 int main(int argc, char *argv[]) {
-  SDumpArguments arguments = {
-    // connection option
-    NULL, TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS, 0,
-    // output file
-    DEFAULT_DUMP_FILE, DEFAULT_DUMP_FILE, NULL,
-    // dump unit option
-    false, false,
-    // dump format option
-    false, false, 0, INT64_MAX, 1, false,
-    // other options
-    0, NULL, 0, false};
 
   /* Parse our arguments; every option seen by parse_opt will be
      reflected in arguments. */
-  argp_parse(&argp, argc, argv, 0, 0, &arguments);
+  argp_parse(&argp, argc, argv, 0, 0, &tsArguments);
 
-  if (arguments.abort) {
+  if (tsArguments.abort) {
     #ifndef _ALPINE
       error(10, 0, "ABORTED");
     #else
@@ -347,14 +399,48 @@ int main(int argc, char *argv[]) {
     #endif
   }
 
-  if (taosCheckParam(&arguments) < 0) {
+  printf("====== arguments config ======\n");
+  {
+    printf("host: %s\n", tsArguments.host);
+    printf("user: %s\n", tsArguments.user);
+    printf("password: %s\n", tsArguments.password);
+    printf("port: %u\n", tsArguments.port);
+    printf("cversion: %s\n", tsArguments.cversion);    
+    printf("mysqlFlag: %d", tsArguments.mysqlFlag);    
+    printf("outpath: %s\n", tsArguments.outpath);
+    printf("inpath: %s\n", tsArguments.inpath);
+    printf("encode: %s\n", tsArguments.encode);
+    printf("all_databases: %d\n", tsArguments.all_databases);
+    printf("databases: %d\n", tsArguments.databases);
+    printf("schemaonly: %d\n", tsArguments.schemaonly);
+    printf("with_property: %d\n", tsArguments.with_property);
+    printf("start_time: %" PRId64 "\n", tsArguments.start_time);
+    printf("end_time: %" PRId64 "\n", tsArguments.end_time);
+    printf("data_batch: %d\n", tsArguments.data_batch);
+    printf("table_batch: %d\n", tsArguments.table_batch);
+    printf("allow_sys: %d\n", tsArguments.allow_sys);
+    printf("abort: %d\n", tsArguments.abort);
+    printf("isDumpIn: %d\n", tsArguments.isDumpIn);
+    printf("arg_list_len: %d\n", tsArguments.arg_list_len);
+
+    for (int32_t i = 0; i < tsArguments.arg_list_len; i++) {
+      printf("arg_list[%d]: %s\n", i, tsArguments.arg_list[i]);
+    }
+  }  
+  printf("==============================\n");
+
+  if (tsArguments.cversion[0] != 0){
+    strcpy(version, tsArguments.cversion);
+  }
+
+  if (taosCheckParam(&tsArguments) < 0) {
     exit(EXIT_FAILURE);
   }
 
-  if (arguments.isDumpIn) {
-    if (taosDumpIn(&arguments) < 0) return -1;
+  if (tsArguments.isDumpIn) {
+    if (taosDumpIn(&tsArguments) < 0) return -1;
   } else {
-    if (taosDumpOut(&arguments) < 0) return -1;
+    if (taosDumpOut(&tsArguments) < 0) return -1;
   }
 
   return 0;
@@ -362,96 +448,214 @@ int main(int argc, char *argv[]) {
 
 void taosFreeDbInfos() {
   if (dbInfos == NULL) return;
-  for (int i = 0; i < MAX_DBS; i++) tfree(dbInfos[i]);
+  for (int i = 0; i < 128; i++) tfree(dbInfos[i]);
   tfree(dbInfos);
 }
 
-int taosGetTableRecordInfo(char *table, STableRecordInfo *pTableRecordInfo) {
+// check table is normal table or super table
+int taosGetTableRecordInfo(char *table, STableRecordInfo *pTableRecordInfo, TAOS *taosCon) {
   TAOS_ROW row = NULL;
   bool isSet = false;
+  TAOS_RES *result     = NULL;
 
   memset(pTableRecordInfo, 0, sizeof(STableRecordInfo));
 
-  sprintf(command, "show tables like %s", table);
-  TAOS_RES *result = taos_query(taos, command);\
-  int32_t code = taos_errno(result);
+  char* tempCommand = (char *)malloc(COMMAND_SIZE);
+  if (tempCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return -1;
+  }
 
+  sprintf(tempCommand, "show tables like %s", table);
+  
+  result = taos_query(taosCon, tempCommand);  
+  int32_t code = taos_errno(result);
+  
   if (code != 0) {
-    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    fprintf(stderr, "failed to run command %s\n", tempCommand);
+    free(tempCommand);
     taos_free_result(result);
     return -1;
   }
 
   TAOS_FIELD *fields = taos_fetch_fields(result);
 
-  if ((row = taos_fetch_row(result)) != NULL) {
+  while ((row = taos_fetch_row(result)) != NULL) {
     isSet = true;
     pTableRecordInfo->isMetric = false;
     strncpy(pTableRecordInfo->tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX],
             fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
     strncpy(pTableRecordInfo->tableRecord.metric, (char *)row[TSDB_SHOW_TABLES_METRIC_INDEX],
             fields[TSDB_SHOW_TABLES_METRIC_INDEX].bytes);
+    break;
   }
 
   taos_free_result(result);
   result = NULL;
 
-  if (isSet) return 0;
-
-  sprintf(command, "show stables like %s", table);
-
-  result = taos_query(taos, command);
+  if (isSet) {
+    free(tempCommand);
+    return 0;
+  }
+  
+  sprintf(tempCommand, "show stables like %s", table);
+  
+  result = taos_query(taosCon, tempCommand);  
   code = taos_errno(result);
+  
   if (code != 0) {
-    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    fprintf(stderr, "failed to run command %s\n", tempCommand);
+    free(tempCommand);
     taos_free_result(result);
     return -1;
   }
 
-  if ((row = taos_fetch_row(result)) != NULL) {
+  while ((row = taos_fetch_row(result)) != NULL) {
     isSet = true;
     pTableRecordInfo->isMetric = true;
-    tstrncpy(pTableRecordInfo->tableRecord.metric, table, TSDB_TABLE_NAME_LEN);
+    strcpy(pTableRecordInfo->tableRecord.metric, table);
+    break;
   }
 
   taos_free_result(result);
   result = NULL;
 
-  if (isSet) return 0;
-
+  if (isSet) {
+    free(tempCommand);
+    return 0;
+  }
   fprintf(stderr, "invalid table/metric %s\n", table);
+  free(tempCommand);
   return -1;
 }
 
-int taosDumpOut(SDumpArguments *arguments) {
-  TAOS_ROW row;
-  TAOS_RES* result = NULL;
-  char *temp = NULL;
-  FILE *fp = NULL;
-  int count = 0;
-  STableRecordInfo tableRecordInfo;
 
-  fp = fopen(arguments->output, "w");
-  if (fp == NULL) {
-    fprintf(stderr, "failed to open file %s\n", arguments->output);
+int32_t taosSaveAllNormalTableToTempFile(TAOS *taosCon, char*meter, char* metric, int* fd) {
+  STableRecord tableRecord;
+
+  if (-1 == *fd) {
+    *fd = open(".tables.tmp.0", O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
+    if (*fd == -1) {
+      fprintf(stderr, "failed to open temp file: .tables.tmp.0\n");
+      return -1;
+    }
+  }
+  
+  memset(tableRecord.name, 0, sizeof(STableRecord));
+  strcpy(tableRecord.name, meter);
+  strcpy(tableRecord.metric, metric);
+
+  twrite(*fd, &tableRecord, sizeof(STableRecord));
+  return 0;
+}
+
+
+int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct arguments *arguments, int32_t*  totalNumOfThread) {
+  TAOS_ROW row;
+  int fd = -1;
+  STableRecord tableRecord;
+
+  char* tmpCommand = (char *)malloc(COMMAND_SIZE);
+  if (tmpCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
     return -1;
   }
 
-  dbInfos = (SDbInfo **)calloc(MAX_DBS, sizeof(SDbInfo *));
+  sprintf(tmpCommand, "select tbname from %s", metric);
+  
+  TAOS_RES *result = taos_query(taosCon, tmpCommand);  
+  int32_t code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s\n", tmpCommand);
+    free(tmpCommand);
+    taos_free_result(result);
+    return -1;
+  }
+
+  TAOS_FIELD *fields = taos_fetch_fields(result);
+
+  int32_t  numOfTable  = 0;
+  int32_t  numOfThread = *totalNumOfThread;
+  char     tmpFileName[TSDB_FILENAME_LEN + 1];
+  while ((row = taos_fetch_row(result)) != NULL) {
+    if (0 == numOfTable) {
+      memset(tmpFileName, 0, TSDB_FILENAME_LEN);
+      sprintf(tmpFileName, ".tables.tmp.%d", numOfThread);
+      fd = open(tmpFileName, O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
+      if (fd == -1) {
+        fprintf(stderr, "failed to open temp file: %s\n", tmpFileName);
+        taos_free_result(result);
+        for (int32_t loopCnt = 0; loopCnt < numOfThread; loopCnt++) {
+          sprintf(tmpFileName, ".tables.tmp.%d", loopCnt);
+          remove(tmpFileName);
+        }
+        free(tmpCommand);
+        return -1;
+      }
+      
+      numOfThread++;
+    }
+  
+    memset(tableRecord.name, 0, sizeof(STableRecord));
+    strncpy(tableRecord.name, (char *)row[0], fields[0].bytes);
+    strcpy(tableRecord.metric, metric);
+
+    twrite(fd, &tableRecord, sizeof(STableRecord));
+
+    numOfTable++;
+
+    if (numOfTable >= arguments->table_batch) {
+      numOfTable = 0;
+      tclose(fd);
+      fd = -1;
+    }
+  }
+  tclose(fd);
+  fd = -1;
+  taos_free_result(result);
+
+  *totalNumOfThread = numOfThread;
+ 
+  free(tmpCommand);
+
+  return 0;
+}
+
+int taosDumpOut(struct arguments *arguments) {
+  TAOS     *taos       = NULL;
+  TAOS_RES *result     = NULL;
+  char     *command    = NULL;
+
+  TAOS_ROW row;
+  FILE *fp = NULL;
+  int32_t count = 0;
+  STableRecordInfo tableRecordInfo;
+
+  char tmpBuf[TSDB_FILENAME_LEN+9] = {0};
+  if (arguments->outpath[0] != 0) {
+      sprintf(tmpBuf, "%s/dbs.sql", arguments->outpath);
+  } else {
+    sprintf(tmpBuf, "dbs.sql");
+  }
+  
+  fp = fopen(tmpBuf, "w");
+  if (fp == NULL) {
+    fprintf(stderr, "failed to open file %s\n", tmpBuf);
+    return -1;
+  }
+
+  dbInfos = (SDbInfo **)calloc(128, sizeof(SDbInfo *));
   if (dbInfos == NULL) {
     fprintf(stderr, "failed to allocate memory\n");
     goto _exit_failure;
   }
 
-  temp = (char *)malloc(2 * COMMAND_SIZE);
-  if (temp == NULL) {
+  command = (char *)malloc(COMMAND_SIZE);
+  if (command == NULL) {
     fprintf(stderr, "failed to allocate memory\n");
     goto _exit_failure;
   }
 
-  command = temp;
-  buffer = command + COMMAND_SIZE;
-
   /* Connect to server */
   taos = taos_connect(arguments->host, arguments->user, arguments->password, NULL, arguments->port);
   if (taos == NULL) {
@@ -465,29 +669,30 @@ int taosDumpOut(SDumpArguments *arguments) {
   taosDumpCharset(fp);
 
   sprintf(command, "show databases");
-  result = taos_query(taos, command);
+  result = taos_query(taos, command);  
   int32_t code = taos_errno(result);
+  
   if (code != 0) {
-    fprintf(stderr, "failed to run command: %s, reason: %s\n", command, taos_errstr(result));
-    taos_free_result(result);
+    fprintf(stderr, "failed to run command: %s, reason: %s\n", command, taos_errstr(taos));
     goto _exit_failure;
   }
 
   TAOS_FIELD *fields = taos_fetch_fields(result);
 
   while ((row = taos_fetch_row(result)) != NULL) {
+    // sys database name : 'monitor', but subsequent version changed to 'log'
     if (strncasecmp(row[TSDB_SHOW_DB_NAME_INDEX], "monitor", fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0 &&
         (!arguments->allow_sys))
       continue;
 
-    if (arguments->databases) {
+    if (arguments->databases) {  // input multi dbs
       for (int i = 0; arguments->arg_list[i]; i++) {
         if (strncasecmp(arguments->arg_list[i], (char *)row[TSDB_SHOW_DB_NAME_INDEX],
                         fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0)
           goto _dump_db_point;
       }
       continue;
-    } else if (!arguments->all_databases) {
+    } else if (!arguments->all_databases) {  // only input one db
       if (strncasecmp(arguments->arg_list[0], (char *)row[TSDB_SHOW_DB_NAME_INDEX],
                       fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0)
         goto _dump_db_point;
@@ -504,19 +709,19 @@ int taosDumpOut(SDumpArguments *arguments) {
     }
 
     strncpy(dbInfos[count]->name, (char *)row[TSDB_SHOW_DB_NAME_INDEX], fields[TSDB_SHOW_DB_NAME_INDEX].bytes);
-    if (strcmp(arguments->user, TSDB_DEFAULT_USER) == 0) {
-      dbInfos[count]->replica = (int)(*((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]));
-      dbInfos[count]->days = (int)(*((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]));
-      dbInfos[count]->keep = *((int *)row[TSDB_SHOW_DB_KEEP_INDEX]);
-      dbInfos[count]->tables = *((int *)row[TSDB_SHOW_DB_TABLES_INDEX]);
-      dbInfos[count]->rows = *((int *)row[TSDB_SHOW_DB_ROWS_INDEX]);
-      dbInfos[count]->cache = *((int *)row[TSDB_SHOW_DB_CACHE_INDEX]);
-      dbInfos[count]->ablocks = *((int *)row[TSDB_SHOW_DB_ABLOCKS_INDEX]);
-      dbInfos[count]->tblocks = (int)(*((int16_t *)row[TSDB_SHOW_DB_TBLOCKS_INDEX]));
-      dbInfos[count]->ctime = *((int *)row[TSDB_SHOW_DB_CTIME_INDEX]);
-      dbInfos[count]->clog = (int)(*((int8_t *)row[TSDB_SHOW_DB_CLOG_INDEX]));
-      dbInfos[count]->comp = (int)(*((int8_t *)row[TSDB_SHOW_DB_COMP_INDEX]));
-    }
+ #if 0   
+    dbInfos[count]->replica = (int)(*((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]));
+    dbInfos[count]->days = (int)(*((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]));
+    dbInfos[count]->keep = *((int *)row[TSDB_SHOW_DB_KEEP_INDEX]);
+    dbInfos[count]->tables = *((int *)row[TSDB_SHOW_DB_TABLES_INDEX]);
+    dbInfos[count]->rows = *((int *)row[TSDB_SHOW_DB_ROWS_INDEX]);
+    dbInfos[count]->cache = *((int *)row[TSDB_SHOW_DB_CACHE_INDEX]);
+    dbInfos[count]->ablocks = *((int *)row[TSDB_SHOW_DB_ABLOCKS_INDEX]);
+    dbInfos[count]->tblocks = (int)(*((int16_t *)row[TSDB_SHOW_DB_TBLOCKS_INDEX]));
+    dbInfos[count]->ctime = *((int *)row[TSDB_SHOW_DB_CTIME_INDEX]);
+    dbInfos[count]->clog = (int)(*((int8_t *)row[TSDB_SHOW_DB_CLOG_INDEX]));
+    dbInfos[count]->comp = (int)(*((int8_t *)row[TSDB_SHOW_DB_COMP_INDEX]));
+#endif
 
     count++;
 
@@ -528,42 +733,71 @@ int taosDumpOut(SDumpArguments *arguments) {
     }
   }
 
-  // taos_free_result(result);
-
   if (count == 0) {
     fprintf(stderr, "No databases valid to dump\n");
     goto _exit_failure;
   }
 
-  if (arguments->databases || arguments->all_databases) {
+  if (arguments->databases || arguments->all_databases) { // case: taosdump --databases dbx dby ...   OR  taosdump --all-databases
     for (int i = 0; i < count; i++) {
-      (void)taosDumpDb(dbInfos[i], arguments, fp);
+      taosDumpDb(dbInfos[i], arguments, fp, taos);
     }
   } else {
-    if (arguments->arg_list_len == 1) {
-      (void)taosDumpDb(dbInfos[0], arguments, fp);
-    } else {
+    if (arguments->arg_list_len == 1) {             // case: taosdump <db>
+      taosDumpDb(dbInfos[0], arguments, fp, taos);
+    } else {                                        // case: taosdump <db> tablex tabley ...
       taosDumpCreateDbClause(dbInfos[0], arguments->with_property, fp);
 
       sprintf(command, "use %s", dbInfos[0]->name);
-      if (taos_query(taos, command) == NULL ) {
+      
+      result = taos_query(taos, command);  
+      int32_t code = taos_errno(result);
+      if (code != 0) {
         fprintf(stderr, "invalid database %s\n", dbInfos[0]->name);
         goto _exit_failure;
       }
 
       fprintf(fp, "USE %s;\n\n", dbInfos[0]->name);
 
+      int32_t totalNumOfThread = 1;  // 0: all normal talbe into .tables.tmp.0
+      int  normalTblFd = -1;
+      int32_t retCode;
       for (int i = 1; arguments->arg_list[i]; i++) {
-        if (taosGetTableRecordInfo(arguments->arg_list[i], &tableRecordInfo) < 0) {
-          fprintf(stderr, "invalide table %s\n", arguments->arg_list[i]);
+        if (taosGetTableRecordInfo(arguments->arg_list[i], &tableRecordInfo, taos) < 0) {
+          fprintf(stderr, "input the invalide table %s\n", arguments->arg_list[i]);
           continue;
         }
 
-        if (tableRecordInfo.isMetric) {  // dump whole metric
-          (void)taosDumpMetric(tableRecordInfo.tableRecord.metric, arguments, fp);
-        } else {  // dump MTable and NTable
-          (void)taosDumpTable(tableRecordInfo.tableRecord.name, tableRecordInfo.tableRecord.metric, arguments, fp);
+        if (tableRecordInfo.isMetric) {  // dump all table of this metric
+          (void)taosDumpStable(tableRecordInfo.tableRecord.metric, fp, taos);
+          retCode = taosSaveTableOfMetricToTempFile(taos, tableRecordInfo.tableRecord.metric, arguments, &totalNumOfThread);
+        } else {
+          if (tableRecordInfo.tableRecord.metric[0] != '\0') {  // dump this sub table and it's metric
+            (void)taosDumpStable(tableRecordInfo.tableRecord.metric, fp, taos);          
+          }
+          retCode = taosSaveAllNormalTableToTempFile(taos, tableRecordInfo.tableRecord.name, tableRecordInfo.tableRecord.metric, &normalTblFd);
         }
+
+        if (retCode < 0) {
+          if (-1 != normalTblFd){
+            tclose(normalTblFd);
+          }
+          goto _clean_tmp_file;
+        }
+      }
+
+      if (-1 != normalTblFd){
+        tclose(normalTblFd);
+      }
+
+      // start multi threads to dumpout
+      taosStartDumpOutWorkThreads(arguments, totalNumOfThread, dbInfos[0]->name);
+
+      char tmpFileName[TSDB_FILENAME_LEN + 1];
+      _clean_tmp_file:
+      for (int loopCnt = 0; loopCnt < totalNumOfThread; loopCnt++) {
+        sprintf(tmpFileName, ".tables.tmp.%d", loopCnt);
+        remove(tmpFileName);
       }
     }
   }
@@ -572,21 +806,120 @@ int taosDumpOut(SDumpArguments *arguments) {
   fclose(fp);
   taos_close(taos);
   taos_free_result(result);
-  tfree(temp);
-  taosFreeDbInfos();
+  tfree(command);
+  taosFreeDbInfos();  
+  fprintf(stderr, "dump out rows: %" PRId64 "\n", totalDumpOutRows);
   return 0;
 
 _exit_failure:
   fclose(fp);
   taos_close(taos);
   taos_free_result(result);
-  tfree(temp);
+  tfree(command);
   taosFreeDbInfos();
+  fprintf(stderr, "dump out rows: %" PRId64 "\n", totalDumpOutRows);
   return -1;
 }
 
+int taosGetTableDes(char *table, STableDef *tableDes, TAOS* taosCon) {
+  TAOS_ROW row = NULL;
+  TAOS_RES *tmpResult = NULL;
+  int count = 0;
+
+  char* tempCommand = (char *)malloc(COMMAND_SIZE);
+  if (tempCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return -1;
+  }
+
+  sprintf(tempCommand, "describe %s", table);
+  
+  tmpResult = taos_query(taosCon, tempCommand);  
+  int32_t code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s\n", tempCommand);
+    free(tempCommand);
+    taos_free_result(tmpResult);
+    return -1;
+  }
+
+  TAOS_FIELD *fields = taos_fetch_fields(tmpResult);
+
+  strcpy(tableDes->name, table);
+
+  while ((row = taos_fetch_row(tmpResult)) != NULL) {
+    strncpy(tableDes->cols[count].field, (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
+            fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
+    strncpy(tableDes->cols[count].type, (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
+            fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes);
+    tableDes->cols[count].length = *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
+    strncpy(tableDes->cols[count].note, (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
+            fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes);
+
+    count++;
+  }
+
+  taos_free_result(tmpResult);
+  tmpResult = NULL;
+
+  free(tempCommand);
+
+  return count;
+}
+
+int32_t taosDumpTable(char *table, char *metric, struct arguments *arguments, FILE *fp, TAOS* taosCon) {
+  int count = 0;
+
+  STableDef *tableDes = (STableDef *)calloc(1, sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
+
+  if (metric != NULL && metric[0] != '\0') {  // dump table schema which is created by using super table
+    /*
+    count = taosGetTableDes(metric, tableDes, taosCon);
+
+    if (count < 0) {
+      free(tableDes);
+      return -1;
+    }
+
+    taosDumpCreateTableClause(tableDes, count, fp);
+
+    memset(tableDes, 0, sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
+    */
+
+    count = taosGetTableDes(table, tableDes, taosCon);
+
+    if (count < 0) {
+      free(tableDes);
+      return -1;
+    }
+
+    taosDumpCreateMTableClause(tableDes, metric, count, fp);
+
+  } else {  // dump table definition
+    count = taosGetTableDes(table, tableDes, taosCon);
+
+    if (count < 0) {
+      free(tableDes);
+      return -1;
+    }
+
+    taosDumpCreateTableClause(tableDes, count, fp);
+  }
+
+  free(tableDes);
+
+  return taosDumpTableData(fp, table, arguments, taosCon);
+}
+
 void taosDumpCreateDbClause(SDbInfo *dbInfo, bool isDumpProperty, FILE *fp) {
-  char *pstr = buffer;
+
+  char* tmpCommand = (char *)malloc(COMMAND_SIZE);
+  if (tmpCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return;
+  }
+
+  char *pstr = tmpCommand;
 
   pstr += sprintf(pstr, "CREATE DATABASE IF NOT EXISTS %s", dbInfo->name);
   if (isDumpProperty) {
@@ -596,78 +929,304 @@ void taosDumpCreateDbClause(SDbInfo *dbInfo, bool isDumpProperty, FILE *fp) {
         dbInfo->ablocks, dbInfo->tblocks, dbInfo->ctime, dbInfo->clog, dbInfo->comp);
   }
 
-  fprintf(fp, "%s\n\n", buffer);
+  pstr += sprintf(pstr, ";");
+
+  fprintf(fp, "%s\n\n", tmpCommand);
+  free(tmpCommand);
 }
 
-int taosDumpDb(SDbInfo *dbInfo, SDumpArguments *arguments, FILE *fp) {
+void* taosDumpOutWorkThreadFp(void *arg)
+{
+  SThreadParaObj *pThread = (SThreadParaObj*)arg;
+  STableRecord    tableRecord;
+  int fd;  
+  
+  char tmpFileName[TSDB_FILENAME_LEN*4] = {0};
+  sprintf(tmpFileName, ".tables.tmp.%d", pThread->threadIndex);
+  fd = open(tmpFileName, O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
+  if (fd == -1) {
+    fprintf(stderr, "taosDumpTableFp() failed to open temp file: %s\n", tmpFileName);
+    return NULL;
+  }
+
+  FILE *fp = NULL;
+  memset(tmpFileName, 0, TSDB_FILENAME_LEN + 128);
+  
+  if (tsArguments.outpath[0] != 0) {
+    sprintf(tmpFileName, "%s/%s.tables.%d.sql", tsArguments.outpath, pThread->dbName, pThread->threadIndex);
+  } else {
+    sprintf(tmpFileName, "%s.tables.%d.sql", pThread->dbName, pThread->threadIndex);
+  }
+  
+  fp = fopen(tmpFileName, "w");
+  if (fp == NULL) {
+    fprintf(stderr, "failed to open file %s\n", tmpFileName);
+    return NULL;
+  }
+
+  memset(tmpFileName, 0, TSDB_FILENAME_LEN);
+  sprintf(tmpFileName, "use %s", pThread->dbName);
+  
+  TAOS_RES* tmpResult = taos_query(pThread->taosCon, tmpFileName);  
+  int32_t code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "invalid database %s\n", pThread->dbName);
+    taos_free_result(tmpResult);
+    return NULL;
+  }
+
+  fprintf(fp, "USE %s\n\n", pThread->dbName);
+  while (read(fd, &tableRecord, sizeof(STableRecord)) > 0) {
+    taosDumpTable(tableRecord.name, tableRecord.metric, &tsArguments, fp, pThread->taosCon);
+  }
+
+  taos_free_result(tmpResult);
+  tclose(fd);
+  fclose(fp);  
+
+  return NULL;
+}
+
+static void taosStartDumpOutWorkThreads(struct arguments* args, int32_t  numOfThread, char *dbName)
+{
+  pthread_attr_t thattr;
+  SThreadParaObj *threadObj = (SThreadParaObj *)calloc(numOfThread, sizeof(SThreadParaObj));
+  for (int t = 0; t < numOfThread; ++t) {
+    SThreadParaObj *pThread = threadObj + t;
+    pThread->threadIndex = t;
+    pThread->totalThreads = numOfThread;
+    strcpy(pThread->dbName, dbName);
+    pThread->taosCon = taos_connect(args->host, args->user, args->password, NULL, args->port);
+                                
+    if (pThread->taosCon == NULL) {
+      fprintf(stderr, "ERROR: thread:%d failed connect to TDengine, error:%s\n", pThread->threadIndex, taos_errstr(pThread->taosCon));
+      exit(0);
+    }
+
+    pthread_attr_init(&thattr);
+    pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+
+    if (pthread_create(&(pThread->threadID), &thattr, taosDumpOutWorkThreadFp, (void*)pThread) != 0) {
+      fprintf(stderr, "ERROR: thread:%d failed to start\n", pThread->threadIndex);
+      exit(0);
+    }
+  }
+
+  for (int32_t t = 0; t < numOfThread; ++t) {
+    pthread_join(threadObj[t].threadID, NULL);
+  }
+
+  for (int32_t t = 0; t < numOfThread; ++t) {
+    taos_close(threadObj[t].taosCon);
+  }
+  free(threadObj);
+}
+
+
+
+int32_t taosDumpStable(char *table, FILE *fp, TAOS* taosCon) {
+  int count = 0;
+
+  STableDef *tableDes = (STableDef *)calloc(1, sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
+  if (NULL == tableDes) {
+    fprintf(stderr, "failed to allocate memory\n");
+    exit(-1);
+  }
+
+  count = taosGetTableDes(table, tableDes, taosCon);
+
+  if (count < 0) {
+    free(tableDes);
+    fprintf(stderr, "failed to get stable schema\n");
+    exit(-1);
+  }
+
+  taosDumpCreateTableClause(tableDes, count, fp);
+
+  free(tableDes);
+  return 0;
+}
+
+
+int32_t taosDumpCreateSuperTableClause(TAOS* taosCon, char* dbName, FILE *fp) 
+{
+  TAOS_ROW row;
+  int fd = -1;
+  STableRecord tableRecord;
+
+  char* tmpCommand = (char *)malloc(COMMAND_SIZE);
+  if (tmpCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    exit(-1);
+  }
+
+  sprintf(tmpCommand, "use %s", dbName);
+  
+  TAOS_RES* tmpResult = taos_query(taosCon, tmpCommand);  
+  int32_t code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "invalid database %s, error: %s\n", dbName, taos_errstr(taosCon));
+    free(tmpCommand);
+    taos_free_result(tmpResult);
+    exit(-1);
+  }
+  
+  taos_free_result(tmpResult);
+
+  sprintf(tmpCommand, "show stables");
+  
+  tmpResult = taos_query(taosCon, tmpCommand);  
+  code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", tmpCommand, taos_errstr(taosCon));
+    free(tmpCommand);
+    taos_free_result(tmpResult);
+    exit(-1);
+  }
+  taos_free_result(tmpResult);
+
+  TAOS_FIELD *fields = taos_fetch_fields(tmpResult);
+
+  char     tmpFileName[TSDB_FILENAME_LEN + 1];
+  memset(tmpFileName, 0, TSDB_FILENAME_LEN);
+  sprintf(tmpFileName, ".stables.tmp");
+  fd = open(tmpFileName, O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
+  if (fd == -1) {
+    fprintf(stderr, "failed to open temp file: %s\n", tmpFileName);
+    taos_free_result(tmpResult);
+    free(tmpCommand);
+    remove(".stables.tmp");
+    exit(-1);
+  }
+  
+  while ((row = taos_fetch_row(tmpResult)) != NULL) {  
+    memset(&tableRecord, 0, sizeof(STableRecord));
+    strncpy(tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX], fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
+    twrite(fd, &tableRecord, sizeof(STableRecord));
+  }  
+  
+  taos_free_result(tmpResult);
+  lseek(fd, 0, SEEK_SET);
+
+  while (read(fd, &tableRecord, sizeof(STableRecord)) > 0) {
+    (void)taosDumpStable(tableRecord.name, fp, taosCon);
+  }
+
+  tclose(fd);
+  remove(".stables.tmp");
+  
+  free(tmpCommand);
+  return 0;  
+}
+
+
+int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *taosCon) {
   TAOS_ROW row;
   int fd = -1;
   STableRecord tableRecord;
 
   taosDumpCreateDbClause(dbInfo, arguments->with_property, fp);
 
-  sprintf(command, "use %s", dbInfo->name);
-  if (taos_errno(taos_query(taos, command)) != 0) {
-    fprintf(stderr, "invalid database %s\n", dbInfo->name);
+  char* tmpCommand = (char *)malloc(COMMAND_SIZE);
+  if (tmpCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
     return -1;
   }
 
+  sprintf(tmpCommand, "use %s", dbInfo->name);
+  
+  TAOS_RES* tmpResult = taos_query(taosCon, tmpCommand);  
+  int32_t code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "invalid database %s\n", dbInfo->name);
+    free(tmpCommand);
+    taos_free_result(tmpResult);
+    return -1;
+  }
+  taos_free_result(tmpResult);
+
   fprintf(fp, "USE %s\n\n", dbInfo->name);
+  
+  (void)taosDumpCreateSuperTableClause(taosCon, dbInfo->name, fp);
 
-  sprintf(command, "show tables");
-  TAOS_RES* result = taos_query(taos,command);
-  int32_t code = taos_errno(result);
+  sprintf(tmpCommand, "show tables");
+  
+  tmpResult = taos_query(taosCon, tmpCommand);  
+  code = taos_errno(tmpResult);
   if (code != 0) {
-    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
-    taos_free_result(result);
+    fprintf(stderr, "failed to run command %s\n", tmpCommand);
+    free(tmpCommand);
+    taos_free_result(tmpResult);
     return -1;
   }
 
-  TAOS_FIELD *fields = taos_fetch_fields(result);
+  TAOS_FIELD *fields = taos_fetch_fields(tmpResult);
 
-  fd = open(".table.tmp", O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
-  if (fd == -1) {
-    fprintf(stderr, "failed to open temp file\n");
-    taos_free_result(result);
-    return -1;
-  }
+  int32_t  numOfTable  = 0;
+  int32_t  numOfThread = 0;
+  char     tmpFileName[TSDB_FILENAME_LEN + 1];
+  while ((row = taos_fetch_row(tmpResult)) != NULL) {
+    if (0 == numOfTable) {
+      memset(tmpFileName, 0, TSDB_FILENAME_LEN);
+      sprintf(tmpFileName, ".tables.tmp.%d", numOfThread);
+      fd = open(tmpFileName, O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
+      if (fd == -1) {
+        fprintf(stderr, "failed to open temp file: %s\n", tmpFileName);
+        taos_free_result(tmpResult);
+        for (int32_t loopCnt = 0; loopCnt < numOfThread; loopCnt++) {
+          sprintf(tmpFileName, ".tables.tmp.%d", loopCnt);
+          remove(tmpFileName);
+        }
+        free(tmpCommand);
+        return -1;
+      }
 
-  while ((row = taos_fetch_row(result)) != NULL) {
+      numOfThread++;
+    }
+  
     memset(&tableRecord, 0, sizeof(STableRecord));
     strncpy(tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX], fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
     strncpy(tableRecord.metric, (char *)row[TSDB_SHOW_TABLES_METRIC_INDEX], fields[TSDB_SHOW_TABLES_METRIC_INDEX].bytes);
 
     twrite(fd, &tableRecord, sizeof(STableRecord));
+
+    numOfTable++;
+
+    if (numOfTable >= arguments->table_batch) {
+      numOfTable = 0;
+      tclose(fd);
+      fd = -1;
+    }
   }
+  tclose(fd);
+  fd = -1;
+  taos_free_result(tmpResult);
 
-  taos_free_result(result);
-
-  (void)lseek(fd, 0, SEEK_SET);
-
-  STableRecord tableInfo;
-  while (1) {
-    memset(&tableInfo, 0, sizeof(STableRecord));
-    ssize_t ret = read(fd, &tableInfo, sizeof(STableRecord));
-    if (ret <= 0) break;
-    
-    tableInfo.name[sizeof(tableInfo.name) - 1] = 0;
-    tableInfo.metric[sizeof(tableInfo.metric) - 1] = 0;
-    taosDumpTable(tableInfo.name, tableInfo.metric, arguments, fp);
+  // start multi threads to dumpout
+  taosStartDumpOutWorkThreads(arguments, numOfThread, dbInfo->name);
+  for (int loopCnt = 0; loopCnt < numOfThread; loopCnt++) {
+    sprintf(tmpFileName, ".tables.tmp.%d", loopCnt);
+    remove(tmpFileName);
   }
-
-  close(fd);
-  (void)remove(".table.tmp");
+  
+  free(tmpCommand);
 
   return 0;
 }
 
-void taosDumpCreateTableClause(STableDef *tableDes, int numOfCols, SDumpArguments *arguments, FILE *fp) {
-  char *pstr = NULL;
-  pstr = buffer;
+void taosDumpCreateTableClause(STableDef *tableDes, int numOfCols, FILE *fp) {
   int counter = 0;
   int count_temp = 0;
 
-  pstr += sprintf(buffer, "CREATE TABLE IF NOT EXISTS %s", tableDes->name);
+  char* tmpBuf = (char *)malloc(COMMAND_SIZE);
+  if (tmpBuf == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return;
+  }
+
+  char* pstr = tmpBuf;
+
+  pstr += sprintf(tmpBuf, "CREATE TABLE IF NOT EXISTS %s", tableDes->name);
 
   for (; counter < numOfCols; counter++) {
     if (tableDes->cols[counter].note[0] != '\0') break;
@@ -699,19 +1258,27 @@ void taosDumpCreateTableClause(STableDef *tableDes, int numOfCols, SDumpArgument
     }
   }
 
-  pstr += sprintf(pstr, ")");
+  pstr += sprintf(pstr, ");");
 
-  fprintf(fp, "%s\n\n", buffer);
+  fprintf(fp, "%s\n", tmpBuf);
+
+  free(tmpBuf);
 }
 
-void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols, SDumpArguments *arguments,
-                                FILE *fp) {
-  char *pstr = NULL;
-  pstr = buffer;
+void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols, FILE *fp) {
   int counter = 0;
   int count_temp = 0;
 
-  pstr += sprintf(buffer, "CREATE TABLE IF NOT EXISTS %s USING %s TAGS (", tableDes->name, metric);
+  char* tmpBuf = (char *)malloc(COMMAND_SIZE);
+  if (tmpBuf == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return;
+  }
+
+  char *pstr = NULL;
+  pstr = tmpBuf;
+
+  pstr += sprintf(tmpBuf, "CREATE TABLE IF NOT EXISTS %s USING %s TAGS (", tableDes->name, metric);
 
   for (; counter < numOfCols; counter++) {
     if (tableDes->cols[counter].note[0] != '\0') break;
@@ -721,54 +1288,6 @@ void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols
   count_temp = counter;
 
   for (; counter < numOfCols; counter++) {
-    TAOS_ROW row = NULL;
-
-    sprintf(command, "select %s from %s limit 1", tableDes->cols[counter].field, tableDes->name);
-
-    TAOS_RES* result = taos_query(taos, command);
-    int32_t code = taos_errno(result);
-    if (code != 0) {
-      fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
-      return;
-    }
-
-    TAOS_FIELD *fields = taos_fetch_fields(result);
-
-    row = taos_fetch_row(result);
-    switch (fields[0].type) {
-      case TSDB_DATA_TYPE_BOOL:
-        sprintf(tableDes->cols[counter].note, "%d", ((((int)(*((char *)row[0]))) == 1) ? 1 : 0));
-        break;
-      case TSDB_DATA_TYPE_TINYINT:
-        sprintf(tableDes->cols[counter].note, "%d", (int)(*((char *)row[0])));
-        break;
-      case TSDB_DATA_TYPE_SMALLINT:
-        sprintf(tableDes->cols[counter].note, "%d", (int)(*((short *)row[0])));
-        break;
-      case TSDB_DATA_TYPE_INT:
-        sprintf(tableDes->cols[counter].note, "%d", *((int *)row[0]));
-        break;
-      case TSDB_DATA_TYPE_BIGINT:
-        sprintf(tableDes->cols[counter].note, "%" PRId64 "", *((int64_t *)row[0]));
-        break;
-      case TSDB_DATA_TYPE_FLOAT:
-        sprintf(tableDes->cols[counter].note, "%f", GET_FLOAT_VAL(row[0]));
-        break;
-      case TSDB_DATA_TYPE_DOUBLE:
-        sprintf(tableDes->cols[counter].note, "%f", GET_DOUBLE_VAL(row[0]));
-        break;
-      case TSDB_DATA_TYPE_TIMESTAMP:
-        sprintf(tableDes->cols[counter].note, "%" PRId64 "", *(int64_t *)row[0]);
-        break;
-      case TSDB_DATA_TYPE_BINARY:
-      case TSDB_DATA_TYPE_NCHAR:
-      default:
-        strncpy(tableDes->cols[counter].note, (char *)row[0], fields[0].bytes);
-        break;
-    }
-
-    taos_free_result(result);
-
     if (counter != count_temp) {
       if (strcasecmp(tableDes->cols[counter].type, "binary") == 0 ||
           strcasecmp(tableDes->cols[counter].type, "nchar") == 0) {
@@ -792,193 +1311,95 @@ void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols
     /* } */
   }
 
-  pstr += sprintf(pstr, ")");
+  pstr += sprintf(pstr, ");");
 
-  fprintf(fp, "%s\n\n", buffer);
+  fprintf(fp, "%s\n", tmpBuf);
+  free(tmpBuf);
 }
 
-int taosGetTableDes(char *table, STableDef *tableDes) {
-  TAOS_ROW row = NULL;
-  int count = 0;
-
-  sprintf(command, "describe %s", table);
-
-  TAOS_RES* result = taos_query(taos, command);
-  int32_t code = taos_errno(result);
-  if (code != 0) {
-    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
-    taos_free_result(result);
-    return -1;
-  }
-
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-
-  tstrncpy(tableDes->name, table, TSDB_COL_NAME_LEN);
-
-  while ((row = taos_fetch_row(result)) != NULL) {
-    strncpy(tableDes->cols[count].field, (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
-            fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
-    strncpy(tableDes->cols[count].type, (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
-            fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes);
-    tableDes->cols[count].length = *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
-    strncpy(tableDes->cols[count].note, (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
-            fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes);
-
-    count++;
-  }
-
-  taos_free_result(result);
-  result = NULL;
-
-  return count;
-}
-
-int32_t taosDumpTable(char *table, char *metric, SDumpArguments *arguments, FILE *fp) {
-  int count = 0;
-
-  STableDef *tableDes = (STableDef *)calloc(1, sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
-
-  if (metric != NULL && metric[0] != '\0') {  // dump metric definition
-    count = taosGetTableDes(metric, tableDes);
-
-    if (count < 0) {
-      free(tableDes);
-      return -1;
-    }
-
-    taosDumpCreateTableClause(tableDes, count, arguments, fp);
-
-    memset(tableDes, 0, sizeof(STableDef) + sizeof(SColDes) * TSDB_MAX_COLUMNS);
-
-    count = taosGetTableDes(table, tableDes);
-
-    if (count < 0) {
-      free(tableDes);
-      return -1;
-    }
-
-    taosDumpCreateMTableClause(tableDes, metric, count, arguments, fp);
-
-  } else {  // dump table definition
-    count = taosGetTableDes(table, tableDes);
-
-    if (count < 0) {
-      free(tableDes);
-      return -1;
-    }
-
-    taosDumpCreateTableClause(tableDes, count, arguments, fp);
-  }
-
-  free(tableDes);
-
-  return taosDumpTableData(fp, table, arguments);
-}
-
-int32_t taosDumpMetric(char *metric, SDumpArguments *arguments, FILE *fp) {
-  TAOS_ROW row = NULL;
-  int fd = -1;
-  STableRecord tableRecord;
-
-  //tstrncpy(tableRecord.metric, metric, TSDB_TABLE_NAME_LEN);
-
-  sprintf(command, "select tbname from %s", metric);
-  TAOS_RES* result = taos_query(taos, command);
-  int32_t code = taos_errno(result);
-  if (code != 0) {
-    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
-    taos_free_result(result);
-    return -1;
-  }
-
-  fd = open(".table.tmp", O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
-  if (fd < 0) {
-    fprintf(stderr, "failed to open temp file");
-    return -1;
-  }
-
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-
-  while ((row = taos_fetch_row(result)) != NULL) {
-    memset(&tableRecord, 0, sizeof(STableRecord));
-    tstrncpy(tableRecord.name, (char *)row[0], fields[0].bytes);
-    tstrncpy(tableRecord.metric, metric, TSDB_TABLE_NAME_LEN);
-    twrite(fd, &tableRecord, sizeof(STableRecord));
-  }
-
-  taos_free_result(result);
-  result = NULL;
-
-  (void)lseek(fd, 0, SEEK_SET);
-
-  //STableRecord tableInfo;
-  char tableName[TSDB_TABLE_NAME_LEN] ;
-  char metricName[TSDB_TABLE_NAME_LEN];
-  ssize_t ret;
-  while (1) {
-    //memset(&tableInfo, 0, sizeof(STableRecord));      
-    memset(tableName, 0, TSDB_TABLE_NAME_LEN);    
-    memset(metricName, 0, TSDB_TABLE_NAME_LEN);
-    //ssize_t ret = read(fd, &tableInfo, sizeof(STableRecord));
-    //if (ret <= 0) break;
-    ret = read(fd, tableName, TSDB_TABLE_NAME_LEN);
-    if (ret <= 0) break;
-    
-    ret = read(fd, metricName, TSDB_TABLE_NAME_LEN);
-    if (ret <= 0) break;
-    
-    //tableInfo.name[sizeof(tableInfo.name) - 1] = 0;
-    //tableInfo.metric[sizeof(tableInfo.metric) - 1] = 0;    
-    //taosDumpTable(tableInfo.name, tableInfo.metric, arguments, fp);
-    //tstrncpy(tableName, tableInfo.name, TSDB_TABLE_NAME_LEN-1);
-    //tstrncpy(metricName, tableInfo.metric, TSDB_TABLE_NAME_LEN-1);
-    taosDumpTable(tableName, metricName, arguments, fp);
-  }
-
-  close(fd);
-  (void)remove(".table.tmp");
-
-  return 0;
-}
-
-int taosDumpTableData(FILE *fp, char *tbname, SDumpArguments *arguments) {
+int taosDumpTableData(FILE *fp, char *tbname, struct arguments *arguments, TAOS* taosCon) {
   /* char       temp[MAX_COMMAND_SIZE] = "\0"; */
+  int64_t totalRows = 0;
   int count = 0;
   char *pstr = NULL;
   TAOS_ROW row = NULL;
   int numFields = 0;
   char *tbuf = NULL;
 
-  if (arguments->schemaonly) return 0;
-
-  sprintf(command, "select * from %s where _c0 >= %" PRId64 " and _c0 <= %" PRId64 " order by _c0 asc", tbname, arguments->start_time,
-          arguments->end_time);
-          
-  TAOS_RES* result = taos_query(taos, command);
-  int32_t code = taos_errno(result);
-  if (code != 0) {
-    fprintf(stderr, "failed to run command %s, reason: %s\n", command, taos_errstr(result));
-    taos_free_result(result);
+  char* tmpCommand = (char *)calloc(1, COMMAND_SIZE);
+  if (tmpCommand == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
     return -1;
   }
 
-  numFields = taos_field_count(result);
+  char* tmpBuffer = (char *)calloc(1, COMMAND_SIZE);
+  if (tmpBuffer == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    free(tmpCommand);
+    return -1;
+  }
+
+  pstr = tmpBuffer;
+
+  if (arguments->schemaonly) {
+    free(tmpCommand);
+    free(tmpBuffer);
+    return 0;
+  }
+  
+  sprintf(tmpCommand, 
+          "select * from %s where _c0 >= %" PRId64 " and _c0 <= %" PRId64 " order by _c0 asc", 
+          tbname, 
+          arguments->start_time,
+          arguments->end_time);
+  
+  TAOS_RES* tmpResult = taos_query(taosCon, tmpCommand);  
+  int32_t code = taos_errno(tmpResult);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, reason: %s\n", tmpCommand, taos_errstr(taosCon));
+    free(tmpCommand);
+    free(tmpBuffer);
+    taos_free_result(tmpResult);
+    return -1;
+  }
+
+  numFields = taos_field_count(taosCon);
   assert(numFields > 0);
-  TAOS_FIELD *fields = taos_fetch_fields(result);
+  TAOS_FIELD *fields = taos_fetch_fields(tmpResult);
   tbuf = (char *)malloc(COMMAND_SIZE);
   if (tbuf == NULL) {
     fprintf(stderr, "No enough memory\n");
+    free(tmpCommand);
+    free(tmpBuffer);
+    taos_free_result(tmpResult);
     return -1;
   }
 
+  char sqlStr[8] = "\0";
+  if (arguments->mysqlFlag) {
+    sprintf(sqlStr, "INSERT");
+  } else {
+    sprintf(sqlStr, "IMPORT");
+  }
+
+  int rowFlag = 0;
   count = 0;
-  while ((row = taos_fetch_row(result)) != NULL) {
-    pstr = buffer;
+  while ((row = taos_fetch_row(tmpResult)) != NULL) {
+    pstr = tmpBuffer;
 
     if (count == 0) {
-      pstr += sprintf(pstr, "INSERT INTO %s VALUES (", tbname);
-    } else {
-      pstr += sprintf(pstr, "(");
+      pstr += sprintf(pstr, "%s INTO %s VALUES (", sqlStr, tbname);
+    } else {      
+      if (arguments->mysqlFlag) {
+        if (0 == rowFlag) {
+          pstr += sprintf(pstr, "(");
+          rowFlag++;
+        } else {
+          pstr += sprintf(pstr, ", (");
+        }
+      } else {
+        pstr += sprintf(pstr, "(");
+      }
     }
 
     for (int col = 0; col < numFields; col++) {
@@ -1003,7 +1424,7 @@ int taosDumpTableData(FILE *fp, char *tbname, SDumpArguments *arguments) {
           pstr += sprintf(pstr, "%d", *((int *)row[col]));
           break;
         case TSDB_DATA_TYPE_BIGINT:
-          pstr += sprintf(pstr, "%" PRId64, *((int64_t *)row[col]));
+          pstr += sprintf(pstr, "%" PRId64 "", *((int64_t *)row[col]));
           break;
         case TSDB_DATA_TYPE_FLOAT:
           pstr += sprintf(pstr, "%f", GET_FLOAT_VAL(row[col]));
@@ -1022,34 +1443,52 @@ int taosDumpTableData(FILE *fp, char *tbname, SDumpArguments *arguments) {
           pstr += sprintf(pstr, "\'%s\'", tbuf);
           break;
         case TSDB_DATA_TYPE_TIMESTAMP:
-          pstr += sprintf(pstr, "%" PRId64, *(int64_t *)row[col]);
+          if (!arguments->mysqlFlag) {
+            pstr += sprintf(pstr, "%" PRId64 "", *(int64_t *)row[col]);
+          } else {
+            char buf[64] = "\0";
+            int64_t ts = *((int64_t *)row[col]);
+            time_t tt = (time_t)(ts / 1000);
+            struct tm *ptm = localtime(&tt);
+            strftime(buf, 64, "%y-%m-%d %H:%M:%S", ptm);
+            pstr += sprintf(pstr, "\'%s.%03d\'", buf, (int)(ts % 1000));
+          }
           break;
         default:
           break;
       }
     }
-    sprintf(pstr, ")");
 
+    pstr += sprintf(pstr, ") ");
+
+    totalRows++;
     count++;
-    fprintf(fp, "%s", buffer);
+    fprintf(fp, "%s", tmpBuffer);
 
     if (count >= arguments->data_batch) {
-      fprintf(fp, "\n");
+      fprintf(fp, ";\n");
       count = 0;
-    } else {
-      fprintf(fp, "\\\n");
-    }
+    } //else {
+      //fprintf(fp, "\\\n");
+    //}
   }
 
+  atomic_add_fetch_64(&totalDumpOutRows, totalRows);
+
   fprintf(fp, "\n");
 
-  if (tbuf) free(tbuf);
-  taos_free_result(result);
-  result = NULL;
+  if (tbuf) {
+    free(tbuf);
+  }
+  
+  taos_free_result(tmpResult);
+  tmpResult = NULL;
+  free(tmpCommand);
+  free(tmpBuffer);
   return 0;
 }
 
-int taosCheckParam(SDumpArguments *arguments) {
+int taosCheckParam(struct arguments *arguments) {
   if (arguments->all_databases && arguments->databases) {
     fprintf(stderr, "conflict option --all-databases and --databases\n");
     return -1;
@@ -1059,19 +1498,25 @@ int taosCheckParam(SDumpArguments *arguments) {
     fprintf(stderr, "start time is larger than end time\n");
     return -1;
   }
+  
   if (arguments->arg_list_len == 0) {
     if ((!arguments->all_databases) && (!arguments->isDumpIn)) {
       fprintf(stderr, "taosdump requires parameters\n");
       return -1;
     }
   }
-
-  if (arguments->isDumpIn && (strcmp(arguments->output, DEFAULT_DUMP_FILE) != 0)) {
-    fprintf(stderr, "duplicate parameter input and output file\n");
+/*
+  if (arguments->isDumpIn && (strcmp(arguments->outpath, DEFAULT_DUMP_FILE) != 0)) {
+    fprintf(stderr, "duplicate parameter input and output file path\n");
+    return -1;
+  }
+*/
+  if (!arguments->isDumpIn && arguments->encode != NULL) {
+    fprintf(stderr, "invalid option in dump out\n");
     return -1;
   }
 
-  if (!arguments->isDumpIn && arguments->encode != NULL) {
+  if (arguments->table_batch <= 0) {
     fprintf(stderr, "invalid option in dump out\n");
     return -1;
   }
@@ -1134,177 +1579,6 @@ void taosReplaceCtrlChar(char *str) {
   *pstr = '\0';
 }
 
-int taosDumpIn(SDumpArguments *arguments) {
-  assert(arguments->isDumpIn);
-
-  int     tsize = 0;
-  FILE *  fp = NULL;
-  char *  line = NULL;
-  _Bool   isRun = true;
-  size_t  line_size = 0;
-  char *  pstr = NULL, *lstr = NULL;
-  iconv_t cd = (iconv_t)-1;
-  size_t  inbytesleft = 0;
-  size_t  outbytesleft = COMMAND_SIZE;
-  char    fcharset[64];
-  char *  tcommand = NULL;
-
-  fp = fopen(arguments->input, "r");
-  if (fp == NULL) {
-    fprintf(stderr, "failed to open input file %s\n", arguments->input);
-    return -1;
-  }
-
-  taosLoadFileCharset(fp, fcharset);
-
-  taos = taos_connect(arguments->host, arguments->user, arguments->password, NULL, arguments->port);
-  if (taos == NULL) {
-    fprintf(stderr, "failed to connect to TDengine server\n");
-    goto _dumpin_exit_failure;
-  }
-
-  command = (char *)malloc(COMMAND_SIZE);
-  lcommand = (char *)malloc(COMMAND_SIZE);
-  if (command == NULL || lcommand == NULL) {
-    fprintf(stderr, "failed to connect to allocate memory\n");
-    goto _dumpin_exit_failure;
-  }
-
-  // Resolve locale
-  if (*fcharset != '\0') {
-    arguments->encode = fcharset;
-  }
-
-  if (arguments->encode != NULL && strcasecmp(tsCharset, arguments->encode) != 0) {
-    cd = iconv_open(tsCharset, arguments->encode);
-    if (cd == (iconv_t)-1) {
-      fprintf(stderr, "Failed to open iconv handle\n");
-      goto _dumpin_exit_failure;
-    }
-  }
-
-  pstr = command;
-  int64_t linenu = 0;
-  while (1) {
-    ssize_t size = getline(&line, &line_size, fp);
-    linenu++;
-    if (size <= 0) break;
-    if (size == 1) {
-      if (pstr != command) {
-        inbytesleft = pstr - command;
-        memset(lcommand, 0, COMMAND_SIZE);
-        pstr = command;
-        lstr = lcommand;
-        outbytesleft = COMMAND_SIZE;
-        if (cd != (iconv_t)-1) {
-          iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
-          tcommand = lcommand;
-        } else {
-          tcommand = command;
-        }
-        taosReplaceCtrlChar(tcommand);
-
-        TAOS_RES* result = taos_query(taos, tcommand);
-        if (taos_errno(result) != 0){
-          fprintf(stderr, "linenu: %" PRId64 " failed to run command %s reason:%s \ncontinue...\n", linenu, command,
-                  taos_errstr(result));
-          taos_free_result(result);
-        }
-
-        pstr = command;
-        pstr[0] = '\0';
-        tsize = 0;
-        isRun = true;
-      }
-
-      continue;
-    }
-
-    /* if (line[0] == '-' && line[1] == '-') continue; */
-
-    line[size - 1] = 0;
-
-    if (tsize + size - 1 > COMMAND_SIZE) {
-      fprintf(stderr, "command is too long\n");
-      goto _dumpin_exit_failure;
-    }
-
-    if (line[size - 2] == '\\') {
-      line[size - 2] = ' ';
-      isRun = false;
-    } else {
-      isRun = true;
-    }
-
-    memcpy(pstr, line, size - 1);
-    pstr += (size - 1);
-    *pstr = '\0';
-
-    if (!isRun) continue;
-
-    if (command != pstr && !isEmptyCommand(command)) {
-      inbytesleft = pstr - command;
-      memset(lcommand, 0, COMMAND_SIZE);
-      pstr = command;
-      lstr = lcommand;
-      outbytesleft = COMMAND_SIZE;
-      if (cd != (iconv_t)-1) {
-        iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
-        tcommand = lcommand;
-      } else {
-        tcommand = command;
-      }
-      taosReplaceCtrlChar(tcommand);
-      TAOS_RES* result = taos_query(taos, tcommand);
-      int32_t code = taos_errno(result);
-      if (code != 0) 
-      {
-        fprintf(stderr, "linenu:%" PRId64 " failed to run command %s reason: %s \ncontinue...\n", linenu, command,
-                taos_errstr(result));
-      }
-      taos_free_result(result);
-    }
-
-    pstr = command;
-    *pstr = '\0';
-    tsize = 0;
-  }
-
-  if (pstr != command) {
-    inbytesleft = pstr - command;
-    memset(lcommand, 0, COMMAND_SIZE);
-    pstr = command;
-    lstr = lcommand;
-    outbytesleft = COMMAND_SIZE;
-    if (cd != (iconv_t)-1) {
-      iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
-      tcommand = lcommand;
-    } else {
-      tcommand = command;
-    }
-    taosReplaceCtrlChar(lcommand);
-    if (taos_query(taos, tcommand) == NULL)
-      fprintf(stderr, "linenu:%" PRId64 " failed to run command %s reason:%s \ncontinue...\n", linenu, command,
-              taos_errstr(taos));
-  }
-
-  if (cd != (iconv_t)-1) iconv_close(cd);
-  tfree(line);
-  tfree(command);
-  tfree(lcommand);
-  taos_close(taos);
-  fclose(fp);
-  return 0;
-
-_dumpin_exit_failure:
-  if (cd != (iconv_t)-1) iconv_close(cd);
-  tfree(command);
-  tfree(lcommand);
-  taos_close(taos);
-  fclose(fp);
-  return -1;
-}
-
 char *ascii_literal_list[] = {
     "\\x00", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\x07", "\\x08", "\\t",   "\\n",   "\\x0b", "\\x0c",
     "\\r",   "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19",
@@ -1351,7 +1625,7 @@ int convertNCharToReadable(char *str, int size, char *buf, int bufsize) {
 
     if ((int)wc < 256) {
       pbuf = stpcpy(pbuf, ascii_literal_list[(int)wc]);
-    } else if (byte_width > 0) {
+    } else {
       memcpy(pbuf, pstr, byte_width);
       pbuf += byte_width;
     }
@@ -1399,3 +1673,453 @@ _exit_no_charset:
   tfree(line);
   return;
 }
+
+// ========  dumpIn support multi threads functions ================================//
+
+static char    **tsDumpInSqlFiles   = NULL;
+static int32_t   tsSqlFileNum = 0;
+static char      tsDbSqlFile[TSDB_FILENAME_LEN] = {0};
+static char      tsfCharset[64] = {0};
+static int taosGetFilesNum(const char *directoryName, const char *prefix)
+{
+  char cmd[1024] = { 0 };
+  sprintf(cmd, "ls %s/*.%s | wc -l ", directoryName, prefix);
+
+  FILE *fp = popen(cmd, "r");
+  if (fp == NULL) {
+    fprintf(stderr, "ERROR: failed to execute:%s, error:%s\n", cmd, strerror(errno));
+    exit(0);
+  }
+
+  int fileNum = 0;
+  if (fscanf(fp, "%d", &fileNum) != 1) {
+    fprintf(stderr, "ERROR: failed to execute:%s, parse result error\n", cmd);
+    exit(0);
+  }
+
+  if (fileNum <= 0) {
+    fprintf(stderr, "ERROR: directory:%s is empry\n", directoryName);
+    exit(0);
+  }
+
+  pclose(fp);
+  return fileNum;
+}
+
+static void taosParseDirectory(const char *directoryName, const char *prefix, char **fileArray, int totalFiles)
+{
+  char cmd[1024] = { 0 };
+  sprintf(cmd, "ls %s/*.%s | sort", directoryName, prefix);
+
+  FILE *fp = popen(cmd, "r");
+  if (fp == NULL) {
+    fprintf(stderr, "ERROR: failed to execute:%s, error:%s\n", cmd, strerror(errno));
+    exit(0);
+  }
+
+  int fileNum = 0;
+  while (fscanf(fp, "%s", fileArray[fileNum++])) {
+    if (strcmp(fileArray[fileNum-1], tsDbSqlFile) == 0) {
+      fileNum--;
+    }
+    if (fileNum >= totalFiles) {
+      break;
+    }
+  }
+
+  if (fileNum != totalFiles) {
+    fprintf(stderr, "ERROR: directory:%s changed while read\n", directoryName);
+    exit(0);
+  }
+
+  pclose(fp);
+}
+
+static void taosCheckTablesSQLFile(const char *directoryName)
+{
+  char cmd[1024] = { 0 };
+  sprintf(cmd, "ls %s/dbs.sql", directoryName);
+
+  FILE *fp = popen(cmd, "r");
+  if (fp == NULL) {
+    fprintf(stderr, "ERROR: failed to execute:%s, error:%s\n", cmd, strerror(errno));
+    exit(0);
+  }
+
+  while (fscanf(fp, "%s", tsDbSqlFile)) {
+    break;
+  }
+
+  pclose(fp);
+}
+
+static void taosMallocSQLFiles()
+{
+  tsDumpInSqlFiles = (char**)calloc(tsSqlFileNum, sizeof(char*));
+  for (int i = 0; i < tsSqlFileNum; i++) {
+    tsDumpInSqlFiles[i] = calloc(1, TSDB_FILENAME_LEN);
+  }
+}
+
+static void taosFreeSQLFiles()
+{
+  for (int i = 0; i < tsSqlFileNum; i++) {
+    tfree(tsDumpInSqlFiles[i]);
+  }
+  tfree(tsDumpInSqlFiles);
+}
+
+static void taosGetDirectoryFileList(char *inputDir)
+{
+  struct stat fileStat;
+  if (stat(inputDir, &fileStat) < 0) {
+    fprintf(stderr, "ERROR: %s not exist\n", inputDir);
+    exit(0);
+  }
+
+  if (fileStat.st_mode & S_IFDIR) {
+    taosCheckTablesSQLFile(inputDir);
+    tsSqlFileNum = taosGetFilesNum(inputDir, "sql");
+    int totalSQLFileNum = tsSqlFileNum;
+    if (tsDbSqlFile[0] != 0) {
+      tsSqlFileNum--;
+    }
+    taosMallocSQLFiles();
+    taosParseDirectory(inputDir, "sql", tsDumpInSqlFiles, tsSqlFileNum);
+    fprintf(stdout, "\nstart to dispose %d files in %s\n", totalSQLFileNum, inputDir);
+  }
+  else {
+    fprintf(stderr, "ERROR: %s is not a directory\n", inputDir);
+    exit(0);
+  }
+}
+
+static FILE*  taosOpenDumpInFile(char *fptr) {
+  wordexp_t full_path;
+
+  if (wordexp(fptr, &full_path, 0) != 0) {
+    fprintf(stderr, "ERROR: illegal file name: %s\n", fptr);
+    return NULL;
+  }
+
+  char *fname = full_path.we_wordv[0];
+  
+  if (access(fname, F_OK) != 0) {
+    fprintf(stderr, "ERROR: file %s is not exist\n", fptr);
+    
+    wordfree(&full_path);
+    return NULL;
+  }
+  
+  if (access(fname, R_OK) != 0) {
+    fprintf(stderr, "ERROR: file %s is not readable\n", fptr);
+    
+    wordfree(&full_path);
+    return NULL;
+  }
+
+  FILE *f = fopen(fname, "r");
+  if (f == NULL) {
+    fprintf(stderr, "ERROR: failed to open file %s\n", fname);
+    wordfree(&full_path);
+    return NULL;
+  }
+
+  wordfree(&full_path);
+
+  return f;
+}
+
+int taosDumpInOneFile_old(TAOS     * taos, FILE* fp, char* fcharset, char* encode) {
+  char     *command       = NULL;
+  char     *lcommand      = NULL;
+  int       tsize         = 0;
+  char     *line          = NULL;
+  _Bool     isRun         = true;
+  size_t    line_size     = 0;
+  char     *pstr          = NULL;
+  char     *lstr          = NULL;
+  size_t    inbytesleft   = 0;
+  size_t    outbytesleft  = COMMAND_SIZE;
+  char     *tcommand      = NULL;
+  char     *charsetOfFile = NULL;
+  iconv_t   cd            = (iconv_t)(-1);
+
+  command  = (char *)malloc(COMMAND_SIZE);
+  lcommand = (char *)malloc(COMMAND_SIZE);
+  if (command == NULL || lcommand == NULL) {
+    fprintf(stderr, "failed to connect to allocate memory\n");
+    goto _dumpin_exit_failure;
+  }
+
+  // Resolve locale
+  if (*fcharset != '\0') {
+    charsetOfFile = fcharset;
+  } else {
+    charsetOfFile = encode;
+  }
+
+  if (charsetOfFile != NULL && strcasecmp(tsCharset, charsetOfFile) != 0) {
+    cd = iconv_open(tsCharset, charsetOfFile);
+    if (cd == ((iconv_t)(-1))) {
+      fprintf(stderr, "Failed to open iconv handle\n");
+      goto _dumpin_exit_failure;
+    }
+  }
+
+  pstr = command;
+  int64_t linenu = 0;
+  while (1) {
+    ssize_t size = getline(&line, &line_size, fp);
+    linenu++;
+    if (size <= 0) break;
+    if (size == 1) {
+      if (pstr != command) {
+        inbytesleft = pstr - command;
+        memset(lcommand, 0, COMMAND_SIZE);
+        pstr = command;
+        lstr = lcommand;
+        outbytesleft = COMMAND_SIZE;
+        if (cd != ((iconv_t)(-1))) {
+          iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
+          tcommand = lcommand;
+        } else {
+          tcommand = command;
+        }
+        
+        taosReplaceCtrlChar(tcommand);
+        
+        if (queryDB(taos, tcommand) != 0) {
+          fprintf(stderr, "error sql: linenu: %" PRId64 " failed\n", linenu);
+          exit(0);
+        }
+        
+        pstr = command;
+        pstr[0] = '\0';
+        tsize = 0;
+        isRun = true;
+      }
+
+      continue;
+    }
+
+    /* if (line[0] == '-' && line[1] == '-') continue; */
+
+    line[size - 1] = 0;
+
+    if (tsize + size - 1 > COMMAND_SIZE) {
+      fprintf(stderr, "command is too long\n");
+      goto _dumpin_exit_failure;
+    }
+
+    if (line[size - 2] == '\\') {
+      line[size - 2] = ' ';
+      isRun = false;
+    } else {
+      isRun = true;
+    }
+
+    memcpy(pstr, line, size - 1);
+    pstr += (size - 1);
+    *pstr = '\0';
+
+    if (!isRun) continue;
+
+    if (command != pstr && !isEmptyCommand(command)) {
+      inbytesleft = pstr - command;
+      memset(lcommand, 0, COMMAND_SIZE);
+      pstr = command;
+      lstr = lcommand;
+      outbytesleft = COMMAND_SIZE;
+      if (cd != ((iconv_t)(-1))) {
+        iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
+        tcommand = lcommand;
+      } else {
+        tcommand = command;
+      }
+      taosReplaceCtrlChar(tcommand);
+      if (queryDB(taos, tcommand) != 0) {
+        fprintf(stderr, "error sql: linenu:%" PRId64 " failed\n", linenu);
+        exit(0); 
+      }
+    }
+
+    pstr = command;
+    *pstr = '\0';
+    tsize = 0;
+  }
+
+  if (pstr != command) {
+    inbytesleft = pstr - command;
+    memset(lcommand, 0, COMMAND_SIZE);
+    pstr = command;
+    lstr = lcommand;
+    outbytesleft = COMMAND_SIZE;
+    if (cd != ((iconv_t)(-1))) {
+      iconv(cd, &pstr, &inbytesleft, &lstr, &outbytesleft);
+      tcommand = lcommand;
+    } else {
+      tcommand = command;
+    }
+    taosReplaceCtrlChar(lcommand);
+    if (queryDB(taos, tcommand) != 0)
+      fprintf(stderr, "error sql: linenu:%" PRId64 " failed \n", linenu);
+  }
+
+  if (cd != ((iconv_t)(-1))) iconv_close(cd);
+  tfree(line);
+  tfree(command);
+  tfree(lcommand);
+  taos_close(taos);
+  fclose(fp);
+  return 0;
+
+_dumpin_exit_failure:
+  if (cd != ((iconv_t)(-1))) iconv_close(cd);
+  tfree(command);
+  tfree(lcommand);
+  taos_close(taos);
+  fclose(fp);
+  return -1;
+}
+
+int taosDumpInOneFile(TAOS     * taos, FILE* fp, char* fcharset, char* encode, char* fileName) {
+  int       read_len = 0;
+  char *    cmd      = NULL;
+  size_t    cmd_len  = 0;
+  char *    line     = NULL;
+  size_t    line_len = 0;
+
+  cmd  = (char *)malloc(COMMAND_SIZE);
+  if (cmd == NULL) {
+    fprintf(stderr, "failed to allocate memory\n");
+    return -1;
+  }
+
+  int lineNo = 0;
+  while ((read_len = getline(&line, &line_len, fp)) != -1) {
+    ++lineNo;
+    if (read_len >= COMMAND_SIZE) continue;
+    line[--read_len] = '\0';
+
+    //if (read_len == 0 || isCommentLine(line)) {  // line starts with #
+    if (read_len == 0 ) { 
+      continue;
+    }
+
+    if (line[read_len - 1] == '\\') {
+      line[read_len - 1] = ' ';
+      memcpy(cmd + cmd_len, line, read_len);
+      cmd_len += read_len;
+      continue;
+    }
+
+    memcpy(cmd + cmd_len, line, read_len);
+    if (queryDB(taos, cmd)) {
+      fprintf(stderr, "error sql: linenu:%d, file:%s\n", lineNo, fileName);
+    }
+
+    memset(cmd, 0, COMMAND_SIZE);
+    cmd_len = 0;
+  }
+
+  tfree(cmd);
+  tfree(line);
+  fclose(fp);
+  return 0;
+}
+
+void* taosDumpInWorkThreadFp(void *arg)
+{
+  SThreadParaObj *pThread = (SThreadParaObj*)arg;
+  for (int32_t f = 0; f < tsSqlFileNum; ++f) {
+    if (f % pThread->totalThreads == pThread->threadIndex) {
+      char *SQLFileName = tsDumpInSqlFiles[f];
+      FILE* fp = taosOpenDumpInFile(SQLFileName);
+      if (NULL == fp) {
+        continue;
+      }
+      fprintf(stderr, "Success Open input file: %s\n", SQLFileName);
+      taosDumpInOneFile(pThread->taosCon, fp, tsfCharset, tsArguments.encode, SQLFileName);
+    }
+  }
+
+  return NULL;
+}
+
+static void taosStartDumpInWorkThreads(struct arguments *args)
+{
+  pthread_attr_t  thattr;
+  SThreadParaObj *pThread;
+  int32_t         totalThreads = args->thread_num;
+
+  if (totalThreads > tsSqlFileNum) {
+    totalThreads = tsSqlFileNum;
+  }
+  
+  SThreadParaObj *threadObj = (SThreadParaObj *)calloc(totalThreads, sizeof(SThreadParaObj));
+  for (int32_t t = 0; t < totalThreads; ++t) {
+    pThread = threadObj + t;
+    pThread->threadIndex = t;
+    pThread->totalThreads = totalThreads;
+    pThread->taosCon = taos_connect(args->host, args->user, args->password, NULL, args->port);
+    if (pThread->taosCon == NULL) {
+      fprintf(stderr, "ERROR: thread:%d failed connect to TDengine, error:%s\n", pThread->threadIndex, taos_errstr(pThread->taosCon));
+      exit(0);
+    }
+
+    pthread_attr_init(&thattr);
+    pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+
+    if (pthread_create(&(pThread->threadID), &thattr, taosDumpInWorkThreadFp, (void*)pThread) != 0) {
+      fprintf(stderr, "ERROR: thread:%d failed to start\n", pThread->threadIndex);
+      exit(0);
+    }
+  }
+
+  for (int t = 0; t < totalThreads; ++t) {
+    pthread_join(threadObj[t].threadID, NULL);
+  }
+
+  for (int t = 0; t < totalThreads; ++t) {
+    taos_close(threadObj[t].taosCon);
+  }
+  free(threadObj);
+}
+
+
+int taosDumpIn(struct arguments *arguments) {
+  assert(arguments->isDumpIn);
+  
+  TAOS     *taos    = NULL;
+  FILE     *fp      = NULL;
+
+  taos = taos_connect(arguments->host, arguments->user, arguments->password, NULL, arguments->port);
+  if (taos == NULL) {
+    fprintf(stderr, "failed to connect to TDengine server\n");
+    return -1;
+  }
+
+  taosGetDirectoryFileList(arguments->inpath);
+
+  if (tsDbSqlFile[0] != 0) {
+    fp = taosOpenDumpInFile(tsDbSqlFile);
+    if (NULL == fp) {
+      fprintf(stderr, "failed to open input file %s\n", tsDbSqlFile);
+      return -1;
+    }
+    fprintf(stderr, "Success Open input file: %s\n", tsDbSqlFile);
+    
+    taosLoadFileCharset(fp, tsfCharset);
+    
+    taosDumpInOneFile(taos, fp, tsfCharset, arguments->encode, tsDbSqlFile);
+  }
+
+  taosStartDumpInWorkThreads(arguments);
+
+  taos_close(taos);
+  taosFreeSQLFiles();
+  return 0;
+}
+
+
diff --git a/src/kit/taosmigrate/taosmigrate.c b/src/kit/taosmigrate/taosmigrate.c
index b7bf6fc1ba..599cc49334 100644
--- a/src/kit/taosmigrate/taosmigrate.c
+++ b/src/kit/taosmigrate/taosmigrate.c
@@ -51,6 +51,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
       break;
     case 'f':
       arguments->fqdn = arg;
+      break;
     case 'g':
       arguments->dnodeGroups = arg;
       break;
diff --git a/src/kit/taosmigrate/taosmigrateMnodeWal.c b/src/kit/taosmigrate/taosmigrateMnodeWal.c
index 6315ff99f7..28e2b7772b 100644
--- a/src/kit/taosmigrate/taosmigrateMnodeWal.c
+++ b/src/kit/taosmigrate/taosmigrateMnodeWal.c
@@ -96,6 +96,7 @@ void walModWalFile(char* walfile) {
   if (wfd < 0) {
     printf("wal:%s, failed to open(%s)\n", newWalFile, strerror(errno));
     free(buffer);
+    close(rfd);
     return ;
   }
 
@@ -116,6 +117,11 @@ void walModWalFile(char* walfile) {
       break;
     } 
 
+    if (pHead->len >= 1024000 - sizeof(SWalHead)) {
+      printf("wal:%s, SWalHead.len(%d) overflow, skip the rest of file\n", walfile, pHead->len);
+      break;
+    } 
+
     ret = read(rfd, pHead->cont, pHead->len);
     if ( ret != pHead->len) {
       printf("wal:%s, failed to read body, skip, len:%d ret:%d\n", walfile, pHead->len, ret);
diff --git a/src/kit/taosmigrate/taosmigrateVnodeCfg.c b/src/kit/taosmigrate/taosmigrateVnodeCfg.c
index 1cb2fee353..b925fb10aa 100644
--- a/src/kit/taosmigrate/taosmigrateVnodeCfg.c
+++ b/src/kit/taosmigrate/taosmigrateVnodeCfg.c
@@ -99,6 +99,8 @@ static int32_t readVnodeCfg(SVnodeObj *pVnode, char* cfgFile)
     goto PARSE_OVER;
   }
 
+  content[maxLen] = (char)0;
+
   root = cJSON_Parse(content);
   if (root == NULL) {
     printf("failed to json parse %s, invalid json format\n", cfgFile);

From 2bba1ed59d4da40d1e3f54eaa707169c353625da Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 14:12:14 +0800
Subject: [PATCH 71/87] [fix bug]

---
 src/kit/taosmigrate/taosmigrate.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/kit/taosmigrate/taosmigrate.c b/src/kit/taosmigrate/taosmigrate.c
index 599cc49334..b80ca44a10 100644
--- a/src/kit/taosmigrate/taosmigrate.c
+++ b/src/kit/taosmigrate/taosmigrate.c
@@ -40,7 +40,7 @@ struct arguments {
 static error_t parse_opt(int key, char *arg, struct argp_state *state) {
   struct arguments *arguments = state->input;
   switch (key) {
-    case 'w':
+    case 'r':
       arguments->dataDir = arg;
       break;
     case 'd':

From 43600966541d4662f1ebb6f8e23c66a02cae58c1 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Wed, 8 Jul 2020 06:42:37 +0000
Subject: [PATCH 72/87] Now crash_gen is able to manage the start/stop/restart
 of taosd

---
 tests/pytest/crash_gen.py | 203 +++++++++++++++++++++++++++++++-------
 1 file changed, 167 insertions(+), 36 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index 49c428b7f1..afe61128a5 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -1629,73 +1629,204 @@ class MyLoggingAdapter(logging.LoggerAdapter):
         # return '[%s] %s' % (self.extra['connid'], msg), kwargs
 
 class SvcManager:    
-    
+    MAX_QUEUE_SIZE = 30
+
     def __init__(self):
         print("Starting service manager")
         signal.signal(signal.SIGTERM, self.sigIntHandler)
         signal.signal(signal.SIGINT, self.sigIntHandler)
+        signal.signal(signal.SIGUSR1, self.sigUsrHandler)
         self.ioThread = None
         self.subProcess = None
         self.shouldStop = False
-        self.status = MainExec.STATUS_RUNNING
+        # self.status = MainExec.STATUS_RUNNING # set inside _startTaosService()
 
     def svcOutputReader(self, out: IO, queue):
-        # print("This is the svcOutput Reader...")
-        for line in out : # iter(out.readline, b''):
+        # Important Reference: https://stackoverflow.com/questions/375427/non-blocking-read-on-a-subprocess-pipe-in-python
+        print("This is the svcOutput Reader...")
+        # for line in out : 
+        for line in iter(out.readline, b''):
             # print("Finished reading a line: {}".format(line))
-            queue.put(line.rstrip()) # get rid of new lines
-        print("No more output from incoming IO") # meaning sub process must have died
+            # print("Adding item to queue...")
+            line = line.decode("utf-8").rstrip()
+            queue.put(line) # This might block, and then causing "out" buffer to block            
+            print("_i", end="", flush=True) 
+
+            # Trim the queue if necessary
+            oneTenthQSize = self.MAX_QUEUE_SIZE // 10
+            if (queue.qsize() >= (self.MAX_QUEUE_SIZE - oneTenthQSize) ) : # 90% full?
+                print("Triming IPC queue by: {}".format(oneTenthQSize))
+                for i in range(0, oneTenthQSize) :
+                    try:
+                        queue.get_nowait()
+                    except Empty:
+                        break # break out of for loop, no more trimming    
+
+            if self.shouldStop :
+                print("Stopping to read output from sub process")
+                break
+
+            # queue.put(line)
+        print("No more output (most likely) from IO thread managing TDengine service") # meaning sub process must have died
         out.close()
 
-    def sigIntHandler(self, signalNumber, frame):
-        if self.status != MainExec.STATUS_RUNNING :
-            print("Ignoring repeated SIGINT...")
-            return # do nothing if it's already not running
-        self.status = MainExec.STATUS_STOPPING # immediately set our status
+    def _doMenu(self):
+        choice = ""
+        while True:
+            print("\nInterrupting Service Program, Choose an Action: ")
+            print("1: Resume")
+            print("2: Terminate")
+            print("3: Restart")
+            # Remember to update the if range below
+            # print("Enter Choice: ", end="", flush=True)            
+            while choice == "":
+                choice = input("Enter Choice: ")
+                if choice != "":
+                    break # done with reading repeated input
+            if choice in ["1", "2", "3"]: 
+                break # we are done with whole method
+            print("Invalid choice, please try again.")
+            choice = "" # reset
+        return choice
 
-        print("Terminating program...")
-        self.subProcess.send_signal(signal.SIGINT)
-        self.shouldStop = True
-        self.joinIoThread()
+    def sigUsrHandler(self, signalNumber, frame) :
+        print("Interrupting main thread execution upon SIGUSR1")
+        if self.status != MainExec.STATUS_RUNNING :
+            print("Ignoring repeated SIG...")
+            return # do nothing if it's already not running
+        self.status = MainExec.STATUS_STOPPING
+
+        choice = self._doMenu()
+        if choice == "1" :
+            self.sigHandlerResume() # TODO: can the sub-process be blocked due to us not reading from queue?
+        elif choice == "2" :
+            self._stopTaosService()
+        elif choice == "3" :
+            self._stopTaosService()
+            self._startTaosService()
+        else:
+            raise RuntimeError("Invalid menu choice: {}".format(choice))
+
+    def sigIntHandler(self, signalNumber, frame):
+        print("Sig INT Handler starting...")
+        if self.status != MainExec.STATUS_RUNNING :
+            print("Ignoring repeated SIG_INT...")
+            return
+
+        self.status = MainExec.STATUS_STOPPING # immediately set our status    
+        self._stopTaosService()  
+        print("INT signal handler returning...")  
+
+    def sigHandlerResume(self) :
+        print("Resuming TDengine service manager thread (main thread)...\n\n")
+        self.status = MainExec.STATUS_RUNNING
 
     def joinIoThread(self):
         if self.ioThread :
             self.ioThread.join()
-            self.ioThread = None        
+            self.ioThread = None   
+        else :
+            print("Joining empty thread, doing nothing")
+    
+    def _procIpcBatch(self):
+        # Process all the output generated by the underlying sub process, managed by IO thread
+        while True :
+            try:  
+                line = self.ipcQueue.get_nowait() # getting output at fast speed   
+                print("_o", end="", flush=True)                 
+            except Empty:
+                # time.sleep(2.3) # wait only if there's no output
+                # no more output
+                return # we are done with THIS BATCH
+            else: # got line
+                print(line)
 
-    def run(self):
+    def _procIpcAll(self):
+        while True :
+            print("<<", end="", flush=True)
+            self._procIpcBatch() # process one batch
+
+            # check if the ioThread is still running
+            if (not self.ioThread) or (not self.ioThread.is_alive()):
+                print("IO Thread (with subprocess) has ended, main thread now exiting...")
+                self._stopTaosService()
+                self._procIpcBatch() # one more batch
+                return # TODO: maybe one last batch?
+
+            # Maybe handler says we should exit now
+            if self.shouldStop:
+                print("Main thread ending all IPC processing with IOThread/SubProcess")
+                self._procIpcBatch() # one more batch
+                return
+
+            print(">>", end="", flush=True)
+            time.sleep(0.5)
+
+    def _startTaosService(self):
         ON_POSIX = 'posix' in sys.builtin_module_names
         svcCmd = ['../../build/build/bin/taosd', '-c', '../../build/test/cfg']
         # svcCmd = ['vmstat', '1']
-        self.subProcess = subprocess.Popen(svcCmd, stdout=subprocess.PIPE, bufsize=1, close_fds=ON_POSIX, text=True)
-        q = Queue()
-        self.ioThread = threading.Thread(target=self.svcOutputReader, args=(self.subProcess.stdout, q))
+        if self.subProcess : # already there
+            raise RuntimeError("Corrupt process state")
+
+        self.subProcess = subprocess.Popen(
+            svcCmd, 
+            stdout=subprocess.PIPE, 
+            # bufsize=1, # not supported in binary mode
+            close_fds=ON_POSIX) # had text=True, which interferred with reading EOF
+        self.ipcQueue = Queue()
+
+        if self.ioThread :
+            raise RuntimeError("Corrupt thread state")
+        self.ioThread = threading.Thread(target=self.svcOutputReader, args=(self.subProcess.stdout, self.ipcQueue))
         self.ioThread.daemon = True # thread dies with the program
         self.ioThread.start()
 
+        self.shouldStop = False # don't let the main loop stop
+        self.status = MainExec.STATUS_RUNNING
+
+    def _stopTaosService(self):
+        # can be called from both main thread or signal handler
+        print("Terminating TDengine service running as the sub process...")
+        # Linux will send Control-C generated SIGINT to the TDengine process already, ref: https://unix.stackexchange.com/questions/176235/fork-and-how-signals-are-delivered-to-processes
+        if not self.subProcess :
+            print("Process already stopped")
+            return
+
+        retCode = self.subProcess.poll()
+        if retCode : # valid return code, process ended
+            self.subProcess = None
+        else: # process still alive, let's interrupt it
+            print("Sub process still running, sending SIG_INT and waiting for it to stop...")
+            self.subProcess.send_signal(signal.SIGINT) # sub process should end, then IPC queue should end, causing IO thread to end
+            try :
+                self.subProcess.wait(10)
+            except subprocess.TimeoutExpired as err:
+                print("Time out waiting for TDengine service process to exit")
+            else:
+                print("Sub process has ended")
+                self.subProcess = None
+
+        if self.subProcess and (not self.subProcess.poll()):
+            print("Sub process is still running... pid = {}".format(self.subProcess.pid))
+            
+        self.shouldStop = True
+        self.joinIoThread()
+
+    def run(self):
+        self._startTaosService()
+
         # proc = subprocess.Popen(['echo', '"to stdout"'], 
         #                 stdout=subprocess.PIPE,
         #                 )
         # stdout_value = proc.communicate()[0]
         # print('\tstdout: {}'.format(repr(stdout_value)))
 
-        while True :
-            try:  
-                line = q.get_nowait() # getting output at fast speed                    
-            except Empty:
-                # print('no output yet')
-                time.sleep(2.3) # wait only if there's no output
-            else: # got line
-                print(line)
-            # print("----end of iteration----")
-            if self.shouldStop:
-                print("Ending main Svc thread")
-                break
+        self._procIpcAll()
 
-        print("end of loop")
-        
-        self.joinIoThread()
-        print("Finished")
+        print("End of loop reading from IPC queue")
+        self.joinIoThread() # should have started already
+        print("SvcManager Run Finished")
 
 class ClientManager:
     def __init__(self):

From 86e087920d1293900b04863fd9996e4b20522f22 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 15:09:45 +0800
Subject: [PATCH 73/87] [TD-853] change error code while vnode not ready

---
 src/dnode/src/dnodeMgmt.c   |  1 +
 src/mnode/src/mnodeVgroup.c |  4 ++--
 src/util/src/tqueue.c       |  4 +++-
 src/vnode/src/vnodeMain.c   | 14 ++++++++++----
 4 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c
index 9c85d4341b..4f489d2af2 100644
--- a/src/dnode/src/dnodeMgmt.c
+++ b/src/dnode/src/dnodeMgmt.c
@@ -402,6 +402,7 @@ static int32_t dnodeProcessCreateVnodeMsg(SRpcMsg *rpcMsg) {
 
   void *pVnode = vnodeAcquireVnode(pCreate->cfg.vgId);
   if (pVnode != NULL) {
+    dDebug("vgId:%d, already exist, processed as alter msg", pCreate->cfg.vgId);
     int32_t code = vnodeAlter(pVnode, pCreate);
     vnodeRelease(pVnode);
     return code;
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index 8fb1b749c2..64e45b3f99 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -696,9 +696,9 @@ static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
   if (rpcMsg->ahandle == NULL) return;
 
   SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
-  mnodeMsg->received++;
+  atomic_add_fetch_8(&mnodeMsg->received, 1);
   if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    mnodeMsg->successed++;
+    atomic_add_fetch_8(&mnodeMsg->successed, 1);
   } else {
     mnodeMsg->code = rpcMsg->code;
   }
diff --git a/src/util/src/tqueue.c b/src/util/src/tqueue.c
index f4f7904968..d9abf0d7c3 100644
--- a/src/util/src/tqueue.c
+++ b/src/util/src/tqueue.c
@@ -93,16 +93,18 @@ void taosCloseQueue(taos_queue param) {
 
 void *taosAllocateQitem(int size) {
   STaosQnode *pNode = (STaosQnode *)calloc(sizeof(STaosQnode) + size, 1);
+  
   if (pNode == NULL) return NULL;
+  uTrace("item:%p, node:%p is allocated", pNode->item, pNode);
   return (void *)pNode->item;
 }
 
 void taosFreeQitem(void *param) {
   if (param == NULL) return;
 
-  uTrace("item:%p is freed", param);
   char *temp = (char *)param;
   temp -= sizeof(STaosQnode);
+  uTrace("item:%p, node:%p is freed", param, temp);
   free(temp);
 }
 
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 1c96ba543c..18c9ebf2e1 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -161,11 +161,17 @@ int32_t vnodeDrop(int32_t vgId) {
 int32_t vnodeAlter(void *param, SMDCreateVnodeMsg *pVnodeCfg) {
   SVnodeObj *pVnode = param;
 
-  if (pVnode->status != TAOS_VN_STATUS_READY) 
-    return TSDB_CODE_VND_INVALID_STATUS;
+  // vnode in non-ready state and still needs to return success instead of TSDB_CODE_VND_INVALID_STATUS
+  // cfgVersion can be corrected by status msg
+  if (pVnode->status != TAOS_VN_STATUS_READY) {
+    vDebug("vgId:%d, vnode is not ready, do alter operation later", pVnode->vgId);
+    return TSDB_CODE_SUCCESS;
+  }
 
-  if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) 
-    return TSDB_CODE_VND_NOT_SYNCED;
+  // the vnode may always fail to synchronize because of it in low cfgVersion
+  // so cannot use the following codes
+  // if (pVnode->syncCfg.replica > 1 && pVnode->role == TAOS_SYNC_ROLE_UNSYNCED) 
+  //   return TSDB_CODE_VND_NOT_SYNCED;
 
   pVnode->status = TAOS_VN_STATUS_UPDATING;
 

From 85ddff090a4c4ad55d060825e941d9a962fe3097 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 15:23:37 +0800
Subject: [PATCH 74/87] refactor pathfinding in util/dnodes.py

---
 tests/pytest/util/dnodes.py | 37 ++++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index 370af1ba13..788f26a262 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -190,32 +190,31 @@ class TDDnode:
             "dnode:%d is deployed and configured by %s" %
             (self.index, self.cfgPath))
 
-    def start(self):
+    def getBuildPath(self):
         selfPath = os.path.dirname(os.path.realpath(__file__))
-        binPath = ""
 
         if ("community" in selfPath):
-            projPath = selfPath + "/../../../../"
-
-            for root, dirs, files in os.walk(projPath):
-                if ("taosd" in files):
-                    rootRealPath = os.path.dirname(os.path.realpath(root))
-                    if ("packaging" not in rootRealPath):
-                        binPath = os.path.join(root, "taosd")
-                        break
+            projPath = selfPath[:selfPath.find("community")]
         else:
-            projPath = selfPath + "/../../../"
-            for root, dirs, files in os.walk(projPath):
-                if ("taosd" in files):
-                    rootRealPath = os.path.dirname(os.path.realpath(root))
-                    if ("packaging" not in rootRealPath):
-                        binPath = os.path.join(root, "taosd")
-                        break
+            projPath = selfPath[:selfPath.find("tests")]
 
-        if (binPath == ""):
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:root.find("build")]
+                    break
+        return buildPath
+
+    def start(self):
+        buildPath = self.getBuildPath()
+
+        if (buildPath == ""):
             tdLog.exit("taosd not found!")
         else:
-            tdLog.info("taosd found in %s" % rootRealPath)
+            tdLog.info("taosd found in %s" % buildPath)
+
+        binPath = buildPath + "/build/bin/taosd"
 
         if self.deployed == 0:
             tdLog.exit("dnode:%d is not deployed" % (self.index))

From 84ff50b61d5e18bc1a3f3714fca7778ad17d3001 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 8 Jul 2020 15:35:17 +0800
Subject: [PATCH 75/87] [TD-873]

---
 src/client/src/tscSQLParser.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index ec4f77b13e..9553af79e2 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -90,6 +90,7 @@ static int32_t validateSqlFunctionInStreamSql(SSqlCmd* pCmd, SQueryInfo* pQueryI
 static int32_t buildArithmeticExprString(tSQLExpr* pExpr, char** exprString);
 static int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);
 static int32_t validateArithmeticSQLExpr(SSqlCmd* pCmd, tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnList* pList, int32_t* type);
+static int32_t validateEp(char* ep);
 static int32_t validateDNodeConfig(tDCLSQL* pOptions);
 static int32_t validateLocalConfig(tDCLSQL* pOptions);
 static int32_t validateColumnName(char* name);
@@ -359,6 +360,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_CFG_DNODE: {
       const char* msg2 = "invalid configure options or values";
+      const char* msg3 = "invalid dnode ep";
 
       /* validate the ip address */
       tDCLSQL* pDCL = pInfo->pDCLInfo;
@@ -375,6 +377,10 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       
       strncpy(pCfg->ep, pDCL->a[0].z, pDCL->a[0].n);
 
+      if (validateEp(pCfg->ep) != TSDB_CODE_SUCCESS) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      }
+
       strncpy(pCfg->config, pDCL->a[1].z, pDCL->a[1].n);
 
       if (pDCL->nTokens == 3) {
@@ -4629,6 +4635,24 @@ typedef struct SDNodeDynConfOption {
   int32_t len;   // name string length
 } SDNodeDynConfOption;
 
+
+int32_t validateEp(char* ep) {
+  char buf[TSDB_EP_LEN + 1] = {0};
+  tstrncpy(buf, ep, TSDB_EP_LEN);
+
+  char *pos = strchr(buf, ':');
+  if (NULL == pos) {   
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+  
+  uint16_t port = atoi(pos+1);
+  if (0 == port) {   
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }  
+
+  return TSDB_CODE_SUCCESS;   
+}
+
 int32_t validateDNodeConfig(tDCLSQL* pOptions) {
   if (pOptions->nTokens < 2 || pOptions->nTokens > 3) {
     return TSDB_CODE_TSC_INVALID_SQL;

From 44bc7056da3be24b6ab4c7d16c95452f6234db6f Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 15:55:10 +0800
Subject: [PATCH 76/87] turn on output for debug.

---
 tests/test-all.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test-all.sh b/tests/test-all.sh
index 275c6b1677..26005c8bc4 100755
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
@@ -27,7 +27,7 @@ function runPyCaseOneByOne {
       if [[ $line != *sleep* ]]; then
         case=`echo $line|awk '{print $NF}'`
         start_time=`date +%s`
-        $line > /dev/null 2>&1 && \
+        $line && \
           echo -e "${GREEN}$case success${NC}" | tee -a pytest-out.log || \
           echo -e "${RED}$case failed${NC}" | tee -a pytest-out.log
         end_time=`date +%s`

From 669f5dcad7f1396d9a6f5c41f9ea0daf295d2b3b Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 16:00:34 +0800
Subject: [PATCH 77/87] cleanup mnode timer before close table

---
 src/mnode/src/mnodeAcct.c   | 1 +
 src/mnode/src/mnodeDb.c     | 1 +
 src/mnode/src/mnodeDnode.c  | 1 +
 src/mnode/src/mnodeMain.c   | 4 ++--
 src/mnode/src/mnodeMnode.c  | 1 +
 src/mnode/src/mnodeTable.c  | 2 ++
 src/mnode/src/mnodeUser.c   | 1 +
 src/mnode/src/mnodeVgroup.c | 1 +
 8 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/mnode/src/mnodeAcct.c b/src/mnode/src/mnodeAcct.c
index d0c0f01d63..2d6e1ae007 100644
--- a/src/mnode/src/mnodeAcct.c
+++ b/src/mnode/src/mnodeAcct.c
@@ -128,6 +128,7 @@ int32_t mnodeInitAccts() {
 void mnodeCleanupAccts() {
   acctCleanUp();
   sdbCloseTable(tsAcctSdb);
+  tsAcctSdb = NULL;
 }
 
 void *mnodeGetAcct(char *name) {
diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c
index 69821e3483..f59f7e0985 100644
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
@@ -459,6 +459,7 @@ void mnodeMoveVgroupToHead(SVgObj *pVgroup) {
 
 void mnodeCleanupDbs() {
   sdbCloseTable(tsDbSdb);
+  tsDbSdb = NULL;
 }
 
 static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c
index 804a64be08..afccbdf212 100644
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -176,6 +176,7 @@ int32_t mnodeInitDnodes() {
 
 void mnodeCleanupDnodes() {
   sdbCloseTable(tsDnodeSdb);
+  tsDnodeSdb = NULL;
 }
 
 void *mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode) { 
diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c
index ba0089c61e..db7c35fe2d 100644
--- a/src/mnode/src/mnodeMain.c
+++ b/src/mnode/src/mnodeMain.c
@@ -121,9 +121,9 @@ void mnodeCleanupSystem() {
   dnodeFreeMnodeWqueue();
   dnodeFreeMnodeRqueue();
   dnodeFreeMnodePqueue();
-  mnodeCleanupComponents(sizeof(tsMnodeComponents) / sizeof(tsMnodeComponents[0]) - 1);
   mnodeCleanupTimer();
-
+  mnodeCleanupComponents(sizeof(tsMnodeComponents) / sizeof(tsMnodeComponents[0]) - 1);
+  
   mInfo("mnode is cleaned up");
 }
 
diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c
index 4d785dd062..7d49915b9c 100644
--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
@@ -165,6 +165,7 @@ int32_t mnodeInitMnodes() {
 
 void mnodeCleanupMnodes() {
   sdbCloseTable(tsMnodeSdb);
+  tsMnodeSdb = NULL;
   mnodeMnodeDestroyLock();
 }
 
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 5c32130925..ecaafa1eb0 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -376,6 +376,7 @@ static int32_t mnodeInitChildTables() {
 
 static void mnodeCleanupChildTables() {
   sdbCloseTable(tsChildTableSdb);
+  tsChildTableSdb = NULL;
 }
 
 static void mnodeAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCtable) {
@@ -554,6 +555,7 @@ static int32_t mnodeInitSuperTables() {
 
 static void mnodeCleanupSuperTables() {
   sdbCloseTable(tsSuperTableSdb);
+  tsSuperTableSdb = NULL;
 }
 
 int32_t mnodeInitTables() {
diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c
index fa2a2634d6..84f5d6aa58 100644
--- a/src/mnode/src/mnodeUser.c
+++ b/src/mnode/src/mnodeUser.c
@@ -154,6 +154,7 @@ int32_t mnodeInitUsers() {
 
 void mnodeCleanupUsers() {
   sdbCloseTable(tsUserSdb);
+  tsUserSdb = NULL;
 }
 
 SUserObj *mnodeGetUser(char *name) {
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index 64e45b3f99..27dbcbf51b 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -427,6 +427,7 @@ void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) {
 
 void mnodeCleanupVgroups() {
   sdbCloseTable(tsVgroupSdb);
+  tsVgroupSdb = NULL;
 }
 
 int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {

From d2b805f3a5424b63a08defd0ec33f003bfdc7598 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 16:19:01 +0800
Subject: [PATCH 78/87] fix pathfinding for CI

---
 tests/pytest/util/dnodes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index 788f26a262..aa865ff9b4 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -202,7 +202,7 @@ class TDDnode:
             if ("taosd" in files):
                 rootRealPath = os.path.dirname(os.path.realpath(root))
                 if ("packaging" not in rootRealPath):
-                    buildPath = root[:root.find("build")]
+                    buildPath = root[:len(root)-len("/build/bin")]
                     break
         return buildPath
 

From 095d5a68bf5f457039483a5b08179a70dc26937a Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Wed, 8 Jul 2020 08:27:59 +0000
Subject: [PATCH 79/87] Added the -a option to crash_gen tool to automatically
 start/stop TDengine service

---
 tests/pytest/crash_gen.py | 58 +++++++++++++++++++++++++++------------
 1 file changed, 41 insertions(+), 17 deletions(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index afe61128a5..e882780b8f 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -1629,7 +1629,7 @@ class MyLoggingAdapter(logging.LoggerAdapter):
         # return '[%s] %s' % (self.extra['connid'], msg), kwargs
 
 class SvcManager:    
-    MAX_QUEUE_SIZE = 30
+    MAX_QUEUE_SIZE = 10000
 
     def __init__(self):
         print("Starting service manager")
@@ -1667,7 +1667,7 @@ class SvcManager:
                 break
 
             # queue.put(line)
-        print("No more output (most likely) from IO thread managing TDengine service") # meaning sub process must have died
+        print("\nNo more output (most likely) from IO thread managing TDengine service") # meaning sub process must have died
         out.close()
 
     def _doMenu(self):
@@ -1700,10 +1700,10 @@ class SvcManager:
         if choice == "1" :
             self.sigHandlerResume() # TODO: can the sub-process be blocked due to us not reading from queue?
         elif choice == "2" :
-            self._stopTaosService()
+            self.stopTaosService()
         elif choice == "3" :
-            self._stopTaosService()
-            self._startTaosService()
+            self.stopTaosService()
+            self.startTaosService()
         else:
             raise RuntimeError("Invalid menu choice: {}".format(choice))
 
@@ -1714,7 +1714,7 @@ class SvcManager:
             return
 
         self.status = MainExec.STATUS_STOPPING # immediately set our status    
-        self._stopTaosService()  
+        self.stopTaosService()  
         print("INT signal handler returning...")  
 
     def sigHandlerResume(self) :
@@ -1728,12 +1728,17 @@ class SvcManager:
         else :
             print("Joining empty thread, doing nothing")
     
+    TD_READY_MSG = "TDengine is initialized successfully"
     def _procIpcBatch(self):
         # Process all the output generated by the underlying sub process, managed by IO thread
         while True :
             try:  
                 line = self.ipcQueue.get_nowait() # getting output at fast speed   
-                print("_o", end="", flush=True)                 
+                print("_o", end="", flush=True)   
+                if self.status == MainExec.STATUS_STARTING : # we are starting, let's see if we have started
+                    if line.find(self.TD_READY_MSG) != -1 : # found
+                        self.status = MainExec.STATUS_RUNNING
+                              
             except Empty:
                 # time.sleep(2.3) # wait only if there's no output
                 # no more output
@@ -1743,13 +1748,13 @@ class SvcManager:
 
     def _procIpcAll(self):
         while True :
-            print("<<", end="", flush=True)
+            print("<", end="", flush=True)
             self._procIpcBatch() # process one batch
 
             # check if the ioThread is still running
             if (not self.ioThread) or (not self.ioThread.is_alive()):
                 print("IO Thread (with subprocess) has ended, main thread now exiting...")
-                self._stopTaosService()
+                self.stopTaosService()
                 self._procIpcBatch() # one more batch
                 return # TODO: maybe one last batch?
 
@@ -1759,10 +1764,10 @@ class SvcManager:
                 self._procIpcBatch() # one more batch
                 return
 
-            print(">>", end="", flush=True)
+            print(">", end="", flush=True)
             time.sleep(0.5)
 
-    def _startTaosService(self):
+    def startTaosService(self):
         ON_POSIX = 'posix' in sys.builtin_module_names
         svcCmd = ['../../build/build/bin/taosd', '-c', '../../build/test/cfg']
         # svcCmd = ['vmstat', '1']
@@ -1783,9 +1788,19 @@ class SvcManager:
         self.ioThread.start()
 
         self.shouldStop = False # don't let the main loop stop
-        self.status = MainExec.STATUS_RUNNING
+        self.status = MainExec.STATUS_STARTING
 
-    def _stopTaosService(self):
+        # wait for service to start
+        for i in range(0, 10) :
+            time.sleep(1.0)
+            self._procIpcBatch() # pump messages
+            print("_zz_", end="", flush=True)
+            if self.status == MainExec.STATUS_RUNNING :
+                print("TDengine service READY to process requests")
+                return # now we've started
+        raise RuntimeError("TDengine service did not start successfully") # TODO: handle this better?
+
+    def stopTaosService(self):
         # can be called from both main thread or signal handler
         print("Terminating TDengine service running as the sub process...")
         # Linux will send Control-C generated SIGINT to the TDengine process already, ref: https://unix.stackexchange.com/questions/176235/fork-and-how-signals-are-delivered-to-processes
@@ -1804,7 +1819,7 @@ class SvcManager:
             except subprocess.TimeoutExpired as err:
                 print("Time out waiting for TDengine service process to exit")
             else:
-                print("Sub process has ended")
+                print("TDengine service process terminated successfully from SIG_INT")
                 self.subProcess = None
 
         if self.subProcess and (not self.subProcess.poll()):
@@ -1814,7 +1829,7 @@ class SvcManager:
         self.joinIoThread()
 
     def run(self):
-        self._startTaosService()
+        self.startTaosService()
 
         # proc = subprocess.Popen(['echo', '"to stdout"'], 
         #                 stdout=subprocess.PIPE,
@@ -1878,6 +1893,10 @@ class ClientManager:
         self._printLastNumbers()
 
     def run(self):
+        if gConfig.auto_start_service :
+            svcMgr = SvcManager()
+            svcMgr.startTaosService()
+
         self._printLastNumbers()
 
         dbManager = DbManager() # Regular function
@@ -1889,6 +1908,8 @@ class ClientManager:
         # print("exec stats: {}".format(self.tc.getExecStats()))
         # print("TC failed = {}".format(self.tc.isFailed()))
         self.conclude()
+        if gConfig.auto_start_service :
+            svcMgr.stopTaosService()
         # print("TC failed (2) = {}".format(self.tc.isFailed()))
         return 1 if self.tc.isFailed() else 0 # Linux return code: ref https://shapeshed.com/unix-exit-codes/
 
@@ -1898,8 +1919,9 @@ class ClientManager:
 
 
 class MainExec:
-    STATUS_RUNNING = 1
-    STATUS_STOPPING = 2
+    STATUS_STARTING = 1
+    STATUS_RUNNING = 2
+    STATUS_STOPPING = 3
     # STATUS_STOPPED = 3 # Not used yet
 
     @classmethod
@@ -1968,6 +1990,8 @@ def main():
 
             '''))
 
+    parser.add_argument('-a', '--auto-start-service', action='store_true',                        
+                        help='Automatically start/stop the TDengine service (default: false)')
     parser.add_argument('-c', '--connector-type', action='store', default='native', type=str,
                         help='Connector type to use: native, rest, or mixed (default: 10)')
     parser.add_argument('-d', '--debug', action='store_true',                        

From f13e3d6adf4a404ea7632117a0a028e21c0bae28 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 16:33:40 +0800
Subject: [PATCH 80/87] turn off output.

---
 tests/test-all.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test-all.sh b/tests/test-all.sh
index 26005c8bc4..275c6b1677 100755
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
@@ -27,7 +27,7 @@ function runPyCaseOneByOne {
       if [[ $line != *sleep* ]]; then
         case=`echo $line|awk '{print $NF}'`
         start_time=`date +%s`
-        $line && \
+        $line > /dev/null 2>&1 && \
           echo -e "${GREEN}$case success${NC}" | tee -a pytest-out.log || \
           echo -e "${RED}$case failed${NC}" | tee -a pytest-out.log
         end_time=`date +%s`

From 93161f42503744153f7045874b04fbd1478986d3 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 16:35:41 +0800
Subject: [PATCH 81/87] add log

---
 src/vnode/src/vnodeWrite.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index dad079c4b8..5ed5e747f2 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -49,19 +49,26 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
   SVnodeObj *pVnode = (SVnodeObj *)param1;
   SWalHead  *pHead = param2;
 
-  if (vnodeProcessWriteMsgFp[pHead->msgType] == NULL) 
+  if (vnodeProcessWriteMsgFp[pHead->msgType] == NULL) {
+    vDebug("vgId:%d, msgType:%s not processed, no handle", pVnode->vgId, taosMsg[pHead->msgType]);
     return TSDB_CODE_VND_MSG_NOT_PROCESSED; 
+  }
 
   if (!(pVnode->accessState & TSDB_VN_WRITE_ACCCESS)) {
+    vDebug("vgId:%d, msgType:%s not processed, no write auth", pVnode->vgId, taosMsg[pHead->msgType]);
     return TSDB_CODE_VND_NO_WRITE_AUTH;
   }
 
   if (pHead->version == 0) { // from client or CQ 
-    if (pVnode->status != TAOS_VN_STATUS_READY) 
+    if (pVnode->status != TAOS_VN_STATUS_READY) {
+      vDebug("vgId:%d, msgType:%s not processed, vnode status is %d", pVnode->vgId, taosMsg[pHead->msgType], pVnode->status);
       return TSDB_CODE_VND_INVALID_STATUS;  // it may be in deleting or closing state
+    }
 
-    if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER)
+    if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+      vDebug("vgId:%d, msgType:%s not processed, replica:%d role:%d", pVnode->vgId, taosMsg[pHead->msgType], pVnode->syncCfg.replica, pVnode->role);
       return TSDB_CODE_RPC_NOT_READY;
+    }
 
     // assign version
     pVnode->version++;

From f0bbd1d32e4c4096567556612303ecb2186f07f4 Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Wed, 8 Jul 2020 08:49:51 +0000
Subject: [PATCH 82/87] Allow crash_gen tool to tolerate 0x5 and 0x510 error
 codes

---
 tests/pytest/crash_gen.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/pytest/crash_gen.py b/tests/pytest/crash_gen.py
index e882780b8f..0688bb828e 100755
--- a/tests/pytest/crash_gen.py
+++ b/tests/pytest/crash_gen.py
@@ -1213,7 +1213,11 @@ class Task():
             self._executeInternal(te, wt) # TODO: no return value?
         except taos.error.ProgrammingError as err:
             errno2 = err.errno if (err.errno > 0) else 0x80000000 + err.errno # correct error scheme
-            if ( errno2 in [0x200, 0x360, 0x362, 0x36A, 0x36B, 0x36D, 0x381, 0x380, 0x383, 0x503, 0x600,
+            if ( errno2 in [
+                0x05, # TSDB_CODE_RPC_NOT_READY
+                0x200, 0x360, 0x362, 0x36A, 0x36B, 0x36D, 0x381, 0x380, 0x383, 0x503, 
+                0x510, # vnode not in ready state
+                0x600,
                 1000 # REST catch-all error
                 ]) : # allowed errors
                 self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(errno2, err, self._lastSql))

From 57671ddf31199d82e7155d62514d15f1a4238f91 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 17:02:25 +0800
Subject: [PATCH 83/87] fix client/client.py

---
 tests/pytest/client/client.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/pytest/client/client.py b/tests/pytest/client/client.py
index 9bb1887216..6ac12c6795 100644
--- a/tests/pytest/client/client.py
+++ b/tests/pytest/client/client.py
@@ -40,8 +40,10 @@ class TDTestCase:
         ret = tdSql.query('select server_status() as result')
         tdSql.checkData(0, 0, 1)
 
-        ret = tdSql.execute('alter dnode 127.0.0.1 debugFlag 135')
-        tdLog.info("alter dnode ret: %d" % ret)
+        ret = tdSql.query('show dnodes')
+
+        ret = tdSql.execute('alter dnode "%s" debugFlag 135' % tdSql.getData(0,1))
+        tdLog.info('alter dnode "%s" debugFlag 135 -> ret: %d' % (tdSql.getData(0, 1), ret))
 
     def stop(self):
         tdSql.close()

From 062515354f5038406e0da8b70e9c178d61815c38 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 10:21:29 +0000
Subject: [PATCH 84/87] scripts

---
 .../alter/cached_schema_after_alter.sim       |  4 ++--
 .../general/parser/slimit_alter_tags.sim      | 24 +++++++++----------
 tests/script/jenkins/basic.txt                | 20 +++++++++-------
 3 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/tests/script/general/alter/cached_schema_after_alter.sim b/tests/script/general/alter/cached_schema_after_alter.sim
index 2d049ec595..bf9b9eb6a3 100644
--- a/tests/script/general/alter/cached_schema_after_alter.sim
+++ b/tests/script/general/alter/cached_schema_after_alter.sim
@@ -68,7 +68,7 @@ endi
 if $data01 != 1 then
   return -1
 endi 
-if $data02 != 1 then
+if $data02 != NULL then
   return -1
 endi 
 
@@ -80,7 +80,7 @@ endi
 if $data01 != 1 then
   return -1
 endi 
-if $data02 != 1 then
+if $data02 != NULL then
   return -1
 endi 
 
diff --git a/tests/script/general/parser/slimit_alter_tags.sim b/tests/script/general/parser/slimit_alter_tags.sim
index e8e81e8809..fb48dddba7 100644
--- a/tests/script/general/parser/slimit_alter_tags.sim
+++ b/tests/script/general/parser/slimit_alter_tags.sim
@@ -141,9 +141,9 @@ $res = 3 * $rowNum
 if $data00 != $res then
   return -1
 endi
-if $data01 != @18-09-17 09:00:00.000@ then
-  return -1
-endi
+#if $data01 != @18-09-17 09:00:00.000@ then
+#  return -1
+#endi
 if $data02 != 3 then
   return -1
 endi
@@ -154,9 +154,9 @@ $res = 3 * $rowNum
 if $data10 != $res then
   return -1
 endi
-if $data11 != @18-09-17 09:00:00.000@ then
-  return -1
-endi
+#if $data11 != @18-09-17 09:00:00.000@ then
+#  return -1
+#endi
 if $data15 != 2 then
   return -1
 endi
@@ -223,9 +223,9 @@ $res = 3 * $rowNum
 if $data00 != $res then
   return -1
 endi
-if $data01 != @18-09-17 09:00:00.000@ then
-  return -1
-endi
+#if $data01 != @18-09-17 09:00:00.000@ then
+#  return -1
+#endi
 if $data02 != 3 then
   return -1
 endi
@@ -236,9 +236,9 @@ $res = 3 * $rowNum
 if $data10 != $res then
   return -1
 endi
-if $data11 != @18-09-17 09:00:00.000@ then
-  return -1
-endi
+#if $data11 != @18-09-17 09:00:00.000@ then
+#  return -1
+#endi
 if $data15 != 2 then
   return -1
 endi
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 3c4733a25b..59e632c640 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -1,10 +1,10 @@
 cd ../../../debug; cmake ..
 cd ../../../debug; make
 
-#./test.sh -f general/alter/cached_schema_after_alter.sim
+./test.sh -f general/alter/cached_schema_after_alter.sim
 ./test.sh -f general/alter/count.sim
 ./test.sh -f general/alter/import.sim
-#./test.sh -f general/alter/insert1.sim
+./test.sh -f general/alter/insert1.sim
 ./test.sh -f general/alter/insert2.sim
 ./test.sh -f general/alter/metrics.sim
 ./test.sh -f general/alter/table.sim
@@ -117,6 +117,7 @@ cd ../../../debug; make
 ./test.sh -f general/parser/import_commit3.sim
 ./test.sh -f general/parser/insert_tb.sim
 ./test.sh -f general/parser/first_last.sim
+# dyh is processing this script
 #./test.sh -f general/parser/import_file.sim
 ./test.sh -f general/parser/lastrow.sim
 ./test.sh -f general/parser/nchar.sim
@@ -142,15 +143,12 @@ cd ../../../debug; make
 ./test.sh -f general/parser/tags_dynamically_specifiy.sim
 ./test.sh -f general/parser/groupby.sim
 ./test.sh -f general/parser/set_tag_vals.sim
-#./test.sh -f general/parser/slimit_alter_tags.sim
+./test.sh -f general/parser/slimit_alter_tags.sim
 ./test.sh -f general/parser/join.sim
 ./test.sh -f general/parser/join_multivnode.sim
 ./test.sh -f general/parser/binary_escapeCharacter.sim
 ./test.sh -f general/parser/bug.sim
-#./test.sh -f general/parser/stream_on_sys.sim
-./test.sh -f general/parser/stream.sim
 ./test.sh -f general/parser/repeatAlter.sim
-#./test.sh -f general/parser/repeatStream.sim
 
 ./test.sh -f general/stable/disk.sim
 ./test.sh -f general/stable/dnode3.sim
@@ -201,7 +199,7 @@ cd ../../../debug; make
 ./test.sh -f general/tag/bool.sim
 ./test.sh -f general/tag/change.sim
 ./test.sh -f general/tag/column.sim
-#./test.sh -f general/tag/commit.sim
+./test.sh -f general/tag/commit.sim
 ./test.sh -f general/tag/create.sim
 ./test.sh -f general/tag/delete.sim
 ./test.sh -f general/tag/double.sim
@@ -309,11 +307,16 @@ cd ../../../debug; make
 ./test.sh -f unique/vnode/replica3_repeat.sim
 ./test.sh -f unique/vnode/replica3_vgroup.sim
 
+# stream still has bugs
+#./test.sh -f general/parser/stream_on_sys.sim
+#./test.sh -f general/parser/stream.sim
+#./test.sh -f general/parser/repeatStream.sim
+#./test.sh -f general/stream/new_stream.sim
+
 ./test.sh -f general/stream/metrics_1.sim
 ./test.sh -f general/stream/metrics_del.sim
 ./test.sh -f general/stream/metrics_n.sim
 ./test.sh -f general/stream/metrics_replica1_vnoden.sim
-#./test.sh -f general/stream/new_stream.sim
 ./test.sh -f general/stream/restart_stream.sim
 ./test.sh -f general/stream/stream_1.sim
 ./test.sh -f general/stream/stream_2.sim
@@ -334,6 +337,7 @@ cd ../../../debug; make
 ./test.sh -f unique/arbitrator/dn3_mn1_replica_change_dropDnod.sim
 ./test.sh -f unique/arbitrator/dn3_mn1_replica_change.sim
 ./test.sh -f unique/arbitrator/dn3_mn1_stopDnode_timeout.sim
+# lower the priority while file corruption
 #./test.sh -f unique/arbitrator/dn3_mn1_vnode_change.sim
 #./test.sh -f unique/arbitrator/dn3_mn1_vnode_corruptFile_offline.sim
 #./test.sh -f unique/arbitrator/dn3_mn1_vnode_corruptFile_online.sim

From 5f8d41bc4d51e5c19406b48e1b0b4d829c343673 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Wed, 8 Jul 2020 19:09:58 +0800
Subject: [PATCH 85/87] change go mod url to reflect 2.0's change.

---
 importSampleData/app/main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/importSampleData/app/main.go b/importSampleData/app/main.go
index d714fc339c..6996047026 100644
--- a/importSampleData/app/main.go
+++ b/importSampleData/app/main.go
@@ -18,7 +18,7 @@ import (
 	"sync"
 	"time"
 
-	_ "github.com/taosdata/TDengine/src/connector/go/taosSql"
+	_ "github.com/taosdata/driver-go/taosSql"
 )
 
 const (

From 1f72417ee65a6072e44318bf545a3a4ed21ac7f8 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Wed, 8 Jul 2020 21:33:10 +0800
Subject: [PATCH 86/87] fix invalid read

---
 src/util/src/tskiplist.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/util/src/tskiplist.c b/src/util/src/tskiplist.c
index f3c0babe6b..045de3aa2f 100644
--- a/src/util/src/tskiplist.c
+++ b/src/util/src/tskiplist.c
@@ -498,7 +498,17 @@ void tSkipListRemoveNode(SSkipList *pSkipList, SSkipListNode *pNode) {
   if (pSkipList->lock) {
     pthread_rwlock_wrlock(pSkipList->lock);
   }
-  
+
+  if (pSkipList->size == 1) {
+    assert(pSkipList->lastKey == SL_GET_NODE_KEY(pSkipList, pNode));
+    pSkipList->lastKey = 0;
+  } else {
+    if (pSkipList->lastKey == SL_GET_NODE_KEY(pSkipList, pNode)) {
+      SSkipListNode* prev = SL_GET_BACKWARD_POINTER(pNode, 0);
+      pSkipList->lastKey = SL_GET_NODE_KEY(pSkipList, prev);
+    }
+  }
+
   for (int32_t j = level - 1; j >= 0; --j) {
     SSkipListNode* prev = SL_GET_BACKWARD_POINTER(pNode, j);
     SSkipListNode* next = SL_GET_FORWARD_POINTER(pNode, j);

From 823761d94c5175d3eecdee472aff17e5ff3fd67d Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 8 Jul 2020 22:41:36 +0800
Subject: [PATCH 87/87] remove some error codes

---
 src/inc/taoserror.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index fc433463c5..b9e61c3195 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -129,9 +129,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_CLUSTER_CFG_INCONSISTENT, 0, 0x0335, "mnode clus
 
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_ALREADY_EXIST,       0, 0x0340, "mnode accounts already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT,             0, 0x0341, "mnode invalid account")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_PARA,        0, 0x0342, "mnode invalid account parameter")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_OPTION,      0, 0x0343, "mnode invalid acct option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_ACCTS,           0, 0x0344, "mnode too many accounts")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_OPTION,      0, 0x0342, "mnode invalid acct option")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_USER_ALREADY_EXIST,       0, 0x0350, "mnode user already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_USER,             0, 0x0351, "mnode invalid user")
@@ -145,7 +143,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_ID,         0, 0x0361, "mnode inva
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_NAME,       0, 0x0362, "mnode invalid table name")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_TYPE,       0, 0x0363, "mnode invalid table type")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TAGS,            0, 0x0364, "mnode too many tags")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TABLES,          0, 0x0365, "mnode too many tables")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TIMESERIES,      0, 0x0366, "mnode not enough time series")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_SUPER_TABLE,          0, 0x0367, "mnode no super table")           // operation only available for super table
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_COL_NAME_TOO_LONG,        0, 0x0368, "mnode column name too long")
@@ -167,7 +164,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_DND_MSG_NOT_PROCESSED,        0, 0x0400, "dnode mess
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_OUT_OF_MEMORY,            0, 0x0401, "dnode out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_NO_WRITE_ACCESS,          0, 0x0402, "dnode no disk write access")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_INVALID_MSG_LEN,          0, 0x0403, "dnode invalid message length")
-TAOS_DEFINE_ERROR(TSDB_CODE_DND_INVALID_FILE_FORMAT,      0, 0x0404, "dnode invalid file format")
 
 // vnode 
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_ACTION_IN_PROGRESS,       0, 0x0500, "vnode action in progress")