mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 17:47:44 +00:00
Everywhere: Stop using NonnullRefPtrVector
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
parent
104be6c8ac
commit
8a48246ed1
168 changed files with 1280 additions and 1280 deletions
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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()) {
|
||||
|
|
|
|||
|
|
@ -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 {});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ ResultOr<void> Database::add_table(TableDef& table)
|
|||
return Result { SQLCommand::Unknown, SQLErrorCode::TableExists, table.name() };
|
||||
|
||||
for (auto& column : table.columns()) {
|
||||
if (!m_table_columns->insert(column.key()))
|
||||
if (!m_table_columns->insert(column->key()))
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ NonnullRefPtr<TupleDescriptor> IndexDef::to_tuple_descriptor() const
|
|||
{
|
||||
NonnullRefPtr<TupleDescriptor> ret = adopt_ref(*new TupleDescriptor);
|
||||
for (auto& part : m_key_definition) {
|
||||
ret->append({ "", "", part.name(), part.type(), part.sort_order() });
|
||||
ret->append({ "", "", part->name(), part->type(), part->sort_order() });
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -161,7 +161,7 @@ NonnullRefPtr<TupleDescriptor> TableDef::to_tuple_descriptor() const
|
|||
{
|
||||
NonnullRefPtr<TupleDescriptor> ret = adopt_ref(*new TupleDescriptor);
|
||||
for (auto& part : m_columns) {
|
||||
ret->append({ parent()->name(), name(), part.name(), part.type(), Order::Ascending });
|
||||
ret->append({ parent()->name(), name(), part->name(), part->type(), Order::Ascending });
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ class IndexDef : public Relation {
|
|||
public:
|
||||
~IndexDef() override = default;
|
||||
|
||||
NonnullRefPtrVector<KeyPartDef> const& key_definition() const { return m_key_definition; }
|
||||
Vector<NonnullRefPtr<KeyPartDef>> const& key_definition() const { return m_key_definition; }
|
||||
bool unique() const { return m_unique; }
|
||||
[[nodiscard]] size_t size() const { return m_key_definition.size(); }
|
||||
void append_column(DeprecatedString, SQLType, Order = Order::Ascending);
|
||||
|
|
@ -123,7 +123,7 @@ private:
|
|||
IndexDef(TableDef*, DeprecatedString, bool unique = true, u32 pointer = 0);
|
||||
explicit IndexDef(DeprecatedString, bool unique = true, u32 pointer = 0);
|
||||
|
||||
NonnullRefPtrVector<KeyPartDef> m_key_definition;
|
||||
Vector<NonnullRefPtr<KeyPartDef>> m_key_definition;
|
||||
bool m_unique { false };
|
||||
|
||||
friend TableDef;
|
||||
|
|
@ -138,8 +138,8 @@ public:
|
|||
void append_column(Key const&);
|
||||
size_t num_columns() { return m_columns.size(); }
|
||||
size_t num_indexes() { return m_indexes.size(); }
|
||||
NonnullRefPtrVector<ColumnDef> const& columns() const { return m_columns; }
|
||||
NonnullRefPtrVector<IndexDef> const& indexes() const { return m_indexes; }
|
||||
Vector<NonnullRefPtr<ColumnDef>> const& columns() const { return m_columns; }
|
||||
Vector<NonnullRefPtr<IndexDef>> const& indexes() const { return m_indexes; }
|
||||
[[nodiscard]] NonnullRefPtr<TupleDescriptor> to_tuple_descriptor() const;
|
||||
|
||||
static NonnullRefPtr<IndexDef> index_def();
|
||||
|
|
@ -149,8 +149,8 @@ public:
|
|||
private:
|
||||
explicit TableDef(SchemaDef*, DeprecatedString);
|
||||
|
||||
NonnullRefPtrVector<ColumnDef> m_columns;
|
||||
NonnullRefPtrVector<IndexDef> m_indexes;
|
||||
Vector<NonnullRefPtr<ColumnDef>> m_columns;
|
||||
Vector<NonnullRefPtr<IndexDef>> m_indexes;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue