You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by cr...@apache.org on 2026/03/26 11:09:34 UTC

(iotdb-docs) branch main updated: update go example code (#1045)

This is an automated email from the ASF dual-hosted git repository.

critas pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/iotdb-docs.git


The following commit(s) were added to refs/heads/main by this push:
     new 6ca5ce0d update go example code (#1045)
6ca5ce0d is described below

commit 6ca5ce0d7c6b2844b0171bc362ff70dd44e7123b
Author: leto-b <bi...@timecho.com>
AuthorDate: Thu Mar 26 19:09:28 2026 +0800

    update go example code (#1045)
---
 .../Table/API/Programming-Go-Native-API_apache.md  | 520 +++++++++++----------
 .../Table/API/Programming-Go-Native-API_timecho.md | 520 +++++++++++----------
 .../API/Programming-Go-Native-API_apache.md        | 520 +++++++++++----------
 .../API/Programming-Go-Native-API_timecho.md       | 520 +++++++++++----------
 .../Table/API/Programming-Go-Native-API_apache.md  | 520 +++++++++++----------
 .../Table/API/Programming-Go-Native-API_timecho.md | 520 +++++++++++----------
 .../API/Programming-Go-Native-API_apache.md        | 520 +++++++++++----------
 .../API/Programming-Go-Native-API_timecho.md       | 520 +++++++++++----------
 8 files changed, 2096 insertions(+), 2064 deletions(-)

diff --git a/src/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md b/src/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
index 0d7cc435..41ab8637 100644
--- a/src/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
+++ b/src/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
@@ -196,143 +196,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -415,158 +420,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md b/src/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
index 18fa3dc0..41ab8637 100644
--- a/src/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
+++ b/src/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
@@ -196,143 +196,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -415,158 +420,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md b/src/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
index 0d7cc435..41ab8637 100644
--- a/src/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
+++ b/src/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
@@ -196,143 +196,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -415,158 +420,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md b/src/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
index 18fa3dc0..41ab8637 100644
--- a/src/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
+++ b/src/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
@@ -196,143 +196,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -415,158 +420,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //before V2.0.6 it is root
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md b/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
index 2892a321..ad109f41 100644
--- a/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
+++ b/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_apache.md
@@ -218,143 +218,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -437,158 +442,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md b/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
index 8866227d..ad109f41 100644
--- a/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
+++ b/src/zh/UserGuide/Master/Table/API/Programming-Go-Native-API_timecho.md
@@ -218,143 +218,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -437,158 +442,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md b/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
index 2892a321..ad109f41 100644
--- a/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
+++ b/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_apache.md
@@ -218,143 +218,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -437,158 +442,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "root",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
diff --git a/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md b/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
index 8866227d..ad109f41 100644
--- a/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
+++ b/src/zh/UserGuide/latest-Table/API/Programming-Go-Native-API_timecho.md
@@ -218,143 +218,148 @@ func NewClusterTableSession(clusterConfig *ClusterConfig, enableRPCCompression b
 package main
 
 import (
-   "flag"
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "math/rand"
-   "strconv"
-   "time"
+	"flag"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   flag.Parse()
-   config := &client.Config{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_session",
-   }
-   session, err := client.NewTableSession(config, false, 0)
-   if err != nil {
-      log.Fatal(err)
-   }
-   defer session.Close()
-
-   checkError(session.ExecuteNonQueryStatement("create database test_db"))
-   checkError(session.ExecuteNonQueryStatement("use test_db"))
-   checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-   insertRelationalTablet(session)
-   showTables(session)
-   query(session)
+	flag.Parse()
+	config := &client.Config{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_session",
+	}
+	session, err := client.NewTableSession(config, false, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer session.Close()
+
+	checkError(session.ExecuteNonQueryStatement("create database test_db"))
+	checkError(session.ExecuteNonQueryStatement("use test_db"))
+	checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+	insertRelationalTablet(session)
+	showTables(session)
+	query(session)
 }
 
 func getTextValueFromDataSet(dataSet *client.SessionDataSet, columnName string) string {
-   if dataSet.IsNull(columnName) {
-      return "null"
-   } else {
-      return dataSet.GetText(columnName)
-   }
+	if isNull, err := dataSet.IsNull(columnName); err != nil {
+		log.Fatal(err)
+	} else if isNull {
+		return "null"
+	}
+	v, err := dataSet.GetString(columnName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return v
 }
 
 func insertRelationalTablet(session client.ITableSession) {
-   tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
-      {
-         Measurement: "id1",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "id2",
-         DataType:    client.STRING,
-      },
-      {
-         Measurement: "s1",
-         DataType:    client.TEXT,
-      },
-      {
-         Measurement: "s2",
-         DataType:    client.TEXT,
-      },
-   }, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
-   if err != nil {
-      log.Fatal("Failed to create relational tablet {}", err)
-   }
-   ts := time.Now().UTC().UnixNano() / 1000000
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_"+strconv.Itoa(row), 0, row)
-      tablet.SetValueAt("id2_field_"+strconv.Itoa(row), 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
-
-   tablet.Reset()
-
-   for row := 0; row < 16; row++ {
-      ts++
-      tablet.SetTimestamp(ts, row)
-      tablet.SetValueAt("id1_field_1", 0, row)
-      tablet.SetValueAt("id2_field_1", 1, row)
-      tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
-      tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
-
-      nullValueColumn := rand.Intn(4)
-      tablet.SetValueAt(nil, nullValueColumn, row)
-      tablet.RowSize++
-   }
-   checkError(session.Insert(tablet))
+	tablet, err := client.NewRelationalTablet("t1", []*client.MeasurementSchema{
+		{
+			Measurement: "tag1",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "tag2",
+			DataType:    client.STRING,
+		},
+		{
+			Measurement: "s1",
+			DataType:    client.TEXT,
+		},
+		{
+			Measurement: "s2",
+			DataType:    client.TEXT,
+		},
+	}, []client.ColumnCategory{client.TAG, client.TAG, client.FIELD, client.FIELD}, 1024)
+	if err != nil {
+		log.Fatal("Failed to create relational tablet {}", err)
+	}
+	ts := time.Now().UTC().UnixNano() / 1000000
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_"+strconv.Itoa(row), 0, row)
+		tablet.SetValueAt("tag2_value_"+strconv.Itoa(row), 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
+
+	tablet.Reset()
+
+	for row := 0; row < 16; row++ {
+		ts++
+		tablet.SetTimestamp(ts, row)
+		tablet.SetValueAt("tag1_value_1", 0, row)
+		tablet.SetValueAt("tag2_value_1", 1, row)
+		tablet.SetValueAt("s1_value_"+strconv.Itoa(row), 2, row)
+		tablet.SetValueAt("s2_value_"+strconv.Itoa(row), 3, row)
+
+		nullValueColumn := rand.Intn(4)
+		tablet.SetValueAt(nil, nullValueColumn, row)
+		tablet.RowSize++
+	}
+	checkError(session.Insert(tablet))
 }
 
 func showTables(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("tableName is", dataSet.GetText("TableName"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		value, err := dataSet.GetString("TableName")
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Printf("tableName is %v", value)
+	}
 }
 
 func query(session client.ITableSession) {
-   timeout := int64(2000)
-   dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
-   if err != nil {
-      log.Fatal(err)
-   }
-   for {
-      hasNext, err := dataSet.Next()
-      if err != nil {
-         log.Fatal(err)
-      }
-      if !hasNext {
-         break
-      }
-      log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "id1"), getTextValueFromDataSet(dataSet, "id2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
-   }
+	timeout := int64(2000)
+	dataSet, err := session.ExecuteQueryStatement("select * from t1", &timeout)
+	defer dataSet.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	for {
+		hasNext, err := dataSet.Next()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !hasNext {
+			break
+		}
+		log.Printf("%v %v %v %v", getTextValueFromDataSet(dataSet, "tag1"), getTextValueFromDataSet(dataSet, "tag2"), getTextValueFromDataSet(dataSet, "s1"), getTextValueFromDataSet(dataSet, "s2"))
+	}
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```
 
@@ -437,158 +442,157 @@ func NewTableSessionPool(conf *PoolConfig, maxSize, connectionTimeoutInMs, waitT
 package main
 
 import (
-   "github.com/apache/iotdb-client-go/client"
-   "github.com/apache/iotdb-client-go/common"
-   "log"
-   "strconv"
-   "sync"
-   "sync/atomic"
-   "time"
+	"log"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/apache/iotdb-client-go/v2/client"
 )
 
 func main() {
-   sessionPoolWithSpecificDatabaseExample()
-   sessionPoolWithoutSpecificDatabaseExample()
-   putBackToSessionPoolExample()
+	sessionPoolWithSpecificDatabaseExample()
+	sessionPoolWithoutSpecificDatabaseExample()
+	putBackToSessionPoolExample()
 }
 
 func putBackToSessionPoolExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
-   defer sessionPool.Close()
-
-   num := 4
-   successGetSessionNum := int32(0)
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database "+dbName+"because ", err)
-            return
-         }
-         atomic.AddInt32(&successGetSessionNum, 1)
-         defer func() {
-            time.Sleep(6 * time.Second)
-            // put back to session pool
-            session.Close()
-         }()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
-   log.Println("success num is", successGetSessionNum)
-
-   log.Println("All session's database have been reset.")
-   // the using database will automatically reset to session pool's database after the session closed
-   wg.Add(5)
-   for i := 0; i < 5; i++ {
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to get session because ", err)
-         }
-         defer session.Close()
-         timeout := int64(3000)
-         dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
-         for {
-            hasNext, err := dataSet.Next()
-            if err != nil {
-               log.Fatal(err)
-            }
-            if !hasNext {
-               break
-            }
-            log.Println("table is", dataSet.GetText("TableName"))
-         }
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 4000, false)
+	defer sessionPool.Close()
+
+	num := 4
+	successGetSessionNum := int32(0)
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database "+dbName+"because ", err)
+				return
+			}
+			atomic.AddInt32(&successGetSessionNum, 1)
+			defer func() {
+				time.Sleep(6 * time.Second)
+				// put back to session pool
+				session.Close()
+			}()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table table_of_" + dbName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
+	log.Println("success num is", successGetSessionNum)
+
+	log.Println("All session's database have been reset.")
+	// the using database will automatically reset to session pool's database after the session closed
+	wg.Add(5)
+	for i := 0; i < 5; i++ {
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to get session because ", err)
+			}
+			defer session.Close()
+			timeout := int64(3000)
+			dataSet, err := session.ExecuteQueryStatement("show tables", &timeout)
+			for {
+				hasNext, err := dataSet.Next()
+				if err != nil {
+					log.Fatal(err)
+				}
+				if !hasNext {
+					break
+				}
+				value, err := dataSet.GetString("TableName")
+				if err != nil {
+					log.Fatal(err)
+				}
+				log.Println("table is", value)
+			}
+			dataSet.Close()
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithSpecificDatabaseExample() {
-   // should create database test_db before executing
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-      Database: "test_db",
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      tableName := "t" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create table "+tableName+"because ", err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	// should create database test_db before executing
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+		Database: "test_db",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		tableName := "t" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create table "+tableName+"because ", err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create table " + tableName + " (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
 func sessionPoolWithoutSpecificDatabaseExample() {
-   config := &client.PoolConfig{
-      Host:     "127.0.0.1",
-      Port:     "6667",
-      UserName: "root",
-      Password: "TimechoDB@2021", //V2.0.6.x 之前默认密码是root 
-   }
-   sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
-   defer sessionPool.Close()
-   num := 10
-   var wg sync.WaitGroup
-   wg.Add(num)
-   for i := 0; i < num; i++ {
-      dbName := "db" + strconv.Itoa(i)
-      go func() {
-         defer wg.Done()
-         session, err := sessionPool.GetSession()
-         if err != nil {
-            log.Println("Failed to create database ", dbName, err)
-            return
-         }
-         defer session.Close()
-         checkError(session.ExecuteNonQueryStatement("create database " + dbName))
-         checkError(session.ExecuteNonQueryStatement("use " + dbName))
-         checkError(session.ExecuteNonQueryStatement("create table t1 (id1 string tag, id2 string tag, s1 text field, s2 text field)"))
-      }()
-   }
-   wg.Wait()
+	config := &client.PoolConfig{
+		Host:     "127.0.0.1",
+		Port:     "6667",
+		UserName: "root",
+		Password: "root",
+	}
+	sessionPool := client.NewTableSessionPool(config, 3, 60000, 8000, false)
+	defer sessionPool.Close()
+	num := 10
+	var wg sync.WaitGroup
+	wg.Add(num)
+	for i := 0; i < num; i++ {
+		dbName := "db" + strconv.Itoa(i)
+		go func() {
+			defer wg.Done()
+			session, err := sessionPool.GetSession()
+			if err != nil {
+				log.Println("Failed to create database ", dbName, err)
+				return
+			}
+			defer session.Close()
+			checkError(session.ExecuteNonQueryStatement("create database " + dbName))
+			checkError(session.ExecuteNonQueryStatement("use " + dbName))
+			checkError(session.ExecuteNonQueryStatement("create table t1 (tag1 string tag, tag2 string tag, s1 text field, s2 text field)"))
+		}()
+	}
+	wg.Wait()
 }
 
-func checkError(status *common.TSStatus, err error) {
-   if err != nil {
-      log.Fatal(err)
-   }
-
-   if status != nil {
-      if err = client.VerifySuccess(status); err != nil {
-         log.Println(err)
-      }
-   }
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 ```