code: def execute_async(self, query, parameters=None, trace=False, custom_payload=None,
                        timeout=_NOT_SET, execution_profile=EXEC_PROFILE_DEFAULT,
                        paging_state=None, host=None):
          
          future = self._create_response_future(
              query, parameters, trace, custom_payload, timeout,
              execution_profile, paging_state, host)
          future._protocol_handler = self.client_protocol_handler
          self._on_request(future)
          future.send_request()
          return future
docs: Execute the given query and return a :class:`~.ResponseFuture` object
          which callbacks may be attached to for asynchronous response
          delivery.  You may also call :meth:`~.ResponseFuture.result()`
          on the :class:`.ResponseFuture` to synchronously block for results at
          any time.
  
          See :meth:`Session.execute` for parameter definitions.
  
          Example usage::
  
              >>> session = cluster.connect()
              >>> future = session.execute_async("SELECT * FROM mycf")
  
              >>> def log_results(results):
              ...     for row in results:
              ...         log.info("Results: %s", row)
  
              >>> def log_error(exc):
              >>>     log.error("Operation failed: %s", exc)
  
              >>> future.add_callbacks(log_results, log_error)
  
          Async execution with blocking wait for results::
  
              >>> future = session.execute_async("SELECT * FROM mycf")
              >>> # do other stuff...
  
              >>> try:
              ...     results = future.result()
              ... except Exception:
              ...     log.exception("Operation failed:")