use super::{ColumnType, Interpreter, IntoTarget, PLpgSQLDatum, SQLError, Value};
impl Interpreter<'_> {
pub(super) fn datum_name(&self, idx: usize) -> Result<String, SQLError> {
let datum = self.datums.get(idx).ok_or_else(|| {
SQLError::Internal(format!("PL/pgSQL references missing datum {idx}"))
})?;
datum.name().map(ToString::to_string).ok_or_else(|| {
SQLError::Internal(format!(
"PL/pgSQL datum {idx} does not have a bindable name"
))
})
}
pub(super) fn assign_datum(&mut self, idx: usize, value: Value) -> Result<(), SQLError> {
self.assign_datum_typed(idx, value, None, None)
}
pub(super) fn assign_datum_typed(
&mut self,
idx: usize,
value: Value,
source: Option<&ColumnType>,
record_schema: Option<uqa_sql::RowSchema>,
) -> Result<(), SQLError> {
match &self.datums[idx] {
PLpgSQLDatum::Var(var) => {
if var.constant {
return Err(SQLError::Routine {
sqlstate: "22005".into(),
message: format!("variable \"{}\" is declared CONSTANT", var.name),
});
}
let value = self.coerce_datum(idx, &var.type_name, &value, source)?;
if var.not_null && matches!(value, Value::Null) {
return Err(SQLError::Routine {
sqlstate: "22004".into(),
message: format!(
"null value cannot be assigned to variable \"{}\" declared NOT NULL",
var.name
),
});
}
self.values[idx] = value;
Ok(())
}
PLpgSQLDatum::Rec { .. } => {
let (value, descriptor) = super::records::RecordVariableDescriptor::bind(
value,
record_schema,
self.services.expressions,
)?;
self.values[idx] = value;
if let Some(descriptor) = descriptor {
self.record_descriptors.insert(idx, descriptor);
} else {
self.record_descriptors.remove(&idx);
}
Ok(())
}
PLpgSQLDatum::RecField { field, parent } => {
let target_type = self.datum_type(idx)?;
let value = match target_type.as_ref() {
Some(target) => uqa_sql::assignment::conversion::coerce_assignment_value(
self.services.expressions,
value,
target,
source,
)?,
None => value,
};
let parent_name = self.datum_name(*parent)?;
if matches!(self.values[*parent], Value::Datum(_)) {
let descriptor = self.record_descriptors.get(parent).ok_or_else(|| {
SQLError::Internal("physical record has no assignment descriptor".into())
})?;
if descriptor.field_index(field).is_none() {
return Err(SQLError::Routine {
sqlstate: "42703".into(),
message: format!("record \"{parent_name}\" has no field \"{field}\""),
});
}
self.values[*parent] = descriptor.replace_field(
&self.values[*parent],
field,
&value,
self.services.expressions,
)?;
return Ok(());
}
match &mut self.values[*parent] {
Value::Record(fields) => {
let field_value = fields
.iter_mut()
.find(|(name, _)| name.as_str() == field)
.map(|(_, value)| value)
.ok_or_else(|| SQLError::Routine {
sqlstate: "42703".into(),
message: format!(
"record \"{parent_name}\" has no field \"{field}\""
),
})?;
*field_value = value;
Ok(())
}
_ => Err(super::diagnostics::unassigned_record(&parent_name)),
}
}
PLpgSQLDatum::Row { .. } => Err(SQLError::Internal(
"direct assignment to a row datum".into(),
)),
}
}
pub(super) fn assign_foreach_target(
&mut self,
idx: usize,
value: Value,
) -> Result<(), SQLError> {
let datum = self.datums.get(idx).cloned().ok_or_else(|| {
SQLError::Internal(format!("PL/pgSQL FOREACH references missing datum {idx}"))
})?;
let PLpgSQLDatum::Row { fields } = datum else {
return self.assign_datum(idx, value);
};
let value = match value {
Value::Datum(ref datum)
if uqa_sql::expr::composites::datum_is_composite(
datum,
self.services.expressions,
)? =>
{
uqa_sql::expr::datums::read_with_catalog(datum, Some(self.services.expressions))?
}
value => value,
};
let values = match value {
Value::Record(fields) => fields.into_values(),
Value::Row(values) => values.into_values(),
Value::Null => Vec::new(),
_ => {
return Err(SQLError::Routine {
sqlstate: "42804".into(),
message: "cannot assign non-composite value to a row variable".into(),
});
}
};
for (field_index, field) in fields.iter().enumerate() {
self.assign_datum(
field.varno,
values.get(field_index).cloned().unwrap_or(Value::Null),
)?;
}
Ok(())
}
pub(super) fn assign_into(
&mut self,
target: &IntoTarget,
schema: &uqa_sql::RowSchema,
values: Option<&[Value]>,
) -> Result<(), SQLError> {
match target {
IntoTarget::Rec(dno) => {
let value = Value::Record(
schema
.columns()
.iter()
.enumerate()
.map(|(index, column)| {
(
column.clone(),
values
.and_then(|values| values.get(index))
.cloned()
.unwrap_or(Value::Null),
)
})
.collect::<Vec<_>>()
.into(),
);
self.values[*dno] = value;
self.record_descriptors.insert(*dno, schema.clone().into());
Ok(())
}
IntoTarget::Row(fields) => {
for (idx, field) in fields.iter().enumerate() {
let value = values
.and_then(|values| values.get(idx))
.cloned()
.unwrap_or(Value::Null);
self.assign_datum_typed(field.varno, value, schema.column_type(idx), None)?;
}
Ok(())
}
}
}
}