#include <TableFunctionsFactory.h>

Collaboration diagram for table_functions::TableFunction:

Public Member Functions
	TableFunction (const std::string &name, const TableFunctionOutputRowSizer output_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, bool uses_manager)

std::vector< ExtArgumentType >	getArgs (const bool ensure_column=false) const

const std::vector < ExtArgumentType > &	getInputArgs () const

const std::vector < ExtArgumentType > &	getOutputArgs () const

const std::vector < ExtArgumentType > &	getSqlArgs () const

const std::vector< std::map < std::string, std::string > > &	getAnnotations () const

const ExtArgumentType	getRet () const

SQLTypeInfo	getInputSQLType (const size_t idx) const

SQLTypeInfo	getOutputSQLType (const size_t idx) const

int32_t	countScalarArgs () const

size_t	getInputsSize () const

size_t	getOutputsSize () const

std::string	getName (const bool drop_suffix=false, const bool lower=false) const

std::string	getSignature (const bool include_name, const bool include_output) const

bool	hasCompileTimeOutputSizeConstant () const

bool	hasPreFlightOutputSizer () const

bool	hasUserSpecifiedOutputSizeConstant () const

bool	hasConstantOutputSize () const

bool	hasTableFunctionSpecifiedParameter () const

bool	hasUserSpecifiedOutputSizeParameter () const

bool	hasNonUserSpecifiedOutputSize () const

bool	hasOutputSizeIndependentOfInputSize () const

bool	hasOutputSizeKnownPreLaunch () const

bool	hasUserSpecifiedOutputSizeMultiplier () const

OutputBufferSizeType	getOutputRowSizeType () const

size_t	getOutputRowSizeParameter () const

bool	containsPreFlightFn () const

std::string	getPreFlightFnName () const

const std::map< std::string, std::string >	getAnnotations (const size_t idx) const

const std::map< std::string, std::string >	getInputAnnotations (const size_t input_arg_idx) const

const std::string	getInputAnnotation (const size_t input_arg_idx, const std::string &key, const std::string &default_) const

const std::map< std::string, std::string >	getOutputAnnotations (const size_t output_arg_idx) const

const std::string	getOutputAnnotation (const size_t output_arg_idx, const std::string &key, const std::string &default_) const

const std::string	getFunctionAnnotation (const std::string &key, const std::string &default_) const

const std::map< std::string, std::string >	getFunctionAnnotations () const

const std::vector< std::string >	getCursorFields (const size_t sql_idx) const

const std::string	getArgTypes (const bool use_input_args) const

const std::string	getArgNames (const bool use_input_args) const

const std::string	getInputArgsDefaultValues () const

std::pair< int32_t, int32_t >	getInputID (const size_t idx) const

size_t	getSqlOutputRowSizeParameter () const

size_t	getOutputRowSizeParameter (const std::vector< SQLTypeInfo > &variant) const

bool	isRuntime () const

bool	usesManager () const

bool	isGPU () const

bool	isCPU () const

bool	useDefaultSizer () const

std::string	toString () const

std::string	toStringSQL () const

Private Attributes
const std::string	name_

const TableFunctionOutputRowSizer	output_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_

const bool	is_runtime_

const bool	uses_manager_

Detailed Description

Definition at line 126 of file TableFunctionsFactory.h.

Constructor & Destructor Documentation

table_functions::TableFunction::TableFunction	(	const std::string &	name,
		const TableFunctionOutputRowSizer	output_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,
		bool	uses_manager
	)

inline

Definition at line 128 of file TableFunctionsFactory.h.

       : name_(name)
       , output_sizer_(output_sizer)
       , input_args_(input_args)
       , output_args_(output_args)
       , sql_args_(sql_args)
       , annotations_(annotations)
       , is_runtime_(is_runtime)
       , uses_manager_(uses_manager) {}

Member Function Documentation

bool table_functions::TableFunction::containsPreFlightFn ( ) const

Definition at line 106 of file TableFunctionsFactory.cpp.

References annotations_, getInputAnnotations(), hasPreFlightOutputSizer(), and input_args_.

Referenced by TableFunctionExecutionContext::execute(), and Executor::executeTableFunction().

                                               {
   if (hasPreFlightOutputSizer()) {
     return true;
   }
   // workaround for default args
   for (size_t idx = 0; idx < std::min(input_args_.size(), annotations_.size()); idx++) {
     const auto& ann = getInputAnnotations(idx);
     if (ann.find("require") != ann.end()) {
       return true;
     }
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t table_functions::TableFunction::countScalarArgs ( ) const

Definition at line 96 of file TableFunctionsFactory.cpp.

References input_args_, and is_ext_arg_type_scalar().

                                              {
   int32_t scalar_args = 0;
   for (const auto& ext_arg : input_args_) {
     if (is_ext_arg_type_scalar(ext_arg)) {
       scalar_args += 1;
     }
   }
   return scalar_args;
 }

Here is the call graph for this function:

const std::vector<std::map<std::string, std::string> >& table_functions::TableFunction::getAnnotations ( ) const

inline

Definition at line 161 of file TableFunctionsFactory.h.

References annotations_.

Referenced by getFunctionAnnotations(), getInputAnnotations(), getOutputAnnotations(), and ThriftSerializers::to_thrift().

                                                                         {
     return annotations_;
   }

Here is the caller graph for this function:

const std::map< std::string, std::string > table_functions::TableFunction::getAnnotations ( const size_t idx ) const

Definition at line 120 of file TableFunctionsFactory.cpp.

References annotations_, CHECK_LE, output_args_, and sql_args_.

                             {
   CHECK_LE(idx, sql_args_.size() + output_args_.size());
   if (annotations_.empty() || idx >= annotations_.size()) {
     static const std::map<std::string, std::string> empty = {};
     return empty;
   }
   return annotations_[idx];
 }

const std::string table_functions::TableFunction::getArgNames ( const bool use_input_args ) const

Definition at line 216 of file TableFunctionsFactory.cpp.

References getCursorFields(), getInputAnnotation(), getOutputAnnotation(), join(), setup::name, output_args_, and sql_args_.

                                                                     {
   std::vector<std::string> names;
   if (use_input_args) {
     for (size_t idx = 0; idx < sql_args_.size(); idx++) {
       const std::vector<std::string> cursor_fields = getCursorFields(idx);
       if (cursor_fields.empty()) {
         const std::string& name = getInputAnnotation(idx, "name", "''");
         names.emplace_back(name);
       } else {
         names.emplace_back("Cursor<" + boost::algorithm::join(cursor_fields, ", ") + ">");
       }
     }
   } else {
     for (size_t idx = 0; idx < output_args_.size(); idx++) {
       const std::string& name = getOutputAnnotation(idx, "name", "''");
       names.emplace_back(name);
     }
   }
 
   return "[" + boost::algorithm::join(names, ", ") + "]";
 }

Here is the call graph for this function:

std::vector<ExtArgumentType> table_functions::TableFunction::getArgs ( const bool ensure_column = false ) const

inline

Definition at line 145 of file TableFunctionsFactory.h.

References run_benchmark_import::args, ext_arg_type_ensure_column(), input_args_, and output_args_.

                                                                              {
     std::vector<ExtArgumentType> args;
     args.insert(args.end(), input_args_.begin(), input_args_.end());
     if (ensure_column) {
       // map row dtype to column type
       std::for_each(output_args_.begin(), output_args_.end(), [&args](auto t) {
         args.push_back(ext_arg_type_ensure_column(t));
       });
     } else {
       args.insert(args.end(), output_args_.begin(), output_args_.end());
     }
     return args;
   }

Here is the call graph for this function:

const std::string table_functions::TableFunction::getArgTypes ( const bool use_input_args ) const

Definition at line 192 of file TableFunctionsFactory.cpp.

References getCursorFields(), input_args_, join(), output_args_, sql_args_, and ExtensionFunctionsWhitelist::toString().

                                                                     {
   if (use_input_args) {
     std::vector<std::string> arg_types;
     size_t arg_idx = 0;
     for (size_t sql_idx = 0; sql_idx < sql_args_.size(); sql_idx++) {
       const std::vector<std::string> cursor_fields = getCursorFields(sql_idx);
       if (cursor_fields.empty()) {
         // fields => {}
         arg_types.emplace_back(
             ExtensionFunctionsWhitelist::toString(input_args_[arg_idx++]));
       } else {
         std::vector<std::string> vec;
         for (size_t i = 0; i < cursor_fields.size(); i++) {
           vec.emplace_back(ExtensionFunctionsWhitelist::toString(input_args_[arg_idx++]));
         }
         arg_types.emplace_back("Cursor<" + boost::algorithm::join(vec, ", ") + ">");
       }
     }
     return "[" + boost::algorithm::join(arg_types, ", ") + "]";
   } else {
     return "[" + ExtensionFunctionsWhitelist::toString(output_args_) + "]";
   }
 }

Here is the call graph for this function:

const std::vector< std::string > table_functions::TableFunction::getCursorFields ( const size_t sql_idx ) const

Definition at line 179 of file TableFunctionsFactory.cpp.

References getInputAnnotation(), parse_ast::line, and split().

Referenced by getArgNames(), getArgTypes(), and getSignature().

                                 {
   std::vector<std::string> fields;
   const std::string& line = getInputAnnotation(sql_idx, "fields", "");
   if (line.empty()) {
     static const std::vector<std::string> empty = {};
     return empty;
   }
   std::string substr = line.substr(1, line.size() - 2);
   boost::split(fields, substr, boost::is_any_of(", "), boost::token_compress_on);
   return fields;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string table_functions::TableFunction::getFunctionAnnotation	(	const std::string &	key,
		const std::string &	default_
	)		const

Definition at line 168 of file TableFunctionsFactory.cpp.

References getFunctionAnnotations().

                                      {
   const std::map<std::string, std::string> ann = getFunctionAnnotations();
   const auto& it = ann.find(key);
   if (it != ann.end()) {
     return it->second;
   }
   return default_;
 }

Here is the call graph for this function:

const std::map< std::string, std::string > table_functions::TableFunction::getFunctionAnnotations ( ) const

Definition at line 164 of file TableFunctionsFactory.cpp.

References getAnnotations(), output_args_, and sql_args_.

Referenced by getFunctionAnnotation().

                                                                                {
   return getAnnotations(sql_args_.size() + output_args_.size());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string table_functions::TableFunction::getInputAnnotation	(	const size_t	input_arg_idx,
		const std::string &	key,
		const std::string &	default_
	)		const

Definition at line 136 of file TableFunctionsFactory.cpp.

References getInputAnnotations().

Referenced by getArgNames(), getCursorFields(), getInputArgsDefaultValues(), and getSignature().

                                                                                      {
   const std::map<std::string, std::string> ann = getInputAnnotations(input_arg_idx);
   const auto& it = ann.find(key);
   if (it != ann.end()) {
     return it->second;
   }
   return default_;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::map< std::string, std::string > table_functions::TableFunction::getInputAnnotations ( const size_t input_arg_idx ) const

Definition at line 130 of file TableFunctionsFactory.cpp.

References CHECK_LT, getAnnotations(), and input_args_.

Referenced by containsPreFlightFn(), and getInputAnnotation().

                                       {
   CHECK_LT(input_arg_idx, input_args_.size());
   return getAnnotations(input_arg_idx);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector<ExtArgumentType>& table_functions::TableFunction::getInputArgs ( ) const

inline

Definition at line 158 of file TableFunctionsFactory.h.

References input_args_.

Referenced by ThriftSerializers::to_thrift().

158 { return input_args_; }

table_functions::TableFunction::input_args_

const std::vector< ExtArgumentType > input_args_

Definition: TableFunctionsFactory.h:333

Here is the caller graph for this function:

const std::string table_functions::TableFunction::getInputArgsDefaultValues ( ) const

Definition at line 238 of file TableFunctionsFactory.cpp.

References getInputAnnotation(), join(), setup::name, and sql_args_.

                                                                {
   std::vector<std::string> default_values;
   default_values.reserve(sql_args_.size());
   for (size_t idx = 0; idx < sql_args_.size(); idx++) {
     const std::string& name = getInputAnnotation(idx, "default", "UNSPECIFIED");
     default_values.emplace_back(name);
   }
 
   return "[" + boost::algorithm::join(default_values, ",") + "]";
 }

Here is the call graph for this function:

std::pair< int32_t, int32_t > table_functions::TableFunction::getInputID ( const size_t idx ) const

Definition at line 249 of file TableFunctionsFactory.cpp.

References ColumnGeoLineString, ColumnGeoMultiLineString, ColumnGeoMultiPoint, ColumnGeoMultiPolygon, ColumnGeoPoint, ColumnGeoPolygon, ColumnListGeoLineString, ColumnListGeoMultiLineString, ColumnListGeoMultiPoint, ColumnListGeoMultiPolygon, ColumnListGeoPoint, ColumnListGeoPolygon, ColumnListTextEncodingDict, ColumnTextEncodingDict, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, getOutputAnnotations(), input_args_, PREFIX_LENGTH, and TextEncodingDict.

                                                                           {
   // if the annotation is of the form args<INT,INT>, it is refering to a column list
 #define PREFIX_LENGTH 5
   const auto& annotation = getOutputAnnotations(idx);
   auto annot = annotation.find("input_id");
   if (annot == annotation.end()) {
     size_t lo = 0;
     for (const auto& ext_arg : input_args_) {
       switch (ext_arg) {
         case ExtArgumentType::TextEncodingDict:
         case ExtArgumentType::ColumnTextEncodingDict:
         case ExtArgumentType::ColumnListTextEncodingDict:
         case ExtArgumentType::GeoPoint:
         case ExtArgumentType::ColumnGeoPoint:
         case ExtArgumentType::ColumnListGeoPoint:
         case ExtArgumentType::GeoLineString:
         case ExtArgumentType::ColumnGeoLineString:
         case ExtArgumentType::ColumnListGeoLineString:
         case ExtArgumentType::GeoPolygon:
         case ExtArgumentType::ColumnGeoPolygon:
         case ExtArgumentType::ColumnListGeoPolygon:
         case ExtArgumentType::GeoMultiPoint:
         case ExtArgumentType::ColumnGeoMultiPoint:
         case ExtArgumentType::ColumnListGeoMultiPoint:
         case ExtArgumentType::GeoMultiLineString:
         case ExtArgumentType::ColumnGeoMultiLineString:
         case ExtArgumentType::ColumnListGeoMultiLineString:
         case ExtArgumentType::GeoMultiPolygon:
         case ExtArgumentType::ColumnGeoMultiPolygon:
         case ExtArgumentType::ColumnListGeoMultiPolygon:
           return std::make_pair(lo, 0);
         default:
           lo++;
       }
     }
     return {-1, -1};  // indicates unspecified
   }
 
   const std::string& input_id = annot->second;
 
   if (input_id == "args<-1>") {
     // empty input id! -1 seems to be the magic number used in RelAlgExecutor.cpp
     return {-1, -1};
   }
 
   size_t comma = input_id.find(",");
   int32_t gt = input_id.size() - 1;
   int32_t lo = std::stoi(input_id.substr(PREFIX_LENGTH, comma - 1));
 
   if (comma == std::string::npos) {
     return std::make_pair(lo, 0);
   }
   int32_t hi = std::stoi(input_id.substr(comma + 1, gt - comma - 1));
   return std::make_pair(lo, hi);
 }

Here is the call graph for this function:

SQLTypeInfo table_functions::TableFunction::getInputSQLType ( const size_t idx ) const

Definition at line 82 of file TableFunctionsFactory.cpp.

References CHECK_LT, table_functions::anonymous_namespace{TableFunctionsFactory.cpp}::ext_arg_pointer_type_to_type_info(), and input_args_.

                                                                  {
   CHECK_LT(idx, input_args_.size());
   return ext_arg_pointer_type_to_type_info(input_args_[idx]);
 }

Here is the call graph for this function:

size_t table_functions::TableFunction::getInputsSize ( ) const

inline

Definition at line 171 of file TableFunctionsFactory.h.

References input_args_.

171 { return input_args_.size(); }

table_functions::TableFunction::input_args_

const std::vector< ExtArgumentType > input_args_

Definition: TableFunctionsFactory.h:333

std::string table_functions::TableFunction::getName	(	const bool	drop_suffix = `false`,
		const bool	lower = `false`
	)		const

Definition at line 563 of file TableFunctionsFactory.cpp.

References anonymous_namespace{RowFunctionManager.h}::drop_suffix_impl(), name_, run_benchmark_import::result, and to_lower().

Referenced by TableFunctionManager::allocate_output_buffers(), TableFunctionCompilationContext::compile(), TableFunctionCompilationContext::generateTableFunctionCall(), getPreFlightFnName(), getSignature(), and ThriftSerializers::to_thrift().

                                                                                {
   std::string result = name_;
   if (drop_suffix) {
     result = drop_suffix_impl(result);
   }
   if (lower) {
     boost::algorithm::to_lower(result);
   }
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string table_functions::TableFunction::getOutputAnnotation	(	const size_t	output_arg_idx,
		const std::string &	key,
		const std::string &	default_
	)		const

Definition at line 153 of file TableFunctionsFactory.cpp.

References getOutputAnnotations().

Referenced by getArgNames().

                                                                                       {
   const std::map<std::string, std::string> ann = getOutputAnnotations(output_arg_idx);
   const auto& it = ann.find(key);
   if (it != ann.end()) {
     return it->second;
   }
   return default_;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::map< std::string, std::string > table_functions::TableFunction::getOutputAnnotations ( const size_t output_arg_idx ) const

Definition at line 147 of file TableFunctionsFactory.cpp.

References CHECK_LT, getAnnotations(), output_args_, and sql_args_.

Referenced by getInputID(), and getOutputAnnotation().

                                        {
   CHECK_LT(output_arg_idx, output_args_.size());
   return getAnnotations(output_arg_idx + sql_args_.size());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector<ExtArgumentType>& table_functions::TableFunction::getOutputArgs ( ) const

inline

Definition at line 159 of file TableFunctionsFactory.h.

References output_args_.

Referenced by ThriftSerializers::to_thrift().

159 { return output_args_; }

table_functions::TableFunction::output_args_

const std::vector< ExtArgumentType > output_args_

Definition: TableFunctionsFactory.h:334

Here is the caller graph for this function:

size_t table_functions::TableFunction::getOutputRowSizeParameter ( ) const

inline

Definition at line 229 of file TableFunctionsFactory.h.

References output_sizer_, and table_functions::TableFunctionOutputRowSizer::val.

Referenced by getSqlOutputRowSizeParameter(), and ThriftSerializers::to_thrift().

229 { return output_sizer_.val; }

table_functions::TableFunction::output_sizer_

const TableFunctionOutputRowSizer output_sizer_

Definition: TableFunctionsFactory.h:332

table_functions::TableFunctionOutputRowSizer::val

const size_t val

Definition: TableFunctionsFactory.h:106

Here is the caller graph for this function:

size_t table_functions::TableFunction::getOutputRowSizeParameter ( const std::vector< SQLTypeInfo > & variant ) const

inline

Definition at line 257 of file TableFunctionsFactory.h.

References hasUserSpecifiedOutputSizeMultiplier(), output_sizer_, and table_functions::TableFunctionOutputRowSizer::val.

                                                                                 {
     auto val = output_sizer_.val;
     if (hasUserSpecifiedOutputSizeMultiplier()) {
       size_t col_index = 0;
       size_t func_arg_index = 0;
       for (const auto& ti : variant) {
         func_arg_index++;
         if (ti.is_column_list()) {
           col_index += ti.get_dimension();
         } else {
           col_index++;
         }
         if (func_arg_index == val) {
           val = col_index;
           break;
         }
       }
     }
     return val;
   }

Here is the call graph for this function:

OutputBufferSizeType table_functions::TableFunction::getOutputRowSizeType ( ) const

inline

Definition at line 227 of file TableFunctionsFactory.h.

References output_sizer_.

Referenced by anonymous_namespace{TableFunctionExecutionContext.cpp}::get_output_row_count(), and ThriftSerializers::to_thrift().

227 { return output_sizer_.type; }

table_functions::TableFunction::output_sizer_

const TableFunctionOutputRowSizer output_sizer_

Definition: TableFunctionsFactory.h:332

Here is the caller graph for this function:

SQLTypeInfo table_functions::TableFunction::getOutputSQLType ( const size_t idx ) const

Definition at line 87 of file TableFunctionsFactory.cpp.

References CHECK_LT, table_functions::anonymous_namespace{TableFunctionsFactory.cpp}::ext_arg_type_to_type_info_output(), and output_args_.

                                                                   {
   CHECK_LT(idx, output_args_.size());
   // TODO(adb): conditionally handle nulls
   return ext_arg_type_to_type_info_output(output_args_[idx]);
 }

Here is the call graph for this function:

size_t table_functions::TableFunction::getOutputsSize ( ) const

inline

Definition at line 172 of file TableFunctionsFactory.h.

References output_args_.

172 { return output_args_.size(); }

table_functions::TableFunction::output_args_

const std::vector< ExtArgumentType > output_args_

Definition: TableFunctionsFactory.h:334

std::string table_functions::TableFunction::getPreFlightFnName ( ) const

Definition at line 606 of file TableFunctionsFactory.cpp.

References getName(), and PREFLIGHT_SUFFIX.

Referenced by TableFunctionCompilationContext::generateTableFunctionCall().

                                                   {
   // gets the name of the pre flight function associated with this table function
   return getName(false, true) + PREFLIGHT_SUFFIX;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const ExtArgumentType table_functions::TableFunction::getRet ( ) const

inline

Definition at line 164 of file TableFunctionsFactory.h.

References Int32.

164 { return ExtArgumentType::Int32; }

ExtArgumentType::Int32

std::string table_functions::TableFunction::getSignature	(	const bool	include_name,
		const bool	include_output
	)		const

Definition at line 574 of file TableFunctionsFactory.cpp.

References run_benchmark_import::args, getCursorFields(), getInputAnnotation(), getName(), input_args_, join(), setup::name, output_args_, sql_args_, ExtensionFunctionsWhitelist::toString(), and run_benchmark_import::type.

                                                                          {
   std::string sig;
   if (include_name) {
     sig += getName(/*drop_suffix=*/true, /*lower=*/true);
   }
 
   size_t arg_idx = 0;
   std::vector<std::string> args;
   for (size_t sql_idx = 0; sql_idx < sql_args_.size(); sql_idx++) {
     const std::vector<std::string> cursor_fields = getCursorFields(sql_idx);
     if (cursor_fields.empty()) {
       const auto& type = ExtensionFunctionsWhitelist::toString(input_args_[arg_idx++]);
       const auto& name = getInputAnnotation(sql_idx, "name", "");
       args.emplace_back(name.empty() ? type : (type + " " + name));
     } else {
       std::vector<std::string> vec;
       for (size_t i = 0; i < cursor_fields.size(); i++) {
         const auto& type = ExtensionFunctionsWhitelist::toString(input_args_[arg_idx++]);
         const auto& name = cursor_fields[i];
         vec.emplace_back((name.empty() ? type : type + " " + name));
       }
       args.emplace_back("Cursor<" + boost::algorithm::join(vec, ", ") + ">");
     }
   }
   sig += "(" + boost::algorithm::join(args, ", ") + ")";
   if (include_output) {
     sig += " -> " + ExtensionFunctionsWhitelist::toString(output_args_);
   }
   return sig;
 }

Here is the call graph for this function:

const std::vector<ExtArgumentType>& table_functions::TableFunction::getSqlArgs ( ) const

inline

Definition at line 160 of file TableFunctionsFactory.h.

References sql_args_.

Referenced by ThriftSerializers::to_thrift().

160 { return sql_args_; }

table_functions::TableFunction::sql_args_

const std::vector< ExtArgumentType > sql_args_

Definition: TableFunctionsFactory.h:335

Here is the caller graph for this function:

size_t table_functions::TableFunction::getSqlOutputRowSizeParameter ( ) const

Definition at line 305 of file TableFunctionsFactory.cpp.

References CHECK, getOutputRowSizeParameter(), hasUserSpecifiedOutputSizeMultiplier(), input_args_, is_ext_arg_type_nonscalar(), is_ext_arg_type_scalar(), and sql_args_.

                                                          {
   /*
     This function differs from getOutputRowSizeParameter() since it returns the correct
     index for the sizer in the sql_args list. For instance, consider the example below:
 
       RowMultiplier=4
       input_args=[{i32*, i64}, {i32*, i64}, {i32*, i64}, i32, {i32*, i64}, {i32*, i64},
     i32] sql_args=[cursor, i32, cursor, i32]
 
     Non-scalar args are aggregated in a cursor inside the sql_args list and the new
     sizer index is 2 rather than 4 originally specified.
   */
 
   if (hasUserSpecifiedOutputSizeMultiplier()) {
     size_t sizer = getOutputRowSizeParameter();  // lookup until reach the sizer arg
     int32_t ext_arg_index = 0, sql_arg_index = 0;
 
     auto same_kind = [&](const ExtArgumentType& ext_arg, const ExtArgumentType& sql_arg) {
       return ((is_ext_arg_type_scalar(ext_arg) && is_ext_arg_type_scalar(sql_arg)) ||
               (is_ext_arg_type_nonscalar(ext_arg) && is_ext_arg_type_nonscalar(sql_arg)));
     };
 
     while ((size_t)ext_arg_index < sizer) {
       if ((size_t)ext_arg_index == sizer - 1) {
         return sql_arg_index;
       }
 
       const auto& ext_arg = input_args_[ext_arg_index];
       const auto& sql_arg = sql_args_[sql_arg_index];
 
       if (same_kind(ext_arg, sql_arg)) {
         ++ext_arg_index;
         ++sql_arg_index;
       } else {
         CHECK(same_kind(ext_arg, sql_args_[sql_arg_index - 1]));
         ext_arg_index += 1;
       }
     }
 
     CHECK(false);
   }
 
   return getOutputRowSizeParameter();
 }

Here is the call graph for this function:

bool table_functions::TableFunction::hasCompileTimeOutputSizeConstant ( ) const

inline

Definition at line 178 of file TableFunctionsFactory.h.

References table_functions::kConstant, and output_sizer_.

                                                 {
     return output_sizer_.type == OutputBufferSizeType::kConstant;
   }

bool table_functions::TableFunction::hasConstantOutputSize ( ) const

inline

Definition at line 190 of file TableFunctionsFactory.h.

References table_functions::kConstant, table_functions::kUserSpecifiedConstantParameter, and output_sizer_.

                                      {
     return output_sizer_.type == OutputBufferSizeType::kConstant ||
            output_sizer_.type == OutputBufferSizeType::kUserSpecifiedConstantParameter;
   }

bool table_functions::TableFunction::hasNonUserSpecifiedOutputSize ( ) const

inline

Definition at line 204 of file TableFunctionsFactory.h.

References table_functions::kConstant, table_functions::kPreFlightParameter, table_functions::kTableFunctionSpecifiedParameter, and output_sizer_.

                                              {
     return output_sizer_.type == OutputBufferSizeType::kConstant ||
            output_sizer_.type == OutputBufferSizeType::kTableFunctionSpecifiedParameter ||
            output_sizer_.type == OutputBufferSizeType::kPreFlightParameter;
   }

bool table_functions::TableFunction::hasOutputSizeIndependentOfInputSize ( ) const

inline

Definition at line 210 of file TableFunctionsFactory.h.

References table_functions::kConstant, table_functions::kPreFlightParameter, table_functions::kTableFunctionSpecifiedParameter, table_functions::kUserSpecifiedConstantParameter, and output_sizer_.

Referenced by TableFunctionExecutionContext::execute().

                                                    {
     return output_sizer_.type == OutputBufferSizeType::kConstant ||
            output_sizer_.type == OutputBufferSizeType::kUserSpecifiedConstantParameter ||
            output_sizer_.type == OutputBufferSizeType::kTableFunctionSpecifiedParameter ||
            output_sizer_.type == OutputBufferSizeType::kPreFlightParameter;
   }

Here is the caller graph for this function:

bool table_functions::TableFunction::hasOutputSizeKnownPreLaunch ( ) const

inline

Definition at line 217 of file TableFunctionsFactory.h.

References table_functions::kConstant, table_functions::kUserSpecifiedConstantParameter, table_functions::kUserSpecifiedRowMultiplier, and output_sizer_.

Referenced by TableFunctionCompilationContext::generateEntryPoint().

                                            {
     return output_sizer_.type == OutputBufferSizeType::kConstant ||
            output_sizer_.type == OutputBufferSizeType::kUserSpecifiedConstantParameter ||
            output_sizer_.type == OutputBufferSizeType::kUserSpecifiedRowMultiplier;
   }

Here is the caller graph for this function:

bool table_functions::TableFunction::hasPreFlightOutputSizer ( ) const

inline

Definition at line 182 of file TableFunctionsFactory.h.

References table_functions::kPreFlightParameter, and output_sizer_.

Referenced by containsPreFlightFn(), and TableFunctionCompilationContext::generateEntryPoint().

                                        {
     return output_sizer_.type == OutputBufferSizeType::kPreFlightParameter;
   }

Here is the caller graph for this function:

bool table_functions::TableFunction::hasTableFunctionSpecifiedParameter ( ) const

inline

Definition at line 195 of file TableFunctionsFactory.h.

References table_functions::kTableFunctionSpecifiedParameter, and output_sizer_.

Referenced by Executor::executeTableFunction(), and TableFunctionExecutionContext::launchGpuCode().

                                                   {
     return output_sizer_.type == OutputBufferSizeType::kTableFunctionSpecifiedParameter;
   }

Here is the caller graph for this function:

bool table_functions::TableFunction::hasUserSpecifiedOutputSizeConstant ( ) const

inline

Definition at line 186 of file TableFunctionsFactory.h.

References table_functions::kUserSpecifiedConstantParameter, and output_sizer_.

                                                   {
     return output_sizer_.type == OutputBufferSizeType::kUserSpecifiedConstantParameter;
   }

bool table_functions::TableFunction::hasUserSpecifiedOutputSizeMultiplier ( ) const

inline

Definition at line 223 of file TableFunctionsFactory.h.

References table_functions::kUserSpecifiedRowMultiplier, and output_sizer_.

Referenced by getOutputRowSizeParameter(), and getSqlOutputRowSizeParameter().

                                                     {
     return output_sizer_.type == OutputBufferSizeType::kUserSpecifiedRowMultiplier;
   }

Here is the caller graph for this function:

bool table_functions::TableFunction::hasUserSpecifiedOutputSizeParameter ( ) const

inline

Definition at line 199 of file TableFunctionsFactory.h.

References table_functions::kUserSpecifiedConstantParameter, table_functions::kUserSpecifiedRowMultiplier, and output_sizer_.

                                                    {
     return output_sizer_.type == OutputBufferSizeType::kUserSpecifiedConstantParameter ||
            output_sizer_.type == OutputBufferSizeType::kUserSpecifiedRowMultiplier;
   }

bool table_functions::TableFunction::isCPU ( ) const

inline

Definition at line 286 of file TableFunctionsFactory.h.

References name_, and usesManager().

                             {
     return usesManager() || (name_.find("_gpu_", name_.find("__")) == std::string::npos);
   }

Here is the call graph for this function:

bool table_functions::TableFunction::isGPU ( ) const

inline

Definition at line 282 of file TableFunctionsFactory.h.

References name_, and usesManager().

                             {
     return !usesManager() && (name_.find("_cpu_", name_.find("__")) == std::string::npos);
   }

Here is the call graph for this function:

bool table_functions::TableFunction::isRuntime ( ) const

inline

Definition at line 278 of file TableFunctionsFactory.h.

References is_runtime_.

Referenced by TableFunctionCompilationContext::passColumnsByValue().

278 { return is_runtime_; }

table_functions::TableFunction::is_runtime_

const bool is_runtime_

Definition: TableFunctionsFactory.h:337

Here is the caller graph for this function:

std::string table_functions::TableFunction::toString ( ) const

inline

Definition at line 295 of file TableFunctionsFactory.h.

References annotations_, input_args_, is_runtime_, name_, output_args_, output_sizer_, run_benchmark_import::result, sql_args_, ExtensionFunctionsWhitelist::toString(), and uses_manager_.

                              {
     auto result = "TableFunction(" + name_ + ", input_args=[";
     result += ExtensionFunctionsWhitelist::toString(input_args_);
     result += "], output_args=[";
     result += ExtensionFunctionsWhitelist::toString(output_args_);
     result += "], sql_args=[";
     result += ExtensionFunctionsWhitelist::toString(sql_args_);
     result += "], is_runtime=" + std::string((is_runtime_ ? "true" : "false"));
     result += ", uses_manager=" + std::string((uses_manager_ ? "true" : "false"));
     result += ", sizer=" + ::toString(output_sizer_);
     result += ", annotations=[";
     for (auto annotation : annotations_) {
       if (annotation.empty()) {
         result += "{}, ";
       } else {
         result += "{";
         for (auto it : annotation) {
           result += ::toString(it.first) + ": " + ::toString(it.second);
         }
         result += "}, ";
       }
     }
     result += "])";
     return result;
   }

Here is the call graph for this function:

std::string table_functions::TableFunction::toStringSQL ( ) const

inline

Definition at line 321 of file TableFunctionsFactory.h.

References input_args_, name_, output_args_, run_benchmark_import::result, and ExtensionFunctionsWhitelist::toStringSQL().

                                 {
     auto result = name_ + "(";
     result += ExtensionFunctionsWhitelist::toStringSQL(input_args_);
     result += ") -> (";
     result += ExtensionFunctionsWhitelist::toStringSQL(output_args_);
     result += ")";
     return result;
   }

Here is the call graph for this function:

bool table_functions::TableFunction::useDefaultSizer ( ) const

inline

Definition at line 290 of file TableFunctionsFactory.h.

References name_.

                                       {
     // Functions that use a default sizer value have one less argument
     return (name_.find("_default_", name_.find("__")) != std::string::npos);
   }

bool table_functions::TableFunction::usesManager ( ) const

inline

Definition at line 280 of file TableFunctionsFactory.h.

References uses_manager_.

Referenced by TableFunctionCompilationContext::generateEntryPoint(), isCPU(), and isGPU().

280 { return uses_manager_; }

table_functions::TableFunction::uses_manager_

const bool uses_manager_

Definition: TableFunctionsFactory.h:338

Here is the caller graph for this function:

Member Data Documentation

const std::vector<std::map<std::string, std::string> > table_functions::TableFunction::annotations_

private

Definition at line 336 of file TableFunctionsFactory.h.

Referenced by containsPreFlightFn(), getAnnotations(), and toString().

const std::vector<ExtArgumentType> table_functions::TableFunction::input_args_

private

Definition at line 333 of file TableFunctionsFactory.h.

Referenced by containsPreFlightFn(), countScalarArgs(), getArgs(), getArgTypes(), getInputAnnotations(), getInputArgs(), getInputID(), getInputSQLType(), getInputsSize(), getSignature(), getSqlOutputRowSizeParameter(), toString(), and toStringSQL().

const bool table_functions::TableFunction::is_runtime_

private

Definition at line 337 of file TableFunctionsFactory.h.

Referenced by isRuntime(), and toString().

const std::string table_functions::TableFunction::name_

private

Definition at line 331 of file TableFunctionsFactory.h.

Referenced by getName(), isCPU(), isGPU(), toString(), toStringSQL(), and useDefaultSizer().

const std::vector<ExtArgumentType> table_functions::TableFunction::output_args_

private

Definition at line 334 of file TableFunctionsFactory.h.

Referenced by getAnnotations(), getArgNames(), getArgs(), getArgTypes(), getFunctionAnnotations(), getOutputAnnotations(), getOutputArgs(), getOutputSQLType(), getOutputsSize(), getSignature(), toString(), and toStringSQL().

const TableFunctionOutputRowSizer table_functions::TableFunction::output_sizer_

private

Definition at line 332 of file TableFunctionsFactory.h.

Referenced by getOutputRowSizeParameter(), getOutputRowSizeType(), hasCompileTimeOutputSizeConstant(), hasConstantOutputSize(), hasNonUserSpecifiedOutputSize(), hasOutputSizeIndependentOfInputSize(), hasOutputSizeKnownPreLaunch(), hasPreFlightOutputSizer(), hasTableFunctionSpecifiedParameter(), hasUserSpecifiedOutputSizeConstant(), hasUserSpecifiedOutputSizeMultiplier(), hasUserSpecifiedOutputSizeParameter(), and toString().

const std::vector<ExtArgumentType> table_functions::TableFunction::sql_args_

private

Definition at line 335 of file TableFunctionsFactory.h.

Referenced by getAnnotations(), getArgNames(), getArgTypes(), getFunctionAnnotations(), getInputArgsDefaultValues(), getOutputAnnotations(), getSignature(), getSqlArgs(), getSqlOutputRowSizeParameter(), and toString().

const bool table_functions::TableFunction::uses_manager_

private

Definition at line 338 of file TableFunctionsFactory.h.

Referenced by toString(), and usesManager().

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation