use super::{
eval_scalar_inner, evaluate_items, evaluate_qualified_whole_row, execute_exists_subquery,
ordinary_output, plain, real_type_name, scalar_source_type, Produced, ProductionControl,
ProductionVec, SQLError, ScalarEvalContext, ScalarExpr, Value,
};
use crate::scalar::state::{ColumnSlot, ConstantCast, ContextSchema, RowCast};
use std::sync::OnceLock;
use uqa_sql::ast::BinaryOp;
use uqa_sql::expr::RowLookup;
use uqa_sql::expr::{
cast_value_with_resolution_with_control, cast_value_with_scoped_resolution,
eval_binary_values_with_engine, negate_value_with_control, truthy,
};
pub(super) fn array(
items: &[ScalarExpr],
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let element_type = context.with_type_schema(|schema| {
uqa_sql::type_resolution::scalar_array_input_type_with_control(
items,
schema,
context.params(),
context.function_hook(),
control,
)
})?;
uqa_sql::expr::construct_array_with_control(
items.len(),
element_type.as_deref(),
control,
|index| eval_scalar_inner(&items[index], context, control),
)
}
pub(super) fn row(
items: &[ScalarExpr],
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let mut fields = ProductionVec::new(*control);
fields.reserve(items.len())?;
let mut complete = true;
for item in items {
let field = context.with_type_schema(|schema| {
uqa_sql::type_resolution::scalar_record_field_type_with_control(
item,
schema,
context.params(),
context.function_hook(),
control,
)
})?;
if let Some(field) = field {
fields.push_copy(field)?;
} else {
complete = false;
}
}
let values = evaluate_items(items, context, control)?;
let row = if complete {
let fields = fields.finish()?;
let state = context.row_constructor(items);
let row = if let Some(descriptor) = state.and_then(|state| state.shared(&fields)) {
drop(fields);
uqa_core::RowValue::typed_shared_with_control(values, descriptor, control)?
} else {
uqa_core::RowValue::typed_with_control(values, fields, control)?
};
if let (Some(state), Some(descriptor)) = (state, row.descriptor()) {
state.remember(descriptor, control)?;
}
row
} else {
uqa_core::RowValue::new_with_control(values, control)?
};
let (row, memory) = row.into_parts();
control.finish(Value::Row(row), memory).map_err(Into::into)
}
pub(super) fn binary(
op: BinaryOp,
lhs: &ScalarExpr,
rhs: &ScalarExpr,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let left = eval_scalar_inner(lhs, context, control)?;
let right = eval_scalar_inner(rhs, context, control)?;
binary_values(op, lhs, rhs, &left, &right, context, control)
}
fn binary_values(
op: BinaryOp,
lhs: &ScalarExpr,
rhs: &ScalarExpr,
left: &Value,
right: &Value,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
if matches!(
op,
BinaryOp::Equal
| BinaryOp::NotEqual
| BinaryOp::Less
| BinaryOp::LessEqual
| BinaryOp::Greater
| BinaryOp::GreaterEqual
) {
if matches!((left, right), (Value::Row(_), Value::Row(_)))
&& !matches!((lhs, rhs), (ScalarExpr::Row(_), ScalarExpr::Row(_)))
{
let value = uqa_sql::expr::eval_record_comparison_truth_with_engine(
op,
left,
right,
control,
context.function_hook(),
)?;
return plain(value.map_or(Value::Null, Value::Bool), control);
}
let value = uqa_sql::expr::eval_comparison_truth_with_deferred_state(
op,
left,
right,
control,
context.function_hook(),
|| context.enum_binary_comparison_state(lhs),
)?;
return plain(value.map_or(Value::Null, Value::Bool), control);
}
if (matches!(*left, Value::Float(_)) || matches!(*right, Value::Float(_)))
&& matches!(
op,
BinaryOp::Add | BinaryOp::Subtract | BinaryOp::Multiply | BinaryOp::Divide
)
&& scalar_source_type(lhs, context, control)?
.map(|ty| real_type_name(&ty, control))
.transpose()?
.unwrap_or(false)
&& scalar_source_type(rhs, context, control)?
.map(|ty| real_type_name(&ty, control))
.transpose()?
.unwrap_or(false)
{
let value = uqa_sql::expr::eval_float_arithmetic_with_control(
op,
left,
right,
uqa_sql::expr::FloatWidth::Real,
control,
)?;
return plain(value, control);
}
let integer_width = if matches!((left, right), (Value::Int(_), Value::Int(_)))
&& matches!(
op,
BinaryOp::Add | BinaryOp::Subtract | BinaryOp::Multiply | BinaryOp::Divide
) {
context.with_type_schema(|schema| {
uqa_sql::scalar_integer_operation_width_with_control(
lhs,
rhs,
schema,
context.params(),
control,
)
})?
} else {
None
};
eval_binary_values_with_engine(
op,
left,
right,
integer_width,
context.function_hook(),
control,
)
}
pub(super) fn unary_minus(
inner: &ScalarExpr,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let source_ty = scalar_source_type(inner, context, control)?;
let value = eval_scalar_inner(inner, context, control)?;
negate_value_with_control(&value, source_ty.as_deref().map(String::as_str), control)
}
pub(super) fn not(
inner: &ScalarExpr,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let value = eval_scalar_inner(inner, context, control)?;
if matches!(*value, Value::Null) {
plain(Value::Null, control)
} else {
plain(Value::Bool(!truthy(&value)), control)
}
}
pub(super) fn is_null(
expr: &ScalarExpr,
negated: bool,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let value = eval_scalar_inner(expr, context, control)?;
plain(
Value::Bool(uqa_sql::expr::sql_null_test_with_control(
&value,
negated,
context.function_hook(),
control,
)?),
control,
)
}
pub(super) fn cast(
expr: &ScalarExpr,
ty: &str,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
if let Some(slot) = context.row_cast(expr) {
return row_cast(expr, ty, context, control, slot);
}
let Some(constant) = context.constant_cast(expr) else {
return convert(expr, ty, context, control, false).map(|converted| converted.value);
};
match constant.get() {
Some(ConstantCast::Retained(value)) => control.copy_value(value).map_err(Into::into),
Some(ConstantCast::PerEvaluation) => {
convert(expr, ty, context, control, false).map(|converted| converted.value)
}
None => {
let CastEvaluation {
source,
value: converted,
..
} = convert(expr, ty, context, control, false)?;
let _ = constant.set(
if immutable_constant_cast(expr, source.as_deref().map(String::as_str), ty) {
ConstantCast::Retained((*converted).clone())
} else {
ConstantCast::PerEvaluation
},
);
Ok(converted)
}
}
}
fn row_cast(
expr: &ScalarExpr,
ty: &str,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
slot: &OnceLock<RowCast>,
) -> Result<Produced<Value>, SQLError> {
if let Some(state) = slot.get() {
let (RowCast::Resolved { schema, .. }
| RowCast::Source { schema, .. }
| RowCast::Catalog { schema, .. }) = state;
let same_schema = match (schema, context.row_schema()) {
(None, None) => true,
(Some(retained), Some(current)) => current.shares_index(retained),
_ => false,
};
if same_schema {
let value = eval_scalar_inner(expr, context, control)?;
return match state {
RowCast::Resolved {
conversion, source, ..
} => conversion.evaluate_with_catalog(
&value,
source,
ty,
context.function_hook(),
control,
),
RowCast::Catalog {
conversion, source, ..
} => conversion
.evaluate(
&value,
source.as_deref().map(String::as_str),
ty,
context.function_hook(),
control,
)
.unwrap_or_else(|| {
cast_value_with_resolution_with_control(
&value,
source.as_deref().map(String::as_str),
ty,
context.function_hook(),
control,
)
.map(|(value, _)| value)
}),
RowCast::Source { source, .. } => cast_value_with_resolution_with_control(
&value,
source.as_deref().map(String::as_str),
ty,
context.function_hook(),
control,
)
.map(|(value, _)| value),
};
}
}
let CastEvaluation {
source,
value: converted,
resolved,
catalog,
} = convert(expr, ty, context, control, slot.get().is_none())?;
if slot.get().is_none() {
let state = match (source, resolved, catalog) {
(Some(source), Some(conversion), _)
if uqa_sql::type_resolution::pg_catalog_builtin_type(ty).is_some()
&& uqa_sql::type_resolution::pg_catalog_builtin_type(&source).is_some() =>
{
RowCast::Resolved {
conversion,
source,
schema: context.row_schema().cloned(),
}
}
(source, _, Some(conversion)) => RowCast::Catalog {
conversion,
source,
schema: context.row_schema().cloned(),
},
(source, _, None) => RowCast::Source {
source,
schema: context.row_schema().cloned(),
},
};
let _ = slot.set(state);
}
Ok(converted)
}
struct CastEvaluation {
source: Option<Produced<String>>,
value: Produced<Value>,
resolved: Option<uqa_sql::expr::ResolvedCast>,
catalog: Option<Box<uqa_sql::expr::RetainedCatalogCast>>,
}
fn convert(
expr: &ScalarExpr,
ty: &str,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
retain_catalog: bool,
) -> Result<CastEvaluation, SQLError> {
#[cfg(test)]
crate::scalar::state::CAST_TYPE_RESOLUTIONS.with(|count| count.set(count.get() + 1));
let source_ty = context.with_type_schema(|schema| {
uqa_sql::type_resolution::scalar_cast_source_type_name_with_control(
expr,
schema,
context.params(),
control,
)
})?;
let value = eval_scalar_inner(expr, context, control)?;
let converted = if retain_catalog {
cast_value_with_scoped_resolution(
&value,
source_ty.as_deref().map(String::as_str),
ty,
context.function_hook(),
control,
)?
} else {
let (value, resolved) = cast_value_with_resolution_with_control(
&value,
source_ty.as_deref().map(String::as_str),
ty,
context.function_hook(),
control,
)?;
uqa_sql::expr::ScopedCastResult {
value,
resolved,
catalog: None,
}
};
Ok(CastEvaluation {
source: source_ty,
value: converted.value,
resolved: converted.resolved,
catalog: converted.catalog,
})
}
fn immutable_constant_cast(operand: &ScalarExpr, source: Option<&str>, target: &str) -> bool {
let (ScalarExpr::Literal(operand) | ScalarExpr::TypedLiteral { value: operand, .. }) = operand
else {
return false;
};
if uqa_sql::expr::composites::literal::contains_records(operand)
|| uqa_sql::expr::datums::contains_datum(operand)
{
return false;
}
let Some(target) = uqa_sql::type_resolution::pg_catalog_builtin_type(target) else {
return false;
};
if !uqa_sql::type_resolution::immutable_cast_type(&target) {
return false;
}
source.is_none_or(|source| {
uqa_sql::ColumnType::from_sql_name(source).is_ok_and(|source| {
uqa_sql::type_resolution::immutable_cast_type(&source)
&& uqa_sql::type_resolution::cast_volatility(&source, &target)
== uqa_sql::ast::FunctionVolatility::Immutable
})
})
}
pub(super) fn column(
expression: &ScalarExpr,
name: &str,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let retained = context.column_slot(expression);
if let Some(value) = retained.and_then(|slot| retained_value(slot, context)) {
return control.copy_value(value).map_err(Into::into);
}
#[cfg(test)]
crate::scalar::state::COLUMN_NAME_LOOKUPS.with(|count| count.set(count.get() + 1));
if context.row_schema().is_some_and(|schema| {
!schema.has_unqualified_column(name)
&& !schema.column_is_ambiguous(name)
&& schema.has_qualifier(name)
}) {
return ordinary_output(evaluate_qualified_whole_row(name, context), control);
}
let value = context
.sql_context()
.column_value_with_control(name, control)?;
let context_schema = context
.row_schema()
.map_or(ContextSchema::Absent, |schema| {
ContextSchema::Shared(schema.clone())
});
retain_key(retained, context, context_schema, |row| {
row.column_key(name)
});
Ok(value)
}
pub(super) fn qualified_column(
expression: &ScalarExpr,
qualifier: &str,
column: &str,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let retained = context.column_slot(expression);
if let Some(value) = retained.and_then(|slot| retained_value(slot, context)) {
return control.copy_value(value).map_err(Into::into);
}
#[cfg(test)]
crate::scalar::state::COLUMN_NAME_LOOKUPS.with(|count| count.set(count.get() + 1));
let value = context
.sql_context()
.qualified_column_value_with_control(qualifier, column, control)?;
retain_key(retained, context, ContextSchema::Unused, |row| {
row.qualified_column_key(qualifier, column)
});
Ok(value)
}
fn retain_key(
slot: Option<&OnceLock<ColumnSlot>>,
context: &ScalarEvalContext<'_>,
context_schema: ContextSchema,
key: impl FnOnce(&dyn RowLookup) -> Option<usize>,
) {
if let (Some(slot), Some(row)) = (slot, context.row_lookup()) {
if let Some(schema) = row.resolution_schema() {
let _ = slot.set(ColumnSlot {
context_schema,
row_schema: schema.clone(),
key_space: row.key_space(),
key: key(row),
});
}
}
}
fn retained_value<'a>(
slot: &OnceLock<ColumnSlot>,
context: &ScalarEvalContext<'a>,
) -> Option<&'a Value> {
let resolved = slot.get()?;
let row = context.row_lookup()?;
if row.key_space() != resolved.key_space
|| !row.resolution_schema()?.shares_index(&resolved.row_schema)
{
return None;
}
match (&resolved.context_schema, context.row_schema()) {
(ContextSchema::Unused, _) | (ContextSchema::Absent, None) => {}
(ContextSchema::Shared(retained), Some(current)) if current.shares_index(retained) => {}
_ => return None,
}
Some(
resolved
.key
.and_then(|key| row.keyed_value(key))
.unwrap_or(&crate::batch::NULL_VALUE),
)
}
pub(super) fn exists(
subquery: super::SubqueryId,
negated: bool,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let exists = execute_exists_subquery(subquery, context)?;
plain(Value::Bool(if negated { !exists } else { exists }), control)
}
pub(super) fn in_subquery(
expr: &ScalarExpr,
subquery: super::SubqueryId,
negated: bool,
context: &ScalarEvalContext<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError> {
let needle = eval_scalar_inner(expr, context, control)?;
let mut can_hash = |output: Option<&uqa_sql::ColumnType>| {
let Some(output) = output else {
return Ok(false);
};
let input = context.with_type_schema(|schema| {
uqa_sql::type_resolution::scalar_operand_type_with_engine_and_control(
expr,
schema,
context.params(),
context.function_hook(),
control,
)
})?;
Ok(input.as_ref().is_some_and(|input| {
uqa_sql::type_resolution::equality_types_share_hash_key(input, output)
}))
};
let found = super::execute_in_subquery(
subquery,
crate::scalar::SubqueryNeedle {
value: &needle,
engine: context.function_hook(),
control: *control,
can_hash: &mut can_hash,
},
context,
)?;
plain(
found.map_or(Value::Null, |found| {
Value::Bool(if negated { !found } else { found })
}),
control,
)
}