orql 0.1.0

use std::ops::Deref;

use crate::ast::{ExprList, WindowSpec};

use super::{Condition, Duplicates, Expr, Hint, Ident, Identifier, Node, OrderBy};

#[derive(Debug)]
pub struct Select<'s, ID> {
    /// the `SELECT` query
    pub query: Query<'s, ID>,
    /// e.g. `SELECT ... FOR UPDATE ...` row locking
    ///
    /// Unlike Oracle, the parser will permit a `FOR UPDATE` clause even if
    /// used ... "with the following other constructs: the DISTINCT operator,
    /// CURSOR expression, set operators, group_by_clause, or aggregate
    /// functions."
    pub for_update: Option<ForUpdate<'s, ID>>,
}

#[derive(Debug)]
pub struct Query<'s, ID> {
    /// Common Table Expressions (CTEs) via `WITH`
    pub with: Option<With<'s, ID>>,
    /// The body of the query, e.g. `SELECT ... WHERE ... ORDER BY ...`
    pub body: QueryBody<'s, ID>,
}

#[derive(Debug)]
pub struct QueryBody<'s, ID> {
    /// the `SELECT` including `UNION`, `EXCEPT`, ...
    pub block: QueryBlock<'s, ID>,
    /// `ORDER BY ...`
    pub order_by: Option<OrderBy<'s, ID>>,
    /// `OFFSET ... FETCH ...`
    pub row_limit: RowLimit<'s, ID>,
}

#[derive(Debug)]
pub enum QueryBlock<'s, ID> {
    /// The actual query SELECT
    Select(QuerySelect<'s, ID>),
    /// A composition of two queries, e.g. `SELECT ... UNION ALL ... SELECT ...`
    // ~ cannot have the `order_by_clause` or `row_limiting_clause`
    Composed(
        Box<QueryBlock<'s, ID>>,
        ComposeOperator<ID>,
        Box<QueryBlock<'s, ID>>,
    ),
    /// A query (body, ie. without `WITH`) nested in paranthesis, e.g. `(SELECT ...)`
    Nested(Node<Box<QueryBody<'s, ID>>, ID>),
}

#[derive(Debug)]
pub struct ComposeOperator<ID> {
    /// the compose operation, e.g. `UNION`
    pub operation: Node<ComposeOperation, ID>,
    /// tells whether the `ALL` keyword was present
    pub all_token: Option<Node<(), ID>>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ComposeOperation {
    /// `UNION`
    Union,
    /// `INTERSECT`
    Intersect,
    /// `MINUS`
    Minus,
    /// `EXCEPT`
    Except,
}

#[derive(Debug)]
pub struct QuerySelect<'s, ID> {
    /// the `SELECT` keyword
    pub select_token: Node<(), ID>,
    /// a query optimizer hint, e.g. `
    pub hint: Option<Node<Hint<'s>, ID>>,
    /// optional `DISTINCT | UNIQUE | ALL` keyword
    pub duplicates: Option<Node<Duplicates, ID>>,
    /// the projection expressions
    pub projection: Vec<ProjectionItem<'s, ID>>,
    /// the `FROM ...`
    pub from: QueryTables<'s, ID>,
    /// the `WHERE ...` condition, if any
    pub selection: Option<WhereCondition<'s, ID>>,
    // XXX connect_by (hierarchical_query_clause)
    /// the `GROUP BY ...` clause
    pub group_by: Option<GroupBy<'s, ID>>,
    // XXX model_clause
    /// the `WINDOW ...` clause
    pub windows: Option<QueryWindows<'s, ID>>,
}

/// A projection item alias
#[derive(Debug)]
pub struct AsAlias<'s, ID> {
    /// the "AS" token
    pub as_token: Option<Node<(), ID>>,
    /// the alias name; might be `None` if the "AS" token was specified but
    /// the name itself was actually missing (which is possible in Oracle SQL)
    pub name: Option<Node<Ident<'s>, ID>>,
}

#[derive(Debug)]
pub enum ProjectionItem<'s, ID> {
    Expr(Expr<'s, ID>, Option<AsAlias<'s, ID>>),
    Wildcard(ProjectionWildcard<'s, ID>),
}

#[derive(Debug)]
pub enum ProjectionWildcard<'s, ID> {
    /// A simple (single, standalone) `*` wildcard
    Simple(Node<(), ID>),
    /// A qualified wildcard, e.g. `t.*`
    Qualified(Identifier<'s, ID>, Node<(), ID>),
}

#[derive(Debug)]
pub struct QueryTables<'s, ID> {
    /// the `FROM` keyword itself
    pub from_token: Node<(), ID>,
    /// `FROM <table-expr>, <table-expr>, ...`
    pub tables: Vec<QueryTable<'s, ID>>,
}

#[derive(Debug)]
pub enum QueryTable<'s, ID> {
    Table(QueryTableWithJoins<'s, ID>),
    // XXX InlineAnalyticalView(..)
}

#[derive(Debug)]
pub struct QueryTableWithJoins<'s, ID> {
    /// the table like expression being queried
    pub table: AliasedQueryTable<'s, ID>,
    /// ... with more, additional joined table expressions
    pub joins: Vec<TableJoin<'s, ID>>,
}

/// The type of an alias of a query table.
///
/// See [AliasedQueryTable::alias].
pub type QueryTableAlias<'s, ID> = Option<Node<Ident<'s>, ID>>;

/// A query table expression with an alias.
#[derive(Debug)]
pub struct AliasedQueryTable<'s, ID> {
    /// `FROM <table-reference> ...`
    pub table: QueryTableType<'s, ID>,
    /// `FROM ... <alias>`
    pub alias: QueryTableAlias<'s, ID>,
}

#[derive(Debug)]
pub enum QueryTableType<'s, ID> {
    /// e.g. `FROM (dual f)`
    Nested(Node<Box<QueryTable<'s, ID>>, ID>),
    /// e.g. `FROM <table-expression>`
    Expr(QueryTableExpression<'s, ID>),
    /// e.g. `FROM ... ONLY (<table-expression>)`
    Only {
        only_token: Node<(), ID>,
        expression: Node<QueryTableExpression<'s, ID>, ID>,
    },
    /// e.g. `FROM CONTAINERS(table_name)`
    Containers(ContainersTable<'s, ID>),
    /// e.g. `FROM SHARDS(table_name)`
    Shards(ShardsTable<'s, ID>),
}

#[derive(Debug)]
pub struct ContainersTable<'s, ID> {
    /// the `CONTAINERS` keyword
    pub containers_token: Node<(), ID>,
    /// the references table / view identifiers nested in parentheses
    pub table: Node<Identifier<'s, ID>, ID>,
}

#[derive(Debug)]
pub struct ShardsTable<'s, ID> {
    /// the `SHARDS` keyword
    pub shards_token: Node<(), ID>,
    /// the references table / view identifiers nested in parentheses
    pub table: Node<Identifier<'s, ID>, ID>,
}

// XXX this is a bit simplified
// see <https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/SELECT.html#GUID-CFA006CA-6FF1-4972-821E-6996142A51C6__I2126073> for the full scale
#[derive(Debug)]
pub enum QueryTableExpression<'s, ID> {
    /// e.g. `FROM table_name` or `FROM schema.table`
    Name(Identifier<'s, ID>),
    /// e.g. `FROM (SELECT 1 FROM DUAL)`
    SubQuery(SubQuery<'s, ID>),
    /// e.g. `FROM TABLE(<expr>) (+)`
    Table(TableCollection<'s, ID>),
    // XXX there's also this form: `FROM func(param)` where `func` returns a
    // collection expression similarly to the table-collection-expression but
    // without the `TABLE(..)`
}

#[derive(Debug)]
pub struct SubQuery<'s, ID> {
    /// e.g. `FROM LATERAL (...)`
    pub lateral_token: Option<Node<(), ID>>,
    /// e.g. `FROM ... ([WITH ...] SELECT 1 FROM DUAL)`
    pub query: Node<Box<Query<'s, ID>>, ID>,
    // XXX subquery_restirction_clause
}

#[derive(Debug)]
pub struct TableCollection<'s, ID> {
    /// the `TABLE` token
    pub table_token: Node<(), ID>,
    /// the collection expression, e.g. `(<expr>)`
    pub expr: Node<Expr<'s, ID>, ID>,
    /// an optional `(+)` to denote an outer join with the table collection;
    /// the outer `Node` denotes the parentheses, the inner one the `plus`
    /// token.
    pub as_outer_join: Option<Node<Node<(), ID>, ID>>,
}

/// The different types of joins together with the (right) join side
#[derive(Debug)]
pub enum TableJoin<'s, ID> {
    Inner(InnerTableJoin<'s, ID>),
    Outer(OuterTableJoin<'s, ID>),
    Apply(ApplyTableJoin<'s, ID>),
}

impl<'s, ID> From<InnerTableJoin<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: InnerTableJoin<'s, ID>) -> Self {
        Self::Inner(value)
    }
}

impl<'s, ID> From<OuterTableJoin<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: OuterTableJoin<'s, ID>) -> Self {
        Self::Outer(value)
    }
}

impl<'s, ID> From<ApplyTableJoin<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: ApplyTableJoin<'s, ID>) -> Self {
        Self::Apply(value)
    }
}

/// An "inner join"
#[derive(Debug)]
pub enum InnerTableJoin<'s, ID> {
    /// e.g. `table1 INNER JOIN table2 ON (..) | USING (..)`
    Inner(InnerJoinedTable<'s, ID>),
    /// e.g. `table1 CROSS JOIN table2`
    Cross(CrossInnerJoinedTable<'s, ID>),
    /// e.g. `table1 NATURAL [INNER] JOIN table2`
    Natural(NaturalInnerJoinedTable<'s, ID>),
}

impl<'s, ID> From<InnerJoinedTable<'s, ID>> for InnerTableJoin<'s, ID> {
    fn from(value: InnerJoinedTable<'s, ID>) -> Self {
        Self::Inner(value)
    }
}

impl<'s, ID> From<InnerJoinedTable<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: InnerJoinedTable<'s, ID>) -> Self {
        Self::Inner(value.into())
    }
}

impl<'s, ID> From<CrossInnerJoinedTable<'s, ID>> for InnerTableJoin<'s, ID> {
    fn from(value: CrossInnerJoinedTable<'s, ID>) -> Self {
        Self::Cross(value)
    }
}

impl<'s, ID> From<CrossInnerJoinedTable<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: CrossInnerJoinedTable<'s, ID>) -> Self {
        Self::Inner(value.into())
    }
}

impl<'s, ID> From<NaturalInnerJoinedTable<'s, ID>> for InnerTableJoin<'s, ID> {
    fn from(value: NaturalInnerJoinedTable<'s, ID>) -> Self {
        Self::Natural(value)
    }
}

impl<'s, ID> From<NaturalInnerJoinedTable<'s, ID>> for TableJoin<'s, ID> {
    fn from(value: NaturalInnerJoinedTable<'s, ID>) -> Self {
        Self::Inner(value.into())
    }
}

/// A `[INNER] JOIN <table> ON|USING ...`
#[derive(Debug)]
pub struct InnerJoinedTable<'s, ID> {
    /// the `INNER` keyword, if it present
    pub inner_token: Option<Node<(), ID>>,
    /// the `JOIN` keyword itself
    pub join_token: Node<(), ID>,
    /// the table (or table expression) being joined
    pub table: Box<AliasedQueryTable<'s, ID>>,
    /// the condition being joined on
    pub condition: JoinCondition<'s, ID>,
}

/// A `CROSS JOIN <table>`
#[derive(Debug)]
pub struct CrossInnerJoinedTable<'s, ID> {
    /// the `CROSS` keyword
    pub cross_token: Node<(), ID>,
    /// the `JOIN` keyword
    pub join_token: Node<(), ID>,
    /// the table (or table expression) being joined
    pub table: Box<AliasedQueryTable<'s, ID>>,
}

/// A `NATURAL [INNER] JOIN <table>`
#[derive(Debug)]
pub struct NaturalInnerJoinedTable<'s, ID> {
    /// the `NATURAL` keyword
    pub natural_token: Node<(), ID>,
    /// the optional `INNER` keyword
    pub inner_token: Option<Node<(), ID>>,
    /// the `JOIN` keyword
    pub join_token: Node<(), ID>,
    /// the table (or table expression) being joined
    pub table: Box<AliasedQueryTable<'s, ID>>,
}

/// A `[NATURAL] (FULL|LEFT|RIGHT) [OUTER] JOIN [ON ...|USING ...]` clause
#[derive(Debug)]
pub struct OuterTableJoin<'s, ID> {
    /// the type of the join, e.g. `LEFT`, `RIGHT`, or `FULL`
    pub type_token: Node<OuterJoinType, ID>,
    /// the optional `OUTER` token
    pub outer_token: Option<Node<(), ID>>,
    /// the `JOIN` keyword
    pub join_token: Node<(), ID>,
    /// the table (or table expression) being joined
    pub table: Box<AliasedQueryTable<'s, ID>>,
    /// an optional `PARTITION BY` on one of the join sides
    pub partition_by: Option<OuterTableJoinParitionBy<'s, ID>>,
    /// the join condition, either implicit by `NATURAL` or an explicit, user
    /// provided condition
    pub condition: OuterJoinCondition<'s, ID>,
}

/// A `PARTITION BY` applied to one of the sides of an outer join;
///
/// Note: a "partition by" clause is _not_ valid for a `FULL` outer join
#[derive(Debug)]
pub enum OuterTableJoinParitionBy<'s, ID> {
    /// with the `PARTITION BY` applying to the left side of the join,
    /// e.g. `SELECT * FROM left_table PARTITION BY (<expr>) LEFT JOIN right_table ON (<condition>)`
    Left(PartitionBy<'s, ID>),
    /// with the `PARTITION BY` applying to the right side of the join,
    /// e.g. `SELECT * FROM left_table LEFT JOIN right_table PARTITION BY (<expr>) ON (<condition>)`
    Right(PartitionBy<'s, ID>),
}

/// `PARTITION BY (<expr>, <expr>)` of an
/// [outer join](OuterTableJoin::partition_by) or
/// an analytic [function call](crate::ast::FunctionParams::over)
#[derive(Debug)]
pub struct PartitionBy<'s, ID> {
    /// the `PARTITION` keyword
    pub partition_token: Node<(), ID>,
    /// the `BY` keyword
    pub by_token: Node<(), ID>,
    /// the partition expressions, e.g. `<expr>, <expr>` or `(<expr>, <expr>)`
    pub expressions: PartitionByExprs<'s, ID>,
}

/// A list of expressions for of [`PartitionBy`] clause.
///
/// # Note
///
/// * A `PARTITION BY` as part of an "outer join" always encloses its
///   expressions in parentheses and, therefore, represented by
///   [PartitionByExprs::List].
/// * On the other hand, a `PARTITION BY` used in an anlytical function, is
///   _not_ enclosing the expression in parentheses and, therefore, represted
///   by [PartitionByExprs::Exprs].
///
/// The parses enforces these rules.
#[derive(Debug)]
pub enum PartitionByExprs<'s, ID> {
    /// a comma separated sequence of expressions without being enclosed in
    /// parentheses, e.g. `1, 2, 3`
    Exprs(Vec<Expr<'s, ID>>),
    /// a comma separated list of expressions enclosed in parentheses,
    /// e.g. `(1, 2, 3)`
    List(ExprList<'s, ID>),
}

impl<'s, ID> Deref for PartitionByExprs<'s, ID> {
    type Target = [Expr<'s, ID>];

    fn deref(&self) -> &Self::Target {
        match self {
            PartitionByExprs::Exprs(exprs) => exprs,
            PartitionByExprs::List(list) => list,
        }
    }
}

#[derive(Debug)]
pub enum OuterJoinCondition<'s, ID> {
    /// A `NATURAL` join (without an explicit join condition)
    ///
    /// The contained node refers to the `NATURAL` keyword
    Natural { natural_token: Node<(), ID> },
    /// A regular join with an optional, explicit condition
    Regular(Option<JoinCondition<'s, ID>>),
}

/// The type of an outer join
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum OuterJoinType {
    /// `FULL`
    Full,
    /// `LEFT`
    Left,
    /// `RIGHT`
    Right,
}

#[derive(Debug)]
pub enum JoinCondition<'s, ID> {
    /// e.g. `JOIN ... ON (1 = 1)`
    On(JoinConditionOn<'s, ID>),
    /// e.g. `JOIN ... USING (a, b)`
    Using(JoinConditionUsing<'s, ID>),
}

/// A [JoinCondition::On]
#[derive(Debug)]
pub struct JoinConditionOn<'s, ID> {
    /// the `ON` keyword
    pub on_token: Node<(), ID>,
    /// the condition itself
    pub condition: Condition<'s, ID>,
}

/// A [JoinCondition::Using]
#[derive(Debug)]
pub struct JoinConditionUsing<'s, ID> {
    /// the `USING` keyword
    pub using_token: Node<(), ID>,
    /// list of column common to both table on which to join
    pub columns: Node<Vec<Node<Ident<'s>, ID>>, ID>,
}

/// A `<table1> (CROSS | OUTER) APPLY <table2>` join
#[derive(Debug)]
pub struct ApplyTableJoin<'s, ID> {
    /// the type of the `APPLY` join
    pub type_token: Node<ApplyJoinType, ID>,
    /// the `APPLY` token
    pub apply_token: Node<(), ID>,
    /// the joined table or value collection
    pub table: ApplyJoinTable<'s, ID>,
}

/// The different types of a [TableJoin::Apply] join.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ApplyJoinType {
    /// e.g. `CROSS APPLY ...`; equivalent to a `INNER JOIN LATERAL`
    Cross,
    /// e.g. `OUTER APPLY ...`; equivalent to a `LEFT JOIN LATERAL`
    Outer,
}

/// A joined table (expression) via [TableJoin::Apply]
#[derive(Debug)]
pub enum ApplyJoinTable<'s, ID> {
    /// e.g. `CROSS APPLY (SELECT ...) t`
    Table(Box<AliasedQueryTable<'s, ID>>),
    /// e.g. `CROSS APPLY my_function()` with `my_function()` returning a collection
    Expr(Expr<'s, ID>),
}

/// The `WITH` clause
#[derive(Debug)]
pub struct With<'s, ID> {
    /// the `WITH` keyword
    pub with_keyword: Node<(), ID>,
    // XXX plsql_declarations
    /// the common table expressions; at least one provided
    pub ctes: Vec<CteTable<'s, ID>>,
}

#[derive(Debug)]
pub enum CteTable<'s, ID> {
    SubQuery(CteSubQuery<'s, ID>),
    // XXX analytical view (subav_factoring_clauses)
}

#[derive(Debug)]
pub struct CteSubQuery<'s, ID> {
    /// the name of the CTE
    pub name: Node<Ident<'s>, ID>,
    /// optional column aliases, e.g. `WITH cte_name (column_alias1, column_alias2) AS ...`
    pub column_aliases: Option<Node<Vec<Node<Ident<'s>, ID>>, ID>>,
    /// the `AS` token, e.g. `WITH cte_name AS (...`
    pub as_token: Node<(), ID>,
    /// the CTE query itself, e.g. `WITH cte_name AS (SELECT 1 FROM dual) ...`;
    /// the node represents the braces encompasing the query
    pub query: Node<Box<QueryBody<'s, ID>>, ID>,
    // XXX search_clause
    // XXX cycle_clause
}

/// Condition to a [QueryBlock] by which to restrict / filter the selections'
/// data; specified by a `WHERE ...` in a SQL statement
#[derive(Debug)]
pub struct WhereCondition<'s, ID> {
    /// the `WHERE` keyword
    pub where_token: Node<(), ID>,
    /// the `<condition>` itself
    pub condition: Condition<'s, ID>,
}

#[derive(Debug)]
pub struct GroupBy<'s, ID> {
    /// the `GROUP` keyword
    pub group_token: Node<(), ID>,
    /// the `BY` keyword
    pub by_token: Node<(), ID>,
    /// the grouping expressions
    pub group_type: GroupByType<'s, ID>,
    /// the `HAVING ...` clause filtering the groups
    pub having: Option<HavingCondition<'s, ID>>,
}

#[derive(Debug)]
pub enum GroupByType<'s, ID> {
    /// a grouping directly by a list of expressions
    Exprs(GroupByExprs<'s, ID>),
    // XXX ROLLUP / CUBE
    // XXX GROUPING SETS
}

#[derive(Debug)]
pub enum GroupByExprs<'s, ID> {
    /// e.g. `GROUP BY ()`; the outer node denotes the surrounding parentheses
    /// while the inner node denotes the "inner space" of them, possibly
    /// associated with comments.
    All(Node<Node<(), ID>, ID>),
    /// a list of expressions to group by, e.g `GROUP BY id, name`
    Exprs(Vec<Expr<'s, ID>>),
    /// just like [GroupByExprs::Exprs] but enclosed by parantheses
    /// possibly associated with comments, e.g. `GROUP BY (id, name)`
    Nested(Node<Vec<Expr<'s, ID>>, ID>),
}

/// The `HAVING` clause of a [GroupBy] definition.
#[derive(Debug)]
pub struct HavingCondition<'s, ID> {
    /// the `HAVING` keyword
    pub having_token: Node<(), ID>,
    /// the restricting condition
    pub condition: Condition<'s, ID>,
}

/// A `FOR UPDATE ...` of a [`SELECT`](Select) statement.
#[derive(Debug)]
pub struct ForUpdate<'s, ID> {
    /// the `FOR` keyword
    pub for_token: Node<(), ID>,
    /// the `UPDATE` keyword
    pub update_token: Node<(), ID>,
    /// the lock row `OF col1, col2, ...` columns
    pub of_columns: Option<ForUpdateOfColumns<'s, ID>>,
    /// lock options, e.g. `NOWAIT`
    pub lock_opts: Option<ForUpdateLockOptions<'s, ID>>,
}

/// List of columns in an [ForUpdate] clause identifying the rows' tables to be locked.
///
/// "…Oracle will lock only the rows in those tables that contain any of the specified columns.…"
/// — [source](https://www.oreilly.com/library/view/oracle-pl-sql-best/0596001215/re70.html)
#[derive(Debug)]
pub struct ForUpdateOfColumns<'s, ID> {
    /// the `OF` keyword
    pub of_token: Node<(), ID>,
    /// the list of columns identifying row tables to lock; valid with at
    /// least one column identifier
    pub columns: Vec<Identifier<'s, ID>>,
}

/// Options on acquiring a lock through [`FOR UPDATE`](ForUpdate)
#[derive(Debug)]
pub enum ForUpdateLockOptions<'s, ID> {
    /// e.g. `SKIP LOCKED`
    Skip {
        /// the `SKIP` keyword ...
        skip_token: Node<(), ID>,
        /// the `LOCKED` keyword
        locked_token: Node<(), ID>,
    },
    /// e.g. `NOWAIT`
    NoWait {
        /// the `NOWAIT` token
        nowait_token: Node<(), ID>,
    },
    /// e.g. `WAIT 10`
    Wait {
        /// the `WAIT` keyword
        wait_token: Node<(), ID>,
        /// the duration in seconds to wait for the lock to get acquired;
        /// integer without a sign, only decimals with possibly leading zeros
        duration: Node<&'s str, ID>,
    },
}

/// e.g. `SELECT ... OFFSET 10 ROWS FETCH 20 ROWS ONLY`
///
/// Both, `OFFSET` and `FETCH` are optional, but never `None` at the same
/// time.
#[derive(Debug)]
pub struct RowLimit<'s, ID> {
    /// e.g. `... OFFSET <n> ROWS`
    pub offset: Option<RowLimitOffset<'s, ID>>,
    /// e.g. `... FETCH 10 PERCENT ROWS WITH TIES`
    pub fetch: Option<RowLimitFetch<'s, ID>>,
}

/// The "offset" definition of a [row limit](RowLimit) clause
#[derive(Debug)]
pub struct RowLimitOffset<'s, ID> {
    /// the `OFFSET` keyword
    pub offset_token: Node<(), ID>,
    /// the number of rows to skip; typically an integer literal by can be any
    /// expression evaluating to a number
    pub offset_value: Expr<'s, ID>,
    /// the `ROW` or `ROWS` keyword
    pub row_token: Node<RowKeyword, ID>,
}

/// The "limit" definition of a [row limit](RowLimit) clause
#[derive(Debug)]
pub struct RowLimitFetch<'s, ID> {
    /// the `FETCH` keyword
    pub fetch_token: Node<(), ID>,
    /// the `FIRST | NEXT` keyword following `FETCH`
    pub first_token: Node<FetchFirstKeyword, ID>,
    /// the `ROW` or `ROWS` keyword
    pub row_token: Node<RowKeyword, ID>,
    /// the number or percent of rows to fetch
    pub fetch_amount: FetchAmount<'s, ID>,
    /// corresponding to `ONLY` | WITH TIES` keywords
    pub fetch_amount_spec: FetchAmountSpec<ID>,
}

/// the `FIRST | NEXT` keywords part of a [RowLimitFetch] clause; all variants are
/// interchanglable and have the same meaning
#[derive(Debug, Copy, Clone)]
pub enum FetchFirstKeyword {
    /// the `FIRST` keyword
    First,
    /// the `NEXT` keyword
    Next,
}

/// The definition of the count or percentages in a [RowLimitFetch] clause
#[derive(Debug)]
pub enum FetchAmount<'s, ID> {
    /// the count of rows to return; generally a numeric literal but can be
    /// any expression evaluating to a number
    Count(Expr<'s, ID>),
    /// percentage of rows to return
    Percent {
        /// the percentage value of rows to return; generally a numeric
        /// literal but can be any expression evaulating to a number
        amount: Expr<'s, ID>,
        /// the `PERCENT` keyword
        percent_token: Node<(), ID>,
    },
}

/// Details regarding a [row limiting's fetch](RowLimitFetch)
#[derive(Debug)]
pub enum FetchAmountSpec<ID> {
    Only {
        only_token: Node<(), ID>,
    },
    WithTies {
        with_token: Node<(), ID>,
        ties_token: Node<(), ID>,
    },
}

/// The `ROW(S)` keyword part of a [RowLimit] clause; all variants are
/// interchanglable and have the same meaning
#[derive(Debug, Copy, Clone)]
pub enum RowKeyword {
    /// the `ROW` keyword
    Row,
    /// the `ROWS` keyword
    Rows,
}

/// A query's defined [`WINDOW's`](QuerySelect::windows) for reference in analytical function calls
#[derive(Debug)]
pub struct QueryWindows<'s, ID> {
    /// the `WINDOW` keyword
    pub window_token: Node<(), ID>,
    /// the list of defined query windows
    pub windows: Vec<QueryWindow<'s, ID>>,
}

/// A window defintion as part of a query's `WINDOW` clause,
/// e.g. `window_name AS (partition by column)`
#[derive(Debug)]
pub struct QueryWindow<'s, ID> {
    /// the window's defined name
    pub name: Node<Ident<'s>, ID>,
    /// the `AS` keyword
    pub as_token: Node<(), ID>,
    /// the window specification
    pub window: Node<WindowSpec<'s, ID>, ID>,
}