Struct SqlGenerator

pub(crate) struct SqlGenerator<'a, R: Rng> {
    tables: Vec<Table>,
    rng: &'a mut R,
    relation_id: u32,
    bound_relations: Vec<Table>,
    bound_columns: Vec<Column>,
    is_mview: bool,
    recursion_weight: f64,
}

Fields

tables: Vec<Table>

rng: &'a mut R

relation_id: u32

Relation ID used to generate table names and aliases

bound_relations: Vec<Table>

Relations bound in generated query. We might not read from all tables.

bound_columns: Vec<Column>

Columns bound in generated query. May not contain all columns from Self::bound_relations. e.g. GROUP BY clause will constrain bound_columns.

is_mview: bool

SqlGenerator can be used in two execution modes:

1. Generating Query Statements.
2. Generating queries for CREATE MATERIALIZED VIEW. Under this mode certain restrictions and workarounds are applied for unsupported stream executors.

recursion_weight: f64

Implementations

impl<R: Rng> SqlGenerator<'_, R>

pub fn gen_agg(&mut self, ret: &DataType) -> Expr

fn make_agg_expr( &mut self, func: PbAggKind, exprs: &[Expr], distinct: bool, filter: Option<Box<Expr>>, order_by: Vec<OrderByExpr>, ) -> Option<Expr>

Generates aggregate expressions. For internal / unsupported aggregators, we return None.

impl<R: Rng> SqlGenerator<'_, R>

pub(crate) fn gen_explicit_cast( &mut self, ret: &DataType, context: SqlGeneratorContext, ) -> Expr

fn gen_explicit_cast_inner( &mut self, ret: &DataType, context: SqlGeneratorContext, ) -> Option<Expr>

Generate casts from a cast map. TODO: Assign casts have to be tested via INSERT.

pub(crate) fn gen_implicit_cast( &mut self, ret: &DataType, context: SqlGeneratorContext, ) -> Expr

NOTE: This can result in ambiguous expressions. Should only be used in unambiguous context.

impl<R: Rng> SqlGenerator<'_, R>

pub(crate) fn gen_expr( &mut self, typ: &DataType, context: SqlGeneratorContext, ) -> Expr

In generating expression, there are two execution modes:

1. Can have Aggregate expressions (can_agg = true) We can have aggregate of all bound columns (those present in GROUP BY and otherwise). Not all GROUP BY columns need to be aggregated.
2. Can’t have Aggregate expressions (can_agg = false) Only columns present in GROUP BY can be selected.

inside_agg indicates if we are calling gen_expr inside an aggregate.

fn gen_data_type(&mut self) -> DataType

fn gen_data_type_inner(&mut self, depth: usize) -> DataType

fn gen_list_data_type(&mut self, depth: usize) -> DataType

fn gen_struct_data_type(&mut self, depth: usize) -> DataType

pub(crate) fn gen_arbitrary_expr( &mut self, context: SqlGeneratorContext, ) -> (DataType, Expr)

Generates an arbitrary expression, but biased towards datatypes present in bound columns.

fn gen_col(&mut self, typ: &DataType, context: SqlGeneratorContext) -> Expr

pub(crate) fn gen_n_exprs_with_type( &mut self, n: usize, ret: &DataType, context: SqlGeneratorContext, ) -> Vec<Expr>

Generates n expressions of type ret.

fn gen_exists(&mut self, ret: &DataType, context: SqlGeneratorContext) -> Expr

pub(crate) fn gen_order_by(&mut self) -> Vec<OrderByExpr>

Generate ORDER BY expressions by choosing from available bound columns.

pub(crate) fn gen_order_by_within(&mut self, exprs: &[Expr]) -> Vec<OrderByExpr>

Generate ORDER BY expressions by choosing from given expressions.

impl<'a, R: Rng + 'a> SqlGenerator<'a, R>

pub(crate) fn generate_insert_statement( &mut self, table: &Table, row_count: usize, ) -> Statement

pub(crate) fn generate_update_statements( &mut self, tables: &[Table], inserts: &[Statement], ) -> Result<Vec<Statement>>

pub(crate) fn generate_update_statements_inner( &mut self, table: &Table, values: &[Vec<Expr>], pk_indices: &[usize], ) -> Vec<Statement>

fn row_to_update_statement( table: &Table, pk_indices: &[usize], value_indices: &[usize], row: &[Expr], ) -> Statement

fn create_selection_expr( table: &Table, selected_indices: &[usize], row: &[Expr], ) -> Expr

fn generate_delete_statements( &mut self, table: &Table, values: &[Vec<Expr>], ) -> Vec<Statement>

fn extract_insert_values(source: &Query) -> Result<&[Vec<Expr>]>

fn gen_values( &mut self, data_types: &[DataType], row_count: usize, ) -> Vec<Vec<Expr>>

fn gen_row(&mut self, data_types: &[DataType]) -> Vec<Expr>

impl<R: Rng> SqlGenerator<'_, R>

pub fn gen_func(&mut self, ret: &DataType, context: SqlGeneratorContext) -> Expr

fn gen_special_func( &mut self, ret: &DataType, context: SqlGeneratorContext, ) -> Expr

Generates functions with special properties, e.g. CASE, COALESCE, CONCAT, CONCAT_WS, OVERLAY. These require custom logic for arguments. For instance, OVERLAY requires a positive length argument, and CONCAT and CONCAT_WS require variable number of arguments.

fn gen_overlay(&mut self, context: SqlGeneratorContext) -> Expr

We do custom generation for the OVERLAY function call. See: [https://github.com/risingwavelabs/risingwave/issues/10695] for rationale.

fn gen_case(&mut self, ret: &DataType, context: SqlGeneratorContext) -> Expr

fn gen_coalesce(&mut self, ret: &DataType, context: SqlGeneratorContext) -> Expr

fn gen_concat(&mut self, context: SqlGeneratorContext) -> Expr

fn gen_concat_ws(&mut self, context: SqlGeneratorContext) -> Expr

fn gen_concat_args(&mut self, context: SqlGeneratorContext) -> Vec<Expr>

fn gen_decode(&mut self, context: SqlGeneratorContext) -> Expr

fn gen_fixed_func( &mut self, ret: &DataType, context: SqlGeneratorContext, ) -> Expr

impl<R: Rng> SqlGenerator<'_, R>

Generators

pub(crate) fn gen_query(&mut self) -> (Query, Vec<Column>)

Generates query expression and returns its query schema as well.

fn gen_complex_query(&mut self) -> (Query, Vec<Column>)

Generates a complex query which may recurse. e.g. through gen_with or other generated parts of the query.

fn gen_simple_query(&mut self) -> (Query, Vec<Column>)

This query can still recurse, but it is “simpler” does not have “with” clause, “order by”. Which makes it more unlikely to recurse.

pub(crate) fn gen_single_item_query(&mut self) -> (Query, Column)

Generates a query with a single SELECT item. e.g. SELECT v from t; Returns the query and the SELECT column alias.

pub(crate) fn gen_local_query(&mut self) -> (Query, Vec<Column>)

Generates a query with local context. Used by WITH, Table Subquery in Relation

pub(crate) fn gen_correlated_query(&mut self) -> (Query, Vec<Column>)

Generates a query with correlated context to ensure proper recursion.

fn gen_with(&mut self) -> (Option<With>, Vec<Table>)

fn gen_with_inner(&mut self) -> (With, Vec<Table>)

fn gen_set_expr( &mut self, with_tables: Vec<Table>, num_select_items: usize, ) -> (SetExpr, Vec<Column>)

fn gen_limit(&mut self, has_order_by: bool) -> Option<Expr>

fn gen_select_stmt( &mut self, with_tables: Vec<Table>, num_select_items: usize, ) -> (Select, Vec<Column>)

fn gen_select_list( &mut self, num_select_items: usize, ) -> (Vec<SelectItem>, Vec<Column>)

fn gen_select_item( &mut self, i: usize, context: SqlGeneratorContext, ) -> (SelectItem, Column)

fn gen_from(&mut self, with_tables: Vec<Table>) -> Vec<TableWithJoins>

fn gen_where(&mut self) -> Option<Expr>

fn gen_group_by(&mut self) -> Vec<Expr>

GROUP BY will constrain the generated columns.

fn gen_grouping_sets(&mut self) -> Vec<Expr>

GROUPING SETS will constrain the generated columns.

fn gen_random_bound_columns(&mut self) -> Vec<Column>

fn gen_having(&mut self, have_group_by: bool) -> Option<Expr>

impl<R: Rng> SqlGenerator<'_, R>

pub(crate) fn gen_from_relation(&mut self) -> (TableWithJoins, Vec<Table>)

A relation specified in the FROM clause.

fn gen_no_join(&mut self) -> (TableWithJoins, Vec<Table>)

fn gen_simple_table_factor(&mut self) -> (TableFactor, Table)

fn gen_table_factor(&mut self) -> (TableFactor, Table)

fn gen_table_factor_inner(&mut self) -> (TableFactor, Table)

Generates a table factor, and provides bound columns. Generated column names should be qualified by table name.

fn gen_equi_join_columns( &mut self, left_columns: Vec<Column>, right_columns: Vec<Column>, ) -> Vec<(Column, Column)>

fn gen_bool_with_tables(&mut self, tables: Vec<Table>) -> Expr

fn gen_single_equi_join_expr( &mut self, left_columns: Vec<Column>, right_columns: Vec<Column>, ) -> Option<(Expr, Vec<(Column, Column)>)>

fn gen_non_equi_expr( &mut self, available_join_on_columns: Vec<(Column, Column)>, ) -> Expr

fn gen_more_equi_join_exprs( &mut self, available_join_on_columns: Vec<(Column, Column)>, ) -> Expr

fn gen_arbitrary_bool( &mut self, left_table: Table, right_table: Table, ) -> Option<Expr>

fn gen_join_on_expr( &mut self, left_columns: Vec<Column>, left_table: Table, right_columns: Vec<Column>, right_table: Table, ) -> Option<Expr>

Generates the ON clause in t JOIN t2 ON ... It will generate at least one equi join condition This will reduce chance of nested loop join from being generated.

fn gen_join_constraint( &mut self, left_columns: Vec<Column>, left_table: Table, right_columns: Vec<Column>, right_table: Table, ) -> Option<JoinConstraint>

fn gen_join_operator( &mut self, left_columns: Vec<Column>, left_table: Table, right_columns: Vec<Column>, right_table: Table, ) -> Option<JoinOperator>

Generates t1 JOIN t2 ON …

fn gen_simple_join_clause(&mut self) -> Option<(TableWithJoins, Vec<Table>)>

Generates t1 JOIN t2 ON …

fn gen_more_joins(&mut self) -> (TableWithJoins, Vec<Table>)

Generates three-way join.

fn gen_table_subquery(&mut self) -> (TableFactor, Table)

impl<R: Rng> SqlGenerator<'_, R>

pub(super) fn gen_range_scalar( &mut self, typ: &DataType, start: i64, end: i64, ) -> Option<Expr>

Generates integer scalar expression. Bound: [start, end). Type: DataType.

pub(super) fn gen_simple_scalar(&mut self, typ: &DataType) -> Expr

fn gen_simple_scalar_list(&mut self, ty: &DataType, n: usize) -> Vec<Expr>

Generates a list of n simple scalar values of a specific type.

fn gen_int(&mut self, min: i64, max: i64) -> String

fn gen_float(&mut self) -> String

fn gen_temporal_scalar(&mut self, typ: &DataType) -> String

impl<R: Rng> SqlGenerator<'_, R>

pub(crate) fn gen_time_window_func(&mut self) -> (TableFactor, Table)

Generates time window functions.

fn gen_tumble(&mut self) -> (TableFactor, Table)

Generates TUMBLE. TUMBLE(data: TABLE, timecol: COLUMN, size: INTERVAL, offset?: INTERVAL)

fn gen_hop(&mut self) -> (TableFactor, Table)

Generates HOP. HOP(data: TABLE, timecol: COLUMN, slide: INTERVAL, size: INTERVAL, offset?: INTERVAL)

fn gen_secs(&mut self) -> u64

fn secs_to_interval_expr(i: u64) -> Expr

fn gen_slide(&mut self) -> (u64, Expr)

fn gen_size(&mut self, slide_secs: u64) -> Expr

Size must be divisible by slide. i.e. size_secs = k * slide_secs. k cannot be too large, to avoid overflow.

impl<R: Rng> SqlGenerator<'_, R>

Context utils

pub(crate) fn add_relations_to_context(&mut self, tables: Vec<Table>)

pub(crate) fn new_local_context(&mut self) -> (Vec<Column>, Vec<Table>)

pub(crate) fn restore_context( &mut self, (old_cols, old_rels): (Vec<Column>, Vec<Table>), )

pub(crate) fn clone_local_context(&mut self) -> (Vec<Column>, Vec<Table>)

impl<R: Rng> SqlGenerator<'_, R>

Gen utils

pub(crate) fn gen_table_name_with_prefix(&mut self, prefix: &str) -> String

fn gen_relation_id(&mut self) -> u32

pub(crate) fn gen_table_alias_with_prefix(&mut self, prefix: &str) -> TableAlias

impl<'a, R: Rng> SqlGenerator<'a, R>

Generators

pub(crate) fn new(rng: &'a mut R, tables: Vec<Table>) -> Self

pub(crate) fn new_for_mview(rng: &'a mut R, tables: Vec<Table>) -> Self

pub(crate) fn gen_batch_query_stmt(&mut self) -> Statement

pub(crate) fn gen_mview_stmt(&mut self, name: &str) -> (Statement, Table)

fn flip_coin(&mut self) -> bool

50/50 chance to be true/false.

pub(crate) fn can_recurse(&mut self) -> bool

Provide recursion bounds.