mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 20:37:36 +00:00
Everywhere: Rename {Deprecated => Byte}String
This commit un-deprecates DeprecatedString, and repurposes it as a byte
string.
As the null state has already been removed, there are no other
particularly hairy blockers in repurposing this type as a byte string
(what it _really_ is).
This commit is auto-generated:
$ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \
Meta Ports Ladybird Tests Kernel)
$ perl -pie 's/\bDeprecatedString\b/ByteString/g;
s/deprecated_string/byte_string/g' $xs
$ clang-format --style=file -i \
$(git diff --name-only | grep \.cpp\|\.h)
$ gn format $(git ls-files '*.gn' '*.gni')
This commit is contained in:
Ali Mohammad Pur
Ali Mohammad Pur
parent
38d62563b3
commit
5e1499d104
1615 changed files with 10257 additions and 10257 deletions
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <AK/DeprecatedString.h>
|
||||
#include <AK/ByteString.h>
|
||||
#include <AK/NonnullRefPtr.h>
|
||||
#include <AK/RefCounted.h>
|
||||
#include <AK/RefPtr.h>
|
||||
|
|
@ -54,53 +54,53 @@ private:
|
|||
|
||||
class TypeName : public ASTNode {
|
||||
public:
|
||||
TypeName(DeprecatedString name, Vector<NonnullRefPtr<SignedNumber>> signed_numbers)
|
||||
TypeName(ByteString name, Vector<NonnullRefPtr<SignedNumber>> signed_numbers)
|
||||
: m_name(move(name))
|
||||
, m_signed_numbers(move(signed_numbers))
|
||||
{
|
||||
VERIFY(m_signed_numbers.size() <= 2);
|
||||
}
|
||||
|
||||
DeprecatedString const& name() const { return m_name; }
|
||||
ByteString const& name() const { return m_name; }
|
||||
Vector<NonnullRefPtr<SignedNumber>> const& signed_numbers() const { return m_signed_numbers; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_name;
|
||||
ByteString m_name;
|
||||
Vector<NonnullRefPtr<SignedNumber>> m_signed_numbers;
|
||||
};
|
||||
|
||||
class ColumnDefinition : public ASTNode {
|
||||
public:
|
||||
ColumnDefinition(DeprecatedString name, NonnullRefPtr<TypeName> type_name)
|
||||
ColumnDefinition(ByteString name, NonnullRefPtr<TypeName> type_name)
|
||||
: m_name(move(name))
|
||||
, m_type_name(move(type_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& name() const { return m_name; }
|
||||
ByteString const& name() const { return m_name; }
|
||||
NonnullRefPtr<TypeName> const& type_name() const { return m_type_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_name;
|
||||
ByteString m_name;
|
||||
NonnullRefPtr<TypeName> m_type_name;
|
||||
};
|
||||
|
||||
class CommonTableExpression : public ASTNode {
|
||||
public:
|
||||
CommonTableExpression(DeprecatedString table_name, Vector<DeprecatedString> column_names, NonnullRefPtr<Select> select_statement)
|
||||
CommonTableExpression(ByteString table_name, Vector<ByteString> column_names, NonnullRefPtr<Select> select_statement)
|
||||
: m_table_name(move(table_name))
|
||||
, m_column_names(move(column_names))
|
||||
, m_select_statement(move(select_statement))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
Vector<DeprecatedString> const& column_names() const { return m_column_names; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
Vector<ByteString> const& column_names() const { return m_column_names; }
|
||||
NonnullRefPtr<Select> const& select_statement() const { return m_select_statement; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_table_name;
|
||||
Vector<DeprecatedString> m_column_names;
|
||||
ByteString m_table_name;
|
||||
Vector<ByteString> m_column_names;
|
||||
NonnullRefPtr<Select> m_select_statement;
|
||||
};
|
||||
|
||||
|
|
@ -123,28 +123,28 @@ private:
|
|||
|
||||
class QualifiedTableName : public ASTNode {
|
||||
public:
|
||||
QualifiedTableName(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString alias)
|
||||
QualifiedTableName(ByteString schema_name, ByteString table_name, ByteString alias)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
, m_alias(move(alias))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
DeprecatedString const& alias() const { return m_alias; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
ByteString const& alias() const { return m_alias; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
DeprecatedString m_alias;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
ByteString m_alias;
|
||||
};
|
||||
|
||||
class ReturningClause : public ASTNode {
|
||||
public:
|
||||
struct ColumnClause {
|
||||
NonnullRefPtr<Expression> expression;
|
||||
DeprecatedString column_alias;
|
||||
ByteString column_alias;
|
||||
};
|
||||
|
||||
ReturningClause() = default;
|
||||
|
|
@ -171,13 +171,13 @@ class ResultColumn : public ASTNode {
|
|||
public:
|
||||
ResultColumn() = default;
|
||||
|
||||
explicit ResultColumn(DeprecatedString table_name)
|
||||
explicit ResultColumn(ByteString table_name)
|
||||
: m_type(ResultType::Table)
|
||||
, m_table_name(move(table_name))
|
||||
{
|
||||
}
|
||||
|
||||
ResultColumn(NonnullRefPtr<Expression> expression, DeprecatedString column_alias)
|
||||
ResultColumn(NonnullRefPtr<Expression> expression, ByteString column_alias)
|
||||
: m_type(ResultType::Expression)
|
||||
, m_expression(move(expression))
|
||||
, m_column_alias(move(column_alias))
|
||||
|
|
@ -187,19 +187,19 @@ public:
|
|||
ResultType type() const { return m_type; }
|
||||
|
||||
bool select_from_table() const { return m_table_name.has_value(); }
|
||||
Optional<DeprecatedString> const& table_name() const { return m_table_name; }
|
||||
Optional<ByteString> const& table_name() const { return m_table_name; }
|
||||
|
||||
bool select_from_expression() const { return !m_expression.is_null(); }
|
||||
RefPtr<Expression> const& expression() const { return m_expression; }
|
||||
DeprecatedString const& column_alias() const { return m_column_alias; }
|
||||
ByteString const& column_alias() const { return m_column_alias; }
|
||||
|
||||
private:
|
||||
ResultType m_type { ResultType::All };
|
||||
|
||||
Optional<DeprecatedString> m_table_name {};
|
||||
Optional<ByteString> m_table_name {};
|
||||
|
||||
RefPtr<Expression> m_expression {};
|
||||
DeprecatedString m_column_alias {};
|
||||
ByteString m_column_alias {};
|
||||
};
|
||||
|
||||
class GroupByClause : public ASTNode {
|
||||
|
|
@ -223,7 +223,7 @@ class TableOrSubquery : public ASTNode {
|
|||
public:
|
||||
TableOrSubquery() = default;
|
||||
|
||||
TableOrSubquery(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString table_alias)
|
||||
TableOrSubquery(ByteString schema_name, ByteString table_name, ByteString table_alias)
|
||||
: m_is_table(true)
|
||||
, m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
|
|
@ -238,18 +238,18 @@ public:
|
|||
}
|
||||
|
||||
bool is_table() const { return m_is_table; }
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
DeprecatedString const& table_alias() const { return m_table_alias; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
ByteString const& table_alias() const { return m_table_alias; }
|
||||
|
||||
bool is_subquery() const { return m_is_subquery; }
|
||||
Vector<NonnullRefPtr<TableOrSubquery>> const& subqueries() const { return m_subqueries; }
|
||||
|
||||
private:
|
||||
bool m_is_table { false };
|
||||
DeprecatedString m_schema_name {};
|
||||
DeprecatedString m_table_name {};
|
||||
DeprecatedString m_table_alias {};
|
||||
ByteString m_schema_name {};
|
||||
ByteString m_table_name {};
|
||||
ByteString m_table_alias {};
|
||||
|
||||
bool m_is_subquery { false };
|
||||
Vector<NonnullRefPtr<TableOrSubquery>> m_subqueries {};
|
||||
|
|
@ -257,7 +257,7 @@ private:
|
|||
|
||||
class OrderingTerm : public ASTNode {
|
||||
public:
|
||||
OrderingTerm(NonnullRefPtr<Expression> expression, DeprecatedString collation_name, Order order, Nulls nulls)
|
||||
OrderingTerm(NonnullRefPtr<Expression> expression, ByteString collation_name, Order order, Nulls nulls)
|
||||
: m_expression(move(expression))
|
||||
, m_collation_name(move(collation_name))
|
||||
, m_order(order)
|
||||
|
|
@ -266,13 +266,13 @@ public:
|
|||
}
|
||||
|
||||
NonnullRefPtr<Expression> const& expression() const { return m_expression; }
|
||||
DeprecatedString const& collation_name() const { return m_collation_name; }
|
||||
ByteString const& collation_name() const { return m_collation_name; }
|
||||
Order order() const { return m_order; }
|
||||
Nulls nulls() const { return m_nulls; }
|
||||
|
||||
private:
|
||||
NonnullRefPtr<Expression> m_expression;
|
||||
DeprecatedString m_collation_name;
|
||||
ByteString m_collation_name;
|
||||
Order m_order;
|
||||
Nulls m_nulls;
|
||||
};
|
||||
|
|
@ -331,29 +331,29 @@ private:
|
|||
|
||||
class StringLiteral : public Expression {
|
||||
public:
|
||||
explicit StringLiteral(DeprecatedString value)
|
||||
explicit StringLiteral(ByteString value)
|
||||
: m_value(move(value))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& value() const { return m_value; }
|
||||
ByteString const& value() const { return m_value; }
|
||||
virtual ResultOr<Value> evaluate(ExecutionContext&) const override;
|
||||
|
||||
private:
|
||||
DeprecatedString m_value;
|
||||
ByteString m_value;
|
||||
};
|
||||
|
||||
class BlobLiteral : public Expression {
|
||||
public:
|
||||
explicit BlobLiteral(DeprecatedString value)
|
||||
explicit BlobLiteral(ByteString value)
|
||||
: m_value(move(value))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& value() const { return m_value; }
|
||||
ByteString const& value() const { return m_value; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_value;
|
||||
ByteString m_value;
|
||||
};
|
||||
|
||||
class BooleanLiteral : public Expression {
|
||||
|
|
@ -455,22 +455,22 @@ private:
|
|||
|
||||
class ColumnNameExpression : public Expression {
|
||||
public:
|
||||
ColumnNameExpression(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString column_name)
|
||||
ColumnNameExpression(ByteString schema_name, ByteString table_name, ByteString column_name)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
, m_column_name(move(column_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
DeprecatedString const& column_name() const { return m_column_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
ByteString const& column_name() const { return m_column_name; }
|
||||
virtual ResultOr<Value> evaluate(ExecutionContext&) const override;
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
DeprecatedString m_column_name;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
ByteString m_column_name;
|
||||
};
|
||||
|
||||
#define __enum_UnaryOperator(S) \
|
||||
|
|
@ -641,16 +641,16 @@ private:
|
|||
|
||||
class CollateExpression : public NestedExpression {
|
||||
public:
|
||||
CollateExpression(NonnullRefPtr<Expression> expression, DeprecatedString collation_name)
|
||||
CollateExpression(NonnullRefPtr<Expression> expression, ByteString collation_name)
|
||||
: NestedExpression(move(expression))
|
||||
, m_collation_name(move(collation_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& collation_name() const { return m_collation_name; }
|
||||
ByteString const& collation_name() const { return m_collation_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_collation_name;
|
||||
ByteString m_collation_name;
|
||||
};
|
||||
|
||||
enum class MatchOperator {
|
||||
|
|
@ -738,19 +738,19 @@ private:
|
|||
|
||||
class InTableExpression : public InvertibleNestedExpression {
|
||||
public:
|
||||
InTableExpression(NonnullRefPtr<Expression> expression, DeprecatedString schema_name, DeprecatedString table_name, bool invert_expression)
|
||||
InTableExpression(NonnullRefPtr<Expression> expression, ByteString schema_name, ByteString table_name, bool invert_expression)
|
||||
: InvertibleNestedExpression(move(expression), invert_expression)
|
||||
, m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
};
|
||||
|
||||
//==================================================================================================
|
||||
|
|
@ -772,25 +772,25 @@ class ErrorStatement final : public Statement {
|
|||
|
||||
class CreateSchema : public Statement {
|
||||
public:
|
||||
CreateSchema(DeprecatedString schema_name, bool is_error_if_schema_exists)
|
||||
CreateSchema(ByteString schema_name, bool is_error_if_schema_exists)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_is_error_if_schema_exists(is_error_if_schema_exists)
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
bool is_error_if_schema_exists() const { return m_is_error_if_schema_exists; }
|
||||
|
||||
ResultOr<ResultSet> execute(ExecutionContext&) const override;
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
ByteString m_schema_name;
|
||||
bool m_is_error_if_schema_exists;
|
||||
};
|
||||
|
||||
class CreateTable : public Statement {
|
||||
public:
|
||||
CreateTable(DeprecatedString schema_name, DeprecatedString table_name, RefPtr<Select> select_statement, bool is_temporary, bool is_error_if_table_exists)
|
||||
CreateTable(ByteString schema_name, ByteString table_name, RefPtr<Select> select_statement, bool is_temporary, bool is_error_if_table_exists)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
, m_select_statement(move(select_statement))
|
||||
|
|
@ -799,7 +799,7 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
CreateTable(DeprecatedString schema_name, DeprecatedString table_name, Vector<NonnullRefPtr<ColumnDefinition>> columns, bool is_temporary, bool is_error_if_table_exists)
|
||||
CreateTable(ByteString schema_name, ByteString 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))
|
||||
|
|
@ -808,8 +808,8 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
|
||||
bool has_selection() const { return !m_select_statement.is_null(); }
|
||||
RefPtr<Select> const& select_statement() const { return m_select_statement; }
|
||||
|
|
@ -823,8 +823,8 @@ public:
|
|||
ResultOr<ResultSet> execute(ExecutionContext&) const override;
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
RefPtr<Select> m_select_statement;
|
||||
Vector<NonnullRefPtr<ColumnDefinition>> m_columns;
|
||||
bool m_is_temporary;
|
||||
|
|
@ -833,55 +833,55 @@ private:
|
|||
|
||||
class AlterTable : public Statement {
|
||||
public:
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
|
||||
protected:
|
||||
AlterTable(DeprecatedString schema_name, DeprecatedString table_name)
|
||||
AlterTable(ByteString schema_name, ByteString table_name)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
};
|
||||
|
||||
class RenameTable : public AlterTable {
|
||||
public:
|
||||
RenameTable(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString new_table_name)
|
||||
RenameTable(ByteString schema_name, ByteString table_name, ByteString new_table_name)
|
||||
: AlterTable(move(schema_name), move(table_name))
|
||||
, m_new_table_name(move(new_table_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& new_table_name() const { return m_new_table_name; }
|
||||
ByteString const& new_table_name() const { return m_new_table_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_new_table_name;
|
||||
ByteString m_new_table_name;
|
||||
};
|
||||
|
||||
class RenameColumn : public AlterTable {
|
||||
public:
|
||||
RenameColumn(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString column_name, DeprecatedString new_column_name)
|
||||
RenameColumn(ByteString schema_name, ByteString table_name, ByteString column_name, ByteString new_column_name)
|
||||
: AlterTable(move(schema_name), move(table_name))
|
||||
, m_column_name(move(column_name))
|
||||
, m_new_column_name(move(new_column_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& column_name() const { return m_column_name; }
|
||||
DeprecatedString const& new_column_name() const { return m_new_column_name; }
|
||||
ByteString const& column_name() const { return m_column_name; }
|
||||
ByteString const& new_column_name() const { return m_new_column_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_column_name;
|
||||
DeprecatedString m_new_column_name;
|
||||
ByteString m_column_name;
|
||||
ByteString m_new_column_name;
|
||||
};
|
||||
|
||||
class AddColumn : public AlterTable {
|
||||
public:
|
||||
AddColumn(DeprecatedString schema_name, DeprecatedString table_name, NonnullRefPtr<ColumnDefinition> column)
|
||||
AddColumn(ByteString schema_name, ByteString table_name, NonnullRefPtr<ColumnDefinition> column)
|
||||
: AlterTable(move(schema_name), move(table_name))
|
||||
, m_column(move(column))
|
||||
{
|
||||
|
|
@ -895,34 +895,34 @@ private:
|
|||
|
||||
class DropColumn : public AlterTable {
|
||||
public:
|
||||
DropColumn(DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString column_name)
|
||||
DropColumn(ByteString schema_name, ByteString table_name, ByteString column_name)
|
||||
: AlterTable(move(schema_name), move(table_name))
|
||||
, m_column_name(move(column_name))
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& column_name() const { return m_column_name; }
|
||||
ByteString const& column_name() const { return m_column_name; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_column_name;
|
||||
ByteString m_column_name;
|
||||
};
|
||||
|
||||
class DropTable : public Statement {
|
||||
public:
|
||||
DropTable(DeprecatedString schema_name, DeprecatedString table_name, bool is_error_if_table_does_not_exist)
|
||||
DropTable(ByteString schema_name, ByteString table_name, bool is_error_if_table_does_not_exist)
|
||||
: m_schema_name(move(schema_name))
|
||||
, m_table_name(move(table_name))
|
||||
, m_is_error_if_table_does_not_exist(is_error_if_table_does_not_exist)
|
||||
{
|
||||
}
|
||||
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
bool is_error_if_table_does_not_exist() const { return m_is_error_if_table_does_not_exist; }
|
||||
|
||||
private:
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
bool m_is_error_if_table_does_not_exist;
|
||||
};
|
||||
|
||||
|
|
@ -936,7 +936,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, Vector<NonnullRefPtr<ChainedExpression>> chained_expressions)
|
||||
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, ByteString schema_name, ByteString table_name, ByteString alias, Vector<ByteString> 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))
|
||||
|
|
@ -947,7 +947,7 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString alias, Vector<DeprecatedString> column_names, RefPtr<Select> select_statement)
|
||||
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, ByteString schema_name, ByteString table_name, ByteString alias, Vector<ByteString> column_names, RefPtr<Select> select_statement)
|
||||
: m_common_table_expression_list(move(common_table_expression_list))
|
||||
, m_conflict_resolution(conflict_resolution)
|
||||
, m_schema_name(move(schema_name))
|
||||
|
|
@ -958,7 +958,7 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, DeprecatedString schema_name, DeprecatedString table_name, DeprecatedString alias, Vector<DeprecatedString> column_names)
|
||||
Insert(RefPtr<CommonTableExpressionList> common_table_expression_list, ConflictResolution conflict_resolution, ByteString schema_name, ByteString table_name, ByteString alias, Vector<ByteString> column_names)
|
||||
: m_common_table_expression_list(move(common_table_expression_list))
|
||||
, m_conflict_resolution(conflict_resolution)
|
||||
, m_schema_name(move(schema_name))
|
||||
|
|
@ -970,10 +970,10 @@ public:
|
|||
|
||||
RefPtr<CommonTableExpressionList> const& common_table_expression_list() const { return m_common_table_expression_list; }
|
||||
ConflictResolution conflict_resolution() const { return m_conflict_resolution; }
|
||||
DeprecatedString const& schema_name() const { return m_schema_name; }
|
||||
DeprecatedString const& table_name() const { return m_table_name; }
|
||||
DeprecatedString const& alias() const { return m_alias; }
|
||||
Vector<DeprecatedString> const& column_names() const { return m_column_names; }
|
||||
ByteString const& schema_name() const { return m_schema_name; }
|
||||
ByteString const& table_name() const { return m_table_name; }
|
||||
ByteString const& alias() const { return m_alias; }
|
||||
Vector<ByteString> const& column_names() const { return m_column_names; }
|
||||
|
||||
bool default_values() const { return !has_expressions() && !has_selection(); }
|
||||
|
||||
|
|
@ -988,10 +988,10 @@ public:
|
|||
private:
|
||||
RefPtr<CommonTableExpressionList> m_common_table_expression_list;
|
||||
ConflictResolution m_conflict_resolution;
|
||||
DeprecatedString m_schema_name;
|
||||
DeprecatedString m_table_name;
|
||||
DeprecatedString m_alias;
|
||||
Vector<DeprecatedString> m_column_names;
|
||||
ByteString m_schema_name;
|
||||
ByteString m_table_name;
|
||||
ByteString m_alias;
|
||||
Vector<ByteString> m_column_names;
|
||||
Vector<NonnullRefPtr<ChainedExpression>> m_chained_expressions;
|
||||
RefPtr<Select> m_select_statement;
|
||||
};
|
||||
|
|
@ -999,7 +999,7 @@ private:
|
|||
class Update : public Statement {
|
||||
public:
|
||||
struct UpdateColumns {
|
||||
Vector<DeprecatedString> column_names;
|
||||
Vector<ByteString> column_names;
|
||||
NonnullRefPtr<Expression> expression;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -68,9 +68,9 @@ ResultOr<Value> BinaryOperatorExpression::evaluate(ExecutionContext& context) co
|
|||
return Result { SQLCommand::Unknown, SQLErrorCode::BooleanOperatorTypeMismatch, BinaryOperator_name(type()) };
|
||||
|
||||
AK::StringBuilder builder;
|
||||
builder.append(lhs_value.to_deprecated_string());
|
||||
builder.append(rhs_value.to_deprecated_string());
|
||||
return Value(builder.to_deprecated_string());
|
||||
builder.append(lhs_value.to_byte_string());
|
||||
builder.append(rhs_value.to_byte_string());
|
||||
return Value(builder.to_byte_string());
|
||||
}
|
||||
case BinaryOperator::Multiplication:
|
||||
return lhs_value.multiply(rhs_value);
|
||||
|
|
@ -181,7 +181,7 @@ ResultOr<Value> MatchExpression::evaluate(ExecutionContext& context) const
|
|||
|
||||
char escape_char = '\0';
|
||||
if (escape()) {
|
||||
auto escape_str = TRY(escape()->evaluate(context)).to_deprecated_string();
|
||||
auto escape_str = TRY(escape()->evaluate(context)).to_byte_string();
|
||||
if (escape_str.length() != 1)
|
||||
return Result { SQLCommand::Unknown, SQLErrorCode::SyntaxError, "ESCAPE should be a single character" };
|
||||
escape_char = escape_str[0];
|
||||
|
|
@ -192,7 +192,7 @@ ResultOr<Value> MatchExpression::evaluate(ExecutionContext& context) const
|
|||
bool escaped = false;
|
||||
AK::StringBuilder builder;
|
||||
builder.append('^');
|
||||
for (auto c : rhs_value.to_deprecated_string()) {
|
||||
for (auto c : rhs_value.to_byte_string()) {
|
||||
if (escape() && c == escape_char && !escaped) {
|
||||
escaped = true;
|
||||
} else if (s_posix_basic_metacharacters.contains(c)) {
|
||||
|
|
@ -211,25 +211,25 @@ ResultOr<Value> MatchExpression::evaluate(ExecutionContext& context) const
|
|||
builder.append('$');
|
||||
|
||||
// FIXME: We should probably cache this regex.
|
||||
auto regex = Regex<PosixBasic>(builder.to_deprecated_string());
|
||||
auto result = regex.match(lhs_value.to_deprecated_string(), PosixFlags::Insensitive | PosixFlags::Unicode);
|
||||
auto regex = Regex<PosixBasic>(builder.to_byte_string());
|
||||
auto result = regex.match(lhs_value.to_byte_string(), PosixFlags::Insensitive | PosixFlags::Unicode);
|
||||
return Value(invert_expression() ? !result.success : result.success);
|
||||
}
|
||||
case MatchOperator::Regexp: {
|
||||
Value lhs_value = TRY(lhs()->evaluate(context));
|
||||
Value rhs_value = TRY(rhs()->evaluate(context));
|
||||
|
||||
auto regex = Regex<PosixExtended>(rhs_value.to_deprecated_string());
|
||||
auto regex = Regex<PosixExtended>(rhs_value.to_byte_string());
|
||||
auto err = regex.parser_result.error;
|
||||
if (err != regex::Error::NoError) {
|
||||
StringBuilder builder;
|
||||
builder.append("Regular expression: "sv);
|
||||
builder.append(get_error_string(err));
|
||||
|
||||
return Result { SQLCommand::Unknown, SQLErrorCode::SyntaxError, builder.to_deprecated_string() };
|
||||
return Result { SQLCommand::Unknown, SQLErrorCode::SyntaxError, builder.to_byte_string() };
|
||||
}
|
||||
|
||||
auto result = regex.match(lhs_value.to_deprecated_string(), PosixFlags::Insensitive | PosixFlags::Unicode);
|
||||
auto result = regex.match(lhs_value.to_byte_string(), PosixFlags::Insensitive | PosixFlags::Unicode);
|
||||
return Value(invert_expression() ? !result.success : result.success);
|
||||
}
|
||||
case MatchOperator::Glob:
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ ResultOr<ResultSet> Insert::execute(ExecutionContext& context) const
|
|||
auto values = row_value.to_vector().release_value();
|
||||
|
||||
if (m_column_names.is_empty() && values.size() != row.size())
|
||||
return Result { SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, DeprecatedString::empty() };
|
||||
return Result { SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, ByteString::empty() };
|
||||
|
||||
for (auto ix = 0u; ix < values.size(); ix++) {
|
||||
auto& tuple_descriptor = *row.descriptor();
|
||||
|
|
|
|||
|
|
@ -11,9 +11,9 @@
|
|||
|
||||
namespace SQL::AST {
|
||||
|
||||
HashMap<DeprecatedString, TokenType> Lexer::s_keywords;
|
||||
HashMap<ByteString, TokenType> Lexer::s_keywords;
|
||||
HashMap<char, TokenType> Lexer::s_one_char_tokens;
|
||||
HashMap<DeprecatedString, TokenType> Lexer::s_two_char_tokens;
|
||||
HashMap<ByteString, TokenType> Lexer::s_two_char_tokens;
|
||||
|
||||
Lexer::Lexer(StringView source)
|
||||
: m_source(source)
|
||||
|
|
@ -109,7 +109,7 @@ Token Lexer::next()
|
|||
}
|
||||
}
|
||||
|
||||
Token token(token_type, current_token.to_deprecated_string(),
|
||||
Token token(token_type, current_token.to_byte_string(),
|
||||
{ value_start_line_number, value_start_column_number },
|
||||
{ m_line_number, m_line_column });
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
#pragma once
|
||||
|
||||
#include "Token.h"
|
||||
#include <AK/DeprecatedString.h>
|
||||
#include <AK/ByteString.h>
|
||||
#include <AK/HashMap.h>
|
||||
#include <AK/StringView.h>
|
||||
|
||||
|
|
@ -46,9 +46,9 @@ private:
|
|||
bool is_line_break() const;
|
||||
bool is_eof() const;
|
||||
|
||||
static HashMap<DeprecatedString, TokenType> s_keywords;
|
||||
static HashMap<ByteString, TokenType> s_keywords;
|
||||
static HashMap<char, TokenType> s_one_char_tokens;
|
||||
static HashMap<DeprecatedString, TokenType> s_two_char_tokens;
|
||||
static HashMap<ByteString, TokenType> s_two_char_tokens;
|
||||
|
||||
StringView m_source;
|
||||
size_t m_line_number { 1 };
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ NonnullRefPtr<CreateSchema> Parser::parse_create_schema_statement()
|
|||
is_error_if_exists = false;
|
||||
}
|
||||
|
||||
DeprecatedString schema_name = consume(TokenType::Identifier).value();
|
||||
ByteString schema_name = consume(TokenType::Identifier).value();
|
||||
return create_ast_node<CreateSchema>(move(schema_name), is_error_if_exists);
|
||||
}
|
||||
|
||||
|
|
@ -112,8 +112,8 @@ NonnullRefPtr<CreateTable> Parser::parse_create_table_statement()
|
|||
is_error_if_table_exists = false;
|
||||
}
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
if (consume_if(TokenType::As)) {
|
||||
|
|
@ -135,8 +135,8 @@ NonnullRefPtr<AlterTable> Parser::parse_alter_table_statement()
|
|||
consume(TokenType::Alter);
|
||||
consume(TokenType::Table);
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
if (consume_if(TokenType::Add)) {
|
||||
|
|
@ -177,8 +177,8 @@ NonnullRefPtr<DropTable> Parser::parse_drop_table_statement()
|
|||
is_error_if_table_does_not_exist = false;
|
||||
}
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
return create_ast_node<DropTable>(move(schema_name), move(table_name), is_error_if_table_does_not_exist);
|
||||
|
|
@ -201,15 +201,15 @@ NonnullRefPtr<Insert> Parser::parse_insert_statement(RefPtr<CommonTableExpressio
|
|||
auto conflict_resolution = parse_conflict_resolution();
|
||||
consume(TokenType::Into);
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
DeprecatedString alias;
|
||||
ByteString alias;
|
||||
if (consume_if(TokenType::As))
|
||||
alias = consume(TokenType::Identifier).value();
|
||||
|
||||
Vector<DeprecatedString> column_names;
|
||||
Vector<ByteString> column_names;
|
||||
if (match(TokenType::ParenOpen))
|
||||
parse_comma_separated_list(true, [&]() { column_names.append(consume(TokenType::Identifier).value()); });
|
||||
|
||||
|
|
@ -260,7 +260,7 @@ NonnullRefPtr<Update> Parser::parse_update_statement(RefPtr<CommonTableExpressio
|
|||
|
||||
Vector<Update::UpdateColumns> update_columns;
|
||||
parse_comma_separated_list(false, [&]() {
|
||||
Vector<DeprecatedString> column_names;
|
||||
Vector<ByteString> column_names;
|
||||
if (match(TokenType::ParenOpen)) {
|
||||
parse_comma_separated_list(true, [&]() { column_names.append(consume(TokenType::Identifier).value()); });
|
||||
} else {
|
||||
|
|
@ -391,7 +391,7 @@ RefPtr<CommonTableExpressionList> Parser::parse_common_table_expression_list()
|
|||
NonnullRefPtr<Expression> Parser::parse_expression()
|
||||
{
|
||||
if (++m_parser_state.m_current_expression_depth > Limits::maximum_expression_tree_depth) {
|
||||
syntax_error(DeprecatedString::formatted("Exceeded maximum expression tree depth of {}", Limits::maximum_expression_tree_depth));
|
||||
syntax_error(ByteString::formatted("Exceeded maximum expression tree depth of {}", Limits::maximum_expression_tree_depth));
|
||||
return create_ast_node<ErrorExpression>();
|
||||
}
|
||||
|
||||
|
|
@ -558,7 +558,7 @@ RefPtr<Expression> Parser::parse_bind_parameter_expression()
|
|||
if (consume_if(TokenType::Placeholder)) {
|
||||
auto parameter = m_parser_state.m_bound_parameters;
|
||||
if (++m_parser_state.m_bound_parameters > Limits::maximum_bound_parameters)
|
||||
syntax_error(DeprecatedString::formatted("Exceeded maximum number of bound parameters {}", Limits::maximum_bound_parameters));
|
||||
syntax_error(ByteString::formatted("Exceeded maximum number of bound parameters {}", Limits::maximum_bound_parameters));
|
||||
|
||||
return create_ast_node<Placeholder>(parameter);
|
||||
}
|
||||
|
|
@ -566,23 +566,23 @@ RefPtr<Expression> Parser::parse_bind_parameter_expression()
|
|||
return {};
|
||||
}
|
||||
|
||||
RefPtr<Expression> Parser::parse_column_name_expression(Optional<DeprecatedString> with_parsed_identifier, bool with_parsed_period)
|
||||
RefPtr<Expression> Parser::parse_column_name_expression(Optional<ByteString> with_parsed_identifier, bool with_parsed_period)
|
||||
{
|
||||
if (!with_parsed_identifier.has_value() && !match(TokenType::Identifier))
|
||||
return {};
|
||||
|
||||
DeprecatedString first_identifier;
|
||||
ByteString first_identifier;
|
||||
if (!with_parsed_identifier.has_value())
|
||||
first_identifier = consume(TokenType::Identifier).value();
|
||||
else
|
||||
first_identifier = with_parsed_identifier.release_value();
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
DeprecatedString column_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
ByteString column_name;
|
||||
|
||||
if (with_parsed_period || consume_if(TokenType::Period)) {
|
||||
DeprecatedString second_identifier = consume(TokenType::Identifier).value();
|
||||
ByteString second_identifier = consume(TokenType::Identifier).value();
|
||||
|
||||
if (consume_if(TokenType::Period)) {
|
||||
schema_name = move(first_identifier);
|
||||
|
|
@ -762,7 +762,7 @@ RefPtr<Expression> Parser::parse_collate_expression(NonnullRefPtr<Expression> ex
|
|||
return {};
|
||||
|
||||
consume();
|
||||
DeprecatedString collation_name = consume(TokenType::Identifier).value();
|
||||
ByteString collation_name = consume(TokenType::Identifier).value();
|
||||
|
||||
return create_ast_node<CollateExpression>(move(expression), move(collation_name));
|
||||
}
|
||||
|
|
@ -879,8 +879,8 @@ RefPtr<Expression> Parser::parse_in_expression(NonnullRefPtr<Expression> express
|
|||
return create_ast_node<InChainedExpression>(move(expression), move(chain), invert_expression);
|
||||
}
|
||||
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
if (match(TokenType::ParenOpen)) {
|
||||
|
|
@ -948,7 +948,7 @@ NonnullRefPtr<CommonTableExpression> Parser::parse_common_table_expression()
|
|||
// https://sqlite.org/syntax/common-table-expression.html
|
||||
auto table_name = consume(TokenType::Identifier).value();
|
||||
|
||||
Vector<DeprecatedString> column_names;
|
||||
Vector<ByteString> column_names;
|
||||
if (match(TokenType::ParenOpen))
|
||||
parse_comma_separated_list(true, [&]() { column_names.append(consume(TokenType::Identifier).value()); });
|
||||
|
||||
|
|
@ -963,11 +963,11 @@ NonnullRefPtr<CommonTableExpression> Parser::parse_common_table_expression()
|
|||
NonnullRefPtr<QualifiedTableName> Parser::parse_qualified_table_name()
|
||||
{
|
||||
// https://sqlite.org/syntax/qualified-table-name.html
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
DeprecatedString alias;
|
||||
ByteString alias;
|
||||
if (consume_if(TokenType::As))
|
||||
alias = consume(TokenType::Identifier).value();
|
||||
|
||||
|
|
@ -991,7 +991,7 @@ NonnullRefPtr<ReturningClause> Parser::parse_returning_clause()
|
|||
parse_comma_separated_list(false, [&]() {
|
||||
auto expression = parse_expression();
|
||||
|
||||
DeprecatedString column_alias;
|
||||
ByteString column_alias;
|
||||
if (consume_if(TokenType::As) || match(TokenType::Identifier))
|
||||
column_alias = consume(TokenType::Identifier).value();
|
||||
|
||||
|
|
@ -1010,7 +1010,7 @@ NonnullRefPtr<ResultColumn> Parser::parse_result_column()
|
|||
// If we match an identifier now, we don't know whether it is a table-name of the form "table-name.*", or if it is the start of a
|
||||
// column-name-expression, until we try to parse the asterisk. So if we consume an identifier and a period, but don't find an
|
||||
// asterisk, hold onto that information to form a column-name-expression later.
|
||||
Optional<DeprecatedString> table_name;
|
||||
Optional<ByteString> table_name;
|
||||
bool parsed_period = false;
|
||||
|
||||
if (match(TokenType::Identifier)) {
|
||||
|
|
@ -1024,7 +1024,7 @@ NonnullRefPtr<ResultColumn> Parser::parse_result_column()
|
|||
? parse_expression()
|
||||
: static_cast<NonnullRefPtr<Expression>>(*parse_column_name_expression(move(table_name), parsed_period));
|
||||
|
||||
DeprecatedString column_alias;
|
||||
ByteString column_alias;
|
||||
if (consume_if(TokenType::As) || match(TokenType::Identifier))
|
||||
column_alias = consume(TokenType::Identifier).value();
|
||||
|
||||
|
|
@ -1034,17 +1034,17 @@ NonnullRefPtr<ResultColumn> Parser::parse_result_column()
|
|||
NonnullRefPtr<TableOrSubquery> Parser::parse_table_or_subquery()
|
||||
{
|
||||
if (++m_parser_state.m_current_subquery_depth > Limits::maximum_subquery_depth)
|
||||
syntax_error(DeprecatedString::formatted("Exceeded maximum subquery depth of {}", Limits::maximum_subquery_depth));
|
||||
syntax_error(ByteString::formatted("Exceeded maximum subquery depth of {}", Limits::maximum_subquery_depth));
|
||||
|
||||
ScopeGuard guard([&]() { --m_parser_state.m_current_subquery_depth; });
|
||||
|
||||
// https://sqlite.org/syntax/table-or-subquery.html
|
||||
if (match(TokenType::Identifier)) {
|
||||
DeprecatedString schema_name;
|
||||
DeprecatedString table_name;
|
||||
ByteString schema_name;
|
||||
ByteString table_name;
|
||||
parse_schema_and_table_name(schema_name, table_name);
|
||||
|
||||
DeprecatedString table_alias;
|
||||
ByteString table_alias;
|
||||
if (consume_if(TokenType::As) || match(TokenType::Identifier))
|
||||
table_alias = consume(TokenType::Identifier).value();
|
||||
|
||||
|
|
@ -1064,7 +1064,7 @@ NonnullRefPtr<OrderingTerm> Parser::parse_ordering_term()
|
|||
// https://sqlite.org/syntax/ordering-term.html
|
||||
auto expression = parse_expression();
|
||||
|
||||
DeprecatedString collation_name;
|
||||
ByteString collation_name;
|
||||
if (is<CollateExpression>(*expression)) {
|
||||
auto const& collate = static_cast<CollateExpression const&>(*expression);
|
||||
collation_name = collate.collation_name();
|
||||
|
|
@ -1089,9 +1089,9 @@ NonnullRefPtr<OrderingTerm> Parser::parse_ordering_term()
|
|||
return create_ast_node<OrderingTerm>(move(expression), move(collation_name), order, nulls);
|
||||
}
|
||||
|
||||
void Parser::parse_schema_and_table_name(DeprecatedString& schema_name, DeprecatedString& table_name)
|
||||
void Parser::parse_schema_and_table_name(ByteString& schema_name, ByteString& table_name)
|
||||
{
|
||||
DeprecatedString schema_or_table_name = consume(TokenType::Identifier).value();
|
||||
ByteString schema_or_table_name = consume(TokenType::Identifier).value();
|
||||
|
||||
if (consume_if(TokenType::Period)) {
|
||||
schema_name = move(schema_or_table_name);
|
||||
|
|
@ -1153,10 +1153,10 @@ bool Parser::match(TokenType type) const
|
|||
|
||||
void Parser::expected(StringView what)
|
||||
{
|
||||
syntax_error(DeprecatedString::formatted("Unexpected token {}, expected {}", m_parser_state.m_token.name(), what));
|
||||
syntax_error(ByteString::formatted("Unexpected token {}, expected {}", m_parser_state.m_token.name(), what));
|
||||
}
|
||||
|
||||
void Parser::syntax_error(DeprecatedString message)
|
||||
void Parser::syntax_error(ByteString message)
|
||||
{
|
||||
m_parser_state.m_errors.append({ move(message), position() });
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <AK/DeprecatedString.h>
|
||||
#include <AK/ByteString.h>
|
||||
#include <AK/StringView.h>
|
||||
#include <LibSQL/AST/AST.h>
|
||||
#include <LibSQL/AST/Lexer.h>
|
||||
|
|
@ -24,12 +24,12 @@ constexpr size_t maximum_bound_parameters = 1000;
|
|||
|
||||
class Parser {
|
||||
struct Error {
|
||||
DeprecatedString message;
|
||||
ByteString message;
|
||||
SourcePosition position;
|
||||
|
||||
DeprecatedString to_deprecated_string() const
|
||||
ByteString to_byte_string() const
|
||||
{
|
||||
return DeprecatedString::formatted("{} (line: {}, column: {})", message, position.line, position.column);
|
||||
return ByteString::formatted("{} (line: {}, column: {})", message, position.line, position.column);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ private:
|
|||
bool match_secondary_expression() const;
|
||||
RefPtr<Expression> parse_literal_value_expression();
|
||||
RefPtr<Expression> parse_bind_parameter_expression();
|
||||
RefPtr<Expression> parse_column_name_expression(Optional<DeprecatedString> with_parsed_identifier = {}, bool with_parsed_period = false);
|
||||
RefPtr<Expression> parse_column_name_expression(Optional<ByteString> with_parsed_identifier = {}, bool with_parsed_period = false);
|
||||
RefPtr<Expression> parse_unary_operator_expression();
|
||||
RefPtr<Expression> parse_binary_operator_expression(NonnullRefPtr<Expression> lhs);
|
||||
RefPtr<Expression> parse_chained_expression(bool surrounded_by_parentheses = true);
|
||||
|
|
@ -97,7 +97,7 @@ private:
|
|||
NonnullRefPtr<ResultColumn> parse_result_column();
|
||||
NonnullRefPtr<TableOrSubquery> parse_table_or_subquery();
|
||||
NonnullRefPtr<OrderingTerm> parse_ordering_term();
|
||||
void parse_schema_and_table_name(DeprecatedString& schema_name, DeprecatedString& table_name);
|
||||
void parse_schema_and_table_name(ByteString& schema_name, ByteString& table_name);
|
||||
ConflictResolution parse_conflict_resolution();
|
||||
|
||||
template<typename ParseCallback>
|
||||
|
|
@ -125,7 +125,7 @@ private:
|
|||
bool match(TokenType type) const;
|
||||
|
||||
void expected(StringView what);
|
||||
void syntax_error(DeprecatedString message);
|
||||
void syntax_error(ByteString message);
|
||||
|
||||
SourcePosition position() const;
|
||||
|
||||
|
|
|
|||
|
|
@ -12,10 +12,10 @@
|
|||
|
||||
namespace SQL::AST {
|
||||
|
||||
static DeprecatedString result_column_name(ResultColumn const& column, size_t column_index)
|
||||
static ByteString result_column_name(ResultColumn const& column, size_t column_index)
|
||||
{
|
||||
auto fallback_column_name = [column_index]() {
|
||||
return DeprecatedString::formatted("Column{}", column_index);
|
||||
return ByteString::formatted("Column{}", column_index);
|
||||
};
|
||||
|
||||
if (auto const& alias = column.column_alias(); !alias.is_empty())
|
||||
|
|
@ -40,7 +40,7 @@ static DeprecatedString result_column_name(ResultColumn const& column, size_t co
|
|||
ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
|
||||
{
|
||||
Vector<NonnullRefPtr<ResultColumn const>> columns;
|
||||
Vector<DeprecatedString> column_names;
|
||||
Vector<ByteString> column_names;
|
||||
|
||||
auto const& result_column_list = this->result_column_list();
|
||||
VERIFY(!result_column_list.is_empty());
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
#include "Token.h"
|
||||
#include <AK/Assertions.h>
|
||||
#include <AK/DeprecatedString.h>
|
||||
#include <AK/ByteString.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
namespace SQL::AST {
|
||||
|
|
@ -40,7 +40,7 @@ TokenCategory Token::category(TokenType type)
|
|||
double Token::double_value() const
|
||||
{
|
||||
VERIFY(type() == TokenType::NumericLiteral);
|
||||
DeprecatedString value(m_value);
|
||||
ByteString value(m_value);
|
||||
|
||||
if (value[0] == '0' && value.length() >= 2) {
|
||||
if (value[1] == 'x' || value[1] == 'X')
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <AK/DeprecatedString.h>
|
||||
#include <AK/ByteString.h>
|
||||
#include <AK/HashMap.h>
|
||||
#include <AK/StringView.h>
|
||||
|
||||
|
|
@ -224,7 +224,7 @@ struct SourcePosition {
|
|||
|
||||
class Token {
|
||||
public:
|
||||
Token(TokenType type, DeprecatedString value, SourcePosition start_position, SourcePosition end_position)
|
||||
Token(TokenType type, ByteString value, SourcePosition start_position, SourcePosition end_position)
|
||||
: m_type(type)
|
||||
, m_value(move(value))
|
||||
, m_start_position(start_position)
|
||||
|
|
@ -239,7 +239,7 @@ public:
|
|||
TokenType type() const { return m_type; }
|
||||
TokenCategory category() const { return category(m_type); }
|
||||
|
||||
DeprecatedString const& value() const { return m_value; }
|
||||
ByteString const& value() const { return m_value; }
|
||||
double double_value() const;
|
||||
|
||||
SourcePosition const& start_position() const { return m_start_position; }
|
||||
|
|
@ -247,7 +247,7 @@ public:
|
|||
|
||||
private:
|
||||
TokenType m_type;
|
||||
DeprecatedString m_value;
|
||||
ByteString m_value;
|
||||
SourcePosition m_start_position;
|
||||
SourcePosition m_end_position;
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue