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 <[email protected]>
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)
+ }
}
```
