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>(
self,
params: &mut Vec<V>,
value: V,
parameter_offset: usize,
out: &mut String,
) {
params.push(value);
if self.numbered_placeholders {
let _ = write!(out, "${}", parameter_offset + params.len());
} else {
out.push('?');
}
}
}
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::Unqualified(Identifier::parse(ident)?).render(dialect.quote))
}
pub(crate) fn quote_qualified(dialect: Dialect, ident: &str) -> Result<String, DbError> {
Ok(QualifiedIdentifier::parse(ident)?.render(dialect.quote))
}
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),
IsNull(String),
IsNotNull(String),
ColumnComparison(String, &'static str, String),
#[cfg(feature = "mysql")]
ColumnExpr(String, &'static str, &'static str, Option<V>),
Exists(Box<SubqueryNode<V>>),
NotExists(Box<SubqueryNode<V>>),
InSubquery(String, Box<SubqueryNode<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>(
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>(
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_qualified(dialect, &field)?);
out.push_str(" = ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Ne(field, value) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" != ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Gt(field, value) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" > ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Lt(field, value) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" < ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Gte(field, value) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" >= ");
dialect.push_param(params, value, parameter_offset, out);
Ok(())
}
CondNode::Lte(field, value) => {
out.push_str("e_qualified(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}` 的值列表不能为空"
)));
}
out.push_str("e_qualified(dialect, &field)?);
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}` 的值列表不能为空"
)));
}
out.push_str("e_qualified(dialect, &field)?);
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) => {
out.push_str("e_qualified(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) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" LIKE ");
dialect.push_param(params, pattern, parameter_offset, out);
Ok(())
}
CondNode::IsNull(field) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" IS NULL");
Ok(())
}
CondNode::IsNotNull(field) => {
out.push_str("e_qualified(dialect, &field)?);
out.push_str(" IS NOT NULL");
Ok(())
}
CondNode::ColumnComparison(left, op, right) => {
out.push_str("e_qualified(dialect, &left)?);
out.push(' ');
out.push_str(op);
out.push(' ');
out.push_str("e_qualified(dialect, &right)?);
Ok(())
}
#[cfg(feature = "mysql")]
CondNode::ColumnExpr(field, op, fragment, param) => {
out.push_str("e_qualified(dialect, &field)?);
out.push(' ');
out.push_str(op);
out.push(' ');
out.push_str(fragment);
if let Some(value) = param {
params.push(value);
}
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_qualified(dialect, &field)?);
out.push_str(" IN (");
write_subquery(dialect, *subquery, 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(())
}
}
}
fn write_subquery<V>(
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(())
}