diff --git a/CMakeLists.txt b/CMakeLists.txt
index cdbb4f8..d97a049 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,7 +61,7 @@ FetchContent_MakeAvailable(logger)
 FetchContent_Declare(
         argparse
         GIT_REPOSITORY https://github.com/p-ranav/argparse.git
-        GIT_TAG 997da9255618311d1fcb0135ce86022729d1f1cb # release-2.9
+        GIT_TAG 68fd0277eea5412aff9b91c0b70efc698359dae0 # release-3.1
 )
 FetchContent_MakeAvailable(argparse)
 FetchContent_Declare(
diff --git a/include/SCC/config/scc_args.h b/include/SCC/config/scc_args.h
index 326ed97..a07ce8d 100644
--- a/include/SCC/config/scc_args.h
+++ b/include/SCC/config/scc_args.h
@@ -34,20 +34,22 @@
 
 namespace scc::config {
 
+constexpr std::string_view SCC_SCHEMA_SUBCOMMAND = "schema";
+constexpr std::string_view SCC_DATA_SUBCOMMAND = "data";
+
 class no_argument_error : private std::runtime_error {
 public:
   explicit no_argument_error(const std::string& message);
 };
 
-class SCCArgs : public argparse::ArgumentParser {
+class SCCArgumentParser : public argparse::ArgumentParser {
 public:
-  explicit SCCArgs();
+  explicit SCCArgumentParser(std::string_view program_name);
 
-  void ParseArgs(int argc, const char* const argv[]);
+  SCCArgumentParser& subparser(std::string_view name);
 
   template<typename T = std::string>
-  auto Get(const std::string& arg_name) const
-  -> std::conditional_t<argparse::details::IsContainer<T>, T, const T&> {
+  T Get(const std::string& arg_name) const {
     try {
       return get<T>(arg_name);
     } catch (const std::logic_error& e) {
@@ -60,10 +62,34 @@ class SCCArgs : public argparse::ArgumentParser {
     return present<T>(arg_name);
   }
 
-  bool IsUsed(const std::string& arg_name) const;
+  [[nodiscard]] bool IsUsed(const std::string& arg_name) const;
 
-private:
   void PrintHelpAndExit(int exit_code) const;
 };
 
+class SCCArgs : public SCCArgumentParser {
+public:
+  explicit SCCArgs();
+
+  void ParseArgs(int argc, const char* const argv[]);
+};
+
+class SCCSubcommand : public SCCArgumentParser {
+public:
+  explicit SCCSubcommand(std::string_view subcommand, const std::string& description);
+  virtual ~SCCSubcommand() = default;
+};
+
+class SCCSubcommandSchema : public SCCSubcommand {
+public:
+  explicit SCCSubcommandSchema();
+  ~SCCSubcommandSchema() override = default;
+};
+
+class SCCSubcommandData : public SCCSubcommand {
+public:
+  explicit SCCSubcommandData();
+  ~SCCSubcommandData() override = default;
+};
+
 } // scc::config
diff --git a/include/SCC/config/scc_config.h b/include/SCC/config/scc_config.h
index 9f1761b..93404f4 100644
--- a/include/SCC/config/scc_config.h
+++ b/include/SCC/config/scc_config.h
@@ -24,7 +24,7 @@ class SCCConfig : public common::Singleton<SCCConfig> {
   bool translate_schema;
   bool translate_data;
 
-  explicit SCCConfig(const SCCArgs& args);
+  explicit SCCConfig(SCCArgs& args);
 
   static SCCConfig* Get();
 
@@ -42,6 +42,6 @@ class SCCConfig : public common::Singleton<SCCConfig> {
   std::filesystem::path ast_dump_file_;
 };
 
-void InitConfig(const SCCArgs& args);
+void InitConfig(SCCArgs& args);
 
 } // scc::config
diff --git a/include/SCC/parser/parser.h b/include/SCC/parser/parser.h
index 3b02f0b..ed918fb 100644
--- a/include/SCC/parser/parser.h
+++ b/include/SCC/parser/parser.h
@@ -94,19 +94,19 @@ class Parser {
   std::shared_ptr<ast::INode> ParseMathPower();
   std::shared_ptr<ast::INode> ParseMathValue();
 
-  ast::StmtType DetermineConstraintType(const std::string& keyword) const;
-  ast::StmtType DetermineAlterTableActionType(const std::string& keyword) const;
-  ast::StmtType DetermineDropElementType(const std::string& keyword) const;
-  ast::StmtType DetermineLogicalOperatorType(const std::string& keyword) const;
-
-  bool DetermineIsFullConstraintDefinition(const std::string& keyword) const;
-  bool DetermineIsPrimaryKey(const std::string& keyword) const;
-  bool DetermineIsForeignKey(const std::string& keyword) const;
-  bool DetermineIsReferences(const std::string& keyword) const;
-  bool DetermineIsOROperator(const std::string& keyword) const;
-  bool DetermineIsANDOperator(const std::string& keyword) const;
-  bool DetermineIsNOTOperator(const std::string& keyword) const;
-  bool DetermineIsPrefix(const std::string_view& string, const std::string& prefix) const;
+  static ast::StmtType DetermineConstraintType(const std::string& keyword);
+  static ast::StmtType DetermineAlterTableActionType(const std::string& keyword);
+  static ast::StmtType DetermineDropElementType(const std::string& keyword);
+  static ast::StmtType DetermineLogicalOperatorType(const std::string& keyword);
+
+  static bool DetermineIsFullConstraintDefinition(const std::string& keyword);
+  static bool DetermineIsPrimaryKey(const std::string& keyword);
+  static bool DetermineIsForeignKey(const std::string& keyword);
+  static bool DetermineIsReferences(const std::string& keyword);
+  static bool DetermineIsOROperator(const std::string& keyword);
+  static bool DetermineIsANDOperator(const std::string& keyword);
+  static bool DetermineIsNOTOperator(const std::string& keyword);
+  static bool DetermineIsPrefix(const std::string_view& string, const std::string& prefix);
 
   std::shared_ptr<ast::INode> ParsePrimaryKey();
   std::shared_ptr<ast::INode> ParseForeignKey();
@@ -127,14 +127,14 @@ class Parser {
   void ValidateHasTokens(unsigned min_count = 1) const;
   void ValidateHasNotTokens() const;
 
-  void ValidateIsWord(const std::shared_ptr<ast::INode>& node) const;
-  void ValidateIsOpeningRoundBracket(const std::shared_ptr<ast::INode>& node) const;
-  void ValidateIsClosingRoundBracket(const std::shared_ptr<ast::INode>& node) const;
-  void ValidateIsSingleQuote(const std::shared_ptr<ast::INode>& node) const;
-  void ValidateIsDoubleQuote(const std::shared_ptr<ast::INode>& node) const;
-  void ValidateIsBinaryOperator(const std::shared_ptr<ast::INode>& node) const;
-
-  void ValidateIsAssignmentOperator(const std::shared_ptr<ast::INode>& node) const;
+  static void ValidateIsWord(const std::shared_ptr<ast::INode>& node);
+  static void ValidateIsOpeningRoundBracket(const std::shared_ptr<ast::INode>& node);
+  static void ValidateIsClosingRoundBracket(const std::shared_ptr<ast::INode>& node);
+  static void ValidateIsSingleQuote(const std::shared_ptr<ast::INode>& node);
+  static void ValidateIsDoubleQuote(const std::shared_ptr<ast::INode>& node);
+  static void ValidateIsBinaryOperator(const std::shared_ptr<ast::INode>& node);
+  
+  static void ValidateIsAssignmentOperator(const std::shared_ptr<ast::INode>& node);
 };
 
 } // scc::parser
diff --git a/include/SCC/translator/translator.h b/include/SCC/translator/translator.h
index f851a6e..9ef0a59 100644
--- a/include/SCC/translator/translator.h
+++ b/include/SCC/translator/translator.h
@@ -75,9 +75,9 @@ class Translator {
   void TranslateAlterTableActionDrop(const std::shared_ptr<ast::INode>& action_node,
                                      std::string& table_name);
 
-  std::vector<schema::Property> TranslateColumnDefinitions(
+  static std::vector<schema::Property> TranslateColumnDefinitions(
       const std::shared_ptr<ast::INode>& column_definition);
-  schema::Property TranslateColumnDefinition(const std::shared_ptr<ast::INode>& node);
+  static schema::Property TranslateColumnDefinition(const std::shared_ptr<ast::INode>& node);
   void TranslateTableConstraint(const std::shared_ptr<ast::INode>& constraint_definition,
                                 const std::string& table_name);
 
@@ -96,17 +96,17 @@ class Translator {
   void TranslateForeignKey(const std::shared_ptr<ast::INode>& foreign_key,
                            const std::string& constraint_name, const std::string& table_name);
 
-  std::string GetName(const std::shared_ptr<ast::INode>& name_node) const;
-  std::string GetIdentifier(const std::shared_ptr<ast::INode>& node) const;
+  static std::string GetName(const std::shared_ptr<ast::INode>& name_node);
+  static std::string GetIdentifier(const std::shared_ptr<ast::INode>& node);
 
   std::pair<cypher::PropertyType, std::string>
-  TranslateExpression(const std::shared_ptr<ast::INode>& expr) const;
+  static TranslateExpression(const std::shared_ptr<ast::INode>& expr);
 
-  std::string TranslateMathExpression(const std::shared_ptr<ast::INode>& expr) const;
-  std::string TranslateMathSum(const std::shared_ptr<ast::INode>& sum) const;
-  std::string TranslateMathProduct(const std::shared_ptr<ast::INode>& product) const;
-  std::string TranslateMathPower(const std::shared_ptr<ast::INode>& power) const;
-  std::string TranslateMathValue(const std::shared_ptr<ast::INode>& value) const;
+  static std::string TranslateMathExpression(const std::shared_ptr<ast::INode>& expr);
+  static std::string TranslateMathSum(const std::shared_ptr<ast::INode>& sum);
+  static std::string TranslateMathProduct(const std::shared_ptr<ast::INode>& product);
+  static std::string TranslateMathPower(const std::shared_ptr<ast::INode>& power);
+  static std::string TranslateMathValue(const std::shared_ptr<ast::INode>& value);
 
   void AddPropertyConstraints(const std::string& constraint_name_prefix, const std::string& label,
                               const std::string& property_name,
@@ -120,21 +120,22 @@ class Translator {
       const std::string& end_label, const std::vector<std::string>& end_node_props
   );
   std::string CreateRelationshipType(const std::string& type_prefix);
-  std::string CreatePKConstraintPrefix(const std::string& table_name) const;
-  std::string CreateFKConstraintPrefix(const std::string& table_name,
-                                       const std::string& ref_table_name) const;
+  static std::string CreatePKConstraintPrefix(const std::string& table_name);
+  static std::string CreateFKConstraintPrefix(const std::string& table_name,
+                                              const std::string& ref_table_name);
 
   const schema::Node& GetNodeFromSchema(const std::string& label) const;
 
   // Validation
 
-  bool HasChildren(const std::shared_ptr<ast::INode>& node, unsigned min_children_count = 1) const;
-  bool IsCorrectStmtType(const std::shared_ptr<ast::INode>& node, ast::StmtType stmt_type) const;
+  static bool HasChildren(const std::shared_ptr<ast::INode>& node, unsigned min_children_count = 1);
+  static bool IsCorrectStmtType(const std::shared_ptr<ast::INode>& node, ast::StmtType stmt_type);
 
-  void ValidateHasChildren(const std::shared_ptr<ast::INode>& node, unsigned min_children_count = 1,
-                           const std::string& details = "") const;
-  void ValidateIsCorrectStmtType(const std::shared_ptr<ast::INode>& node,
-                                 ast::StmtType stmt_type) const;
+  static void ValidateHasChildren(const std::shared_ptr<ast::INode>& node, 
+                                  unsigned min_children_count = 1,
+                                  const std::string& details = "");
+  static void ValidateIsCorrectStmtType(const std::shared_ptr<ast::INode>& node,
+                                        ast::StmtType stmt_type);
 };
 
 } // scc::translator
diff --git a/src/config/scc_args.cpp b/src/config/scc_args.cpp
index 295c2e5..fd606f0 100644
--- a/src/config/scc_args.cpp
+++ b/src/config/scc_args.cpp
@@ -2,12 +2,31 @@
 
 namespace scc::config {
 
+using namespace argparse;
+
 no_argument_error::no_argument_error(const std::string& message)
     : std::runtime_error(message) {}
 
-SCCArgs::SCCArgs() : ArgumentParser(PROGRAM_NAME, VERSION, argparse::default_arguments::none) {
+SCCArgumentParser::SCCArgumentParser(std::string_view program_name)
+    : ArgumentParser(std::string(program_name), VERSION, default_arguments::none) {
   set_assign_chars("= ");
+}
+
+SCCArgumentParser& SCCArgumentParser::subparser(std::string_view name) {
+  auto& subparser = at<ArgumentParser>(name);
+  return static_cast<SCCArgumentParser&>(subparser);
+}
+
+bool SCCArgumentParser::IsUsed(const std::string& arg_name) const {
+  return is_used(arg_name);
+}
+
+void SCCArgumentParser::PrintHelpAndExit(int exit_code) const {
+  std::cout << help().str();
+  exit(exit_code);
+}
 
+SCCArgs::SCCArgs() : SCCArgumentParser(PROGRAM_NAME) {
   add_description("Translates SQL queries for MS SQL Server into queries for Neo4j DBMS.");
   add_epilog("Contribute to SCC: " CONTRIBUTE_LINK);
 
@@ -30,37 +49,6 @@ SCCArgs::SCCArgs() : ArgumentParser(PROGRAM_NAME, VERSION, argparse::default_arg
       .implicit_value(true)
       .nargs(0);
 
-  add_argument("--translate-schema")
-      .help("Use this option to translate SQL schema migration queries into Cypher")
-      .default_value(false)
-      .implicit_value(true);
-
-  add_argument("--sql-schema")
-      .help("Specify path to the file with SQL schema migration queries to be converted")
-      .metavar("FILENAME");
-
-  std::string default_graph_schema_file =
-      (std::filesystem::current_path() / "schema.json").string();
-  add_argument("--graph-schema")
-      .help("Specify path to the file with Neo4j graph schema")
-      .metavar("FILENAME")
-      .default_value(default_graph_schema_file);
-
-  add_argument("--translate-data")
-      .help("Use this option to translate SQL data migration queries into Cypher")
-      .default_value(false)
-      .implicit_value(true);
-
-  add_argument("--sql")
-      .help("Specify path to the file with SQL data migration queries to be converted")
-      .metavar("FILENAME");
-
-  std::string default_cypher_file = (std::filesystem::current_path() / "out.cql").string();
-  add_argument("--cypher")
-      .help("Specify path to the file with the result CypherQL queries")
-      .metavar("FILENAME")
-      .default_value(default_cypher_file);
-
   add_argument("--dump")
       .help("Specify path to the PNG image with the dump of SQL AST")
       .metavar("FILENAME");
@@ -92,19 +80,77 @@ void SCCArgs::ParseArgs(int argc, const char* const argv[]) {
 
   try {
     parse_args(argc, argv);
+
+    if (argc == 2) {
+      if (is_subcommand_used(SCC_SCHEMA_SUBCOMMAND)) {
+        auto& schema_subparser = subparser(SCC_SCHEMA_SUBCOMMAND);
+        schema_subparser.PrintHelpAndExit(EXIT_SUCCESS);
+      }
+      if (is_subcommand_used(SCC_DATA_SUBCOMMAND)) {
+        auto& data_subparser = subparser(SCC_DATA_SUBCOMMAND);
+        data_subparser.PrintHelpAndExit(EXIT_SUCCESS);
+      }
+    }
   } catch (const std::runtime_error& e) {
     std::cerr << e.what() << std::endl;
     PrintHelpAndExit(EXIT_FAILURE);
   }
 }
 
-bool SCCArgs::IsUsed(const std::string& arg_name) const {
-  return is_used(arg_name);
+SCCSubcommand::SCCSubcommand(std::string_view name, const std::string& description)
+    : SCCArgumentParser(name) {
+  add_description(description);
+
+  add_argument("-h", "--help")
+      .action([this](const std::string& /*unused*/) {
+        std::cout << help().str();
+        exit(EXIT_SUCCESS);
+      })
+      .help("Show this info")
+      .default_value(false)
+      .implicit_value(true)
+      .nargs(0);
+
+  add_argument("-v", "--version")
+      .action([](const std::string& /*unused*/) {
+        std::cout << "scc version " VERSION << std::endl;
+        exit(EXIT_SUCCESS);
+      })
+      .help("Show version info")
+      .default_value(false)
+      .implicit_value(true)
+      .nargs(0);
 }
 
-void SCCArgs::PrintHelpAndExit(int exit_code) const {
-  std::cout << help().str();
-  exit(exit_code);
+SCCSubcommandSchema::SCCSubcommandSchema()
+    : SCCSubcommand(SCC_SCHEMA_SUBCOMMAND, "Translate SQL schema migration queries into Cypher.") {
+  add_argument("--sql")
+      .help("Specify path to the file with SQL schema migration queries to be converted")
+      .metavar("FILENAME");
+
+  std::string default_graph_schema_file =
+      (std::filesystem::current_path() / "schema.json").string();
+  add_argument("--graph-schema")
+      .help("Specify path to the file with Neo4j graph schema")
+      .metavar("FILENAME")
+      .default_value(default_graph_schema_file);
+}
+
+SCCSubcommandData::SCCSubcommandData()
+    : SCCSubcommand(SCC_DATA_SUBCOMMAND, "Translate SQL data migration queries into Cypher.") {
+  add_argument("--graph-schema")
+      .help("Specify path to the file with Neo4j graph schema")
+      .metavar("FILENAME");
+
+  add_argument("--sql")
+      .help("Specify path to the file with SQL data migration queries to be converted")
+      .metavar("FILENAME");
+
+  std::string default_cypher_file = (std::filesystem::current_path() / "out.cql").string();
+  add_argument("--cypher")
+      .help("Specify path to the file with the result CypherQL queries")
+      .metavar("FILENAME")
+      .default_value(default_cypher_file);
 }
 
 } // scc::config
diff --git a/src/config/scc_config.cpp b/src/config/scc_config.cpp
index 2db4f68..11bd39e 100644
--- a/src/config/scc_config.cpp
+++ b/src/config/scc_config.cpp
@@ -16,45 +16,50 @@ namespace scc::config {
 
 namespace fs = std::filesystem;
 
-SCCConfig::SCCConfig(const SCCArgs& args) {
+SCCConfig::SCCConfig(SCCArgs& args) {
   try {
-    if (args.IsUsed("--log-severity"))
-      log_severity = logger::to_severity(args.Get("--log-severity"));
-    else
-      log_severity = args.Get<logger::Severity>("--log-severity");
-
+    log_severity = args.IsUsed("--log-severity")
+                   ? logger::to_severity(args.Get("--log-severity"))
+                   : args.Get<logger::Severity>("--log-severity");
     log_directory = fs::weakly_canonical(args.Get("--log-directory"));
 
-    if (args.IsUsed("--mode"))
-      mode = SCCMode(args.Get("--mode"));
-    else
-      mode = args.Get<SCCMode>("--mode");
+    mode = args.IsUsed("--mode")
+           ? SCCMode(args.Get("--mode"))
+           : args.Get<SCCMode>("--mode");
+
+    if (args.IsUsed("--dump")) {
+      ast_dump_file_ = fs::weakly_canonical(args.Get("--dump"));
+    }
+
+    if (args.is_subcommand_used(SCC_SCHEMA_SUBCOMMAND)) {
+      translate_schema = true;
+      SCCArgumentParser& schema_subparser = args.subparser(SCC_SCHEMA_SUBCOMMAND);
 
-    translate_schema = args.Get<bool>("--translate-schema");
-    if (translate_schema) {
-      std::string sql_schema_file_path = args.Get("--sql-schema");
+      std::string sql_schema_file_path = schema_subparser.Get("--sql");
       scc::common::ValidateFileExists(sql_schema_file_path);
       sql_schema_file_ = fs::canonical(sql_schema_file_path);
+
+      graph_schema_file_ = fs::weakly_canonical(schema_subparser.Get("--graph-schema"));
     }
-    graph_schema_file_ = fs::weakly_canonical(args.Get("--graph-schema"));
-
-    translate_data = args.Get<bool>("--translate-data");
-    if (translate_data) {
-      if (!translate_schema) {
-        scc::common::ValidateFileExists(graph_schema_file_);
-      }
-      std::string sql_file_path = args.Get("--sql");
+
+    if (args.is_subcommand_used(SCC_DATA_SUBCOMMAND)) {
+      translate_data = true;
+      SCCArgumentParser& data_subparser = args.subparser(SCC_DATA_SUBCOMMAND);
+
+      std::string graph_schema_file_path = data_subparser.Get("--graph-schema");
+      scc::common::ValidateFileExists(graph_schema_file_path);
+      graph_schema_file_ = fs::canonical(graph_schema_file_path);
+
+      std::string sql_file_path = data_subparser.Get("--sql");
       scc::common::ValidateFileExists(sql_file_path);
       sql_file_ = fs::canonical(sql_file_path);
-      cypher_file_ = fs::weakly_canonical(args.Get("--cypher"));
+
+      cypher_file_ = fs::weakly_canonical(data_subparser.Get("--cypher"));
     }
 
     if (!(translate_schema || translate_data)) {
       throw std::logic_error("Either --translate-schema or --translate-data must be specified");
     }
-
-    if (args.IsUsed("--dump"))
-      ast_dump_file_ = fs::weakly_canonical(args.Get("--dump"));
   } catch (const std::logic_error& e) {
     ThrowFailedConfigCreation(e);
   } catch (const std::runtime_error& e) {
@@ -85,7 +90,7 @@ const fs::path& SCCConfig::get_ast_dump_file() const {
   return ast_dump_file_;
 }
 
-void InitConfig(const SCCArgs& args) {
+void InitConfig(SCCArgs& args) {
   static SCCConfig scc_config(args);
 }
 
diff --git a/src/main.cpp b/src/main.cpp
index 7b7760b..8f25f3d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,6 +3,11 @@
 int main(int argc, char* argv[]) {
   try {
     scc::config::SCCArgs scc_args;
+    scc::config::SCCSubcommandSchema scc_schema_subcommand;
+    scc_args.add_subparser(scc_schema_subcommand);
+    scc::config::SCCSubcommandData scc_data_subcommand;
+    scc_args.add_subparser(scc_data_subcommand);
+
     scc_args.ParseArgs(argc, argv);
 
     scc::config::InitConfig(scc_args);
diff --git a/src/parser/common/basic_statements.cpp b/src/parser/common/basic_statements.cpp
index 7a503b6..a06f972 100644
--- a/src/parser/common/basic_statements.cpp
+++ b/src/parser/common/basic_statements.cpp
@@ -12,7 +12,7 @@ template<typename NodeType,
     typename std::enable_if<std::is_base_of<INode, NodeType>::value>::type* = nullptr>
 using NodePtr = std::shared_ptr<NodeType>;
 
-StmtType Parser::DetermineConstraintType(const std::string& keyword) const {
+StmtType Parser::DetermineConstraintType(const std::string& keyword) {
   if (DetermineIsPrimaryKey(keyword)) {
     return StmtType::kPrimaryKey;
   } else if (DetermineIsForeignKey(keyword)) {
@@ -20,7 +20,7 @@ StmtType Parser::DetermineConstraintType(const std::string& keyword) const {
   }
   return StmtType::kNone;
 }
-StmtType Parser::DetermineAlterTableActionType(const std::string& keyword) const {
+StmtType Parser::DetermineAlterTableActionType(const std::string& keyword) {
   std::string keyword_lower = scc::common::LowerCase(keyword);
   if (kST_ADD_KW.find(keyword_lower) == 0) {
     return StmtType::kAddKW;
@@ -29,7 +29,7 @@ StmtType Parser::DetermineAlterTableActionType(const std::string& keyword) const
   }
   return StmtType::kNone;
 }
-StmtType Parser::DetermineDropElementType(const std::string& keyword) const {
+StmtType Parser::DetermineDropElementType(const std::string& keyword) {
   std::string keyword_lower = scc::common::LowerCase(keyword);
   if (kST_CONSTRAINT_KW.find(keyword_lower) == 0) {
     return StmtType::kDropConstraint;
@@ -38,7 +38,7 @@ StmtType Parser::DetermineDropElementType(const std::string& keyword) const {
   }
   return StmtType::kNone;
 }
-StmtType Parser::DetermineLogicalOperatorType(const std::string& keyword) const {
+StmtType Parser::DetermineLogicalOperatorType(const std::string& keyword) {
   if (DetermineIsOROperator(keyword)) {
     return StmtType::kOROperator;
   } else if (DetermineIsANDOperator(keyword)) {
@@ -49,28 +49,28 @@ StmtType Parser::DetermineLogicalOperatorType(const std::string& keyword) const
   return StmtType::kNone;
 }
 
-bool Parser::DetermineIsFullConstraintDefinition(const std::string& keyword) const {
+bool Parser::DetermineIsFullConstraintDefinition(const std::string& keyword) {
   return DetermineIsPrefix(kST_CONSTRAINT_KW, keyword);
 }
-bool Parser::DetermineIsPrimaryKey(const std::string& keyword) const {
+bool Parser::DetermineIsPrimaryKey(const std::string& keyword) {
   return DetermineIsPrefix(kST_PRIMARY_KEY, keyword);
 }
-bool Parser::DetermineIsForeignKey(const std::string& keyword) const {
+bool Parser::DetermineIsForeignKey(const std::string& keyword) {
   return DetermineIsPrefix(kST_FOREIGN_KEY, keyword);
 }
-bool Parser::DetermineIsReferences(const std::string& keyword) const {
+bool Parser::DetermineIsReferences(const std::string& keyword) {
   return DetermineIsPrefix(kST_REFERENCES_KW, keyword);
 }
-bool Parser::DetermineIsOROperator(const std::string& keyword) const {
+bool Parser::DetermineIsOROperator(const std::string& keyword) {
   return DetermineIsPrefix(kST_OR_OPERATOR, keyword);
 }
-bool Parser::DetermineIsANDOperator(const std::string& keyword) const {
+bool Parser::DetermineIsANDOperator(const std::string& keyword) {
   return DetermineIsPrefix(kST_AND_OPERATOR, keyword);
 }
-bool Parser::DetermineIsNOTOperator(const std::string& keyword) const {
+bool Parser::DetermineIsNOTOperator(const std::string& keyword) {
   return DetermineIsPrefix(kST_NOT_OPERATOR, keyword);
 }
-bool Parser::DetermineIsPrefix(const std::string_view& string, const std::string& prefix) const {
+bool Parser::DetermineIsPrefix(const std::string_view& string, const std::string& prefix) {
   return string.find(scc::common::LowerCase(prefix)) == 0;
 }
 
diff --git a/src/parser/common/validation.cpp b/src/parser/common/validation.cpp
index 8bf1683..ccd8bac 100644
--- a/src/parser/common/validation.cpp
+++ b/src/parser/common/validation.cpp
@@ -36,44 +36,44 @@ void Parser::ValidateHasNotTokens() const {
     throw parsing_error("Unexpected non empty tokens array");
   }
 }
-void Parser::ValidateIsWord(const NodePtr<INode>& node) const {
+void Parser::ValidateIsWord(const NodePtr<INode>& node) {
   if (!NodeDataTypeClassifier::IsWord(node)) {
     std::string msg = format("Expected Word at line {}", node->line);
     throw parsing_error(msg);
   }
 }
-void Parser::ValidateIsOpeningRoundBracket(const NodePtr<INode>& node) const {
+void Parser::ValidateIsOpeningRoundBracket(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsOpeningRoundBracket(node)) {
     std::string msg = format("Expected Opening Round Bracket at line {}", node->line);
     throw parsing_error(msg);
   }
 }
-void Parser::ValidateIsClosingRoundBracket(const NodePtr<INode>& node) const {
+void Parser::ValidateIsClosingRoundBracket(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsClosingRoundBracket(node)) {
     std::string msg = format("Expected Closing Round Bracket at line {}", node->line);
     throw parsing_error(msg);
   }
 }
-void Parser::ValidateIsSingleQuote(const NodePtr<INode>& node) const {
+void Parser::ValidateIsSingleQuote(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsSingleQuote(node)) {
     std::string msg = format("Expected Single Quote at line {}", node->line);
     throw parsing_error(msg);
   }
 }
-void Parser::ValidateIsDoubleQuote(const NodePtr<INode>& node) const {
+void Parser::ValidateIsDoubleQuote(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsSingleQuote(node)) {
     std::string msg = format("Expected Double Quote at line {}", node->line);
     throw parsing_error(msg);
   }
 }
-void Parser::ValidateIsBinaryOperator(const NodePtr<INode>& node) const {
+void Parser::ValidateIsBinaryOperator(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsBinaryOperator(node)) {
     std::string msg = format("Expected Binary Operator at line {}", node->line);
     throw parsing_error(msg);
   }
 }
 
-void Parser::ValidateIsAssignmentOperator(const NodePtr<INode>& node) const {
+void Parser::ValidateIsAssignmentOperator(const NodePtr<INode>& node) {
   if (!NodeDataClassifier::IsAssignmentOperator(node)) {
     std::string msg = format("Expected Assignment Operator at line {}", node->line);
     throw parsing_error(msg);
diff --git a/src/translator/common/basic_statements.cpp b/src/translator/common/basic_statements.cpp
index c127231..fa95f7f 100644
--- a/src/translator/common/basic_statements.cpp
+++ b/src/translator/common/basic_statements.cpp
@@ -85,7 +85,7 @@ void Translator::TranslateForeignKey(const ASTNodePtr<INode>& foreign_key,
   AddRelationship(relationship_type, table_name, ref_table_name, apply_conditions);
 }
 
-std::string Translator::GetName(const ASTNodePtr<INode>& name_node) const {
+std::string Translator::GetName(const ASTNodePtr<INode>& name_node) {
   std::ostringstream name;
   ValidateHasChildren(name_node);
   for (unsigned i = 0; HasChildren(name_node, i + 1); ++i) {
@@ -95,7 +95,7 @@ std::string Translator::GetName(const ASTNodePtr<INode>& name_node) const {
   }
   return name.str();
 }
-std::string Translator::GetIdentifier(const ASTNodePtr<INode>& node) const {
+std::string Translator::GetIdentifier(const ASTNodePtr<INode>& node) {
   return ASTUtils::CastToNodeType<StringNode>(node->Child(0))->data;
 }
 
@@ -135,11 +135,11 @@ std::string Translator::CreateRelationshipType(const std::string& type_prefix) {
   relationship_counter++;
   return type;
 }
-std::string Translator::CreatePKConstraintPrefix(const std::string& table_name) const {
+std::string Translator::CreatePKConstraintPrefix(const std::string& table_name) {
   return format("{}_pk_", table_name);
 }
 std::string Translator::CreateFKConstraintPrefix(const std::string& table_name,
-                                                 const std::string& ref_table_name) const {
+                                                 const std::string& ref_table_name) {
   return format("fk_{}_to_{}_", table_name, ref_table_name);
 }
 
diff --git a/src/translator/common/validation.cpp b/src/translator/common/validation.cpp
index 3d3fd98..69a184b 100644
--- a/src/translator/common/validation.cpp
+++ b/src/translator/common/validation.cpp
@@ -14,23 +14,23 @@ using NodePtr = std::shared_ptr<NodeType>;
 translation_error::translation_error(const std::string& message) : std::logic_error(message) {}
 
 bool Translator::HasChildren(const std::shared_ptr<ast::INode>& node,
-                             unsigned min_children_count) const {
+                             unsigned min_children_count) {
   return node->ChildrenCount() >= min_children_count;
 }
 bool Translator::IsCorrectStmtType(const std::shared_ptr<ast::INode>& node,
-                                   ast::StmtType stmt_type) const {
+                                   ast::StmtType stmt_type) {
   return node->stmt_type == stmt_type;
 }
 
 void Translator::ValidateHasChildren(const NodePtr<INode>& node, unsigned min_children_count,
-                                     const std::string& details) const {
+                                     const std::string& details) {
   if (!HasChildren(node, min_children_count)) {
     std::string msg = "Unexpected absence of child nodes";
     std::string cause = (details.empty() ? "" : (": " + details));
     throw translation_error(msg + cause);
   }
 }
-void Translator::ValidateIsCorrectStmtType(const NodePtr<INode>& node, StmtType stmt_type) const {
+void Translator::ValidateIsCorrectStmtType(const NodePtr<INode>& node, StmtType stmt_type) {
   if (!IsCorrectStmtType(node, stmt_type)) {
     throw translation_error(format("Unexpected statement type \'{}\': expected \'{}\'",
                                    UpperCase(node->stmt_type.ToString()),
diff --git a/src/translator/dml/conditions.cpp b/src/translator/dml/conditions.cpp
index dbd61a2..238cf9f 100644
--- a/src/translator/dml/conditions.cpp
+++ b/src/translator/dml/conditions.cpp
@@ -15,7 +15,7 @@ template<typename T, typename U>
 using Pair = std::pair<T, U>;
 
 Pair<PropertyType, std::string>
-Translator::TranslateExpression(const ASTNodePtr<INode>& expr) const {
+Translator::TranslateExpression(const ASTNodePtr<INode>& expr) {
   auto value_node = expr->Child(0);
 
   if (IsCorrectStmtType(value_node, StmtType::kName)) {
diff --git a/src/translator/dml/math_expressions.cpp b/src/translator/dml/math_expressions.cpp
index 6b72493..de3d203 100644
--- a/src/translator/dml/math_expressions.cpp
+++ b/src/translator/dml/math_expressions.cpp
@@ -11,7 +11,7 @@ template<typename ASTNodeType,
     typename std::enable_if<std::is_base_of<INode, ASTNodeType>::value>::type* = nullptr>
 using ASTNodePtr = std::shared_ptr<ASTNodeType>;
 
-std::string Translator::TranslateMathExpression(const ASTNodePtr<INode>& expr) const {
+std::string Translator::TranslateMathExpression(const ASTNodePtr<INode>& expr) {
   std::stringstream ss;
 
   auto sum_node = expr->Child(0);
@@ -22,7 +22,7 @@ std::string Translator::TranslateMathExpression(const ASTNodePtr<INode>& expr) c
 
   return ss.str();
 }
-std::string Translator::TranslateMathSum(const ASTNodePtr<INode>& sum) const {
+std::string Translator::TranslateMathSum(const ASTNodePtr<INode>& sum) {
   std::stringstream ss;
 
   auto left_product_node = sum->Child(0);
@@ -45,7 +45,7 @@ std::string Translator::TranslateMathSum(const ASTNodePtr<INode>& sum) const {
 
   return ss.str();
 }
-std::string Translator::TranslateMathProduct(const ASTNodePtr<INode>& product) const {
+std::string Translator::TranslateMathProduct(const ASTNodePtr<INode>& product) {
   std::stringstream ss;
 
   auto left_power_node = product->Child(0);
@@ -68,7 +68,7 @@ std::string Translator::TranslateMathProduct(const ASTNodePtr<INode>& product) c
 
   return ss.str();
 }
-std::string Translator::TranslateMathPower(const ASTNodePtr<INode>& power) const {
+std::string Translator::TranslateMathPower(const ASTNodePtr<INode>& power) {
   std::stringstream ss;
 
   auto value_node = power->Child(0);
@@ -91,7 +91,7 @@ std::string Translator::TranslateMathPower(const ASTNodePtr<INode>& power) const
 
   return ss.str();
 }
-std::string Translator::TranslateMathValue(const ASTNodePtr<INode>& value) const {
+std::string Translator::TranslateMathValue(const ASTNodePtr<INode>& value) {
   std::stringstream ss;
 
   auto node = value->Child(0);