How should I find out dynamically which rust type to map a column into?

[dhbradshaw]

I'm trying to write code that will work with returned rows when I don't know what the query that generated that row or the database associated with that row looked like in advance.

The first idea I have on how to do this is to try to map column values into an enum with variants for the different possible types.
But when I try to get type information to match on it feels like I'm fighting sqlx. The column's type_info doesn't expose id() anymore. It also doesn't let you get types to match on.

So far my best ideas are to match on the debug string or the oid! But both feel like hacks, making me thing that I'm working against sqlx rather than with it. Is there a better route to take here?

[bbstilson]

I'm also trying to solve this problem. The only idea I have is enumerating the column type info from postgres, which gets complicated very fast (especially if you have user defined types like we do).

There might be something in using PgRow::try_get_raw, then getting the type_info. That still reverts back to having to enumerate all type possibilities, but maybe with a bit more hand holding?

It's possible sqlx might not be a good choice for this use-case given its goal of being type safe. quaint might be a better option.

[bbstilson]

I did get what I needed working with quaint. Here's some code very specific to my situation, but it might help others:

quaint = { git = "https://github.com/prisma/prisma-engines.git", features = [
  "postgresql-native",
] }

    async fn clone_row(&mut self, row_to_clone: &RowToClone) -> Result<i64> {
        // We can't know what the row shape is at compile time, so we build up the
        // select/insert queries dynamically.

        let cols = self.get_columns(row_to_clone).await?;

        let row_query = Select::from_table(row_to_clone.table.clone())
            .columns(cols.clone())
            .so_that(row_to_clone.pk_col.clone().equals(row_to_clone.id));
        let row = self.from_conn.select(row_query).await?;
        let row = row.first().unwrap();

        let mut insert_qb = Insert::single_into(row_to_clone.table.clone());

        insert_qb = insert_qb.value(row_to_clone.fk_col.clone(), row_to_clone.fk_id);
        for col in cols {
            let v = row.get(&col).unwrap().to_owned();
            insert_qb = insert_qb.value(col, v);
        }

        let insert_query = insert_qb.build().returning(vec!["id"]);
        let new_row = self.to_conn.insert(insert_query).await?;
        let new_id = new_row
            .first()
            .unwrap()
            .get("id")
            .unwrap()
            .as_i64()
            .unwrap();

        Ok(new_id)
    }

from_conn and to_conn are Quaint::new() instances.

No guarantees on this working for anyone else but hopefully it helps someone!