code: def execute(self, query, parameters=None, timeout=_NOT_SET, trace=False,
                  custom_payload=None, execution_profile=EXEC_PROFILE_DEFAULT,
                  paging_state=None, host=None):
          
          return self.execute_async(query, parameters, trace, custom_payload,
                                    timeout, execution_profile, paging_state, host).result()
docs: Execute the given query and synchronously wait for the response.
  
          If an error is encountered while executing the query, an Exception
          will be raised.
  
          `query` may be a query string or an instance of :class:`cassandra.query.Statement`.
  
          `parameters` may be a sequence or dict of parameters to bind.  If a
          sequence is used, ``%s`` should be used the placeholder for each
          argument.  If a dict is used, ``%(name)s`` style placeholders must
          be used.
  
          `timeout` should specify a floating-point timeout (in seconds) after
          which an :exc:`.OperationTimedOut` exception will be raised if the query
          has not completed.  If not set, the timeout defaults to
          :attr:`~.Session.default_timeout`.  If set to :const:`None`, there is
          no timeout. Please see :meth:`.ResponseFuture.result` for details on
          the scope and effect of this timeout.
  
          If `trace` is set to :const:`True`, the query will be sent with tracing enabled.
          The trace details can be obtained using the returned :class:`.ResultSet` object.
  
          `custom_payload` is a :ref:`custom_payload` dict to be passed to the server.
          If `query` is a Statement with its own custom_payload. The message payload
          will be a union of the two, with the values specified here taking precedence.
  
          `execution_profile` is the execution profile to use for this request. It can be a key to a profile configured
          via :meth:`Cluster.add_execution_profile` or an instance (from :meth:`Session.execution_profile_clone_update`,
          for example
  
          `paging_state` is an optional paging state, reused from a previous :class:`ResultSet`.
  
          `host` is the :class:`pool.Host` that should handle the query. Using this is discouraged except in a few
          cases, e.g., querying node-local tables and applying schema changes.