OmniSciDB  6686921089
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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().

1595 def build_require_check_function(fn_name, input_types, input_annotations, uses_manager):
1596 
1597  def format_error_msg(err_msg, uses_manager):
1598  if uses_manager:
1599  return " return mgr.error_message(%s);\n" % (err_msg,)
1600  else:
1601  return " return table_function_error(%s);\n" % (err_msg,)
1602 
1603  input_cpp_args = []
1604  arg_names = []
1605 
1606  for idx, (typ, ann) in enumerate(zip(input_types, input_annotations)):
1607  arg_names.append(dict(ann).get('name', 'input%s' % (idx)))
1608  cpp_arg, _ = typ.format_cpp_type(idx, arg_name=arg_names[idx])
1609  input_cpp_args.append(cpp_arg)
1610 
1611  if uses_manager:
1612  input_cpp_args = ["TableFunctionManager& mgr"] + input_cpp_args
1613  arg_names = ["mgr"] + arg_names
1614  input_annotations = [[]] + input_annotations
1615 
1616  fn = "EXTENSION_NOINLINE int32_t\n"
1617  fn += "%s(%s) {\n" % (fn_name.lower() + "__require_check", ', '.join(input_cpp_args))
1618 
1619  for idx, arg_name in enumerate(arg_names):
1620  ann = input_annotations[idx]
1621  for key, value in ann:
1622  if key == 'require':
1623  err_msg = '"Constraint `%s` is not satisfied."' % (value[1:-1])
1624 
1625  fn += " if (!(%s)) {\n" % (value[1:-1].replace('\\', ''),)
1626  fn += format_error_msg(err_msg, uses_manager)
1627  fn += " }\n"
1628 
1629  fn += " return 0;\n"
1630  fn += "}\n\n"
1631 
1632  return fn
1633 
std::string join(T const &container, std::string const &delim)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.build_template_function_call (   caller,
  callee,
  input_types,
  output_types,
  uses_manager 
)

Definition at line 1563 of file generate_TableFunctionsFactory_init.py.

References join().

Referenced by parse_annotations().

1564 def build_template_function_call(caller, callee, input_types, output_types, uses_manager):
1565  # caller calls callee
1566 
1567  input_cpp_args = []
1568  output_cpp_args = []
1569  arg_names = []
1570 
1571  if uses_manager:
1572  input_cpp_args.append("TableFunctionManager& mgr")
1573  arg_names.append("mgr")
1574 
1575  for idx, input_type in enumerate(input_types):
1576  cpp_arg, arg_name = input_type.format_cpp_type(idx)
1577  input_cpp_args.append(cpp_arg)
1578  arg_names.append(arg_name)
1579 
1580  for idx, output_type in enumerate(output_types):
1581  cpp_arg, arg_name = output_type.format_cpp_type(idx, is_input=False)
1582  output_cpp_args.append(cpp_arg)
1583  arg_names.append(arg_name)
1584 
1585  args = ', '.join(input_cpp_args + output_cpp_args)
1586  arg_names = ', '.join(arg_names)
1587 
1588  template = ("EXTENSION_NOINLINE int32_t\n"
1589  "%s(%s) {\n"
1590  " return %s(%s);\n"
1591  "}\n") % (caller, args, callee, arg_names)
1592  return template
1593 
std::string join(T const &container, std::string const &delim)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.contains_require_check (   sig)

Definition at line 1634 of file generate_TableFunctionsFactory_init.py.

Referenced by parse_annotations().

1635 def contains_require_check(sig):
1636  for arg_annotations in sig.input_annotations:
1637  d = dict(arg_annotations)
1638  if 'require' in d.keys():
1639  return True
1640  return False
1641 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.find_comma (   line)

Definition at line 324 of file generate_TableFunctionsFactory_init.py.

Referenced by generate_TableFunctionsFactory_init.Bracket.parse().

325 def find_comma(line):
326  d = 0
327  for i, c in enumerate(line):
328  if c in '<([{':
329  d += 1
330  elif c in '>)]{':
331  d -= 1
332  elif d == 0 and c == ',':
333  return i
334  return -1
335 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.find_signatures (   input_file)
Returns a list of parsed UDTF signatures.

Definition at line 1507 of file generate_TableFunctionsFactory_init.py.

References line_is_incomplete(), omnisci.open(), split(), and run_benchmark_import.type.

Referenced by parse_annotations().

1508 def find_signatures(input_file):
1509  """Returns a list of parsed UDTF signatures."""
1510  signatures = []
1511 
1512  last_line = None
1513  for line in open(input_file).readlines():
1514  line = line.strip()
1515  if last_line is not None:
1516  line = last_line + line
1517  last_line = None
1518  if not line.startswith('UDTF:'):
1519  continue
1520  if line_is_incomplete(line):
1521  last_line = line
1522  continue
1523  last_line = None
1524  line = line[5:].lstrip()
1525  i = line.find('(')
1526  j = line.find(')')
1527  if i == -1 or j == -1:
1528  sys.stderr.write('Invalid UDTF specification: `%s`. Skipping.\n' % (line))
1529  continue
1530 
1531  expected_result = None
1532  if '!' in line:
1533  line, expected_result = line.split('!', 1)
1534  expected_result = expected_result.strip().split('!')
1535  expected_result = list(map(lambda s: s.strip(), expected_result))
1536 
1537  ast = Parser(line).parse()
1538 
1539  if expected_result is not None:
1540  # Template transformer expands templates into multiple lines
1541  skip_signature = False
1542  try:
1543  result = Pipeline(TemplateTransformer, NormalizeTransformer, SupportedAnnotationsTransformer, AstPrinter)(ast)
1544  except TransformerException as msg:
1545  result = ['%s: %s' % (type(msg).__name__, msg)]
1546  skip_signature = True
1547  assert set(result) == set(expected_result), "\n\tresult: %s != \n\texpected: %s" % (
1548  result,
1549  expected_result,
1550  )
1551  if skip_signature:
1552  continue
1553 
1554  signature = Pipeline(TemplateTransformer,
1555  NormalizeTransformer,
1556  SupportedAnnotationsTransformer,
1557  SignatureTransformer)(ast)
1558 
1559  signatures.extend(signature)
1560 
1561  return signatures
1562 
int open(const char *path, int flags, int mode)
Definition: omnisci_fs.cpp:64
std::vector< std::string > split(std::string_view str, std::string_view delim, std::optional< size_t > maxsplit)
split apart a string into a vector of substrings

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.format_annotations (   annotations_)

Definition at line 1642 of file generate_TableFunctionsFactory_init.py.

References join().

Referenced by parse_annotations().

1643 def format_annotations(annotations_):
1644  def fmt(k, v):
1645  # type(v) is not always 'str'
1646  if k == 'require':
1647  return v[1:-1]
1648  return v
1649 
1650  s = "std::vector<std::map<std::string, std::string>>{"
1651  s += ', '.join(('{' + ', '.join('{"%s", "%s"}' % (k, fmt(k, v)) for k, v in a) + '}') for a in annotations_)
1652  s += "}"
1653  return s
1654 
std::string join(T const &container, std::string const &delim)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.is_cpu_function (   sig)

Definition at line 1664 of file generate_TableFunctionsFactory_init.py.

References uses_manager().

Referenced by parse_annotations().

1665 def is_cpu_function(sig):
1666  # Any function that does not have _gpu_ suffix is a cpu function.
1667  i = sig.name.rfind('_gpu_')
1668  if i >= 0 and '__' in sig.name[:i + 1]:
1669  if uses_manager(sig):
1670  raise ValueError('Table function {} with gpu execution target cannot have TableFunctionManager argument'.format(sig.name))
1671  return False
1672  return True
1673 

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.is_gpu_function (   sig)

Definition at line 1674 of file generate_TableFunctionsFactory_init.py.

References uses_manager().

Referenced by parse_annotations().

1675 def is_gpu_function(sig):
1676  # A function with TableFunctionManager argument is a cpu-only function
1677  if uses_manager(sig):
1678  return False
1679  # Any function that does not have _cpu_ suffix is a gpu function.
1680  i = sig.name.rfind('_cpu_')
1681  return not (i >= 0 and '__' in sig.name[:i + 1])
1682 

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.is_identifier_cursor (   identifier)

Definition at line 342 of file generate_TableFunctionsFactory_init.py.

Referenced by generate_TableFunctionsFactory_init.Parser.parse_composed().

343 def is_identifier_cursor(identifier):
344  return identifier.lower() == 'cursor'
345 
346 
347 # fmt: on
348 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.is_template_function (   sig)

Definition at line 1655 of file generate_TableFunctionsFactory_init.py.

Referenced by parse_annotations().

1656 def is_template_function(sig):
1657  i = sig.name.rfind('_template')
1658  return i >= 0 and '__' in sig.name[:i + 1]
1659 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.line_is_incomplete (   line)

Definition at line 336 of file generate_TableFunctionsFactory_init.py.

Referenced by find_signatures().

337 def line_is_incomplete(line):
338  # TODO: try to parse the line to be certain about completeness.
339  # `!' is used to separate the UDTF signature and the expected result
340  return line.endswith(',') or line.endswith('->') or line.endswith('!')
341 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.parse_annotations (   input_files)

Definition at line 1683 of file generate_TableFunctionsFactory_init.py.

References build_require_check_function(), build_template_function_call(), contains_require_check(), find_signatures(), format_annotations(), is_cpu_function(), is_gpu_function(), is_template_function(), and join().

1684 def parse_annotations(input_files):
1685 
1686  counter = 0
1687 
1688  add_stmts = []
1689  cpu_template_functions = []
1690  gpu_template_functions = []
1691  cpu_function_address_expressions = []
1692  gpu_function_address_expressions = []
1693  cond_fns = []
1694 
1695  for input_file in input_files:
1696  for sig in find_signatures(input_file):
1697 
1698  # Compute sql_types, input_types, and sizer
1699  sql_types_ = []
1700  input_types_ = []
1701  input_annotations = []
1702  sizer = None
1703  uses_manager = False
1704  for i, (t, annot) in enumerate(zip(sig.inputs, sig.input_annotations)):
1705  if t.is_output_buffer_sizer():
1706  if t.is_user_specified():
1707  sql_types_.append(Bracket.parse('int32').normalize(kind='input'))
1708  input_types_.append(sql_types_[-1])
1709  input_annotations.append(annot)
1710  assert sizer is None # exactly one sizer argument is allowed
1711  assert len(t.args) == 1, t
1712  sizer = 'TableFunctionOutputRowSizer{OutputBufferSizeType::%s, %s}' % (t.name, t.args[0])
1713  elif t.name == 'Cursor':
1714  for t_ in t.args:
1715  input_types_.append(t_)
1716  input_annotations.append(annot)
1717  sql_types_.append(Bracket('Cursor', args=()))
1718  elif t.name == 'TableFunctionManager':
1719  if i != 0:
1720  raise ValueError('{} must appear as a first argument of {}, but found it at position {}.'.format(t, sig.name, i))
1721  uses_manager = True
1722  else:
1723  input_types_.append(t)
1724  input_annotations.append(annot)
1725  if t.is_column_any():
1726  # XXX: let Bracket handle mapping of column to cursor(column)
1727  sql_types_.append(Bracket('Cursor', args=()))
1728  else:
1729  sql_types_.append(t)
1730 
1731  if sizer is None:
1732  name = 'kTableFunctionSpecifiedParameter'
1733  idx = 1 # this sizer is not actually materialized in the UDTF
1734  sizer = 'TableFunctionOutputRowSizer{OutputBufferSizeType::%s, %s}' % (name, idx)
1735 
1736  assert sizer is not None
1737  ns_output_types = tuple([a.apply_namespace(ns='ExtArgumentType') for a in sig.outputs])
1738  ns_input_types = tuple([t.apply_namespace(ns='ExtArgumentType') for t in input_types_])
1739  ns_sql_types = tuple([t.apply_namespace(ns='ExtArgumentType') for t in sql_types_])
1740 
1741  input_types = 'std::vector<ExtArgumentType>{%s}' % (', '.join(map(tostring, ns_input_types)))
1742  output_types = 'std::vector<ExtArgumentType>{%s}' % (', '.join(map(tostring, ns_output_types)))
1743  sql_types = 'std::vector<ExtArgumentType>{%s}' % (', '.join(map(tostring, ns_sql_types)))
1744  annotations = format_annotations(input_annotations + sig.output_annotations + [sig.function_annotations])
1745 
1746  # Notice that input_types and sig.input_types, (and
1747  # similarly, input_annotations and sig.input_annotations)
1748  # have different lengths when the sizer argument is
1749  # Constant or TableFunctionSpecifiedParameter. That is,
1750  # input_types contains all the user-specified arguments
1751  # while sig.input_types contains all arguments of the
1752  # implementation of an UDTF.
1753 
1754  if contains_require_check(sig):
1755  check_fn = build_require_check_function(sig.name, input_types_, input_annotations, uses_manager)
1756  cond_fns.append(check_fn)
1757 
1758  if is_template_function(sig):
1759  name = sig.name + '_' + str(counter)
1760  counter += 1
1761  t = build_template_function_call(name, sig.name, input_types_, sig.outputs, uses_manager)
1762  address_expression = ('avoid_opt_address(reinterpret_cast<void*>(%s))' % name)
1763  if is_cpu_function(sig):
1764  cpu_template_functions.append(t)
1765  cpu_function_address_expressions.append(address_expression)
1766  if is_gpu_function(sig):
1767  gpu_template_functions.append(t)
1768  gpu_function_address_expressions.append(address_expression)
1769  add = ('TableFunctionsFactory::add("%s", %s, %s, %s, %s, %s, /*is_runtime:*/false, /*uses_manager:*/%s);'
1770  % (name, sizer, input_types, output_types, sql_types, annotations, str(uses_manager).lower()))
1771  add_stmts.append(add)
1772 
1773  else:
1774  add = ('TableFunctionsFactory::add("%s", %s, %s, %s, %s, %s, /*is_runtime:*/false, /*uses_manager:*/%s);'
1775  % (sig.name, sizer, input_types, output_types, sql_types, annotations, str(uses_manager).lower()))
1776  add_stmts.append(add)
1777  address_expression = ('avoid_opt_address(reinterpret_cast<void*>(%s))' % sig.name)
1778 
1779  if is_cpu_function(sig):
1780  cpu_function_address_expressions.append(address_expression)
1781  if is_gpu_function(sig):
1782  gpu_function_address_expressions.append(address_expression)
1783 
1784  return add_stmts, cpu_template_functions, gpu_template_functions, cpu_function_address_expressions, gpu_function_address_expressions, cond_fns
1785 
std::string join(T const &container, std::string const &delim)

+ Here is the call graph for this function:

def generate_TableFunctionsFactory_init.product_dict (   kwargs)

Definition at line 714 of file generate_TableFunctionsFactory_init.py.

Referenced by generate_TableFunctionsFactory_init.TemplateTransformer.visit_udtf_node().

715 def product_dict(**kwargs):
716  keys = kwargs.keys()
717  vals = kwargs.values()
718  for instance in itertools.product(*vals):
719  yield dict(zip(keys, instance))
720 

+ Here is the caller graph for this function:

def generate_TableFunctionsFactory_init.tostring (   obj)

Definition at line 156 of file generate_TableFunctionsFactory_init.py.

157 def tostring(obj):
158  return obj.tostring()
159 
def generate_TableFunctionsFactory_init.uses_manager (   sig)

Definition at line 1660 of file generate_TableFunctionsFactory_init.py.

Referenced by is_cpu_function(), and is_gpu_function().

1661 def uses_manager(sig):
1662  return sig.inputs and sig.inputs[0].name == 'TableFunctionManager'
1663 

+ Here is the caller graph for this function:

Variable Documentation

list generate_TableFunctionsFactory_init.canonical_input_files = [input_file[input_file.find("/QueryEngine/") + 1:] for input_file in input_files]

Definition at line 1803 of file generate_TableFunctionsFactory_init.py.

string generate_TableFunctionsFactory_init.content

Definition at line 1806 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.cpu_output_header = os.path.splitext(output_filename)

Definition at line 1797 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.dirname = os.path.dirname(output_filename)

Definition at line 1883 of file generate_TableFunctionsFactory_init.py.

string generate_TableFunctionsFactory_init.ExtArgumentTypes
Initial value:
1 = ''' Int8, Int16, Int32, Int64, Float, Double, Void, PInt8, PInt16,
2 PInt32, PInt64, PFloat, PDouble, PBool, Bool, ArrayInt8, ArrayInt16,
3 ArrayInt32, ArrayInt64, ArrayFloat, ArrayDouble, ArrayBool, GeoPoint,
4 GeoLineString, Cursor, GeoPolygon, GeoMultiPolygon, ColumnInt8,
5 ColumnInt16, ColumnInt32, ColumnInt64, ColumnFloat, ColumnDouble,
6 ColumnBool, ColumnTextEncodingDict, TextEncodingNone, TextEncodingDict,
7 ColumnListInt8, ColumnListInt16, ColumnListInt32, ColumnListInt64,
8 ColumnListFloat, ColumnListDouble, ColumnListBool, ColumnListTextEncodingDict'''

Definition at line 80 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.f = open(output_filename, 'w')

Definition at line 1893 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.gpu_output_header = os.path.splitext(output_filename)

Definition at line 1798 of file generate_TableFunctionsFactory_init.py.

string generate_TableFunctionsFactory_init.header_content
Initial value:
1 = '''
2 /*
3  This file is generated by %s. Do no edit!
4 */
5 %s
6 
7 %s
8 '''

Definition at line 1874 of file generate_TableFunctionsFactory_init.py.

list generate_TableFunctionsFactory_init.header_includes = ['#include "' + canonical_input_file + '"' for canonical_input_file in canonical_input_files]

Definition at line 1804 of file generate_TableFunctionsFactory_init.py.

list generate_TableFunctionsFactory_init.input_files = [os.path.join(os.path.dirname(__file__), 'test_udtf_signatures.hpp')]

Definition at line 1788 of file generate_TableFunctionsFactory_init.py.

string generate_TableFunctionsFactory_init.OutputBufferSizeTypes
Initial value:
1 = '''
2 kConstant, kUserSpecifiedConstantParameter, kUserSpecifiedRowMultiplier, kTableFunctionSpecifiedParameter
3 '''

Definition at line 89 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.Signature = namedtuple('Signature', ['name', 'inputs', 'outputs', 'input_annotations', 'output_annotations', 'function_annotations'])

Definition at line 78 of file generate_TableFunctionsFactory_init.py.

Referenced by generate_TableFunctionsFactory_init.SignatureTransformer.visit_udtf_node().

string generate_TableFunctionsFactory_init.SupportedAnnotations
Initial value:
1 = '''
2 input_id, name, fields, require
3 '''

Definition at line 93 of file generate_TableFunctionsFactory_init.py.

string generate_TableFunctionsFactory_init.SupportedFunctionAnnotations
Initial value:
1 = '''
2 filter_table_function_transpose
3 '''

Definition at line 98 of file generate_TableFunctionsFactory_init.py.

tuple generate_TableFunctionsFactory_init.translate_map
Initial value:
1 = dict(
2  Constant='kConstant',
3  ConstantParameter='kUserSpecifiedConstantParameter',
4  RowMultiplier='kUserSpecifiedRowMultiplier',
5  UserSpecifiedConstantParameter='kUserSpecifiedConstantParameter',
6  UserSpecifiedRowMultiplier='kUserSpecifiedRowMultiplier',
7  TableFunctionSpecifiedParameter='kTableFunctionSpecifiedParameter',
8  short='Int16',
9  int='Int32',
10  long='Int64',
11 )

Definition at line 102 of file generate_TableFunctionsFactory_init.py.