RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 10:28:10 +00:00
Code Issues Activity Actions

LibSQL+SQLServer: Return the new Result class from statement executions

Browse source 
We can now TRY anything that returns a SQL::Result or an AK::Error.
This commit is contained in:
Timothy Flynn 2022-02-09 15:57:57 -05:00 • committed by Linus Groh
parent d9055de7ea
commit 6620f19979
11 changed files with 337 additions and 337 deletions
Download patch file Download diff file Expand all files Collapse all files

63
Userland/Libraries/LibSQL/AST/Insert.cpp
View file

@ -14,78 +14,69 @@ namespace SQL::AST {
static bool does_value_data_type_match(SQLType expected, SQLType actual)
{
if (actual == SQLType::Null) {
if (actual == SQLType::Null)
return false;
}
if (expected == SQLType::Integer) {
if (expected == SQLType::Integer)
return actual == SQLType::Integer || actual == SQLType::Float;
}
return expected == actual;
}
RefPtr<SQLResult> Insert::execute(ExecutionContext& context) const
Result Insert::execute(ExecutionContext& context) const
{
auto table_def_or_error = context.database->get_table(m_schema_name, m_table_name);
if (table_def_or_error.is_error())
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::InternalError, table_def_or_error.release_error());
auto table_def = table_def_or_error.release_value();
auto table_def = TRY(context.database->get_table(m_schema_name, m_table_name));
if (!table_def) {
auto schema_name = m_schema_name;
if (schema_name.is_null() || schema_name.is_empty())
schema_name = "default";
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, m_table_name));
auto schema_name = m_schema_name.is_empty() ? String("default"sv) : m_schema_name;
return { SQLCommand::Insert, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, m_table_name) };
}
Row row(table_def);
for (auto& column : m_column_names) {
if (!row.has(column)) {
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::ColumnDoesNotExist, column);
}
if (!row.has(column))
return { SQLCommand::Insert, SQLErrorCode::ColumnDoesNotExist, column };
}
Vector<Row> inserted_rows;
inserted_rows.ensure_capacity(m_chained_expressions.size());
context.result = SQLResult::construct();
TRY(inserted_rows.try_ensure_capacity(m_chained_expressions.size()));
context.result = Result { SQLCommand::Insert };
for (auto& row_expr : m_chained_expressions) {
for (auto& column_def : table_def->columns()) {
if (!m_column_names.contains_slow(column_def.name())) {
if (!m_column_names.contains_slow(column_def.name()))
row[column_def.name()] = column_def.default_value();
}
}
auto row_value = row_expr.evaluate(context);
if (context.result->has_error())
return context.result;
if (context.result->is_error())
return context.result.release_value();
VERIFY(row_value.type() == SQLType::Tuple);
auto values = row_value.to_vector().value();
if (m_column_names.size() == 0 && values.size() != row.size()) {
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, "");
}
if (m_column_names.is_empty() && values.size() != row.size())
return { SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, String::empty() };
for (auto ix = 0u; ix < values.size(); ix++) {
auto input_value_type = values[ix].type();
auto& tuple_descriptor = *row.descriptor();
// In case of having column names, this must succeed since we checked for every column name for existence in the table.
auto element_index = (m_column_names.size() == 0) ? ix : tuple_descriptor.find_if([&](auto element) { return element.name == m_column_names[ix]; }).index();
auto element_index = m_column_names.is_empty() ? ix : tuple_descriptor.find_if([&](auto element) { return element.name == m_column_names[ix]; }).index();
auto element_type = tuple_descriptor[element_index].type;
if (!does_value_data_type_match(element_type, input_value_type)) {
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index].name());
}
if (!does_value_data_type_match(element_type, input_value_type))
return { SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index].name() };
row[element_index] = values[ix];
}
inserted_rows.append(row);
}
for (auto& inserted_row : inserted_rows) {
if (auto maybe_error = context.database->insert(inserted_row); maybe_error.is_error())
return SQLResult::construct(SQLCommand::Insert, SQLErrorCode::InternalError, maybe_error.release_error());
}
for (auto& inserted_row : inserted_rows)
TRY(context.database->insert(inserted_row));
return SQLResult::construct(SQLCommand::Insert, 0, m_chained_expressions.size(), 0);
return { SQLCommand::Insert, 0, m_chained_expressions.size() };
}
}