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	TemplateTransformer
class	NormalizeTransformer
class	SupportedAnnotationsTransformer
class	SignatureTransformer
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	build_template_function_call
def	build_require_check_function
def	contains_require_check
def	format_annotations
def	is_template_function
def	uses_manager
def	is_cpu_function
def	is_gpu_function
def	parse_annotations

Variables
tuple	Signature = namedtuple('Signature', ['name', 'inputs', 'outputs', 'input_annotations', 'output_annotations', 'function_annotations'])
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]
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.build_require_check_function	(		fn_name,
			input_types,
			input_annotations,
			uses_manager
	)

Definition at line 1594 of file generate_TableFunctionsFactory_init.py.

References join().

Referenced by parse_annotations().

def build_require_check_function(fn_name, input_types, input_annotations, uses_manager):

    def format_error_msg(err_msg, uses_manager):
        if uses_manager:
            return "    return mgr.error_message(%s);\n" % (err_msg,)
        else:
            return "    return table_function_error(%s);\n" % (err_msg,)

    input_cpp_args = []
    arg_names = []

    for idx, (typ, ann) in enumerate(zip(input_types, input_annotations)):
        arg_names.append(dict(ann).get('name', 'input%s' % (idx)))
        cpp_arg, _ = typ.format_cpp_type(idx, arg_name=arg_names[idx])
        input_cpp_args.append(cpp_arg)

    if uses_manager:
        input_cpp_args = ["TableFunctionManager& mgr"] + input_cpp_args
        arg_names = ["mgr"] + arg_names
        input_annotations = [[]] + input_annotations

    fn = "EXTENSION_NOINLINE int32_t\n"
    fn += "%s(%s) {\n" % (fn_name.lower() + "__require_check", ', '.join(input_cpp_args))

    for idx, arg_name in enumerate(arg_names):
        ann = input_annotations[idx]
        for key, value in ann:
            if key == 'require':
                err_msg = '"Constraint `%s` is not satisfied."' % (value[1:-1])

                fn += "  if (!(%s)) {\n" % (value[1:-1].replace('\\', ''),)
                fn += format_error_msg(err_msg, uses_manager)
                fn += "  }\n"

    fn += "  return 0;\n"
    fn += "}\n\n"

    return fn

Here is the call graph for this function:

Here is the caller graph for this function: