sascha
/
rsql-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

some renamings for clarity and consistency

This commit is contained in:
Sascha Kühl 2026-03-08 19:27:52 +01:00
parent 86c8a11074
commit 21fc06173e
7 changed files with 80 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
include/matador/rsql/binary_condition_node.hpp
View File

@ -8,25 +8,25 @@
namespace matador::rsql { namespace matador::rsql {
enum class binary_operator { enum class binary_operator {
EQUALS, Equals,
NOT_EQUALS, NotEquals,
GREATER_THAN, GreaterThan,
GREATER_THAN_OR_EQUAL, GreaterThanOrEqual,
LESS_THAN, LessThan,
LESS_THAN_OR_EQUAL, LessThanOrEqual,
}; };
static const std::map<std::string, binary_operator> binary_operators = { static const std::map<std::string, binary_operator> binary_operators = {
{ "==", binary_operator::EQUALS }, { "==", binary_operator::Equals },
{ "!=", binary_operator::NOT_EQUALS }, { "!=", binary_operator::NotEquals },
{ ">", binary_operator::GREATER_THAN }, { ">", binary_operator::GreaterThan },
{ "=gt*", binary_operator::GREATER_THAN }, { "=gt*", binary_operator::GreaterThan },
{ ">=", binary_operator::GREATER_THAN_OR_EQUAL }, { ">=", binary_operator::GreaterThanOrEqual },
{ "=ge=", binary_operator::GREATER_THAN_OR_EQUAL }, { "=ge=", binary_operator::GreaterThanOrEqual },
{ "<", binary_operator::LESS_THAN }, { "<", binary_operator::LessThan },
{ "=lt=", binary_operator::LESS_THAN }, { "=lt=", binary_operator::LessThan },
{ "<=", binary_operator::LESS_THAN_OR_EQUAL }, { "<=", binary_operator::LessThanOrEqual },
{ "=le=", binary_operator::LESS_THAN_OR_EQUAL } { "=le=", binary_operator::LessThanOrEqual }
}; };
class node_visitor; class node_visitor;
@ -36,9 +36,9 @@ public:
void accept(node_visitor& visitor) const override; void accept(node_visitor& visitor) const override;
const std::string& field() const; [[nodiscard]] const std::string& field() const;
binary_operator operand() const; [[nodiscard]] binary_operator operand() const;
const std::string& value() const; [[nodiscard]] const std::string& value() const;
private: private:
std::string field_; std::string field_;

14
include/matador/rsql/collection_condition_node.hpp
View File

@ -9,13 +9,13 @@
namespace matador::rsql { namespace matador::rsql {
enum class collection_operator { enum class collection_operator {
IN, In,
OUT Out
}; };
static const std::map<std::string, collection_operator> collection_operators = { static const std::map<std::string, collection_operator> collection_operators = {
{ "=in=", collection_operator::IN }, { "=in=", collection_operator::In },
{ "=out=", collection_operator::OUT } { "=out=", collection_operator::Out }
}; };
@ -25,9 +25,9 @@ public:
void accept(node_visitor& visitor) const override; void accept(node_visitor& visitor) const override;
const std::string& field() const; [[nodiscard]] const std::string& field() const;
collection_operator operand() const; [[nodiscard]] collection_operator operand() const;
const std::vector<std::string>& values() const; [[nodiscard]] const std::vector<std::string>& values() const;
private: private:
std::string field_; std::string field_;

8
include/matador/rsql/logical_node.hpp
View File

@ -9,8 +9,8 @@
namespace matador::rsql { namespace matador::rsql {
enum class logical_operator { enum class logical_operator {
AND, And,
OR, Or,
}; };
class node_visitor; class node_visitor;
@ -20,8 +20,8 @@ public:
explicit logical_node(logical_operator op); explicit logical_node(logical_operator op);
void accept(node_visitor& visitor) const override; void accept(node_visitor& visitor) const override;
const std::vector<std::shared_ptr<node>>& children() const; [[nodiscard]] const std::vector<std::shared_ptr<node>>& children() const;
logical_operator operand() const; [[nodiscard]] logical_operator operand() const;
private: private:
friend class parser; friend class parser;

16
include/matador/rsql/token_type.hpp
View File

@ -3,14 +3,14 @@
namespace matador::rsql { namespace matador::rsql {
enum class token_type { enum class token_type {
IDENTIFIER, Identifier,
OPERATOR, Operator,
VALUE, Value,
LOGICAL_AND, LogicalAnd,
LOGICAL_OR, LogicalOr,
OPEN_PAREN, OpenParen,
CLOSE_PAREN, CloseParen,
UNKNOWN Unknown
}; };
} }

36
src/main.cpp
View File

@ -25,7 +25,7 @@ public:
} }
void visit(const matador::rsql::logical_node& node) override { void visit(const matador::rsql::logical_node& node) override {
std::cout << "Logical (" << (node.operand() == matador::rsql::logical_operator::AND ? "AND" : "OR") << ")\n"; std::cout << "Logical (" << (node.operand() == matador::rsql::logical_operator::And ? "AND" : "OR") << ")\n";
for (const auto& child : node.children()) { for (const auto& child : node.children()) {
child->accept(*this); child->accept(*this);
} }
@ -34,12 +34,12 @@ public:
private: private:
static std::string to_string(const matador::rsql::binary_operator op) { static std::string to_string(const matador::rsql::binary_operator op) {
static std::map<matador::rsql::binary_operator, std::string> bin_to_string { static std::map<matador::rsql::binary_operator, std::string> bin_to_string {
{ matador::rsql::binary_operator::EQUALS, "==" }, { matador::rsql::binary_operator::Equals, "==" },
{ matador::rsql::binary_operator::NOT_EQUALS, "!=" }, { matador::rsql::binary_operator::NotEquals, "!=" },
{ matador::rsql::binary_operator::GREATER_THAN, ">" }, { matador::rsql::binary_operator::GreaterThan, ">" },
{ matador::rsql::binary_operator::GREATER_THAN_OR_EQUAL, ">=" }, { matador::rsql::binary_operator::GreaterThanOrEqual, ">=" },
{ matador::rsql::binary_operator::LESS_THAN, "<" }, { matador::rsql::binary_operator::LessThan, "<" },
{ matador::rsql::binary_operator::LESS_THAN_OR_EQUAL, "<=" }, { matador::rsql::binary_operator::LessThanOrEqual, "<=" },
}; };
return bin_to_string.at(op); return bin_to_string.at(op);
@ -47,8 +47,8 @@ private:
static std::string to_string(const matador::rsql::collection_operator op) { static std::string to_string(const matador::rsql::collection_operator op) {
static std::map<matador::rsql::collection_operator, std::string> col_to_string { static std::map<matador::rsql::collection_operator, std::string> col_to_string {
{ matador::rsql::collection_operator::IN, "=IN=" }, { matador::rsql::collection_operator::In, "=IN=" },
{ matador::rsql::collection_operator::OUT, "=OUT=" } { matador::rsql::collection_operator::Out, "=OUT=" }
}; };
return col_to_string.at(op); return col_to_string.at(op);
@ -76,7 +76,7 @@ public:
child->accept(sub); child->accept(sub);
parts.push_back(sub.result); parts.push_back(sub.result);
} }
const std::string operand = (node.operand() == matador::rsql::logical_operator::AND ? " AND " : " OR "); const std::string operand = (node.operand() == matador::rsql::logical_operator::And ? " AND " : " OR ");
result += "("; result += "(";
for (size_t i = 0; i < parts.size(); ++i) { for (size_t i = 0; i < parts.size(); ++i) {
result += parts[i]; result += parts[i];
@ -130,17 +130,17 @@ private:
static std::string binary_op_string(const matador::rsql::binary_operator op, const std::string& val) { static std::string binary_op_string(const matador::rsql::binary_operator op, const std::string& val) {
using namespace matador::rsql; using namespace matador::rsql;
switch (op) { switch (op) {
case binary_operator::EQUALS: case binary_operator::Equals:
return "= " + quote(val); return "= " + quote(val);
case binary_operator::NOT_EQUALS: case binary_operator::NotEquals:
return "<> " + quote(val); return "<> " + quote(val);
case binary_operator::GREATER_THAN: case binary_operator::GreaterThan:
return "> " + quote(val); return "> " + quote(val);
case binary_operator::GREATER_THAN_OR_EQUAL: case binary_operator::GreaterThanOrEqual:
return ">= " + quote(val); return ">= " + quote(val);
case binary_operator::LESS_THAN: case binary_operator::LessThan:
return "< " + quote(val); return "< " + quote(val);
case binary_operator::LESS_THAN_OR_EQUAL: case binary_operator::LessThanOrEqual:
return "<= " + quote(val); return "<= " + quote(val);
default: default:
return "??"; return "??";
@ -149,7 +149,7 @@ private:
static std::string collection_op_string(const matador::rsql::collection_operator op, const std::vector<std::string>& list) { static std::string collection_op_string(const matador::rsql::collection_operator op, const std::vector<std::string>& list) {
if (list.empty()) { if (list.empty()) {
return (op == matador::rsql::collection_operator::OUT ? "NOT IN (NULL)" : "IN (NULL)"); return (op == matador::rsql::collection_operator::Out ? "NOT IN (NULL)" : "IN (NULL)");
} }
std::string joined; std::string joined;
joined += "("; joined += "(";
@ -158,7 +158,7 @@ private:
if (i + 1 < list.size()) joined += ", "; if (i + 1 < list.size()) joined += ", ";
} }
joined += ")"; joined += ")";
if (op == matador::rsql::collection_operator::OUT) { if (op == matador::rsql::collection_operator::Out) {
return "IN " + joined; return "IN " + joined;
} }
return "NOT IN " + joined; return "NOT IN " + joined;

22
src/rsql/lexer.cpp
View File

@ -6,30 +6,30 @@ std::vector<token> tokenize( const std::string& input ) {
std::vector<token> tokens; std::vector<token> tokens;
// Pattern catches: =in=, =out=, operators, quoted strings, identifiers, parentheses, commas/semicolons // Pattern catches: =in=, =out=, operators, quoted strings, identifiers, parentheses, commas/semicolons
std::regex tokenRegex(R"((=in=|=out=|[=!><~]+)|('[^']*'|"[^"]*")|(\()|(\))|(;|,)|([A-Za-z_]\w*)|([^ \t\n\r]+))"); const std::regex tokenRegex(R"((=in=|=out=|[=!><~]+)|('[^']*'|"[^"]*")|(\()|(\))|(;|,)|([A-Za-z_]\w*)|([^ \t\n\r]+))");
auto begin = std::sregex_iterator(input.begin(), input.end(), tokenRegex); const auto begin = std::sregex_iterator(input.begin(), input.end(), tokenRegex);
auto end = std::sregex_iterator(); const auto end = std::sregex_iterator();
for (auto it = begin; it != end; ++it) { for (auto it = begin; it != end; ++it) {
const std::smatch& m = *it; const std::smatch& m = *it;
if (std::string match = m.str(); match == ";") { if (std::string match = m.str(); match == ";") {
tokens.push_back({token_type::LOGICAL_AND, match}); tokens.push_back({token_type::LogicalAnd, match});
} else if (match == ",") { } else if (match == ",") {
tokens.push_back({token_type::LOGICAL_OR, match}); tokens.push_back({token_type::LogicalOr, match});
} else if (match == "(") { } else if (match == "(") {
tokens.push_back({token_type::OPEN_PAREN, match}); tokens.push_back({token_type::OpenParen, match});
} else if (match == ")") { } else if (match == ")") {
tokens.push_back({token_type::CLOSE_PAREN, match}); tokens.push_back({token_type::CloseParen, match});
} else if (std::regex_match(match, std::regex(R"(=in=|=out=|[=!><~]+)"))) { } else if (std::regex_match(match, std::regex(R"(=in=|=out=|[=!><~]+)"))) {
tokens.push_back({token_type::OPERATOR, match}); tokens.push_back({token_type::Operator, match});
} else if ((match.size() >= 2 && ((match.front() == '\'' && match.back() == '\'') || } else if ((match.size() >= 2 && ((match.front() == '\'' && match.back() == '\'') ||
(match.front() == '"' && match.back() == '"')))) { (match.front() == '"' && match.back() == '"')))) {
tokens.push_back({token_type::VALUE, match.substr(1, match.size() - 2)}); tokens.push_back({token_type::Value, match.substr(1, match.size() - 2)});
} else if (std::regex_match(match, std::regex(R"([A-Za-z_]\w*)"))) { } else if (std::regex_match(match, std::regex(R"([A-Za-z_]\w*)"))) {
tokens.push_back({token_type::IDENTIFIER, match}); tokens.push_back({token_type::Identifier, match});
} else { } else {
tokens.push_back({token_type::VALUE, match}); tokens.push_back({token_type::Value, match});
} }
} }

26
src/rsql/parser.cpp
View File

@ -25,9 +25,9 @@ std::shared_ptr<node> parser::parse() {
std::shared_ptr<node> parser::parse_or_expression() { std::shared_ptr<node> parser::parse_or_expression() {
auto node = parse_and_expression(); auto node = parse_and_expression();
while (match({token_type::LOGICAL_OR})) { while (match({token_type::LogicalOr})) {
std::string op = previous().value; std::string op = previous().value;
const auto logical = std::make_shared<logical_node>(logical_operator::OR); const auto logical = std::make_shared<logical_node>(logical_operator::Or);
logical->children_.push_back(node); logical->children_.push_back(node);
logical->children_.push_back(parse_and_expression()); logical->children_.push_back(parse_and_expression());
node = logical; node = logical;
@ -37,9 +37,9 @@ std::shared_ptr<node> parser::parse_or_expression() {
std::shared_ptr<node> parser::parse_and_expression() { std::shared_ptr<node> parser::parse_and_expression() {
auto node = parse_primary(); auto node = parse_primary();
while (match({token_type::LOGICAL_AND})) { while (match({token_type::LogicalAnd})) {
std::string op = previous().value; std::string op = previous().value;
const auto logical = std::make_shared<logical_node>(logical_operator::AND); const auto logical = std::make_shared<logical_node>(logical_operator::And);
logical->children_.push_back(node); logical->children_.push_back(node);
logical->children_.push_back(parse_primary()); logical->children_.push_back(parse_primary());
node = logical; node = logical;
@ -48,9 +48,9 @@ std::shared_ptr<node> parser::parse_and_expression() {
} }
std::shared_ptr<node> parser::parse_primary() { std::shared_ptr<node> parser::parse_primary() {
if (match({token_type::OPEN_PAREN})) { if (match({token_type::OpenParen})) {
auto node = parse_or_expression(); auto node = parse_or_expression();
if (!match({token_type::CLOSE_PAREN})) { if (!match({token_type::CloseParen})) {
throw std::runtime_error("Missing closing parenthesis"); throw std::runtime_error("Missing closing parenthesis");
} }
return node; return node;
@ -59,30 +59,30 @@ std::shared_ptr<node> parser::parse_primary() {
} }
std::shared_ptr<node> parser::parse_condition() { std::shared_ptr<node> parser::parse_condition() {
if (!match({token_type::IDENTIFIER})) { if (!match({token_type::Identifier})) {
throw std::runtime_error("Expected field name"); throw std::runtime_error("Expected field name");
} }
std::string field = previous().value; std::string field = previous().value;
if (!match({token_type::OPERATOR})) { if (!match({token_type::Operator})) {
throw std::runtime_error("Expected operator after field"); throw std::runtime_error("Expected operator after field");
} }
const std::string op = previous().value; const std::string op = previous().value;
if (op == "=in=" || op == "=out=") { if (op == "=in=" || op == "=out=") {
if (!match({token_type::OPEN_PAREN})) { if (!match({token_type::OpenParen})) {
throw std::runtime_error("Expected '(' after " + op); throw std::runtime_error("Expected '(' after " + op);
} }
std::vector<std::string> values; std::vector<std::string> values;
bool first = true; bool first = true;
while (!match({token_type::CLOSE_PAREN})) { while (!match({token_type::CloseParen})) {
if (!first) { if (!first) {
// accept comma as separator: tokens use LOGICAL_OR for comma in lexer // accept comma as separator: tokens use LOGICAL_OR for comma in lexer
if (!match({token_type::LOGICAL_OR})) { if (!match({token_type::LogicalOr})) {
throw std::runtime_error("Expected ',' between list values"); throw std::runtime_error("Expected ',' between list values");
} }
} }
if (!match({token_type::VALUE, token_type::IDENTIFIER})) { if (!match({token_type::Value, token_type::Identifier})) {
throw std::runtime_error("Expected value in list"); throw std::runtime_error("Expected value in list");
} }
values.push_back(previous().value); values.push_back(previous().value);
@ -91,7 +91,7 @@ std::shared_ptr<node> parser::parse_condition() {
return std::make_shared<collection_condition_node>(field, collection_operators.at(op), values); return std::make_shared<collection_condition_node>(field, collection_operators.at(op), values);
} }
if (!match({token_type::VALUE, token_type::IDENTIFIER})) { if (!match({token_type::Value, token_type::Identifier})) {
throw std::runtime_error("Expected value after operator"); throw std::runtime_error("Expected value after operator");
} }
return std::make_shared<binary_condition_node>(field, binary_operators.at(op), previous().value); return std::make_shared<binary_condition_node>(field, binary_operators.at(op), previous().value);