Calcite Class Reference

#include <Calcite.h>

Collaboration diagram for Calcite:

Public Member Functions
	Calcite (const int db_port, const int port, const std::string &data_dir, const size_t calcite_max_mem, const size_t service_timeout, const bool service_keepalive, const std::string &udf_filename="")
	Calcite (const SystemParameters &db_parameters, const std::string &data_dir, const std::string &udf_filename="")
	Calcite ()
TPlanResult	process (query_state::QueryStateProxy, std::string sql_string, const TQueryParsingOption &query_parsing_option, const TOptimizationOption &optimization_option, const std::string &calcite_session_id="")
void	checkAccessedObjectsPrivileges (query_state::QueryStateProxy query_state_prox, TPlanResult plan) const
std::vector< TCompletionHint >	getCompletionHints (const Catalog_Namespace::SessionInfo &session_info, const std::vector< std::string > &visible_tables, const std::string sql_string, const int cursor)
std::string	getExtensionFunctionWhitelist ()
std::string	getUserDefinedFunctionWhitelist ()
virtual void	updateMetadata (std::string catalog, std::string table)
void	close_calcite_server (bool log=true)
virtual	~Calcite ()
std::string	getRuntimeExtensionFunctionWhitelist ()
void	setRuntimeExtensionFunctions (const std::vector< TUserDefinedFunction > &udfs, const std::vector< TUserDefinedTableFunction > &udtfs, bool isruntime=true)
TQueryParsingOption	getCalciteQueryParsingOption (bool legacy_syntax, bool is_explain, bool check_privileges, bool is_explain_detail)
TOptimizationOption	getCalciteOptimizationOption (bool is_view_optimize, bool enable_watchdog, const std::vector< TFilterPushDownInfo > &filter_push_down_info, bool distributed_mode)

Static Public Member Functions
static std::string const	getInternalSessionProxyUserName ()
static std::string const	getInternalSessionProxyPassword ()

Private Member Functions
void	init (const int db_port, const int port, const std::string &data_dir, const size_t calcite_max_mem, const std::string &udf_filename)
void	runServer (const int db_port, const int port, const std::string &data_dir, const size_t calcite_max_mem, const std::string &udf_filename)
TPlanResult	processImpl (query_state::QueryStateProxy, std::string sql_string, const TQueryParsingOption &query_parsing_option, const TOptimizationOption &optimization_option, const std::string &calcite_session_id)
std::vector< std::string >	get_db_objects (const std::string ra)
void	inner_close_calcite_server (bool log)
std::pair< std::shared_ptr < CalciteServerClient > , std::shared_ptr< TTransport > >	getClient (int port)
int	ping (int retry_num=0, int max_retry=50)

Private Attributes
std::shared_ptr < ThriftClientConnection >	connMgr_
bool	server_available_
size_t	service_timeout_
bool	service_keepalive_ = true
int	remote_calcite_port_ = -1
std::string	ssl_trust_store_
std::string	ssl_trust_password_
std::string	ssl_key_file_
std::string	ssl_keystore_
std::string	ssl_keystore_password_
std::string	ssl_ca_file_
std::string	db_config_file_
std::once_flag	shutdown_once_flag_

Detailed Description

Definition at line 62 of file Calcite.h.

Constructor & Destructor Documentation

Calcite::Calcite	(	const int	db_port,
		const int	port,
		const std::string &	data_dir,
		const size_t	calcite_max_mem,
		const size_t	service_timeout,
		const bool	service_keepalive,
		const std::string &	udf_filename = ""
	)

Definition at line 355 of file Calcite.cpp.

References init().

    : server_available_(false)
    , service_timeout_(service_timeout)
    , service_keepalive_(service_keepalive) {
  init(db_port, calcite_port, data_dir, calcite_max_mem, udf_filename);
}

Here is the call graph for this function:

Calcite::Calcite	(	const SystemParameters &	db_parameters,
		const std::string &	data_dir,
		const std::string &	udf_filename = ""
	)

Definition at line 390 of file Calcite.cpp.

References SystemParameters::calcite_max_mem, SystemParameters::calcite_port, init(), and SystemParameters::omnisci_server_port.

    : service_timeout_(system_parameters.calcite_timeout)
    , service_keepalive_(system_parameters.calcite_keepalive)
    , ssl_trust_store_(system_parameters.ssl_trust_store)
    , ssl_trust_password_(system_parameters.ssl_trust_password)
    , ssl_key_file_(system_parameters.ssl_key_file)
    , ssl_keystore_(system_parameters.ssl_keystore)
    , ssl_keystore_password_(system_parameters.ssl_keystore_password)
    , ssl_ca_file_(system_parameters.ssl_trust_ca_file)
    , db_config_file_(system_parameters.config_file) {
  init(system_parameters.omnisci_server_port,
       system_parameters.calcite_port,
       data_dir,
       system_parameters.calcite_max_mem,
       udf_filename);
}

Here is the call graph for this function:

Calcite::Calcite ( )

inline

Definition at line 74 of file Calcite.h.

{}

Calcite::~Calcite ( )

virtual

Definition at line 686 of file Calcite.cpp.

References close_calcite_server().

                  {
  close_calcite_server(false);
}

Here is the call graph for this function:

Member Function Documentation

void Calcite::checkAccessedObjectsPrivileges	(	query_state::QueryStateProxy	query_state_prox,
		TPlanResult	plan
	)		const

Definition at line 496 of file Calcite.cpp.

References anonymous_namespace{Calcite.cpp}::checkPermissionForTables(), AccessPrivileges::DELETE_FROM_TABLE, query_state::QueryState::getConstSessionInfo(), AccessPrivileges::INSERT_INTO_TABLE, AccessPrivileges::SELECT_FROM_TABLE, AccessPrivileges::SELECT_FROM_VIEW, and AccessPrivileges::UPDATE_IN_TABLE.

Referenced by process().

                            {
  AccessPrivileges NOOP;
  // check the individual tables
  auto const session_ptr = query_state_proxy->getConstSessionInfo();
  // TODO: Replace resolved tables vector with a `FullyQualifiedTableName` struct.
  checkPermissionForTables(*session_ptr,
                           plan.primary_accessed_objects.tables_selected_from,
                           AccessPrivileges::SELECT_FROM_TABLE,
                           AccessPrivileges::SELECT_FROM_VIEW);
  checkPermissionForTables(*session_ptr,
                           plan.primary_accessed_objects.tables_inserted_into,
                           AccessPrivileges::INSERT_INTO_TABLE,
                           NOOP);
  checkPermissionForTables(*session_ptr,
                           plan.primary_accessed_objects.tables_updated_in,
                           AccessPrivileges::UPDATE_IN_TABLE,
                           NOOP);
  checkPermissionForTables(*session_ptr,
                           plan.primary_accessed_objects.tables_deleted_from,
                           AccessPrivileges::DELETE_FROM_TABLE,
                           NOOP);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Calcite::close_calcite_server

(

bool

log = true

)

Definition at line 662 of file Calcite.cpp.

References inner_close_calcite_server(), and shutdown_once_flag_.

Referenced by ~Calcite().

                                           {
  std::call_once(shutdown_once_flag_,
                 [this, log]() { this->inner_close_calcite_server(log); });
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::string > Calcite::get_db_objects ( const std::string  ra )

private

Definition at line 537 of file Calcite.cpp.

References CHECK.

                                                               {
  std::vector<std::string> v_db_obj;
  Document document;
  document.Parse(ra.c_str());
  const Value& rels = document["rels"];
  CHECK(rels.IsArray());
  for (auto& v : rels.GetArray()) {
    std::string relOp(v["relOp"].GetString());
    if (!relOp.compare("EnumerableTableScan")) {
      std::string x;
      auto t = v["table"].GetArray();
      x = t[1].GetString();
      v_db_obj.push_back(x);
    }
  }

  return v_db_obj;
}

TOptimizationOption Calcite::getCalciteOptimizationOption	(	bool	is_view_optimize,
		bool	enable_watchdog,
		const std::vector< TFilterPushDownInfo > &	filter_push_down_info,
		bool	distributed_mode
	)

Definition at line 734 of file Calcite.cpp.

                           {
  TOptimizationOption optimization_option;
  optimization_option.filter_push_down_info = filter_push_down_info;
  optimization_option.is_view_optimize = is_view_optimize;
  optimization_option.enable_watchdog = enable_watchdog;
  optimization_option.distributed_mode = distributed_mode;
  return optimization_option;
}

TQueryParsingOption Calcite::getCalciteQueryParsingOption	(	bool	legacy_syntax,
		bool	is_explain,
		bool	check_privileges,
		bool	is_explain_detail
	)

Definition at line 720 of file Calcite.cpp.

References CHECK_LE.

                                                                                  {
  TQueryParsingOption query_parsing_info;
  query_parsing_info.legacy_syntax = legacy_syntax;
  query_parsing_info.is_explain = is_explain;
  query_parsing_info.check_privileges = check_privileges;
  query_parsing_info.is_explain_detail = is_explain_detail;
  // `EXPLAIN CALCITE DETAIL` requires `is_explain` set to TRUE
  CHECK_LE(is_explain_detail, is_explain);
  return query_parsing_info;
}

std::pair< std::shared_ptr< CalciteServerClient >, std::shared_ptr< TTransport > > Calcite::getClient ( int  port )

private

Definition at line 252 of file Calcite.cpp.

Referenced by getCompletionHints(), getExtensionFunctionWhitelist(), getRuntimeExtensionFunctionWhitelist(), getUserDefinedFunctionWhitelist(), inner_close_calcite_server(), processImpl(), setRuntimeExtensionFunctions(), and updateMetadata().

                           {
  const auto transport = connMgr_->open_buffered_client_transport("localhost",
                                                                  port,
                                                                  ssl_ca_file_,
                                                                  true,
                                                                  service_keepalive_,
                                                                  service_timeout_,
                                                                  service_timeout_,
                                                                  service_timeout_);
  try {
    transport->open();

  } catch (TException& tx) {
    throw tx;
  } catch (std::exception& ex) {
    throw ex;
  }
  std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
  std::shared_ptr<CalciteServerClient> client;
  client.reset(new CalciteServerClient(protocol));
  std::pair<std::shared_ptr<CalciteServerClient>, std::shared_ptr<TTransport>> ret;
  return std::make_pair(client, transport);
}

Here is the caller graph for this function:

std::vector< TCompletionHint > Calcite::getCompletionHints	(	const Catalog_Namespace::SessionInfo &	session_info,
		const std::vector< std::string > &	visible_tables,
		const std::string	sql_string,
		const int	cursor
	)

Definition at line 521 of file Calcite.cpp.

References cat(), Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::get_session_id(), Catalog_Namespace::SessionInfo::getCatalog(), getClient(), remote_calcite_port_, and Catalog_Namespace::UserMetadata::userName.

                      {
  std::vector<TCompletionHint> hints;
  auto& cat = session_info.getCatalog();
  const auto user = session_info.get_currentUser().userName;
  const auto session = session_info.get_session_id();
  const auto catalog = cat.getCurrentDB().dbName;
  auto client = getClient(remote_calcite_port_);
  client.first->getCompletionHints(
      hints, user, session, catalog, visible_tables, sql_string, cursor);
  return hints;
}

Here is the call graph for this function:

std::string Calcite::getExtensionFunctionWhitelist

(

)

Definition at line 626 of file Calcite.cpp.

References CHECK, logger::FATAL, getClient(), LOG, remote_calcite_port_, server_available_, and VLOG.

                                                 {
  if (server_available_) {
    TPlanResult ret;
    std::string whitelist;

    auto clientP = getClient(remote_calcite_port_);
    clientP.first->getExtensionFunctionWhitelist(whitelist);
    clientP.second->close();
    VLOG(1) << whitelist;
    return whitelist;
  } else {
    LOG(FATAL) << "Not routing to Calcite, server is not up";
    return "";
  }
  CHECK(false);
  return "";
}

Here is the call graph for this function:

static std::string const Calcite::getInternalSessionProxyPassword ( )

inlinestatic

Definition at line 98 of file Calcite.h.

References anonymous_namespace{Calcite.h}::kCalciteUserPassword.

                                                           {
    return kCalciteUserPassword;
  }

static std::string const Calcite::getInternalSessionProxyUserName ( )

inlinestatic

Definition at line 97 of file Calcite.h.

References anonymous_namespace{Calcite.h}::kCalciteUserName.

Referenced by processImpl().

{ return kCalciteUserName; }

Here is the caller graph for this function:

std::string Calcite::getRuntimeExtensionFunctionWhitelist

(

)

Definition at line 690 of file Calcite.cpp.

References logger::FATAL, getClient(), LOG, remote_calcite_port_, server_available_, UNREACHABLE, and VLOG.

                                                        {
  if (server_available_) {
    TPlanResult ret;
    std::string whitelist;
    auto clientP = getClient(remote_calcite_port_);
    clientP.first->getRuntimeExtensionFunctionWhitelist(whitelist);
    clientP.second->close();
    VLOG(1) << "Runtime extension functions whitelist loaded from Calcite: " << whitelist;
    return whitelist;
  } else {
    LOG(FATAL) << "Not routing to Calcite, server is not up";
    return "";
  }
  UNREACHABLE();
  return "";
}

Here is the call graph for this function:

std::string Calcite::getUserDefinedFunctionWhitelist

(

)

Definition at line 644 of file Calcite.cpp.

References logger::FATAL, getClient(), LOG, remote_calcite_port_, server_available_, UNREACHABLE, and VLOG.

                                                   {
  if (server_available_) {
    TPlanResult ret;
    std::string whitelist;

    auto clientP = getClient(remote_calcite_port_);
    clientP.first->getUserDefinedFunctionWhitelist(whitelist);
    clientP.second->close();
    VLOG(1) << "User defined functions whitelist loaded from Calcite: " << whitelist;
    return whitelist;
  } else {
    LOG(FATAL) << "Not routing to Calcite, server is not up";
    return "";
  }
  UNREACHABLE();
  return "";
}

Here is the call graph for this function:

void Calcite::init ( const int  db_port, const int  port, const std::string &  data_dir, const size_t  calcite_max_mem, const std::string &  udf_filename  )

private

Definition at line 368 of file Calcite.cpp.

References CHECK, connMgr_, logger::INFO, LOG, remote_calcite_port_, runServer(), and server_available_.

Referenced by Calcite().

                                                  {
  LOG(INFO) << "Creating Calcite Handler,  Calcite Port is " << calcite_port
            << " base data dir is " << data_dir;
  connMgr_ = std::make_shared<ThriftClientConnection>();
  if (calcite_port < 0) {
    CHECK(false) << "JNI mode no longer supported.";
  }
  if (calcite_port == 0) {
    // dummy process for initheavy
    remote_calcite_port_ = calcite_port;
    server_available_ = false;
  } else {
    remote_calcite_port_ = calcite_port;
    runServer(db_port, calcite_port, data_dir, calcite_max_mem, udf_filename);
    server_available_ = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Calcite::inner_close_calcite_server ( bool  log )

private

Definition at line 667 of file Calcite.cpp.

References getClient(), logger::INFO, LOG_IF, remote_calcite_port_, and server_available_.

Referenced by close_calcite_server().

                                                 {
  if (server_available_) {
    LOG_IF(INFO, log) << "Shutting down Calcite server";
    try {
      auto clientP = getClient(remote_calcite_port_);
      clientP.first->shutdown();
      clientP.second->close();
    } catch (const std::exception& e) {
      if (std::string(e.what()) != "connect() failed: Connection refused" &&
          std::string(e.what()) != "socket open() error: Connection refused" &&
          std::string(e.what()) != "No more data to read.") {
        std::cerr << "Error shutting down Calcite server: " << e.what() << std::endl;
      }  // else Calcite already shut down
    }
    LOG_IF(INFO, log) << "shut down Calcite";
    server_available_ = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Calcite::ping ( int  retry_num = 0, int  max_retry = 50  )

private

Definition at line 338 of file Calcite.cpp.

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

                                              {
  try {
    auto ms = measure<>::execution([&]() {
      auto clientP = getClient(remote_calcite_port_);
      clientP.first->ping();
      clientP.second->close();
    });
    return ms;

  } catch (TException& tx) {
    if (retry_num >= max_retry) {
      LOG(ERROR) << "Problems connecting to Calcite. Thrift error - " << tx.what();
    }
    return -1;
  }
}

Here is the call graph for this function:

TPlanResult Calcite::process	(	query_state::QueryStateProxy	query_state_proxy,
		std::string	sql_string,
		const TQueryParsingOption &	query_parsing_option,
		const TOptimizationOption &	optimization_option,
		const std::string &	calcite_session_id = ""
	)

Definition at line 480 of file Calcite.cpp.

References checkAccessedObjectsPrivileges(), processImpl(), and run_benchmark_import::result.

                                                                  {
  TPlanResult result = processImpl(query_state_proxy,
                                   std::move(sql_string),
                                   query_parsing_option,
                                   optimization_option,
                                   calcite_session_id);
  if (query_parsing_option.check_privileges && !query_parsing_option.is_explain) {
    checkAccessedObjectsPrivileges(query_state_proxy, result);
  }
  return result;
}

Here is the call graph for this function:

TPlanResult Calcite::processImpl ( query_state::QueryStateProxy  query_state_proxy, std::string  sql_string, const TQueryParsingOption &  query_parsing_option, const TOptimizationOption &  optimization_option, const std::string &  calcite_session_id  )

private

Definition at line 556 of file Calcite.cpp.

References cat(), query_state::QueryStateProxy::createTimer(), measure< TimeT >::execution(), logger::EXECUTOR, logger::FATAL, getClient(), query_state::QueryState::getConstSessionInfo(), getInternalSessionProxyUserName(), hide_sensitive_data_from_query(), logger::INFO, logger::IR, LOG, logger::PTX, remote_calcite_port_, server_available_, and logger::WARNING.

Referenced by process().

                                                                      {
  query_state::Timer timer = query_state_proxy.createTimer(__func__);
  const auto& user_session_info = query_state_proxy->getConstSessionInfo();
  const auto& cat = user_session_info->getCatalog();
  const std::string user = getInternalSessionProxyUserName();
  const std::string catalog = cat.getCurrentDB().dbName;
  LOG(INFO) << "User " << user << " catalog " << catalog << " sql '"
            << hide_sensitive_data_from_query(sql_string) << "'";
  LOG(IR) << "SQL query\n"
          << hide_sensitive_data_from_query(sql_string) << "\nEnd of SQL query";
  LOG(PTX) << "SQL query\n"
           << hide_sensitive_data_from_query(sql_string) << "\nEnd of SQL query";
  LOG(EXECUTOR) << "SQL query\n"
                << hide_sensitive_data_from_query(sql_string) << "\nEnd of SQL query";

  std::vector<TRestriction> trestrictions;

  TPlanResult ret;
  if (server_available_) {
    try {
      // calcite_session_id would be an empty string when accessed by internal resources
      // that would not access `process` through handler instance, like for eg: Unit
      // Tests. In these cases we would use the session_id from query state.
      auto ms = measure<>::execution([&]() {
        auto clientP = getClient(remote_calcite_port_);
        clientP.first->process(ret,
                               user,
                               calcite_session_id.empty()
                                   ? user_session_info->get_session_id()
                                   : calcite_session_id,
                               catalog,
                               sql_string,
                               query_parsing_option,
                               optimization_option,
                               trestrictions);
        clientP.second->close();
      });

      // LOG(INFO) << ret.plan_result;
      LOG(INFO) << "Time in Thrift "
                << (ms > ret.execution_time_ms ? ms - ret.execution_time_ms : 0)
                << " (ms), Time in Java Calcite server " << ret.execution_time_ms
                << " (ms)";
    } catch (InvalidParseRequest& e) {
      throw std::invalid_argument(e.whyUp);
    } catch (const TTransportException& ex) {
      if (ex.getType() == TTransportException::TIMED_OUT) {
        LOG(WARNING) << "Calcite request timed out: " << ex.what();
      } else {
        LOG(FATAL) << "Error occurred trying to communicate with Calcite server, the "
                      "error was: '"
                   << ex.what() << "', heavydb restart will be required";
      }
      throw;
    } catch (const std::exception& ex) {
      LOG(FATAL)
          << "Error occurred trying to communicate with Calcite server, the error was: '"
          << ex.what() << "', heavydb restart will be required";
      return ret;  // satisfy return-type warning
    }
  } else {
    LOG(FATAL) << "Not routing to Calcite, server is not up";
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Calcite::runServer ( const int  db_port, const int  port, const std::string &  data_dir, const size_t  calcite_max_mem, const std::string &  udf_filename  )

private

Definition at line 276 of file Calcite.cpp.

References logger::ERROR, logger::FATAL, logger::INFO, LOG, and start_calcite_server_as_daemon().

Referenced by init().

                                                       {
  LOG(INFO) << "Running Calcite server as a daemon";

  // ping server to see if for any reason there is an orphaned one
  int ping_time = ping();
  if (ping_time > -1) {
    // we have an orphaned server shut it down
    LOG(ERROR)
        << "Appears to be orphaned Calcite server already running, shutting it down";
    LOG(ERROR) << "Please check that you are not trying to run two servers on same port";
    LOG(ERROR) << "Attempting to shutdown orphaned Calcite server";
    try {
      auto clientP = getClient(remote_calcite_port_);
      clientP.first->shutdown();
      clientP.second->close();
      LOG(ERROR) << "orphaned Calcite server shutdown";

    } catch (TException& tx) {
      LOG(ERROR) << "Failed to shutdown orphaned Calcite server, reason: " << tx.what();
    }
  }

  // start the calcite server as a seperate process
  start_calcite_server_as_daemon(db_port,
                                 port,
                                 data_dir,
                                 calcite_max_mem,
                                 ssl_trust_store_,
                                 ssl_trust_password_,
                                 ssl_keystore_,
                                 ssl_keystore_password_,
                                 ssl_key_file_,
                                 db_config_file_,
                                 udf_filename);

  // check for new server for 30 seconds max
  std::this_thread::sleep_for(std::chrono::milliseconds(200));
  int retry_max = 300;
  for (int i = 2; i <= retry_max; i++) {
    int ping_time = ping(i, retry_max);
    if (ping_time > -1) {
      LOG(INFO) << "Calcite server start took " << i * 100 << " ms ";
      LOG(INFO) << "ping took " << ping_time << " ms ";
      server_available_ = true;
      return;
    } else {
      // wait 100 ms
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
  }
  server_available_ = false;
  LOG(FATAL) << "Could not connect to Calcite remote server running on port [" << port
             << "]";
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Calcite::setRuntimeExtensionFunctions	(	const std::vector< TUserDefinedFunction > &	udfs,
		const std::vector< TUserDefinedTableFunction > &	udtfs,
		bool	isruntime = true
	)

Definition at line 707 of file Calcite.cpp.

References logger::FATAL, getClient(), LOG, remote_calcite_port_, and server_available_.

                    {
  if (server_available_) {
    auto clientP = getClient(remote_calcite_port_);
    clientP.first->setRuntimeExtensionFunctions(udfs, udtfs, isruntime);
    clientP.second->close();
  } else {
    LOG(FATAL) << "Not routing to Calcite, server is not up";
  }
}

Here is the call graph for this function:

void Calcite::updateMetadata ( std::string  catalog, std::string  table  )

virtual

Definition at line 409 of file Calcite.cpp.

References measure< TimeT >::execution(), getClient(), logger::INFO, LOG, remote_calcite_port_, and server_available_.

                                                               {
  if (server_available_) {
    auto ms = measure<>::execution([&]() {
      auto clientP = getClient(remote_calcite_port_);
      clientP.first->updateMetadata(catalog, table);
      clientP.second->close();
    });
    LOG(INFO) << "Time to updateMetadata " << ms << " (ms)";
  } else {
    LOG(INFO) << "Not routing to Calcite, server is not up";
  }
}

Here is the call graph for this function:

Member Data Documentation

std::shared_ptr<ThriftClientConnection> Calcite::connMgr_

private

Definition at line 134 of file Calcite.h.

Referenced by init().

std::string Calcite::db_config_file_

private

Definition at line 145 of file Calcite.h.

int Calcite::remote_calcite_port_ = -1

private

Definition at line 138 of file Calcite.h.

Referenced by getCompletionHints(), getExtensionFunctionWhitelist(), getRuntimeExtensionFunctionWhitelist(), getUserDefinedFunctionWhitelist(), init(), inner_close_calcite_server(), processImpl(), setRuntimeExtensionFunctions(), and updateMetadata().

bool Calcite::server_available_

private

Definition at line 135 of file Calcite.h.

Referenced by getExtensionFunctionWhitelist(), getRuntimeExtensionFunctionWhitelist(), getUserDefinedFunctionWhitelist(), init(), inner_close_calcite_server(), processImpl(), setRuntimeExtensionFunctions(), and updateMetadata().

bool Calcite::service_keepalive_ = true

private

Definition at line 137 of file Calcite.h.

size_t Calcite::service_timeout_

private

Definition at line 136 of file Calcite.h.

std::once_flag Calcite::shutdown_once_flag_

private

Definition at line 146 of file Calcite.h.

Referenced by close_calcite_server().

std::string Calcite::ssl_ca_file_

private

Definition at line 144 of file Calcite.h.

std::string Calcite::ssl_key_file_

private

Definition at line 141 of file Calcite.h.

std::string Calcite::ssl_keystore_

private

Definition at line 142 of file Calcite.h.

std::string Calcite::ssl_keystore_password_

private

Definition at line 143 of file Calcite.h.

std::string Calcite::ssl_trust_password_

private

Definition at line 140 of file Calcite.h.

std::string Calcite::ssl_trust_store_

private

Definition at line 139 of file Calcite.h.

---

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

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