logo

Trait sea_query::backend::QueryBuilder

source · [−]
pub trait QueryBuilder: QuotedBuilder + EscapeBuilder {

Show 45 methods    fn prepare_query_statement(
        &self,
        query: &SubQueryStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    );

    fn placeholder(&self) -> (&str, bool) { ... }
    fn values_list_tuple_prefix(&self) -> &str { ... }
    fn prepare_insert_statement(
        &self,
        insert: &InsertStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_select_statement(
        &self,
        select: &SelectStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_update_statement(
        &self,
        update: &UpdateStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_delete_statement(
        &self,
        delete: &DeleteStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_simple_expr(
        &self,
        simple_expr: &SimpleExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_simple_expr_common(
        &self,
        simple_expr: &SimpleExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_case_statement(
        &self,
        stmts: &CaseStatement,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_select_distinct(
        &self,
        select_distinct: &SelectDistinct,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_select_lock(
        &self,
        lock: &LockClause,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_select_expr(
        &self,
        select_expr: &SelectExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_join_expr(
        &self,
        join_expr: &JoinExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_join_table_ref(
        &self,
        join_expr: &JoinExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_table_ref(
        &self,
        table_ref: &TableRef,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_table_ref_common(
        &self,
        table_ref: &TableRef,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_column_ref(&self, column_ref: &ColumnRef, sql: &mut SqlWriter) { ... }
    fn prepare_un_oper(
        &self,
        un_oper: &UnOper,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_bin_oper_common(
        &self,
        bin_oper: &BinOper,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_bin_oper(
        &self,
        bin_oper: &BinOper,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_logical_chain_oper(
        &self,
        log_chain_oper: &LogicalChainOper,
        i: usize,
        length: usize,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_function_common(
        &self,
        function: &Function,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_query(
        &self,
        query: &WithQuery,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_clause(
        &self,
        with_clause: &WithClause,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_clause_recursive_options(
        &self,
        with_clause: &WithClause,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_clause_common_tables(
        &self,
        with_clause: &WithClause,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_query_clause_common_table(
        &self,
        cte: &CommonTableExpression,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_with_query_clause_materialization(
        &self,
        cte: &CommonTableExpression,
        sql: &mut SqlWriter
    ) { ... }
    fn prepare_with_clause_start(
        &self,
        with_clause: &WithClause,
        sql: &mut SqlWriter
    ) { ... }
    fn prepare_insert(&self, replace: bool, sql: &mut SqlWriter) { ... }
    fn prepare_function(
        &self,
        function: &Function,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_join_type(
        &self,
        join_type: &JoinType,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_order_expr(
        &self,
        order_expr: &OrderExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_join_on(
        &self,
        join_on: &JoinOn,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_order(
        &self,
        order_expr: &OrderExpr,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_field_order(
        &self,
        order_expr: &OrderExpr,
        values: &Values,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_value(
        &self,
        value: &Value,
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_constant(&self, value: &Value, sql: &mut SqlWriter) { ... }
    fn prepare_values_list(
        &self,
        value_tuples: &[ValueTuple],
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_tuple(
        &self,
        exprs: &[SimpleExpr],
        sql: &mut SqlWriter,
        collector: &mut dyn FnMut(Value)
    ) { ... }
    fn prepare_keyword(
        &self,
        keyword: &Keyword,
        sql: &mut SqlWriter,
        _collector: &mut dyn FnMut(Value)
    ) { ... }
    fn value_to_string(&self, v: &Value) -> String { ... }
    fn insert_default_keyword(&self) -> &str { ... }
    fn insert_default_values(&self, num_rows: u32, sql: &mut SqlWriter) { ... }

}

Required Methods

Translate QueryStatement into SQL statement.

Provided Methods

The type of placeholder the builder uses for values, and whether it is numbered.

Prefix for tuples in VALUES list (e.g. ROW for Mysql)

Translate InsertStatement into SQL statement.

Translate SelectStatement into SQL statement.

Translate UpdateStatement into SQL statement.

Translate DeleteStatement into SQL statement.

Translate SimpleExpr into SQL statement.

Translate CaseStatement into SQL statement.

Translate SelectDistinct into SQL statement.

Translate LockType into SQL statement.

Translate SelectExpr into SQL statement.

Translate JoinExpr into SQL statement.

Translate TableRef into SQL statement.

Translate UnOper into SQL statement.

Translate BinOper into SQL statement.

Translate LogicalChainOper into SQL statement.

Translate Function into SQL statement.

Translate JoinType into SQL statement.

Translate OrderExpr into SQL statement.

Translate JoinOn into SQL statement.

Translate Order into SQL statement.

Translate Order::Field into SQL statement

Write Value into SQL statement as parameter.

Write Value inline.

Translate a &[ValueTuple] into a VALUES list.

Translate SimpleExpr::Tuple into SQL statement.

Translate Keyword into SQL statement.

Convert a SQL value into syntax-specific string

The keywords for insert default row.

Write insert default rows expression.

Implementors