Was this page helpful?
ScyllaDB Python Driver is available under the Apache v2 License. ScyllaDB Python Driver is a fork of DataStax Python Driver. See Copyright here.
Caution
You're viewing documentation for a deprecated version of Scylla Python Driver. Switch to the latest stable version.
cassandra.cluster - Clusters and Sessions¶The main class to use when interacting with a Cassandra cluster. Typically, one instance of this class will be created for each separate Cassandra cluster that your application interacts with.
Example usage:
>>> from cassandra.cluster import Cluster
>>> cluster = Cluster(['192.168.1.1', '192.168.1.2'])
>>> session = cluster.connect()
>>> session.execute("CREATE KEYSPACE ...")
>>> ...
>>> cluster.shutdown()
Cluster and Session also provide context management functions
which implicitly handle shutdown when leaving scope.
executor_threads defines the number of threads in a pool for handling asynchronous tasks such as
extablishing connection pools or refreshing metadata.
Any of the mutable Cluster attributes may be set as keyword arguments to the constructor.
When protocol_version is 2 or higher, this should
be an instance of a subclass of AuthProvider,
such as PlainTextAuthProvider.
When protocol_version is 1, this should be
a function that accepts one argument, the IP address of a node,
and returns a dict of credentials for that node.
When not using authentication, this should be left as None.
An instance of policies.LoadBalancingPolicy or
one of its subclasses.
Changed in version 2.6.0.
Defaults to TokenAwarePolicy (DCAwareRoundRobinPolicy).
when using CPython (where the murmur3 extension is available). DCAwareRoundRobinPolicy
otherwise. Default local DC will be chosen from contact points.
Please see DCAwareRoundRobinPolicy for a discussion on default behavior with respect to
DC locality and remote nodes.
A default policies.RetryPolicy instance to use for all
Statement objects which do not have a retry_policy
explicitly set.
Flag indicating whether internal schema metadata is updated.
When disabled, the driver does not populate Cluster.metadata.keyspaces on connect, or on schema change events. This can be used to speed initial connection, and reduce load on client and server during operation. Turning this off gives away token aware request routing, and programmatic inspection of the metadata model.
Flag indicating whether internal token metadata is updated.
When disabled, the driver does not query node token information on connect, or on topology change events. This can be used to speed initial connection, and reduce load on client and server during operation. It is most useful in large clusters using vnodes, where the token map can be expensive to compute. Turning this off gives away token aware request routing, and programmatic inspection of the token ring.
Creates and returns a new Session object.
If keyspace is specified, that keyspace will be the default keyspace for
operations on the Session.
wait_for_all_pools specifies whether this call should wait for all connection pools to be established or attempted. Default is False, which means it will return when the first successful connection is established. Remaining pools are added asynchronously.
Closes all sessions and connection associated with this Cluster. To ensure all connections are properly closed, you should always call shutdown() on a Cluster instance when you are done with it.
Once shutdown, a Cluster should not be used for any purpose.
Registers a class to use to represent a particular user-defined type. Query parameters for this user-defined type will be assumed to be instances of klass. Result sets for this user-defined type will be instances of klass. If no class is registered for a user-defined type, a namedtuple will be used for result sets, and non-prepared statements may not encode parameters for this type correctly.
keyspace is the name of the keyspace that the UDT is defined in.
user_type is the string name of the UDT to register the mapping for.
klass should be a class with attributes whose names match the fields of the user-defined type. The constructor must accepts kwargs for each of the fields in the UDT.
This method should only be called after the type has been created within Cassandra.
Example:
cluster = Cluster(protocol_version=3)
session = cluster.connect()
session.set_keyspace('mykeyspace')
session.execute("CREATE TYPE address (street text, zipcode int)")
session.execute("CREATE TABLE users (id int PRIMARY KEY, location address)")
# create a class to map to the "address" UDT
class Address(object):
def __init__(self, street, zipcode):
self.street = street
self.zipcode = zipcode
cluster.register_user_type('mykeyspace', 'address', Address)
# insert a row using an instance of Address
session.execute("INSERT INTO users (id, location) VALUES (%s, %s)",
(0, Address("123 Main St.", 78723)))
# results will include Address instances
results = session.execute("SELECT * FROM users")
row = results[0]
print(row.id, row.location.street, row.location.zipcode)
Adds a cassandra.policies.HostStateListener subclass instance to
the list of listeners to be notified when a host is added, removed,
marked up, or marked down.
Removes a registered listener.
Adds an ExecutionProfile to the cluster. This makes it available for use by name in Session.execute()
and Session.execute_async(). This method will raise if the profile already exists.
Normally profiles will be injected at cluster initialization via Cluster(execution_profiles). This method
provides a way of adding them dynamically.
Adding a new profile updates the connection pools according to the specified load_balancing_policy. By default,
this method will wait up to five seconds for the pool creation to complete, so the profile can be used immediately
upon return. This behavior can be controlled using pool_wait_timeout (see
concurrent.futures.wait
for timeout semantics).
Sets a threshold for concurrent requests per connection, above which new
connections will be created to a host (up to max connections;
see set_max_connections_per_host()).
Pertains to connection pool management in protocol versions {1,2}.
Sets a threshold for concurrent requests per connection, below which
connections will be considered for disposal (down to core connections;
see set_core_connections_per_host()).
Pertains to connection pool management in protocol versions {1,2}.
Gets the minimum number of connections per Session that will be opened
for each host with HostDistance equal to host_distance.
The default is 2 for LOCAL and 1 for
REMOTE.
This property is ignored if protocol_version is
3 or higher.
Sets the minimum number of connections per Session that will be opened
for each host with HostDistance equal to host_distance.
The default is 2 for LOCAL and 1 for
REMOTE.
Protocol version 1 and 2 are limited in the number of concurrent requests they can send per connection. The driver implements connection pooling to support higher levels of concurrency.
If protocol_version is set to 3 or higher, this
is not supported (there is always one connection per host, unless
the host is remote and connect_to_remote_hosts is False)
and using this will result in an UnsupportedOperation.
Gets the maximum number of connections per Session that will be opened
for each host with HostDistance equal to host_distance.
The default is 8 for LOCAL and 2 for
REMOTE.
This property is ignored if protocol_version is
3 or higher.
Sets the maximum number of connections per Session that will be opened
for each host with HostDistance equal to host_distance.
The default is 2 for LOCAL and 1 for
REMOTE.
If protocol_version is set to 3 or higher, this
is not supported (there is always one connection per host, unless
the host is remote and connect_to_remote_hosts is False)
and using this will result in an UnsupportedOperation.
Returns the control connection host metadata.
Synchronously refresh all schema metadata.
By default, the timeout for this operation is governed by max_schema_agreement_wait
and control_connection_timeout.
Passing max_schema_agreement_wait here overrides max_schema_agreement_wait.
Setting max_schema_agreement_wait <= 0 will bypass schema agreement and refresh schema immediately.
An Exception is raised if schema refresh fails for any reason.
Synchronously refresh keyspace metadata. This applies to keyspace-level information such as replication and durability settings. It does not refresh tables, types, etc. contained in the keyspace.
See refresh_schema_metadata() for description of max_schema_agreement_wait behavior
Synchronously refresh table metadata. This applies to a table, and any triggers or indexes attached to the table.
See refresh_schema_metadata() for description of max_schema_agreement_wait behavior
Synchronously refresh user defined type metadata.
See refresh_schema_metadata() for description of max_schema_agreement_wait behavior
Synchronously refresh user defined function metadata.
function is a cassandra.UserFunctionDescriptor.
See refresh_schema_metadata() for description of max_schema_agreement_wait behavior
Synchronously refresh user defined aggregate metadata.
aggregate is a cassandra.UserAggregateDescriptor.
See refresh_schema_metadata() for description of max_schema_agreement_wait behavior
Synchronously refresh the node list and token metadata
force_token_rebuild can be used to rebuild the token map metadata, even if no new nodes are discovered.
An Exception is raised if node refresh fails for any reason.
Deprecated: set schema_metadata_enabled token_metadata_enabled instead
Sets a flag to enable (True) or disable (False) all metadata refresh queries. This applies to both schema and node topology.
Disabling this is useful to minimize refreshes during multiple changes.
Meta refresh must be enabled for the driver to become aware of any cluster topology changes or schema updates.
Returns each row as a namedtuple. This is the default row factory.
Example:
>>> from cassandra.query import named_tuple_factory
>>> session = cluster.connect('mykeyspace')
>>> session.row_factory = named_tuple_factory
>>> rows = session.execute("SELECT name, age FROM users LIMIT 1")
>>> user = rows[0]
>>> # you can access field by their name:
>>> print("name: %s, age: %d" % (user.name, user.age))
name: Bob, age: 42
>>> # or you can access fields by their position (like a tuple)
>>> name, age = user
>>> print("name: %s, age: %d" % (name, age))
name: Bob, age: 42
>>> name = user[0]
>>> age = user[1]
>>> print("name: %s, age: %d" % (name, age))
name: Bob, age: 42
Changed in version 2.0.0: moved from cassandra.decoder to cassandra.query
Default execution profile for graph execution.
See ExecutionProfile for base attributes. Note that if not explicitly set,
the row_factory and graph_options.graph_protocol are resolved during the query execution.
These options will resolve to graph_graphson3_row_factory and GraphProtocol.GRAPHSON_3_0
for the core graph engine (DSE 6.8+), otherwise graph_object_row_factory and GraphProtocol.GRAPHSON_1_0
In addition to default parameters shown in the signature, this profile also defaults retry_policy to
cassandra.policies.NeverRetryPolicy.
Execution profile with timeout and load balancing appropriate for graph analytics queries.
See also GraphExecutionPolicy.
In addition to default parameters shown in the signature, this profile also defaults retry_policy to
cassandra.policies.NeverRetryPolicy, and load_balancing_policy to one that targets the current Spark
master.
Note: The graph_options.graph_source is set automatically to b’a’ (analytics) when using GraphAnalyticsExecutionProfile. This is mandatory to target analytics nodes.
The base class of the class hierarchy.
When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.
The base class of the class hierarchy.
When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.
The base class of the class hierarchy.
When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.
The base class of the class hierarchy.
When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.
A collection of connection pools for each host in the cluster.
Instances of this class should not be created directly, only
using Cluster.connect().
Queries and statements can be executed through Session instances
using the execute() and execute_async()
methods.
Example usage:
>>> session = cluster.connect()
>>> session.set_keyspace("mykeyspace")
>>> session.execute("SELECT * FROM mycf")
A default timeout, measured in seconds, for queries executed through
execute() or execute_async(). This default may be
overridden with the timeout parameter for either of those methods.
Setting this to None will cause no timeouts to be set by default.
Please see ResponseFuture.result() for details on the scope and
effect of this timeout.
Added in version 2.0.0.
Deprecated: use execution profiles instead
The default ConsistencyLevel for operations executed through
this session. This default may be overridden by setting the
consistency_level on individual statements.
Added in version 1.2.0.
Changed in version 3.0.0: default changed from ONE to LOCAL_ONE
The default ConsistencyLevel for serial phase of conditional updates executed through
this session. This default may be overridden by setting the
serial_consistency_level on individual statements.
Only valid for protocol_version >= 2.
The format to return row results in. By default, each returned row will be a named tuple. You can alternatively use any of the following:
cassandra.query.tuple_factory() - return a result row as a tuple
cassandra.query.named_tuple_factory() - return a result row as a named tuple
cassandra.query.dict_factory() - return a result row as a dict
cassandra.query.ordered_dict_factory() - return a result row as an OrderedDict
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 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 OperationTimedOut exception will be raised if the query
has not completed. If not set, the timeout defaults to the request_timeout of the selected execution_profile.
If set to None, there is no timeout. Please see ResponseFuture.result() for details on
the scope and effect of this timeout.
If trace is set to True, the query will be sent with tracing enabled.
The trace details can be obtained using the returned ResultSet object.
custom_payload is a Custom Payloads 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 Cluster.add_execution_profile() or an instance (from Session.execution_profile_clone_update(),
for example
paging_state is an optional paging state, reused from a previous ResultSet.
host is the cassandra.pool.Host that should handle the query. If the host specified is down or
not yet connected, the query will fail with NoHostAvailable. Using this is
discouraged except in a few cases, e.g., querying node-local tables and applying schema changes.
execute_as the user that will be used on the server to execute the request. This is only available on a DSE cluster.
Execute the given query and return a ResponseFuture object
which callbacks may be attached to for asynchronous response
delivery. You may also call result()
on the ResponseFuture to synchronously block for results at
any time.
See 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:")
Executes a Gremlin query string or GraphStatement synchronously, and returns a ResultSet from this execution.
parameters is dict of named parameters to bind. The values must be JSON-serializable.
execution_profile: Selects an execution profile for the request.
execute_as the user that will be used on the server to execute the request.
Execute the graph query and return a ResponseFuture
object which callbacks may be attached to for asynchronous response delivery. You may also call ResponseFuture.result() to synchronously block for
results at any time.
Prepares a query string, returning a PreparedStatement
instance which can be used as follows:
>>> session = cluster.connect("mykeyspace")
>>> query = "INSERT INTO users (id, name, age) VALUES (?, ?, ?)"
>>> prepared = session.prepare(query)
>>> session.execute(prepared, (user.id, user.name, user.age))
Or you may bind values to the prepared statement ahead of time:
>>> prepared = session.prepare(query)
>>> bound_stmt = prepared.bind((user.id, user.name, user.age))
>>> session.execute(bound_stmt)
Of course, prepared statements may (and should) be reused:
>>> prepared = session.prepare(query)
>>> for user in users:
... bound = prepared.bind((user.id, user.name, user.age))
... session.execute(bound)
Alternatively, if protocol_version is 5 or higher
(requires Cassandra 4.0+), the keyspace can be specified as a
parameter. This will allow you to avoid specifying the keyspace in the
query without specifying a keyspace in connect(). It
even will let you prepare and use statements against a keyspace other
than the one originally specified on connection:
>>> analyticskeyspace_prepared = session.prepare(
... "INSERT INTO user_activity id, last_activity VALUES (?, ?)",
... keyspace="analyticskeyspace") # note the different keyspace
Important: PreparedStatements should be prepared only once. Preparing the same query more than once will likely affect performance.
custom_payload is a key value map to be passed along with the prepare message. See Custom Payloads.
Close all connections. Session instances should not be used
for any purpose after being shutdown.
Set the default keyspace for all queries made through this Session. This operation blocks until complete.
Returns the execution profile associated with the provided name.
name – The name (or key) of the execution profile.
Returns a clone of the ep profile. kwargs can be specified to update attributes
of the returned profile.
This is a shallow clone, so any objects referenced by the profile are shared. This means Load Balancing Policy is maintained by inclusion in the active profiles. It also means updating any other rich objects will be seen by the active profile. In cases where this is not desirable, be sure to replace the instance instead of manipulating the shared object.
Adds a callback with arguments to be called when any request is created.
It will be invoked as fn(response_future, *args, **kwargs) after each client request is created, and before the request is sent. This can be used to create extensions by adding result callbacks to the response future.
response_future is the ResponseFuture for the request.
Note that the init callback is done on the client thread creating the request, so you may need to consider
synchronization if you have multiple threads. Any callbacks added to the response future will be executed
on the event loop thread, so the normal advice about minimizing cycles and avoiding blocking apply (see Note in
ResponseFuture.add_callbacks().
See this example in the source tree for an example.
Removes a callback and arguments from the list.
An asynchronous response delivery mechanism that is returned from calls
to Session.execute_async().
Synchronously, by calling result()
Asynchronously, by attaching callback and errback functions via
add_callback(), add_errback(), and
add_callbacks().
Return the final result or raise an Exception if errors were encountered. If the final result or error has not been set yet, this method will block until it is set, or the timeout set for the request expires.
Timeout is specified in the Session request execution functions.
If the timeout is exceeded, an cassandra.OperationTimedOut will be raised.
This is a client-side timeout. For more information
about server-side coordinator timeouts, see policies.RetryPolicy.
Example usage:
>>> future = session.execute_async("SELECT * FROM mycf")
>>> # do other stuff...
>>> try:
... rows = future.result()
... for row in rows:
... ... # process results
... except Exception:
... log.exception("Operation failed:")
Fetches and returns the query trace of the last response, or None if tracing was not enabled.
Note that this may raise an exception if there are problems retrieving the trace
details from Cassandra. If the trace is not available after max_wait,
cassandra.query.TraceUnavailable will be raised.
If the ResponseFuture is not done (async execution) and you try to retrieve the trace,
cassandra.query.TraceUnavailable will be raised.
query_cl is the consistency level used to poll the trace tables.
Fetches and returns the query traces for all query pages, if tracing was enabled.
See note in get_query_trace() regarding possible exceptions.
The custom payload returned from the server, if any. This will only be set by Cassandra servers implementing a custom QueryHandler, and only for protocol_version 4+.
Ensure the future is complete before trying to access this property
(call result(), or after callback is invoked).
Otherwise it may throw if the response has not been received.
Returns True if there are more pages left in the
query results, False otherwise. This should only
be checked after the first page has been returned.
Added in version 2.0.0.
Warnings returned from the server, if any. This will only be set for protocol_version 4+.
Warnings may be returned for such things as oversized batches, or too many tombstones in slice queries.
Ensure the future is complete before trying to access this property
(call result(), or after callback is invoked).
Otherwise it may throw if the response has not been received.
If there are more pages left in the query result, this asynchronously
starts fetching the next page. If there are no pages left, QueryExhausted
is raised. Also see has_more_pages.
This should only be called after the first page has been returned.
Added in version 2.0.0.
Attaches a callback function to be called when the final results arrive.
By default, fn will be called with the results as the first and only argument. If *args or **kwargs are supplied, they will be passed through as additional positional or keyword arguments to fn.
If an error is hit while executing the operation, a callback attached
here will not be called. Use add_errback() or add_callbacks()
if you wish to handle that case.
If the final result has already been seen when this method is called, the callback will be called immediately (before this method returns).
Note: in the case that the result is not available when the callback is added, the callback is executed by IO event thread. This means that the callback should not block or attempt further synchronous requests, because no further IO will be processed until the callback returns.
Important: if the callback you attach results in an exception being raised, the exception will be ignored, so please ensure your callback handles all error cases that you care about.
Usage example:
>>> session = cluster.connect("mykeyspace")
>>> def handle_results(rows, start_time, should_log=False):
... if should_log:
... log.info("Total time: %f", time.time() - start_time)
... ...
>>> future = session.execute_async("SELECT * FROM users")
>>> future.add_callback(handle_results, time.time(), should_log=True)
Like add_callback(), but handles error cases.
An Exception instance will be passed as the first positional argument
to fn.
A convenient combination of add_callback() and
add_errback().
Example usage:
>>> session = cluster.connect()
>>> query = "SELECT * FROM mycf"
>>> future = session.execute_async(query)
>>> def log_results(results, level='debug'):
... for row in results:
... log.log(level, "Result: %s", row)
>>> def log_error(exc, query):
... log.error("Query '%s' failed: %s", query, exc)
>>> future.add_callbacks(
... callback=log_results, callback_kwargs={'level': 'info'},
... errback=log_error, errback_args=(query,))
An iterator over the rows from a query result. Also supplies basic equality and indexing methods for backward-compatability. These methods materialize the entire result set (loading all pages), and should only be used if the total result size is understood. Warnings are emitted when paged results are materialized in this fashion.
You can treat this as a normal iterator over rows:
>>> from cassandra.query import SimpleStatement
>>> statement = SimpleStatement("SELECT * FROM users", fetch_size=10)
>>> for user_row in session.execute(statement):
... process_user(user_row)
Whenever there are no more rows in the current page, the next page will
be fetched transparently. However, note that it is possible for
an Exception to be raised while fetching the next page, just
like you might see on a normal call to session.execute().
Returns all the remaining rows as a list. This is basically a convenient shortcut to list(result_set).
This function is not recommended for queries that return a large number of elements.
The list of current page rows. May be empty if the result was empty, or this is the last page.
Manually, synchronously fetch the next page. Supplied for manually retrieving pages
and inspecting current_page(). It is not necessary to call this when iterating
through results; paging happens implicitly in iteration.
Gets all query traces from the associated future.
See ResponseFuture.get_all_query_traces() for details.
Gets the last query trace from the associated future.
See ResponseFuture.get_query_trace() for details.
True if the last response indicated more pages; False otherwise
Return a single row of the results or None if empty. This is basically a shortcut to result_set.current_rows[0] and should only be used when you know a query returns a single row. Consider using an iterator if the ResultSet contains more than one row.
Server paging state of the query. Can be None if the query was not paged.
The driver treats paging state as opaque, but it may contain primary key data, so applications may want to avoid sending this to untrusted parties.
For LWT results, returns whether the transaction was applied.
Result is indeterminate if called on a result that was not an LWT request or on
a query.BatchStatement containing LWT. In the latter case either all the batch
succeeds or fails.
Only valid when one of the of the internal row factories is in use.
Raised when ResponseFuture.start_fetching_next_page() is called and
there are no more pages. You can check ResponseFuture.has_more_pages
before calling to avoid this.
Added in version 2.0.0.
Raised when an operation is attempted but all connections are busy, defunct, closed, or resulted in errors when used.
An attempt was made to use a user-defined type that does not exist.
Added in version 2.1.0.
Was this page helpful?
ScyllaDB Python Driver is available under the Apache v2 License. ScyllaDB Python Driver is a fork of DataStax Python Driver. See Copyright here.
cassandra - Exceptions and Enumscassandra.cluster - Clusters and Sessionscassandra.policies - Load balancing and Failure Handling Policiescassandra.auth - Authenticationcassandra.graph - Graph Statements, Options, and Row Factoriescassandra.metadata - Schema and Ring Topologycassandra.metrics - Performance Metricscassandra.query - Prepared Statements, Batch Statements, Tracing, and Row Factoriescassandra.pool - Hosts and Connection Poolscassandra.protocol - Protocol Featurescassandra.encoder - Encoders for non-prepared Statementscassandra.decoder - Data Return Formatscassandra.concurrent - Utilities for Concurrent Statement Executioncassandra.connection - Low Level Connection Infocassandra.util - Utilitiescassandra.timestamps - Timestamp Generationcassandra.io.asyncioreactor - asyncio Event Loopcassandra.io.asyncorereactor - asyncore Event Loopcassandra.io.eventletreactor - eventlet-compatible Connectioncassandra.io.libevreactor - libev Event Loopcassandra.io.geventreactor - gevent-compatible Event Loopcassandra.io.twistedreactor - Twisted Event Loopcassandra.cqlengine.models - Table models for object mappingcassandra.cqlengine.columns - Column types for object mapping modelscassandra.cqlengine.query - Query and filter model objectscassandra.cqlengine.connection - Connection management for cqlenginecassandra.cqlengine.management - Schema management for cqlenginecassandra.cqlengine.usertype - Model classes for User Defined Typescassandra.datastax.graph - Graph Statements, Options, and Row Factoriescassandra.datastax.graph.fluentcassandra.datastax.graph.fluent.querycassandra.datastax.graph.fluent.predicatesOn this page
cassandra.cluster - Clusters and SessionsClusterCluster.contact_pointsCluster.portCluster.cql_versionCluster.protocol_versionCluster.compressionCluster.auth_providerCluster.load_balancing_policyCluster.reconnection_policyCluster.default_retry_policyCluster.conviction_policy_factoryCluster.address_translatorCluster.metrics_enabledCluster.metricsCluster.ssl_contextCluster.ssl_optionsCluster.sockoptsCluster.max_schema_agreement_waitCluster.metadataCluster.connection_classCluster.control_connection_timeoutCluster.idle_heartbeat_intervalCluster.idle_heartbeat_timeoutCluster.schema_event_refresh_windowCluster.topology_event_refresh_windowCluster.status_event_refresh_windowCluster.prepare_on_all_hostsCluster.reprepare_on_upCluster.connect_timeoutCluster.schema_metadata_enabledCluster.token_metadata_enabledCluster.timestamp_generatorCluster.endpoint_factoryCluster.cloudCluster.connect()Cluster.shutdown()Cluster.register_user_type()Cluster.register_listener()Cluster.unregister_listener()Cluster.add_execution_profile()Cluster.set_max_requests_per_connection()Cluster.get_max_requests_per_connection()Cluster.set_min_requests_per_connection()Cluster.get_min_requests_per_connection()Cluster.get_core_connections_per_host()Cluster.set_core_connections_per_host()Cluster.get_max_connections_per_host()Cluster.set_max_connections_per_host()Cluster.get_control_connection_host()Cluster.refresh_schema_metadata()Cluster.refresh_keyspace_metadata()Cluster.refresh_table_metadata()Cluster.refresh_user_type_metadata()Cluster.refresh_user_function_metadata()Cluster.refresh_user_aggregate_metadata()Cluster.refresh_nodes()Cluster.set_meta_refresh_enabled()ExecutionProfile
GraphExecutionProfileGraphAnalyticsExecutionProfileEXEC_PROFILE_DEFAULTEXEC_PROFILE_GRAPH_DEFAULTEXEC_PROFILE_GRAPH_SYSTEM_DEFAULTEXEC_PROFILE_GRAPH_ANALYTICS_DEFAULTSessionSession.default_timeoutSession.default_consistency_levelSession.default_serial_consistency_levelSession.row_factorySession.default_fetch_sizeSession.use_client_timestampSession.timestamp_generatorSession.encoderSession.client_protocol_handlerSession.execute()Session.execute_async()Session.execute_graph()Session.execute_graph_async()Session.prepare()Session.shutdown()Session.set_keyspace()Session.get_execution_profile()Session.execution_profile_clone_update()Session.add_request_init_listener()Session.remove_request_init_listener()ResponseFutureResponseFuture.queryResponseFuture.result()ResponseFuture.get_query_trace()ResponseFuture.get_all_query_traces()ResponseFuture.custom_payloadResponseFuture.is_schema_agreedResponseFuture.has_more_pagesResponseFuture.warningsResponseFuture.start_fetching_next_page()ResponseFuture.add_callback()ResponseFuture.add_errback()ResponseFuture.add_callbacks()ResultSet
QueryExhaustedNoHostAvailableUserTypeDoesNotExist