Struct Select 

pub struct Select<'a> {
    pub distinct: Option<()>,
    pub cols: Vec<&'a str>,
    pub joins: Vec<JoinInfo<'a>>,
    pub whereas: Vec<WhereInfo<'a>>,
    pub groups: Vec<&'a str>,
    pub havings: Vec<HavingInfo<'a>>,
    pub orders: Vec<Order<'a>>,
    pub limit: Option<u32>,
    pub offset: Option<u32>,
    /* private fields */
}

Fields

distinct: Option<()>

cols: Vec<&'a str>

joins: Vec<JoinInfo<'a>>

whereas: Vec<WhereInfo<'a>>

groups: Vec<&'a str>

havings: Vec<HavingInfo<'a>>

orders: Vec<Order<'a>>

limit: Option<u32>

offset: Option<u32>

Implementations

impl<'a> Select<'a>

pub fn any() -> Self

pub fn cols(cols: Vec<&'a str>) -> Self

pub fn col(self, col: &'a str) -> Self

pub fn distinct(self) -> Self

pub fn from(self, table: &'a str) -> Self

pub fn from_subquery(self, table: impl Into<Select<'a>>) -> Self

pub fn inner_join(self, table: &'a str) -> Join<'a>

pub fn left_join(self, table: &'a str) -> Join<'a>

pub fn right_join(self, table: &'a str) -> Join<'a>

pub fn outer_join(self, table: &'a str) -> Join<'a>

pub fn where_by(self, left: &'a str, op: Op<'a>) -> Where<'a>

pub fn group_by(self, cols: Vec<&'a str>) -> Self

pub fn order_by(self, col: &'a str) -> Self

pub fn order_by_desc(self, col: &'a str) -> Self

pub fn having(self, left: &'a str, op: Op<'a>) -> Having<'a>

pub fn limit(self, num: u32) -> Self

pub fn offset(self, num: u32) -> Self

pub fn build(&self) -> String

Trait Implementations

impl<'a> Display for Select<'a>

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

Formats the value using the given formatter.

impl<'a> Into<Select<'a>> for Where<'a>

fn into(self) -> Select<'a>

Converts this type into the (usually inferred) input type.

impl<'a> Into<Value<'a>> for Select<'a>

fn into(self) -> Value<'a>

Converts this type into the (usually inferred) input type.

impl<'a> WhereOwner<'a> for Select<'a>

fn set_seperator(&mut self, index: usize, sep: CondSep)

fn push(&mut self, where_info: WhereInfo<'a>)

fn len(&self) -> usize