Naming the return type

[hfjallemark]

Just like you can name the generated function with the -- name: comment it would be nice if you could name the return type as well as this type tends to get spread out in the code base as you pass it around in functions.

So instead of:

-- name: get_job_listings
select * from job_listing

generating:

GetJobListingsRow

you could provide a name:

-- name: get_job_listings
-- returns: JobListing
select * from job_listing

that would generate:

JobListing

[giacomocavalieri]

For now I'm not sure how to implement this nicely or if this could be a nice addition to Squirrel, there's some things to address. For example, what if someone gives the same name to two returned values?

-- returning: wibble
select * from job_listing;

-- returning: wibble
select 1;

This opens to a couple of questions:

• should squirrel just fail? But that might be surprising if someone actually wanted this (for example if they two queries both returning Users or whatever)
• or should squirrel check that the two types are the same structurally and allow to merge the two together? I'm not really sure, it could be really nice, or really fiddly 😆

For now I'll keep this on hold and see what the main pain points are using the library and if this could actually be a nice addition to address those, thank you so much for the suggestion!

[hfjallemark]

Yeah I have no obvious solution in mind either. But option two actually sounds appealing (from a user perspective at least) -- it would allow me to have the same exact type returned from different queries which would in turn allow me to use that one type for different things (e.g. json encoders, other business rules and so on). For example now I have to create two JSON encoders for the exact same thing which is pretty annoying:

-- get_job_listings.sql
select id, title, description from job_listing

-- get_job_listing_by_id.sql
select id, title, description from job_listing where id = $1

fn encode_job_listing(job_listing: GetJobListingsRow) {
  json.object([
    #("description", json.nullable(job_listing.description, of: json.string)),
    #("id", json.int(job_listing.id)),
    #("title", json.string(job_listing.title)),
  ])
}

fn encode_job_listing_by_id(job_listing: GetJobListingByIdRow) {
  json.object([
    #("description", json.nullable(job_listing.description, of: json.string)),
    #("id", json.int(job_listing.id)),
    #("title", json.string(job_listing.title)),
  ])
}

The most common use case would probably be where you get a list of rows and then get the same row but by id like above, but I'm certain there are other scenarios as well. I think the ability to control both the name of the type and whether it's shared between queries would be a powerful feature and allow me to generate useful types from squirrel that can be passed around in my app instead of squirrel being a 1:1 with the db/query and then require additional mapping to other custom types.