generate_TableFunctionsFactory_init Namespace Reference

Classes
class	Bracket

Functions
def	find_comma
def	line_is_incomplete
def	find_signatures
def	is_template_function
def	build_template_function_call
def	format_annotations
def	parse_annotations

Variables
tuple	Signature = namedtuple('Signature', ['name', 'inputs', 'outputs', 'line'])
string	ExtArgumentTypes
string	OutputBufferSizeTypes
string	SupportedAnnotations
tuple	translate_map
tuple	_is_int = re.compile(r'\d+')
list	input_files = [os.path.join(os.path.dirname(__file__), 'test_udtf_signatures.hpp')]
string	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>

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>
  where i is 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.

Function Documentation

def generate_TableFunctionsFactory_init.build_template_function_call	(		name,
			input_types,
			output_types
	)

Definition at line 392 of file generate_TableFunctionsFactory_init.py.

References join().

Referenced by parse_annotations().

def build_template_function_call(name, input_types, output_types):

    def format_cpp_type(cpp_type, idx, is_input=True):
        # Perhaps integrate this to Bracket?
        col_typs = ('Column', 'ColumnList')
        idx = str(idx)
        # TODO: use name in annotations when present?
        arg_name = 'input' + idx if is_input else 'out' + idx
        const = 'const ' if is_input else ''

        if any(cpp_type.startswith(ct) for ct in col_typs):
            return '%s%s& %s' % (const, cpp_type, arg_name), arg_name
        else:
            return '%s %s' % (cpp_type, arg_name), arg_name

    input_cpp_args = []
    output_cpp_args = []
    arg_names = []

    for idx, input_type in enumerate(input_types):
        cpp_type = input_type.get_cpp_type()
        cpp_arg, arg_name = format_cpp_type(cpp_type, idx)
        input_cpp_args.append(cpp_arg)
        arg_names.append(arg_name)

    for idx, output_type in enumerate(output_types):
        cpp_type = output_type.get_cpp_type()
        cpp_arg, arg_name = format_cpp_type(cpp_type, idx, is_input=False)
        output_cpp_args.append(cpp_arg)
        arg_names.append(arg_name)

    callee = name
    called = name.split('__')[0]
    args = ', '.join(input_cpp_args + output_cpp_args)
    arg_names = ', '.join(arg_names)

    template = ("EXTENSION_NOINLINE int32_t\n"
                "%s(%s) {\n"
                "    return %s(%s);\n"
                "}\n") % (callee, args, called, arg_names)
    return template

Here is the call graph for this function:

Here is the caller graph for this function: