<test> : merge go test case from develop to master

tests/gotest/batchtest.bat

+
 @echo off
 echo ==== start Go connector test cases test ====
 cd /d %~dp0
@@ -18,3 +19,10 @@ rem case002.bat
 
 :: cd case002
 :: case002.bat
+
+
+rem cd nanosupport 
+rem nanoCase.bat 
+
+:: cd nanosupport 
+:: nanoCase.bat 

tests/gotest/batchtest.sh

@@ -19,3 +19,4 @@ go env -w GOPROXY=https://goproxy.cn,direct
 bash ./case001/case001.sh $severIp $serverPort
 bash ./case002/case002.sh $severIp $serverPort
 #bash ./case003/case003.sh $severIp $serverPort
+bash ./nanosupport/nanoCase.sh $severIp $serverPort

tests/gotest/case001/case001.sh

@@ -15,8 +15,7 @@ script_dir="$(dirname $(readlink -f $0))"
 ###### step 3: start build
 cd $script_dir
 rm -f go.*
-go mod init demotest > /dev/null 2>&1
-go mod tidy > /dev/null 2>&1
-go build  > /dev/null 2>&1
+go mod init demotest
+go build 
 sleep 1s
 ./demotest -h $1 -p $2

tests/gotest/case002/case002.go

@@ -44,7 +44,7 @@ func main() {
 	}
 	defer db.Close()
 	db.Exec("drop database if exists test")
-	db.Exec("create database if not exists test")
+	db.Exec("create database if not exists test ")
 	db.Exec("use test")
 	db.Exec("create table test (ts timestamp ,level int)")
 	for i := 0; i < 10; i++ {

tests/gotest/nanosupport/connector/executor.go

+package connector
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/taosdata/go-utils/log"
+	"github.com/taosdata/go-utils/tdengine/config"
+	"github.com/taosdata/go-utils/tdengine/connector"
+	tdengineExecutor "github.com/taosdata/go-utils/tdengine/executor"
+)
+
+type Executor struct {
+	executor *tdengineExecutor.Executor
+	ctx      context.Context
+}
+
+var Logger = log.NewLogger("taos test")
+
+func NewExecutor(conf *config.TDengineGo, db string, showSql bool) (*Executor, error) {
+	tdengineConnector, err := connector.NewTDengineConnector("go", conf)
+	if err != nil {
+		return nil, err
+	}
+	executor := tdengineExecutor.NewExecutor(tdengineConnector, db, showSql, Logger)
+	return &Executor{
+		executor: executor,
+		ctx:      context.Background(),
+	}, nil
+}
+
+func (e *Executor) Execute(sql string) (int64, error) {
+	return e.executor.DoExec(e.ctx, sql)
+}
+func (e *Executor) Query(sql string) (*connector.Data, error) {
+	fmt.Println("query :", sql)
+	return e.executor.DoQuery(e.ctx, sql)
+}
+func (e *Executor) CheckData(row, col int, value interface{}, data *connector.Data) (bool, error) {
+	if data == nil {
+		return false, fmt.Errorf("data is nil")
+	}
+	if col >= len(data.Head) {
+		return false, fmt.Errorf("col out of data")
+	}
+	if row >= len(data.Data) {
+		return false, fmt.Errorf("row out of data")
+	}
+	dataValue := data.Data[row][col]
+
+	if dataValue == nil && value != nil {
+		return false, fmt.Errorf("dataValue is nil but value is not nil")
+	}
+	if dataValue == nil && value == nil {
+		return true, nil
+	}
+	if reflect.TypeOf(dataValue) != reflect.TypeOf(value) {
+		return false, fmt.Errorf("type not match expect %s got %s", reflect.TypeOf(value), reflect.TypeOf(dataValue))
+	}
+	switch value.(type) {
+	case time.Time:
+		t, _ := dataValue.(time.Time)
+		if value.(time.Time).Nanosecond() != t.Nanosecond() {
+			return false, fmt.Errorf("value not match expect %d got %d", value.(time.Time).Nanosecond(), t.Nanosecond())
+		}
+	case string:
+		if value.(string) != dataValue.(string) {
+			return false, fmt.Errorf("value not match expect %s got %s", value.(string), dataValue.(string))
+		}
+	case int8:
+		if value.(int8) != dataValue.(int8) {
+			return false, fmt.Errorf("value not match expect %d got %d", value.(int8), dataValue.(int8))
+		}
+	case int16:
+		if value.(int16) != dataValue.(int16) {
+			return false, fmt.Errorf("value not match expect %d got %d", value.(int16), dataValue.(int16))
+		}
+	case int32:
+		if value.(int32) != dataValue.(int32) {
+			return false, fmt.Errorf("value not match expect %d got %d", value.(int32), dataValue.(int32))
+		}
+	case int64:
+		if value.(int64) != dataValue.(int64) {
+			return false, fmt.Errorf("value not match expect %d got %d", value.(int64), dataValue.(int64))
+		}
+	case float32:
+		if value.(float32) != dataValue.(float32) {
+			return false, fmt.Errorf("value not match expect %f got %f", value.(float32), dataValue.(float32))
+		}
+	case float64:
+		if value.(float64) != dataValue.(float64) {
+			return false, fmt.Errorf("value not match expect %f got %f", value.(float32), dataValue.(float32))
+		}
+	case bool:
+		if value.(bool) != dataValue.(bool) {
+			return false, fmt.Errorf("value not match expect %t got %t", value.(bool), dataValue.(bool))
+		}
+	default:
+		return false, fmt.Errorf("unsupport type %v", reflect.TypeOf(value))
+	}
+	return true, nil
+}
+
+func (e *Executor) CheckData2(row, col int, value interface{}, data *connector.Data) {
+
+	match, err := e.CheckData(row, col, value, data)
+	fmt.Println("expect data is :", value)
+	fmt.Println("go got data is :", data.Data[row][col])
+	if err != nil {
+		fmt.Println(err)
+	}
+	if !match {
+		fmt.Println(" data not match")
+
+	}
+
+	/*
+		fmt.Println(value)
+		if data == nil {
+			// return false, fmt.Errorf("data is nil")
+			// fmt.Println("check failed")
+		}
+		if col >= len(data.Head) {
+			// return false, fmt.Errorf("col out of data")
+			// fmt.Println("check failed")
+		}
+		if row >= len(data.Data) {
+			// return false, fmt.Errorf("row out of data")
+			// fmt.Println("check failed")
+		}
+		dataValue := data.Data[row][col]
+
+		if dataValue == nil && value != nil {
+			// return false, fmt.Errorf("dataValue is nil but value is not nil")
+			// fmt.Println("check failed")
+		}
+		if dataValue == nil && value == nil {
+			// return true, nil
+			fmt.Println("check pass")
+		}
+		if reflect.TypeOf(dataValue) != reflect.TypeOf(value) {
+			// return false, fmt.Errorf("type not match expect %s got %s", reflect.TypeOf(value), reflect.TypeOf(dataValue))
+			fmt.Println("check failed")
+		}
+		switch value.(type) {
+		case time.Time:
+			t, _ := dataValue.(time.Time)
+			if value.(time.Time).Nanosecond() != t.Nanosecond() {
+				// return false, fmt.Errorf("value not match expect %d got %d", value.(time.Time).Nanosecond(), t.Nanosecond())
+				// fmt.Println("check failed")
+			}
+		case string:
+			if value.(string) != dataValue.(string) {
+				// return false, fmt.Errorf("value not match expect %s got %s", value.(string), dataValue.(string))
+				// fmt.Println("check failed")
+			}
+		case int8:
+			if value.(int8) != dataValue.(int8) {
+				// return false, fmt.Errorf("value not match expect %d got %d", value.(int8), dataValue.(int8))
+				// fmt.Println("check failed")
+			}
+		case int16:
+			if value.(int16) != dataValue.(int16) {
+				// return false, fmt.Errorf("value not match expect %d got %d", value.(int16), dataValue.(int16))
+				// fmt.Println("check failed")
+			}
+		case int32:
+			if value.(int32) != dataValue.(int32) {
+				// return false, fmt.Errorf("value not match expect %d got %d", value.(int32), dataValue.(int32))
+				// fmt.Println("check failed")
+			}
+		case int64:
+			if value.(int64) != dataValue.(int64) {
+				// return false, fmt.Errorf("value not match expect %d got %d", value.(int64), dataValue.(int64))
+				// fmt.Println("check failed")
+			}
+		case float32:
+			if value.(float32) != dataValue.(float32) {
+				// return false, fmt.Errorf("value not match expect %f got %f", value.(float32), dataValue.(float32))
+				// fmt.Println("check failed")
+			}
+		case float64:
+			if value.(float64) != dataValue.(float64) {
+				// return false, fmt.Errorf("value not match expect %f got %f", value.(float32), dataValue.(float32))
+				// fmt.Println("check failed")
+			}
+		case bool:
+			if value.(bool) != dataValue.(bool) {
+				// return false, fmt.Errorf("value not match expect %t got %t", value.(bool), dataValue.(bool))
+				// fmt.Println("check failed")
+			}
+		default:
+			// return false, fmt.Errorf("unsupport type %v", reflect.TypeOf(value))
+			// fmt.Println("check failed")
+		}
+		// return true, nil
+		// fmt.Println("check pass")
+	*/
+}
+
+func (e *Executor) CheckRow(count int, data *connector.Data) {
+
+	if len(data.Data) != count {
+		fmt.Println("check failed !")
+	}
+}

tests/gotest/nanosupport/nanoCase.bat

+@echo off
+echo ==== start run nanosupport.go
+
+del go.*
+go mod init nano
+go mod tidy
+go build
+nano.exe -h %1 -p %2
+cd ..

tests/gotest/nanosupport/nanoCase.sh

+#!/bin/bash
+
+echo "==== start run nanosupport.go "
+
+set +e
+#set -x
+
+script_dir="$(dirname $(readlink -f $0))"
+#echo "pwd: $script_dir, para0: $0"
+
+#execName=$0
+#execName=`echo ${execName##*/}`
+#goName=`echo ${execName%.*}`
+
+###### step 3: start build
+cd $script_dir
+rm -f go.*
+go mod init nano
+go mod tidy
+go build
+sleep 10s
+./nano -h $1 -p $2

tests/gotest/nanosupport/nanosupport.go

+package main
+
+import (
+	"fmt"
+	"log"
+	"nano/connector"
+	"time"
+
+	"github.com/taosdata/go-utils/tdengine/config"
+)
+
+func main() {
+	e, err := connector.NewExecutor(&config.TDengineGo{
+		Address:     "root:taosdata@/tcp(127.0.0.1:6030)/",
+		MaxIdle:     20,
+		MaxOpen:     30,
+		MaxLifetime: 30,
+	}, "db", false)
+	if err != nil {
+		panic(err)
+	}
+	prepareData(e)
+	data, err := e.Query("select * from tb")
+	if err != nil {
+		panic(err)
+	}
+
+	layout := "2006-01-02 15:04:05.999999999"
+	t0, _ := time.Parse(layout, "2021-06-10 00:00:00.100000001")
+	t1, _ := time.Parse(layout, "2021-06-10 00:00:00.150000000")
+	t2, _ := time.Parse(layout, "2021-06-10 00:00:00.299999999")
+	t3, _ := time.Parse(layout, "2021-06-10 00:00:00.300000000")
+	t4, _ := time.Parse(layout, "2021-06-10 00:00:00.300000001")
+	t5, _ := time.Parse(layout, "2021-06-10 00:00:00.999999999")
+
+	e.CheckData2(0, 0, t0, data)
+	e.CheckData2(1, 0, t1, data)
+	e.CheckData2(2, 0, t2, data)
+	e.CheckData2(3, 0, t3, data)
+	e.CheckData2(4, 0, t4, data)
+	e.CheckData2(5, 0, t5, data)
+	e.CheckData2(3, 1, int32(3), data)
+	e.CheckData2(4, 1, int32(5), data)
+	e.CheckData2(5, 1, int32(7), data)
+
+	fmt.Println(" start check nano support!")
+
+	data, _ = e.Query("select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400100000002;")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb where ts > \"2021-06-10 0:00:00.100000001\" and ts < \"2021-06-10 0:00:00.160000000\";")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400150000000;")
+	e.CheckData2(0, 0, int64(1), data)
+	data, _ = e.Query("select count(*) from tb where ts > \"2021-06-10 0:00:00.100000000\" and ts < \"2021-06-10 0:00:00.150000000\";")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb where ts > 1623254400400000000;")
+	e.CheckData2(0, 0, int64(1), data)
+	data, _ = e.Query("select count(*) from tb where ts < \"2021-06-10 00:00:00.400000000\";")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb where ts < now + 400000000b;")
+	e.CheckData2(0, 0, int64(6), data)
+
+	data, _ = e.Query("select count(*) from tb where ts >= \"2021-06-10 0:00:00.100000001\";")
+	e.CheckData2(0, 0, int64(6), data)
+
+	data, _ = e.Query("select count(*) from tb where ts <= 1623254400300000000;")
+	e.CheckData2(0, 0, int64(4), data)
+
+	data, _ = e.Query("select count(*) from tb where ts = \"2021-06-10 0:00:00.000000000\";")
+
+	data, _ = e.Query("select count(*) from tb where ts = 1623254400150000000;")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb where ts = \"2021-06-10 0:00:00.100000001\";")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb where ts between 1623254400000000000 and 1623254400400000000;")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb where ts between \"2021-06-10 0:00:00.299999999\" and \"2021-06-10 0:00:00.300000001\";")
+	e.CheckData2(0, 0, int64(3), data)
+
+	data, _ = e.Query("select avg(speed) from tb interval(5000000000b);")
+	e.CheckRow(1, data)
+
+	data, _ = e.Query("select avg(speed) from tb interval(100000000b)")
+	e.CheckRow(4, data)
+
+	data, _ = e.Query("select avg(speed) from tb interval(1000b);")
+	e.CheckRow(5, data)
+
+	data, _ = e.Query("select avg(speed) from tb interval(1u);")
+	e.CheckRow(5, data)
+
+	data, _ = e.Query("select avg(speed) from tb interval(100000000b) sliding (100000000b);")
+	e.CheckRow(4, data)
+
+	data, _ = e.Query("select last(*) from tb")
+	tt, _ := time.Parse(layout, "2021-06-10 0:00:00.999999999")
+	e.CheckData2(0, 0, tt, data)
+
+	data, _ = e.Query("select first(*) from tb")
+	tt1, _ := time.Parse(layout, "2021-06-10 0:00:00.100000001")
+	e.CheckData2(0, 0, tt1, data)
+
+	e.Execute("insert into tb values(now + 500000000b, 6);")
+	data, _ = e.Query("select * from tb;")
+	e.CheckRow(7, data)
+
+	e.Execute("create table tb2 (ts timestamp, speed int, ts2 timestamp);")
+	e.Execute("insert into tb2 values(\"2021-06-10 0:00:00.100000001\", 1, \"2021-06-11 0:00:00.100000001\");")
+	e.Execute("insert into tb2 values(1623254400150000000, 2, 1623340800150000000);")
+	e.Execute("import into tb2 values(1623254400300000000, 3, 1623340800300000000);")
+	e.Execute("import into tb2 values(1623254400299999999, 4, 1623340800299999999);")
+	e.Execute("insert into tb2 values(1623254400300000001, 5, 1623340800300000001);")
+	e.Execute("insert into tb2 values(1623254400999999999, 7, 1623513600999999999);")
+
+	data, _ = e.Query("select * from tb2;")
+	tt2, _ := time.Parse(layout, "2021-06-10 0:00:00.100000001")
+	tt3, _ := time.Parse(layout, "2021-06-10 0:00:00.150000000")
+
+	e.CheckData2(0, 0, tt2, data)
+	e.CheckData2(1, 0, tt3, data)
+	e.CheckData2(2, 1, int32(4), data)
+	e.CheckData2(3, 1, int32(3), data)
+	tt4, _ := time.Parse(layout, "2021-06-11 00:00:00.300000001")
+	e.CheckData2(4, 2, tt4, data)
+	e.CheckRow(6, data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 > 1623340800000000000 and ts2 < 1623340800150000000;")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 > \"2021-06-11 0:00:00.100000000\" and ts2 < \"2021-06-11 0:00:00.100000002\";")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 > 1623340800500000000;")
+	e.CheckData2(0, 0, int64(1), data)
+	data, _ = e.Query("select count(*) from tb2 where ts2 < \"2021-06-11 0:00:00.400000000\";")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 < now + 400000000b;")
+	e.CheckData2(0, 0, int64(6), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 >= \"2021-06-11 0:00:00.100000001\";")
+	e.CheckData2(0, 0, int64(6), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 <= 1623340800400000000;")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 = \"2021-06-11 0:00:00.000000000\";")
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 = \"2021-06-11 0:00:00.300000001\";")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 = 1623340800300000001;")
+	e.CheckData2(0, 0, int64(1), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 between 1623340800000000000 and 1623340800450000000;")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 between \"2021-06-11 0:00:00.299999999\" and \"2021-06-11 0:00:00.300000001\";")
+	e.CheckData2(0, 0, int64(3), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 <> 1623513600999999999;")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 <> \"2021-06-11 0:00:00.100000001\";")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 <> \"2021-06-11 0:00:00.100000000\";")
+	e.CheckData2(0, 0, int64(6), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 != 1623513600999999999;")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 != \"2021-06-11 0:00:00.100000001\";")
+	e.CheckData2(0, 0, int64(5), data)
+
+	data, _ = e.Query("select count(*) from tb2 where ts2 != \"2021-06-11 0:00:00.100000000\";")
+	e.CheckData2(0, 0, int64(6), data)
+
+	e.Execute("insert into tb2 values(now + 500000000b, 6, now +2d);")
+	data, _ = e.Query("select * from tb2;")
+	e.CheckRow(7, data)
+
+	e.Execute("create table tb3 (ts timestamp, speed int);")
+	_, err = e.Execute("insert into tb3 values(16232544001500000, 2);")
+	if err != nil {
+		fmt.Println("check pass! ")
+	}
+
+	e.Execute("insert into tb3 values(\"2021-06-10 0:00:00.123456\", 2);")
+	data, _ = e.Query("select * from tb3 where ts = \"2021-06-10 0:00:00.123456000\";")
+	e.CheckRow(1, data)
+
+	e.Execute("insert into tb3 values(\"2021-06-10 0:00:00.123456789000\", 2);")
+	data, _ = e.Query("select * from tb3 where ts = \"2021-06-10 0:00:00.123456789\";")
+	e.CheckRow(1, data)
+
+	// check timezone support
+
+	e.Execute("drop database if exists nsdb;")
+	e.Execute("create database nsdb precision 'ns';")
+	e.Execute("use nsdb;")
+	e.Execute("create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);")
+	e.Execute("insert into tb1 using st tags('2021-06-10 0:00:00.123456789' , 1 ) values('2021-06-10T0:00:00.123456789+07:00' , 1.0);")
+	data, _ = e.Query("select first(*) from tb1;")
+
+	ttt, _ := time.Parse(layout, "2021-06-10 01:00:00.123456789")
+	e.CheckData2(0, 0, ttt, data)
+
+	e.Execute("create database usdb precision 'us';")
+	e.Execute("use usdb;")
+	e.Execute("create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);")
+	e.Execute("insert into tb1 using st tags('2021-06-10 0:00:00.123456' , 1 ) values('2021-06-10T0:00:00.123456+07:00' , 1.0);")
+	data, _ = e.Query("select first(*) from tb1;")
+	ttt2, _ := time.Parse(layout, "2021-06-10 01:00:00.123456")
+	e.CheckData2(0, 0, ttt2, data)
+
+	e.Execute("drop database if exists msdb;")
+	e.Execute("create database msdb precision 'ms';")
+	e.Execute("use msdb;")
+	e.Execute("create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);")
+	e.Execute("insert into tb1 using st tags('2021-06-10 0:00:00.123' , 1 ) values('2021-06-10T0:00:00.123+07:00' , 1.0);")
+	data, _ = e.Query("select first(*) from tb1;")
+	ttt3, _ := time.Parse(layout, "2021-06-10 01:00:00.123")
+	e.CheckData2(0, 0, ttt3, data)
+	fmt.Println("all test done!")
+
+}
+
+func prepareData(e *connector.Executor) {
+	sqlList := []string{
+		"reset query cache;",
+		"drop database if exists db;",
+		"create database db;",
+		"use db;",
+		"reset query cache;",
+		"drop database if exists db;",
+		"create database db precision 'ns';",
+		"show databases;",
+		"use db;",
+		"create table tb (ts timestamp, speed int);",
+		"insert into tb values('2021-06-10 0:00:00.100000001', 1);",
+		"insert into tb values(1623254400150000000, 2);",
+		"import into tb values(1623254400300000000, 3);",
+		"import into tb values(1623254400299999999, 4);",
+		"insert into tb values(1623254400300000001, 5);",
+		"insert into tb values(1623254400999999999, 7);",
+	}
+	for _, sql := range sqlList {
+		err := executeSql(e, sql)
+		if err != nil {
+			log.Fatalf("prepare data error:%v, sql:%s", err, sql)
+		}
+	}
+}
+
+func executeSql(e *connector.Executor, sql string) error {
+	_, err := e.Execute(sql)
+	if err != nil {
+		return err
+	}
+	return nil
+}