table_functions::TableFunctionsFactory Class Reference

#include <TableFunctionsFactory.h>

Static Public Member Functions
static void	add (const std::string &name, const TableFunctionOutputRowSizer sizer, const std::vector< ExtArgumentType > &input_args, const std::vector< ExtArgumentType > &output_args, const std::vector< ExtArgumentType > &sql_args, const std::vector< std::map< std::string, std::string >> &annotations, bool is_runtime=false)
static std::vector< TableFunction >	get_table_funcs (const std::string &name, const bool is_gpu)
static std::vector< TableFunction >	get_table_funcs (const std::string &name)
static std::vector< TableFunction >	get_table_funcs (const bool is_runtime)
static std::vector< TableFunction >	get_table_funcs ()
static void	init ()
static void	reset ()

Static Private Attributes
static std::unordered_map < std::string, TableFunction >	functions_

Friends
class	::ExtensionFunctionsWhitelist

Detailed Description

Definition at line 350 of file TableFunctionsFactory.h.

Member Function Documentation

void table_functions::TableFunctionsFactory::add ( const std::string &  name, const TableFunctionOutputRowSizer  sizer, const std::vector< ExtArgumentType > &  input_args, const std::vector< ExtArgumentType > &  output_args, const std::vector< ExtArgumentType > &  sql_args, const std::vector< std::map< std::string, std::string >> &  annotations, bool  is_runtime = false  )

static

Definition at line 353 of file TableFunctionsFactory.cpp.

References DEFAULT_ROW_MULTIPLIER_SUFFIX, functions_, g_enable_dev_table_functions, table_functions::is_table_function_whitelisted(), table_functions::kUserSpecifiedRowMultiplier, LOG, setup::name, table_functions::TableFunctionOutputRowSizer::type, generate_TableFunctionsFactory_init::uses_manager(), table_functions::TableFunctionOutputRowSizer::val, and logger::WARNING.

Referenced by DBHandler::register_runtime_extension_functions().

                     {
  static const std::map<std::string, std::string> empty = {};

  auto func_annotations =
      (annotations.size() == sql_args.size() + output_args.size() + 1 ? annotations.back()
                                                                      : empty);
  auto mgr_annotation = func_annotations.find("uses_manager");
  bool uses_manager = mgr_annotation != func_annotations.end() &&
                      boost::algorithm::to_lower_copy(mgr_annotation->second) == "true";

  auto tf = TableFunction(name,
                          sizer,
                          input_args,
                          output_args,
                          sql_args,
                          annotations,
                          is_runtime,
                          uses_manager);
  const auto tf_name = tf.getName(true /* drop_suffix */, true /* lower */);
  if (!g_enable_dev_table_functions && !is_runtime &&
      !is_table_function_whitelisted(tf_name)) {
    return;
  }
  auto sig = tf.getSignature(/* include_name */ true, /* include_output */ false);
  for (auto it = functions_.begin(); it != functions_.end();) {
    if (it->second.getName() == name) {
      if (it->second.isRuntime()) {
        LOG(WARNING)
            << "Overriding existing run-time table function (reset not called?): "
            << name;
        it = functions_.erase(it);
      } else {
        throw std::runtime_error("Will not override existing load-time table function: " +
                                 name);
      }
    } else {
      if (sig == it->second.getSignature(/* include_name */ true,
                                         /* include_output */ false) &&
          ((tf.isCPU() && it->second.isCPU()) || (tf.isGPU() && it->second.isGPU()))) {
        LOG(WARNING)
            << "The existing (1) and added (2) table functions have the same signature `"
            << sig << "`:\n"
            << "  1: " << it->second.toString() << "\n  2: " << tf.toString() << "\n";
      }
      ++it;
    }
  }

  functions_.emplace(name, tf);
  if (sizer.type == OutputBufferSizeType::kUserSpecifiedRowMultiplier) {
    auto input_args2 = input_args;
    input_args2.erase(input_args2.begin() + sizer.val - 1);

    auto sql_args2 = sql_args;
    auto sql_sizer_pos = tf.getSqlOutputRowSizeParameter();
    sql_args2.erase(sql_args2.begin() + sql_sizer_pos);

    auto annotations2 = annotations;
    annotations2.erase(annotations2.begin() + sql_sizer_pos);

    auto tf2 = TableFunction(name + DEFAULT_ROW_MULTIPLIER_SUFFIX,
                             sizer,
                             input_args2,
                             output_args,
                             sql_args2,
                             annotations2,
                             is_runtime,
                             uses_manager);
    auto sig = tf2.getSignature(/* include_name */ true, /* include_output */ false);
    for (auto it = functions_.begin(); it != functions_.end();) {
      if (sig == it->second.getSignature(/* include_name */ true,
                                         /* include_output */ false) &&
          ((tf2.isCPU() && it->second.isCPU()) || (tf2.isGPU() && it->second.isGPU()))) {
        LOG(WARNING)
            << "The existing (1) and added (2) table functions have the same signature `"
            << sig << "`:\n"
            << "  1: " << it->second.toString() << "\n  2: " << tf2.toString() << "\n";
      }
      ++it;
    }
    functions_.emplace(name + DEFAULT_ROW_MULTIPLIER_SUFFIX, tf2);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< TableFunction > table_functions::TableFunctionsFactory::get_table_funcs ( const std::string &  name, const bool  is_gpu  )

static

Definition at line 524 of file TableFunctionsFactory.cpp.

References get_table_funcs().

                                                                                     {
  std::vector<TableFunction> table_funcs;
  for (const auto& tf : get_table_funcs(name)) {
    if (is_gpu ? tf.isGPU() : tf.isCPU()) {
      table_funcs.emplace_back(tf);
    }
  }
  return table_funcs;
}

Here is the call graph for this function:

std::vector< TableFunction > table_functions::TableFunctionsFactory::get_table_funcs ( const std::string &  name )

static

Definition at line 535 of file TableFunctionsFactory.cpp.

References anonymous_namespace{RowFunctionManager.h}::drop_suffix_impl(), functions_, setup::name, and to_lower().

                           {
  std::vector<TableFunction> table_funcs;
  auto table_func_name = name;
  boost::algorithm::to_lower(table_func_name);
  for (const auto& pair : functions_) {
    auto fname = drop_suffix_impl(pair.first);
    if (fname == table_func_name) {
      table_funcs.push_back(pair.second);
    }
  }
  return table_funcs;
}

Here is the call graph for this function:

std::vector< TableFunction > table_functions::TableFunctionsFactory::get_table_funcs ( const bool  is_runtime )

static

Definition at line 549 of file TableFunctionsFactory.cpp.

References functions_.

                                                                                     {
  std::vector<TableFunction> table_funcs;
  for (const auto& pair : functions_) {
    if (pair.second.isRuntime() == is_runtime) {
      table_funcs.push_back(pair.second);
    }
  }
  return table_funcs;
}

std::vector< TableFunction > table_functions::TableFunctionsFactory::get_table_funcs ( )

static

Definition at line 559 of file TableFunctionsFactory.cpp.

References functions_.

Referenced by bind_table_function(), ShowTableFunctionsCommand::execute(), ShowRuntimeTableFunctionsCommand::execute(), DBHandler::get_runtime_table_function_names(), get_table_funcs(), DBHandler::get_table_function_details(), DBHandler::get_table_function_names(), DBHandler::initialize(), QueryRunner::QueryRunner::QueryRunner(), and DBHandler::register_runtime_extension_functions().

                                                                {
  std::vector<TableFunction> table_funcs;
  for (const auto& pair : functions_) {
    table_funcs.push_back(pair.second);
  }
  return table_funcs;
}

Here is the caller graph for this function:

static void table_functions::TableFunctionsFactory::init ( )

static

Referenced by DBHandler::initialize(), and QueryRunner::QueryRunner::QueryRunner().

Here is the caller graph for this function:

void table_functions::TableFunctionsFactory::reset ( )

static

Definition at line 450 of file TableFunctionsFactory.cpp.

References functions_, and g_enable_table_functions.

Referenced by DBHandler::register_runtime_extension_functions().

                                  {
  if (!g_enable_table_functions) {
    return;
  }
  for (auto it = functions_.begin(); it != functions_.end();) {
    if (it->second.isRuntime()) {
      it = functions_.erase(it);
    } else {
      ++it;
    }
  }
}

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class ::ExtensionFunctionsWhitelist

friend

Definition at line 371 of file TableFunctionsFactory.h.

Member Data Documentation

std::unordered_map< std::string, TableFunction > table_functions::TableFunctionsFactory::functions_

staticprivate

Definition at line 369 of file TableFunctionsFactory.h.

Referenced by add(), get_table_funcs(), ExtensionFunctionsWhitelist::getLLVMDeclarations(), and reset().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/TableFunctionsFactory.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/TableFunctionsFactory.cpp