foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp} Namespace Reference

Functions
size_t	find_last_end_of_line (const char *buffer, size_t buffer_size, size_t start, size_t end, char line_delim)
bool	line_starts_with_regex (const char *buffer, size_t start, size_t end, const boost::regex &line_start_regex)
std::optional< std::string >	get_line_start_regex (const ForeignTable *foreign_table)
std::string	get_line_regex (const ForeignTable *foreign_table)
std::string	get_next_row (const char *curr, const char *buffer_end, char line_delim, const std::optional< boost::regex > &line_start_regex)
size_t	get_row_count (const char *buffer, size_t start, size_t end, char line_delim, const std::optional< boost::regex > &line_start_regex)
bool	regex_match_columns (const std::string &row_str, const boost::regex &line_regex, size_t logical_column_count, std::vector< std::string > &parsed_columns_str, std::vector< std::string_view > &parsed_columns_sv, const std::string &file_path)

Function Documentation

size_t foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::find_last_end_of_line	(	const char *	buffer,
		size_t	buffer_size,
		size_t	start,
		size_t	end,
		char	line_delim
	)

Definition at line 29 of file RegexFileBufferParser.cpp.

References i, and to_string().

Referenced by foreign_storage::RegexFileBufferParser::findRowEndPosition().

                                              {
  int64_t i = end;
  while (i >= static_cast<int64_t>(start)) {
    if (buffer[i] == line_delim) {
      return i;
    } else {
      i--;
    }
  }
  throw InsufficientBufferSizeException{
      "Unable to find an end of line character after reading " +
      std::to_string(buffer_size) + " characters."};
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::get_line_regex

(

const ForeignTable *

foreign_table

)

Definition at line 66 of file RegexFileBufferParser.cpp.

References CHECK, foreign_storage::RegexFileBufferParser::LINE_REGEX_KEY, and foreign_storage::OptionsContainer::options.

                                                            {
  if (foreign_table) {
    auto it = foreign_table->options.find(RegexFileBufferParser::LINE_REGEX_KEY);
    CHECK(it != foreign_table->options.end());
    return it->second;
  }
  return {};
}

std::optional<std::string> foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::get_line_start_regex

(

const ForeignTable *

foreign_table

)

Definition at line 56 of file RegexFileBufferParser.cpp.

References foreign_storage::RegexFileBufferParser::LINE_START_REGEX_KEY, and foreign_storage::OptionsContainer::options.

Referenced by foreign_storage::RegexFileBufferParser::validateFiles().

                                                                               {
  if (foreign_table) {
    auto it = foreign_table->options.find(RegexFileBufferParser::LINE_START_REGEX_KEY);
    if (it != foreign_table->options.end()) {
      return it->second;
    }
  }
  return {};
}

Here is the caller graph for this function:

std::string foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::get_next_row	(	const char *	curr,
		const char *	buffer_end,
		char	line_delim,
		const std::optional< boost::regex > &	line_start_regex
	)

Definition at line 75 of file RegexFileBufferParser.cpp.

References CHECK, and line_starts_with_regex().

Referenced by get_row_count(), and foreign_storage::RegexFileBufferParser::parseBuffer().

                                                                          {
  auto row_end = curr;
  bool row_found{false};
  while (!row_found && row_end <= buffer_end) {
    if (*row_end == line_delim) {
      if (row_end == buffer_end) {
        row_found = true;
      } else if (line_start_regex.has_value()) {
        // When a LINE_START_REGEX option is present, concatenate the following lines
        // until a line that starts with the specified regex is found.
        CHECK(line_starts_with_regex(curr, 0, row_end - curr, line_start_regex.value()));
        auto row_str = get_next_row(row_end + 1, buffer_end, line_delim, {});
        while (!line_starts_with_regex(
            row_str.c_str(), 0, row_str.length() - 1, line_start_regex.value())) {
          row_end += row_str.length() + 1;
          if (row_end == buffer_end) {
            break;
          }
          row_str = get_next_row(row_end + 1, buffer_end, line_delim, {});
        }
        row_found = true;
      } else {
        row_found = true;
      }
    }
    row_end++;
  }
  CHECK(row_found);
  return std::string{curr, static_cast<size_t>(row_end - curr - 1)};
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::get_row_count	(	const char *	buffer,
		size_t	start,
		size_t	end,
		char	line_delim,
		const std::optional< boost::regex > &	line_start_regex
	)

Definition at line 109 of file RegexFileBufferParser.cpp.

References get_next_row().

Referenced by foreign_storage::RegexFileBufferParser::findRowEndPosition().

                                                                      {
  size_t row_count{0};
  auto buffer_end = buffer + end;
  auto curr = buffer + start;
  while (curr <= buffer_end) {
    auto row_str = get_next_row(curr, buffer_end, line_delim, line_start_regex);
    curr += row_str.length() + 1;
    row_count++;
  }
  return row_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::line_starts_with_regex	(	const char *	buffer,
		size_t	start,
		size_t	end,
		const boost::regex &	line_start_regex
	)

Definition at line 47 of file RegexFileBufferParser.cpp.

Referenced by foreign_storage::RegexFileBufferParser::findRowEndPosition(), get_next_row(), and foreign_storage::RegexFileBufferParser::validateFiles().

                                                                {
  return boost::regex_search(std::string{buffer + start, end - start + 1},
                             line_start_regex,
                             boost::regex_constants::match_continuous);
}

Here is the caller graph for this function:

bool foreign_storage::anonymous_namespace{RegexFileBufferParser.cpp}::regex_match_columns	(	const std::string &	row_str,
		const boost::regex &	line_regex,
		size_t	logical_column_count,
		std::vector< std::string > &	parsed_columns_str,
		std::vector< std::string_view > &	parsed_columns_sv,
		const std::string &	file_path
	)

Definition at line 125 of file RegexFileBufferParser.cpp.

References CHECK_GT, i, and foreign_storage::throw_number_of_columns_mismatch_error().

Referenced by foreign_storage::RegexFileBufferParser::parseBuffer().

                                                     {
  parsed_columns_str.clear();
  parsed_columns_sv.clear();
  boost::smatch match;
  bool set_all_nulls{false};
  if (boost::regex_match(row_str, match, line_regex)) {
    auto matched_column_count = match.size() - 1;
    if (logical_column_count != matched_column_count) {
      throw_number_of_columns_mismatch_error(
          logical_column_count, matched_column_count, file_path);
    }
    CHECK_GT(match.size(), static_cast<size_t>(1));
    for (size_t i = 1; i < match.size(); i++) {
      parsed_columns_str.emplace_back(match[i].str());
      parsed_columns_sv.emplace_back(parsed_columns_str.back());
    }
  } else {
    parsed_columns_sv =
        std::vector<std::string_view>(logical_column_count, std::string_view{});
    set_all_nulls = true;
  }
  return set_all_nulls;
}

Here is the call graph for this function:

Here is the caller graph for this function: