generate_TableFunctionsFactory_init Namespace Reference

Classes
class	Declaration
class	Bracket
class	TokenizeException
class	ParserException
class	TransformerException
class	Token
class	Tokenize
class	AstVisitor
class	AstTransformer
class	AstPrinter
class	AstDebugger
class	TemplateTransformer
class	FixRowMultiplierPosArgTransformer
class	RenameNodesTransformer
class	TextEncodingDictTransformer
class	FieldAnnotationTransformer
class	SupportedAnnotationsTransformer
class	DeclBracketTransformer
class	Node
class	IterableNode
class	UdtfNode
class	ArgNode
class	TypeNode
class	PrimitiveNode
class	ComposedNode
class	AnnotationNode
class	TemplateNode
class	Pipeline
class	Parser

Functions
def	tostring
def	find_comma
def	line_is_incomplete
def	is_identifier_cursor
def	product_dict
def	find_signatures
def	format_function_args
def	build_template_function_call
def	build_preflight_function
def	must_emit_preflight_function
def	format_annotations
def	is_template_function
def	uses_manager
def	is_cpu_function
def	is_gpu_function
def	parse_annotations
def	add_method
def	add_methods
def	call_methods

Variables
string	separator = '$=>$'
tuple	Signature = namedtuple('Signature', ['name', 'inputs', 'outputs', 'input_annotations', 'output_annotations', 'function_annotations', 'sizer'])
string	ExtArgumentTypes
string	OutputBufferSizeTypes
string	SupportedAnnotations
string	SupportedFunctionAnnotations
tuple	translate_map
list	input_files = [os.path.join(os.path.dirname(__file__), 'test_udtf_signatures.hpp')]
tuple	cpu_output_header = os.path.splitext(output_filename)
tuple	gpu_output_header = os.path.splitext(output_filename)
list	canonical_input_files = [input_file[input_file.find("/QueryEngine/") + 1:] for input_file in input_files]
list	header_includes = ['#include "' + canonical_input_file + '"' for canonical_input_file in canonical_input_files]
int	ADD_FUNC_CHUNK_SIZE = 100
string	content
string	header_content
tuple	dirname = os.path.dirname(output_filename)
tuple	f = open(output_filename, 'w')

Detailed Description

Given a list of input files, scan for lines containing UDTF
specification statements in the following form:

  UDTF: function_name(<arguments>) -> <output column types> (, <template type specifications>)?

where <arguments> is a comma-separated list of argument types. The
argument types specifications are:

- scalar types:
    Int8, Int16, Int32, Int64, Float, Double, Bool, TextEncodingDict, etc
- column types:
    ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64, ColumnFloat, ColumnDouble, ColumnBool, etc
- column list types:
    ColumnListInt8, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListFloat, ColumnListDouble, ColumnListBool, etc
- cursor type:
    Cursor<t0, t1, ...>
  where t0, t1 are column or column list types
- output buffer size parameter type:
    RowMultiplier<i>, ConstantParameter<i>, Constant<i>, TableFunctionSpecifiedParameter<i>
  where i is a literal integer.

The output column types is a comma-separated list of column types, see above.

In addition, the following equivalents are suppored:

  Column<T> == ColumnT
  ColumnList<T> == ColumnListT
  Cursor<T, V, ...> == Cursor<ColumnT, ColumnV, ...>
  int8 == int8_t == Int8, etc
  float == Float, double == Double, bool == Bool
  T == ColumnT for output column types
  RowMultiplier == RowMultiplier<i> where i is the one-based position of the sizer argument
  when no sizer argument is provided, Constant<1> is assumed

Argument types can be annotated using `|' (bar) symbol after an
argument type specification. An annotation is specified by a label and
a value separated by `=' (equal) symbol. Multiple annotations can be
specified by using `|` (bar) symbol as the annotations separator.
Supported annotation labels are:

- name: to specify argument name
- input_id: to specify the dict id mapping for output TextEncodingDict columns.

If argument type follows an identifier, it will be mapped to name
annotations. For example, the following argument type specifications
are equivalent:

  Int8 a
  Int8 | name=a

Template type specifications is a comma separated list of template
type assignments where values are lists of argument type names. For
instance:

  T = [Int8, Int16, Int32, Float], V = [Float, Double]

Function Documentation

def generate_TableFunctionsFactory_init.add_method	(		i,
			chunk
	)

Definition at line 1935 of file generate_TableFunctionsFactory_init.py.

References join().

Referenced by add_methods().

def add_method(i, chunk):
    return '''
  NO_OPT_ATTRIBUTE void add_table_functions_%d() const {
    %s
  }
''' % (i, '\n    '.join(chunk))

Here is the call graph for this function:

Here is the caller graph for this function: