Struct quaint::visitor::Postgres

pub struct Postgres<'a> { /* private fields */ }

A visitor to generate queries for the PostgreSQL database.

The returned parameter values implement the ToSql trait from postgres and can be used directly with the database.

Trait Implementations

impl<'a> Visitor<'a> for Postgres<'a>

fn visit_column(&mut self, column: Column<'a>) -> Result

A database column identifier

const C_BACKTICK_OPEN: &'static str = "\""

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

const C_BACKTICK_CLOSE: &'static str = "\""

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

const C_WILDCARD: &'static str = "%"

Wildcard character to be used in LIKE queries.

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.

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

Write to the query.

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.

fn parameter_substitution(&mut self) -> Result

What to use to substitute a parameter in the query.

fn visit_parameterized_enum( &mut self, variant: EnumVariant<'a>, name: Option<EnumName<'a>> ) -> Result

fn visit_parameterized_enum_array( &mut self, variants: Vec<EnumVariant<'a>>, name: Option<EnumName<'a>> ) -> Result

fn visit_limit_and_offset( &mut self, limit: Option<Value<'a>>, offset: Option<Value<'a>> ) -> Result

The LIMIT and OFFSET statement in the query

fn visit_raw_value(&mut self, value: Value<'a>) -> Result

Visit a non-parameterized value.

fn visit_insert(&mut self, insert: Insert<'a>) -> Result

A walk through an INSERT statement

fn visit_aggregate_to_string(&mut self, value: Expression<'a>) -> Result

What to use to substitute a parameter in the query.

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_json_extract(&mut self, json_extract: JsonExtract<'a>) -> Result

fn visit_json_unquote(&mut self, json_unquote: JsonUnquote<'a>) -> Result

fn visit_json_array_contains( &mut self, left: Expression<'a>, right: Expression<'a>, not: bool ) -> 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_type_equals( &mut self, left: Expression<'a>, json_type: JsonType<'a>, not: bool ) -> Result

fn visit_json_array_agg(&mut self, array_agg: JsonArrayAgg<'a>) -> Result

fn visit_json_build_object(&mut self, build_obj: JsonBuildObject<'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

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_ordering(&mut self, ordering: Ordering<'a>) -> Result

A visit in the ORDER BY section of the query

fn visit_concat(&mut self, concat: Concat<'a>) -> Result

fn visit_min(&mut self, min: Minimum<'a>) -> Result

fn visit_max(&mut self, max: Maximum<'a>) -> Result

fn visit_delete(&mut self, delete: Delete<'a>) -> Result

A walk through an DELETE statement

fn compatibility_modifications(&self, query: Query<'a>) -> Query<'a>

A point to modify an incoming query to make it compatible with the underlying database.

fn surround_with<F>(&mut self, begin: &str, end: &str, f: F) -> Resultwhere 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

A visit to a value we parameterize

fn visit_joins(&mut self, joins: Vec<Join<'a>>) -> Result

The join statements in the query

fn visit_join_data(&mut self, data: JoinData<'a>) -> Result

fn visit_select(&mut self, select: Select<'a>) -> Result

A walk through a SELECT statement

fn visit_update(&mut self, update: Update<'a>) -> Result

A walk through an UPDATE statement

fn visit_upsert(&mut self, update: Update<'a>) -> Result

fn visit_update_set(&mut self, update: Update<'a>) -> Result

fn delimited_identifiers(&mut self, parts: &[&str]) -> Result

A helper for delimiting an identifier, surrounding every part with C_BACKTICK and delimiting the values with a .

fn surround_with_backticks(&mut self, part: &str) -> Result

A helper for delimiting a part of an identifier, surrounding it with C_BACKTICK

fn visit_merge(&mut self, _merge: Merge<'a>) -> Result

Visit an SQL MERGE query.

fn visit_query(&mut self, query: Query<'a>) -> Result

A walk through a complete Query statement

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

A walk through a union of SELECT statements

fn visit_columns(&mut self, columns: Vec<Expression<'a>>) -> Result

The selected columns

fn visit_operation(&mut self, op: SqlOp<'a>) -> Result

fn visit_expression(&mut self, value: Expression<'a>) -> Result

A visit to a value used in an expression

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

A database table identifier

fn visit_row(&mut self, row: Row<'a>) -> Result

A row of data used as an expression

fn visit_conditions(&mut self, tree: ConditionTree<'a>) -> Result

A walk through the query conditions

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_compare(&mut self, compare: Compare<'a>) -> Result

A comparison expression

fn visit_grouping(&mut self, grouping: Grouping<'a>) -> Result

A visit in the GROUP BY section of the query

fn visit_average(&mut self, avg: Average<'a>) -> Result

fn visit_function(&mut self, fun: Function<'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