RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 05:27:45 +00:00
Code Issues Activity Actions

Everywhere: Stop using NonnullRefPtrVector

Browse source 
This class had slightly confusing semantics and the added weirdness
doesn't seem worth it just so we can say "." instead of "->" when
iterating over a vector of NNRPs.

This patch replaces NonnullRefPtrVector<T> with Vector<NNRP<T>>.
This commit is contained in:
Andreas Kling 2023-03-06 14:17:01 +01:00
parent 104be6c8ac
commit 8a48246ed1
168 changed files with 1280 additions and 1280 deletions
Download patch file Download diff file Expand all files Collapse all files

62
Userland/Libraries/LibSQL/AST/AST.h
View file

@ -55,7 +55,7 @@ private:
class TypeName : public ASTNode {
public:
TypeName(DeprecatedString name, NonnullRefPtrVector<SignedNumber> signed_numbers)
TypeName(DeprecatedString name, Vector<NonnullRefPtr<SignedNumber>> signed_numbers)
: m_name(move(name))
, m_signed_numbers(move(signed_numbers))
{
@ -63,11 +63,11 @@ public:
}
DeprecatedString const& name() const { return m_name; }
NonnullRefPtrVector<SignedNumber> const& signed_numbers() const { return m_signed_numbers; }
Vector<NonnullRefPtr<SignedNumber>> const& signed_numbers() const { return m_signed_numbers; }
private:
DeprecatedString m_name;
NonnullRefPtrVector<SignedNumber> m_signed_numbers;
Vector<NonnullRefPtr<SignedNumber>> m_signed_numbers;
};
class ColumnDefinition : public ASTNode {
@ -107,7 +107,7 @@ private:
class CommonTableExpressionList : public ASTNode {
public:
CommonTableExpressionList(bool recursive, NonnullRefPtrVector<CommonTableExpression> common_table_expressions)
CommonTableExpressionList(bool recursive, Vector<NonnullRefPtr<CommonTableExpression>> common_table_expressions)
: m_recursive(recursive)
, m_common_table_expressions(move(common_table_expressions))
{
@ -115,11 +115,11 @@ public:
}
bool recursive() const { return m_recursive; }
NonnullRefPtrVector<CommonTableExpression> const& common_table_expressions() const { return m_common_table_expressions; }
Vector<NonnullRefPtr<CommonTableExpression>> const& common_table_expressions() const { return m_common_table_expressions; }
private:
bool m_recursive;
NonnullRefPtrVector<CommonTableExpression> m_common_table_expressions;
Vector<NonnullRefPtr<CommonTableExpression>> m_common_table_expressions;
};
class QualifiedTableName : public ASTNode {
@ -205,18 +205,18 @@ private:
class GroupByClause : public ASTNode {
public:
GroupByClause(NonnullRefPtrVector<Expression> group_by_list, RefPtr<Expression> having_clause)
GroupByClause(Vector<NonnullRefPtr<Expression>> group_by_list, RefPtr<Expression> having_clause)
: m_group_by_list(move(group_by_list))
, m_having_clause(move(having_clause))
{
VERIFY(!m_group_by_list.is_empty());
}
NonnullRefPtrVector<Expression> const& group_by_list() const { return m_group_by_list; }
Vector<NonnullRefPtr<Expression>> const& group_by_list() const { return m_group_by_list; }
RefPtr<Expression> const& having_clause() const { return m_having_clause; }
private:
NonnullRefPtrVector<Expression> m_group_by_list;
Vector<NonnullRefPtr<Expression>> m_group_by_list;
RefPtr<Expression> m_having_clause;
};
@ -232,7 +232,7 @@ public:
{
}
explicit TableOrSubquery(NonnullRefPtrVector<TableOrSubquery> subqueries)
explicit TableOrSubquery(Vector<NonnullRefPtr<TableOrSubquery>> subqueries)
: m_is_subquery(!subqueries.is_empty())
, m_subqueries(move(subqueries))
{
@ -244,7 +244,7 @@ public:
DeprecatedString const& table_alias() const { return m_table_alias; }
bool is_subquery() const { return m_is_subquery; }
NonnullRefPtrVector<TableOrSubquery> const& subqueries() const { return m_subqueries; }
Vector<NonnullRefPtr<TableOrSubquery>> const& subqueries() const { return m_subqueries; }
private:
bool m_is_table { false };
@ -253,7 +253,7 @@ private:
DeprecatedString m_table_alias {};
bool m_is_subquery { false };
NonnullRefPtrVector<TableOrSubquery> m_subqueries {};
Vector<NonnullRefPtr<TableOrSubquery>> m_subqueries {};
};
class OrderingTerm : public ASTNode {
@ -573,16 +573,16 @@ private:
class ChainedExpression : public Expression {
public:
explicit ChainedExpression(NonnullRefPtrVector<Expression> expressions)
explicit ChainedExpression(Vector<NonnullRefPtr<Expression>> expressions)
: m_expressions(move(expressions))
{
}
NonnullRefPtrVector<Expression> const& expressions() const { return m_expressions; }
Vector<NonnullRefPtr<Expression>> const& expressions() const { return m_expressions; }
virtual ResultOr<Value> evaluate(ExecutionContext&) const override;
private:
NonnullRefPtrVector<Expression> m_expressions;
Vector<NonnullRefPtr<Expression>> m_expressions;
};
class CastExpression : public NestedExpression {
@ -800,7 +800,7 @@ public:
{
}
CreateTable(DeprecatedString schema_name, DeprecatedString table_name, NonnullRefPtrVector<ColumnDefinition> columns, bool is_temporary, bool is_error_if_table_exists)
CreateTable(DeprecatedString schema_name, DeprecatedString table_name, Vector<NonnullRefPtr<ColumnDefinition>> columns, bool is_temporary, bool is_error_if_table_exists)
: m_schema_name(move(schema_name))
, m_table_name(move(table_name))
, m_columns(move(columns))
@ -816,7 +816,7 @@ public:
RefPtr<Select> const& select_statement() const { return m_select_statement; }
bool has_columns() const { return !m_columns.is_empty(); }
NonnullRefPtrVector<ColumnDefinition> const& columns() const { return m_columns; }
Vector<NonnullRefPtr<ColumnDefinition>> const& columns() const { return m_columns; }
bool is_temporary() const { return m_is_temporary; }
bool is_error_if_table_exists() const { return m_is_error_if_table_exists; }
@ -827,7 +827,7 @@ private:
DeprecatedString m_schema_name;
DeprecatedString m_table_name;
RefPtr<Select> m_select_statement;
NonnullRefPtrVector<ColumnDefinition> m_columns;
Vector<NonnullRefPtr<ColumnDefinition>> m_columns;
bool m_is_temporary;
bool m_is_error_if_table_exists;
};
@ -937,7 +937,7 @@ enum class ConflictResolution {
class Insert : public Statement {
public:
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString alias, Vector<DeprecatedString> column_names, NonnullRefPtrVector<ChainedExpression> chained_expressions)
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString alias, Vector<DeprecatedString> column_names, Vector<NonnullRefPtr<ChainedExpression>> chained_expressions)
: m_common_table_expression_list(move(common_table_expression_list))
, m_conflict_resolution(conflict_resolution)
, m_schema_name(move(schema_name))
@ -979,7 +979,7 @@ public:
bool default_values() const { return !has_expressions() && !has_selection(); };
bool has_expressions() const { return !m_chained_expressions.is_empty(); }
NonnullRefPtrVector<ChainedExpression> const& chained_expressions() const { return m_chained_expressions; }
Vector<NonnullRefPtr<ChainedExpression>> const& chained_expressions() const { return m_chained_expressions; }
bool has_selection() const { return !m_select_statement.is_null(); }
RefPtr<Select> const& select_statement() const { return m_select_statement; }
@ -993,7 +993,7 @@ private:
DeprecatedString m_table_name;
DeprecatedString m_alias;
Vector<DeprecatedString> m_column_names;
NonnullRefPtrVector<ChainedExpression> m_chained_expressions;
Vector<NonnullRefPtr<ChainedExpression>> m_chained_expressions;
RefPtr<Select> m_select_statement;
};
@ -1004,7 +1004,7 @@ public:
NonnullRefPtr<Expression> expression;
};
Update(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, NonnullRefPtr<QualifiedTableName> qualified_table_name, Vector<UpdateColumns> update_columns, NonnullRefPtrVector<TableOrSubquery> table_or_subquery_list, RefPtr<Expression> where_clause, RefPtr<ReturningClause> returning_clause)
Update(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, NonnullRefPtr<QualifiedTableName> qualified_table_name, Vector<UpdateColumns> update_columns, Vector<NonnullRefPtr<TableOrSubquery>> table_or_subquery_list, RefPtr<Expression> where_clause, RefPtr<ReturningClause> returning_clause)
: m_common_table_expression_list(move(common_table_expression_list))
, m_conflict_resolution(conflict_resolution)
, m_qualified_table_name(move(qualified_table_name))
@ -1019,7 +1019,7 @@ public:
ConflictResolution conflict_resolution() const { return m_conflict_resolution; }
NonnullRefPtr<QualifiedTableName> const& qualified_table_name() const { return m_qualified_table_name; }
Vector<UpdateColumns> const& update_columns() const { return m_update_columns; }
NonnullRefPtrVector<TableOrSubquery> const& table_or_subquery_list() const { return m_table_or_subquery_list; }
Vector<NonnullRefPtr<TableOrSubquery>> const& table_or_subquery_list() const { return m_table_or_subquery_list; }
RefPtr<Expression> const& where_clause() const { return m_where_clause; }
RefPtr<ReturningClause> const& returning_clause() const { return m_returning_clause; }
@ -1030,7 +1030,7 @@ private:
ConflictResolution m_conflict_resolution;
NonnullRefPtr<QualifiedTableName> m_qualified_table_name;
Vector<UpdateColumns> m_update_columns;
NonnullRefPtrVector<TableOrSubquery> m_table_or_subquery_list;
Vector<NonnullRefPtr<TableOrSubquery>> m_table_or_subquery_list;
RefPtr<Expression> m_where_clause;
RefPtr<ReturningClause> m_returning_clause;
};
@ -1061,7 +1061,7 @@ private:
class Select : public Statement {
public:
Select(RefPtr<CommonTableExpressionList> common_table_expression_list, bool select_all, NonnullRefPtrVector<ResultColumn> result_column_list, NonnullRefPtrVector<TableOrSubquery> table_or_subquery_list, RefPtr<Expression> where_clause, RefPtr<GroupByClause> group_by_clause, NonnullRefPtrVector<OrderingTerm> ordering_term_list, RefPtr<LimitClause> limit_clause)
Select(RefPtr<CommonTableExpressionList> common_table_expression_list, bool select_all, Vector<NonnullRefPtr<ResultColumn>> result_column_list, Vector<NonnullRefPtr<TableOrSubquery>> table_or_subquery_list, RefPtr<Expression> where_clause, RefPtr<GroupByClause> group_by_clause, Vector<NonnullRefPtr<OrderingTerm>> ordering_term_list, RefPtr<LimitClause> limit_clause)
: m_common_table_expression_list(move(common_table_expression_list))
, m_select_all(move(select_all))
, m_result_column_list(move(result_column_list))
@ -1075,22 +1075,22 @@ public:
RefPtr<CommonTableExpressionList> const& common_table_expression_list() const { return m_common_table_expression_list; }
bool select_all() const { return m_select_all; }
NonnullRefPtrVector<ResultColumn> const& result_column_list() const { return m_result_column_list; }
NonnullRefPtrVector<TableOrSubquery> const& table_or_subquery_list() const { return m_table_or_subquery_list; }
Vector<NonnullRefPtr<ResultColumn>> const& result_column_list() const { return m_result_column_list; }
Vector<NonnullRefPtr<TableOrSubquery>> const& table_or_subquery_list() const { return m_table_or_subquery_list; }
RefPtr<Expression> const& where_clause() const { return m_where_clause; }
RefPtr<GroupByClause> const& group_by_clause() const { return m_group_by_clause; }
NonnullRefPtrVector<OrderingTerm> const& ordering_term_list() const { return m_ordering_term_list; }
Vector<NonnullRefPtr<OrderingTerm>> const& ordering_term_list() const { return m_ordering_term_list; }
RefPtr<LimitClause> const& limit_clause() const { return m_limit_clause; }
ResultOr<ResultSet> execute(ExecutionContext&) const override;
private:
RefPtr<CommonTableExpressionList> m_common_table_expression_list;
bool m_select_all;
NonnullRefPtrVector<ResultColumn> m_result_column_list;
NonnullRefPtrVector<TableOrSubquery> m_table_or_subquery_list;
Vector<NonnullRefPtr<ResultColumn>> m_result_column_list;
Vector<NonnullRefPtr<TableOrSubquery>> m_table_or_subquery_list;
RefPtr<Expression> m_where_clause;
RefPtr<GroupByClause> m_group_by_clause;
NonnullRefPtrVector<OrderingTerm> m_ordering_term_list;
Vector<NonnullRefPtr<OrderingTerm>> m_ordering_term_list;
RefPtr<LimitClause> m_limit_clause;
};

12
Userland/Libraries/LibSQL/AST/CreateTable.cpp
View file

@ -17,18 +17,18 @@ ResultOr<ResultSet> CreateTable::execute(ExecutionContext& context) const
for (auto const& column : m_columns) {
SQLType type;
if (column.type_name()->name().is_one_of("VARCHAR"sv, "TEXT"sv))
if (column->type_name()->name().is_one_of("VARCHAR"sv, "TEXT"sv))
type = SQLType::Text;
else if (column.type_name()->name().is_one_of("INT"sv, "INTEGER"sv))
else if (column->type_name()->name().is_one_of("INT"sv, "INTEGER"sv))
type = SQLType::Integer;
else if (column.type_name()->name().is_one_of("FLOAT"sv, "NUMBER"sv))
else if (column->type_name()->name().is_one_of("FLOAT"sv, "NUMBER"sv))
type = SQLType::Float;
else if (column.type_name()->name().is_one_of("BOOL"sv, "BOOLEAN"sv))
else if (column->type_name()->name().is_one_of("BOOL"sv, "BOOLEAN"sv))
type = SQLType::Boolean;
else
return Result { SQLCommand::Create, SQLErrorCode::InvalidType, column.type_name()->name() };
return Result { SQLCommand::Create, SQLErrorCode::InvalidType, column->type_name()->name() };
table_def->append_column(column.name(), type);
table_def->append_column(column->name(), type);
}
if (auto result = context.database->add_table(*table_def); result.is_error()) {

4
Userland/Libraries/LibSQL/AST/Describe.cpp
View file

@ -26,8 +26,8 @@ ResultOr<ResultSet> DescribeTable::execute(ExecutionContext& context) const
for (auto& column : table_def->columns()) {
Tuple tuple(descriptor);
tuple[0] = column.name();
tuple[1] = SQLType_name(column.type());
tuple[0] = column->name();
tuple[1] = SQLType_name(column->type());
result.insert_row(tuple, Tuple {});
}

2
Userland/Libraries/LibSQL/AST/Expression.cpp
View file

@ -52,7 +52,7 @@ ResultOr<Value> ChainedExpression::evaluate(ExecutionContext& context) const
TRY(values.try_ensure_capacity(expressions().size()));
for (auto& expression : expressions())
values.unchecked_append(TRY(expression.evaluate(context)));
values.unchecked_append(TRY(expression->evaluate(context)));
return Value::create_tuple(move(values));
}

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

@ -27,11 +27,11 @@ ResultOr<ResultSet> Insert::execute(ExecutionContext& context) const
for (auto& row_expr : m_chained_expressions) {
for (auto& column_def : table_def->columns()) {
if (!m_column_names.contains_slow(column_def.name()))
row[column_def.name()] = column_def.default_value();
if (!m_column_names.contains_slow(column_def->name()))
row[column_def->name()] = column_def->default_value();
}
auto row_value = TRY(row_expr.evaluate(context));
auto row_value = TRY(row_expr->evaluate(context));
VERIFY(row_value.type() == SQLType::Tuple);
auto values = row_value.to_vector().release_value();
@ -46,7 +46,7 @@ ResultOr<ResultSet> Insert::execute(ExecutionContext& context) const
auto element_type = tuple_descriptor[element_index].type;
if (!values[ix].is_type_compatible_with(element_type))
return Result { SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index].name() };
return Result { SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index]->name() };
row[element_index] = move(values[ix]);
}

26
Userland/Libraries/LibSQL/AST/Parser.cpp
View file

@ -121,7 +121,7 @@ NonnullRefPtr<CreateTable> Parser::parse_create_table_statement()
return create_ast_node<CreateTable>(move(schema_name), move(table_name), move(select_statement), is_temporary, is_error_if_table_exists);
}
NonnullRefPtrVector<ColumnDefinition> column_definitions;
Vector<NonnullRefPtr<ColumnDefinition>> column_definitions;
parse_comma_separated_list(true, [&]() { column_definitions.append(parse_column_definition()); });
// FIXME: Parse "table-constraint".
@ -213,7 +213,7 @@ NonnullRefPtr<Insert> Parser::parse_insert_statement(RefPtr<CommonTableExpressio
if (match(TokenType::ParenOpen))
parse_comma_separated_list(true, [&]() { column_names.append(consume(TokenType::Identifier).value()); });
NonnullRefPtrVector<ChainedExpression> chained_expressions;
Vector<NonnullRefPtr<ChainedExpression>> chained_expressions;
RefPtr<Select> select_statement;
if (consume_if(TokenType::Values)) {
@ -271,7 +271,7 @@ NonnullRefPtr<Update> Parser::parse_update_statement(RefPtr<CommonTableExpressio
update_columns.append({ move(column_names), parse_expression() });
});
NonnullRefPtrVector<TableOrSubquery> table_or_subquery_list;
Vector<NonnullRefPtr<TableOrSubquery>> table_or_subquery_list;
if (consume_if(TokenType::From)) {
// FIXME: Parse join-clause.
parse_comma_separated_list(false, [&]() { table_or_subquery_list.append(parse_table_or_subquery()); });
@ -314,10 +314,10 @@ NonnullRefPtr<Select> Parser::parse_select_statement(RefPtr<CommonTableExpressio
bool select_all = !consume_if(TokenType::Distinct);
consume_if(TokenType::All); // ALL is the default, so ignore it if specified.
NonnullRefPtrVector<ResultColumn> result_column_list;
Vector<NonnullRefPtr<ResultColumn>> result_column_list;
parse_comma_separated_list(false, [&]() { result_column_list.append(parse_result_column()); });
NonnullRefPtrVector<TableOrSubquery> table_or_subquery_list;
Vector<NonnullRefPtr<TableOrSubquery>> table_or_subquery_list;
if (consume_if(TokenType::From)) {
// FIXME: Parse join-clause.
parse_comma_separated_list(false, [&]() { table_or_subquery_list.append(parse_table_or_subquery()); });
@ -331,7 +331,7 @@ NonnullRefPtr<Select> Parser::parse_select_statement(RefPtr<CommonTableExpressio
if (consume_if(TokenType::Group)) {
consume(TokenType::By);
NonnullRefPtrVector<Expression> group_by_list;
Vector<NonnullRefPtr<Expression>> group_by_list;
parse_comma_separated_list(false, [&]() { group_by_list.append(parse_expression()); });
if (!group_by_list.is_empty()) {
@ -346,7 +346,7 @@ NonnullRefPtr<Select> Parser::parse_select_statement(RefPtr<CommonTableExpressio
// FIXME: Parse 'WINDOW window-name AS window-defn'.
// FIXME: Parse 'compound-operator'.
NonnullRefPtrVector<OrderingTerm> ordering_term_list;
Vector<NonnullRefPtr<OrderingTerm>> ordering_term_list;
if (consume_if(TokenType::Order)) {
consume(TokenType::By);
parse_comma_separated_list(false, [&]() { ordering_term_list.append(parse_ordering_term()); });
@ -377,7 +377,7 @@ RefPtr<CommonTableExpressionList> Parser::parse_common_table_expression_list()
consume(TokenType::With);
bool recursive = consume_if(TokenType::Recursive);
NonnullRefPtrVector<CommonTableExpression> common_table_expression;
Vector<NonnullRefPtr<CommonTableExpression>> common_table_expression;
parse_comma_separated_list(false, [&]() { common_table_expression.append(parse_common_table_expression()); });
if (common_table_expression.is_empty()) {
@ -670,7 +670,7 @@ RefPtr<Expression> Parser::parse_chained_expression()
if (match(TokenType::Select))
return parse_exists_expression(false, TokenType::Select);
NonnullRefPtrVector<Expression> expressions;
Vector<NonnullRefPtr<Expression>> expressions;
parse_comma_separated_list(false, [&]() { expressions.append(parse_expression()); });
consume(TokenType::ParenClose);
@ -854,7 +854,7 @@ RefPtr<Expression> Parser::parse_in_expression(NonnullRefPtr<Expression> express
// FIXME: Consolidate this with parse_chained_expression(). That method consumes the opening paren as
// well, and also requires at least one expression (whereas this allows for an empty chain).
NonnullRefPtrVector<Expression> expressions;
Vector<NonnullRefPtr<Expression>> expressions;
if (!match(TokenType::ParenClose))
parse_comma_separated_list(false, [&]() { expressions.append(parse_expression()); });
@ -884,7 +884,7 @@ NonnullRefPtr<ColumnDefinition> Parser::parse_column_definition()
auto type_name = match(TokenType::Identifier)
? parse_type_name()
// https://www.sqlite.org/datatype3.html: If no type is specified then the column has affinity BLOB.
: create_ast_node<TypeName>("BLOB", NonnullRefPtrVector<SignedNumber> {});
: create_ast_node<TypeName>("BLOB", Vector<NonnullRefPtr<SignedNumber>> {});
// FIXME: Parse "column-constraint".
@ -895,7 +895,7 @@ NonnullRefPtr<TypeName> Parser::parse_type_name()
{
// https: //sqlite.org/syntax/type-name.html
auto name = consume(TokenType::Identifier).value();
NonnullRefPtrVector<SignedNumber> signed_numbers;
Vector<NonnullRefPtr<SignedNumber>> signed_numbers;
if (consume_if(TokenType::ParenOpen)) {
signed_numbers.append(parse_signed_number());
@ -1038,7 +1038,7 @@ NonnullRefPtr<TableOrSubquery> Parser::parse_table_or_subquery()
// FIXME: Parse join-clause.
NonnullRefPtrVector<TableOrSubquery> subqueries;
Vector<NonnullRefPtr<TableOrSubquery>> subqueries;
parse_comma_separated_list(true, [&]() { subqueries.append(parse_table_or_subquery()); });
return create_ast_node<TableOrSubquery>(move(subqueries));

26
Userland/Libraries/LibSQL/AST/Select.cpp
View file

@ -39,41 +39,41 @@ static DeprecatedString result_column_name(ResultColumn const& column, size_t co
ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
{
NonnullRefPtrVector<ResultColumn const> columns;
Vector<NonnullRefPtr<ResultColumn const>> columns;
Vector<DeprecatedString> column_names;
auto const& result_column_list = this->result_column_list();
VERIFY(!result_column_list.is_empty());
for (auto& table_descriptor : table_or_subquery_list()) {
if (!table_descriptor.is_table())
if (!table_descriptor->is_table())
return Result { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv };
auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name()));
auto table_def = TRY(context.database->get_table(table_descriptor->schema_name(), table_descriptor->table_name()));
if (result_column_list.size() == 1 && result_column_list[0].type() == ResultType::All) {
if (result_column_list.size() == 1 && result_column_list[0]->type() == ResultType::All) {
TRY(columns.try_ensure_capacity(columns.size() + table_def->columns().size()));
TRY(column_names.try_ensure_capacity(column_names.size() + table_def->columns().size()));
for (auto& col : table_def->columns()) {
columns.unchecked_append(
create_ast_node<ResultColumn>(
create_ast_node<ColumnNameExpression>(table_def->parent()->name(), table_def->name(), col.name()),
create_ast_node<ColumnNameExpression>(table_def->parent()->name(), table_def->name(), col->name()),
""));
column_names.unchecked_append(col.name());
column_names.unchecked_append(col->name());
}
}
}
if (result_column_list.size() != 1 || result_column_list[0].type() != ResultType::All) {
if (result_column_list.size() != 1 || result_column_list[0]->type() != ResultType::All) {
TRY(columns.try_ensure_capacity(result_column_list.size()));
TRY(column_names.try_ensure_capacity(result_column_list.size()));
for (size_t i = 0; i < result_column_list.size(); ++i) {
auto const& col = result_column_list[i];
if (col.type() == ResultType::All) {
if (col->type() == ResultType::All) {
// FIXME can have '*' for example in conjunction with computed columns
return Result { SQLCommand::Select, SQLErrorCode::SyntaxError, "*"sv };
}
@ -93,10 +93,10 @@ ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
rows.append(tuple);
for (auto& table_descriptor : table_or_subquery_list()) {
if (!table_descriptor.is_table())
if (!table_descriptor->is_table())
return Result { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv };
auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name()));
auto table_def = TRY(context.database->get_table(table_descriptor->schema_name(), table_descriptor->table_name()));
if (table_def->num_columns() == 0)
continue;
@ -118,7 +118,7 @@ ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
bool has_ordering { false };
auto sort_descriptor = adopt_ref(*new TupleDescriptor);
for (auto& term : m_ordering_term_list) {
sort_descriptor->append(TupleElementDescriptor { .order = term.order() });
sort_descriptor->append(TupleElementDescriptor { .order = term->order() });
has_ordering = true;
}
Tuple sort_key(sort_descriptor);
@ -135,14 +135,14 @@ ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
tuple.clear();
for (auto& col : columns) {
auto value = TRY(col.expression()->evaluate(context));
auto value = TRY(col->expression()->evaluate(context));
tuple.append(value);
}
if (has_ordering) {
sort_key.clear();
for (auto& term : m_ordering_term_list) {
auto value = TRY(term.expression()->evaluate(context));
auto value = TRY(term->expression()->evaluate(context));
sort_key.append(value);
}
}