Struct SelectQuery 

pub struct SelectQuery { /* private fields */ }

SELECT query builder

Implementations

impl SelectQuery

pub fn new() -> SelectQuery

Create an empty SELECT query

pub fn distinct(self) -> SelectQuery

Set DISTINCT

pub fn column(self, name: &str) -> SelectQuery

Add a column

pub fn columns(self, names: &[&str]) -> SelectQuery

Add multiple columns

pub fn all_columns(self) -> SelectQuery

Add a * column

pub fn from(self, table: &str) -> SelectQuery

Set FROM table

pub fn from_subquery(self, subquery_sql: &str, alias: &str) -> SelectQuery

Set FROM subquery: FROM (<subquery_sql>) AS <alias>

Mutually exclusive with from; later caller overrides earlier. The subquery SQL is constructed by the caller (may be generated by another SelectQuery::build), and the alias is escaped via dialect.quote() to prevent identifier escape.

Example

use sz_orm_core::DbType;
use sz_orm_query_builder::Query;

let inner = Query::select()
    .column("id")
    .column("amount")
    .from("orders")
    .build(DbType::MySQL);
let sql = Query::select()
    .column("id")
    .from_subquery(&inner, "t")
    .build(DbType::MySQL);
assert!(sql.contains("FROM (SELECT `id`, `amount` FROM `orders`) AS `t`"));

pub fn inner_join(self, table: &str, on: &str) -> SelectQuery

Add an INNER JOIN

Security (gate 9 fix)

The table name is escaped via quote_ident(). The on condition is an expression; the caller should ensure it is not constructed with malicious input.

pub fn left_join(self, table: &str, on: &str) -> SelectQuery

Add a LEFT JOIN

Security (gate 9 fix)

Same as inner_join; the table name is escaped via quote_ident().

pub fn right_join(self, table: &str, on: &str) -> SelectQuery

Add a RIGHT JOIN

Security (gate 9 fix)

Same as inner_join; the table name is escaped via quote_ident().

pub fn inner_join_on( self, table: &str, left_col: &str, right_col: &str, ) -> SelectQuery

Add an INNER JOIN with a column-to-column equality ON condition (left_col = right_col)

Security

Column names are escaped per dialect via quote_column_dialect, preventing identifier escape. No parameter values; pure identifier join, the most common and safest JOIN form.

pub fn left_join_on( self, table: &str, left_col: &str, right_col: &str, ) -> SelectQuery

Add a LEFT JOIN with a column-to-column equality ON condition

pub fn right_join_on( self, table: &str, left_col: &str, right_col: &str, ) -> SelectQuery

Add a RIGHT JOIN with a column-to-column equality ON condition

pub fn inner_join_param( self, table: &str, left_col: &str, op_expr: &str, value: Value, ) -> SelectQuery

Add an INNER JOIN with a parameterized expression ON condition (left_col op ?)

Parameters

• table: JOIN table name (supports alias orders o)
• left_col: left column name (already escaped)
• op_expr: operator + placeholder part (e.g., = ?, > ?, IN (?, ?))
• value: single parameter value

pub fn left_join_param( self, table: &str, left_col: &str, op_expr: &str, value: Value, ) -> SelectQuery

Add a LEFT JOIN with a parameterized expression ON condition

pub fn right_join_param( self, table: &str, left_col: &str, op_expr: &str, value: Value, ) -> SelectQuery

Add a RIGHT JOIN with a parameterized expression ON condition

pub fn where_clause(self, condition: &str) -> SelectQuery

Add a WHERE condition (AND joined)

Security (v0.2.2 fix C-6)

Calls check_where_injection to detect high-risk patterns (semicolon + SQL keyword, line comments, block comments). Complex WHERE conditions should use the parameterized query API to avoid direct string concatenation.

pub fn where_eq(self, column: &str, value: Value) -> SelectQuery

Add a column = ? AND condition

pub fn where_ne(self, column: &str, value: Value) -> SelectQuery

Add a column <> ? AND condition

pub fn where_gt(self, column: &str, value: Value) -> SelectQuery

Add a column > ? AND condition

pub fn where_ge(self, column: &str, value: Value) -> SelectQuery

Add a column >= ? AND condition

pub fn where_lt(self, column: &str, value: Value) -> SelectQuery

Add a column < ? AND condition

pub fn where_le(self, column: &str, value: Value) -> SelectQuery

Add a column <= ? AND condition

pub fn where_like(self, column: &str, pattern: Value) -> SelectQuery

Add a column LIKE ? AND condition

pub fn where_in(self, column: &str, values: Vec<Value>) -> SelectQuery

Add a column IN (?, ?, ...) AND condition

An empty list produces 1 = 0 (always false), avoiding an invalid IN ().

pub fn where_not_in(self, column: &str, values: Vec<Value>) -> SelectQuery

Add a column NOT IN (?, ?, ...) AND condition

An empty list produces 1 = 1 (always true), avoiding an invalid NOT IN ().

pub fn where_between(self, column: &str, low: Value, high: Value) -> SelectQuery

Add a column BETWEEN ? AND ? AND condition

pub fn where_null(self, column: &str) -> SelectQuery

Add a column IS NULL AND condition

pub fn where_not_null(self, column: &str) -> SelectQuery

Add a column IS NOT NULL AND condition

pub fn or_where_eq(self, column: &str, value: Value) -> SelectQuery

Add a column = ? OR condition

pub fn or_where_ne(self, column: &str, value: Value) -> SelectQuery

Add a column <> ? OR condition

pub fn or_where_gt(self, column: &str, value: Value) -> SelectQuery

Add a column > ? OR condition

pub fn or_where_ge(self, column: &str, value: Value) -> SelectQuery

Add a column >= ? OR condition

pub fn or_where_lt(self, column: &str, value: Value) -> SelectQuery

Add a column < ? OR condition

pub fn or_where_le(self, column: &str, value: Value) -> SelectQuery

Add a column <= ? OR condition

pub fn or_where_like(self, column: &str, pattern: Value) -> SelectQuery

Add a column LIKE ? OR condition

pub fn or_where_in(self, column: &str, values: Vec<Value>) -> SelectQuery

Add a column IN (?, ?, ...) OR condition

pub fn or_where_between( self, column: &str, low: Value, high: Value, ) -> SelectQuery

Add a column BETWEEN ? AND ? OR condition

pub fn or_where_null(self, column: &str) -> SelectQuery

Add a column IS NULL OR condition

pub fn or_where_not_null(self, column: &str) -> SelectQuery

Add a column IS NOT NULL OR condition

pub fn group_by(self, column: &str) -> SelectQuery

Add GROUP BY

pub fn having(self, condition: &str) -> SelectQuery

Add HAVING

pub fn order_by(self, column: &str, asc: bool) -> SelectQuery

Add ORDER BY

Parameters

• column: column name
• asc: true=ASC, false=DESC

pub fn limit(self, n: u64) -> SelectQuery

Set LIMIT

pub fn offset(self, n: u64) -> SelectQuery

Set OFFSET

pub fn paginate(self, page: u64, size: u64) -> SelectQuery

Generate pagination (sets both LIMIT and OFFSET)

Parameters

• page: page number (1-based)
• size: page size

pub fn with_cte(self, name: &str, subquery: &str) -> SelectQuery

Add a CTE (Common Table Expression / WITH clause).

Generates SQL of the form WITH name AS (subquery) SELECT ....

Parameters

• name: CTE name
• subquery: subquery SQL (a complete SELECT statement)

pub fn with_recursive_cte(self, name: &str, subquery: &str) -> SelectQuery

Add a recursive CTE (WITH RECURSIVE name AS (...) SELECT ...).

Parameters

• name: CTE name
• subquery: recursive subquery SQL

pub fn window_function(self, expr: &str) -> SelectQuery

Add a window function column (as a raw expression in the SELECT list).

The caller is responsible for constructing the complete window function expression, e.g.:

• ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC)
• RANK() OVER (ORDER BY score DESC)
• SUM(amount) OVER (PARTITION BY user_id ORDER BY created_at)

Parameters

• expr: complete window function expression

pub fn row_number( self, partition_by: &str, order_by: &str, alias: &str, ) -> SelectQuery

Add a ROW_NUMBER() window function column.

Parameters

• partition_by: PARTITION BY column (may be empty)
• order_by: ORDER BY column (e.g., salary DESC)
• alias: result column alias (e.g., row_num)

pub fn rank( self, partition_by: &str, order_by: &str, alias: &str, ) -> SelectQuery

Add a RANK() window function column.

Parameters

• partition_by: PARTITION BY column (may be empty)
• order_by: ORDER BY column
• alias: result column alias

pub fn dense_rank( self, partition_by: &str, order_by: &str, alias: &str, ) -> SelectQuery

Add a DENSE_RANK() window function column.

Parameters

• partition_by: PARTITION BY column (may be empty)
• order_by: ORDER BY column
• alias: result column alias

pub fn for_update(self) -> SelectQuery

Set FOR UPDATE row lock.

Appends FOR UPDATE to the end of the generated SQL, used for pessimistic lock.

pub fn for_update_with_options(self, options: &str) -> SelectQuery

Set FOR UPDATE with options (e.g., NOWAIT, SKIP LOCKED).

Parameters

• options: options string, e.g., "NOWAIT" or "SKIP LOCKED"

pub fn union(self, other: SelectQuery) -> SetQuery

Combine the current query with another query using UNION set operation.

Returns a SetQuery, which can be turned into the final SQL via build().

pub fn union_all(self, other: SelectQuery) -> SetQuery

Combine the current query with another query using UNION ALL set operation.

pub fn intersect(self, other: SelectQuery) -> SetQuery

Combine the current query with another query using INTERSECT set operation.

pub fn except(self, other: SelectQuery) -> SetQuery

Combine the current query with another query using EXCEPT set operation.

pub fn build(self, db_type: DbType) -> String

Generate SQL

Parameters

• db_type: database type, used to select the dialect

pub fn build_with_params(self, db_type: DbType) -> BuiltQuery

Generate parameterized SQL (parameterized query, P0 fix: SQL injection prevention)

Returns a BuiltQuery, containing a SQL string with ? placeholders and a list of parameters bound in order. Differences from build:

• WHERE conditions can come from parameterized APIs like where_eq/where_in/where_between
• User input is bound as parameters rather than concatenated into the SQL string

Mixed usage rules

When using both raw where_clause(&str) and parameterized where_eq(column, value):

• Raw conditions render first (no parameters)
• Parameterized conditions render after (parameters collected in order)
• Both preserve AND/OR conjunction semantics in call order

Example

use sz_orm_core::{DbType, Value};
use sz_orm_query_builder::Query;

let built = Query::select()
    .column("id")
    .from("users")
    .where_eq("age", Value::I32(18))
    .or_where_eq("role", Value::String("admin".into()))
    .build_with_params(DbType::MySQL);
assert!(built.sql.contains("WHERE `age` = ? OR `role` = ?"));
assert_eq!(built.params.len(), 2);

Trait Implementations

impl Clone for SelectQuery

fn clone(&self) -> SelectQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SelectQuery

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

Formats the value using the given formatter.

impl Default for SelectQuery

fn default() -> SelectQuery

Returns the “default value” for a type.