code: def generate_query_batches(
          self,
          sql,
          params=None,
          param_types=None,
          partition_size_bytes=None,
          max_partitions=None,
      ):
          
          partitions = self._get_snapshot().partition_query(
              sql=sql,
              params=params,
              param_types=param_types,
              partition_size_bytes=partition_size_bytes,
              max_partitions=max_partitions,
          )
  
          query_info = {"sql": sql}
          if params:
              query_info["params"] = params
              query_info["param_types"] = param_types
  
          for partition in partitions:
              yield {"partition": partition, "query": query_info}
docs: Start a partitioned query operation.
  
          Uses the ``PartitionQuery`` API request to start a partitioned
          query operation.  Returns a list of batch information needed to
          peform the actual queries.
  
          :type sql: str
          :param sql: SQL query statement
  
          :type params: dict, {str -> column value}
          :param params: values for parameter replacement.  Keys must match
                         the names used in ``sql``.
  
          :type param_types: dict[str -> Union[dict, .types.Type]]
          :param param_types:
              (Optional) maps explicit types for one or more param values;
              required if parameters are passed.
  
          :type partition_size_bytes: int
          :param partition_size_bytes:
              (Optional) desired size for each partition generated.  The service
              uses this as a hint, the actual partition size may differ.
  
          :type partition_size_bytes: int
          :param partition_size_bytes:
              (Optional) desired size for each partition generated.  The service
              uses this as a hint, the actual partition size may differ.
  
          :type max_partitions: int
          :param max_partitions:
              (Optional) desired maximum number of partitions generated. The
              service uses this as a hint, the actual number of partitions may
              differ.
  
          :rtype: iterable of dict
          :returns:
              mappings of information used peform actual partitioned reads via
              :meth:`process_read_batch`.