Method parse

src/db/sqlengine/parser/zvec_sql_parser.cc:35–92

namespace zvec::sqlengine {

SQLInfo::Ptr ZVecSQLParser::parse(const std::string &query,
                                  bool need_formatted_tree) {
  try {
    ANTLRInputStream input(query);
    CaseChangingCharStream in(&input, true);

    SQLLexer lexer(&in);

    CommonTokenStream tokens(&lexer);

    SQLParser parser(&tokens);

    // remove and add new error listeners
    ErrorVerboseListener lexer_error_listener;
    lexer.removeErrorListeners();  // remove all error listeners
    lexer.addErrorListener((ANTLRErrorListener *)&lexer_error_listener);  // add
    ErrorVerboseListener parser_error_listener;
    parser.removeErrorListeners();  // remove all error listeners
    parser.addErrorListener(
        (ANTLRErrorListener *)&parser_error_listener);  // add

    // int64_t curtime = Util::cur_micro_second_time();
    ParseTree *tree = parser.compilation_unit();

    if (lexer.getNumberOfSyntaxErrors() > 0 ||
        parser.getNumberOfSyntaxErrors() > 0) {
      LOG_INFO("SLL failed. using LL");
      tokens.reset();
      parser.reset();
      parser.getInterpreter<ParserATNSimulator>()->setPredictionMode(
          PredictionMode::LL);
      tree = parser.compilation_unit();
    }

    // int64_t duration = Util::cur_micro_second_time() - curtime;
    // printf("parsing time %ld\n", duration);
    // LOG_DEBUG("antlr parsing time: [%ld]", duration);

    if (lexer.getNumberOfSyntaxErrors() > 0) {
      err_msg_ = "lexer error [" + lexer_error_listener.err_msg() + "]";
      return nullptr;
    }
    if (parser.getNumberOfSyntaxErrors() > 0) {
      err_msg_ = "syntax error [" + parser_error_listener.err_msg() + "]";
      return nullptr;
    }

    if (need_formatted_tree) {
      formatted_tree_ = to_formatted_string_tree(tree, &parser);
    }

    SQLInfo::Ptr sqlInfo = sql_info(tree);
    return sqlInfo;
  } catch (std::exception &e) {
    err_msg_ = "parse error [" + std::string(e.what()) + "]";
    return nullptr;
  }
}