/* * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with * the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions * and limitations under the License. */ package com.amazonaws.services.timestreamquery.model; import java.io.Serializable; import javax.annotation.Generated; import com.amazonaws.AmazonWebServiceRequest; /** * * @see AWS API * Documentation */ @Generated("com.amazonaws:aws-java-sdk-code-generator") public class QueryRequest extends com.amazonaws.AmazonWebServiceRequest implements Serializable, Cloneable { /** *
* The query to be run by Timestream. *
*/ private String queryString; /** *
* Unique, case-sensitive string of up to 64 ASCII characters specified when a Query
request is made.
* Providing a ClientToken
makes the call to Query
idempotent. This means that
* running the same query repeatedly will produce the same result. In other words, making multiple identical
* Query
requests has the same effect as making a single request. When using ClientToken
* in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a subsequent
* invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
* A pagination token used to return a set of results. When the Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior call to
* Query
, and a result set is returned. However, if the Query
invocation only contains the
* ClientToken
, that invocation of Query
is assumed to be a new query run.
*
* Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1 hour –
* whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the result
* set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which point
* a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query initiator and
* the result reader do not have the same query string in the query requests, the query will fail with an
* Invalid pagination token
error.
*
* The total number of rows to be returned in the Query
output. The initial run of Query
* with a MaxRows
value specified will return the result set of the query in two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can then be
* used in subsequent calls to fetch the result set. To resume pagination, provide the NextToken
value
* in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the response
* size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send the necessary
* number of rows to meet the 1 MB limit.
*
* The query to be run by Timestream. *
* * @param queryString * The query to be run by Timestream. */ public void setQueryString(String queryString) { this.queryString = queryString; } /** ** The query to be run by Timestream. *
* * @return The query to be run by Timestream. */ public String getQueryString() { return this.queryString; } /** ** The query to be run by Timestream. *
* * @param queryString * The query to be run by Timestream. * @return Returns a reference to this object so that method calls can be chained together. */ public QueryRequest withQueryString(String queryString) { setQueryString(queryString); return this; } /** *
* Unique, case-sensitive string of up to 64 ASCII characters specified when a Query
request is made.
* Providing a ClientToken
makes the call to Query
idempotent. This means that
* running the same query repeatedly will produce the same result. In other words, making multiple identical
* Query
requests has the same effect as making a single request. When using ClientToken
* in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a subsequent
* invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
Query
request is
* made. Providing a ClientToken
makes the call to Query
idempotent. This
* means that running the same query repeatedly will produce the same result. In other words, making multiple
* identical Query
requests has the same effect as making a single request. When using
* ClientToken
in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a
* subsequent invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
* Unique, case-sensitive string of up to 64 ASCII characters specified when a Query
request is made.
* Providing a ClientToken
makes the call to Query
idempotent. This means that
* running the same query repeatedly will produce the same result. In other words, making multiple identical
* Query
requests has the same effect as making a single request. When using ClientToken
* in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a subsequent
* invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
Query
request is
* made. Providing a ClientToken
makes the call to Query
idempotent. This
* means that running the same query repeatedly will produce the same result. In other words, making
* multiple identical Query
requests has the same effect as making a single request. When using
* ClientToken
in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a
* subsequent invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
* Unique, case-sensitive string of up to 64 ASCII characters specified when a Query
request is made.
* Providing a ClientToken
makes the call to Query
idempotent. This means that
* running the same query repeatedly will produce the same result. In other words, making multiple identical
* Query
requests has the same effect as making a single request. When using ClientToken
* in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a subsequent
* invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
Query
request is
* made. Providing a ClientToken
makes the call to Query
idempotent. This
* means that running the same query repeatedly will produce the same result. In other words, making multiple
* identical Query
requests has the same effect as making a single request. When using
* ClientToken
in a query, note the following:
*
* If the Query API is instantiated without a ClientToken
, the Query SDK generates a
* ClientToken
on your behalf.
*
* If the Query
invocation only contains the ClientToken
but does not include a
* NextToken
, that invocation of Query
is assumed to be a new query run.
*
* If the invocation contains NextToken
, that particular invocation is assumed to be a
* subsequent invocation of a prior call to the Query API, and a result set is returned.
*
* After 4 hours, any request with the same ClientToken
is treated as a new request.
*
* A pagination token used to return a set of results. When the Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior call to
* Query
, and a result set is returned. However, if the Query
invocation only contains the
* ClientToken
, that invocation of Query
is assumed to be a new query run.
*
* Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1 hour –
* whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the result
* set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which point
* a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query initiator and
* the result reader do not have the same query string in the query requests, the query will fail with an
* Invalid pagination token
error.
*
Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior
* call to Query
, and a result set is returned. However, if the Query
invocation
* only contains the ClientToken
, that invocation of Query
is assumed to be a new
* query run.
* * Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1
* hour – whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the
* result set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query * API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which
* point a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query
* initiator and the result reader do not have the same query string in the query requests, the query will
* fail with an Invalid pagination token
error.
*
* A pagination token used to return a set of results. When the Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior call to
* Query
, and a result set is returned. However, if the Query
invocation only contains the
* ClientToken
, that invocation of Query
is assumed to be a new query run.
*
* Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1 hour –
* whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the result
* set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which point
* a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query initiator and
* the result reader do not have the same query string in the query requests, the query will fail with an
* Invalid pagination token
error.
*
Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior
* call to Query
, and a result set is returned. However, if the Query
invocation
* only contains the ClientToken
, that invocation of Query
is assumed to be a new
* query run.
* * Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to
* 1 hour – whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the
* result set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
* and TokenB
. If TokenB
is used in a subsequent Query
invocation,
* then TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query * API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at
* which point a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query
* initiator and the result reader do not have the same query string in the query requests, the query will
* fail with an Invalid pagination token
error.
*
* A pagination token used to return a set of results. When the Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior call to
* Query
, and a result set is returned. However, if the Query
invocation only contains the
* ClientToken
, that invocation of Query
is assumed to be a new query run.
*
* Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1 hour –
* whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the result
* set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which point
* a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query initiator and
* the result reader do not have the same query string in the query requests, the query will fail with an
* Invalid pagination token
error.
*
Query
API is invoked using
* NextToken
, that particular invocation is assumed to be a subsequent invocation of a prior
* call to Query
, and a result set is returned. However, if the Query
invocation
* only contains the ClientToken
, that invocation of Query
is assumed to be a new
* query run.
* * Note the following when using NextToken in a query: *
*
* A pagination token can be used for up to five Query
invocations, OR for a duration of up to 1
* hour – whichever comes first.
*
* Using the same NextToken
will return the same set of records. To keep paginating through the
* result set, you must to use the most recent nextToken
.
*
* Suppose a Query
invocation returns two NextToken
values, TokenA
and
* TokenB
. If TokenB
is used in a subsequent Query
invocation, then
* TokenA
is invalidated and cannot be reused.
*
* To request a previous result set from a query after pagination has begun, you must re-invoke the Query * API. *
*
* The latest NextToken
should be used to paginate until null
is returned, at which
* point a new NextToken
should be used.
*
* If the IAM principal of the query initiator and the result reader are not the same and/or the query
* initiator and the result reader do not have the same query string in the query requests, the query will
* fail with an Invalid pagination token
error.
*
* The total number of rows to be returned in the Query
output. The initial run of Query
* with a MaxRows
value specified will return the result set of the query in two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can then be
* used in subsequent calls to fetch the result set. To resume pagination, provide the NextToken
value
* in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the response
* size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send the necessary
* number of rows to meet the 1 MB limit.
*
Query
output. The initial run of
* Query
with a MaxRows
value specified will return the result set of the query in
* two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can
* then be used in subsequent calls to fetch the result set. To resume pagination, provide the
* NextToken
value in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the
* response size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send
* the necessary number of rows to meet the 1 MB limit.
*/
public void setMaxRows(Integer maxRows) {
this.maxRows = maxRows;
}
/**
*
* The total number of rows to be returned in the Query
output. The initial run of Query
* with a MaxRows
value specified will return the result set of the query in two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can then be
* used in subsequent calls to fetch the result set. To resume pagination, provide the NextToken
value
* in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the response
* size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send the necessary
* number of rows to meet the 1 MB limit.
*
Query
output. The initial run of
* Query
with a MaxRows
value specified will return the result set of the query in
* two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can
* then be used in subsequent calls to fetch the result set. To resume pagination, provide the
* NextToken
value in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the
* response size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will
* send the necessary number of rows to meet the 1 MB limit.
*/
public Integer getMaxRows() {
return this.maxRows;
}
/**
*
* The total number of rows to be returned in the Query
output. The initial run of Query
* with a MaxRows
value specified will return the result set of the query in two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can then be
* used in subsequent calls to fetch the result set. To resume pagination, provide the NextToken
value
* in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the response
* size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send the necessary
* number of rows to meet the 1 MB limit.
*
Query
output. The initial run of
* Query
with a MaxRows
value specified will return the result set of the query in
* two cases:
*
* The size of the result is less than 1MB
.
*
* The number of rows in the result set is less than the value of maxRows
.
*
* Otherwise, the initial invocation of Query
only returns a NextToken
, which can
* then be used in subsequent calls to fetch the result set. To resume pagination, provide the
* NextToken
value in the subsequent command.
*
* If the row size is large (e.g. a row has many columns), Timestream may return fewer rows to keep the
* response size from exceeding the 1 MB limit. If MaxRows
is not provided, Timestream will send
* the necessary number of rows to meet the 1 MB limit.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public QueryRequest withMaxRows(Integer maxRows) {
setMaxRows(maxRows);
return this;
}
/**
* Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
* redacted from this string using a placeholder value.
*
* @return A string representation of this object.
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (getQueryString() != null)
sb.append("QueryString: ").append("***Sensitive Data Redacted***").append(",");
if (getClientToken() != null)
sb.append("ClientToken: ").append("***Sensitive Data Redacted***").append(",");
if (getNextToken() != null)
sb.append("NextToken: ").append(getNextToken()).append(",");
if (getMaxRows() != null)
sb.append("MaxRows: ").append(getMaxRows());
sb.append("}");
return sb.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (obj instanceof QueryRequest == false)
return false;
QueryRequest other = (QueryRequest) obj;
if (other.getQueryString() == null ^ this.getQueryString() == null)
return false;
if (other.getQueryString() != null && other.getQueryString().equals(this.getQueryString()) == false)
return false;
if (other.getClientToken() == null ^ this.getClientToken() == null)
return false;
if (other.getClientToken() != null && other.getClientToken().equals(this.getClientToken()) == false)
return false;
if (other.getNextToken() == null ^ this.getNextToken() == null)
return false;
if (other.getNextToken() != null && other.getNextToken().equals(this.getNextToken()) == false)
return false;
if (other.getMaxRows() == null ^ this.getMaxRows() == null)
return false;
if (other.getMaxRows() != null && other.getMaxRows().equals(this.getMaxRows()) == false)
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int hashCode = 1;
hashCode = prime * hashCode + ((getQueryString() == null) ? 0 : getQueryString().hashCode());
hashCode = prime * hashCode + ((getClientToken() == null) ? 0 : getClientToken().hashCode());
hashCode = prime * hashCode + ((getNextToken() == null) ? 0 : getNextToken().hashCode());
hashCode = prime * hashCode + ((getMaxRows() == null) ? 0 : getMaxRows().hashCode());
return hashCode;
}
@Override
public QueryRequest clone() {
return (QueryRequest) super.clone();
}
}