Struct Select

pub struct Select<'a> {
    pub select_span: Span,
    pub flags: Vec<SelectFlag>,
    pub select_exprs: Vec<SelectExpr<'a>>,
    pub from_span: Option<Span>,
    pub table_references: Option<Vec<TableReference<'a>>>,
    pub where_: Option<(Expression<'a>, Span)>,
    pub group_by: Option<(Span, Vec<Expression<'a>>)>,
    pub having: Option<(Expression<'a>, Span)>,
    pub window_span: Option<Span>,
    pub order_by: Option<(Span, Vec<(Expression<'a>, OrderFlag)>)>,
    pub limit: Option<(Span, Option<Expression<'a>>, Expression<'a>)>,
    pub locking: Option<Locking<'a>>,
}

Representation of select Statement

let sql = "SELECT f1,f2 FROM t1 WHERE f3<=10 AND f4='y'";
let mut issues = Issues::new(sql);
let stmt = parse_statement(sql, &mut issues, &options);

let s: Select = match stmt {
    Some(Statement::Select(s)) => s,
    _ => panic!("We should get an select statement")
};

println!("{:#?}", s.where_);

let sql = "SELECT CAST(NULL AS CHAR)";
let stmt = parse_statement(sql, &mut issues, &options);

let s: Select = match stmt {
    Some(Statement::Select(s)) => s,
    _ => panic!("We should get an select statement")
};

println!("{:#?}", s.where_);

let sql = "SELECT * FROM t1, d2.t2 FOR SHARE OF t1, t2 NOWAIT";
let stmt = parse_statement(sql, &mut issues, &options);

let s: Select = match stmt {
    Some(Statement::Select(s)) => s,
    _ => panic!("We should get an select statement")
};

assert!(s.locking.is_some());
println!("{:#?}", s.locking);

Fields

select_span: Span

Span of “SELECT”

flags: Vec<SelectFlag>

Flags specified after “SELECT”

select_exprs: Vec<SelectExpr<'a>>

List of values to select

from_span: Option<Span>

Span of “FROM”

table_references: Option<Vec<TableReference<'a>>>

List of tables to select from

where_: Option<(Expression<'a>, Span)>

Where expression and span of “WHERE” if specified

group_by: Option<(Span, Vec<Expression<'a>>)>

Span of “GROUP_BY” and group expression if specified

having: Option<(Expression<'a>, Span)>

Having expression and span of “HAVING” if specified

window_span: Option<Span>

Span of window if specified

order_by: Option<(Span, Vec<(Expression<'a>, OrderFlag)>)>

Span of “ORDER BY” and list of order expression and directions, if specified

limit: Option<(Span, Option<Expression<'a>>, Expression<'a>)>

Span of “LIMIT”, offset and count expressions if specified

locking: Option<Locking<'a>>

Row locking clause

Trait Implementations

impl<'a> Clone for Select<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Select<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for Select<'a>

fn span(&self) -> Span

Compute byte span of an ast fragment

fn join_span(&self, other: &impl OptSpanned) -> Span

Compute the minimal span containing both self and other