Catalog_Namespace Namespace Reference

Namespaces
	anonymous_namespace{Catalog.cpp}
	anonymous_namespace{SysCatalog.cpp}

Classes
class	Catalog
	class for a per-database catalog. also includes metadata for the current database and the current user. More...
class	CommonFileOperations
struct	DBMetadata
struct	DBSummary
class	MapDHandler
class	read_lock
class	SessionInfo
class	sqlite_lock
class	SysCatalog
struct	UserMetadata
class	write_lock

Typedefs
using	cat_read_lock = read_lock< Catalog >
using	cat_write_lock = write_lock< Catalog >
using	cat_sqlite_lock = sqlite_lock< Catalog >
using	sys_read_lock = read_lock< SysCatalog >
using	sys_write_lock = write_lock< SysCatalog >
using	sys_sqlite_lock = sqlite_lock< SysCatalog >
using	DBSummaryList = std::list< DBSummary >

Functions
std::string	abs_path (const File_Namespace::GlobalFileMgr *global_file_mgr)
std::string	run (const std::string &cmd, const std::string &chdir="")
std::string	simple_file_cat (const std::string &archive_path, const std::string &file_name, const std::string &compression)
std::string	get_table_schema (const std::string &archive_path, const std::string &table, const std::string &compression)
std::ostream &	operator<< (std::ostream &os, const SessionInfo &session_info)
void	deleteObjectPrivileges (std::unique_ptr< SqliteConnector > &sqliteConnector, std::string roleName, bool userRole, DBObject &object)
void	insertOrUpdateObjectPrivileges (std::unique_ptr< SqliteConnector > &sqliteConnector, std::string roleName, bool userRole, DBObject &object)
static bool	parseUserMetadataFromSQLite (const std::unique_ptr< SqliteConnector > &conn, UserMetadata &user)

Variables
const int	DEFAULT_INITIAL_VERSION = 1
const int	MAPD_TEMP_TABLE_START_ID
const int	MAPD_TEMP_DICT_START_ID
static constexpr char const *	table_schema_filename = "_table.sql"
static constexpr char const *	table_oldinfo_filename = "_table.oldinfo"
static constexpr char const *	table_epoch_filename = "_table.epoch"
auto	simple_file_closer = [](FILE* f) { std::fclose(f); }

Typedef Documentation

cat_read_lock

typedef read_lock< Catalog > Catalog_Namespace::cat_read_lock

Definition at line 100 of file Catalog.cpp.

cat_sqlite_lock

using Catalog_Namespace::cat_sqlite_lock = typedef sqlite_lock<Catalog>

Definition at line 102 of file Catalog.cpp.

cat_write_lock

using Catalog_Namespace::cat_write_lock = typedef write_lock<Catalog>

Definition at line 101 of file Catalog.cpp.

DBSummaryList

using Catalog_Namespace::DBSummaryList = typedef std::list<DBSummary>

Definition at line 121 of file SysCatalog.h.

sys_read_lock

using Catalog_Namespace::sys_read_lock = typedef read_lock<SysCatalog>

Definition at line 74 of file SysCatalog.cpp.

sys_sqlite_lock

using Catalog_Namespace::sys_sqlite_lock = typedef sqlite_lock<SysCatalog>

Definition at line 76 of file SysCatalog.cpp.

sys_write_lock

using Catalog_Namespace::sys_write_lock = typedef write_lock<SysCatalog>

Definition at line 75 of file SysCatalog.cpp.

Function Documentation

abs_path()

std::string Catalog_Namespace::abs_path ( const File_Namespace::GlobalFileMgr *  global_file_mgr )

inline

Definition at line 71 of file DumpRestore.cpp.

References File_Namespace::GlobalFileMgr::getBasePath().

Referenced by Catalog_Namespace::Catalog::dumpTable(), Catalog_Namespace::Catalog::renameTableDirectories(), and Catalog_Namespace::Catalog::restoreTable().

                                                                              {
  return boost::filesystem::canonical(global_file_mgr->getBasePath()).string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

deleteObjectPrivileges()

void Catalog_Namespace::deleteObjectPrivileges	(	std::unique_ptr< SqliteConnector > &	sqliteConnector,
		std::string	roleName,
		bool	userRole,
		DBObject &	object
	)

Definition at line 317 of file SysCatalog.cpp.

References DBObjectKey::dbId, DBObjectKey::objectId, DBObjectKey::permissionType, and to_string().

Referenced by Catalog_Namespace::SysCatalog::revokeDBObjectPrivileges_unsafe().

                                              {
  DBObjectKey key = object.getObjectKey();

  sqliteConnector->query_with_text_params(
      "DELETE FROM mapd_object_permissions WHERE roleName = ?1 and roleType = ?2 and "
      "objectPermissionsType = ?3 and "
      "dbId = "
      "?4 "
      "and objectId = ?5",
      std::vector<std::string>{roleName,
                               std::to_string(userRole),
                               std::to_string(key.permissionType),
                               std::to_string(key.dbId),
                               std::to_string(key.objectId)});
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_table_schema()

std::string Catalog_Namespace::get_table_schema ( const std::string &  archive_path, const std::string &  table, const std::string &  compression  )

inline

Definition at line 148 of file DumpRestore.cpp.

References simple_file_cat().

Referenced by Catalog_Namespace::Catalog::restoreTable().

                                                                  {
  const auto schema_str =
      simple_file_cat(archive_path, table_schema_filename, compression);
  std::regex regex("@T");
  return std::regex_replace(schema_str, regex, table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

insertOrUpdateObjectPrivileges()

void Catalog_Namespace::insertOrUpdateObjectPrivileges	(	std::unique_ptr< SqliteConnector > &	sqliteConnector,
		std::string	roleName,
		bool	userRole,
		DBObject &	object
	)

Definition at line 336 of file SysCatalog.cpp.

References DBObjectKey::dbId, DBObjectKey::objectId, DBObjectKey::permissionType, and to_string().

Referenced by Catalog_Namespace::SysCatalog::createRole_unsafe(), Catalog_Namespace::SysCatalog::grantDBObjectPrivileges_unsafe(), Catalog_Namespace::SysCatalog::migrateDBAccessPrivileges(), Catalog_Namespace::SysCatalog::migratePrivileges(), Catalog_Namespace::SysCatalog::populateRoleDbObjects(), and Catalog_Namespace::SysCatalog::revokeDBObjectPrivileges_unsafe().

                                                      {
  DBObjectKey key = object.getObjectKey();

  sqliteConnector->query_with_text_params(
      "INSERT OR REPLACE INTO mapd_object_permissions("
      "roleName, "
      "roleType, "
      "objectPermissionsType, "
      "dbId, "
      "objectId, "
      "objectPermissions, "
      "objectOwnerId,"
      "objectName) "
      "VALUES (?1, ?2, ?3, "
      "?4, ?5, ?6, ?7, ?8)",
      std::vector<std::string>{
          roleName,                                           // roleName
          userRole ? "1" : "0",                               // roleType
          std::to_string(key.permissionType),                 // permissionType
          std::to_string(key.dbId),                           // dbId
          std::to_string(key.objectId),                       // objectId
          std::to_string(object.getPrivileges().privileges),  // objectPrivileges
          std::to_string(object.getOwner()),                  // objectOwnerId
          object.getName()                                    // name
      });
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<()

std::ostream & Catalog_Namespace::operator<<	(	std::ostream &	os,
		const SessionInfo &	session_info
	)

Definition at line 53 of file SessionInfo.cpp.

References Catalog_Namespace::SessionInfo::get_public_session_id().

                                                                        {
  os << session_info.get_public_session_id();
  return os;
}

Here is the call graph for this function:

parseUserMetadataFromSQLite()

static bool Catalog_Namespace::parseUserMetadataFromSQLite ( const std::unique_ptr< SqliteConnector > &  conn, UserMetadata &  user  )

static

Definition at line 1181 of file SysCatalog.cpp.

References Catalog_Namespace::UserMetadata::can_login, Catalog_Namespace::UserMetadata::defaultDbId, Catalog_Namespace::UserMetadata::isSuper, Catalog_Namespace::UserMetadata::passwd_hash, Catalog_Namespace::UserMetadata::userId, and Catalog_Namespace::UserMetadata::userName.

Referenced by Catalog_Namespace::SysCatalog::getMetadataForUser(), and Catalog_Namespace::SysCatalog::getMetadataForUserById().

                                                            {
  int numRows = conn->getNumRows();
  if (numRows == 0) {
    return false;
  }
  user.userId = conn->getData<int>(0, 0);
  user.userName = conn->getData<string>(0, 1);
  user.passwd_hash = conn->getData<string>(0, 2);
  user.isSuper = conn->getData<bool>(0, 3);
  user.defaultDbId = conn->isNull(0, 4) ? -1 : conn->getData<int>(0, 4);
  user.can_login = conn->getData<bool>(0, 5);
  return true;
}

Here is the caller graph for this function:

run()

std::string Catalog_Namespace::run ( const std::string &  cmd, const std::string &  chdir = ""  )

inline

Definition at line 75 of file DumpRestore.cpp.

References logger::ERROR, error_code, measure< TimeT >::execution(), LOG, to_string(), and VLOG.

                                                                        {
  VLOG(3) << "running cmd: " << cmd;
  int rcode;
  std::error_code ec;
  std::string output, errors;
  const auto time_ms = measure<>::execution([&]() {
    using namespace boost::process;
    ipstream stdout, stderr;
    if (!chdir.empty()) {
      rcode = system(cmd, std_out > stdout, std_err > stderr, ec, start_dir = chdir);
    } else {
      rcode = system(cmd, std_out > stdout, std_err > stderr, ec);
    }
    std::ostringstream ss_output, ss_errors;
    stdout >> ss_output.rdbuf();
    stderr >> ss_errors.rdbuf();
    output = ss_output.str();
    errors = ss_errors.str();
  });
  if (rcode || ec) {
    LOG(ERROR) << "failed cmd: " << cmd;
    LOG(ERROR) << "exit code: " << rcode;
    LOG(ERROR) << "error code: " << ec.value() << " - " << ec.message();
    LOG(ERROR) << "stdout: " << output;
    LOG(ERROR) << "stderr: " << errors;
#if defined(__APPLE__)
    // osx bsdtar options "--use-compress-program" and "--fast-read" together
    // run into pipe write error after tar extracts the first occurrence of a
    // file and closes the read end while the decompression program still writes
    // to the pipe. bsdtar doesn't handle this situation well like gnu tar does.
    if (1 == rcode && cmd.find("--fast-read") &&
        (errors.find("cannot write decoded block") != std::string::npos ||
         errors.find("Broken pipe") != std::string::npos)) {
      // ignore this error, or lose speed advantage of "--fast-read" on osx.
      LOG(ERROR) << "tar error ignored on osx for --fast-read";
    } else
#endif
        // circumvent tar warning on reading file that is "changed as we read it".
        // this warning results from reading a table file under concurrent inserts
        if (1 == rcode && errors.find("changed as we read") != std::string::npos) {
      LOG(ERROR) << "tar error ignored under concurrent inserts";
    } else {
      throw std::runtime_error("Failed to run command: " + cmd +
                               "\nexit code: " + std::to_string(rcode) + "\nerrors:\n" +
                               (rcode ? errors : ec.message()));
    }
  } else {
    VLOG(3) << "finished cmd: " << cmd;
    VLOG(3) << "time: " << time_ms << " ms";
    VLOG(3) << "stdout: " << output;
  }
  return output;
}

Here is the call graph for this function:

simple_file_cat()

std::string Catalog_Namespace::simple_file_cat ( const std::string &  archive_path, const std::string &  file_name, const std::string &  compression  )

inline

Definition at line 129 of file DumpRestore.cpp.

References run.

Referenced by get_table_schema(), and Catalog_Namespace::Catalog::restoreTable().

                                                                 {
#if defined(__APPLE__)
  constexpr static auto opt_occurrence = " --fast-read ";
#else
  constexpr static auto opt_occurrence = " --occurrence=1 ";
#endif
  boost::filesystem::path temp_dir =
      boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
  boost::filesystem::create_directories(temp_dir);
  run("tar " + compression + " -xvf \"" + archive_path + "\" " + opt_occurrence +
          file_name,
      temp_dir.string());
  const auto output = run("cat " + (temp_dir / file_name).string());
  boost::filesystem::remove_all(temp_dir);
  return output;
}

Here is the caller graph for this function:

Variable Documentation

DEFAULT_INITIAL_VERSION

const int Catalog_Namespace::DEFAULT_INITIAL_VERSION = 1

Definition at line 89 of file Catalog.cpp.

MAPD_TEMP_DICT_START_ID

const int Catalog_Namespace::MAPD_TEMP_DICT_START_ID

Initial value:

=
    1073741824

Definition at line 92 of file Catalog.cpp.

MAPD_TEMP_TABLE_START_ID

const int Catalog_Namespace::MAPD_TEMP_TABLE_START_ID

Initial value:

=
    1073741824

Definition at line 90 of file Catalog.cpp.

simple_file_closer

auto Catalog_Namespace::simple_file_closer = [](FILE* f) { std::fclose(f); }

inline

Definition at line 69 of file DumpRestore.cpp.

Referenced by Catalog_Namespace::Catalog::adjustAlteredTableFiles(), and Catalog_Namespace::Catalog::dumpTable().

table_epoch_filename

constexpr char const* Catalog_Namespace::table_epoch_filename = "_table.epoch"

static

Definition at line 67 of file DumpRestore.cpp.

table_oldinfo_filename

constexpr char const* Catalog_Namespace::table_oldinfo_filename = "_table.oldinfo"

static

Definition at line 66 of file DumpRestore.cpp.

table_schema_filename

constexpr char const* Catalog_Namespace::table_schema_filename = "_table.sql"

static

Definition at line 65 of file DumpRestore.cpp.