Need PostgreSQL native enum

[haruki-nikaidou]

Need something like this

#[welds(enum_name = "server_status", schema="metrics", rename_all="snake_case")]
pub enum ServerStatus {
    Online,
    Offline,
    Maintenance,
    UnderAttack,
}

SeaORM has some bugs on this btw

[lex148]

I agree that could be really nice. I'm thinking we should do it in a way that supports wiring up a rust Enum to a database in other common ways. I would want to make sure they are all directly usable on your models.

I haven't checked lately, but there was a big problem with enums in SQLx 7.x they were ignoring the schema name and would run into name collisions across schemas. If they still haven't fixed it, what we do might need to be a little different from SQLx

[retorted]

I have a feeling this is fixed in sqlx 0.8.x. @haruki-nikaidou I think something like this should work:

#[derive(sqlx::Type)]
#[sqlx(type_name = "server_status", rename_all = "snake_case")]
pub enum ServerStatus {
    Online,
    Offline,
    Maintenance,
    UnderAttack,
}

Docs here for reference: https://docs.rs/sqlx/latest/sqlx/postgres/types/index.html#enumerations

[lex148]

@haruki-nikaidou I was able to confirm what retorted was saying. I tested with the following models and all appear to work.

If this doesn't work for you please let me know so we can get this working for you.

use welds::prelude::*;

#[derive(sqlx::Type, PartialEq, Clone, Default, Debug)]
#[sqlx(type_name = "testschema.VehicleType", rename_all = "snake_case")]
pub enum VehicleType {
    #[default]
    Car,
    Truck,
    Motorcycle,
    Bike,
}

#[derive(WeldsModel, PartialEq, Debug)]
#[welds(schema = "testschema", table = "vehicles")]
pub(crate) struct Vehicle {
    #[welds(primary_key)]
    pub id: uuid::Uuid,
    pub ty: VehicleType,
}

[haruki-nikaidou]

@haruki-nikaidou I was able to confirm what retorted was saying. I tested with the following models and all appear to work.

If this doesn't work for you please let me know so we can get this working for you.

use welds::prelude::*;

#[derive(sqlx::Type, PartialEq, Clone, Default, Debug)]
#[sqlx(type_name = "testschema.VehicleType", rename_all = "snake_case")]
pub enum VehicleType {
#[default]
Car,
Truck,
Motorcycle,
Bike,
}

#[derive(WeldsModel, PartialEq, Debug)]
#[welds(schema = "testschema", table = "vehicles")]
pub(crate) struct Vehicle {
#[welds(primary_key)]
pub id: uuid::Uuid,
pub ty: VehicleType,
}

I got the idea. It do support PostgreSQL native enum, but since there is neither example nor document to show how to do that, nobody knows it.

Could you add an example for it? Everyone using an ORM don't want to read sqlx's document to figure out how to use the ORM.

[retorted]

I've been doing some spicy things with "Transparent Tuple-Structs" as attributes on my models recently and I've been really pleased with the results. Not sure if this is worth adding to the docs/examples, but here's a rough example of what it looks like:

use welds::{prelude::*};
use welds::query::optional::Optional;
use sqxl::Type;
use core::net::socket_addr::{SocketAddrV4, AddrParseError};
use core::fmt::{Display, Formatter};
use core::fmt::Result as FormatResult;
use serde::{Deserialize, Serialize};

#[derive Debug, Clone, Serialize, Deserialize, WeldsModel]
#[welds(table = "servers")]
#[welds(BeforeCreate(Server::validate))]
#[welds(BeforeUpdate(Server::validate))]
pub struct Server {
    #[welds(primary_key)]
    pub id: i32,
    pub status: ServerStatus,
    pub ip_address: IpAdddressV4 // Custom Type for storing/handling ip addresses (see below)
}

impl Server {
    fn build(address: &str) -> DbState<Server> {
        DbState::new_uncreated(
            Server {
                ip_address: IpAdddressV4::new(address),
                ..Default::default()
            }
        )
    }

    fn validate(&self) -> Result<(), String> {
        if !self.ip_address.is_valid() {
            return Err(format!("IP Address is invalid: {}", self.ip_address))
        }
        Ok(())
    }
}

// Plain enum (deriving sqlx::Type)
#[derive(PartialEq, Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize, Type)]
pub enum ServerStatus {
    #[default]
    Offline,
    Online
}

// Tuple-Struct type as a thin wrapper around an address like "123.4.5.67" stored as a VARCHAR(15) column
#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Type)]
#[sqlx(transparent)] // Transparently convert to/from IpAdddressV4 type when loading/saving from the database
pub struct IpAdddressV4(pub String);

// Interface / helper methods
impl IpAdddressV4 {
    pub fn new(address: &str) -> Self {
        Self(address.trim().to_owned())
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn is_valid(&self) -> bool {
        // validate address format with a Regex
    }

    pub fn as_socket_addr(&self) -> Result<SocketAddrV4, AddrParseError> {
        SocketAddrV4::from_str(&self.0)
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

// Conversions and formatting
impl From<String> for IpAdddressV4 {
    fn from(value: String) -> IpAdddressV4 { IpAdddressV4::new(&value) }
}

impl From<&str> for IpAdddressV4 {
    fn from(value: &str) -> IpAdddressV4 { IpAdddressV4::new(value) }
}

impl From<&IpAdddressV4> for Optional<IpAdddressV4> {
    // welds::query::optional::Optional, used when binding params in query builder
    fn from(value: &IpAdddressV4) -> Optional<IpAdddressV4> {
        Optional::Some(value.to_owned())
    }
}

impl Display for IpAdddressV4 { // For debug/print/etc
    fn fmt(&self, f: &mut Formatter<'_>) -> FormatResult {
        write!(f, "{}", self.0)
    }
}

// Example usages:

let bad_address = IpAddressV4::new("xxxxxxxxx");
let valid = bad_address.is_valid(); // -> false

let good_address = IpAddressV4::new("123.45.6.7");
let valid = good_address.is_valid(); // -> true

let bad_server = Server::build("xxxxxx");
bad_server.save(&client).await; // -> Result::Err ("IP Address is invalid: xxxxxx")

let good_server = Server::build("123.45.6.7");
good_server.save(&client).await; // -> Result::Ok

let server_ip_str = good_server.ip_address.as_str(); // -> "123.45.6.7"
let socket_addr = good_server.ip_address.as_socket_addr()?; // -> SocketAddrV4

let some_address = IpAddressV4::new("12.34.56.7");
let found_server = Server::where_col(|server| server.ip_address.equal(&some_address))
    .fetch_one(&client)
    .await?; // -> DbState<Server>

let some_address = IpAddressV4::new("123.45.67.8");
let update_status = Server::where_col(|server| server.ip_address.equal(&some_address))
    .set_col(|server| server.status.equal(ServerStatus::Online))
    .run(&client); // -> Result::Ok