Enum OrderBy 

pub enum OrderBy {
    Field(OrderByField),
    Fields(Box<[OrderByField]>),
}

Order by specification that can be a single field or multiple fields.

Variants

Field(OrderByField)

Order by a single field.

Fields(Box<[OrderByField]>)

Order by multiple fields (frozen slice for memory efficiency).

Implementations

impl OrderBy

pub fn none() -> Self

Create an empty order by (no ordering).

pub fn is_empty(&self) -> bool

Check if the order by is empty.

pub fn then(self, field: OrderByField) -> Self

Add a field to the order by.

pub fn from_fields(fields: impl IntoIterator<Item = OrderByField>) -> Self

Create an OrderBy from multiple fields (optimized).

pub fn to_sql(&self) -> String

Generate the SQL ORDER BY clause (without the “ORDER BY” keyword).

Optimized to write directly to a pre-sized buffer.

pub fn write_sql(&self, buffer: &mut String)

Write the SQL ORDER BY clause directly to a buffer (zero allocation).

Examples

use prax_query::types::{OrderBy, OrderByField};

let order = OrderBy::from_fields([
    OrderByField::desc("created_at"),
    OrderByField::asc("id"),
]);
let mut buffer = String::with_capacity(64);
buffer.push_str("ORDER BY ");
order.write_sql(&mut buffer);
assert_eq!(buffer, "ORDER BY created_at DESC, id ASC");

pub fn field_count(&self) -> usize

Get the number of fields in this OrderBy.

Trait Implementations

impl Clone for OrderBy

fn clone(&self) -> OrderBy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrderBy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<OrderByField> for OrderBy

fn from(field: OrderByField) -> Self

Converts to this type from the input type.

impl From<Vec<OrderByField>> for OrderBy

fn from(fields: Vec<OrderByField>) -> Self

Converts to this type from the input type.

impl PartialEq for OrderBy

fn eq(&self, other: &OrderBy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for OrderBy

impl StructuralPartialEq for OrderBy