docs: def execute_async(self, table_name=None, table_mode='create', use_cache=True, priority='high',
                      allow_large_results=False, dialect=None, billing_tier=None):
      """Materialize the View asynchronously.
  
      Args:
        table_name: the result table name; if None, then a temporary table will be used.
        table_mode: one of 'create', 'overwrite' or 'append'. If 'create' (the default), the request
            will fail if the table exists.
        use_cache: whether to use past query results or ignore cache. Has no effect if destination is
            specified (default True).
        priority:one of 'low' or 'high' (default). Note that 'high' is more expensive, but is
            better suited to exploratory analysis.
        allow_large_results: whether to allow large results; i.e. compressed data over 100MB. This is
            slower and requires a table_name to be specified) (default False).
        dialect : {'legacy', 'standard'}, default 'legacy'
            'legacy' : Use BigQuery's legacy SQL dialect.
            'standard' : Use BigQuery's standard SQL (beta), which is
            compliant with the SQL 2011 standard.
        billing_tier: Limits the billing tier for this job. Queries that have resource
            usage beyond this tier will fail (without incurring a charge). If unspecified, this
            will be set to your project default. This can also be used to override your
            project-wide default billing tier on a per-query basis.
      Returns:
        A QueryJob for the materialization
      Raises:
        Exception (KeyError) if View could not be materialized.
      """
      return self._materialization.execute_async(table_name=table_name, table_mode=table_mode,
                                                 use_cache=use_cache, priority=priority,
                                                 allow_large_results=allow_large_results,
                                                 dialect=dialect, billing_tier=billing_tier)