ksqldb 0.1.0-alpha.6

A thin wrapper around the KSQL DB REST API to make it more ergonomic to work with.
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
135
136
137
138
139
140
141

use serde::Deserialize;

use std::collections::HashMap;

use super::{CommandState, Entity, FieldType, Format};

/// Generic information about the request
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct RequestInfo {
    #[serde(rename = "@type")]
    pub response_type: String,
    pub statement_text: Option<String>,
    pub warnings: Option<Vec<Warning>>,
}

/// The status of the current command being processed
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct CommandStatus {
    pub status: CommandState,
    pub message: String,
}

/// Warnings that were returned by KSQL
#[derive(Clone, Debug, Deserialize)]
pub struct Warning {
    pub message: String,
}

/// Information about a KSQL Stream
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Stream {
    pub name: String,
    pub topic: String,
    pub format: Option<Format>,
    #[serde(rename = "type")]
    pub entity: Entity,
}

/// Information about a KSQL Table
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Table {
    pub name: String,
    pub topic: String,
    pub format: Format,
    #[serde(rename = "type")]
    pub entity: Entity,
    pub is_windowed: bool,
}

#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Query {
    pub query_string: String,
    pub sinks: String,
    pub id: String,
}

/// Information about the properties set on the instance
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Properties {
    pub properties: Vec<Property>,
    pub overwritten_properties: Vec<Property>,
    pub default_properties: Vec<String>,
}

/// Information about a specific property in the instance
#[derive(Clone, Debug, Deserialize)]
pub struct Property {
    pub name: String,
    pub scope: String,
    pub value: Option<String>,
}

/// Information about the entity
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Description {
    pub name: String,
    #[serde(rename = "type")]
    pub entity: Entity,
    pub timestamp: String,
    pub format: Option<Format>,
    pub topic: String,
    pub read_queries: Vec<String>,
    pub write_queries: Vec<String>,
    pub fields: Vec<Field>,
    pub extended: bool,
    pub window_type: Option<String>,
    pub key_format: Option<Format>,
    pub value_format: Option<Format>,
    pub key: Option<String>,
    pub statement: Option<String>,

    // Extended only fields
    pub statistics: Option<String>,
    pub error_stats: Option<String>,
    pub replication: Option<u32>,
    pub partitions: Option<u32>,
}

/// Information about the expression or query
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Explanation {
    pub statement_text: String,
    pub fields: Vec<Field>,
    pub sources: Vec<String>,
    pub sinks: Vec<String>,
    pub execution_plan: String,
    pub topology: String,
}

/// Information about the field
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Field {
    pub name: String,
    pub schema: Schema,

    #[serde(rename = "type")]
    pub field_type: Option<String>,
}

/// Information about the schema
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all(serialize = "snake_case", deserialize = "camelCase"))]
pub struct Schema {
    #[serde(rename = "type")]
    pub field_type: FieldType,
    /// For `MAP` and `ARRAY` types, contains the schema of the map values and array elements,
    /// respectively. For other types this field is not used and its value is `None`.
    pub member_schema: Option<HashMap<String, Schema>>,
    /// For STRUCT types, contains a list of field objects that describes each field within
    /// the struct. For other types this field is not used and its value is `None`.
    pub fields: Option<Vec<Field>>,
}