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/sqlite/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/sqlite/posts.sql");
const _: () = assert!(
    SOURCE.len() == 3261usize,
    "tests/queries/sqlite/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: i64,
    /// `$2` — a row count.
    pub limit: i64,
}
impl PostsForUserParams {
    /// The parameters in placeholder order.
    pub fn new(user_id: i64, 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<(i64, i64)> for PostsForUserParams {
    fn from(v: (i64, 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: i64,
    /// `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: i64,
    /// `published_at` — nullable by rule N1.
    pub published_at: Option<chrono::NaiveDateTime>,
}
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[407usize..494usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[496usize..532usize]);
        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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostsForUserQuery {}
/// Posts by one user, newest first.
///
/// 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.
///
/// 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_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[468usize..475usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[482usize..494usize]);
                            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[506usize..525usize]);
                        }),
                    ),
                );
        }
        {
            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: i64,
}
impl CommentsWithAuthorParams {
    /// The parameters in placeholder order.
    pub fn new(post_id: i64) -> 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<i64> for CommentsWithAuthorParams {
    fn from(v: i64) -> 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: i64,
    /// `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: i64,
    /// `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<i64> = 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[723usize..917usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[919usize..933usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for CommentsWithAuthorQuery {}
/// Comments on one post, with the author when there is one — rule N2 through a
/// nullable foreign key, so the whole `author` side is one `Option`.
///
/// 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 — rule N2 through a
/// nullable foreign key, so the whole `author` side is one `Option`.
///
/// 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_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[850usize..898usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[905usize..917usize]);
                            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[929usize..933usize]);
                        }),
                    ),
                );
        }
    })
}
/// 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: i64,
    /// `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<i64>,
    /// `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[1112usize..1421usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserStatsQuery {}
/// The aggregate rules: N4 for `count`, N5 for the rest, N7 for `coalesce`,
/// and N3 — an `IS NOT NULL` filter leaves `email` an `Option<String>`.
///
/// Build `user_stats` without running it.
pub fn user_stats_query(params: impl Into<UserStatsParams>) -> UserStatsQuery {
    UserStatsQuery {
        params: params.into(),
    }
}
/// The aggregate rules: N4 for `count`, N5 for the rest, N7 for `coalesce`,
/// and N3 — an `IS NOT NULL` filter leaves `email` an `Option<String>`.
///
/// 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_sqlite::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[1305usize..1350usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[1357usize..1376usize]);
                            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[1386usize..1407usize]);
                        }),
                    ),
                );
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[1417usize..1421usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `post_flags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostFlagsParams {
    /// `$1` — type taken from the column it is compared with.
    pub views: i64,
}
impl PostFlagsParams {
    /// The parameters in placeholder order.
    pub fn new(views: i64) -> 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<i64> for PostFlagsParams {
    fn from(v: i64) -> Self {
        PostFlagsParams::new(v)
    }
}
/// One row of `post_flags`.
#[derive(Debug, Clone, PartialEq)]
pub struct PostFlagsRow {
    /// `id` — never NULL by rule N1.
    pub id: i64,
    /// `has_status` — never NULL by rule N11.
    pub has_status: i64,
    /// `is_popular` — never NULL by rule N10.
    pub is_popular: i64,
    /// `is_published` — nullable by rule N10.
    pub is_published: Option<i64>,
    /// `heat` — never NULL by rule N9.
    pub heat: String,
    /// `maybe_heat` — nullable by rule N9.
    pub maybe_heat: Option<String>,
    /// `views_text` — never NULL by rule N13.
    pub views_text: String,
}
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_text: row.take("views_text")?,
        })
    }
}
/** `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[1536usize..1611usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[1613usize..1896usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostFlagsQuery {}
/// The expression rules, SQLite-flavoured: comparisons are integers, not
/// booleans.
///
/// Build `post_flags` without running it.
pub fn post_flags_query(params: impl Into<PostFlagsParams>) -> PostFlagsQuery {
    PostFlagsQuery {
        params: params.into(),
    }
}
/// The expression rules, SQLite-flavoured: comparisons are integers, not
/// booleans.
///
/// 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_sqlite::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[1875usize..1882usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[1892usize..1896usize]);
                        }),
                    ),
                );
        }
    })
}
/// 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: i64,
    /// `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[1959usize..2118usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for PostsWithTagsQuery {}
/// The to-many nested shape.
///
/// 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.
///
/// 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_sqlite::SelectQuery> {
    let _ = params;
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[2008usize..2096usize]);
                            }),
                        ),
                    );
            }
        }
        {
            q.order_by
                .append_order(
                    keelson_core::dyn_expr(
                        keelson_core::expr_fn(move |w: &mut keelson_core::SqlWriter<'_>| {
                            w.push_str(&SOURCE[2106usize..2118usize]);
                        }),
                    ),
                );
        }
    })
}
/// Parameters of `user_by_id`.
#[derive(Debug, Clone, PartialEq)]
pub struct UserByIdParams {
    /// `$1` — type taken from the column it is compared with.
    pub id: i64,
}
impl UserByIdParams {
    /// The parameters in placeholder order.
    pub fn new(id: i64) -> 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<i64> for UserByIdParams {
    fn from(v: i64) -> 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: i64,
    /// `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<i64>,
    /// `is_active` — never NULL by rule N1.
    pub is_active: bool,
    /// `created_at` — never NULL by rule N1.
    pub created_at: chrono::NaiveDateTime,
}
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[2166usize..2255usize]);
        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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserByIdQuery {}
/// Exactly one row.
///
/// 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.
///
/// 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_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[2234usize..2241usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[2248usize..2255usize]);
                            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: i64,
    /// `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[2427usize..2497usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[2499usize..2513usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for AnnotatedQuery {}
/// The annotations settle what inference will not guess.
///
/// Build `annotated` without running it.
pub fn annotated_query(params: impl Into<AnnotatedParams>) -> AnnotatedQuery {
    AnnotatedQuery {
        params: params.into(),
    }
}
/// The annotations settle what inference will not guess.
///
/// 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_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[2470usize..2477usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[2484usize..2497usize]);
                            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[2509usize..2513usize]);
                        }),
                    ),
                );
        }
    })
}
/// 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[2679usize..2760usize]);
    }
}
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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for TitlesUnionQuery {}
/// A compound select: the query face runs it (and rule N14 merges the arms'
/// nullability), while the mod face is refused in writing.
///
/// Build `titles_union` without running it.
pub fn titles_union_query(params: impl Into<TitlesUnionParams>) -> TitlesUnionQuery {
    TitlesUnionQuery {
        params: params.into(),
    }
}
/// A compound select: the query face runs it (and rule N14 merges the arms'
/// nullability), while the mod face is refused in writing.
///
/// 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: i64,
    /// `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[2816usize..2865usize]);
        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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for UserByEmailQuery {}
/// Zero or one row.
///
/// 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.
///
/// 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_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[2841usize..2848usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[2855usize..2865usize]);
                            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: i64,
}
impl BumpViewsParams {
    /// The parameters in placeholder order.
    pub fn new(id: i64) -> 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<i64> for BumpViewsParams {
    fn from(v: i64) -> 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[2956usize..3002usize]);
        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_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for BumpViewsQuery {}
/// Run for its side effect: no row struct, and no mod face.
///
/// Build `bump_views` without running it.
pub fn bump_views_query(params: impl Into<BumpViewsParams>) -> BumpViewsQuery {
    BumpViewsQuery {
        params: params.into(),
    }
}
/// Run for its side effect: no row struct, and no mod face.
///
/// 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 `hot_or_recent`.
#[derive(Debug, Clone, PartialEq)]
pub struct HotOrRecentParams {
    /// `$1` — type taken from the column it is compared with.
    pub views: i64,
}
impl HotOrRecentParams {
    /// The parameters in placeholder order.
    pub fn new(views: i64) -> Self {
        HotOrRecentParams { 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<i64> for HotOrRecentParams {
    fn from(v: i64) -> Self {
        HotOrRecentParams::new(v)
    }
}
/// One row of `hot_or_recent`.
#[derive(Debug, Clone, PartialEq)]
pub struct HotOrRecentRow {
    /// `id` — never NULL by rule N1.
    pub id: i64,
    /// `title` — never NULL by rule N1.
    pub title: String,
}
impl keelson_exec::FromRow for HotOrRecentRow {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(HotOrRecentRow {
            id: row.take("id")?,
            title: row.take("title")?,
        })
    }
}
/** `hot_or_recent` 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 HotOrRecentQuery {
    params: HotOrRecentParams,
}
impl HotOrRecentQuery {
    /// The parameters this query was built with.
    pub fn params(&self) -> &HotOrRecentParams {
        &self.params
    }
}
impl keelson_core::Expression for HotOrRecentQuery {
    fn write_sql(&self, w: &mut keelson_core::SqlWriter<'_>) {
        let args = self.params.args();
        w.push_str(&SOURCE[3181usize..3231usize]);
        w.push_arg(args[0].clone());
        w.push_str(&SOURCE[3233usize..3259usize]);
    }
}
impl keelson_core::Query for HotOrRecentQuery {
    fn query_type(&self) -> keelson_core::QueryType {
        keelson_core::QueryType::Select
    }
    fn dialect(&self) -> &dyn keelson_core::Dialect {
        &keelson_sqlite::Sqlite
    }
}
impl<H, L, M> keelson_core::QueryExtensions<H, L, M> for HotOrRecentQuery {}
/// A top-level `OR` in the WHERE: as a mod it merges into the host's `AND`
/// chain, so the fragment has to arrive parenthesised or it re-binds.
///
/// Build `hot_or_recent` without running it.
pub fn hot_or_recent_query(params: impl Into<HotOrRecentParams>) -> HotOrRecentQuery {
    HotOrRecentQuery {
        params: params.into(),
    }
}
/// A top-level `OR` in the WHERE: as a mod it merges into the host's `AND`
/// chain, so the fragment has to arrive parenthesised or it re-binds.
///
/// Run `hot_or_recent` and return every row.
pub async fn hot_or_recent(
    db: &dyn keelson_exec::Executor,
    params: impl Into<HotOrRecentParams>,
) -> Result<Vec<HotOrRecentRow>, keelson_exec::ExecError> {
    use keelson_exec::Execute as _;
    hot_or_recent_query(params).fetch_all::<HotOrRecentRow>(db).await
}
/** `hot_or_recent` 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 hot_or_recent_mod(
    params: impl Into<HotOrRecentParams>,
) -> impl keelson_core::Mod<keelson_sqlite::SelectQuery> {
    let args = params.into().args();
    keelson_core::mod_fn(move |q: &mut keelson_sqlite::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[3207usize..3214usize]);
                            }),
                        ),
                    );
            }
        }
        {
            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[3221usize..3231usize]);
                            w.push_arg(a0.clone());
                            w.push_str(&SOURCE[3233usize..3259usize]);
                            w.push_str(")");
                        }),
                    ),
                );
        }
    })
}