Lazy loading of bytea/text

[owochle]

Hello,
I'm storing files in my database which are quite small, but when i query 50+ entries, it starts to pile up. Would there be a way in SeaORM to have a lazy loaded Vec or a way to mark fields as "lazy" which would generate getter methods ?

struct Model {
    #[lazy]
    file: Vec<u8>
}

// ----

fn main() {
    let model: Model
    model.get_file().await // Vec<u8> or &[u8]
}

For now, I am using custom models, selecting all columns but file, but it makes this more cumbersome

[sinder38]

Could be a feature.
I just want to put on the table that implementing something like Django's defer() instead of #[sea_orm(lazy)] would be more practical. defer() allows to specify columns we don't want fetch, basically the opposite of Django's only() and SeaORM's select_only()

Side note: if you have control over the schema, storing files on disk/object storage and keeping only a path/URL in the DB is recommended.

[owochle]

I feel like although defer() is a good idea, it does not really aims at the same thing. Marking a field as lazy would make you able to use Model as usual, without needing some custom models and into_model calls, whereas defer would required something like this.

[For8stt]

I’d probably avoid #[lazy] on the normal Model.

If file is part of the model type but not actually loaded, then every access needs some hidden state like “loaded / not loaded / loading failed”. That makes the model less predictable and easy to misuse.

For this case I’d keep it explicit:

#[derive(Debug, FromQueryResult)]
struct EntryWithoutFile {
    id: i32,
    name: String,
}

let rows = Entity::find()
    .select_only()
    .column(Column::Id)
    .column(Column::Name)
    .into_model::<EntryWithoutFile>()
    .all(db)
    .await?;

Then load the blob only when needed:

let file: Option<Vec<u8>> = Entity::find_by_id(id)
    .select_only()
    .column(Column::File)
    .into_tuple()
    .one(db)
    .await?;

So imo a defer() / select_except() style API would fit SeaORM better than lazy fields on Model.

Something like this would be really nice:

Entity::find()
    .select_except([Column::File])
    .all(db)
    .await?;

For bigger files, I’d also consider moving the bytes to object storage / filesystem and keeping only metadata + path/key in DB. But if the files are small and DB storage is intentional, explicit projection + a helper method is probably the cleanest workaround for now.

Maybe you can wrap it like:

impl EntryWithoutFile {
    async fn load_file(&self, db: &DatabaseConnection) -> Result<Option<Vec<u8>>, DbErr> {
        Entity::find_by_id(self.id)
            .select_only()
            .column(Column::File)
            .into_tuple()
            .one(db)
            .await
    }
}

Not as magic as #[lazy], but much clearer and avoids accidentally fetching blobs in list queries.