Trait quaint::visitor::Visitor

source ·

pub trait Visitor<'a> {
    const C_BACKTICK_OPEN: &'static str;
    const C_BACKTICK_CLOSE: &'static str;
    const C_WILDCARD: &'static str;
Show 61 methods
    // Required methods
    fn build<Q>(query: Q) -> Result<(String, Vec<Value<'a>>)>
       where Q: Into<Query<'a>>;
    fn write<D: Display>(&mut self, s: D) -> Result;
    fn add_parameter(&mut self, value: Value<'a>);
    fn visit_limit_and_offset(
        &mut self,
        limit: Option<Value<'a>>,
        offset: Option<Value<'a>>
    ) -> Result;
    fn visit_ordering(&mut self, ordering: Ordering<'a>) -> Result;
    fn visit_insert(&mut self, insert: Insert<'a>) -> Result;
    fn parameter_substitution(&mut self) -> Result;
    fn visit_aggregate_to_string(&mut self, value: Expression<'a>) -> Result;
    fn visit_raw_value(&mut self, value: Value<'a>) -> Result;
    fn visit_json_extract(&mut self, json_extract: JsonExtract<'a>) -> Result;
    fn visit_json_extract_last_array_item(
        &mut self,
        extract: JsonExtractLastArrayElem<'a>
    ) -> Result;
    fn visit_json_extract_first_array_item(
        &mut self,
        extract: JsonExtractFirstArrayElem<'a>
    ) -> Result;
    fn visit_json_array_contains(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>,
        not: bool
    ) -> Result;
    fn visit_json_type_equals(
        &mut self,
        left: Expression<'a>,
        right: JsonType<'a>,
        not: bool
    ) -> Result;
    fn visit_json_unquote(&mut self, json_unquote: JsonUnquote<'a>) -> Result;
    fn visit_text_search(&mut self, text_search: TextSearch<'a>) -> Result;
    fn visit_matches(
        &mut self,
        left: Expression<'a>,
        right: Cow<'a, str>,
        not: bool
    ) -> Result;
    fn visit_text_search_relevance(
        &mut self,
        text_search_relevance: TextSearchRelevance<'a>
    ) -> Result;

    // Provided methods
    fn compatibility_modifications(&self, query: Query<'a>) -> Query<'a> { ... }
    fn surround_with<F>(&mut self, begin: &str, end: &str, f: F) -> Result
       where F: FnOnce(&mut Self) -> Result { ... }
    fn columns_to_bracket_list(&mut self, columns: Vec<Column<'a>>) -> Result { ... }
    fn visit_parameterized(&mut self, value: Value<'a>) -> Result { ... }
    fn visit_joins(&mut self, joins: Vec<Join<'a>>) -> Result { ... }
    fn visit_join_data(&mut self, data: JoinData<'a>) -> Result { ... }
    fn visit_select(&mut self, select: Select<'a>) -> Result { ... }
    fn visit_update(&mut self, update: Update<'a>) -> Result { ... }
    fn visit_upsert(&mut self, update: Update<'a>) -> Result { ... }
    fn visit_update_set(&mut self, update: Update<'a>) -> Result { ... }
    fn visit_delete(&mut self, delete: Delete<'a>) -> Result { ... }
    fn delimited_identifiers(&mut self, parts: &[&str]) -> Result { ... }
    fn surround_with_backticks(&mut self, part: &str) -> Result { ... }
    fn visit_merge(&mut self, _merge: Merge<'a>) -> Result { ... }
    fn visit_query(&mut self, query: Query<'a>) -> Result { ... }
    fn visit_sub_selection(&mut self, query: SelectQuery<'a>) -> Result { ... }
    fn visit_selection(&mut self, query: SelectQuery<'a>) -> Result { ... }
    fn visit_union(&mut self, ua: Union<'a>) -> Result { ... }
    fn visit_columns(&mut self, columns: Vec<Expression<'a>>) -> Result { ... }
    fn visit_operation(&mut self, op: SqlOp<'a>) -> Result { ... }
    fn visit_expression(&mut self, value: Expression<'a>) -> Result { ... }
    fn visit_multiple_tuple_comparison(
        &mut self,
        left: Row<'a>,
        right: Values<'a>,
        negate: bool
    ) -> Result { ... }
    fn visit_values(&mut self, values: Values<'a>) -> Result { ... }
    fn visit_table(&mut self, table: Table<'a>, include_alias: bool) -> Result { ... }
    fn visit_column(&mut self, column: Column<'a>) -> Result { ... }
    fn visit_row(&mut self, row: Row<'a>) -> Result { ... }
    fn visit_conditions(&mut self, tree: ConditionTree<'a>) -> Result { ... }
    fn visit_greater_than(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_greater_than_or_equals(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_less_than(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_less_than_or_equals(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_like(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_not_like(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_compare(&mut self, compare: Compare<'a>) -> Result { ... }
    fn visit_equals(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_not_equals(
        &mut self,
        left: Expression<'a>,
        right: Expression<'a>
    ) -> Result { ... }
    fn visit_grouping(&mut self, grouping: Grouping<'a>) -> Result { ... }
    fn visit_average(&mut self, avg: Average<'a>) -> Result { ... }
    fn visit_function(&mut self, fun: Function<'a>) -> Result { ... }
    fn visit_concat(&mut self, concat: Concat<'a>) -> Result { ... }
    fn visit_partitioning(&mut self, over: Over<'a>) -> Result { ... }
    fn visit_cte(&mut self, cte: CommonTableExpression<'a>) -> Result { ... }
    fn visit_comment(&mut self, comment: Cow<'a, str>) -> Result { ... }
}

Expand description

A function travelling through the query AST, building the final query string and gathering parameters sent to the database together with the query.

Required Associated Constants§

source

const C_BACKTICK_OPEN: &'static str

Opening backtick character to surround identifiers, such as column and table names.

source

const C_BACKTICK_CLOSE: &'static str

Closing backtick character to surround identifiers, such as column and table names.

source

const C_WILDCARD: &'static str

Wildcard character to be used in LIKE queries.

Required Methods§

source

fn build<Q>(query: Q) -> Result<(String, Vec<Value<'a>>)>where Q: Into<Query<'a>>,

Convert the given Query to an SQL string and a vector of parameters. When certain parameters are replaced with the C_PARAM character in the query, the vector should contain the parameter value in the right position.

The point of entry for visiting query ASTs.

let query = Select::from_table("cats");
let (sqlite, _) = Sqlite::build(query.clone())?;
let (psql, _) = Postgres::build(query.clone())?;
let (mysql, _) = Mysql::build(query.clone())?;
let (mssql, _) = Mssql::build(query.clone())?;

assert_eq!("SELECT `cats`.* FROM `cats`", sqlite);
assert_eq!("SELECT \"cats\".* FROM \"cats\"", psql);
assert_eq!("SELECT `cats`.* FROM `cats`", mysql);
assert_eq!("SELECT [cats].* FROM [cats]", mssql);

source

fn write<D: Display>(&mut self, s: D) -> Result

Write to the query.

source

fn add_parameter(&mut self, value: Value<'a>)

When called, the visitor decided to not render the parameter into the query, replacing it with the C_PARAM, calling add_parameter with the replaced value.

source