Package com.datastax.driver.core

Class StatementWrapper

  • public abstract class StatementWrapper
extends Statement
    Base class for custom Statement implementations that wrap another statement.

    This is intended for use with a custom RetryPolicy, LoadBalancingPolicy or SpeculativeExecutionPolicy. The client code can wrap a statement to "mark" it, or add information that will lead to special handling in the policy.

    Example: 

    
 // Define your own subclass
 public class MyCustomStatement extends StatementWrapper {
     public MyCustomStatement(Statement wrapped) {
         super(wrapped);
     }
 }

 // In your load balancing policy, add a special case for that new type
 public class MyLoadBalancingPolicy implements LoadBalancingPolicy {
     public Iterator<Host> newQueryPlan(String loggedKeyspace, Statement statement) {
         if (statement instanceof MyCustomStatement) {
             // return specially crafted plan
         } else {
             // return default plan
         }
     }
 }

 // The client wraps whenever it wants to trigger the special plan
 Statement s = new SimpleStatement("...");
 session.execute(s);                         // will use default plan
 session.execute(new MyCustomStatement(s));  // will use special plan

    • Constructor Detail

      • StatementWrapper

        protected StatementWrapper​(Statement wrapped)
        Builds a new instance.
        Parameters:
        wrapped - the wrapped statement.

    • Method Detail

      • setConsistencyLevel

        public Statement setConsistencyLevel​(ConsistencyLevel consistency)
        Description copied from class: Statement
        Sets the consistency level for the query.
        Overrides:
        setConsistencyLevel in class Statement
        Parameters:
        consistency - the consistency level to set.
        Returns:
        this Statement object.

      • getConsistencyLevel

        public ConsistencyLevel getConsistencyLevel()
        Description copied from class: Statement
        The consistency level for this query.
        Overrides:
        getConsistencyLevel in class Statement
        Returns:
        the consistency level for this query, or null if no consistency level has been specified (through setConsistencyLevel). In the latter case, the default consistency level will be used.

      • setSerialConsistencyLevel

        public Statement setSerialConsistencyLevel​(ConsistencyLevel serialConsistency)
        Description copied from class: Statement
        Sets the serial consistency level for the query.

        The serial consistency level is only used by conditional updates (INSERT, UPDATE or DELETE statements with an IF condition). For those, the serial consistency level defines the consistency level of the serial phase (or "paxos" phase) while the normal consistency level defines the consistency for the "learn" phase, i.e. what type of reads will be guaranteed to see the update right away. For instance, if a conditional write has a regular consistency of QUORUM (and is successful), then a QUORUM read is guaranteed to see that write. But if the regular consistency of that write is ANY, then only a read with a consistency of SERIAL is guaranteed to see it (even a read with consistency ALL is not guaranteed to be enough).

        The serial consistency can only be one of ConsistencyLevel.SERIAL or ConsistencyLevel.LOCAL_SERIAL. While ConsistencyLevel.SERIAL guarantees full linearizability (with other SERIAL updates), ConsistencyLevel.LOCAL_SERIAL only guarantees it in the local data center.

        The serial consistency level is ignored for any query that is not a conditional update (serial reads should use the regular consistency level for instance).

        Overrides:
        setSerialConsistencyLevel in class Statement
        Parameters:
        serialConsistency - the serial consistency level to set.
        Returns:
        this Statement object.

      • enableTracing

        public Statement enableTracing()
        Description copied from class: Statement
        Enables tracing for this query.

        By default (that is unless you call this method), tracing is not enabled.

        Overrides:
        enableTracing in class Statement
        Returns:
        this Statement object.

      • disableTracing

        public Statement disableTracing()
        Description copied from class: Statement
        Disables tracing for this query.
        Overrides:
        disableTracing in class Statement
        Returns:
        this Statement object.

      • isTracing

        public boolean isTracing()
        Description copied from class: Statement
        Returns whether tracing is enabled for this query or not.
        Overrides:
        isTracing in class Statement
        Returns:
        true if this query has tracing enabled, false otherwise.

      • getRoutingKey

        public ByteBuffer getRoutingKey​(ProtocolVersion protocolVersion,
                                CodecRegistry codecRegistry)
        Description copied from class: Statement
        Returns the routing key (in binary raw form) to use for token aware routing of this query.

        The routing key is optional in that implementers are free to return null. The routing key is an hint used for token-aware routing (see TokenAwarePolicy), and if provided should correspond to the binary value for the query partition key. However, not providing a routing key never causes a query to fail and if the load balancing policy used is not token aware, then the routing key can be safely ignored.

        Specified by:
        getRoutingKey in class Statement
        Parameters:
        protocolVersion - the protocol version that will be used if the actual implementation needs to serialize something to compute the key.
        codecRegistry - the codec registry that will be used if the actual implementation needs to serialize something to compute this key.
        Returns:
        the routing key for this query or null.

      • getKeyspace

        public String getKeyspace()
        Description copied from class: Statement
        Returns the keyspace this query operates on.

        Note that not all query specify on which keyspace they operate on, and so this method can always return null. Firstly, some queries do not operate inside a keyspace: keyspace creation, USE queries, user creation, etc. Secondly, even query that operate within a keyspace do not have to specify said keyspace directly, in which case the currently logged in keyspace (the one set through a USE query (or through the use of Cluster.connect(String))). Lastly, as for the routing key, this keyspace information is only a hint for token-aware routing (since replica placement depend on the replication strategy in use which is a per-keyspace property) and having this method return null (or even a bogus keyspace name) will never cause the query to fail.

        Specified by:
        getKeyspace in class Statement
        Returns:
        the keyspace this query operate on if relevant or null.

      • setRetryPolicy

        public Statement setRetryPolicy​(RetryPolicy policy)
        Description copied from class: Statement
        Sets the retry policy to use for this query.

        The default retry policy, if this method is not called, is the one returned by Policies.getRetryPolicy() in the cluster configuration. This method is thus only useful in case you want to punctually override the default policy for this request.

        Overrides:
        setRetryPolicy in class Statement
        Parameters:
        policy - the retry policy to use for this query.
        Returns:
        this Statement object.

      • setFetchSize

        public Statement setFetchSize​(int fetchSize)
        Description copied from class: Statement
        Sets the query fetch size.

        The fetch size controls how much resulting rows will be retrieved simultaneously (the goal being to avoid loading too much results in memory for queries yielding large results). Please note that while value as low as 1 can be used, it is *highly* discouraged to use such a low value in practice as it will yield very poor performance. If in doubt, leaving the default is probably a good idea.

        Only SELECT queries only ever make use of this setting.

        Note that unlike other configuration, when this statement is prepared BoundStatements created off of PreparedStatement do not inherit this configuration.

        Note: Paging is not supported with the native protocol version 1. If you call this method with fetchSize &gt; 0 and fetchSize != Integer.MAX_VALUE and the protocol version is in use (i.e. if you've force version 1 through Cluster.Builder.withProtocolVersion(com.datastax.driver.core.ProtocolVersion) or you use Cassandra 1.2), you will get UnsupportedProtocolVersionException when submitting this statement for execution.

        Overrides:
        setFetchSize in class Statement
        Parameters:
        fetchSize - the fetch size to use. If fetchSize &lte; 0, the default fetch size will be used. To disable paging of the result set, use fetchSize == Integer.MAX_VALUE.
        Returns:
        this Statement object.

      • getFetchSize

        public int getFetchSize()
        Description copied from class: Statement
        The fetch size for this query.
        Overrides:
        getFetchSize in class Statement
        Returns:
        the fetch size for this query. If that value is less or equal to 0 (the default unless Statement.setFetchSize(int) is used), the default fetch size will be used.

      • setDefaultTimestamp

        public Statement setDefaultTimestamp​(long defaultTimestamp)
        Description copied from class: Statement
        Sets the default timestamp for this query (in microseconds since the epoch).

        This feature is only available when version V3 or higher of the native protocol is in use. With earlier versions, calling this method has no effect.

        The actual timestamp that will be used for this query is, in order of preference:

        • the timestamp specified directly in the CQL query string (using the USING TIMESTAMP syntax);
        • the timestamp specified through this method, if different from Long.MIN_VALUE;
        • the timestamp returned by the TimestampGenerator currently in use, if different from Long.MIN_VALUE.
        If none of these apply, no timestamp will be sent with the query and Cassandra will generate a server-side one (similar to the pre-V3 behavior).

        Note that unlike other configuration, when this statement is prepared BoundStatements created off of PreparedStatement do not inherit this configuration.

        Overrides:
        setDefaultTimestamp in class Statement
        Parameters:
        defaultTimestamp - the default timestamp for this query (must be strictly positive).
        Returns:
        this Statement object.
        See Also:
        Cluster.Builder.withTimestampGenerator(TimestampGenerator)

      • getDefaultTimestamp

        public long getDefaultTimestamp()
        Description copied from class: Statement
        The default timestamp for this query.
        Overrides:
        getDefaultTimestamp in class Statement
        Returns:
        the default timestamp (in microseconds since the epoch).

      • setReadTimeoutMillis

        public Statement setReadTimeoutMillis​(int readTimeoutMillis)
        Description copied from class: Statement
        Overrides the default per-host read timeout (SocketOptions.getReadTimeoutMillis()) for this statement.

        You should override this only for statements for which the coordinator may allow a longer server-side timeout (for example aggregation queries).

        Note that unlike other configuration, when this statement is prepared BoundStatements created off of PreparedStatement do not inherit this configuration.

        Overrides:
        setReadTimeoutMillis in class Statement
        Parameters:
        readTimeoutMillis - the timeout to set. Negative values are not allowed. If it is 0, the read timeout will be disabled for this statement.
        Returns:
        this Statement object.

      • setPagingState

        public Statement setPagingState​(PagingState pagingState,
                                CodecRegistry codecRegistry)
        Description copied from class: Statement
        Sets the paging state.

        This will cause the next execution of this statement to fetch results from a given page, rather than restarting from the beginning.

        You get the paging state from a previous execution of the statement (see ExecutionInfo.getPagingState(). This is typically used to iterate in a "stateless" manner (e.g. across HTTP requests): 

        
 Statement st = new SimpleStatement("your query");
 ResultSet rs = session.execute(st.setFetchSize(20));
 int available = rs.getAvailableWithoutFetching();
 for (int i = 0; i < available; i++) {
     Row row = rs.one();
     // Do something with row (e.g. display it to the user...)
 }
 // Get state and serialize as string or byte[] to store it for the next execution
 // (e.g. pass it as a parameter in the "next page" URI)
 PagingState pagingState = rs.getExecutionInfo().getPagingState();
 String savedState = pagingState.toString();

 // Next execution:
 // Get serialized state back (e.g. get URI parameter)
 String savedState = ...
 Statement st = new SimpleStatement("your query");
 st.setPagingState(PagingState.fromString(savedState));
 ResultSet rs = session.execute(st.setFetchSize(20));
 int available = rs.getAvailableWithoutFetching();
 for (int i = 0; i < available; i++) {
     ...
 }

        The paging state can only be reused between perfectly identical statements (same query string, same bound parameters). Altering the contents of the paging state or trying to set it on a different statement will cause this method to fail.

        Note that, due to internal implementation details, the paging state is not portable across native protocol versions (see the online documentation for more explanations about the native protocol). This means that PagingState instances generated with an old version won't work with a higher version. If that is a problem for you, consider using the "unsafe" API (see Statement.setPagingStateUnsafe(byte[])).

        Overrides:
        setPagingState in class Statement
        Parameters:
        pagingState - the paging state to set, or null to remove any state that was previously set on this statement.
        codecRegistry - the codec registry that will be used if this method needs to serialize the statement's values in order to check that the paging state matches.
        Returns:
        this Statement object.
        See Also:
        Statement.setPagingState(PagingState)

      • setPagingStateUnsafe

        public Statement setPagingStateUnsafe​(byte[] pagingState)
        Description copied from class: Statement
        Sets the paging state.

        Contrary to Statement.setPagingState(PagingState), this method takes the "raw" form of the paging state (previously extracted with ExecutionInfo.getPagingStateUnsafe(). It won't validate that this statement matches the one that the paging state was extracted from. If the paging state was altered in any way, you will get unpredictable behavior from Cassandra (ranging from wrong results to a query failure). If you decide to use this variant, it is strongly recommended to add your own validation (for example, signing the raw state with a private key).

        Overrides:
        setPagingStateUnsafe in class Statement
        Parameters:
        pagingState - the paging state to set, or null to remove any state that was previously set on this statement.
        Returns:
        this Statement object.

      • getPagingState

        public ByteBuffer getPagingState()

      • setIdempotent

        public Statement setIdempotent​(boolean idempotent)
        Description copied from class: Statement
        Sets whether this statement is idempotent.

        See Statement.isIdempotent() for more explanations about this property.

        Overrides:
        setIdempotent in class Statement
        Parameters:
        idempotent - the new value.
        Returns:
        this Statement object.

      • isIdempotent

        public Boolean isIdempotent()
        Description copied from class: Statement
        Whether this statement is idempotent, i.e. whether it can be applied multiple times without changing the result beyond the initial application.

        If a statement is not idempotent, the driver will ensure that it never gets executed more than once, which means:

        (this behavior is implemented in the driver internals, the corresponding policies will not even be invoked).

        Note that this method can return null, in which case the driver will default to QueryOptions.getDefaultIdempotence().

        By default, this method returns null for all statements, except for

        • BuiltStatement - value will be inferred from the query: if it updates counters, prepends/appends to a list, or uses a function call or QueryBuilder.raw(String) anywhere in an inserted value, the result will be false; otherwise it will be true.
        • Batch and BatchStatement:
          1. If any statement in batch has isIdempotent() false - return false
          2. If no statements with isIdempotent() false, but some have isIdempotent() null - return null
          3. Otherwise - return true
        In all cases, calling Statement.setIdempotent(boolean) forces a value that overrides calculated value.

        Note that when a statement is prepared (Session.prepare(String)), its idempotence flag will be propagated to all PreparedStatements created from it.

        Overrides:
        isIdempotent in class Statement
        Returns:
        whether this statement is idempotent, or null to use QueryOptions.getDefaultIdempotence().

      • isIdempotentWithDefault

        public boolean isIdempotentWithDefault​(QueryOptions queryOptions)

      • getOutgoingPayload

        public Map<String,​ByteBuffer> getOutgoingPayload()
        Description copied from class: Statement
        Returns this statement's outgoing payload. Each time this statement is executed, this payload will be included in the query request.

        This method returns null if no payload has been set, otherwise it always returns immutable maps.

        This feature is only available with ProtocolVersion.V4 or above. Trying to include custom payloads in requests sent by the driver under lower protocol versions will result in an UnsupportedFeatureException (wrapped in a NoHostAvailableException).

        Overrides:
        getOutgoingPayload in class Statement
        Returns:
        the outgoing payload to include with this statement, or null if no payload has been set.

      • setOutgoingPayload

        public Statement setOutgoingPayload​(Map<String,​ByteBuffer> payload)
        Description copied from class: Statement
        Set the given outgoing payload on this statement. Each time this statement is executed, this payload will be included in the query request.

        This method makes a defensive copy of the given map, but its values remain inherently mutable. Care should be taken not to modify the original map once it is passed to this method.

        This feature is only available with ProtocolVersion.V4 or above. Trying to include custom payloads in requests sent by the driver under lower protocol versions will result in an UnsupportedFeatureException (wrapped in a NoHostAvailableException).

        Overrides:
        setOutgoingPayload in class Statement
        Parameters:
        payload - the outgoing payload to include with this statement, or null to clear any previously entered payload.
        Returns:
        this Statement object.

      • requestSizeInBytes

        public int requestSizeInBytes​(ProtocolVersion protocolVersion,
                              CodecRegistry codecRegistry)
        Description copied from class: Statement
        Returns the number of bytes required to encode this statement.

        The calculated size may be overestimated by a few bytes, but is never underestimated. If the size cannot be calculated, this method returns -1.

        Note that the returned value is not cached, but instead recomputed at every method call.

        Overrides:
        requestSizeInBytes in class Statement
        Returns:
        the number of bytes required to encode this statement.

      • setHost

        public Statement setHost​(Host host)
        Description copied from class: Statement
        Sets the Host that should handle this query.

        In the general case, use of this method is heavily discouraged and should only be used in the following cases:

        1. Querying node-local tables, such as tables in the system and system_views keyspaces.
        2. Applying a series of schema changes, where it may be advantageous to execute schema changes in sequence on the same node.

        Configuring a specific host causes the configured LoadBalancingPolicy to be completely bypassed. However, if the load balancing policy dictates that the host is at distance HostDistance.IGNORED or there is no active connectivity to the host, the request will fail with a NoHostAvailableException.

        Note that unlike other configuration, when this statement is prepared BoundStatements created off of PreparedStatement do not inherit this configuration.

        Overrides:
        setHost in class Statement
        Parameters:
        host - The host that should be used to handle executions of this statement or null to delegate to the configured load balancing policy.
        Returns:
        this Statement object.

      • getNowInSeconds

        public int getNowInSeconds()
        Overrides:
        getNowInSeconds in class Statement
        Returns:
        a custom "now in seconds" to use when applying the request (for testing purposes). Integer.MIN_VALUE means "no value".