Struct sea_query::query::WithQuery

pub struct WithQuery { /* private fields */ }

A WITH query. A simple SQL query that has a WITH clause (WithClause).

The WithClause 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::cte and the Self::query.

Implementations

impl WithQuery

pub fn new() -> Self

Constructs a new empty WithQuery.

pub fn with_clause(&mut self, with_clause: WithClause) -> &mut Self

Set the whole WithClause.

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

Set the WithClause::recursive. See that method for more information.

pub fn search(&mut self, search: Search) -> &mut Self

Add the WithClause::search. See that method for more information.

pub fn cycle(&mut self, cycle: Cycle) -> &mut Self

Set the WithClause::cycle. See that method for more information.

pub fn cte(&mut self, cte: CommonTableExpression) -> &mut Self

Add a CommonTableExpression to the with clause. See WithClause::cte.

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

where T: QueryStatementBuilder,

Set the query that you execute with the WithClause.

impl WithQuery

pub fn build_collect_into<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter )

See QueryStatementWriter::build_collect_into

pub fn build_collect<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter ) -> String

See QueryStatementWriter::build_collect

pub fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

See QueryStatementWriter::build

pub fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

See QueryStatementWriter::to_string

Trait Implementations

impl Clone for WithQuery

fn clone(&self) -> WithQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WithQuery

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

Formats the value using the given formatter.

impl Default for WithQuery

fn default() -> WithQuery

Returns the “default value” for a type.

impl PartialEq for WithQuery

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl QueryStatementBuilder for WithQuery

fn build_collect_any_into( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter )

Build corresponding SQL statement into the SqlWriter for certain database backend and collect query parameters

fn into_sub_query_statement(self) -> SubQueryStatement

fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_collect_any( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter ) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

impl QueryStatementWriter for WithQuery

fn build_collect_into<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter )

fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

Build corresponding SQL statement for certain database backend and return SQL string

fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_collect<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter ) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

impl StructuralPartialEq for WithQuery