Documentation ¶
Index ¶
- Constants
- func EpochToTime(epoch int64, precision string) (time.Time, error)
- func ParseConnectionString(path string, ssl bool) (url.URL, error)
- func SetPrecision(t time.Time, precision string) time.Time
- type BatchPoints
- type Client
- func (c *Client) Addr() string
- func (c *Client) Ping() (time.Duration, string, error)
- func (c *Client) Query(q Query) (*Response, error)
- func (c *Client) SetAuth(u, p string)
- func (c *Client) SetPrecision(precision string)
- func (c *Client) Write(bp BatchPoints) (*Response, error)
- func (c *Client) WriteLineProtocol(data, database, retentionPolicy, precision, writeConsistency string) (*Response, error)
- type Config
- type Point
- type Query
- type Response
- type Result
Examples ¶
Constants ¶
const ( // DefaultHost is the default host used to connect to an InfluxDB instance DefaultHost = "localhost" // DefaultPort is the default port used to connect to an InfluxDB instance DefaultPort = 8086 // DefaultTimeout is the default connection timeout used to connect to an InfluxDB instance DefaultTimeout = 0 )
const ( // ConsistencyOne requires at least one data node acknowledged a write. ConsistencyOne = "one" // ConsistencyAll requires all data nodes to acknowledge a write. ConsistencyAll = "all" // ConsistencyQuorum requires a quorum of data nodes to acknowledge a write. ConsistencyQuorum = "quorum" // ConsistencyAny allows for hinted hand off, potentially no write happened yet. ConsistencyAny = "any" )
Variables ¶
This section is empty.
Functions ¶
func EpochToTime ¶
EpochToTime takes a unix epoch time and uses precision to return back a time.Time
func ParseConnectionString ¶ added in v0.1.6
ParseConnectionString will parse a string to create a valid connection URL
Types ¶
type BatchPoints ¶
type BatchPoints struct { Points []Point `json:"points,omitempty"` Database string `json:"database,omitempty"` RetentionPolicy string `json:"retentionPolicy,omitempty"` Tags map[string]string `json:"tags,omitempty"` Time time.Time `json:"time,omitempty"` Precision string `json:"precision,omitempty"` WriteConsistency string `json:"-"` }
BatchPoints is used to send batched data in a single write. Database and Points are required If no retention policy is specified, it will use the databases default retention policy. If tags are specified, they will be "merged" with all points. If a point already has that tag, it is ignored. If time is specified, it will be applied to any point with an empty time. Precision can be specified if the time is in epoch format (integer). Valid values for Precision are n, u, ms, s, m, and h
func (*BatchPoints) UnmarshalJSON ¶
func (bp *BatchPoints) UnmarshalJSON(b []byte) error
UnmarshalJSON decodes the data into the BatchPoints struct
type Client ¶
type Client struct {
// contains filtered or unexported fields
}
Client is used to make calls to the server.
func NewClient ¶
NewClient will instantiate and return a connected client to issue commands to the server.
Example ¶
package main import ( "fmt" "log" "net/url" "os" "github.com/influxdb/influxdb/client" ) func main() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } // NOTE: this assumes you've setup a user and have setup shell env variables, // namely INFLUX_USER/INFLUX_PWD. If not just omit Username/Password below. conf := client.Config{ URL: *host, Username: os.Getenv("INFLUX_USER"), Password: os.Getenv("INFLUX_PWD"), } con, err := client.NewClient(conf) if err != nil { log.Fatal(err) } log.Println("Connection", con) }
Output:
func (*Client) Addr ¶
Addr provides the current url as a string of the server the client is connected to.
func (*Client) Ping ¶
Ping will check to see if the server is up Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
Example ¶
package main import ( "fmt" "log" "net/url" "github.com/influxdb/influxdb/client" ) func main() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } dur, ver, err := con.Ping() if err != nil { log.Fatal(err) } log.Printf("Happy as a hippo! %v, %s", dur, ver) }
Output:
func (*Client) Query ¶
Query sends a command to the server and returns the Response
Example ¶
package main import ( "fmt" "log" "net/url" "github.com/influxdb/influxdb/client" ) func main() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } q := client.Query{ Command: "select count(value) from shapes", Database: "square_holes", } if response, err := con.Query(q); err == nil && response.Error() == nil { log.Println(response.Results) } }
Output:
func (*Client) SetPrecision ¶ added in v0.2.0
SetPrecision will update the precision
func (*Client) Write ¶
func (c *Client) Write(bp BatchPoints) (*Response, error)
Write takes BatchPoints and allows for writing of multiple points with defaults If successful, error is nil and Response is nil If an error occurs, Response may contain additional information if populated.
Example ¶
package main import ( "fmt" "log" "math/rand" "net/url" "strconv" "time" "github.com/influxdb/influxdb/client" ) func main() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } var ( shapes = []string{"circle", "rectangle", "square", "triangle"} colors = []string{"red", "blue", "green"} sampleSize = 1000 pts = make([]client.Point, sampleSize) ) rand.Seed(42) for i := 0; i < sampleSize; i++ { pts[i] = client.Point{ Measurement: "shapes", Tags: map[string]string{ "color": strconv.Itoa(rand.Intn(len(colors))), "shape": strconv.Itoa(rand.Intn(len(shapes))), }, Fields: map[string]interface{}{ "value": rand.Intn(sampleSize), }, Time: time.Now(), Precision: "s", } } bps := client.BatchPoints{ Points: pts, Database: "BumbeBeeTuna", RetentionPolicy: "default", } _, err = con.Write(bps) if err != nil { log.Fatal(err) } }
Output:
func (*Client) WriteLineProtocol ¶ added in v0.1.6
func (c *Client) WriteLineProtocol(data, database, retentionPolicy, precision, writeConsistency string) (*Response, error)
WriteLineProtocol takes a string with line returns to delimit each write If successful, error is nil and Response is nil If an error occurs, Response may contain additional information if populated.
type Config ¶
type Config struct { URL url.URL Username string Password string UserAgent string Timeout time.Duration Precision string }
Config is used to specify what server to connect to. URL: The URL of the server connecting to. Username/Password are optional. They will be passed via basic auth if provided. UserAgent: If not provided, will default "InfluxDBClient", Timeout: If not provided, will default to 0 (no timeout)
type Point ¶
type Point struct { Measurement string Tags map[string]string Time time.Time Fields map[string]interface{} Precision string Raw string }
Point defines the fields that will be written to the database Measurement, Time, and Fields are required Precision can be specified if the time is in epoch format (integer). Valid values for Precision are n, u, ms, s, m, and h
func (*Point) MarshalJSON ¶
MarshalJSON will format the time in RFC3339Nano Precision is also ignored as it is only used for writing, not reading Or another way to say it is we always send back in nanosecond precision
func (*Point) MarshalString ¶
MarshalString renders string representation of a Point with specified precision. The default precision is nanoseconds.
func (*Point) UnmarshalJSON ¶
UnmarshalJSON decodes the data into the Point struct
type Response ¶
Response represents a list of statement results.
func (Response) Error ¶
Error returns the first error from any statement. Returns nil if no errors occurred on any statements.
func (*Response) MarshalJSON ¶
MarshalJSON encodes the response into JSON.
func (*Response) UnmarshalJSON ¶
UnmarshalJSON decodes the data into the Response struct
type Result ¶
Result represents a resultset returned from a single statement.
func (*Result) MarshalJSON ¶
MarshalJSON encodes the result into JSON.
func (*Result) UnmarshalJSON ¶
UnmarshalJSON decodes the data into the Result struct