From 2fe5cb1c92d3d9a4ef14de71ff77a985d67344d3 Mon Sep 17 00:00:00 2001 From: Matt Clegg Date: Tue, 22 Oct 2024 13:25:40 +0100 Subject: [PATCH] DOCS: consistent whitepspacing example code Signed-off-by: Matt Clegg --- README.md | 656 +++++++++++++++++++++++++++--------------------------- 1 file changed, 328 insertions(+), 328 deletions(-) diff --git a/README.md b/README.md index 49a98427..7300f993 100644 --- a/README.md +++ b/README.md @@ -67,14 +67,14 @@ There are also other examples in the API docs: #### Go mod project 1. Add the latest version of the client package to your project dependencies (go.mod). - ```sh - go get github.com/influxdata/influxdb-client-go/v2 - ``` +```sh +go get github.com/influxdata/influxdb-client-go/v2 +``` 1. Add import `github.com/influxdata/influxdb-client-go/v2` to your source code. #### GOPATH project - ```sh - go get github.com/influxdata/influxdb-client-go - ``` +```sh +go get github.com/influxdata/influxdb-client-go +``` Note: To have _go get_ in the GOPATH mode, the environment variable `GO111MODULE` must have the `off` value. ### Basic Example @@ -83,64 +83,64 @@ The following example demonstrates how to write data to InfluxDB 2 and read them package main import ( - "context" - "fmt" - "time" + "context" + "fmt" + "time" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Use blocking write client for writes to desired bucket - writeAPI := client.WriteAPIBlocking("my-org", "my-bucket") - // Create point using full params constructor - p := influxdb2.NewPoint("stat", - map[string]string{"unit": "temperature"}, - map[string]interface{}{"avg": 24.5, "max": 45.0}, - time.Now()) - // write point immediately - writeAPI.WritePoint(context.Background(), p) - // Create point using fluent style - p = influxdb2.NewPointWithMeasurement("stat"). - AddTag("unit", "temperature"). - AddField("avg", 23.2). - AddField("max", 45.0). - SetTime(time.Now()) - err := writeAPI.WritePoint(context.Background(), p) + // Create a new client using an InfluxDB server base URL and an authentication token + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Use blocking write client for writes to desired bucket + writeAPI := client.WriteAPIBlocking("my-org", "my-bucket") + // Create point using full params constructor + p := influxdb2.NewPoint("stat", + map[string]string{"unit": "temperature"}, + map[string]interface{}{"avg": 24.5, "max": 45.0}, + time.Now()) + // write point immediately + writeAPI.WritePoint(context.Background(), p) + // Create point using fluent style + p = influxdb2.NewPointWithMeasurement("stat"). + AddTag("unit", "temperature"). + AddField("avg", 23.2). + AddField("max", 45.0). + SetTime(time.Now()) + err := writeAPI.WritePoint(context.Background(), p) if err != nil { panic(err) } - // Or write directly line protocol - line := fmt.Sprintf("stat,unit=temperature avg=%f,max=%f", 23.5, 45.0) - err = writeAPI.WriteRecord(context.Background(), line) + // Or write directly line protocol + line := fmt.Sprintf("stat,unit=temperature avg=%f,max=%f", 23.5, 45.0) + err = writeAPI.WriteRecord(context.Background(), line) if err != nil { panic(err) } - // Get query client - queryAPI := client.QueryAPI("my-org") - // Get parser flux query result - result, err := queryAPI.Query(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) - if err == nil { - // Use Next() to iterate over query result lines - for result.Next() { - // Observe when there is new grouping key producing new table - if result.TableChanged() { - fmt.Printf("table: %s\n", result.TableMetadata().String()) - } - // read result - fmt.Printf("row: %s\n", result.Record().String()) - } - if result.Err() != nil { - fmt.Printf("Query error: %s\n", result.Err().Error()) - } - } else { + // Get query client + queryAPI := client.QueryAPI("my-org") + // Get parser flux query result + result, err := queryAPI.Query(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) + if err == nil { + // Use Next() to iterate over query result lines + for result.Next() { + // Observe when there is new grouping key producing new table + if result.TableChanged() { + fmt.Printf("table: %s\n", result.TableMetadata().String()) + } + // read result + fmt.Printf("row: %s\n", result.Record().String()) + } + if result.Err() != nil { + fmt.Printf("Query error: %s\n", result.Err().Error()) + } + } else { panic(err) - } - // Ensures background processes finishes - client.Close() + } + // Ensures background processes finishes + client.Close() } ``` ### Options @@ -155,11 +155,11 @@ To set different configuration values, e.g. to set gzip compression and trust al and change what is needed: ```go client := influxdb2.NewClientWithOptions("http://localhost:8086", "my-token", - influxdb2.DefaultOptions(). - SetUseGZip(true). - SetTLSConfig(&tls.Config{ - InsecureSkipVerify: true, - })) + influxdb2.DefaultOptions(). + SetUseGZip(true). + SetTLSConfig(&tls.Config{ + InsecureSkipVerify: true, + })) ``` ### Writes @@ -180,45 +180,45 @@ Asynchronous write client is recommended for frequent periodic writes. package main import ( - "fmt" - "math/rand" - "time" + "fmt" + "math/rand" + "time" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - // and set batch size to 20 - client := influxdb2.NewClientWithOptions("http://localhost:8086", "my-token", - influxdb2.DefaultOptions().SetBatchSize(20)) - // Get non-blocking write client - writeAPI := client.WriteAPI("my-org","my-bucket") - // write some points - for i := 0; i <100; i++ { - // create point - p := influxdb2.NewPoint( - "system", - map[string]string{ - "id": fmt.Sprintf("rack_%v", i%10), - "vendor": "AWS", - "hostname": fmt.Sprintf("host_%v", i%100), - }, - map[string]interface{}{ - "temperature": rand.Float64() * 80.0, - "disk_free": rand.Float64() * 1000.0, - "disk_total": (i/10 + 1) * 1000000, - "mem_total": (i/100 + 1) * 10000000, - "mem_free": rand.Uint64(), - }, - time.Now()) - // write asynchronously - writeAPI.WritePoint(p) - } - // Force all unwritten data to be sent - writeAPI.Flush() - // Ensures background processes finishes - client.Close() + // Create a new client using an InfluxDB server base URL and an authentication token + // and set batch size to 20 + client := influxdb2.NewClientWithOptions("http://localhost:8086", "my-token", + influxdb2.DefaultOptions().SetBatchSize(20)) + // Get non-blocking write client + writeAPI := client.WriteAPI("my-org","my-bucket") + // write some points + for i := 0; i <100; i++ { + // create point + p := influxdb2.NewPoint( + "system", + map[string]string{ + "id": fmt.Sprintf("rack_%v", i%10), + "vendor": "AWS", + "hostname": fmt.Sprintf("host_%v", i%100), + }, + map[string]interface{}{ + "temperature": rand.Float64() * 80.0, + "disk_free": rand.Float64() * 1000.0, + "disk_total": (i/10 + 1) * 1000000, + "mem_total": (i/100 + 1) * 10000000, + "mem_free": rand.Uint64(), + }, + time.Now()) + // write asynchronously + writeAPI.WritePoint(p) + } + // Force all unwritten data to be sent + writeAPI.Flush() + // Ensures background processes finishes + client.Close() } ``` ### Handling of failed async writes @@ -256,46 +256,46 @@ WriteAPI automatically logs write errors. Use [Errors()](https://pkg.go.dev/gith package main import ( - "fmt" - "math/rand" - "time" + "fmt" + "math/rand" + "time" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Get non-blocking write client - writeAPI := client.WriteAPI("my-org", "my-bucket") - // Get errors channel - errorsCh := writeAPI.Errors() - // Create go proc for reading and logging errors - go func() { - for err := range errorsCh { - fmt.Printf("write error: %s\n", err.Error()) - } - }() - // write some points - for i := 0; i < 100; i++ { - // create point - p := influxdb2.NewPointWithMeasurement("stat"). - AddTag("id", fmt.Sprintf("rack_%v", i%10)). - AddTag("vendor", "AWS"). - AddTag("hostname", fmt.Sprintf("host_%v", i%100)). - AddField("temperature", rand.Float64()*80.0). - AddField("disk_free", rand.Float64()*1000.0). - AddField("disk_total", (i/10+1)*1000000). - AddField("mem_total", (i/100+1)*10000000). - AddField("mem_free", rand.Uint64()). - SetTime(time.Now()) - // write asynchronously - writeAPI.WritePoint(p) - } - // Force all unwritten data to be sent - writeAPI.Flush() - // Ensures background processes finishes - client.Close() + // Create a new client using an InfluxDB server base URL and an authentication token + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Get non-blocking write client + writeAPI := client.WriteAPI("my-org", "my-bucket") + // Get errors channel + errorsCh := writeAPI.Errors() + // Create go proc for reading and logging errors + go func() { + for err := range errorsCh { + fmt.Printf("write error: %s\n", err.Error()) + } + }() + // write some points + for i := 0; i < 100; i++ { + // create point + p := influxdb2.NewPointWithMeasurement("stat"). + AddTag("id", fmt.Sprintf("rack_%v", i%10)). + AddTag("vendor", "AWS"). + AddTag("hostname", fmt.Sprintf("host_%v", i%100)). + AddField("temperature", rand.Float64()*80.0). + AddField("disk_free", rand.Float64()*1000.0). + AddField("disk_total", (i/10+1)*1000000). + AddField("mem_total", (i/100+1)*10000000). + AddField("mem_free", rand.Uint64()). + SetTime(time.Now()) + // write asynchronously + writeAPI.WritePoint(p) + } + // Force all unwritten data to be sent + writeAPI.Flush() + // Ensures background processes finishes + client.Close() } ``` @@ -307,45 +307,45 @@ Implicit batching can be enabled with `WriteAPIBlocking.EnableBatching()`. package main import ( - "context" - "fmt" - "math/rand" - "time" + "context" + "fmt" + "math/rand" + "time" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Get blocking write client - writeAPI := client.WriteAPIBlocking("my-org","my-bucket") - // write some points - for i := 0; i <100; i++ { - // create data point - p := influxdb2.NewPoint( - "system", - map[string]string{ - "id": fmt.Sprintf("rack_%v", i%10), - "vendor": "AWS", - "hostname": fmt.Sprintf("host_%v", i%100), - }, - map[string]interface{}{ - "temperature": rand.Float64() * 80.0, - "disk_free": rand.Float64() * 1000.0, - "disk_total": (i/10 + 1) * 1000000, - "mem_total": (i/100 + 1) * 10000000, - "mem_free": rand.Uint64(), - }, - time.Now()) - // write synchronously - err := writeAPI.WritePoint(context.Background(), p) - if err != nil { - panic(err) - } - } - // Ensures background processes finishes - client.Close() + // Create a new client using an InfluxDB server base URL and an authentication token + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Get blocking write client + writeAPI := client.WriteAPIBlocking("my-org","my-bucket") + // write some points + for i := 0; i <100; i++ { + // create data point + p := influxdb2.NewPoint( + "system", + map[string]string{ + "id": fmt.Sprintf("rack_%v", i%10), + "vendor": "AWS", + "hostname": fmt.Sprintf("host_%v", i%100), + }, + map[string]interface{}{ + "temperature": rand.Float64() * 80.0, + "disk_free": rand.Float64() * 1000.0, + "disk_total": (i/10 + 1) * 1000000, + "mem_total": (i/100 + 1) * 10000000, + "mem_free": rand.Uint64(), + }, + time.Now()) + // write synchronously + err := writeAPI.WritePoint(context.Background(), p) + if err != nil { + panic(err) + } + } + // Ensures background processes finishes + client.Close() } ``` @@ -360,38 +360,38 @@ for easy reading the result. package main import ( - "context" - "fmt" + "context" + "fmt" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Get query client - queryAPI := client.QueryAPI("my-org") - // get QueryTableResult - result, err := queryAPI.Query(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) - if err == nil { - // Iterate over query response - for result.Next() { - // Notice when group key has changed - if result.TableChanged() { - fmt.Printf("table: %s\n", result.TableMetadata().String()) - } - // Access data - fmt.Printf("value: %v\n", result.Record().Value()) - } - // check for an error - if result.Err() != nil { - fmt.Printf("query parsing error: %s\n", result.Err().Error()) - } - } else { - panic(err) - } - // Ensures background processes finishes - client.Close() + // Create a new client using an InfluxDB server base URL and an authentication token + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Get query client + queryAPI := client.QueryAPI("my-org") + // get QueryTableResult + result, err := queryAPI.Query(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) + if err == nil { + // Iterate over query response + for result.Next() { + // Notice when group key has changed + if result.TableChanged() { + fmt.Printf("table: %s\n", result.TableMetadata().String()) + } + // Access data + fmt.Printf("value: %v\n", result.Record().Value()) + } + // check for an error + if result.Err() != nil { + fmt.Printf("query parsing error: %s\n", result.Err().Error()) + } + } else { + panic(err) + } + // Ensures background processes finishes + client.Close() } ``` @@ -403,28 +403,28 @@ can be controlled by the third parameter, query dialect. package main import ( - "context" - "fmt" + "context" + "fmt" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - // Create a new client using an InfluxDB server base URL and an authentication token - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Get query client - queryAPI := client.QueryAPI("my-org") - // Query and get complete result as a string - // Use default dialect - result, err := queryAPI.QueryRaw(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`, influxdb2.DefaultDialect()) - if err == nil { - fmt.Println("QueryResult:") - fmt.Println(result) - } else { - panic(err) - } - // Ensures background processes finishes - client.Close() + // Create a new client using an InfluxDB server base URL and an authentication token + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Get query client + queryAPI := client.QueryAPI("my-org") + // Query and get complete result as a string + // Use default dialect + result, err := queryAPI.QueryRaw(context.Background(), `from(bucket:"my-bucket")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`, influxdb2.DefaultDialect()) + if err == nil { + fmt.Println("QueryResult:") + fmt.Println(result) + } else { + panic(err) + } + // Ensures background processes finishes + client.Close() } ``` ### Parametrized Queries @@ -506,26 +506,26 @@ most importantly reusing HTTP connections. For efficient reuse of HTTP resources among multiple clients, create an HTTP client and use `Options.SetHTTPClient()` for setting it to all clients: ```go - // Create HTTP client - httpClient := &http.Client{ - Timeout: time.Second * time.Duration(60), - Transport: &http.Transport{ - DialContext: (&net.Dialer{ - Timeout: 5 * time.Second, - }).DialContext, - TLSHandshakeTimeout: 5 * time.Second, - TLSClientConfig: &tls.Config{ - InsecureSkipVerify: true, - }, - MaxIdleConns: 100, - MaxIdleConnsPerHost: 100, - IdleConnTimeout: 90 * time.Second, - }, - } - // Client for server 1 - client1 := influxdb2.NewClientWithOptions("https://server:8086", "my-token", influxdb2.DefaultOptions().SetHTTPClient(httpClient)) - // Client for server 2 - client2 := influxdb2.NewClientWithOptions("https://server:9999", "my-token2", influxdb2.DefaultOptions().SetHTTPClient(httpClient)) + // Create HTTP client + httpClient := &http.Client{ + Timeout: time.Second * time.Duration(60), + Transport: &http.Transport{ + DialContext: (&net.Dialer{ + Timeout: 5 * time.Second, + }).DialContext, + TLSHandshakeTimeout: 5 * time.Second, + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, + }, + MaxIdleConns: 100, + MaxIdleConnsPerHost: 100, + IdleConnTimeout: 90 * time.Second, + }, + } + // Client for server 1 + client1 := influxdb2.NewClientWithOptions("https://server:8086", "my-token", influxdb2.DefaultOptions().SetHTTPClient(httpClient)) + // Client for server 2 + client2 := influxdb2.NewClientWithOptions("https://server:9999", "my-token2", influxdb2.DefaultOptions().SetHTTPClient(httpClient)) ``` Client ensures that there is a single instance of each server API sub-client for the specific area. E.g. a single `WriteAPI` instance for each org/bucket pair, @@ -545,63 +545,63 @@ import ( ) func main() { - // Create client - client := influxdb2.NewClient("http://localhost:8086", "my-token") - // Ensure closing the client - defer client.Close() - - // Get write client - writeApi := client.WriteAPI("my-org", "my-bucket") - - // Create channel for points feeding - pointsCh := make(chan *write.Point, 200) - - threads := 5 - - var wg sync.WaitGroup - go func(points int) { - for i := 0; i < points; i++ { - p := influxdb2.NewPoint("meas", - map[string]string{"tag": "tagvalue"}, - map[string]interface{}{"val1": rand.Int63n(1000), "val2": rand.Float64()*100.0 - 50.0}, - time.Now()) - pointsCh <- p - } - close(pointsCh) - }(1000000) - - // Launch write routines - for t := 0; t < threads; t++ { - wg.Add(1) - go func() { - for p := range pointsCh { - writeApi.WritePoint(p) - } - wg.Done() - }() - } - // Wait for writes complete - wg.Wait() + // Create client + client := influxdb2.NewClient("http://localhost:8086", "my-token") + // Ensure closing the client + defer client.Close() + + // Get write client + writeApi := client.WriteAPI("my-org", "my-bucket") + + // Create channel for points feeding + pointsCh := make(chan *write.Point, 200) + + threads := 5 + + var wg sync.WaitGroup + go func(points int) { + for i := 0; i < points; i++ { + p := influxdb2.NewPoint("meas", + map[string]string{"tag": "tagvalue"}, + map[string]interface{}{"val1": rand.Int63n(1000), "val2": rand.Float64()*100.0 - 50.0}, + time.Now()) + pointsCh <- p + } + close(pointsCh) + }(1000000) + + // Launch write routines + for t := 0; t < threads; t++ { + wg.Add(1) + go func() { + for p := range pointsCh { + writeApi.WritePoint(p) + } + wg.Done() + }() + } + // Wait for writes complete + wg.Wait() } ``` ### Proxy and redirects You can configure InfluxDB Go client behind a proxy in two ways: - 1. Using environment variable - Set environment variable `HTTP_PROXY` (or `HTTPS_PROXY` based on the scheme of your server url). - e.g. (linux) `export HTTP_PROXY=http://my-proxy:8080` or in Go code `os.Setenv("HTTP_PROXY","http://my-proxy:8080")` - - 1. Configure `http.Client` to use proxy
- Create a custom `http.Client` with a proxy configuration: - ```go - proxyUrl, err := url.Parse("http://my-proxy:8080") - httpClient := &http.Client{ - Transport: &http.Transport{ - Proxy: http.ProxyURL(proxyUrl) - } - } - client := influxdb2.NewClientWithOptions("http://localhost:8086", token, influxdb2.DefaultOptions().SetHTTPClient(httpClient)) - ``` +1. Using environment variable + Set environment variable `HTTP_PROXY` (or `HTTPS_PROXY` based on the scheme of your server url). + e.g. (linux) `export HTTP_PROXY=http://my-proxy:8080` or in Go code `os.Setenv("HTTP_PROXY","http://my-proxy:8080")` + +1. Configure `http.Client` to use proxy
+ Create a custom `http.Client` with a proxy configuration: +```go +proxyUrl, err := url.Parse("http://my-proxy:8080") +httpClient := &http.Client{ + Transport: &http.Transport{ + Proxy: http.ProxyURL(proxyUrl) + } +} +client := influxdb2.NewClientWithOptions("http://localhost:8086", token, influxdb2.DefaultOptions().SetHTTPClient(httpClient)) +``` Client automatically follows HTTP redirects. The default redirect policy is to follow up to 10 consecutive requests. Due to a security reason _Authorization_ header is not forwarded when redirect leads to a different domain. @@ -610,10 +610,10 @@ You can configure InfluxDB Go client behind a proxy in two ways: token := "my-token" httpClient := &http.Client{ - CheckRedirect: func(req *http.Request, via []*http.Request) error { - req.Header.Add("Authorization","Token " + token) - return nil - }, + CheckRedirect: func(req *http.Request, via []*http.Request) error { + req.Header.Add("Authorization","Token " + token) + return nil + }, } client := influxdb2.NewClientWithOptions("http://localhost:8086", token, influxdb2.DefaultOptions().SetHTTPClient(httpClient)) ``` @@ -652,53 +652,53 @@ Only the [Ping()](https://pkg.go.dev/github.com/influxdata/influxdb-client-go/v2 package main import ( - "context" - "fmt" - "time" + "context" + "fmt" + "time" - "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2" ) func main() { - userName := "my-user" - password := "my-password" - // Create a new client using an InfluxDB server base URL and an authentication token - // For authentication token supply a string in the form: "username:password" as a token. Set empty value for an unauthenticated server - client := influxdb2.NewClient("http://localhost:8086", fmt.Sprintf("%s:%s",userName, password)) - // Get the blocking write client - // Supply a string in the form database/retention-policy as a bucket. Skip retention policy for the default one, use just a database name (without the slash character) - // Org name is not used - writeAPI := client.WriteAPIBlocking("", "test/autogen") - // create point using full params constructor - p := influxdb2.NewPoint("stat", - map[string]string{"unit": "temperature"}, - map[string]interface{}{"avg": 24.5, "max": 45}, - time.Now()) - // Write data - err := writeAPI.WritePoint(context.Background(), p) - if err != nil { - fmt.Printf("Write error: %s\n", err.Error()) - } - - // Get query client. Org name is not used - queryAPI := client.QueryAPI("") - // Supply string in a form database/retention-policy as a bucket. Skip retention policy for the default one, use just a database name (without the slash character) - result, err := queryAPI.Query(context.Background(), `from(bucket:"test")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) - if err == nil { - for result.Next() { - if result.TableChanged() { - fmt.Printf("table: %s\n", result.TableMetadata().String()) - } - fmt.Printf("row: %s\n", result.Record().String()) - } - if result.Err() != nil { - fmt.Printf("Query error: %s\n", result.Err().Error()) - } - } else { - fmt.Printf("Query error: %s\n", err.Error()) - } - // Close client - client.Close() + userName := "my-user" + password := "my-password" + // Create a new client using an InfluxDB server base URL and an authentication token + // For authentication token supply a string in the form: "username:password" as a token. Set empty value for an unauthenticated server + client := influxdb2.NewClient("http://localhost:8086", fmt.Sprintf("%s:%s",userName, password)) + // Get the blocking write client + // Supply a string in the form database/retention-policy as a bucket. Skip retention policy for the default one, use just a database name (without the slash character) + // Org name is not used + writeAPI := client.WriteAPIBlocking("", "test/autogen") + // create point using full params constructor + p := influxdb2.NewPoint("stat", + map[string]string{"unit": "temperature"}, + map[string]interface{}{"avg": 24.5, "max": 45}, + time.Now()) + // Write data + err := writeAPI.WritePoint(context.Background(), p) + if err != nil { + fmt.Printf("Write error: %s\n", err.Error()) + } + + // Get query client. Org name is not used + queryAPI := client.QueryAPI("") + // Supply string in a form database/retention-policy as a bucket. Skip retention policy for the default one, use just a database name (without the slash character) + result, err := queryAPI.Query(context.Background(), `from(bucket:"test")|> range(start: -1h) |> filter(fn: (r) => r._measurement == "stat")`) + if err == nil { + for result.Next() { + if result.TableChanged() { + fmt.Printf("table: %s\n", result.TableMetadata().String()) + } + fmt.Printf("row: %s\n", result.Record().String()) + } + if result.Err() != nil { + fmt.Printf("Query error: %s\n", result.Err().Error()) + } + } else { + fmt.Printf("Query error: %s\n", err.Error()) + } + // Close client + client.Close() } ```