Parser::DumpRestoreTableStmtBase Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::DumpRestoreTableStmtBase:

Collaboration diagram for Parser::DumpRestoreTableStmtBase:

Public Types
enum	CompressionType { CompressionType::kGZIP, CompressionType::kLZ4, CompressionType::kNONE }

Public Member Functions
	DumpRestoreTableStmtBase (std::string *tab, std::string *path, std::list< NameValueAssign * > *options, const bool is_restore)
	DumpRestoreTableStmtBase (const rapidjson::Value &payload, const bool is_restore)
CompressionType	defaultCompression (bool is_restore)
CompressionType	validateCompression (const std::string &compression, const bool is_restore)
std::string	tarCompressionStr (CompressionType compression, const bool is_restore)
const std::string *	getTable () const
const std::string *	getPath () const
const CompressionType	getCompression () const
Public Member Functions inherited from Parser::DDLStmt
virtual void	execute (const Catalog_Namespace::SessionInfo &session, bool read_only_mode)=0
void	setColumnDescriptor (ColumnDescriptor &cd, const ColumnDef *coldef)
Public Member Functions inherited from Parser::Node
virtual	~Node ()

Protected Attributes
std::unique_ptr< std::string >	table_
std::unique_ptr< std::string >	path_
CompressionType	compression_

Detailed Description

Definition at line 1424 of file ParserNode.h.

Member Enumeration Documentation

enum Parser::DumpRestoreTableStmtBase::CompressionType

strong

Enumerator
kGZIP
kLZ4
kNONE

Definition at line 1467 of file ParserNode.h.

{ kGZIP, kLZ4, kNONE };

Constructor & Destructor Documentation

Parser::DumpRestoreTableStmtBase::DumpRestoreTableStmtBase ( std::string *  tab, std::string *  path, std::list< NameValueAssign * > *  options, const bool  is_restore  )

inline

Definition at line 1426 of file ParserNode.h.

References compression_, defaultCompression(), and validateCompression().

      : table_(tab), path_(path) {
    for (const auto& program : {"tar", "rm", "mkdir", "mv", "cat"}) {
      if (boost::process::search_path(program).empty()) {
        throw std::runtime_error{"Required program \"" + std::string{program} +
                                 "\" was not found."};
      }
    }
    auto options_deleter = [](std::list<NameValueAssign*>* options) {
      for (auto option : *options) {
        delete option;
      }
      delete options;
    };

    compression_ = defaultCompression(is_restore);

    std::unique_ptr<std::list<NameValueAssign*>, decltype(options_deleter)> options_ptr(
        options, options_deleter);
    // specialize decompressor or break on osx bsdtar...
    if (options) {
      for (const auto option : *options) {
        if (boost::iequals(*option->get_name(), "compression")) {
          if (const auto str_literal =
                  dynamic_cast<const StringLiteral*>(option->get_value())) {
            compression_ = validateCompression(*str_literal->get_stringval(), is_restore);
          } else {
            throw std::runtime_error("Compression option must be a string.");
          }
        } else {
          throw std::runtime_error("Invalid WITH option: " + *option->get_name());
        }
      }
    }
  }

Here is the call graph for this function:

Parser::DumpRestoreTableStmtBase::DumpRestoreTableStmtBase	(	const rapidjson::Value &	payload,
		const bool	is_restore
	)

Definition at line 6704 of file ParserNode.cpp.

References CHECK, Parser::checkStringLiteral(), compression_, defaultCompression(), json_str(), Parser::anonymous_namespace{ParserNode.cpp}::parse_options(), path_, table_, and validateCompression().

                                                                          {
  CHECK(payload.HasMember("tableName"));
  table_ = std::make_unique<std::string>(json_str(payload["tableName"]));

  CHECK(payload.HasMember("filePath"));
  path_ = std::make_unique<std::string>(json_str(payload["filePath"]));

  compression_ = defaultCompression(is_restore);

  std::list<std::unique_ptr<NameValueAssign>> options;
  parse_options(payload, options);

  if (!options.empty()) {
    for (auto& p : options) {
      if (boost::iequals(*p->get_name(), "compression")) {
        checkStringLiteral("compression", p);
        const auto str_literal = static_cast<const StringLiteral*>(p->get_value());
        compression_ = validateCompression(*str_literal->get_stringval(), is_restore);
      }
    }
  }

  for (const auto& program : {"tar", "rm", "mkdir", "mv", "cat"}) {
    if (boost::process::search_path(program).empty()) {
      throw std::runtime_error{"Required program \"" + std::string{program} +
                               "\" was not found."};
    }
  }
}

Here is the call graph for this function:

Member Function Documentation

DumpRestoreTableStmtBase::CompressionType Parser::DumpRestoreTableStmtBase::defaultCompression

(

bool

is_restore

)

Definition at line 6736 of file ParserNode.cpp.

References kGZIP, kLZ4, kNONE, Parser::Compress::sGZIP, Parser::Compress::sLZ4, Parser::Compress::sUNGZIP, and Parser::Compress::sUNLZ4.

Referenced by DumpRestoreTableStmtBase().

                           {
  if (boost::process::search_path(is_restore ? Compress::sUNGZIP : Compress::sGZIP)
          .string()
          .size()) {
    return CompressionType::kGZIP;
  } else if (boost::process::search_path(is_restore ? Compress::sUNLZ4 : Compress::sLZ4)
                 .string()
                 .size()) {
    return CompressionType::kLZ4;
  }
  return CompressionType::kNONE;
}

Here is the caller graph for this function:

const CompressionType Parser::DumpRestoreTableStmtBase::getCompression ( ) const

inline

Definition at line 1481 of file ParserNode.h.

References compression_.

{ return compression_; }

const std::string* Parser::DumpRestoreTableStmtBase::getPath ( ) const

inline

Definition at line 1480 of file ParserNode.h.

References path_.

{ return path_.get(); }

const std::string* Parser::DumpRestoreTableStmtBase::getTable ( ) const

inline

Definition at line 1479 of file ParserNode.h.

References table_.

{ return table_.get(); }

std::string Parser::DumpRestoreTableStmtBase::tarCompressionStr	(	CompressionType	compression,
		const bool	is_restore
	)

Definition at line 6781 of file ParserNode.cpp.

References kGZIP, kLZ4, Parser::Compress::sGZIP, Parser::Compress::sLZ4, Parser::Compress::sUNGZIP, and Parser::Compress::sUNLZ4.

Referenced by Parser::DumpTableStmt::execute(), and Parser::RestoreTableStmt::execute().

                                                                               {
  if (compression_type == CompressionType::kGZIP) {
    return "--use-compress-program=" + (is_restore ? Compress::sUNGZIP : Compress::sGZIP);
  } else if (compression_type == CompressionType::kLZ4) {
    return "--use-compress-program=" + (is_restore ? Compress::sUNLZ4 : Compress::sLZ4);
  }
  // kNONE uses "none' as a user input, but an empty string "" for tar
  return "";
}

Here is the caller graph for this function:

DumpRestoreTableStmtBase::CompressionType Parser::DumpRestoreTableStmtBase::validateCompression	(	const std::string &	compression,
		const bool	is_restore
	)

Definition at line 6750 of file ParserNode.cpp.

References kGZIP, kLZ4, kNONE, Parser::Compress::sGZIP, Parser::Compress::sLZ4, Parser::Compress::sNONE, Parser::Compress::sUNGZIP, and Parser::Compress::sUNLZ4.

Referenced by DumpRestoreTableStmtBase().

                           {
  // only allow ('gzip', 'lz4', 'none') compression types
  const std::string compression = boost::algorithm::to_lower_copy(compression_type);

  // verify correct compression executable is available
  if (boost::iequals(compression, Compress::sGZIP)) {
    const auto prog_name = is_restore ? Compress::sUNGZIP : Compress::sGZIP;
    const auto prog_path = boost::process::search_path(prog_name);
    if (prog_path.string().empty()) {
      throw std::runtime_error("Compression program " + prog_name + " is not found.");
    }
    return CompressionType::kGZIP;

  } else if (boost::iequals(compression, Compress::sLZ4)) {
    const auto prog_name = is_restore ? Compress::sUNLZ4 : Compress::sLZ4;
    const auto prog_path = boost::process::search_path(prog_name);
    if (prog_path.string().empty()) {
      throw std::runtime_error("Compression program " + prog_name + " is not found.");
    }
    return CompressionType::kLZ4;

  } else if (!boost::iequals(compression, Compress::sNONE)) {
    throw std::runtime_error("Compression program " + compression + " is not supported.");
  }

  return CompressionType::kNONE;
}

Here is the caller graph for this function:

Member Data Documentation

CompressionType Parser::DumpRestoreTableStmtBase::compression_

protected

Definition at line 1486 of file ParserNode.h.

Referenced by DumpRestoreTableStmtBase(), Parser::DumpTableStmt::execute(), Parser::RestoreTableStmt::execute(), and getCompression().

std::unique_ptr<std::string> Parser::DumpRestoreTableStmtBase::path_

protected

Definition at line 1485 of file ParserNode.h.

Referenced by DumpRestoreTableStmtBase(), Parser::DumpTableStmt::execute(), Parser::RestoreTableStmt::execute(), and getPath().

std::unique_ptr<std::string> Parser::DumpRestoreTableStmtBase::table_

protected

Definition at line 1484 of file ParserNode.h.

Referenced by DumpRestoreTableStmtBase(), Parser::DumpTableStmt::execute(), Parser::RestoreTableStmt::execute(), and getTable().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.h
• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.cpp