Struct 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() -> WithQuery

Constructs a new empty WithQuery.

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

Set the whole WithClause.

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

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

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

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

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

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

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

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

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

where T: Into<SubQueryStatement>,

Set the query that you execute with the WithClause.

impl WithQuery

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

where T: QueryBuilder,

See QueryStatementWriter::build_collect_into

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

where T: QueryBuilder,

See QueryStatementWriter::build_collect

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

where T: QueryBuilder,

See QueryStatementWriter::build

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

where T: QueryBuilder,

See QueryStatementWriter::to_string

Trait Implementations

impl Clone for WithQuery

fn clone(&self) -> WithQuery

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl Default for WithQuery

fn default() -> WithQuery

Returns the “default value” for a type.

impl From<WithQuery> for Expr

fn from(v: WithQuery) -> Expr

Converts to this type from the input type.

impl From<WithQuery> for SubQueryStatement

fn from(s: WithQuery) -> SubQueryStatement

Converts to this type from the input type.

impl PartialEq for WithQuery

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

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

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

fn build_any(&self, query_builder: &impl 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: &impl QueryBuilder, sql: &mut impl SqlWriter, ) -> String

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

fn into_sub_query_statement(self) -> SubQueryStatement

impl QueryStatementWriter for WithQuery

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

where T: QueryBuilder,

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

where T: QueryBuilder,

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

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

where T: QueryBuilder,

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

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

where T: QueryBuilder,

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

impl StatementBuilder for WithQuery

fn build(&self, db_backend: &DatabaseBackend) -> Statement

Method to build a Statement

impl StructuralPartialEq for WithQuery