use std::fmt::Write as _;
use crate::error::DbError;
use crate::sql_types::{Identifier, QualifiedIdentifier, RenderedCondition};
#[derive(Debug, Clone, Copy)]
pub(crate) struct Dialect {
quote: char,
numbered_placeholders: bool,
}
#[cfg(feature = "mysql")]
pub(crate) const MYSQL: Dialect = Dialect {
quote: '`',
numbered_placeholders: false,
};
#[cfg(feature = "postgres")]
pub(crate) const POSTGRES: Dialect = Dialect {
quote: '"',
numbered_placeholders: true,
};
impl Dialect {
fn push_param<V: CondValue>(
self,
params: &mut Vec<V>,
value: V,
parameter_offset: usize,
out: &mut String,
) {
let cast_suffix = value.cast_suffix();
params.push(value);
if self.numbered_placeholders {
let _ = write!(out, "${}", parameter_offset + params.len());
} else {
out.push('?');
}
if let Some(suffix) = cast_suffix {
out.push_str(suffix);
}
}
#[cfg(feature = "postgres")]
fn render_expr(
self,
expression: &crate::SqlExpr,
placeholder: usize,
) -> Result<(String, Vec<crate::reference::SqlExprParam>), DbError> {
if self.numbered_placeholders {
#[cfg(feature = "postgres")]
{
let rendered = expression.postgres_render(placeholder);
Ok((rendered.sql, rendered.params))
}
#[cfg(not(feature = "postgres"))]
{
let _ = (expression, placeholder);
unreachable!("编号占位符方言只有 PostgreSQL")
}
} else {
#[cfg(feature = "mysql")]
{
let _ = placeholder;
let rendered = expression.mysql_render()?;
Ok((rendered.sql, rendered.params))
}
#[cfg(not(feature = "mysql"))]
{
let _ = (expression, placeholder);
unreachable!("? 占位符方言只有 MySQL")
}
}
}
}
pub(crate) fn is_valid_identifier(s: &str) -> bool {
Identifier::parse(s).is_ok()
}
pub(crate) fn quote_identifier(dialect: Dialect, ident: &str) -> Result<String, DbError> {
Ok(QualifiedIdentifier::parse_with_max_parts(ident, 1)?.render(dialect.quote))
}
pub(crate) fn quote_qualified(dialect: Dialect, ident: &str) -> Result<String, DbError> {
Ok(QualifiedIdentifier::parse(ident)?.render(dialect.quote))
}
#[cfg(feature = "postgres")]
pub(crate) fn quote_table(dialect: Dialect, ident: &str) -> Result<String, DbError> {
Ok(QualifiedIdentifier::parse_with_max_parts(ident, 2)?.render(dialect.quote))
}
pub(crate) trait CondValue {
fn is_null(&self) -> bool;
#[cfg(feature = "postgres")]
fn from_expr_param(param: crate::reference::SqlExprParam) -> Self;
#[cfg(feature = "postgres")]
fn is_json(&self) -> bool {
false
}
#[cfg(feature = "postgres")]
fn is_array(&self) -> bool {
false
}
#[cfg(feature = "postgres")]
fn is_range_value(&self) -> bool {
false
}
fn cast_suffix(&self) -> Option<&'static str> {
None
}
#[cfg(feature = "postgres")]
fn array_is_empty(&self) -> bool {
false
}
}
#[cfg(feature = "mysql")]
impl CondValue for crate::mysql::SqlValue {
fn is_null(&self) -> bool {
matches!(self, crate::mysql::SqlValue::Null)
}
#[cfg(feature = "postgres")]
fn from_expr_param(param: crate::reference::SqlExprParam) -> Self {
param.into()
}
}
#[cfg(feature = "postgres")]
impl CondValue for crate::postgres::SqlValue {
fn is_null(&self) -> bool {
matches!(self, crate::postgres::SqlValue::Null)
}
fn from_expr_param(param: crate::reference::SqlExprParam) -> Self {
param.into()
}
fn is_json(&self) -> bool {
matches!(self, crate::postgres::SqlValue::Json(_))
}
fn is_array(&self) -> bool {
matches!(
self,
crate::postgres::SqlValue::Array(_) | crate::postgres::SqlValue::TypedArray { .. }
)
}
fn is_range_value(&self) -> bool {
matches!(
self,
crate::postgres::SqlValue::Range(_) | crate::postgres::SqlValue::Multirange(_)
)
}
fn array_is_empty(&self) -> bool {
matches!(
self,
crate::postgres::SqlValue::Array(values) if values.is_empty()
) || matches!(
self,
crate::postgres::SqlValue::TypedArray { values, .. } if values.is_empty()
)
}
fn cast_suffix(&self) -> Option<&'static str> {
match self {
crate::postgres::SqlValue::Inet(_) => Some("::inet"),
crate::postgres::SqlValue::Cidr(_) => Some("::cidr"),
crate::postgres::SqlValue::MacAddr(_) => Some("::macaddr"),
crate::postgres::SqlValue::MacAddr8(_) => Some("::macaddr8"),
crate::postgres::SqlValue::Range(_) => Some("::int4range"),
crate::postgres::SqlValue::Multirange(_) => Some("::int4multirange"),
crate::postgres::SqlValue::TypedArray { element_type, .. } => match *element_type {
"varchar" => Some("::varchar[]"),
"inet" => Some("::inet[]"),
"cidr" => Some("::cidr[]"),
"macaddr" => Some("::macaddr[]"),
"macaddr8" => Some("::macaddr8[]"),
_ => None,
},
_ => None,
}
}
}
fn quote_condition_field(dialect: Dialect, field: &str) -> Result<String, DbError> {
if dialect.numbered_placeholders {
if let Some((first, rest)) = field.split_once('.') {
if first.eq_ignore_ascii_case("excluded") {
return Ok(format!("excluded.{}", quote_identifier(dialect, rest)?));
}
}
}
quote_qualified(dialect, field)
}
pub(crate) enum CondNode<V> {
Eq(String, V),
Ne(String, V),
Gt(String, V),
Lt(String, V),
Gte(String, V),
Lte(String, V),
In(String, Vec<V>),
NotIn(String, Vec<V>),
Between(String, V, V),
Like(String, V),
PatternMatch(String, &'static str, V),
#[cfg(feature = "postgres")]
DistinctFrom(String, bool, V),
IsNull(String),
IsNotNull(String),
ColumnComparison(String, &'static str, String),
#[cfg(feature = "mysql")]
ColumnExpr(String, &'static str, String, Vec<V>),
#[cfg(feature = "postgres")]
ExprComparison(String, &'static str, crate::SqlExpr),
Exists(Box<SubqueryNode<V>>),
NotExists(Box<SubqueryNode<V>>),
InSubquery(String, Box<SubqueryNode<V>>),
#[cfg(feature = "postgres")]
JsonContains(String, V),
#[cfg(feature = "postgres")]
JsonContainedBy(String, V),
#[cfg(feature = "postgres")]
JsonHasKey(String, V),
#[cfg(feature = "postgres")]
Any(String, V),
#[cfg(feature = "postgres")]
All(String, V),
#[cfg(feature = "postgres")]
RangeContains(String, V),
#[cfg(feature = "postgres")]
RangeOverlaps(String, V),
#[cfg(feature = "postgres")]
JsonPathExists(String, V),
#[cfg(feature = "postgres")]
JsonPathMatch(String, V, V),
#[cfg(feature = "postgres")]
FullText(String, V),
#[cfg(feature = "postgres")]
FullTextQuery(String, V),
#[cfg(feature = "postgres")]
Not(Box<CondNode<V>>),
And(Vec<CondNode<V>>),
Or(Vec<CondNode<V>>),
}
pub(crate) struct SubqueryNode<V> {
pub(crate) table: String,
pub(crate) field: String,
pub(crate) conditions: Vec<CondNode<V>>,
}
pub(crate) fn render_condition<V: CondValue>(
dialect: Dialect,
condition: CondNode<V>,
parameter_offset: usize,
) -> Result<RenderedCondition<V>, DbError> {
let mut rendered = RenderedCondition {
sql: String::new(),
params: Vec::new(),
};
write_condition(
dialect,
condition,
&mut rendered.sql,
&mut rendered.params,
parameter_offset,
)?;
Ok(rendered)
}
fn write_condition<V: CondValue>(
dialect: Dialect,
condition: CondNode<V>,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
match condition {
CondNode::Eq(field, value) => {
out.push_str("e_condition_field(dialect, &field)?);
if value.is_null() {
out.push_str(" IS NULL");
} else {
out.push_str(" = ");
dialect.push_param(params, value, parameter_offset, out);
}
Ok(())
}
CondNode::Ne(field, value) => {
out.push_str("e_condition_field(dialect, &field)?);
if value.is_null() {
out.push_str(" IS NOT NULL");
} else {
out.push_str(" != ");
dialect.push_param(params, value, parameter_offset, out);
}
Ok(())
}
CondNode::Gt(field, value) => {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" > ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Lt(field, value) => {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" < ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Gte(field, value) => {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" >= ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Lte(field, value) => {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" <= ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::In(field, values) => {
if values.is_empty() {
return Err(DbError::InvalidArgument(format!(
"IN 条件 `{field}` 的值列表不能为空"
)));
}
let values: Vec<V> = values
.into_iter()
.filter(|value| !value.is_null())
.collect();
if values.is_empty() {
out.push_str("NULL");
return Ok(());
}
let quoted = quote_condition_field(dialect, &field)?;
out.push_str("ed);
out.push_str(" IN (");
for (index, value) in values.into_iter().enumerate() {
if index > 0 {
out.push_str(", ");
}
dialect.push_param(params, value, parameter_offset, out);
}
out.push(')');
Ok(())
}
CondNode::NotIn(field, values) => {
if values.is_empty() {
return Err(DbError::InvalidArgument(format!(
"NOT IN 条件 `{field}` 的值列表不能为空"
)));
}
if values.iter().any(CondValue::is_null) {
out.push_str("NULL");
return Ok(());
}
let quoted = quote_condition_field(dialect, &field)?;
out.push_str("ed);
out.push_str(" NOT IN (");
for (index, value) in values.into_iter().enumerate() {
if index > 0 {
out.push_str(", ");
}
dialect.push_param(params, value, parameter_offset, out);
}
out.push(')');
Ok(())
}
CondNode::Between(field, start, end) => {
if start.is_null() || end.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" BETWEEN ");
dialect.push_param(params, start, parameter_offset, out);
out.push_str(" AND ");
dialect.push_param(params, end, parameter_offset, out);
Ok(())
}
CondNode::Like(field, pattern) => {
if pattern.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" LIKE ");
dialect.push_param(params, pattern, parameter_offset, out);
Ok(())
}
CondNode::PatternMatch(field, operator, pattern) => {
if pattern.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("e_condition_field(dialect, &field)?);
out.push(' ');
out.push_str(operator);
out.push(' ');
dialect.push_param(params, pattern, parameter_offset, out);
Ok(())
}
#[cfg(feature = "postgres")]
CondNode::DistinctFrom(field, negated, value) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(if negated {
" IS DISTINCT FROM "
} else {
" IS NOT DISTINCT FROM "
});
if value.is_null() {
out.push_str("NULL");
} else {
dialect.push_param(params, value, parameter_offset, out);
}
Ok(())
}
CondNode::IsNull(field) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" IS NULL");
Ok(())
}
CondNode::IsNotNull(field) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" IS NOT NULL");
Ok(())
}
CondNode::ColumnComparison(left, op, right) => {
out.push_str("e_condition_field(dialect, &left)?);
out.push(' ');
out.push_str(op);
out.push(' ');
out.push_str("e_condition_field(dialect, &right)?);
Ok(())
}
#[cfg(feature = "mysql")]
CondNode::ColumnExpr(field, op, fragment, expr_params) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push(' ');
out.push_str(op);
out.push(' ');
out.push_str(&fragment);
params.extend(expr_params);
Ok(())
}
CondNode::Exists(subquery) => {
out.push_str("EXISTS (");
write_subquery(dialect, *subquery, out, params, parameter_offset)?;
out.push(')');
Ok(())
}
CondNode::NotExists(subquery) => {
out.push_str("NOT EXISTS (");
write_subquery(dialect, *subquery, out, params, parameter_offset)?;
out.push(')');
Ok(())
}
CondNode::InSubquery(field, subquery) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(" IN (");
write_subquery(dialect, *subquery, out, params, parameter_offset)?;
out.push(')');
Ok(())
}
#[cfg(feature = "postgres")]
CondNode::JsonContains(field, value) => write_json_predicate(
dialect,
" @> ",
&field,
value,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::JsonContainedBy(field, value) => write_json_predicate(
dialect,
" <@ ",
&field,
value,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::JsonHasKey(field, key) => {
out.push('(');
out.push_str("e_condition_field(dialect, &field)?);
out.push_str(")::jsonb");
out.push_str(" ? ");
dialect.push_param(params, key, parameter_offset, out);
Ok(())
}
#[cfg(feature = "postgres")]
CondNode::Any(field, value) => write_array_predicate(
dialect,
" = ANY(",
&field,
value,
out,
params,
parameter_offset,
true,
),
#[cfg(feature = "postgres")]
CondNode::All(field, value) => write_array_predicate(
dialect,
" = ALL(",
&field,
value,
out,
params,
parameter_offset,
false,
),
#[cfg(feature = "postgres")]
CondNode::RangeContains(field, value) => write_range_predicate(
dialect,
" @> ",
&field,
value,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::RangeOverlaps(field, value) => write_range_predicate(
dialect,
" && ",
&field,
value,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::JsonPathExists(field, path) => write_json_path_predicate(
dialect,
"jsonb_path_exists",
&field,
path,
None,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::JsonPathMatch(field, path, vars) => write_json_path_predicate(
dialect,
"jsonb_path_match",
&field,
path,
Some(vars),
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::FullText(field, query) => write_full_text_predicate(
dialect,
"plainto_tsquery",
&field,
query,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::FullTextQuery(field, query) => write_full_text_predicate(
dialect,
"to_tsquery",
&field,
query,
out,
params,
parameter_offset,
),
#[cfg(feature = "postgres")]
CondNode::ExprComparison(field, op, expression) => {
out.push_str("e_condition_field(dialect, &field)?);
out.push(' ');
out.push_str(op);
out.push(' ');
let placeholder = parameter_offset + params.len() + 1;
let (fragment, expr_params) = dialect.render_expr(&expression, placeholder)?;
out.push_str(&fragment);
for param in expr_params {
params.push(V::from_expr_param(param));
}
Ok(())
}
#[cfg(feature = "postgres")]
CondNode::Not(inner) => {
out.push_str("NOT (");
write_condition(dialect, *inner, out, params, parameter_offset)?;
out.push(')');
Ok(())
}
CondNode::And(mut conditions) => {
if conditions.is_empty() {
return Err(DbError::InvalidArgument("AND 条件组不能为空".to_string()));
}
if conditions.len() == 1 {
return write_condition(
dialect,
conditions.remove(0),
out,
params,
parameter_offset,
);
}
out.push('(');
for (index, condition) in conditions.into_iter().enumerate() {
if index > 0 {
out.push_str(" AND ");
}
write_condition(dialect, condition, out, params, parameter_offset)?;
}
out.push(')');
Ok(())
}
CondNode::Or(mut conditions) => {
if conditions.is_empty() {
return Err(DbError::InvalidArgument("OR 条件组不能为空".to_string()));
}
if conditions.len() == 1 {
return write_condition(
dialect,
conditions.remove(0),
out,
params,
parameter_offset,
);
}
out.push('(');
for (index, condition) in conditions.into_iter().enumerate() {
if index > 0 {
out.push_str(" OR ");
}
write_condition(dialect, condition, out, params, parameter_offset)?;
}
out.push(')');
Ok(())
}
}
}
#[cfg(feature = "postgres")]
fn write_json_predicate<V: CondValue>(
dialect: Dialect,
operator: &str,
field: &str,
value: V,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
if !value.is_json() {
return Err(DbError::InvalidArgument(format!(
"JSON 谓词 `{field}` 的值必须是 SqlValue::Json"
)));
}
out.push('(');
out.push_str("e_condition_field(dialect, field)?);
out.push_str(")::jsonb");
out.push_str(operator);
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
#[cfg(feature = "postgres")]
#[allow(clippy::too_many_arguments)]
fn write_array_predicate<V: CondValue>(
dialect: Dialect,
operator: &str,
field: &str,
value: V,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
is_any: bool,
) -> Result<(), DbError> {
if !value.is_array() {
return Err(DbError::InvalidArgument(format!(
"ANY/ALL 条件 `{field}` 的值必须是 SqlValue::Array"
)));
}
if value.array_is_empty() {
out.push_str(if is_any { "FALSE" } else { "TRUE" });
return Ok(());
}
out.push_str("e_condition_field(dialect, field)?);
out.push_str(operator);
dialect.push_param(params, value, parameter_offset, out);
out.push(')');
Ok(())
}
#[cfg(feature = "postgres")]
fn write_range_predicate<V: CondValue>(
dialect: Dialect,
operator: &str,
field: &str,
value: V,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
if value.is_null() {
out.push_str("NULL");
return Ok(());
}
if !value.is_range_value() {
return Err(DbError::InvalidArgument(format!(
"范围谓词 `{field}` 的值必须是 SqlValue::Range 或 SqlValue::Multirange"
)));
}
out.push_str("e_condition_field(dialect, field)?);
out.push_str(operator);
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
#[cfg(feature = "postgres")]
#[allow(clippy::too_many_arguments)]
fn write_json_path_predicate<V: CondValue>(
dialect: Dialect,
function: &str,
field: &str,
path: V,
vars: Option<V>,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
if path.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str(function);
out.push_str("((");
out.push_str("e_condition_field(dialect, field)?);
out.push_str(")::jsonb, ");
dialect.push_param(params, path, parameter_offset, out);
out.push_str("::jsonpath");
if let Some(vars) = vars {
out.push_str(", ");
dialect.push_param(params, vars, parameter_offset, out);
out.push_str("::jsonb");
}
out.push(')');
Ok(())
}
#[cfg(feature = "postgres")]
fn write_full_text_predicate<V: CondValue>(
dialect: Dialect,
query_function: &str,
field: &str,
query: V,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
if query.is_null() {
out.push_str("NULL");
return Ok(());
}
out.push_str("to_tsvector('simple', ");
out.push_str("e_condition_field(dialect, field)?);
out.push_str(") @@ ");
out.push_str(query_function);
out.push_str("('simple', ");
dialect.push_param(params, query, parameter_offset, out);
out.push(')');
Ok(())
}
fn write_subquery<V: CondValue>(
dialect: Dialect,
subquery: SubqueryNode<V>,
out: &mut String,
params: &mut Vec<V>,
parameter_offset: usize,
) -> Result<(), DbError> {
out.push_str("SELECT ");
out.push_str("e_qualified(dialect, &subquery.field)?);
out.push_str(" FROM ");
out.push_str("e_identifier(dialect, &subquery.table)?);
if !subquery.conditions.is_empty() {
out.push_str(" WHERE ");
for (index, condition) in subquery.conditions.into_iter().enumerate() {
if index > 0 {
out.push_str(" AND ");
}
write_condition(dialect, condition, out, params, parameter_offset)?;
}
}
Ok(())
}