add check demo

examples/go/demo.go

 package main
 
 import (
+	"container/heap"
 	"database/sql"
 	"database/sql/driver"
 	"flag"
 	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
 	"sync"
 	"time"
-	"strings"
-	"container/heap"
-	"strconv"
-	"reflect"
-	
 
 	_ "github.com/taosdata/driver-go/v2/taosSql"
 )
 
-
-
 type heapElem struct {
 	timeout int64
 	colName string
@@ -25,9 +22,7 @@ type heapElem struct {
 
 type MinHeap []heapElem
 
-
 type Column struct {
-	  
 }
 
 func (h MinHeap) Len() int {
@@ -37,16 +32,16 @@ func (h MinHeap) Len() int {
 func (h MinHeap) Less(i, j int) bool {
 	res := h[i].timeout - h[j].timeout
 	if res < 0 {
-		return true;
+		return true
 	} else if res > 0 {
-		return false;
+		return false
 	}
 
 	cmp := strings.Compare(h[i].colName, h[j].colName)
-	if (cmp <= 0) {
-		return true;
+	if cmp <= 0 {
+		return true
 	} else {
-		return false;
+		return false
 	}
 }
 
@@ -69,7 +64,7 @@ func (h *MinHeap) Top() heapElem {
 	return (*h)[0]
 }
 
-func (h *MinHeap) Pop() interface{}{
+func (h *MinHeap) Pop() interface{} {
 	res := (*h)[len(*h)-1]
 	*h = (*h)[:len(*h)-1]
 	return res
@@ -107,7 +102,6 @@ func checkErr(err error, prompt string) {
 	}
 }
 
-
 type schema struct {
 	idx        int
 	numOfField int
@@ -115,7 +109,6 @@ type schema struct {
 	colName    string
 	interval   int32
 	threshold  int32
-	
 }
 
 type demo struct {
@@ -153,6 +146,7 @@ type tableInfo struct {
 	tid        int64
 	vgId       int32
 }
+
 func (d *demo) Init(wg *sync.WaitGroup) {
 	d.heap = make(MinHeap, 0, 200)
 	heap.Init(&d.heap)
@@ -170,7 +164,6 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 		checkErr(err, sql)
 	}
 
-
 	{
 		sql := fmt.Sprintf("create table if not exists %s.%s (ts timestamp,  dbname binary(64), tablename binary(64), colName binary(128),  checkInterval int, threshold  int)", d.dbname, d.metaTable)
 		_, err := d.db.Exec(sql)
@@ -209,9 +202,8 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 		//tid        := e.tid
 		//vgId       := vgId
 
-		
 		// ignore exceptable name
-		if strings.Compare(strings.ToLower(tbname), strings.ToLower(d.metaTable)) == 0  || strings.Compare(tbname, d.exceptTable) == 0 || strings.HasPrefix(strings.ToLower(stbname), strings.ToLower(d.exceptTable)) == true{
+		if strings.Compare(strings.ToLower(tbname), strings.ToLower(d.metaTable)) == 0 || strings.Compare(tbname, d.exceptTable) == 0 || strings.HasPrefix(strings.ToLower(stbname), strings.ToLower(d.exceptTable)) == true {
 			continue
 		}
 
@@ -220,7 +212,6 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 			continue
 		}
 
-
 		fields := make([]string, 0, columns)
 		// sub sql
 		{
@@ -231,7 +222,7 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 				checkErr(err, subsql)
 			}
 
-			count := 0; 
+			count := 0
 			for subRows.Next() {
 				var field string
 				var ty string
@@ -239,7 +230,7 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 				var note string
 				subRows.Scan(&field, &ty, &len, &note)
 
-				if count != 0  &&  strings.Compare(note, "TAG") != 0{
+				if count != 0 && strings.Compare(note, "TAG") != 0 {
 					// skip first and skip tag col
 					fields = append(fields, field)
 				}
@@ -263,12 +254,9 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 			subRows.Close()
 		}
 
-
-
-		
 		for i, f := range fields {
 			col := fmt.Sprintf("%s %s %s", stbname, tbname, f)
-			count := 0;
+			count := 0
 			{
 
 				var (
@@ -288,9 +276,9 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 
 				for checkRow.Next() {
 					_ = checkRow.Scan(&ts, &dbname, &tablename, &colname, &checkinterval, &threshold)
-				  d.metaDict[col] = &schema{idx: i, numOfField: len(fields),  timestamp: lastTime, colName : col, interval: int32(checkinterval), threshold : int32(threshold)}
+					d.metaDict[col] = &schema{idx: i, numOfField: len(fields), timestamp: lastTime, colName: col, interval: int32(checkinterval), threshold: int32(threshold)}
 
-				  count = count + 1;
+					count = count + 1
 				}
 				if count != 0 {
 					continue
@@ -305,15 +293,14 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 					checkErr(err, sql)
 				}
 
-				d.metaDict[col] = &schema{idx: i, numOfField: len(fields), timestamp: lastTime, colName : col, interval: d.dInterval, threshold : d.dThreshold}
+				d.metaDict[col] = &schema{idx: i, numOfField: len(fields), timestamp: lastTime, colName: col, interval: d.dInterval, threshold: d.dThreshold}
 
 			}
 			fieldTs = fieldTs.Add(time.Millisecond * 2)
 
-
 		}
 	}
-  now := time.Now();  
+	now := time.Now()
 	for k, v := range d.metaDict {
 		durtion := fmt.Sprintf("%ds", v.interval)
 		s, _ := time.ParseDuration(durtion)
@@ -321,7 +308,6 @@ func (d *demo) Init(wg *sync.WaitGroup) {
 		heap.Push(&d.heap, heapElem{timeout: now.Unix(), colName: k})
 	}
 
-
 	d.timer = time.NewTimer(time.Second * 1)
 	wg.Done()
 }
@@ -380,9 +366,7 @@ func (d *demo) NextTimout() int32 {
 		}
 	}
 
-	
-	
-	cacheTs := make(map[string] *ValueRows)
+	cacheTs := make(map[string]*ValueRows)
 	ts := time.Now()
 
 	for _, e := range colArray {
@@ -430,7 +414,6 @@ func (d *demo) NextTimout() int32 {
 
 			cvttime, is := v.(time.Time)
 
-			
 			if is {
 				fmt.Println("yes ")
 				cacheTs[cacheKey] = &ValueRows{rows: values, ts: cvttime}
@@ -447,21 +430,21 @@ func (d *demo) NextTimout() int32 {
 
 		exceptTableName := fmt.Sprintf("%s_%s_%s", stbName, tabName, colName)
 
-		var dura time.Duration = ts.Sub(elem.timestamp);
+		var dura time.Duration = ts.Sub(elem.timestamp)
 		cost := int32(dura.Seconds())
-    if (cost == 0) {
-			elem.timestamp = ts;
+		if cost == 0 {
+			elem.timestamp = ts
 			fmt.Printf("A dura %d, threshold %d insert\n", cost, elem.threshold)
-			sql := fmt.Sprintf("insert into %s.%s using %s.%s tags(\"%s\") values(%v, \"%s\", \"%s\", \"%s\", %v, %d)", d.dbname,exceptTableName, d.dbname, d.exceptTable, exceptTableName, time.Now().UnixMilli(), d.dbname,  tabName, colName, ts.UnixMilli(), int(time.Now().Sub(elem.timestamp).Seconds()))
+			sql := fmt.Sprintf("insert into %s.%s using %s.%s tags(\"%s\") values(%v, \"%s\", \"%s\", \"%s\", %v, %d)", d.dbname, exceptTableName, d.dbname, d.exceptTable, exceptTableName, time.Now().UnixMilli(), d.dbname, tabName, colName, ts.UnixMilli(), int(time.Now().Sub(elem.timestamp).Seconds()))
 			_, err := d.db.Exec(sql)
 			if err != nil {
 				checkErr(err, sql)
 			}
 		} else {
-			elem.timestamp = ts; 
-      if (cost > elem.threshold) {
+			elem.timestamp = ts
+			if cost > elem.threshold {
 				fmt.Printf("B dura %d, threshold %d insert \n", cost, elem.threshold)
-			  sql := fmt.Sprintf("insert into %s.%s using %s.%s tags(\"%s\") values(%v, \"%s\", \"%s\", \"%s\", %v, %d)", d.dbname,exceptTableName, d.dbname, d.exceptTable, exceptTableName, time.Now().UnixMilli(), d.dbname,  tabName, colName, ts.UnixMilli(), int(time.Now().Sub(elem.timestamp).Seconds()))
+				sql := fmt.Sprintf("insert into %s.%s using %s.%s tags(\"%s\") values(%v, \"%s\", \"%s\", \"%s\", %v, %d)", d.dbname, exceptTableName, d.dbname, d.exceptTable, exceptTableName, time.Now().UnixMilli(), d.dbname, tabName, colName, ts.UnixMilli(), int(time.Now().Sub(elem.timestamp).Seconds()))
 
 				_, err := d.db.Exec(sql)
 				if err != nil {
@@ -471,7 +454,7 @@ func (d *demo) NextTimout() int32 {
 				fmt.Printf("C dura %d, threshold %d not insert \n", cost, elem.threshold)
 			}
 		}
-		heap.Push(&d.heap, heapElem{timeout : int64(elem.interval) + now, colName : e})
+		heap.Push(&d.heap, heapElem{timeout: int64(elem.interval) + now, colName: e})
 	}
 
 	if !d.heap.Empty() {
@@ -480,9 +463,9 @@ func (d *demo) NextTimout() int32 {
 		if timeout < 1 {
 			timeout = 1
 		}
-       return int32(timeout);	
+		return int32(timeout)
 	}
-	return 1;
+	return 1
 
 }
 
@@ -496,7 +479,7 @@ func printAllArgs() {
 	fmt.Printf("srcDbName:            %v\n", configPara.srcdbname)
 	fmt.Printf("stbNme:               %v\n", configPara.supTblName)
 	fmt.Printf("================================================\n")
-  }
+}
 
 func main() {
 
@@ -508,11 +491,10 @@ func main() {
 		checkErr(err, "failed to connect db")
 	}
 	wg := sync.WaitGroup{}
-	demo := &demo{db: db, dbname: configPara.dbName, srcdbname: configPara.srcdbname, metaTable: "metaTable", exceptTable: "exceptTable", dStartTs : 0, dInterval : 2, dThreshold :  2}
+	demo := &demo{db: db, dbname: configPara.dbName, srcdbname: configPara.srcdbname, metaTable: "metaTable", exceptTable: "exceptTable", dStartTs: 0, dInterval: 2, dThreshold: 2}
 	wg.Add(1)
 	go demo.Init(&wg)
 
-
 	wg.Wait()
 
 	demo.Update("st1", "t1", "f", 10, 20)