#include <ParserNode.h>

Inheritance diagram for Parser::DumpRestoreTableStmtBase:

Collaboration diagram for Parser::DumpRestoreTableStmtBase:

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

const std::string *	getTable () const

const std::string *	getPath () const

const std::string	getCompression () const

Public Member Functions inherited from Parser::DDLStmt
virtual void	execute (const Catalog_Namespace::SessionInfo &session)=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

std::string	compression

Detailed Description

Definition at line 1387 of file ParserNode.h.

Constructor & Destructor Documentation

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

inline

Definition at line 1389 of file ParserNode.h.

References compression.

       : table(tab), path(path) {
     auto options_deleter = [](std::list<NameValueAssign*>* options) {
       for (auto option : *options) {
         delete option;
       }
       delete options;
     };
     std::unique_ptr<std::list<NameValueAssign*>, decltype(options_deleter)> options_ptr(
         options, options_deleter);
     std::vector<std::string> allowed_compression_programs{"lz4", "gzip", "none"};
     // 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 = *str_literal->get_stringval();
             const std::string lowercase_compression =
                 boost::algorithm::to_lower_copy(compression);
             if (allowed_compression_programs.end() ==
                 std::find(allowed_compression_programs.begin(),
                           allowed_compression_programs.end(),
                           lowercase_compression)) {
               throw std::runtime_error("Compression program " + compression +
                                        " is not supported.");
             }
           } else {
             throw std::runtime_error("Compression option must be a string.");
           }
         } else {
           throw std::runtime_error("Invalid WITH option: " + *option->get_name());
         }
       }
     }
     // default lz4 compression, next gzip, or none.
     if (compression.empty()) {
       if (boost::process::search_path(compression = "gzip").string().empty()) {
         if (boost::process::search_path(compression = "lz4").string().empty()) {
           compression = "none";
         }
       }
     }
     if (boost::iequals(compression, "none")) {
       compression.clear();
     } else {
       std::map<std::string, std::string> decompression{{"lz4", "unlz4"},
                                                        {"gzip", "gunzip"}};
       const auto use_program = is_restore ? decompression[compression] : compression;
       const auto prog_path = boost::process::search_path(use_program);
       if (prog_path.string().empty()) {
         throw std::runtime_error("Compression program " + use_program + " is not found.");
       }
       compression = "--use-compress-program=" + use_program;
     }
   }