Struct CteRef 

pub struct CteRef<'a> {
    pub name: Cow<'a, str>,
    pub columns: SmallVec<[Cow<'a, str>; 8]>,
    pub query: Cow<'a, str>,
    pub recursive: bool,
    pub materialized: Option<bool>,
}

A zero-copy CTE definition that accepts column slices.

This is more efficient than Cte when working with static column lists.

Example

use prax_query::zero_copy::CteRef;
use prax_query::sql::DatabaseType;

// Column names are borrowed from a static slice
let cte = CteRef::new("active_users")
    .columns(&["id", "name", "email"])
    .query("SELECT id, name, email FROM users WHERE active = true");

let sql = cte.to_sql(DatabaseType::PostgreSQL);

Fields

name: Cow<'a, str>

CTE name.

columns: SmallVec<[Cow<'a, str>; 8]>

Column aliases (borrowed from slice).

query: Cow<'a, str>

The defining query.

recursive: bool

Whether this is recursive.

materialized: Option<bool>

Materialization hint (PostgreSQL).

Implementations

impl<'a> CteRef<'a>

pub fn new(name: &'a str) -> Self

Create a new CTE with a borrowed name.

pub fn owned(name: String) -> Self

Create a new CTE with an owned name.

pub fn columns(self, cols: &[&'a str]) -> Self

Set column aliases from a slice (zero-copy).

pub fn columns_owned<I, S>(self, cols: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Set column aliases (owned).

pub fn column(self, col: &'a str) -> Self

Add a single column (borrowed).

pub fn query(self, q: &'a str) -> Self

Set the defining query (borrowed).

pub fn query_owned(self, q: String) -> Self

Set the defining query (owned).

pub fn recursive(self) -> Self

Mark as recursive CTE.

pub fn materialized(self, mat: bool) -> Self

Set materialization hint (PostgreSQL).

pub fn is_zero_copy(&self) -> bool

Check if this CTE uses only borrowed data.

pub fn to_sql(&self, db_type: DatabaseType) -> String

Generate the CTE definition SQL.

pub fn to_owned_cte(&self) -> Cte

Convert to owned Cte.

Trait Implementations

impl<'a> Clone for CteRef<'a>

fn clone(&self) -> CteRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CteRef<'a>

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

Formats the value using the given formatter.

impl<'a> Default for CteRef<'a>

fn default() -> CteRef<'a>

Returns the “default value” for a type.