1use serde::{Deserialize, Serialize};
5
6#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
8pub struct Schema {
9 pub enums: Vec<EnumType>,
11 pub tables: Vec<Table>,
13 pub indexes: Vec<Index>,
15 pub extras: Vec<Extra>,
17}
18
19#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
21pub struct EnumType {
22 pub name: String,
24 pub values: Vec<String>,
26 pub module: String,
28 #[serde(default, skip_serializing_if = "Vec::is_empty")]
30 pub doc: Vec<String>,
31}
32
33#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
35pub struct Table {
36 pub name: String,
38 pub module: String,
40 #[serde(default, skip_serializing_if = "Vec::is_empty")]
42 pub doc: Vec<String>,
43 pub columns: Vec<Column>,
45 pub primary_key: Vec<String>,
47 #[serde(default, skip_serializing_if = "Vec::is_empty")]
49 pub uniques: Vec<Unique>,
50 #[serde(default, skip_serializing_if = "Vec::is_empty")]
52 pub foreign_keys: Vec<ForeignKey>,
53 #[serde(default, skip_serializing_if = "Vec::is_empty")]
55 pub checks: Vec<Check>,
56}
57
58impl Table {
59 pub fn column(&self, name: &str) -> Option<&Column> {
61 self.columns.iter().find(|c| c.name == name)
62 }
63
64 pub fn is_unique(&self, columns: &[String]) -> bool {
67 self.primary_key == columns || self.uniques.iter().any(|u| u.columns == columns)
68 }
69}
70
71#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
73pub struct Column {
74 pub name: String,
76 pub sql_type: String,
78 pub nullable: bool,
80 #[serde(default, skip_serializing_if = "Option::is_none")]
82 pub default: Option<String>,
83 #[serde(default, skip_serializing_if = "Option::is_none")]
85 pub generated: Option<String>,
86 #[serde(default, skip_serializing_if = "Option::is_none")]
88 pub identity: Option<String>,
89 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
91 pub tenant: bool,
92 #[serde(default, skip_serializing_if = "Vec::is_empty")]
94 pub doc: Vec<String>,
95}
96
97impl Column {
98 pub fn has_database_value(&self) -> bool {
100 self.default.is_some()
101 || self.generated.is_some()
102 || self.identity.is_some()
103 || crate::types::is_serial(&self.sql_type)
104 }
105}
106
107#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
109pub struct Unique {
110 pub name: String,
112 pub columns: Vec<String>,
114}
115
116#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
118pub struct ForeignKey {
119 pub name: String,
121 pub columns: Vec<String>,
123 pub ref_table: String,
125 pub ref_columns: Vec<String>,
127 #[serde(default, skip_serializing_if = "Option::is_none")]
129 pub on_delete: Option<String>,
130 #[serde(default, skip_serializing_if = "Option::is_none")]
132 pub on_update: Option<String>,
133}
134
135#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
137pub struct Check {
138 pub name: String,
140 pub expr: String,
142}
143
144#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
146pub struct Index {
147 pub name: String,
149 pub table: String,
151 pub sql: String,
153}
154
155#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
157pub struct Extra {
158 pub up: String,
160 pub down: String,
162 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
164 pub before_tables: bool,
165}
166
167#[derive(Debug, Clone, Copy, PartialEq, Eq)]
169pub enum QueryKind {
170 One,
172 OneRequired,
174 Many,
176 Stream,
178 Exec,
180}
181
182impl QueryKind {
183 pub(crate) fn parse(s: &str) -> Option<Self> {
184 Some(match s {
185 ":one" => Self::One,
186 ":one!" => Self::OneRequired,
187 ":many" => Self::Many,
188 ":stream" => Self::Stream,
189 ":exec" => Self::Exec,
190 _ => return None,
191 })
192 }
193}
194
195#[derive(Debug, Clone, PartialEq, Eq)]
197pub struct Query {
198 pub name: String,
200 pub module: String,
202 pub kind: QueryKind,
204 pub sql: String,
206 pub doc: Vec<String>,
208 pub param_names: Vec<(usize, String)>,
210 pub location: String,
212}