influxdb: github.com/influxdata/influxdb/client Index | Examples | Files | Directories

package client

import "github.com/influxdata/influxdb/client"

Package client implements a now-deprecated client for InfluxDB; use github.com/influxdata/influxdb/client/v2 instead.

Index

Examples

Package Files

influxdb.go

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"
)

func EpochToTime Uses

func EpochToTime(epoch int64, precision string) (time.Time, error)

EpochToTime takes a unix epoch time and uses precision to return back a time.Time

func ParseConnectionString Uses

func ParseConnectionString(path string, ssl bool) (url.URL, error)

ParseConnectionString will parse a string to create a valid connection URL

func SetPrecision Uses

func SetPrecision(t time.Time, precision string) time.Time

SetPrecision will round a time to the specified precision

type BatchPoints Uses

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 will be 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 Uses

func (bp *BatchPoints) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the data into the BatchPoints struct

type ChunkedResponse Uses

type ChunkedResponse struct {
    // contains filtered or unexported fields
}

ChunkedResponse represents a response from the server that uses chunking to stream the output.

func NewChunkedResponse Uses

func NewChunkedResponse(r io.Reader) *ChunkedResponse

NewChunkedResponse reads a stream and produces responses from the stream.

func (*ChunkedResponse) NextResponse Uses

func (r *ChunkedResponse) NextResponse() (*Response, error)

NextResponse reads the next line of the stream and returns a response.

type Client Uses

type Client struct {
    // contains filtered or unexported fields
}

Client is used to make calls to the server.

func NewClient Uses

func NewClient(c Config) (*Client, error)

NewClient will instantiate and return a connected client to issue commands to the server.

Code:

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)

func (*Client) Addr Uses

func (c *Client) Addr() string

Addr provides the current url as a string of the server the client is connected to.

func (*Client) Ping Uses

func (c *Client) Ping() (time.Duration, string, error)

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.

Code:

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)

func (*Client) Query Uses

func (c *Client) Query(q Query) (*Response, error)

Query sends a command to the server and returns the Response

Code:

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)
}

func (*Client) QueryContext Uses

func (c *Client) QueryContext(ctx context.Context, q Query) (*Response, error)

QueryContext sends a command to the server and returns the Response It uses a context that can be cancelled by the command line client

func (*Client) SetAuth Uses

func (c *Client) SetAuth(u, p string)

SetAuth will update the username and passwords

func (*Client) SetPrecision Uses

func (c *Client) SetPrecision(precision string)

SetPrecision will update the precision

func (*Client) Write Uses

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.

Code:

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)
}

func (*Client) WriteLineProtocol Uses

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 Uses

type Config struct {
    URL              url.URL
    UnixSocket       string
    Username         string
    Password         string
    UserAgent        string
    Timeout          time.Duration
    Precision        string
    WriteConsistency string
    UnsafeSsl        bool
}

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)

func NewConfig Uses

func NewConfig() Config

NewConfig will create a config to be used in connecting to the client

type Message Uses

type Message struct {
    Level string `json:"level,omitempty"`
    Text  string `json:"text,omitempty"`
}

Message represents a user message.

type Point Uses

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 Uses

func (p *Point) MarshalJSON() ([]byte, error)

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 Uses

func (p *Point) MarshalString() string

MarshalString renders string representation of a Point with specified precision. The default precision is nanoseconds.

func (*Point) UnmarshalJSON Uses

func (p *Point) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the data into the Point struct

type Query Uses

type Query struct {
    Command  string
    Database string

    // Chunked tells the server to send back chunked responses. This places
    // less load on the server by sending back chunks of the response rather
    // than waiting for the entire response all at once.
    Chunked bool

    // ChunkSize sets the maximum number of rows that will be returned per
    // chunk. Chunks are either divided based on their series or if they hit
    // the chunk size limit.
    //
    // Chunked must be set to true for this option to be used.
    ChunkSize int
}

Query is used to send a command to the server. Both Command and Database are required.

type Response Uses

type Response struct {
    Results []Result
    Err     error
}

Response represents a list of statement results.

func (*Response) Error Uses

func (r *Response) Error() error

Error returns the first error from any statement. Returns nil if no errors occurred on any statements.

func (*Response) MarshalJSON Uses

func (r *Response) MarshalJSON() ([]byte, error)

MarshalJSON encodes the response into JSON.

func (*Response) UnmarshalJSON Uses

func (r *Response) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the data into the Response struct

type Result Uses

type Result struct {
    Series   []models.Row
    Messages []*Message
    Err      error
}

Result represents a resultset returned from a single statement.

func (*Result) MarshalJSON Uses

func (r *Result) MarshalJSON() ([]byte, error)

MarshalJSON encodes the result into JSON.

func (*Result) UnmarshalJSON Uses

func (r *Result) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the data into the Result struct

Directories

PathSynopsis
v2Package client (v2) is the current official Go client for InfluxDB.

Package client imports 15 packages (graph) and is imported by 68 packages. Updated 2017-09-01. Refresh now. Tools for package owners.