Struct SelectStatement 

pub struct SelectStatement {

    pub fields: Fields,
    pub omit: Vec<Expr>,
    pub only: bool,
    pub what: Vec<Expr>,
    pub with: Option<With>,
    pub cond: Option<Cond>,
    pub split: Option<Splits>,
    pub group: Option<Groups>,
    pub order: Option<Ordering>,
    pub limit: Option<Limit>,
    pub start: Option<Start>,
    pub fetch: Option<Fetchs>,
    pub version: Expr,
    pub timeout: Expr,
    pub explain: Option<Explain>,
    pub tempfiles: bool,
    pub for_update: bool,
}

Fields

fields: Fields

The fields to extract from the records.

The foo,bar part in SELECT foo,bar FROM baz.

omit: Vec<Expr>

The fields to omit from the records. This is used to exclude fields from wildcard selection.

The OMIT foo,bar part in SELECT foo,bar OMIT baz,qux FROM baz.

only: bool

Whether to only return a single record.

The ONLY part in SELECT * FROM ONLY foo.

what: Vec<Expr>

The expressions (tables, record IDs, arrays, etc) to select from.

The baz part in SELECT foo,bar FROM baz.

with: Option<With>

cond: Option<Cond>

The WHERE clause.

split: Option<Splits>

The SPLIT clause.

This is used to produce the cartesian product of the values in split fields.

group: Option<Groups>

order: Option<Ordering>

limit: Option<Limit>

start: Option<Start>

fetch: Option<Fetchs>

version: Expr

timeout: Expr

explain: Option<Explain>

tempfiles: bool

for_update: bool

Whether the read locks the selected records for the duration of the transaction.

The FOR UPDATE part in SELECT * FROM foo FOR UPDATE.

Implementations

impl SelectStatement

pub fn read_only(&self) -> bool

Check if computing this type can be done on a read only transaction. Whether computing this statement can be done on a read-only transaction.

Every clause that can carry a user expression is inspected. The executor picks the transaction type from this before the statement is planned, so a clause omitted here would let a mutation reach a read-only transaction and fail partway through the statement. A FOR UPDATE read always requires a write transaction: the locked reads register the fetched keys for commit-time conflict detection, which storage engines only support on writeable transactions.

Trait Implementations

impl Clone for SelectStatement

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectStatement

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

Formats the value using the given formatter.

impl Eq for SelectStatement

impl From<SelectStatement> for SelectStatement

fn from(v: SelectStatement) -> Self

Converts to this type from the input type.

impl From<SelectStatement> for SelectStatement

fn from(v: SelectStatement) -> Self

Converts to this type from the input type.

impl Hash for SelectStatement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SelectStatement

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SelectStatement

impl<V: Visitor> Visit<V> for SelectStatement

fn visit(&self, this: &mut V) -> Result<(), V::Error>

impl<V: MutVisitor> VisitMut<V> for SelectStatement

fn visit_mut(&mut self, this: &mut V) -> Result<(), V::Error>