cognite-sdk 0.6.2

SDK for the Cognite Data Fusion API
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
134

use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;

use crate::{AdvancedFilter, AggregateFilter};

use super::EventFilter;

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
/// Descriptor for event properties to compute aggregates on.
pub struct AggregateProperty {
    /// An array of strings specifying a nested property.
    property: Vec<String>,
    /// Filter on which property values to include.
    filter: Option<AggregateFilter>,
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged, rename_all_fields = "camelCase")]
/// Variants of the `count` aggregate on events.
pub enum EventAggregateCount {
    /// Count the number of events with a given property (non-null),
    /// matching the filters.
    PropertyCount {
        /// Advanced filter on events.
        advanced_filter: Option<AdvancedFilter>,
        /// Simple filter on events.
        filter: Option<EventFilter>,
        /// Properties to apply the aggration on. Currently limited to one property per request.
        properties: Vec<AggregateProperty>,
    },
    /// Count the number of events matching filters.
    EventCount {
        /// Advanced filter on events.
        advanced_filter: Option<AdvancedFilter>,
        /// Simple filter on events.
        filter: Option<EventFilter>,
    },
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
#[serde(rename_all = "camelCase")]
/// Aggregate query with a list of properties.
pub struct AggregateWithProperty {
    /// Filter on aggregate property values.
    aggregate_filter: Option<AggregateFilter>,
    /// Advanced filter on events.
    advanced_filter: Option<AdvancedFilter>,
    /// Simple filter on events.
    filter: Option<EventFilter>,
    /// Properties to apply the aggration on. Currently limited to one property per request.
    properties: Vec<AggregateProperty>,
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
#[serde(rename_all = "camelCase")]
/// Aggregate query with a path within a metadata object.
pub struct AggregateWithPath {
    /// Filter on aggregate property values.
    aggregate_filter: Option<AggregateFilter>,
    /// Advanced filter on events.
    advanced_filter: Option<AdvancedFilter>,
    /// Simple filter on events.
    filter: Option<EventFilter>,
    /// Scope in each document to aggregate properties. Currently the only allowed value is
    /// `["metadata"]`, meaning aggregates are computed on metadata properties.
    path: Vec<String>,
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
/// Request for aggregates on events.
pub enum EventAggregateRequest {
    /// Count the number of events matching filters.
    Count(EventAggregateCount),
    /// Compute the approximate number of unique values for the specified property.
    CardinalityValues(AggregateWithProperty),
    /// Compute the approximate number of unique metadata properties.
    CardinalityProperties(AggregateWithPath),
    /// Get up to 1000 unique values for the specified property ordered by frequency.
    /// Note: when aggregating on metadata, a value may occur multiple times in one asset
    /// for different metadata keys. Each occurence is counted.
    UniqueValues(AggregateProperty),
    /// Get unique metadata keys in a given asset. Ordered by frequency.
    UniqueProperties(AggregateWithPath),
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
#[serde(rename_all = "camelCase")]
/// Describes a property in an event.
pub struct AggregatedProperty {
    /// Path to the property.
    property: Vec<String>,
}

#[skip_serializing_none]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged, rename_all_fields = "camelCase")]
/// Response for an event aggregation request. The type of result depends
/// on the requested aggregate.
pub enum EventAggregateResponse {
    /// Aggregate with a list of string values
    Strings {
        /// Number of items in this bucket.
        count: i64,
        /// Array of unique values in the property.
        values: Vec<String>,
    },
    /// Aggregate with a list of integer values.
    Integers {
        /// Number of items in this bucket.
        count: i64,
        /// Array of unique values in the property.
        values: Vec<i64>,
    },
    /// A bucket representing the result of the `UniqueProperties` aggregate.
    Properties {
        /// Number of items in this bucket.
        count: i64,
        /// An array of unique properties.
        values: Vec<AggregatedProperty>,
    },
    /// Aggregate returned when only a simple count is requested.
    Count {
        /// Number of items in this aggregation group.
        count: i64,
    },
}