use cot::db::{DbFieldValue, ToDbFieldValue};
use crate::db::Identifier;
use crate::db::query::expr::{FieldRef, SqlQueryBuilder};
use crate::db::query::{Expr, IntoField, QueryBuildingError};
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum SortOrder {
Asc,
Desc,
}
impl From<&SortOrder> for sea_query::Order {
fn from(value: &SortOrder) -> Self {
match value {
SortOrder::Asc => sea_query::Order::Asc,
SortOrder::Desc => sea_query::Order::Desc,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NullsOrder {
First,
Last,
}
impl From<NullsOrder> for sea_query::NullOrdering {
fn from(value: NullsOrder) -> Self {
match value {
NullsOrder::First => sea_query::NullOrdering::First,
NullsOrder::Last => sea_query::NullOrdering::Last,
}
}
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub(crate) enum OrderTarget {
Column(Identifier),
Expression(Expr),
}
#[derive(Debug, Clone, PartialEq)]
enum OrderMode {
Directional { order: SortOrder, nulls: NullsOrder },
FieldValue(sea_query::Values),
}
fn default_nulls_for(order: SortOrder) -> NullsOrder {
match order {
SortOrder::Asc => NullsOrder::Last,
SortOrder::Desc => NullsOrder::First,
}
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct OrderByExpr {
target: OrderTarget,
mode: OrderMode,
}
impl OrderByExpr {
pub(crate) fn directional(target: OrderTarget, order: SortOrder) -> Self {
Self {
target,
mode: OrderMode::Directional {
order,
nulls: default_nulls_for(order),
},
}
}
pub(crate) fn by_values(target: OrderTarget, values: sea_query::Values) -> Self {
assert!(
!values.0.is_empty(),
"`by_values` requires at least one value to rank by"
);
Self {
target,
mode: OrderMode::FieldValue(values),
}
}
#[must_use]
pub fn nulls_first(mut self) -> Self {
self.set_nulls(NullsOrder::First);
self
}
#[must_use]
pub fn nulls_last(mut self) -> Self {
self.set_nulls(NullsOrder::Last);
self
}
#[track_caller]
fn set_nulls(&mut self, nulls: NullsOrder) {
match &mut self.mode {
OrderMode::Directional { nulls: n, .. } => *n = nulls,
OrderMode::FieldValue(_) => panic!(
"`nulls_first`/`nulls_last` can't be combined with `by_values`: a by_values \
term never produces a NULL sort key, so an explicit NULLS placement would \
have no effect"
),
}
}
pub(crate) fn add_to_statement(
&self,
statement: &mut sea_query::SelectStatement,
sql_builder: &dyn SqlQueryBuilder,
) -> Result<(), QueryBuildingError> {
let (sea_order, nulls): (sea_query::Order, Option<NullsOrder>) = match &self.mode {
OrderMode::Directional { order, nulls } => (order.into(), Some(*nulls)),
OrderMode::FieldValue(values) => (sea_query::Order::Field(values.clone()), None),
};
match &self.target {
OrderTarget::Column(field) => match nulls {
Some(nulls) => {
statement.order_by_with_nulls(*field, sea_order, nulls.into());
}
None => {
statement.order_by(*field, sea_order);
}
},
OrderTarget::Expression(expr) => {
let expr = expr.as_sea_query_expr(sql_builder)?;
match nulls {
Some(nulls) => {
statement.order_by_expr_with_nulls(expr, sea_order, nulls.into());
}
None => {
statement.order_by_expr(expr, sea_order);
}
}
}
}
Ok(())
}
}
impl<T: ToDbFieldValue + 'static> From<FieldRef<T>> for OrderByExpr {
fn from(field: FieldRef<T>) -> Self {
OrderByExpr::directional(OrderTarget::Column(field.identifier()), SortOrder::Asc)
}
}
impl From<Expr> for OrderByExpr {
fn from(expr: Expr) -> Self {
expr.asc()
}
}
pub trait ExprSort<T> {
fn asc(&self) -> OrderByExpr;
fn desc(&self) -> OrderByExpr;
fn by_values<I>(&self, values: I) -> OrderByExpr
where
I: IntoIterator,
I::Item: IntoField<T>;
}
impl<T: ToDbFieldValue + 'static> ExprSort<T> for FieldRef<T> {
fn asc(&self) -> OrderByExpr {
OrderByExpr::directional(OrderTarget::Column(self.identifier()), SortOrder::Asc)
}
fn desc(&self) -> OrderByExpr {
OrderByExpr::directional(OrderTarget::Column(self.identifier()), SortOrder::Desc)
}
fn by_values<I>(&self, values: I) -> OrderByExpr
where
I: IntoIterator,
I::Item: IntoField<T>,
{
let values = values
.into_iter()
.map(|v| match v.into_field().to_db_field_value() {
DbFieldValue::Value(value) => value,
DbFieldValue::Auto => {
panic!("cannot use an auto-generated value as a field value ordering key")
}
})
.collect();
OrderByExpr::by_values(
OrderTarget::Column(self.identifier()),
sea_query::Values(values),
)
}
}