Method _create_boolean_func_tree

tests/comparison/query_generator.py:1347–1479

Creates a function that returns a Boolean. The returned value is a Tuple > where the first function is the root of the tree and the list contains relational functions (though other relational functions may also be in the tree). The root function's argumen

(self, require_relational_func=False,
                                relational_col_types=None, allow_subquery=False,
                                allowed_signatures=None)

      _enable_distinct_helper(item.val_expr)

  def _create_boolean_func_tree(self, require_relational_func=False,
                                relational_col_types=None, allow_subquery=False,
                                allowed_signatures=None):
    '''Creates a function that returns a Boolean. The returned value is a
       Tuple<Function, List<Function>> where the first function is the root of the tree
       and the list contains relational functions (though other relational functions
       may also be in the tree). The root function&#x27;s arguments may be other functions
       depending on the query profile in use. The leaf arguments of the tree will all be
       set to a NULL literal.

       Args:
         require_relational_func: If True, at least one function in the tree will be a
         relational function such as Equals, LessThanOrEquals, etc.

         relational_col_types: Can be used to restrict the signature of the chosen
         relational function to the given types.

         allow_subquery: If True, a subquery may be added to the function tree.

         allowed_signatures: A list of allowable signatures to be used inside the function
         tree. This list is not definitive, functions outside this list may be added to
         the function tree if they are explicitly added by the QueryProfile.
    ''&#x27;
    # To create a realistic expression, the nodes nearest the root of the tree will be
    # ANDs and ORs, their children will be relational functions, then other number of
    # functions requested by the profile will be added as children of the relational
    # functions. There is no requirement that all children of ANDs and ORs will be
    # relational functions so a wide variety of queries should be generated.

    # Determine the number of non-leaf nodes in the tree.
    if require_relational_func:
      # Just assume this is for a JOIN.
      func_count = self.profile.choose_join_condition_count()
      if func_count <= 0:
        raise Exception("Relational condition count must be greater than zero")
    else:
      func_count = self.profile.choose_nested_expr_count() + 1

    and_or_fill_ratio = self.profile.choose_conjunct_disjunct_fill_ratio()
    and_or_count = int(and_or_fill_ratio * func_count)
    if and_or_count == func_count and require_relational_func:
      # Leave a space for a relational function.
      and_or_count -= 1

    relational_fill_ratio = self.profile.choose_relational_func_fill_ratio()
    relational_count = int(relational_fill_ratio * (func_count - and_or_count))
    if relational_count > and_or_count + 1:
      # Reduce the AND/OR count to the number of boolean spaces that are guaranteed to
      # exist.
      relational_count = and_or_count + 1
    elif relational_count == 0 and require_relational_func:
      relational_count = 1

    root_func = None   # The root of the function tree.
    relational_funcs = list()  # These will be in the tree somewhere.

    # After a root function is chosen, each additional function will be chosen based on
    # the types required by the leaves (existing unused function args). For example if