keelson-gen 0.1.1

// @generated by keelson-gen. DO NOT EDIT.
// Regenerate from the .sql files instead; the SQL is the source of truth
// and lives outside this directory.

//! Generated from `tests/queries/psql/posts.sql`. Each query has two faces: a query object that runs the file's own SQL, and a mod that merges the same clauses into a host statement. Both slice the text below, so they can never disagree.
/// The query file, verbatim. Every span below indexes it.
const SOURCE: &str = include_str!("../../queries/psql/posts.sql");
const _: () = assert!(
    SOURCE.len() == 4758usize,
    "tests/queries/psql/posts.sql changed after it was generated from; re-run keelson-gen"
);
/// Parameters of `posts_for_user`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostsForUserParams {
    /// `$1` — type taken from the column it is compared with.
    pub user_id: i32,
    /// `$2` — a row count.
    pub limit: i64,
}
impl PostsForUserParams {
    /// The parameters in placeholder order.
    pub fn new(user_id: i32, limit: i64) -> Self {
        PostsForUserParams {
            user_id,
            limit,
        }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![
            keelson_core::ToValue::to_value(self.user_id),
            keelson_core::ToValue::to_value(self.limit)
        ]
    }
}
impl From<(i32, i64)> for PostsForUserParams {
    fn from(v: (i32, i64)) -> Self {
        PostsForUserParams::new(v.0, v.1)
    }
}
/// One row of `posts_for_user`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostsForUserRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `title` — never NULL by rule N1.
    pub title: String,
    /// `status` — nullable by rule N1.
    pub status: Option<String>,
    /// `views` — never NULL by rule N1.
    pub views: i32,
    /// `published_at` — nullable by rule N1.
    pub published_at: Option<chrono::DateTime<chrono::Utc>>,
}
impl keelson_exec::FromRow for PostsForUserRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(PostsForUserRow {
            id: row.take("id")?,
            title: row.take("title")?,
            status: row.take("status")?,
            views: row.take("views")?,
            published_at: row.take("published_at")?,
        })
    }
}
/** `posts_for_user` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct PostsForUserQuery {
    params: PostsForUserParams,
}
impl PostsForUserQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &PostsForUserParams {
        &self.params
    }
}
impl keelson_core::Expression for PostsForUserQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[619usize..706usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[708usize..744usize]);
        w.push_arg(args[1].clone());
    }
}
impl keelson_core::Query for PostsForUserQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostsForUserQuery {}
/// Posts by one user, newest first.
/// The plain case: every column's nullability is the DDL's (rule N1), and both
/// placeholders take their type from where they sit — `$1` from the column it
/// is compared with (P1), `$2` from being a row count (P3).
///
/// Build `posts_for_user` without running it.
pub fn posts_for_user_query(params: impl Into<PostsForUserParams>) -> PostsForUserQuery {
    PostsForUserQuery {
        params: params.into(),
    }
}
/// Posts by one user, newest first.
/// The plain case: every column's nullability is the DDL's (rule N1), and both
/// placeholders take their type from where they sit — `$1` from the column it
/// is compared with (P1), `$2` from being a row count (P3).
///
/// Run `posts_for_user` and return every row.
pub async fn posts_for_user(
    db: &dyn keelson_exec::Executor,
    params: impl Into<PostsForUserParams>,
) -> Result<Vec<PostsForUserRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    posts_for_user_query(params).fetch_all::<PostsForUserRow>(db).await
}
/** `posts_for_user` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn posts_for_user_mod(
    params: impl Into<PostsForUserParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[680usize..687usize]);
                            }),
                        ),
                    );
            }
        }
        {
            let a0 = args[0].clone();
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[694usize..706usize]);
                            w.push_arg(a0.clone());
                            w.push_str(")");
                        }),
                    ),
                );
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[718usize..737usize]);
                        }),
                    ),
                );
        }
        {
            let a1 = args[1].clone();
            if q.limit.is_empty() {
                q.limit
                    .set_limit(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_arg(a1.clone());
                            }),
                        ),
                    );
            }
        }
    })
}
/// Parameters of `comments_with_author`.
#[derive(Debug, Clone, PartialEq)]
pub struct CommentsWithAuthorParams {
    /// `$1` — type taken from the column it is compared with.
    pub post_id: i32,
}
impl CommentsWithAuthorParams {
    /// The parameters in placeholder order.
    pub fn new(post_id: i32) -> Self {
        CommentsWithAuthorParams {
            post_id,
        }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.post_id)]
    }
}
impl From<i32> for CommentsWithAuthorParams {
    fn from(v: i32) -> Self {
        CommentsWithAuthorParams::new(v)
    }
}
/// `comments_with_author`'s nested `author`.
#[derive(Debug, Clone, PartialEq)]
pub struct CommentsWithAuthorAuthor {
    /// `author__id` — never NULL by rule N2.
    pub id: i32,
    /// `author__name` — never NULL by rule N2.
    pub name: String,
    /// `author__email` — nullable by rule N2.
    pub email: Option<String>,
}
/// One row of `comments_with_author`.
#[derive(Debug, Clone, PartialEq)]
pub struct CommentsWithAuthorRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `body` — never NULL by rule N1.
    pub body: String,
    /// `author__*` — a to-one nested group, `None` when the outer join found no row.
    pub author: Option<CommentsWithAuthorAuthor>,
}
impl keelson_exec::FromRow for CommentsWithAuthorRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(CommentsWithAuthorRow {
            id: row.take("id")?,
            body: row.take("body")?,
            author: {
                let id: Option<i32> = row.take("author__id")?;
                let name: Option<String> = row.take("author__name")?;
                let email: Option<String> = row.take("author__email")?;
                match (id, name) {
                    (Some(id), Some(name)) => {
                        Some(CommentsWithAuthorAuthor {
                            id,
                            name,
                            email,
                        })
                    }
                    _ => None,
                }
            },
        })
    }
}
/** `comments_with_author` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct CommentsWithAuthorQuery {
    params: CommentsWithAuthorParams,
}
impl CommentsWithAuthorQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &CommentsWithAuthorParams {
        &self.params
    }
}
impl keelson_core::Expression for CommentsWithAuthorQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[1137usize..1331usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[1333usize..1347usize]);
    }
}
impl keelson_core::Query for CommentsWithAuthorQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for CommentsWithAuthorQuery {}
/// Comments on one post, with the author when there is one.
/// `users` is LEFT-joined through a nullable foreign key, so every one of its
/// columns comes back nullable however the DDL declares it (rule N2) — and
/// because the *whole* side is in that position, it becomes one
/// `Option<…Author>` whose fields go back to their own nullability.
///
/// Build `comments_with_author` without running it.
pub fn comments_with_author_query(
    params: impl Into<CommentsWithAuthorParams>,
) -> CommentsWithAuthorQuery {
    CommentsWithAuthorQuery {
        params: params.into(),
    }
}
/// Comments on one post, with the author when there is one.
/// `users` is LEFT-joined through a nullable foreign key, so every one of its
/// columns comes back nullable however the DDL declares it (rule N2) — and
/// because the *whole* side is in that position, it becomes one
/// `Option<…Author>` whose fields go back to their own nullability.
///
/// Run `comments_with_author` and return every row.
pub async fn comments_with_author(
    db: &dyn keelson_exec::Executor,
    params: impl Into<CommentsWithAuthorParams>,
) -> Result<Vec<CommentsWithAuthorRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    comments_with_author_query(params).fetch_all::<CommentsWithAuthorRow>(db).await
}
/** `comments_with_author` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn comments_with_author_mod(
    params: impl Into<CommentsWithAuthorParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[1264usize..1312usize]);
                            }),
                        ),
                    );
            }
        }
        {
            let a0 = args[0].clone();
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[1319usize..1331usize]);
                            w.push_arg(a0.clone());
                            w.push_str(")");
                        }),
                    ),
                );
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[1343usize..1347usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `user_stats`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct UserStatsParams {}
impl UserStatsParams {
    /// The parameters in placeholder order.
    pub fn new() -> Self {
        UserStatsParams {}
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![]
    }
}
impl From<()> for UserStatsParams {
    fn from((): ()) -> Self {
        UserStatsParams::new()
    }
}
/// One row of `user_stats`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserStatsRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `name` — never NULL by rule N1.
    pub name: String,
    /// `email` — nullable by rule N1.
    pub email: Option<String>,
    /// `post_count` — never NULL by rule N4.
    pub post_count: i64,
    /// `best_views` — nullable by rule N5.
    pub best_views: Option<i32>,
    /// `total_views` — never NULL by rule N7.
    pub total_views: i64,
}
impl keelson_exec::FromRow for UserStatsRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(UserStatsRow {
            id: row.take("id")?,
            name: row.take("name")?,
            email: row.take("email")?,
            post_count: row.take("post_count")?,
            best_views: row.take("best_views")?,
            total_views: row.take("total_views")?,
        })
    }
}
/** `user_stats` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct UserStatsQuery {
    params: UserStatsParams,
}
impl UserStatsQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &UserStatsParams {
        &self.params
    }
}
impl keelson_core::Expression for UserStatsQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        w.push_str(&SOURCE[1722usize..2031usize]);
    }
}
impl keelson_core::Query for UserStatsQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserStatsQuery {}
/// One row per user with their post counts.
/// The aggregate rules: `count` is never NULL even over an empty group (N4),
/// every other aggregate is (N5), and `coalesce` is NULL only when all of its
/// arguments are (N7). `u.email` is filtered with `IS NOT NULL` and stays
/// `Option<String>` — a filter narrows the rows, not the type (N3).
///
/// Build `user_stats` without running it.
pub fn user_stats_query(params: impl Into<UserStatsParams>) -> UserStatsQuery {
    UserStatsQuery {
        params: params.into(),
    }
}
/// One row per user with their post counts.
/// The aggregate rules: `count` is never NULL even over an empty group (N4),
/// every other aggregate is (N5), and `coalesce` is NULL only when all of its
/// arguments are (N7). `u.email` is filtered with `IS NOT NULL` and stays
/// `Option<String>` — a filter narrows the rows, not the type (N3).
///
/// Run `user_stats` and return every row.
pub async fn user_stats(
    db: &dyn keelson_exec::Executor,
    params: impl Into<UserStatsParams>,
) -> Result<Vec<UserStatsRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    user_stats_query(params).fetch_all::<UserStatsRow>(db).await
}
/** `user_stats` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn user_stats_mod(
    params: impl Into<UserStatsParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[1915usize..1960usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[1967usize..1986usize]);
                            w.push_str(")");
                        }),
                    ),
                );
        }
        {
            q.group_by
                .append_group(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[1996usize..2017usize]);
                        }),
                    ),
                );
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[2027usize..2031usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `post_flags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostFlagsParams {
    /// `$1` — type taken from the column it is compared with.
    pub views: i32,
}
impl PostFlagsParams {
    /// The parameters in placeholder order.
    pub fn new(views: i32) -> Self {
        PostFlagsParams { views }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.views)]
    }
}
impl From<i32> for PostFlagsParams {
    fn from(v: i32) -> Self {
        PostFlagsParams::new(v)
    }
}
/// One row of `post_flags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostFlagsRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `has_status` — never NULL by rule N11.
    pub has_status: bool,
    /// `is_popular` — never NULL by rule N10.
    pub is_popular: bool,
    /// `is_published` — nullable by rule N10.
    pub is_published: Option<bool>,
    /// `heat` — never NULL by rule N9.
    pub heat: String,
    /// `maybe_heat` — nullable by rule N9.
    pub maybe_heat: Option<String>,
    /// `views_wide` — never NULL by rule N13.
    pub views_wide: i64,
}
impl keelson_exec::FromRow for PostFlagsRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(PostFlagsRow {
            id: row.take("id")?,
            has_status: row.take("has_status")?,
            is_popular: row.take("is_popular")?,
            is_published: row.take("is_published")?,
            heat: row.take("heat")?,
            maybe_heat: row.take("maybe_heat")?,
            views_wide: row.take("views_wide")?,
        })
    }
}
/** `post_flags` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct PostFlagsQuery {
    params: PostFlagsParams,
}
impl PostFlagsQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &PostFlagsParams {
        &self.params
    }
}
impl keelson_core::Expression for PostFlagsQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[2419usize..2517usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[2519usize..2866usize]);
    }
}
impl keelson_core::Query for PostFlagsQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostFlagsQuery {}
/// Derived booleans and a cast, one per expression rule.
/// `IS NOT NULL` is a plain boolean (N11); an operator propagates NULL from any
/// operand, so `p.status = 'published'` is nullable while `p.views > $1` is not
/// (N10); a `CASE` with an `ELSE` is not null and one without is (N9); a cast
/// fixes the type and keeps the operand's nullability (N13).
///
/// Build `post_flags` without running it.
pub fn post_flags_query(params: impl Into<PostFlagsParams>) -> PostFlagsQuery {
    PostFlagsQuery {
        params: params.into(),
    }
}
/// Derived booleans and a cast, one per expression rule.
/// `IS NOT NULL` is a plain boolean (N11); an operator propagates NULL from any
/// operand, so `p.status = 'published'` is nullable while `p.views > $1` is not
/// (N10); a `CASE` with an `ELSE` is not null and one without is (N9); a cast
/// fixes the type and keeps the operand's nullability (N13).
///
/// Run `post_flags` and return every row.
pub async fn post_flags(
    db: &dyn keelson_exec::Executor,
    params: impl Into<PostFlagsParams>,
) -> Result<Vec<PostFlagsRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    post_flags_query(params).fetch_all::<PostFlagsRow>(db).await
}
/** `post_flags` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn post_flags_mod(
    params: impl Into<PostFlagsParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[2845usize..2852usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[2862usize..2866usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `posts_with_tags`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct PostsWithTagsParams {}
impl PostsWithTagsParams {
    /// The parameters in placeholder order.
    pub fn new() -> Self {
        PostsWithTagsParams {}
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![]
    }
}
impl From<()> for PostsWithTagsParams {
    fn from((): ()) -> Self {
        PostsWithTagsParams::new()
    }
}
/// `posts_with_tags`'s nested `tags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostsWithTagsTags {
    /// `tags.name` — never NULL by rule N2.
    pub name: String,
}
/// One row of `posts_with_tags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostsWithTagsRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `title` — never NULL by rule N1.
    pub title: String,
    /// `tags.*` — a to-many nested group, folded from the result rows.
    pub tags: Vec<PostsWithTagsTags>,
}
impl keelson_exec::FromRow for PostsWithTagsRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(PostsWithTagsRow {
            id: row.take("id")?,
            title: row.take("title")?,
            tags: {
                let name: Option<String> = row.take("tags.name")?;
                match (name,) {
                    (Some(name),) => Some(PostsWithTagsTags { name }),
                    _ => None,
                }
            }
                .into_iter()
                .collect::<Vec<_>>(),
        })
    }
}
/** `posts_with_tags` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct PostsWithTagsQuery {
    params: PostsWithTagsParams,
}
impl PostsWithTagsQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &PostsWithTagsParams {
        &self.params
    }
}
impl keelson_core::Expression for PostsWithTagsQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        w.push_str(&SOURCE[3030usize..3189usize]);
    }
}
impl keelson_core::Query for PostsWithTagsQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostsWithTagsQuery {}
/// The to-many nested shape: `tags.name` collects into `row.tags`, folded from
/// the flat result rows on every non-nested field.
///
/// Build `posts_with_tags` without running it.
pub fn posts_with_tags_query(
    params: impl Into<PostsWithTagsParams>,
) -> PostsWithTagsQuery {
    PostsWithTagsQuery {
        params: params.into(),
    }
}
/** Fold `posts_with_tags`'s flat result rows into their to-many groups.

Rows agreeing on every non-nested field are one row; the comparison is linear in the number of distinct parents, which is what keeps the generated code readable.*/
fn fold_posts_with_tags(rows: Vec<PostsWithTagsRow>) -> Vec<PostsWithTagsRow> {
    let mut out: Vec<PostsWithTagsRow> = Vec::with_capacity(rows.len());
    for mut row in rows {
        if let Some(kept) = out
            .iter_mut()
            .find(|kept| kept.id == row.id && kept.title == row.title)
        {
            kept.tags.append(&mut row.tags);
            continue;
        }
        out.push(row);
    }
    out
}
/// The to-many nested shape: `tags.name` collects into `row.tags`, folded from
/// the flat result rows on every non-nested field.
///
/// Run `posts_with_tags` and return every row.
pub async fn posts_with_tags(
    db: &dyn keelson_exec::Executor,
    params: impl Into<PostsWithTagsParams>,
) -> Result<Vec<PostsWithTagsRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    let rows = posts_with_tags_query(params).fetch_all::<PostsWithTagsRow>(db).await?;
    let rows = fold_posts_with_tags(rows);
    Ok(rows)
}
/** `posts_with_tags` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn posts_with_tags_mod(
    params: impl Into<PostsWithTagsParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[3079usize..3167usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[3177usize..3189usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `user_by_id`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserByIdParams {
    /// `$1` — type taken from the column it is compared with.
    pub id: i32,
}
impl UserByIdParams {
    /// The parameters in placeholder order.
    pub fn new(id: i32) -> Self {
        UserByIdParams { id }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.id)]
    }
}
impl From<i32> for UserByIdParams {
    fn from(v: i32) -> Self {
        UserByIdParams::new(v)
    }
}
/// One row of `user_by_id`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserByIdRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `name` — never NULL by rule N1.
    pub name: String,
    /// `email` — nullable by rule N1.
    pub email: Option<String>,
    /// `age` — nullable by rule N1.
    pub age: Option<i32>,
    /// `is_active` — never NULL by rule N1.
    pub is_active: bool,
    /// `created_at` — never NULL by rule N1.
    pub created_at: chrono::DateTime<chrono::Utc>,
}
impl keelson_exec::FromRow for UserByIdRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(UserByIdRow {
            id: row.take("id")?,
            name: row.take("name")?,
            email: row.take("email")?,
            age: row.take("age")?,
            is_active: row.take("is_active")?,
            created_at: row.take("created_at")?,
        })
    }
}
/** `user_by_id` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct UserByIdQuery {
    params: UserByIdParams,
}
impl UserByIdQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &UserByIdParams {
        &self.params
    }
}
impl keelson_core::Expression for UserByIdQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[3272usize..3361usize]);
        w.push_arg(args[0].clone());
    }
}
impl keelson_core::Query for UserByIdQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserByIdQuery {}
/// Exactly one row, and no annotation needed anywhere.
///
/// Build `user_by_id` without running it.
pub fn user_by_id_query(params: impl Into<UserByIdParams>) -> UserByIdQuery {
    UserByIdQuery {
        params: params.into(),
    }
}
/// Exactly one row, and no annotation needed anywhere.
///
/// Run `user_by_id` and return its single row.
pub async fn user_by_id(
    db: &dyn keelson_exec::Executor,
    params: impl Into<UserByIdParams>,
) -> Result<UserByIdRow, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    user_by_id_query(params).fetch_one::<UserByIdRow>(db).await
}
/** `user_by_id` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn user_by_id_mod(
    params: impl Into<UserByIdParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[3340usize..3347usize]);
                            }),
                        ),
                    );
            }
        }
        {
            let a0 = args[0].clone();
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[3354usize..3361usize]);
                            w.push_arg(a0.clone());
                            w.push_str(")");
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `annotated`.
#[derive(Debug, Clone, PartialEq)]
pub struct AnnotatedParams {
    /// `$1` — type given by a `-- param:` annotation.
    pub title_pattern: String,
}
impl AnnotatedParams {
    /// The parameters in placeholder order.
    pub fn new(title_pattern: String) -> Self {
        AnnotatedParams { title_pattern }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.title_pattern.clone())]
    }
}
impl From<String> for AnnotatedParams {
    fn from(v: String) -> Self {
        AnnotatedParams::new(v)
    }
}
/// One row of `annotated`.
#[derive(Debug, Clone, PartialEq)]
pub struct AnnotatedRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `shouty` — never NULL by rule N16.
    pub shouty: String,
}
impl keelson_exec::FromRow for AnnotatedRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(AnnotatedRow {
            id: row.take("id")?,
            shouty: row.take("shouty")?,
        })
    }
}
/** `annotated` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct AnnotatedQuery {
    params: AnnotatedParams,
}
impl AnnotatedQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &AnnotatedParams {
        &self.params
    }
}
impl keelson_core::Expression for AnnotatedQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[3702usize..3772usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[3774usize..3788usize]);
    }
}
impl keelson_core::Query for AnnotatedQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for AnnotatedQuery {}
/// Where inference refuses, the annotations settle it: `-- column:` fixes a
/// type the generator will not guess, `-- nullable:` overrides the inferred
/// nullability (rule N16), and `-- param:` names and types a placeholder.
///
/// Build `annotated` without running it.
pub fn annotated_query(params: impl Into<AnnotatedParams>) -> AnnotatedQuery {
    AnnotatedQuery {
        params: params.into(),
    }
}
/// Where inference refuses, the annotations settle it: `-- column:` fixes a
/// type the generator will not guess, `-- nullable:` overrides the inferred
/// nullability (rule N16), and `-- param:` names and types a placeholder.
///
/// Run `annotated` and return every row.
pub async fn annotated(
    db: &dyn keelson_exec::Executor,
    params: impl Into<AnnotatedParams>,
) -> Result<Vec<AnnotatedRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    annotated_query(params).fetch_all::<AnnotatedRow>(db).await
}
/** `annotated` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn annotated_mod(
    params: impl Into<AnnotatedParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[3745usize..3752usize]);
                            }),
                        ),
                    );
            }
        }
        {
            let a0 = args[0].clone();
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[3759usize..3772usize]);
                            w.push_arg(a0.clone());
                            w.push_str(")");
                        }),
                    ),
                );
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[3784usize..3788usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `titles_union`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TitlesUnionParams {}
impl TitlesUnionParams {
    /// The parameters in placeholder order.
    pub fn new() -> Self {
        TitlesUnionParams {}
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![]
    }
}
impl From<()> for TitlesUnionParams {
    fn from((): ()) -> Self {
        TitlesUnionParams::new()
    }
}
/// One row of `titles_union`.
#[derive(Debug, Clone, PartialEq)]
pub struct TitlesUnionRow {
    /// `title` — never NULL by rule N1.
    pub title: String,
}
impl keelson_exec::FromRow for TitlesUnionRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(TitlesUnionRow {
            title: row.take("title")?,
        })
    }
}
/** `titles_union` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct TitlesUnionQuery {
    params: TitlesUnionParams,
}
impl TitlesUnionQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &TitlesUnionParams {
        &self.params
    }
}
impl keelson_core::Expression for TitlesUnionQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        w.push_str(&SOURCE[3954usize..4035usize]);
    }
}
impl keelson_core::Query for TitlesUnionQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for TitlesUnionQuery {}
/// A set operation: the query face runs it, and the mod face is refused in
/// writing rather than faked by nesting it as a sub-select.
///
/// Build `titles_union` without running it.
pub fn titles_union_query(params: impl Into<TitlesUnionParams>) -> TitlesUnionQuery {
    TitlesUnionQuery {
        params: params.into(),
    }
}
/// A set operation: the query face runs it, and the mod face is refused in
/// writing rather than faked by nesting it as a sub-select.
///
/// Run `titles_union` and return every row.
pub async fn titles_union(
    db: &dyn keelson_exec::Executor,
    params: impl Into<TitlesUnionParams>,
) -> Result<Vec<TitlesUnionRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    titles_union_query(params).fetch_all::<TitlesUnionRow>(db).await
}
/// `titles_union` has no mod face: a set operation has no single WHERE/FROM to merge into a host statement.
///
/// The query face above still runs it. Nesting it as a sub-select would
/// not be the same statement, so the generator refuses rather than
/// pretending.
const _: () = ();
/// Parameters of `user_by_email`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserByEmailParams {
    /// `$1` — type taken from the column it is compared with.
    pub email: String,
}
impl UserByEmailParams {
    /// The parameters in placeholder order.
    pub fn new(email: String) -> Self {
        UserByEmailParams { email }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.email.clone())]
    }
}
impl From<String> for UserByEmailParams {
    fn from(v: String) -> Self {
        UserByEmailParams::new(v)
    }
}
/// One row of `user_by_email`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserByEmailRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `name` — never NULL by rule N1.
    pub name: String,
}
impl keelson_exec::FromRow for UserByEmailRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(UserByEmailRow {
            id: row.take("id")?,
            name: row.take("name")?,
        })
    }
}
/** `user_by_email` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct UserByEmailQuery {
    params: UserByEmailParams,
}
impl UserByEmailQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &UserByEmailParams {
        &self.params
    }
}
impl keelson_core::Expression for UserByEmailQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[4122usize..4171usize]);
        w.push_arg(args[0].clone());
    }
}
impl keelson_core::Query for UserByEmailQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserByEmailQuery {}
/// Zero or one row: the `Option<Row>` cardinality.
///
/// Build `user_by_email` without running it.
pub fn user_by_email_query(params: impl Into<UserByEmailParams>) -> UserByEmailQuery {
    UserByEmailQuery {
        params: params.into(),
    }
}
/// Zero or one row: the `Option<Row>` cardinality.
///
/// Run `user_by_email` and return its row, if there is one.
pub async fn user_by_email(
    db: &dyn keelson_exec::Executor,
    params: impl Into<UserByEmailParams>,
) -> Result<Option<UserByEmailRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    user_by_email_query(params).fetch_optional::<UserByEmailRow>(db).await
}
/** `user_by_email` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn user_by_email_mod(
    params: impl Into<UserByEmailParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[4147usize..4154usize]);
                            }),
                        ),
                    );
            }
        }
        {
            let a0 = args[0].clone();
            q.where_
                .append_where(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str("(");
                            w.push_str(&SOURCE[4161usize..4171usize]);
                            w.push_arg(a0.clone());
                            w.push_str(")");
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `bump_views`.
#[derive(Debug, Clone, PartialEq)]
pub struct BumpViewsParams {
    /// `$1` — type taken from the column it is compared with.
    pub id: i32,
}
impl BumpViewsParams {
    /// The parameters in placeholder order.
    pub fn new(id: i32) -> Self {
        BumpViewsParams { id }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![keelson_core::ToValue::to_value(self.id)]
    }
}
impl From<i32> for BumpViewsParams {
    fn from(v: i32) -> Self {
        BumpViewsParams::new(v)
    }
}
/** `bump_views` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct BumpViewsQuery {
    params: BumpViewsParams,
}
impl BumpViewsQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &BumpViewsParams {
        &self.params
    }
}
impl keelson_core::Expression for BumpViewsQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[4337usize..4383usize]);
        w.push_arg(args[0].clone());
    }
}
impl keelson_core::Query for BumpViewsQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for BumpViewsQuery {}
/// A statement run for its side effect: no row struct at all, and no mod face
/// (an UPDATE has no clause a host SELECT could absorb).
///
/// Build `bump_views` without running it.
pub fn bump_views_query(params: impl Into<BumpViewsParams>) -> BumpViewsQuery {
    BumpViewsQuery {
        params: params.into(),
    }
}
/// A statement run for its side effect: no row struct at all, and no mod face
/// (an UPDATE has no clause a host SELECT could absorb).
///
/// Run `bump_views` for its side effect.
pub async fn bump_views(
    db: &dyn keelson_exec::Executor,
    params: impl Into<BumpViewsParams>,
) -> Result<keelson_exec::ExecResult, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    bump_views_query(params).execute(db).await
}
/// `bump_views` has no mod face: only a SELECT has a mod face: an INSERT/UPDATE/DELETE has no clause a host SELECT could absorb.
///
/// The query face above still runs it. Nesting it as a sub-select would
/// not be the same statement, so the generator refuses rather than
/// pretending.
const _: () = ();
/// Parameters of `comments_with_prefixed_author`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CommentsWithPrefixedAuthorParams {}
impl CommentsWithPrefixedAuthorParams {
    /// The parameters in placeholder order.
    pub fn new() -> Self {
        CommentsWithPrefixedAuthorParams {
        }
    }
    /// The bound arguments, in placeholder order.
    ///
    /// Public deliberately: a query with no placeholders never calls
    /// this, and a *private* method nothing calls is a `dead_code`
    /// warning in a generated file the application cannot edit.
    pub fn args(&self) -> Vec<keelson_core::Value> {
        vec![]
    }
}
impl From<()> for CommentsWithPrefixedAuthorParams {
    fn from((): ()) -> Self {
        CommentsWithPrefixedAuthorParams::new()
    }
}
/// `comments_with_prefixed_author`'s nested `author`.
#[derive(Debug, Clone, PartialEq)]
pub struct CommentsWithPrefixedAuthorAuthor {
    /// `author_id` — never NULL by rule N2.
    pub id: i32,
    /// `author_name` — never NULL by rule N2.
    pub name: String,
}
/// One row of `comments_with_prefixed_author`.
#[derive(Debug, Clone, PartialEq)]
pub struct CommentsWithPrefixedAuthorRow {
    /// `id` — never NULL by rule N1.
    pub id: i32,
    /// `author__*` — a to-one nested group, `None` when the outer join found no row.
    pub author: Option<CommentsWithPrefixedAuthorAuthor>,
}
impl keelson_exec::FromRow for CommentsWithPrefixedAuthorRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(CommentsWithPrefixedAuthorRow {
            id: row.take("id")?,
            author: {
                let id: Option<i32> = row.take("author_id")?;
                let name: Option<String> = row.take("author_name")?;
                match (id, name) {
                    (Some(id), Some(name)) => {
                        Some(CommentsWithPrefixedAuthorAuthor {
                            id,
                            name,
                        })
                    }
                    _ => None,
                }
            },
        })
    }
}
/** `comments_with_prefixed_author` as a query object: the file's own SQL, run as written.

Placeholders are re-bound through the writer, so the statement composes as a sub-select without re-numbering by hand.*/
#[derive(Debug, Clone)]
pub struct CommentsWithPrefixedAuthorQuery {
    params: CommentsWithPrefixedAuthorParams,
}
impl CommentsWithPrefixedAuthorQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &CommentsWithPrefixedAuthorParams {
        &self.params
    }
}
impl keelson_core::Expression for CommentsWithPrefixedAuthorQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        w.push_str(&SOURCE[4635usize..4756usize]);
    }
}
impl keelson_core::Query for CommentsWithPrefixedAuthorQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_psql::Psql
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M>
for CommentsWithPrefixedAuthorQuery {}
/// `-- prefix:` switches the nested-row separator for this query alone:
/// `author_id`/`author_name` would be two flat fields under the defaults, and
/// are one nested `author` here.
///
/// Build `comments_with_prefixed_author` without running it.
pub fn comments_with_prefixed_author_query(
    params: impl Into<CommentsWithPrefixedAuthorParams>,
) -> CommentsWithPrefixedAuthorQuery {
    CommentsWithPrefixedAuthorQuery {
        params: params.into(),
    }
}
/// `-- prefix:` switches the nested-row separator for this query alone:
/// `author_id`/`author_name` would be two flat fields under the defaults, and
/// are one nested `author` here.
///
/// Run `comments_with_prefixed_author` and return every row.
pub async fn comments_with_prefixed_author(
    db: &dyn keelson_exec::Executor,
    params: impl Into<CommentsWithPrefixedAuthorParams>,
) -> Result<Vec<CommentsWithPrefixedAuthorRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    comments_with_prefixed_author_query(params)
        .fetch_all::<CommentsWithPrefixedAuthorRow>(db)
        .await
}
/** `comments_with_prefixed_author` as a mod: its clauses merged into the host statement, flat.

The `WHERE` is `AND`ed onto the host's; the `FROM` (joins included) is contributed only when the host has none of its own, so a model query on the same table keeps its own. Nothing nests as a sub-select — that flatness is the point.

The select list is deliberately **not** contributed: the host statement owns its projection, which is what lets a typed model query and this mod sit in the same tuple.*/
pub fn comments_with_prefixed_author_mod(
    params: impl Into<CommentsWithPrefixedAuthorParams>,
) -> impl keelson_core::Mod<keelson_psql::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_psql::SelectQuery| {
        {
            if q.from.expression.is_none() {
                q.from
                    .set_table(
                        keelson_core::dyn_expr(
                            keelson_core::expr_fn(move |
                                w: &mut keelson_core::SqlWriter<'_>|
                            {
                                w.push_str(&SOURCE[4694usize..4742usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[4752usize..4756usize]);
                        }),
                    ),
                );
        }
    })
}