use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Schema {
pub enums: Vec<EnumType>,
pub tables: Vec<Table>,
pub indexes: Vec<Index>,
pub extras: Vec<Extra>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnumType {
pub name: String,
pub values: Vec<String>,
pub module: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub doc: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Table {
pub name: String,
pub module: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub doc: Vec<String>,
pub columns: Vec<Column>,
pub primary_key: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub uniques: Vec<Unique>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub foreign_keys: Vec<ForeignKey>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub checks: Vec<Check>,
}
impl Table {
pub fn column(&self, name: &str) -> Option<&Column> {
self.columns.iter().find(|c| c.name == name)
}
pub fn is_unique(&self, columns: &[String]) -> bool {
self.primary_key == columns || self.uniques.iter().any(|u| u.columns == columns)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Column {
pub name: String,
pub sql_type: String,
pub nullable: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub generated: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub identity: Option<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub tenant: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub doc: Vec<String>,
}
impl Column {
pub fn has_database_value(&self) -> bool {
self.default.is_some()
|| self.generated.is_some()
|| self.identity.is_some()
|| crate::types::is_serial(&self.sql_type)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Unique {
pub name: String,
pub columns: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ForeignKey {
pub name: String,
pub columns: Vec<String>,
pub ref_table: String,
pub ref_columns: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub on_delete: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub on_update: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Check {
pub name: String,
pub expr: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Index {
pub name: String,
pub table: String,
pub sql: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Extra {
pub up: String,
pub down: String,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub before_tables: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QueryKind {
One,
OneRequired,
Many,
Stream,
Exec,
}
impl QueryKind {
pub(crate) fn parse(s: &str) -> Option<Self> {
Some(match s {
":one" => Self::One,
":one!" => Self::OneRequired,
":many" => Self::Many,
":stream" => Self::Stream,
":exec" => Self::Exec,
_ => return None,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Query {
pub name: String,
pub module: String,
pub kind: QueryKind,
pub sql: String,
pub doc: Vec<String>,
pub param_names: Vec<(usize, String)>,
pub location: String,
}