diff --git a/backends/postgres/src/postgres_dialect.cpp b/backends/postgres/src/postgres_dialect.cpp
index 22a33a5..e607880 100644
--- a/backends/postgres/src/postgres_dialect.cpp
+++ b/backends/postgres/src/postgres_dialect.cpp
@@ -13,7 +13,7 @@
       return "$" + std::to_string(index);
     })
     .with_token_replace_map({
-                          {dialect_token::BEGIN_BINARY_DATA, "'\\x"}
+                          {dialect_token::BeginBinaryData, "'\\x"}
                           })
     .with_data_type_replace_map({
         {matador::utils::basic_type::type_int8, "SMALLINT"},
diff --git a/include/matador/query/internal/query_parts.hpp b/include/matador/query/internal/query_parts.hpp
index ae0141d..5fba597 100644
--- a/include/matador/query/internal/query_parts.hpp
+++ b/include/matador/query/internal/query_parts.hpp
@@ -68,7 +68,7 @@ class query_on_part final : public query_part
 public:
   template < class Condition >
   explicit query_on_part(const Condition &cond)
-    : query_part(sql::dialect_token::ON)
+    : query_part(sql::dialect_token::On)
     , condition_(new Condition(cond)) {}
   explicit query_on_part(std::unique_ptr<basic_condition> &&cond);
 
@@ -86,7 +86,7 @@ class query_where_part final : public query_part
 public:
   template < class Condition >
   explicit query_where_part(const Condition &cond)
-  : query_part(sql::dialect_token::WHERE)
+  : query_part(sql::dialect_token::Where)
   , condition_(new Condition(cond)) {}
   explicit query_where_part(std::unique_ptr<basic_condition> &&cond);
 
diff --git a/include/matador/sql/dialect.hpp b/include/matador/sql/dialect.hpp
index 1073a32..9dad7e1 100644
--- a/include/matador/sql/dialect.hpp
+++ b/include/matador/sql/dialect.hpp
@@ -139,50 +139,50 @@ private:
   // std::unique_ptr<query_compiler> compiler_;
 
   token_to_string_map tokens_ {
-    {dialect_token::CREATE,      "CREATE"},
-    {dialect_token::DROP,        "DROP"},
-    {dialect_token::REMOVE,      "DELETE"},
-    {dialect_token::INSERT,      "INSERT"},
-    {dialect_token::TABLE,       "TABLE"},
-    {dialect_token::INTO,        "INTO"},
-    {dialect_token::VALUES,      "VALUES"},
-    {dialect_token::UPDATE,      "UPDATE"},
-    {dialect_token::SELECT,      "SELECT"},
-    {dialect_token::COLUMNS,     "COLUMNS"},
-    {dialect_token::COLUMN,      "COLUMN"},
-    {dialect_token::FROM,        "FROM"},
-    {dialect_token::JOIN,        "LEFT JOIN"},
-    {dialect_token::ON,          "ON"},
-    {dialect_token::WHERE,       "WHERE"},
-    {dialect_token::AND,         "AND"},
-    {dialect_token::OR,          "OR"},
-    {dialect_token::NOT,         "NOT"},
-    {dialect_token::LIKE,        "LIKE"},
-    {dialect_token::BETWEEN,     "BETWEEN"},
-    {dialect_token::IN,          "IN"},
-    {dialect_token::ORDER_BY,    "ORDER BY"},
-    {dialect_token::GROUP_BY,    "GROUP BY"},
-    {dialect_token::ASC,         "ASC"},
-    {dialect_token::DESC,        "DESC"},
-    {dialect_token::OFFSET,      "OFFSET"},
-    {dialect_token::LIMIT,       "LIMIT"},
-    {dialect_token::AS,          "AS"},
-    {dialect_token::OFFSET,      "OFFSET"},
-    {dialect_token::DISTINCT,    "DISTINCT"},
-    {dialect_token::SET,         "SET"},
-    {dialect_token::NOT_NULL,    "NOT NULL"},
-    {dialect_token::PRIMARY_KEY, "PRIMARY KEY"},
-    {dialect_token::BEGIN,       "BEGIN TRANSACTION"},
-    {dialect_token::COMMIT,      "COMMIT TRANSACTION"},
-    {dialect_token::ROLLBACK,    "ROLLBACK TRANSACTION"},
-    {dialect_token::START_QUOTE, "\""},
-    {dialect_token::END_QUOTE, "\""},
-    {dialect_token::STRING_QUOTE, "'"},
-    {dialect_token::BEGIN_BINARY_DATA, "X'"},
-    {dialect_token::END_BINARY_DATA, "'"},
-    {dialect_token::BEGIN_STRING_DATA, "'"},
-    {dialect_token::END_STRING_DATA, "'"},
-    {dialect_token::NONE, ""}
+    {dialect_token::Create,      "CREATE"},
+    {dialect_token::Drop,        "DROP"},
+    {dialect_token::Remove,      "DELETE"},
+    {dialect_token::Insert,      "INSERT"},
+    {dialect_token::Table,       "TABLE"},
+    {dialect_token::Into,        "INTO"},
+    {dialect_token::Values,      "VALUES"},
+    {dialect_token::Update,      "UPDATE"},
+    {dialect_token::Select,      "SELECT"},
+    {dialect_token::Columns,     "COLUMNS"},
+    {dialect_token::Column,      "COLUMN"},
+    {dialect_token::From,        "FROM"},
+    {dialect_token::Join,        "LEFT JOIN"},
+    {dialect_token::On,          "ON"},
+    {dialect_token::Where,       "WHERE"},
+    {dialect_token::And,         "AND"},
+    {dialect_token::Or,          "OR"},
+    {dialect_token::Not,         "NOT"},
+    {dialect_token::Like,        "LIKE"},
+    {dialect_token::Between,     "BETWEEN"},
+    {dialect_token::In,          "IN"},
+    {dialect_token::OrderBy,    "ORDER BY"},
+    {dialect_token::GroupBy,    "GROUP BY"},
+    {dialect_token::Asc,         "ASC"},
+    {dialect_token::Desc,        "DESC"},
+    {dialect_token::Offset,      "OFFSET"},
+    {dialect_token::Limit,       "LIMIT"},
+    {dialect_token::As,          "AS"},
+    {dialect_token::Offset,      "OFFSET"},
+    {dialect_token::Distinct,    "DISTINCT"},
+    {dialect_token::Set,         "SET"},
+    {dialect_token::NotNull,    "NOT NULL"},
+    {dialect_token::PrimaryKey, "PRIMARY KEY"},
+    {dialect_token::Begin,       "BEGIN TRANSACTION"},
+    {dialect_token::Commit,      "COMMIT TRANSACTION"},
+    {dialect_token::Rollback,    "ROLLBACK TRANSACTION"},
+    {dialect_token::StartQuote, "\""},
+    {dialect_token::EndQuote, "\""},
+    {dialect_token::StringQuote, "'"},
+    {dialect_token::BeginBinaryData, "X'"},
+    {dialect_token::EndBinaryData, "'"},
+    {dialect_token::BeginStringData, "'"},
+    {dialect_token::EndStringData, "'"},
+    {dialect_token::None, ""}
   };
 
   data_type_to_string_map data_types_ {
diff --git a/include/matador/sql/dialect_token.hpp b/include/matador/sql/dialect_token.hpp
index 92dffb3..c6b90d6 100644
--- a/include/matador/sql/dialect_token.hpp
+++ b/include/matador/sql/dialect_token.hpp
@@ -6,55 +6,55 @@
 namespace matador::sql {
 
 enum class dialect_token : uint8_t {
-  CREATE = 0,
-  DROP,
-  REMOVE,
-  INSERT,
-  UPDATE,
-  SELECT,
-  ALTER,
-  SCHEMA,
-  DATABASE,
-  TABLE,
-  VALUES,
-  INSERT_VALUES,
-  COLUMNS,
-  COLUMN,
-  FROM,
-  JOIN,
-  ON,
-  INTO,
-  WHERE,
-  WHERE_CLAUSE,
-  AND,
-  OR,
-  NOT,
-  LIKE,
-  BETWEEN,
-  IN,
-  ORDER_BY,
-  GROUP_BY,
-  ASC,
-  DESC,
-  LIMIT,
-  AS,
-  OFFSET,
-  DISTINCT,
-  SET,
-  UPDATE_VALUES,
-  NOT_NULL,
-  PRIMARY_KEY,
-  BEGIN,
-  COMMIT,
-  ROLLBACK,
-  START_QUOTE,
-  END_QUOTE,
-  STRING_QUOTE,
-  BEGIN_BINARY_DATA,
-  END_BINARY_DATA,
-  BEGIN_STRING_DATA,
-  END_STRING_DATA,
-  NONE
+  Create = 0,
+  Drop,
+  Remove,
+  Insert,
+  Update,
+  Select,
+  Alter,
+  Schema,
+  Database,
+  Table,
+  Values,
+  InsertValues,
+  Columns,
+  Column,
+  From,
+  Join,
+  On,
+  Into,
+  Where,
+  WhereClause,
+  And,
+  Or,
+  Not,
+  Like,
+  Between,
+  In,
+  OrderBy,
+  GroupBy,
+  Asc,
+  Desc,
+  Limit,
+  As,
+  Offset,
+  Distinct,
+  Set,
+  UpdateValues,
+  NotNull,
+  PrimaryKey,
+  Begin,
+  Commit,
+  Rollback,
+  StartQuote,
+  EndQuote,
+  StringQuote,
+  BeginBinaryData,
+  EndBinaryData,
+  BeginStringData,
+  EndStringData,
+  None
 };
 }
 
diff --git a/source/orm/query/attribute_string_writer.cpp b/source/orm/query/attribute_string_writer.cpp
index 72d2f0e..abfc71e 100644
--- a/source/orm/query/attribute_string_writer.cpp
+++ b/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);
   }
 }
 
diff --git a/source/orm/query/criteria_evaluator.cpp b/source/orm/query/criteria_evaluator.cpp
index 096ce3f..c46fb44 100644
--- a/source/orm/query/criteria_evaluator.cpp
+++ b/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_ += ")";
 }
diff --git a/source/orm/query/internal/query_parts.cpp b/source/orm/query/internal/query_parts.cpp
index 989ed77..07d11dc 100644
--- a/source/orm/query/internal/query_parts.cpp
+++ b/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
diff --git a/source/orm/query/query_compiler.cpp b/source/orm/query/query_compiler.cpp
index 9258a36..20cf292 100644
--- a/source/orm/query/query_compiler.cpp
+++ b/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_);
diff --git a/source/orm/sql/connection.cpp b/source/orm/sql/connection.cpp
index 75890fe..a940d31 100644
--- a/source/orm/sql/connection.cpp
+++ b/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());
   }
diff --git a/source/orm/sql/dialect.cpp b/source/orm/sql/dialect.cpp
index 994458b..e86b736 100644
--- a/source/orm/sql/dialect.cpp
+++ b/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);
 }
 
diff --git a/test/backends/QueryBasicTest.cpp b/test/backends/QueryBasicTest.cpp
index 15a9345..8598a6a 100644
--- a/test/backends/QueryBasicTest.cpp
+++ b/test/backends/QueryBasicTest.cpp
@@ -166,8 +166,8 @@ TEST_CASE_METHOD( QueryFixture, "Test quoted identifier", "[query][quotes][ident
 TEST_CASE_METHOD( QueryFixture, "Test quoted column names", "[query][quotes][column]" ) {
   using namespace matador::sql;
 
-  const auto start_quote = db.dialect().token_at(matador::sql::dialect_token::START_QUOTE);
-  const auto end_quote = db.dialect().token_at(matador::sql::dialect_token::END_QUOTE);
+  const auto start_quote = db.dialect().token_at(matador::sql::dialect_token::StartQuote);
+  const auto end_quote = db.dialect().token_at(matador::sql::dialect_token::EndQuote);
 
   const std::string column_name = "name_with_" + start_quote + "open_close_quotes" + end_quote + "_in_backend_ctx";