influxdb_rs 0.2.0

InfluxDBv2 Rust driver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use influxdb_rs::{point, points, Client, Point, Points, Precision};
use url::Url;
use chrono::prelude::*;

#[tokio::test]
async fn create_and_delete_database() {
    // Create client with a parsed url, bucket, org, and jwt token
    let client = Client::new(Url::parse("http://localhost:8086").unwrap(), "test_bucket", "test_org", "0123456789").await.unwrap();

    let create = client.create_database("temporary").await;

    // Do a check to see if the bucket is already created
    if create.is_ok() {
        let drop = client.drop_database("temporary").await;

        assert_eq!(drop.is_ok(), true);

    } else {
        // Delete bucket after verifying that one already exists
        let drop = client.drop_database("temporary").await;

        assert_eq!(drop.is_ok(), true);
    }

}

#[tokio::test]
async fn create_and_delete_measurement() {
    // Create client with a parsed url, bucket, org, and jwt token
    let client = Client::new(Url::parse("http://localhost:8086").unwrap(), "test_bucket", "test_org", "0123456789").await.unwrap();
    
    let now = Utc::now();

    let point = Point::new("temporary")
        .add_field("foo", "bar")
        .add_field("integer", 11)
        .add_field("float", 22.3)
        .add_field("'boolean'", false)
        .add_timestamp(now.timestamp());

    let result = client.write_point(point, Some(Precision::Seconds), None).await;

    // No need to check to see whether the fieds and timestamp are available 
    // variable drop verifies that for us
    assert_eq!(result.is_ok(), true);

    let later = Utc::now().to_rfc3339().to_string();


    // No Error means the value was present
    let drop = client.drop_measurement("temporary", &now.to_rfc3339(), &later).await;

    assert_eq!(drop.is_ok(), true);

}

#[tokio::test]
async fn use_points() {
    // Create client with a parsed url, bucket, org, and jwt token
    let client = Client::new(Url::parse("http://localhost:8086").unwrap(), "test_bucket", "test_org", "0123456789").await.unwrap();
    let now = Utc::now();
    let point = Point::new("test1")
        .add_field("foo", "bar")
        .add_field("integer", 11)
        .add_field("float", 22.3)
        .add_field("'boolean'", false);

    let point1 = Point::new("test2")
        .add_tag("tags", "'=213w")
        .add_tag("number", 12)
        .add_tag("float", 12.6)
        .add_field("fd", "'3'".to_string());

    let points = Points::create_new(vec![point1, point]);

    let write_points = client.write_points(points, Some(Precision::Seconds), None).await;

    assert_eq!(write_points.is_ok(), true);

    let later = Utc::now().to_rfc3339().to_string();

    let drop1 = client.drop_measurement("test1", &now.to_rfc3339(), &later).await;

    assert_eq!(drop1.is_ok(), true);

    let drop2 = client.drop_measurement("test2", &now.to_rfc3339(), &later).await;

    assert_eq!(drop2.is_ok(), true);
}

#[tokio::test]
async fn query_with_macros() {
    // Create client with a parsed url, bucket, org, and jwt token
    let client = Client::new(Url::parse("http://localhost:8086").unwrap(), "test_bucket", "test_org", "0123456789").await.unwrap();
    // Need a date-timestamp for insert
    let now = Utc::now();

    // user macro to create points
    let point = point!("test4").add_field("foo", "bar");
    let point1 = point.clone();
    let point = point.add_timestamp(now.timestamp());
    let point1 = point1.add_timestamp(now.timestamp());

    let points = points![point, point1];
    client.write_points(points, Some(Precision::Nanoseconds), None).await.unwrap();


    let later = Utc::now();

    // NOTE: convert time from timstamp_nanos() due to to_rfc3339() doesn't convert nicely with GOLANG
    let flux_query = format!("from(bucket: \"test_bucket\") 
    |> range(start: time(v: {:?}))
    |> filter(fn: (r) => r._measurement == \"test4\")
    |> yield()", now.timestamp_nanos());

    let query = influxdb_rs::data_model::query::ReadQuery{
        r#extern: None,
        query: flux_query,
        r#type: None,
        dialect: None,
        now: None,

    };

    let result = client.query(Some(query)).await;


    assert_eq!(result.is_ok(), true);

    let drop = client.drop_measurement("test4", &now.to_rfc3339(), &later.to_rfc3339()).await;

    assert_eq!(drop.is_ok(), true);
}