Changed names of dialect tokens to PascalCase writing

source/orm/query/attribute_string_writer.cpp

@@ -98,9 +98,9 @@ void attribute_string_writer::write_value(size_t /*pos*/, const utils::blob& x )
   // MSSQL:    0x5468697320697320612062616E617279204461746120737472696E67
   // Sqlite:   X'5468697320697320612062616E617279204461746120737472696E67'
   if (conn_.has_value()) {
-    result_ = dialect_.token_at(sql::dialect_token::BEGIN_BINARY_DATA) + conn_.value().get().to_escaped_string(x) + dialect_.token_at(sql::dialect_token::END_BINARY_DATA);
+    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + conn_.value().get().to_escaped_string(x) + dialect_.token_at(sql::dialect_token::EndBinaryData);
   } else {
-    result_ = dialect_.token_at(sql::dialect_token::BEGIN_BINARY_DATA) + dialect_.to_escaped_string(x) + dialect_.token_at(sql::dialect_token::END_BINARY_DATA);
+    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + dialect_.to_escaped_string(x) + dialect_.token_at(sql::dialect_token::EndBinaryData);
   }
 }
 

source/orm/query/criteria_evaluator.cpp

@@ -40,9 +40,9 @@ std::string criteria_evaluator::evaluate(const abstract_criteria &node) {
 void criteria_evaluator::visit(const between_criteria &node) {
   query_.bind_vars.emplace_back(node.column().name);
   query_.bind_vars.emplace_back(node.column().name);
-  clause_ += dialect_.prepare_identifier(node.column()) + " " + dialect_.token_at(sql::dialect_token::BETWEEN) + " ";
+  clause_ += dialect_.prepare_identifier(node.column()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
   evaluate_value(node.min());
-  clause_ += " " + dialect_.token_at(sql::dialect_token::AND) + " ";
+  clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
   evaluate_value(node.max());
 }
 
@@ -62,8 +62,8 @@ void criteria_evaluator::visit(const collection_criteria &node) {
   }
 
   clause_ += dialect_.prepare_identifier(node.column()) +
-      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::NOT) + " " : " ") +
-      dialect_.token_at(sql::dialect_token::IN) + " (";
+      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
+      dialect_.token_at(sql::dialect_token::In) + " (";
   if (node.values().size() < 2) {
     for (const auto &val: node.values()) {
       evaluate_value(val);
@@ -81,28 +81,28 @@ void criteria_evaluator::visit(const collection_criteria &node) {
 
 void criteria_evaluator::visit(const collection_query_criteria &node) {
   clause_ += dialect_.prepare_identifier(node.column()) +
-      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::NOT) + " " : " ") +
-      dialect_.token_at(sql::dialect_token::IN) + " (" +node.context().sql + ")";
+      (node.operand() == collection_operator::OUT ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
+      dialect_.token_at(sql::dialect_token::In) + " (" +node.context().sql + ")";
 }
 
 void criteria_evaluator::visit(const like_criteria &node) {
-  clause_ += dialect_.prepare_condition(node.column()) + " " + dialect_.token_at(sql::dialect_token::LIKE) +
-      " " + dialect_.token_at(sql::dialect_token::BEGIN_STRING_DATA) + node.pattern() + dialect_.token_at(
-        sql::dialect_token::END_STRING_DATA);
+  clause_ += dialect_.prepare_condition(node.column()) + " " + dialect_.token_at(sql::dialect_token::Like) +
+      " " + dialect_.token_at(sql::dialect_token::BeginStringData) + node.pattern() + dialect_.token_at(
+        sql::dialect_token::EndStringData);
 }
 
 void criteria_evaluator::visit(const logical_criteria &node) {
   clause_ += "(";
   node.left_clause()->accept(*this);
   clause_ += " " + dialect_.token_at(node.operand() == logical_operator::AND
-                                       ? sql::dialect_token::AND
-                                       : sql::dialect_token::OR) + " ";
+                                       ? sql::dialect_token::And
+                                       : sql::dialect_token::Or) + " ";
   node.right_clause()->accept(*this);
   clause_ += ")";
 }
 
 void criteria_evaluator::visit(const not_criteria &node) {
-  clause_ += dialect_.token_at(sql::dialect_token::NOT) + " (";
+  clause_ += dialect_.token_at(sql::dialect_token::Not) + " (";
   node.clause()->accept(*this);
   clause_ += ")";
 }

source/orm/query/internal/query_parts.cpp

@@ -5,7 +5,7 @@
 namespace matador::query::internal {
 
 query_select_part::query_select_part(std::vector<sql::column> columns)
-  : query_part(sql::dialect_token::SELECT)
+  : query_part(sql::dialect_token::Select)
   , columns_(std::move(columns)) {}
 
 void query_select_part::accept(query_part_visitor &visitor)
@@ -19,7 +19,7 @@ const std::vector<sql::column>& query_select_part::columns() const
 }
 
 query_from_part::query_from_part(sql::table t)
-  : query_part(sql::dialect_token::FROM)
+  : query_part(sql::dialect_token::From)
   , table_(std::move(t)) {}
 
 const sql::table &query_from_part::table() const
@@ -33,7 +33,7 @@ void query_from_part::accept(query_part_visitor &visitor)
 }
 
 query_join_part::query_join_part(sql::table t)
-  : query_part(sql::dialect_token::JOIN)
+  : query_part(sql::dialect_token::Join)
   , table_(std::move(t)) {}
 
 const sql::table &query_join_part::table() const
@@ -47,7 +47,7 @@ void query_join_part::accept(query_part_visitor &visitor)
 }
 
 query_on_part::query_on_part(std::unique_ptr<basic_condition> &&cond)
-: query_part(sql::dialect_token::ON)
+: query_part(sql::dialect_token::On)
 , condition_(std::move(cond)) {}
 
 const basic_condition &query_on_part::condition() const
@@ -61,7 +61,7 @@ void query_on_part::accept(query_part_visitor &visitor)
 }
 
 query_where_part::query_where_part(std::unique_ptr<basic_condition> &&cond)
-: query_part(sql::dialect_token::WHERE)
+: query_part(sql::dialect_token::Where)
 , condition_(std::move(cond)) {}
 
 void query_where_part::accept(query_part_visitor &visitor)
@@ -79,7 +79,7 @@ query_table_name_part::query_table_name_part(sql::dialect_token token, std::stri
 , table_name_(std::move(table_name)) {}
 
 query_group_by_part::query_group_by_part(sql::column col)
-: query_part(sql::dialect_token::GROUP_BY)
+: query_part(sql::dialect_token::GroupBy)
 , column_(std::move(col))
 {}
 
@@ -94,7 +94,7 @@ void query_group_by_part::accept(query_part_visitor &visitor)
 }
 
 query_order_by_part::query_order_by_part(sql::column col)
-: query_part(sql::dialect_token::ORDER_BY)
+: query_part(sql::dialect_token::OrderBy)
 , column_(std::move(col))
 {}
 
@@ -109,7 +109,7 @@ void query_order_by_part::accept(query_part_visitor &visitor)
 }
 
 query_order_by_asc_part::query_order_by_asc_part()
-: query_part(sql::dialect_token::ASC)
+: query_part(sql::dialect_token::Asc)
 {}
 
 void query_order_by_asc_part::accept(query_part_visitor &visitor)
@@ -118,7 +118,7 @@ void query_order_by_asc_part::accept(query_part_visitor &visitor)
 }
 
 query_order_by_desc_part::query_order_by_desc_part()
-: query_part(sql::dialect_token::DESC)
+: query_part(sql::dialect_token::Desc)
 {}
 
 void query_order_by_desc_part::accept(query_part_visitor &visitor)
@@ -127,7 +127,7 @@ void query_order_by_desc_part::accept(query_part_visitor &visitor)
 }
 
 query_offset_part::query_offset_part(size_t offset)
-: query_part(sql::dialect_token::OFFSET)
+: query_part(sql::dialect_token::Offset)
 , offset_(offset) {}
 
 size_t query_offset_part::offset() const
@@ -141,7 +141,7 @@ void query_offset_part::accept(query_part_visitor &visitor)
 }
 
 query_limit_part::query_limit_part(size_t limit)
-: query_part(sql::dialect_token::LIMIT)
+: query_part(sql::dialect_token::Limit)
 , limit_(limit) {}
 
 size_t query_limit_part::limit() const
@@ -155,7 +155,7 @@ void query_limit_part::accept(query_part_visitor &visitor)
 }
 
 query_insert_part::query_insert_part()
-: query_part(sql::dialect_token::INSERT) {}
+: query_part(sql::dialect_token::Insert) {}
 
 void query_insert_part::accept(query_part_visitor &visitor)
 {
@@ -163,7 +163,7 @@ void query_insert_part::accept(query_part_visitor &visitor)
 }
 
 query_into_part::query_into_part(sql::table t, std::vector<sql::column> columns)
-: query_part(sql::dialect_token::INSERT)
+: query_part(sql::dialect_token::Insert)
 , table_(std::move(t))
 , columns_(std::move(columns)) {}
 
@@ -183,7 +183,7 @@ void query_into_part::accept(query_part_visitor &visitor)
 }
 
 query_values_part::query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values)
-: query_part(sql::dialect_token::VALUES)
+: query_part(sql::dialect_token::Values)
 , values_(std::move(values)) {}
 
 const std::vector<std::variant<utils::placeholder, utils::database_type>>& query_values_part::values() const
@@ -197,7 +197,7 @@ void query_values_part::accept(query_part_visitor &visitor)
 }
 
 query_update_part::query_update_part(sql::table table)
-: query_part(sql::dialect_token::UPDATE)
+: query_part(sql::dialect_token::Update)
 , table_(std::move(table)) {}
 
 const sql::table& query_update_part::table() const
@@ -211,7 +211,7 @@ void query_update_part::accept(query_part_visitor &visitor)
 }
 
 query_set_part::query_set_part(const std::vector<key_value_pair>& key_value_pairs)
-: query_part(sql::dialect_token::SET)
+: query_part(sql::dialect_token::Set)
 , key_value_pairs_(key_value_pairs) {}
 
 const std::vector<key_value_pair> &query_set_part::key_values() const
@@ -225,7 +225,7 @@ void query_set_part::accept(query_part_visitor &visitor)
 }
 
 query_delete_part::query_delete_part()
-: query_part(sql::dialect_token::REMOVE) {}
+: query_part(sql::dialect_token::Remove) {}
 
 void query_delete_part::accept(query_part_visitor &visitor)
 {
@@ -233,7 +233,7 @@ void query_delete_part::accept(query_part_visitor &visitor)
 }
 
 query_delete_from_part::query_delete_from_part(sql::table table)
-: query_part(sql::dialect_token::FROM)
+: query_part(sql::dialect_token::From)
 , table_(std::move(table)) {}
 
 const sql::table &query_delete_from_part::table() const
@@ -247,7 +247,7 @@ void query_delete_from_part::accept(query_part_visitor &visitor)
 }
 
 query_create_part::query_create_part()
-: query_part(sql::dialect_token::CREATE) {}
+: query_part(sql::dialect_token::Create) {}
 
 void query_create_part::accept(query_part_visitor &visitor)
 {
@@ -255,7 +255,7 @@ void query_create_part::accept(query_part_visitor &visitor)
 }
 
 query_create_table_part::query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns)
-: query_part(sql::dialect_token::TABLE)
+: query_part(sql::dialect_token::Table)
 , table_(std::move(table))
 , columns_(std::move(columns)) {}
 
@@ -275,7 +275,7 @@ void query_create_table_part::accept(query_part_visitor &visitor)
 }
 
 query_drop_part::query_drop_part()
-: query_part(sql::dialect_token::DROP) {}
+: query_part(sql::dialect_token::Drop) {}
 
 void query_drop_part::accept(query_part_visitor &visitor)
 {
@@ -283,7 +283,7 @@ void query_drop_part::accept(query_part_visitor &visitor)
 }
 
 query_drop_table_part::query_drop_table_part(sql::table table)
-: query_part(sql::dialect_token::TABLE)
+: query_part(sql::dialect_token::Table)
 , table_(std::move(table)) {}
 
 const sql::table &query_drop_table_part::table() const

source/orm/query/query_compiler.cpp

@@ -53,7 +53,7 @@ std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const
 void query_compiler::visit(internal::query_select_part &select_part)
 {
   query_.command = sql::sql_command::SQL_SELECT;
-  query_.sql = dialect_->token_at(sql::dialect_token::SELECT) + " ";
+  query_.sql = dialect_->token_at(sql::dialect_token::Select) + " ";
 
   query_.prototype.clear();
 
@@ -88,57 +88,57 @@ void query_compiler::visit(internal::query_join_part &join_part)
 
 void query_compiler::visit(internal::query_on_part &on_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::ON) +
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::On) +
                 " " + on_part.condition().evaluate(*dialect_, query_);
 }
 
 void query_compiler::visit(internal::query_where_part &where_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::WHERE) +
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Where) +
                 " " + where_part.condition().evaluate(*dialect_, query_);
 }
 
 void query_compiler::visit(internal::query_group_by_part &group_by_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::GROUP_BY) + " " + dialect_->prepare_identifier(group_by_part.column());
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + dialect_->prepare_identifier(group_by_part.column());
 }
 
 void query_compiler::visit(internal::query_order_by_part &order_by_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::ORDER_BY) +
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::OrderBy) +
                 " " + dialect_->prepare_condition(order_by_part.column());
 }
 
 void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::ASC);
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Asc);
 }
 
 void query_compiler::visit(internal::query_order_by_desc_part &/*order_by_desc_part*/)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::DESC);
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Desc);
 }
 
 void query_compiler::visit(internal::query_offset_part &offset_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::OFFSET) + " " + std::to_string(offset_part.offset());
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Offset) + " " + std::to_string(offset_part.offset());
 }
 
 void query_compiler::visit(internal::query_limit_part &limit_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::LIMIT) + " " + std::to_string(limit_part.limit());
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Limit) + " " + std::to_string(limit_part.limit());
 }
 
 void query_compiler::visit(internal::query_insert_part &/*insert_part*/)
 {
   query_.command = sql::sql_command::SQL_INSERT;
-  query_.sql = dialect_->token_at(sql::dialect_token::INSERT);
+  query_.sql = dialect_->token_at(sql::dialect_token::Insert);
 }
 
 void query_compiler::visit(internal::query_into_part &into_part)
 {
   query_.table = into_part.table();
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::INTO) +
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Into) +
                 " " + dialect_->prepare_identifier_string(into_part.table().name);
 
   std::string result{"("};
@@ -185,7 +185,7 @@ std::string query_compiler::determine_value(value_visitor &visitor, const std::v
 }
 
 void query_compiler::visit(internal::query_values_part &values_part) {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::VALUES);
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Values);
 
   attribute_string_writer writer(*dialect_, connection_);
 
@@ -220,7 +220,7 @@ void query_compiler::visit(internal::query_update_part &update_part)
 void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
 {
   query_.command = sql::sql_command::SQL_DELETE;
-  query_.sql = dialect_->token_at(sql::dialect_token::REMOVE);
+  query_.sql = dialect_->token_at(sql::dialect_token::Remove);
 }
 
 void query_compiler::visit(internal::query_delete_from_part &delete_from_part)
@@ -232,7 +232,7 @@ void query_compiler::visit(internal::query_delete_from_part &delete_from_part)
 void query_compiler::visit(internal::query_create_part &/*create_part*/)
 {
   query_.command = sql::sql_command::SQL_CREATE_TABLE;
-  query_.sql = dialect_->token_at(sql::dialect_token::CREATE);
+  query_.sql = dialect_->token_at(sql::dialect_token::Create);
 }
 
 struct fk_context {
@@ -250,7 +250,7 @@ std::string build_create_column(const object::attribute_definition &col, const s
 
 void query_compiler::visit(internal::query_create_table_part &create_table_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::TABLE) + " " + dialect_->prepare_identifier_string(create_table_part.table().name) + " ";
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Table) + " " + dialect_->prepare_identifier_string(create_table_part.table().name) + " ";
   query_.table = create_table_part.table();
 
   std::string result = "(";
@@ -290,7 +290,7 @@ void query_compiler::visit(internal::query_create_table_part &create_table_part)
 void query_compiler::visit(internal::query_drop_part &/*drop_part*/)
 {
   query_.command = sql::sql_command::SQL_DROP_TABLE;
-  query_.sql = dialect_->token_at(sql::dialect_token::DROP);
+  query_.sql = dialect_->token_at(sql::dialect_token::Drop);
 }
 
 std::string query_compiler::determine_set_value(internal::basic_type_to_string_visitor &visitor, const utils::database_type &val) {
@@ -305,7 +305,7 @@ std::string query_compiler::determine_set_value(internal::basic_type_to_string_v
 
 void query_compiler::visit(internal::query_set_part &set_part)
 {
-  query_.sql += " " + dialect_->token_at(sql::dialect_token::SET) + " ";
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Set) + " ";
 
   attribute_string_writer writer(*dialect_, connection_);
   internal::basic_type_to_string_visitor visitor(writer, query_);

source/orm/sql/connection.cpp

@@ -111,7 +111,7 @@ std::string connection::type() const {
 }
 
 utils::result<void, utils::error> connection::begin() const {
-  const auto res = connection_->execute(dialect().token_at(dialect_token::BEGIN));
+  const auto res = connection_->execute(dialect().token_at(dialect_token::Begin));
   if (res.is_error()) {
     return utils::failure(res.err());
   }
@@ -120,7 +120,7 @@ utils::result<void, utils::error> connection::begin() const {
 }
 
 utils::result<void, utils::error> connection::commit() const {
-  const auto res = connection_->execute(dialect().token_at(dialect_token::COMMIT));
+  const auto res = connection_->execute(dialect().token_at(dialect_token::Commit));
   if (res.is_error()) {
     return utils::failure(res.err());
   }
@@ -129,7 +129,7 @@ utils::result<void, utils::error> connection::commit() const {
 }
 
 utils::result<void, utils::error> connection::rollback() const {
-  const auto res = connection_->execute(dialect().token_at(dialect_token::ROLLBACK));
+  const auto res = connection_->execute(dialect().token_at(dialect_token::Rollback));
   if (res.is_error()) {
     return utils::failure(res.err());
   }

source/orm/sql/dialect.cpp

@@ -62,7 +62,7 @@ std::string dialect::to_sql_string(const utils::value &val) const {
     return "NULL";
   }
   if (val.is_string()) {
-    return token_at(dialect_token::BEGIN_STRING_DATA) + val.str() + token_at(dialect_token::BEGIN_STRING_DATA);
+    return token_at(dialect_token::BeginStringData) + val.str() + token_at(dialect_token::BeginStringData);
   }
 
   return val.str();
@@ -94,14 +94,14 @@ std::string dialect::prepare_literal(const std::string &str) const
 
 void dialect::quote_identifier(std::string &str) const
 {
-  str.insert(0, token_at(dialect_token::START_QUOTE));
-  str += token_at(dialect_token::END_QUOTE);
+  str.insert(0, token_at(dialect_token::StartQuote));
+  str += token_at(dialect_token::EndQuote);
 }
 
 void dialect::escape_quotes_in_identifier(std::string &str) const
 {
-  const std::string open_char(token_at(dialect_token::START_QUOTE));
-  const std::string close_char(token_at(dialect_token::END_QUOTE));
+  const std::string open_char(token_at(dialect_token::StartQuote));
+  const std::string close_char(token_at(dialect_token::EndQuote));
   if (identifier_escape_type() == escape_identifier_t::ESCAPE_CLOSING_BRACKET) {
     utils::replace_all(str, close_char, close_char + close_char);
   } else {
@@ -111,8 +111,8 @@ void dialect::escape_quotes_in_identifier(std::string &str) const
 
 void dialect::escape_quotes_in_literals(std::string &str) const
 {
-  const std::string single_quote(token_at(dialect_token::STRING_QUOTE));
-  const std::string double_quote(token_at(dialect_token::STRING_QUOTE) + token_at(dialect_token::STRING_QUOTE));
+  const std::string single_quote(token_at(dialect_token::StringQuote));
+  const std::string double_quote(token_at(dialect_token::StringQuote) + token_at(dialect_token::StringQuote));
   utils::replace_all(str, single_quote, double_quote);
 }