wowsql 1.1.0

Official Rust SDK for WOWSQL - MySQL Backend-as-a-Service with S3 Storage
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Response from a query operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryResponse<T> {
    pub data: Vec<T>,
    pub count: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<usize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// Response from a create operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateResponse {
    pub id: Value,
    #[serde(rename = "affected_rows")]
    pub affected_rows: usize,
    pub success: bool,
}

/// Response from an update operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateResponse {
    #[serde(rename = "affected_rows")]
    pub affected_rows: usize,
    pub success: bool,
}

/// Response from a delete operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeleteResponse {
    #[serde(rename = "affected_rows")]
    pub affected_rows: usize,
    pub success: bool,
}

/// Table schema information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableSchema {
    pub name: String,
    pub columns: Vec<ColumnInfo>,
    #[serde(rename = "primary_key")]
    pub primary_key: Option<String>,
    #[serde(rename = "row_count")]
    pub row_count: Option<usize>,
}

/// Column information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ColumnInfo {
    pub name: String,
    pub r#type: String,
    pub nullable: bool,
    pub default: Option<Value>,
}

/// Storage quota information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageQuota {
    #[serde(rename = "storage_quota_gb")]
    pub storage_quota_gb: f64,
    #[serde(rename = "storage_used_gb")]
    pub storage_used_gb: f64,
    #[serde(rename = "storage_expansion_gb")]
    pub storage_expansion_gb: f64,
    #[serde(rename = "storage_available_gb")]
    pub storage_available_gb: f64,
    #[serde(rename = "usage_percentage")]
    pub usage_percentage: f64,
    #[serde(rename = "can_expand_storage")]
    pub can_expand_storage: bool,
    #[serde(rename = "is_enterprise")]
    pub is_enterprise: bool,
    #[serde(rename = "plan_name")]
    pub plan_name: String,
}

impl StorageQuota {
    pub fn storage_quota_bytes(&self) -> i64 {
        (self.storage_quota_gb * 1024.0 * 1024.0 * 1024.0) as i64
    }

    pub fn storage_used_bytes(&self) -> i64 {
        (self.storage_used_gb * 1024.0 * 1024.0 * 1024.0) as i64
    }

    pub fn storage_available_bytes(&self) -> i64 {
        (self.storage_available_gb * 1024.0 * 1024.0 * 1024.0) as i64
    }
}

/// Storage file information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageFile {
    pub key: String,
    pub size: i64,
    #[serde(rename = "last_modified")]
    pub last_modified: String,
    #[serde(rename = "content_type")]
    pub content_type: Option<String>,
    pub etag: Option<String>,
}

/// File upload result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileUploadResult {
    pub key: String,
    pub size: i64,
    pub url: String,
    pub success: bool,
}

/// Filter operators for queries
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FilterOperator {
    Eq,
    Neq,
    Gt,
    Gte,
    Lt,
    Lte,
    Like,
    #[serde(rename = "is")]
    IsNull,
}

impl std::fmt::Display for FilterOperator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FilterOperator::Eq => write!(f, "eq"),
            FilterOperator::Neq => write!(f, "neq"),
            FilterOperator::Gt => write!(f, "gt"),
            FilterOperator::Gte => write!(f, "gte"),
            FilterOperator::Lt => write!(f, "lt"),
            FilterOperator::Lte => write!(f, "lte"),
            FilterOperator::Like => write!(f, "like"),
            FilterOperator::IsNull => write!(f, "is"),
        }
    }
}

/// Sort direction
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SortDirection {
    Asc,
    Desc,
}

/// Filter expression for queries
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FilterExpression {
    pub column: String,
    pub operator: FilterOperator,
    pub value: Option<Value>,
}