Struct CommonTableExpression

pub struct CommonTableExpression { /* private fields */ }

A table definition inside a WITH clause (WithClause).

A WITH clause can contain one or multiple common table expressions (CommonTableExpression).

These named queries can act as a “query local table” that are materialized during execution and then can be used by the query prefixed with the WITH clause.

A WITH clause can contain multiple of these CommonTableExpression. (Except in the case of recursive WITH query which can only contain one CommonTableExpression).

A CommonTableExpression is a name, column names and a query returning data for those columns.

Some databases (like sqlite) restrict the acceptable kinds of queries inside of the WITH clause common table expressions. These databases only allow SelectStatements to form a common table expression.

Other databases like postgres allow modification queries (UPDATE, DELETE) inside of the WITH clause but they have to return a table. (They must have a RETURNING clause).

sea-query doesn’t check this or restrict the kind of CommonTableExpression that you can create in rust. This means that you can put an UPDATE or DELETE queries into WITH clause and sea-query will succeed in generating that kind of sql query but the execution inside the database will fail because they are invalid.

It is your responsibility to ensure that the kind of WITH clause that you put together makes sense and valid for that database that you are using.

NOTE that for recursive WITH queries (in sql: “WITH RECURSIVE”) you can only have a single CommonTableExpression inside of the WITH clause. That query must match certain requirements:

• It is a query of UNION or UNION ALL of two queries.
• The first part of the query (the left side of the UNION) must be executable first in itself. It must be non-recursive. (Cannot contain self reference)
• The self reference must appear in the right hand side of the UNION.
• The query can only have a single self-reference.
• Recursive data-modifying statements are not supported, but you can use the results of a recursive SELECT query in a data-modifying statement. (like so: WITH RECURSIVE cte_name(a,b,c,d) AS (SELECT … UNION SELECT … FROM … JOIN cte_name ON … WHERE …) DELETE FROM table WHERE table.a = cte_name.a)

It is mandatory to set the Self::table_name and the Self::query.

Implementations

impl CommonTableExpression

pub fn new() -> CommonTableExpression

Construct a new CommonTableExpression

pub fn table_name<T>(&mut self, table_name: T) -> &mut Self

where T: IntoIden,

Sets the CTE table name of the query.

pub fn column<C>(&mut self, col: C) -> &mut Self

where C: IntoIden,

Adds a named column to the CTE table definition.

pub fn columns<T, I>(&mut self, cols: I) -> &mut Self

where T: IntoIden, I: IntoIterator<Item = T>,

Adds a named columns to the CTE table definition.

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

Some databases allow you to put “MATERIALIZED” or “NOT MATERIALIZED” in the CTE definition. This will affect how during the execution of WithQuery the CTE in the WithClause will be executed. If the database doesn’t support this syntax this option specified here will be ignored and not appear in the generated sql.

pub fn query<Q>(&mut self, query: Q) -> &mut Self

where Q: QueryStatementBuilder,

Set the query generating the CTE content. The query’s result must match the defined columns.

pub fn from_select(select: SelectStatement) -> Self

Create a CTE from a SelectStatement if the selections are named columns then this will return a CommonTableExpression that has the column names set. The Self::table_name is set if the SelectStatement from clause contains at least one table.

pub fn try_set_cols_from_select(&mut self, select: &SelectStatement) -> bool

Set up the columns of the CTE to match the given SelectStatement selected columns. This will fail if the select contains non named columns like expressions of wildcards.

Returns true if the column setup from the select query was successful. If the returned value is false the columns are untouched.

Trait Implementations

impl Clone for CommonTableExpression

fn clone(&self) -> CommonTableExpression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CommonTableExpression

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

Formats the value using the given formatter.

impl Default for CommonTableExpression

fn default() -> CommonTableExpression

Returns the “default value” for a type.

impl PartialEq for CommonTableExpression

fn eq(&self, other: &CommonTableExpression) -> 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 StructuralPartialEq for CommonTableExpression