1 1 | // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
|
2 + | /* CodegenDelegator.kt:255 */
|
2 3 | pub use crate::operation::query::_query_output::QueryOutputBuilder;
|
3 4 |
|
5 + | /* CodegenDelegator.kt:255 */
|
4 6 | pub use crate::operation::query::_query_input::QueryInputBuilder;
|
5 7 |
|
8 + | /* FluentBuilderGenerator.kt:408 */
|
6 9 | impl crate::operation::query::builders::QueryInputBuilder {
|
7 10 | /// Sends a request with this input using the given client.
|
8 11 | pub async fn send_with(
|
9 12 | self,
|
10 13 | client: &crate::Client,
|
11 14 | ) -> ::std::result::Result<
|
12 15 | crate::operation::query::QueryOutput,
|
13 16 | ::aws_smithy_runtime_api::client::result::SdkError<
|
14 17 | crate::operation::query::QueryError,
|
15 18 | ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
|
16 19 | >,
|
17 20 | > {
|
18 21 | let mut fluent_builder = client.query();
|
19 22 | fluent_builder.inner = self;
|
20 23 | fluent_builder.send().await
|
21 24 | }
|
22 25 | }
|
23 - | /// Fluent builder constructing a request to `Query`.
|
26 + | /// /* FluentBuilderGenerator.kt:129 */Fluent builder constructing a request to `Query`.
|
24 27 | ///
|
25 - | /// <p>The <code>Query</code> operation finds items based on primary key values. You can query any table or secondary index that has a composite primary key (a partition key and a sort key).</p>
|
28 + | /// /* FluentBuilderGenerator.kt:130 */<p>The <code>Query</code> operation finds items based on primary key values. You can query any table or secondary index that has a composite primary key (a partition key and a sort key).</p>
|
26 29 | /// <p>Use the <code>KeyConditionExpression</code> parameter to provide a specific value for the partition key. The <code>Query</code> operation will return all of the items from the table or index with that partition key value. You can optionally narrow the scope of the <code>Query</code> operation by specifying a sort key value and a comparison operator in <code>KeyConditionExpression</code>. To further refine the <code>Query</code> results, you can optionally provide a <code>FilterExpression</code>. A <code>FilterExpression</code> determines which items within the results should be returned to you. All of the other results are discarded.</p>
|
27 30 | /// <p>A <code>Query</code> operation always returns a result set. If no matching items are found, the result set will be empty. Queries that do not return results consume the minimum number of read capacity units for that type of read operation.</p><note>
|
28 31 | /// <p>DynamoDB calculates the number of read capacity units consumed based on item size, not on the amount of data that is returned to an application. The number of capacity units consumed will be the same whether you request all of the attributes (the default behavior) or just some of them (using a projection expression). The number will also be the same whether or not you use a <code>FilterExpression</code>.</p>
|
29 32 | /// </note>
|
30 33 | /// <p><code>Query</code> results are always sorted by the sort key value. If the data type of the sort key is Number, the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes. By default, the sort order is ascending. To reverse the order, set the <code>ScanIndexForward</code> parameter to false.</p>
|
31 34 | /// <p>A single <code>Query</code> operation will read up to the maximum number of items set (if using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then apply any filtering to the results using <code>FilterExpression</code>. If <code>LastEvaluatedKey</code> is present in the response, you will need to paginate the result set. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
32 35 | /// <p><code>FilterExpression</code> is applied after a <code>Query</code> finishes, but before the results are returned. A <code>FilterExpression</code> cannot contain partition key or sort key attributes. You need to specify those attributes in the <code>KeyConditionExpression</code>.</p><note>
|
33 36 | /// <p>A <code>Query</code> operation can return an empty result set and a <code>LastEvaluatedKey</code> if all the items read for the page of results are filtered out.</p>
|
34 37 | /// </note>
|
35 38 | /// <p>You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local secondary index, you can set the <code>ConsistentRead</code> parameter to <code>true</code> and obtain a strongly consistent result. Global secondary indexes support eventually consistent reads only, so do not specify <code>ConsistentRead</code> when querying a global secondary index.</p>
|
39 + | /* RustType.kt:516 */
|
36 40 | #[derive(::std::clone::Clone, ::std::fmt::Debug)]
|
41 + | /* FluentBuilderGenerator.kt:270 */
|
37 42 | pub struct QueryFluentBuilder {
|
38 43 | handle: ::std::sync::Arc<crate::client::Handle>,
|
39 44 | inner: crate::operation::query::builders::QueryInputBuilder,
|
40 45 | config_override: ::std::option::Option<crate::config::Builder>,
|
41 46 | }
|
47 + | /* FluentBuilderGenerator.kt:381 */
|
42 48 | impl crate::client::customize::internal::CustomizableSend<crate::operation::query::QueryOutput, crate::operation::query::QueryError>
|
43 49 | for QueryFluentBuilder
|
44 50 | {
|
45 51 | fn send(
|
46 52 | self,
|
47 53 | config_override: crate::config::Builder,
|
48 54 | ) -> crate::client::customize::internal::BoxFuture<
|
49 55 | crate::client::customize::internal::SendResult<crate::operation::query::QueryOutput, crate::operation::query::QueryError>,
|
50 56 | > {
|
51 57 | ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
|
52 58 | }
|
53 59 | }
|
60 + | /* FluentBuilderGenerator.kt:282 */
|
54 61 | impl QueryFluentBuilder {
|
62 + | /* FluentBuilderGenerator.kt:288 */
|
55 63 | /// Creates a new `QueryFluentBuilder`.
|
56 64 | pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
|
57 65 | Self {
|
58 66 | handle,
|
59 67 | inner: ::std::default::Default::default(),
|
60 68 | config_override: ::std::option::Option::None,
|
61 69 | }
|
62 70 | }
|
71 + | /* FluentBuilderGenerator.kt:301 */
|
63 72 | /// Access the Query as a reference.
|
64 73 | pub fn as_input(&self) -> &crate::operation::query::builders::QueryInputBuilder {
|
65 74 | &self.inner
|
66 75 | }
|
76 + | /* FluentBuilderGenerator.kt:145 */
|
67 77 | /// Sends the request and returns the response.
|
68 78 | ///
|
69 79 | /// If an error occurs, an `SdkError` will be returned with additional details that
|
70 80 | /// can be matched against.
|
71 81 | ///
|
72 82 | /// By default, any retryable failures will be retried twice. Retry behavior
|
73 83 | /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
|
74 84 | /// set when configuring the client.
|
75 85 | pub async fn send(
|
76 86 | self,
|
77 87 | ) -> ::std::result::Result<
|
78 88 | crate::operation::query::QueryOutput,
|
79 89 | ::aws_smithy_runtime_api::client::result::SdkError<
|
80 90 | crate::operation::query::QueryError,
|
81 91 | ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
|
82 92 | >,
|
83 93 | > {
|
84 94 | let input = self
|
85 95 | .inner
|
86 96 | .build()
|
87 97 | .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
|
88 98 | let runtime_plugins =
|
89 99 | crate::operation::query::Query::operation_runtime_plugins(self.handle.runtime_plugins.clone(), &self.handle.conf, self.config_override);
|
90 100 | crate::operation::query::Query::orchestrate(&runtime_plugins, input).await
|
91 101 | }
|
92 102 |
|
93 103 | /// Consumes this builder, creating a customizable operation that can be modified before being sent.
|
94 104 | pub fn customize(
|
95 105 | self,
|
96 106 | ) -> crate::client::customize::CustomizableOperation<crate::operation::query::QueryOutput, crate::operation::query::QueryError, Self> {
|
97 107 | crate::client::customize::CustomizableOperation::new(self)
|
98 108 | }
|
109 + | /* FluentBuilderGenerator.kt:315 */
|
99 110 | pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
|
100 111 | self.set_config_override(::std::option::Option::Some(config_override.into()));
|
101 112 | self
|
102 113 | }
|
103 114 |
|
104 115 | pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
|
105 116 | self.config_override = config_override;
|
106 117 | self
|
107 118 | }
|
119 + | /* FluentBuilderGenerator.kt:340 */
|
108 120 | /// Create a paginator for this request
|
109 121 | ///
|
110 122 | /// Paginators are used by calling [`send().await`](crate::operation::query::paginator::QueryPaginator::send) which returns a [`PaginationStream`](aws_smithy_async::future::pagination_stream::PaginationStream).
|
111 123 | pub fn into_paginator(self) -> crate::operation::query::paginator::QueryPaginator {
|
112 124 | crate::operation::query::paginator::QueryPaginator::new(self.handle, self.inner)
|
113 125 | }
|
114 - | /// <p>The name of the table containing the requested items.</p>
|
126 + | /// /* FluentBuilderGenerator.kt:498 */<p>The name of the table containing the requested items.</p>
|
127 + | /* FluentBuilderGenerator.kt:500 */
|
115 128 | pub fn table_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
116 129 | self.inner = self.inner.table_name(input.into());
|
117 130 | self
|
118 131 | }
|
119 - | /// <p>The name of the table containing the requested items.</p>
|
132 + | /// /* FluentBuilderGenerator.kt:498 */<p>The name of the table containing the requested items.</p>
|
133 + | /* FluentBuilderGenerator.kt:500 */
|
120 134 | pub fn set_table_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
|
121 135 | self.inner = self.inner.set_table_name(input);
|
122 136 | self
|
123 137 | }
|
124 - | /// <p>The name of the table containing the requested items.</p>
|
138 + | /// /* FluentBuilderGenerator.kt:518 */<p>The name of the table containing the requested items.</p>
|
139 + | /* FluentBuilderGenerator.kt:520 */
|
125 140 | pub fn get_table_name(&self) -> &::std::option::Option<::std::string::String> {
|
126 141 | self.inner.get_table_name()
|
127 142 | }
|
128 - | /// <p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
143 + | /// /* FluentBuilderGenerator.kt:498 */<p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
144 + | /* FluentBuilderGenerator.kt:500 */
|
129 145 | pub fn index_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
130 146 | self.inner = self.inner.index_name(input.into());
|
131 147 | self
|
132 148 | }
|
133 - | /// <p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
149 + | /// /* FluentBuilderGenerator.kt:498 */<p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
150 + | /* FluentBuilderGenerator.kt:500 */
|
134 151 | pub fn set_index_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
|
135 152 | self.inner = self.inner.set_index_name(input);
|
136 153 | self
|
137 154 | }
|
138 - | /// <p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
155 + | /// /* FluentBuilderGenerator.kt:518 */<p>The name of an index to query. This index can be any local secondary index or global secondary index on the table. Note that if you use the <code>IndexName</code> parameter, you must also provide <code>TableName.</code></p>
|
156 + | /* FluentBuilderGenerator.kt:520 */
|
139 157 | pub fn get_index_name(&self) -> &::std::option::Option<::std::string::String> {
|
140 158 | self.inner.get_index_name()
|
141 159 | }
|
142 - | /// <p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
160 + | /// /* FluentBuilderGenerator.kt:498 */<p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
143 161 | /// <ul>
|
144 162 | /// <li>
|
145 163 | /// <p><code>ALL_ATTRIBUTES</code> - Returns all of the item attributes from the specified table or index. If you query a local secondary index, then for each matching item in the index, DynamoDB fetches the entire item from the parent table. If the index is configured to project all item attributes, then all of the data can be obtained from the local secondary index, and no fetching is required.</p></li>
|
146 164 | /// <li>
|
147 165 | /// <p><code>ALL_PROJECTED_ATTRIBUTES</code> - Allowed only when querying an index. Retrieves all attributes that have been projected into the index. If the index is configured to project all attributes, this return value is equivalent to specifying <code>ALL_ATTRIBUTES</code>.</p></li>
|
148 166 | /// <li>
|
149 167 | /// <p><code>COUNT</code> - Returns the number of matching items, rather than the matching items themselves.</p></li>
|
150 168 | /// <li>
|
151 169 | /// <p><code>SPECIFIC_ATTRIBUTES</code> - Returns only the attributes listed in <code>AttributesToGet</code>. This return value is equivalent to specifying <code>AttributesToGet</code> without specifying any value for <code>Select</code>.</p>
|
152 170 | /// <p>If you query or scan a local secondary index and request only attributes that are projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the local secondary index, DynamoDB fetches each of these attributes from the parent table. This extra fetching incurs additional throughput cost and latency.</p>
|
153 171 | /// <p>If you query or scan a global secondary index, you can only request attributes that are projected into the index. Global secondary index queries cannot fetch attributes from the parent table.</p></li>
|
154 172 | /// </ul>
|
155 173 | /// <p>If neither <code>Select</code> nor <code>AttributesToGet</code> are specified, DynamoDB defaults to <code>ALL_ATTRIBUTES</code> when accessing a table, and <code>ALL_PROJECTED_ATTRIBUTES</code> when accessing an index. You cannot use both <code>Select</code> and <code>AttributesToGet</code> together in a single request, unless the value for <code>Select</code> is <code>SPECIFIC_ATTRIBUTES</code>. (This usage is equivalent to specifying <code>AttributesToGet</code> without any value for <code>Select</code>.)</p><note>
|
156 174 | /// <p>If you use the <code>ProjectionExpression</code> parameter, then the value for <code>Select</code> can only be <code>SPECIFIC_ATTRIBUTES</code>. Any other value for <code>Select</code> will return an error.</p>
|
157 175 | /// </note>
|
176 + | /* FluentBuilderGenerator.kt:500 */
|
158 177 | pub fn select(mut self, input: crate::types::Select) -> Self {
|
159 178 | self.inner = self.inner.select(input);
|
160 179 | self
|
161 180 | }
|
162 - | /// <p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
181 + | /// /* FluentBuilderGenerator.kt:498 */<p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
163 182 | /// <ul>
|
164 183 | /// <li>
|
165 184 | /// <p><code>ALL_ATTRIBUTES</code> - Returns all of the item attributes from the specified table or index. If you query a local secondary index, then for each matching item in the index, DynamoDB fetches the entire item from the parent table. If the index is configured to project all item attributes, then all of the data can be obtained from the local secondary index, and no fetching is required.</p></li>
|
166 185 | /// <li>
|
167 186 | /// <p><code>ALL_PROJECTED_ATTRIBUTES</code> - Allowed only when querying an index. Retrieves all attributes that have been projected into the index. If the index is configured to project all attributes, this return value is equivalent to specifying <code>ALL_ATTRIBUTES</code>.</p></li>
|
168 187 | /// <li>
|
169 188 | /// <p><code>COUNT</code> - Returns the number of matching items, rather than the matching items themselves.</p></li>
|
170 189 | /// <li>
|
171 190 | /// <p><code>SPECIFIC_ATTRIBUTES</code> - Returns only the attributes listed in <code>AttributesToGet</code>. This return value is equivalent to specifying <code>AttributesToGet</code> without specifying any value for <code>Select</code>.</p>
|
172 191 | /// <p>If you query or scan a local secondary index and request only attributes that are projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the local secondary index, DynamoDB fetches each of these attributes from the parent table. This extra fetching incurs additional throughput cost and latency.</p>
|
173 192 | /// <p>If you query or scan a global secondary index, you can only request attributes that are projected into the index. Global secondary index queries cannot fetch attributes from the parent table.</p></li>
|
174 193 | /// </ul>
|
175 194 | /// <p>If neither <code>Select</code> nor <code>AttributesToGet</code> are specified, DynamoDB defaults to <code>ALL_ATTRIBUTES</code> when accessing a table, and <code>ALL_PROJECTED_ATTRIBUTES</code> when accessing an index. You cannot use both <code>Select</code> and <code>AttributesToGet</code> together in a single request, unless the value for <code>Select</code> is <code>SPECIFIC_ATTRIBUTES</code>. (This usage is equivalent to specifying <code>AttributesToGet</code> without any value for <code>Select</code>.)</p><note>
|
176 195 | /// <p>If you use the <code>ProjectionExpression</code> parameter, then the value for <code>Select</code> can only be <code>SPECIFIC_ATTRIBUTES</code>. Any other value for <code>Select</code> will return an error.</p>
|
177 196 | /// </note>
|
197 + | /* FluentBuilderGenerator.kt:500 */
|
178 198 | pub fn set_select(mut self, input: ::std::option::Option<crate::types::Select>) -> Self {
|
179 199 | self.inner = self.inner.set_select(input);
|
180 200 | self
|
181 201 | }
|
182 - | /// <p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
202 + | /// /* FluentBuilderGenerator.kt:518 */<p>The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.</p>
|
183 203 | /// <ul>
|
184 204 | /// <li>
|
185 205 | /// <p><code>ALL_ATTRIBUTES</code> - Returns all of the item attributes from the specified table or index. If you query a local secondary index, then for each matching item in the index, DynamoDB fetches the entire item from the parent table. If the index is configured to project all item attributes, then all of the data can be obtained from the local secondary index, and no fetching is required.</p></li>
|
186 206 | /// <li>
|
187 207 | /// <p><code>ALL_PROJECTED_ATTRIBUTES</code> - Allowed only when querying an index. Retrieves all attributes that have been projected into the index. If the index is configured to project all attributes, this return value is equivalent to specifying <code>ALL_ATTRIBUTES</code>.</p></li>
|
188 208 | /// <li>
|
189 209 | /// <p><code>COUNT</code> - Returns the number of matching items, rather than the matching items themselves.</p></li>
|
190 210 | /// <li>
|
191 211 | /// <p><code>SPECIFIC_ATTRIBUTES</code> - Returns only the attributes listed in <code>AttributesToGet</code>. This return value is equivalent to specifying <code>AttributesToGet</code> without specifying any value for <code>Select</code>.</p>
|
192 212 | /// <p>If you query or scan a local secondary index and request only attributes that are projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the local secondary index, DynamoDB fetches each of these attributes from the parent table. This extra fetching incurs additional throughput cost and latency.</p>
|
193 213 | /// <p>If you query or scan a global secondary index, you can only request attributes that are projected into the index. Global secondary index queries cannot fetch attributes from the parent table.</p></li>
|
194 214 | /// </ul>
|
195 215 | /// <p>If neither <code>Select</code> nor <code>AttributesToGet</code> are specified, DynamoDB defaults to <code>ALL_ATTRIBUTES</code> when accessing a table, and <code>ALL_PROJECTED_ATTRIBUTES</code> when accessing an index. You cannot use both <code>Select</code> and <code>AttributesToGet</code> together in a single request, unless the value for <code>Select</code> is <code>SPECIFIC_ATTRIBUTES</code>. (This usage is equivalent to specifying <code>AttributesToGet</code> without any value for <code>Select</code>.)</p><note>
|
196 216 | /// <p>If you use the <code>ProjectionExpression</code> parameter, then the value for <code>Select</code> can only be <code>SPECIFIC_ATTRIBUTES</code>. Any other value for <code>Select</code> will return an error.</p>
|
197 217 | /// </note>
|
218 + | /* FluentBuilderGenerator.kt:520 */
|
198 219 | pub fn get_select(&self) -> &::std::option::Option<crate::types::Select> {
|
199 220 | self.inner.get_select()
|
200 221 | }
|
201 - | ///
|
222 + | /// /* FluentBuilderGenerator.kt:436 */
|
202 223 | /// Appends an item to `AttributesToGet`.
|
203 224 | ///
|
204 225 | /// To override the contents of this collection use [`set_attributes_to_get`](Self::set_attributes_to_get).
|
205 226 | ///
|
206 - | /// <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
227 + | /// /* FluentBuilderGenerator.kt:443 */<p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
228 + | /* FluentBuilderGenerator.kt:446 */
|
207 229 | pub fn attributes_to_get(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
208 230 | self.inner = self.inner.attributes_to_get(input.into());
|
209 231 | self
|
210 232 | }
|
211 - | /// <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
233 + | /// /* FluentBuilderGenerator.kt:498 */<p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
234 + | /* FluentBuilderGenerator.kt:500 */
|
212 235 | pub fn set_attributes_to_get(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
|
213 236 | self.inner = self.inner.set_attributes_to_get(input);
|
214 237 | self
|
215 238 | }
|
216 - | /// <p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
239 + | /// /* FluentBuilderGenerator.kt:518 */<p>This is a legacy parameter. Use <code>ProjectionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html">AttributesToGet</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
240 + | /* FluentBuilderGenerator.kt:520 */
|
217 241 | pub fn get_attributes_to_get(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
|
218 242 | self.inner.get_attributes_to_get()
|
219 243 | }
|
220 - | /// <p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
244 + | /// /* FluentBuilderGenerator.kt:498 */<p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
245 + | /* FluentBuilderGenerator.kt:500 */
|
221 246 | pub fn limit(mut self, input: i32) -> Self {
|
222 247 | self.inner = self.inner.limit(input);
|
223 248 | self
|
224 249 | }
|
225 - | /// <p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
250 + | /// /* FluentBuilderGenerator.kt:498 */<p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
251 + | /* FluentBuilderGenerator.kt:500 */
|
226 252 | pub fn set_limit(mut self, input: ::std::option::Option<i32>) -> Self {
|
227 253 | self.inner = self.inner.set_limit(input);
|
228 254 | self
|
229 255 | }
|
230 - | /// <p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
256 + | /// /* FluentBuilderGenerator.kt:518 */<p>The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html">Query and Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
257 + | /* FluentBuilderGenerator.kt:520 */
|
231 258 | pub fn get_limit(&self) -> &::std::option::Option<i32> {
|
232 259 | self.inner.get_limit()
|
233 260 | }
|
234 - | /// <p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
261 + | /// /* FluentBuilderGenerator.kt:498 */<p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
235 262 | /// <p>Strongly consistent reads are not supported on global secondary indexes. If you query a global secondary index with <code>ConsistentRead</code> set to <code>true</code>, you will receive a <code>ValidationException</code>.</p>
|
263 + | /* FluentBuilderGenerator.kt:500 */
|
236 264 | pub fn consistent_read(mut self, input: bool) -> Self {
|
237 265 | self.inner = self.inner.consistent_read(input);
|
238 266 | self
|
239 267 | }
|
240 - | /// <p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
268 + | /// /* FluentBuilderGenerator.kt:498 */<p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
241 269 | /// <p>Strongly consistent reads are not supported on global secondary indexes. If you query a global secondary index with <code>ConsistentRead</code> set to <code>true</code>, you will receive a <code>ValidationException</code>.</p>
|
270 + | /* FluentBuilderGenerator.kt:500 */
|
242 271 | pub fn set_consistent_read(mut self, input: ::std::option::Option<bool>) -> Self {
|
243 272 | self.inner = self.inner.set_consistent_read(input);
|
244 273 | self
|
245 274 | }
|
246 - | /// <p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
275 + | /// /* FluentBuilderGenerator.kt:518 */<p>Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</p>
|
247 276 | /// <p>Strongly consistent reads are not supported on global secondary indexes. If you query a global secondary index with <code>ConsistentRead</code> set to <code>true</code>, you will receive a <code>ValidationException</code>.</p>
|
277 + | /* FluentBuilderGenerator.kt:520 */
|
248 278 | pub fn get_consistent_read(&self) -> &::std::option::Option<bool> {
|
249 279 | self.inner.get_consistent_read()
|
250 280 | }
|
251 - | ///
|
281 + | /// /* FluentBuilderGenerator.kt:466 */
|
252 282 | /// Adds a key-value pair to `KeyConditions`.
|
253 283 | ///
|
254 284 | /// To override the contents of this collection use [`set_key_conditions`](Self::set_key_conditions).
|
255 285 | ///
|
256 - | /// <p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
286 + | /// /* FluentBuilderGenerator.kt:473 */<p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
287 + | /* FluentBuilderGenerator.kt:475 */
|
257 288 | pub fn key_conditions(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::Condition) -> Self {
|
258 289 | self.inner = self.inner.key_conditions(k.into(), v);
|
259 290 | self
|
260 291 | }
|
261 - | /// <p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
292 + | /// /* FluentBuilderGenerator.kt:498 */<p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
293 + | /* FluentBuilderGenerator.kt:500 */
|
262 294 | pub fn set_key_conditions(
|
263 295 | mut self,
|
264 296 | input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>>,
|
265 297 | ) -> Self {
|
266 298 | self.inner = self.inner.set_key_conditions(input);
|
267 299 | self
|
268 300 | }
|
269 - | /// <p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
301 + | /// /* FluentBuilderGenerator.kt:518 */<p>This is a legacy parameter. Use <code>KeyConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html">KeyConditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
302 + | /* FluentBuilderGenerator.kt:520 */
|
270 303 | pub fn get_key_conditions(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>> {
|
271 304 | self.inner.get_key_conditions()
|
272 305 | }
|
273 - | ///
|
306 + | /// /* FluentBuilderGenerator.kt:466 */
|
274 307 | /// Adds a key-value pair to `QueryFilter`.
|
275 308 | ///
|
276 309 | /// To override the contents of this collection use [`set_query_filter`](Self::set_query_filter).
|
277 310 | ///
|
278 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
311 + | /// /* FluentBuilderGenerator.kt:473 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
312 + | /* FluentBuilderGenerator.kt:475 */
|
279 313 | pub fn query_filter(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::Condition) -> Self {
|
280 314 | self.inner = self.inner.query_filter(k.into(), v);
|
281 315 | self
|
282 316 | }
|
283 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
317 + | /// /* FluentBuilderGenerator.kt:498 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
318 + | /* FluentBuilderGenerator.kt:500 */
|
284 319 | pub fn set_query_filter(
|
285 320 | mut self,
|
286 321 | input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>>,
|
287 322 | ) -> Self {
|
288 323 | self.inner = self.inner.set_query_filter(input);
|
289 324 | self
|
290 325 | }
|
291 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
326 + | /// /* FluentBuilderGenerator.kt:518 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html">QueryFilter</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
327 + | /* FluentBuilderGenerator.kt:520 */
|
292 328 | pub fn get_query_filter(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>> {
|
293 329 | self.inner.get_query_filter()
|
294 330 | }
|
295 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
331 + | /// /* FluentBuilderGenerator.kt:498 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
332 + | /* FluentBuilderGenerator.kt:500 */
|
296 333 | pub fn conditional_operator(mut self, input: crate::types::ConditionalOperator) -> Self {
|
297 334 | self.inner = self.inner.conditional_operator(input);
|
298 335 | self
|
299 336 | }
|
300 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
337 + | /// /* FluentBuilderGenerator.kt:498 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
338 + | /* FluentBuilderGenerator.kt:500 */
|
301 339 | pub fn set_conditional_operator(mut self, input: ::std::option::Option<crate::types::ConditionalOperator>) -> Self {
|
302 340 | self.inner = self.inner.set_conditional_operator(input);
|
303 341 | self
|
304 342 | }
|
305 - | /// <p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
343 + | /// /* FluentBuilderGenerator.kt:518 */<p>This is a legacy parameter. Use <code>FilterExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
344 + | /* FluentBuilderGenerator.kt:520 */
|
306 345 | pub fn get_conditional_operator(&self) -> &::std::option::Option<crate::types::ConditionalOperator> {
|
307 346 | self.inner.get_conditional_operator()
|
308 347 | }
|
309 - | /// <p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
348 + | /// /* FluentBuilderGenerator.kt:498 */<p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
310 349 | /// <p>Items with the same partition key value are stored in sorted order by sort key. If the sort key data type is Number, the results are stored in numeric order. For type String, the results are stored in order of UTF-8 bytes. For type Binary, DynamoDB treats each byte of the binary data as unsigned.</p>
|
311 350 | /// <p>If <code>ScanIndexForward</code> is <code>true</code>, DynamoDB returns the results in the order in which they are stored (by sort key value). This is the default behavior. If <code>ScanIndexForward</code> is <code>false</code>, DynamoDB reads the results in reverse order by sort key value, and then returns the results to the client.</p>
|
351 + | /* FluentBuilderGenerator.kt:500 */
|
312 352 | pub fn scan_index_forward(mut self, input: bool) -> Self {
|
313 353 | self.inner = self.inner.scan_index_forward(input);
|
314 354 | self
|
315 355 | }
|
316 - | /// <p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
356 + | /// /* FluentBuilderGenerator.kt:498 */<p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
317 357 | /// <p>Items with the same partition key value are stored in sorted order by sort key. If the sort key data type is Number, the results are stored in numeric order. For type String, the results are stored in order of UTF-8 bytes. For type Binary, DynamoDB treats each byte of the binary data as unsigned.</p>
|
318 358 | /// <p>If <code>ScanIndexForward</code> is <code>true</code>, DynamoDB returns the results in the order in which they are stored (by sort key value). This is the default behavior. If <code>ScanIndexForward</code> is <code>false</code>, DynamoDB reads the results in reverse order by sort key value, and then returns the results to the client.</p>
|
359 + | /* FluentBuilderGenerator.kt:500 */
|
319 360 | pub fn set_scan_index_forward(mut self, input: ::std::option::Option<bool>) -> Self {
|
320 361 | self.inner = self.inner.set_scan_index_forward(input);
|
321 362 | self
|
322 363 | }
|
323 - | /// <p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
364 + | /// /* FluentBuilderGenerator.kt:518 */<p>Specifies the order for index traversal: If <code>true</code> (default), the traversal is performed in ascending order; if <code>false</code>, the traversal is performed in descending order.</p>
|
324 365 | /// <p>Items with the same partition key value are stored in sorted order by sort key. If the sort key data type is Number, the results are stored in numeric order. For type String, the results are stored in order of UTF-8 bytes. For type Binary, DynamoDB treats each byte of the binary data as unsigned.</p>
|
325 366 | /// <p>If <code>ScanIndexForward</code> is <code>true</code>, DynamoDB returns the results in the order in which they are stored (by sort key value). This is the default behavior. If <code>ScanIndexForward</code> is <code>false</code>, DynamoDB reads the results in reverse order by sort key value, and then returns the results to the client.</p>
|
367 + | /* FluentBuilderGenerator.kt:520 */
|
326 368 | pub fn get_scan_index_forward(&self) -> &::std::option::Option<bool> {
|
327 369 | self.inner.get_scan_index_forward()
|
328 370 | }
|
329 - | ///
|
371 + | /// /* FluentBuilderGenerator.kt:466 */
|
330 372 | /// Adds a key-value pair to `ExclusiveStartKey`.
|
331 373 | ///
|
332 374 | /// To override the contents of this collection use [`set_exclusive_start_key`](Self::set_exclusive_start_key).
|
333 375 | ///
|
334 - | /// <p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
376 + | /// /* FluentBuilderGenerator.kt:473 */<p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
335 377 | /// <p>The data type for <code>ExclusiveStartKey</code> must be String, Number, or Binary. No set data types are allowed.</p>
|
378 + | /* FluentBuilderGenerator.kt:475 */
|
336 379 | pub fn exclusive_start_key(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::AttributeValue) -> Self {
|
337 380 | self.inner = self.inner.exclusive_start_key(k.into(), v);
|
338 381 | self
|
339 382 | }
|
340 - | /// <p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
383 + | /// /* FluentBuilderGenerator.kt:498 */<p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
341 384 | /// <p>The data type for <code>ExclusiveStartKey</code> must be String, Number, or Binary. No set data types are allowed.</p>
|
385 + | /* FluentBuilderGenerator.kt:500 */
|
342 386 | pub fn set_exclusive_start_key(
|
343 387 | mut self,
|
344 388 | input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
|
345 389 | ) -> Self {
|
346 390 | self.inner = self.inner.set_exclusive_start_key(input);
|
347 391 | self
|
348 392 | }
|
349 - | /// <p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
393 + | /// /* FluentBuilderGenerator.kt:518 */<p>The primary key of the first item that this operation will evaluate. Use the value that was returned for <code>LastEvaluatedKey</code> in the previous operation.</p>
|
350 394 | /// <p>The data type for <code>ExclusiveStartKey</code> must be String, Number, or Binary. No set data types are allowed.</p>
|
395 + | /* FluentBuilderGenerator.kt:520 */
|
351 396 | pub fn get_exclusive_start_key(
|
352 397 | &self,
|
353 398 | ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
|
354 399 | self.inner.get_exclusive_start_key()
|
355 400 | }
|
356 - | /// <p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
401 + | /// /* FluentBuilderGenerator.kt:498 */<p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
357 402 | /// <ul>
|
358 403 | /// <li>
|
359 404 | /// <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
|
360 405 | /// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>
|
361 406 | /// <li>
|
362 407 | /// <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>
|
363 408 | /// <li>
|
364 409 | /// <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li>
|
365 410 | /// </ul>
|
411 + | /* FluentBuilderGenerator.kt:500 */
|
366 412 | pub fn return_consumed_capacity(mut self, input: crate::types::ReturnConsumedCapacity) -> Self {
|
367 413 | self.inner = self.inner.return_consumed_capacity(input);
|
368 414 | self
|
369 415 | }
|
370 - | /// <p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
416 + | /// /* FluentBuilderGenerator.kt:498 */<p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
371 417 | /// <ul>
|
372 418 | /// <li>
|
373 419 | /// <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
|
374 420 | /// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>
|
375 421 | /// <li>
|
376 422 | /// <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>
|
377 423 | /// <li>
|
378 424 | /// <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li>
|
379 425 | /// </ul>
|
426 + | /* FluentBuilderGenerator.kt:500 */
|
380 427 | pub fn set_return_consumed_capacity(mut self, input: ::std::option::Option<crate::types::ReturnConsumedCapacity>) -> Self {
|
381 428 | self.inner = self.inner.set_return_consumed_capacity(input);
|
382 429 | self
|
383 430 | }
|
384 - | /// <p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
431 + | /// /* FluentBuilderGenerator.kt:518 */<p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
|
385 432 | /// <ul>
|
386 433 | /// <li>
|
387 434 | /// <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
|
388 435 | /// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>
|
389 436 | /// <li>
|
390 437 | /// <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>
|
391 438 | /// <li>
|
392 439 | /// <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li>
|
393 440 | /// </ul>
|
441 + | /* FluentBuilderGenerator.kt:520 */
|
394 442 | pub fn get_return_consumed_capacity(&self) -> &::std::option::Option<crate::types::ReturnConsumedCapacity> {
|
395 443 | self.inner.get_return_consumed_capacity()
|
396 444 | }
|
397 - | /// <p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
445 + | /// /* FluentBuilderGenerator.kt:498 */<p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
398 446 | /// <p>If no attribute names are specified, then all attributes will be returned. If any of the requested attributes are not found, they will not appear in the result.</p>
|
399 447 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
448 + | /* FluentBuilderGenerator.kt:500 */
|
400 449 | pub fn projection_expression(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
401 450 | self.inner = self.inner.projection_expression(input.into());
|
402 451 | self
|
403 452 | }
|
404 - | /// <p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
453 + | /// /* FluentBuilderGenerator.kt:498 */<p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
405 454 | /// <p>If no attribute names are specified, then all attributes will be returned. If any of the requested attributes are not found, they will not appear in the result.</p>
|
406 455 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
456 + | /* FluentBuilderGenerator.kt:500 */
|
407 457 | pub fn set_projection_expression(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
|
408 458 | self.inner = self.inner.set_projection_expression(input);
|
409 459 | self
|
410 460 | }
|
411 - | /// <p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
461 + | /// /* FluentBuilderGenerator.kt:518 */<p>A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas.</p>
|
412 462 | /// <p>If no attribute names are specified, then all attributes will be returned. If any of the requested attributes are not found, they will not appear in the result.</p>
|
413 463 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
464 + | /* FluentBuilderGenerator.kt:520 */
|
414 465 | pub fn get_projection_expression(&self) -> &::std::option::Option<::std::string::String> {
|
415 466 | self.inner.get_projection_expression()
|
416 467 | }
|
417 - | /// <p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
468 + | /// /* FluentBuilderGenerator.kt:498 */<p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
418 469 | /// <p>A <code>FilterExpression</code> does not allow key attributes. You cannot define a filter expression based on a partition key or a sort key.</p><note>
|
419 470 | /// <p>A <code>FilterExpression</code> is applied after the items have already been read; the process of filtering does not consume any additional read capacity units.</p>
|
420 471 | /// </note>
|
421 472 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults">Filter Expressions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
473 + | /* FluentBuilderGenerator.kt:500 */
|
422 474 | pub fn filter_expression(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
423 475 | self.inner = self.inner.filter_expression(input.into());
|
424 476 | self
|
425 477 | }
|
426 - | /// <p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
478 + | /// /* FluentBuilderGenerator.kt:498 */<p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
427 479 | /// <p>A <code>FilterExpression</code> does not allow key attributes. You cannot define a filter expression based on a partition key or a sort key.</p><note>
|
428 480 | /// <p>A <code>FilterExpression</code> is applied after the items have already been read; the process of filtering does not consume any additional read capacity units.</p>
|
429 481 | /// </note>
|
430 482 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults">Filter Expressions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
483 + | /* FluentBuilderGenerator.kt:500 */
|
431 484 | pub fn set_filter_expression(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
|
432 485 | self.inner = self.inner.set_filter_expression(input);
|
433 486 | self
|
434 487 | }
|
435 - | /// <p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
488 + | /// /* FluentBuilderGenerator.kt:518 */<p>A string that contains conditions that DynamoDB applies after the <code>Query</code> operation, but before the data is returned to you. Items that do not satisfy the <code>FilterExpression</code> criteria are not returned.</p>
|
436 489 | /// <p>A <code>FilterExpression</code> does not allow key attributes. You cannot define a filter expression based on a partition key or a sort key.</p><note>
|
437 490 | /// <p>A <code>FilterExpression</code> is applied after the items have already been read; the process of filtering does not consume any additional read capacity units.</p>
|
438 491 | /// </note>
|
439 492 | /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults">Filter Expressions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
493 + | /* FluentBuilderGenerator.kt:520 */
|
440 494 | pub fn get_filter_expression(&self) -> &::std::option::Option<::std::string::String> {
|
441 495 | self.inner.get_filter_expression()
|
442 496 | }
|
443 - | /// <p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
497 + | /// /* FluentBuilderGenerator.kt:498 */<p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
444 498 | /// <p>The condition must perform an equality test on a single partition key value.</p>
|
445 499 | /// <p>The condition can optionally perform one of several comparison tests on a single sort key value. This allows <code>Query</code> to retrieve one item with a given partition key value and sort key value, or several items that have the same partition key value but different sort key values.</p>
|
446 500 | /// <p>The partition key equality test is required, and must be specified in the following format:</p>
|
447 501 | /// <p><code>partitionKeyName</code> <i>=</i> <code>:partitionkeyval</code></p>
|
448 502 | /// <p>If you also want to provide a condition for the sort key, it must be combined using <code>AND</code> with the condition for the sort key. Following is an example, using the <b>=</b> comparison operator for the sort key:</p>
|
449 503 | /// <p><code>partitionKeyName</code> <code>=</code> <code>:partitionkeyval</code> <code>AND</code> <code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code></p>
|
450 504 | /// <p>Valid comparisons for the sort key condition are as follows:</p>
|
451 505 | /// <ul>
|
452 506 | /// <li>
|
453 507 | /// <p><code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code> - true if the sort key value is equal to <code>:sortkeyval</code>.</p></li>
|
454 508 | /// <li>
|
455 509 | /// <p><code>sortKeyName</code> <code><</code> <code>:sortkeyval</code> - true if the sort key value is less than <code>:sortkeyval</code>.</p></li>
|
456 510 | /// <li>
|
457 511 | /// <p><code>sortKeyName</code> <code><=</code> <code>:sortkeyval</code> - true if the sort key value is less than or equal to <code>:sortkeyval</code>.</p></li>
|
458 512 | /// <li>
|
459 513 | /// <p><code>sortKeyName</code> <code>></code> <code>:sortkeyval</code> - true if the sort key value is greater than <code>:sortkeyval</code>.</p></li>
|
460 514 | /// <li>
|
461 515 | /// <p><code>sortKeyName</code> <code>>= </code> <code>:sortkeyval</code> - true if the sort key value is greater than or equal to <code>:sortkeyval</code>.</p></li>
|
462 516 | /// <li>
|
463 517 | /// <p><code>sortKeyName</code> <code>BETWEEN</code> <code>:sortkeyval1</code> <code>AND</code> <code>:sortkeyval2</code> - true if the sort key value is greater than or equal to <code>:sortkeyval1</code>, and less than or equal to <code>:sortkeyval2</code>.</p></li>
|
464 518 | /// <li>
|
465 519 | /// <p><code>begins_with (</code> <code>sortKeyName</code>, <code>:sortkeyval</code> <code>)</code> - true if the sort key value begins with a particular operand. (You cannot use this function with a sort key that is of type Number.) Note that the function name <code>begins_with</code> is case-sensitive.</p></li>
|
466 520 | /// </ul>
|
467 521 | /// <p>Use the <code>ExpressionAttributeValues</code> parameter to replace tokens such as <code>:partitionval</code> and <code>:sortval</code> with actual values at runtime.</p>
|
468 522 | /// <p>You can optionally use the <code>ExpressionAttributeNames</code> parameter to replace the names of the partition key and sort key with placeholder tokens. This option might be necessary if an attribute name conflicts with a DynamoDB reserved word. For example, the following <code>KeyConditionExpression</code> parameter causes an error because <i>Size</i> is a reserved word:</p>
|
469 523 | /// <ul>
|
470 524 | /// <li>
|
471 525 | /// <p><code>Size = :myval</code></p></li>
|
472 526 | /// </ul>
|
473 527 | /// <p>To work around this, define a placeholder (such a <code>#S</code>) to represent the attribute name <i>Size</i>. <code>KeyConditionExpression</code> then is as follows:</p>
|
474 528 | /// <ul>
|
475 529 | /// <li>
|
476 530 | /// <p><code>#S = :myval</code></p></li>
|
477 531 | /// </ul>
|
478 532 | /// <p>For a list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
479 533 | /// <p>For more information on <code>ExpressionAttributeNames</code> and <code>ExpressionAttributeValues</code>, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html">Using Placeholders for Attribute Names and Values</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
534 + | /* FluentBuilderGenerator.kt:500 */
|
480 535 | pub fn key_condition_expression(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
|
481 536 | self.inner = self.inner.key_condition_expression(input.into());
|
482 537 | self
|
483 538 | }
|
484 - | /// <p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
539 + | /// /* FluentBuilderGenerator.kt:498 */<p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
485 540 | /// <p>The condition must perform an equality test on a single partition key value.</p>
|
486 541 | /// <p>The condition can optionally perform one of several comparison tests on a single sort key value. This allows <code>Query</code> to retrieve one item with a given partition key value and sort key value, or several items that have the same partition key value but different sort key values.</p>
|
487 542 | /// <p>The partition key equality test is required, and must be specified in the following format:</p>
|
488 543 | /// <p><code>partitionKeyName</code> <i>=</i> <code>:partitionkeyval</code></p>
|
489 544 | /// <p>If you also want to provide a condition for the sort key, it must be combined using <code>AND</code> with the condition for the sort key. Following is an example, using the <b>=</b> comparison operator for the sort key:</p>
|
490 545 | /// <p><code>partitionKeyName</code> <code>=</code> <code>:partitionkeyval</code> <code>AND</code> <code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code></p>
|
491 546 | /// <p>Valid comparisons for the sort key condition are as follows:</p>
|
492 547 | /// <ul>
|
493 548 | /// <li>
|
494 549 | /// <p><code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code> - true if the sort key value is equal to <code>:sortkeyval</code>.</p></li>
|
495 550 | /// <li>
|
496 551 | /// <p><code>sortKeyName</code> <code><</code> <code>:sortkeyval</code> - true if the sort key value is less than <code>:sortkeyval</code>.</p></li>
|
497 552 | /// <li>
|
498 553 | /// <p><code>sortKeyName</code> <code><=</code> <code>:sortkeyval</code> - true if the sort key value is less than or equal to <code>:sortkeyval</code>.</p></li>
|
499 554 | /// <li>
|
500 555 | /// <p><code>sortKeyName</code> <code>></code> <code>:sortkeyval</code> - true if the sort key value is greater than <code>:sortkeyval</code>.</p></li>
|
501 556 | /// <li>
|
502 557 | /// <p><code>sortKeyName</code> <code>>= </code> <code>:sortkeyval</code> - true if the sort key value is greater than or equal to <code>:sortkeyval</code>.</p></li>
|
503 558 | /// <li>
|
504 559 | /// <p><code>sortKeyName</code> <code>BETWEEN</code> <code>:sortkeyval1</code> <code>AND</code> <code>:sortkeyval2</code> - true if the sort key value is greater than or equal to <code>:sortkeyval1</code>, and less than or equal to <code>:sortkeyval2</code>.</p></li>
|
505 560 | /// <li>
|
506 561 | /// <p><code>begins_with (</code> <code>sortKeyName</code>, <code>:sortkeyval</code> <code>)</code> - true if the sort key value begins with a particular operand. (You cannot use this function with a sort key that is of type Number.) Note that the function name <code>begins_with</code> is case-sensitive.</p></li>
|
507 562 | /// </ul>
|
508 563 | /// <p>Use the <code>ExpressionAttributeValues</code> parameter to replace tokens such as <code>:partitionval</code> and <code>:sortval</code> with actual values at runtime.</p>
|
509 564 | /// <p>You can optionally use the <code>ExpressionAttributeNames</code> parameter to replace the names of the partition key and sort key with placeholder tokens. This option might be necessary if an attribute name conflicts with a DynamoDB reserved word. For example, the following <code>KeyConditionExpression</code> parameter causes an error because <i>Size</i> is a reserved word:</p>
|
510 565 | /// <ul>
|
511 566 | /// <li>
|
512 567 | /// <p><code>Size = :myval</code></p></li>
|
513 568 | /// </ul>
|
514 569 | /// <p>To work around this, define a placeholder (such a <code>#S</code>) to represent the attribute name <i>Size</i>. <code>KeyConditionExpression</code> then is as follows:</p>
|
515 570 | /// <ul>
|
516 571 | /// <li>
|
517 572 | /// <p><code>#S = :myval</code></p></li>
|
518 573 | /// </ul>
|
519 574 | /// <p>For a list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
520 575 | /// <p>For more information on <code>ExpressionAttributeNames</code> and <code>ExpressionAttributeValues</code>, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html">Using Placeholders for Attribute Names and Values</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
576 + | /* FluentBuilderGenerator.kt:500 */
|
521 577 | pub fn set_key_condition_expression(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
|
522 578 | self.inner = self.inner.set_key_condition_expression(input);
|
523 579 | self
|
524 580 | }
|
525 - | /// <p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
581 + | /// /* FluentBuilderGenerator.kt:518 */<p>The condition that specifies the key values for items to be retrieved by the <code>Query</code> action.</p>
|
526 582 | /// <p>The condition must perform an equality test on a single partition key value.</p>
|
527 583 | /// <p>The condition can optionally perform one of several comparison tests on a single sort key value. This allows <code>Query</code> to retrieve one item with a given partition key value and sort key value, or several items that have the same partition key value but different sort key values.</p>
|
528 584 | /// <p>The partition key equality test is required, and must be specified in the following format:</p>
|
529 585 | /// <p><code>partitionKeyName</code> <i>=</i> <code>:partitionkeyval</code></p>
|
530 586 | /// <p>If you also want to provide a condition for the sort key, it must be combined using <code>AND</code> with the condition for the sort key. Following is an example, using the <b>=</b> comparison operator for the sort key:</p>
|
531 587 | /// <p><code>partitionKeyName</code> <code>=</code> <code>:partitionkeyval</code> <code>AND</code> <code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code></p>
|
532 588 | /// <p>Valid comparisons for the sort key condition are as follows:</p>
|
533 589 | /// <ul>
|
534 590 | /// <li>
|
535 591 | /// <p><code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code> - true if the sort key value is equal to <code>:sortkeyval</code>.</p></li>
|
536 592 | /// <li>
|
537 593 | /// <p><code>sortKeyName</code> <code><</code> <code>:sortkeyval</code> - true if the sort key value is less than <code>:sortkeyval</code>.</p></li>
|
538 594 | /// <li>
|
539 595 | /// <p><code>sortKeyName</code> <code><=</code> <code>:sortkeyval</code> - true if the sort key value is less than or equal to <code>:sortkeyval</code>.</p></li>
|
540 596 | /// <li>
|
541 597 | /// <p><code>sortKeyName</code> <code>></code> <code>:sortkeyval</code> - true if the sort key value is greater than <code>:sortkeyval</code>.</p></li>
|
542 598 | /// <li>
|
543 599 | /// <p><code>sortKeyName</code> <code>>= </code> <code>:sortkeyval</code> - true if the sort key value is greater than or equal to <code>:sortkeyval</code>.</p></li>
|
544 600 | /// <li>
|
545 601 | /// <p><code>sortKeyName</code> <code>BETWEEN</code> <code>:sortkeyval1</code> <code>AND</code> <code>:sortkeyval2</code> - true if the sort key value is greater than or equal to <code>:sortkeyval1</code>, and less than or equal to <code>:sortkeyval2</code>.</p></li>
|
546 602 | /// <li>
|
547 603 | /// <p><code>begins_with (</code> <code>sortKeyName</code>, <code>:sortkeyval</code> <code>)</code> - true if the sort key value begins with a particular operand. (You cannot use this function with a sort key that is of type Number.) Note that the function name <code>begins_with</code> is case-sensitive.</p></li>
|
548 604 | /// </ul>
|
549 605 | /// <p>Use the <code>ExpressionAttributeValues</code> parameter to replace tokens such as <code>:partitionval</code> and <code>:sortval</code> with actual values at runtime.</p>
|
550 606 | /// <p>You can optionally use the <code>ExpressionAttributeNames</code> parameter to replace the names of the partition key and sort key with placeholder tokens. This option might be necessary if an attribute name conflicts with a DynamoDB reserved word. For example, the following <code>KeyConditionExpression</code> parameter causes an error because <i>Size</i> is a reserved word:</p>
|
551 607 | /// <ul>
|
552 608 | /// <li>
|
553 609 | /// <p><code>Size = :myval</code></p></li>
|
554 610 | /// </ul>
|
555 611 | /// <p>To work around this, define a placeholder (such a <code>#S</code>) to represent the attribute name <i>Size</i>. <code>KeyConditionExpression</code> then is as follows:</p>
|
556 612 | /// <ul>
|
557 613 | /// <li>
|
558 614 | /// <p><code>#S = :myval</code></p></li>
|
559 615 | /// </ul>
|
560 616 | /// <p>For a list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
561 617 | /// <p>For more information on <code>ExpressionAttributeNames</code> and <code>ExpressionAttributeValues</code>, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html">Using Placeholders for Attribute Names and Values</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
618 + | /* FluentBuilderGenerator.kt:520 */
|
562 619 | pub fn get_key_condition_expression(&self) -> &::std::option::Option<::std::string::String> {
|
563 620 | self.inner.get_key_condition_expression()
|
564 621 | }
|
565 - | ///
|
622 + | /// /* FluentBuilderGenerator.kt:466 */
|
566 623 | /// Adds a key-value pair to `ExpressionAttributeNames`.
|
567 624 | ///
|
568 625 | /// To override the contents of this collection use [`set_expression_attribute_names`](Self::set_expression_attribute_names).
|
569 626 | ///
|
570 - | /// <p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
627 + | /// /* FluentBuilderGenerator.kt:473 */<p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
571 628 | /// <ul>
|
572 629 | /// <li>
|
573 630 | /// <p>To access an attribute whose name conflicts with a DynamoDB reserved word.</p></li>
|
574 631 | /// <li>
|
575 632 | /// <p>To create a placeholder for repeating occurrences of an attribute name in an expression.</p></li>
|
576 633 | /// <li>
|
577 634 | /// <p>To prevent special characters in an attribute name from being misinterpreted in an expression.</p></li>
|
578 635 | /// </ul>
|
579 636 | /// <p>Use the <b>#</b> character in an expression to dereference an attribute name. For example, consider the following attribute name:</p>
|
580 637 | /// <ul>
|
581 638 | /// <li>
|
582 639 | /// <p><code>Percentile</code></p></li>
|
583 640 | /// </ul>
|
584 641 | /// <p>The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this, you could specify the following for <code>ExpressionAttributeNames</code>:</p>
|
585 642 | /// <ul>
|
586 643 | /// <li>
|
587 644 | /// <p><code>{"#P":"Percentile"}</code></p></li>
|
588 645 | /// </ul>
|
589 646 | /// <p>You could then use this substitution in an expression, as in this example:</p>
|
590 647 | /// <ul>
|
591 648 | /// <li>
|
592 649 | /// <p><code>#P = :val</code></p></li>
|
593 650 | /// </ul><note>
|
594 651 | /// <p>Tokens that begin with the <b>:</b> character are <i>expression attribute values</i>, which are placeholders for the actual value at runtime.</p>
|
595 652 | /// </note>
|
596 653 | /// <p>For more information on expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
654 + | /* FluentBuilderGenerator.kt:475 */
|
597 655 | pub fn expression_attribute_names(
|
598 656 | mut self,
|
599 657 | k: impl ::std::convert::Into<::std::string::String>,
|
600 658 | v: impl ::std::convert::Into<::std::string::String>,
|
601 659 | ) -> Self {
|
602 660 | self.inner = self.inner.expression_attribute_names(k.into(), v.into());
|
603 661 | self
|
604 662 | }
|
605 - | /// <p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
663 + | /// /* FluentBuilderGenerator.kt:498 */<p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
606 664 | /// <ul>
|
607 665 | /// <li>
|
608 666 | /// <p>To access an attribute whose name conflicts with a DynamoDB reserved word.</p></li>
|
609 667 | /// <li>
|
610 668 | /// <p>To create a placeholder for repeating occurrences of an attribute name in an expression.</p></li>
|
611 669 | /// <li>
|
612 670 | /// <p>To prevent special characters in an attribute name from being misinterpreted in an expression.</p></li>
|
613 671 | /// </ul>
|
614 672 | /// <p>Use the <b>#</b> character in an expression to dereference an attribute name. For example, consider the following attribute name:</p>
|
615 673 | /// <ul>
|
616 674 | /// <li>
|
617 675 | /// <p><code>Percentile</code></p></li>
|
618 676 | /// </ul>
|
619 677 | /// <p>The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this, you could specify the following for <code>ExpressionAttributeNames</code>:</p>
|
620 678 | /// <ul>
|
621 679 | /// <li>
|
622 680 | /// <p><code>{"#P":"Percentile"}</code></p></li>
|
623 681 | /// </ul>
|
624 682 | /// <p>You could then use this substitution in an expression, as in this example:</p>
|
625 683 | /// <ul>
|
626 684 | /// <li>
|
627 685 | /// <p><code>#P = :val</code></p></li>
|
628 686 | /// </ul><note>
|
629 687 | /// <p>Tokens that begin with the <b>:</b> character are <i>expression attribute values</i>, which are placeholders for the actual value at runtime.</p>
|
630 688 | /// </note>
|
631 689 | /// <p>For more information on expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
690 + | /* FluentBuilderGenerator.kt:500 */
|
632 691 | pub fn set_expression_attribute_names(
|
633 692 | mut self,
|
634 693 | input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
|
635 694 | ) -> Self {
|
636 695 | self.inner = self.inner.set_expression_attribute_names(input);
|
637 696 | self
|
638 697 | }
|
639 - | /// <p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
698 + | /// /* FluentBuilderGenerator.kt:518 */<p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
|
640 699 | /// <ul>
|
641 700 | /// <li>
|
642 701 | /// <p>To access an attribute whose name conflicts with a DynamoDB reserved word.</p></li>
|
643 702 | /// <li>
|
644 703 | /// <p>To create a placeholder for repeating occurrences of an attribute name in an expression.</p></li>
|
645 704 | /// <li>
|
646 705 | /// <p>To prevent special characters in an attribute name from being misinterpreted in an expression.</p></li>
|
647 706 | /// </ul>
|
648 707 | /// <p>Use the <b>#</b> character in an expression to dereference an attribute name. For example, consider the following attribute name:</p>
|
649 708 | /// <ul>
|
650 709 | /// <li>
|
651 710 | /// <p><code>Percentile</code></p></li>
|
652 711 | /// </ul>
|
653 712 | /// <p>The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this, you could specify the following for <code>ExpressionAttributeNames</code>:</p>
|
654 713 | /// <ul>
|
655 714 | /// <li>
|
656 715 | /// <p><code>{"#P":"Percentile"}</code></p></li>
|
657 716 | /// </ul>
|
658 717 | /// <p>You could then use this substitution in an expression, as in this example:</p>
|
659 718 | /// <ul>
|
660 719 | /// <li>
|
661 720 | /// <p><code>#P = :val</code></p></li>
|
662 721 | /// </ul><note>
|
663 722 | /// <p>Tokens that begin with the <b>:</b> character are <i>expression attribute values</i>, which are placeholders for the actual value at runtime.</p>
|
664 723 | /// </note>
|
665 724 | /// <p>For more information on expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
725 + | /* FluentBuilderGenerator.kt:520 */
|
666 726 | pub fn get_expression_attribute_names(
|
667 727 | &self,
|
668 728 | ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
|
669 729 | self.inner.get_expression_attribute_names()
|
670 730 | }
|
671 - | ///
|
731 + | /// /* FluentBuilderGenerator.kt:466 */
|
672 732 | /// Adds a key-value pair to `ExpressionAttributeValues`.
|
673 733 | ///
|
674 734 | /// To override the contents of this collection use [`set_expression_attribute_values`](Self::set_expression_attribute_values).
|
675 735 | ///
|
676 - | /// <p>One or more values that can be substituted in an expression.</p>
|
736 + | /// /* FluentBuilderGenerator.kt:473 */<p>One or more values that can be substituted in an expression.</p>
|
677 737 | /// <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <i>ProductStatus</i> attribute was one of the following:</p>
|
678 738 | /// <p><code>Available | Backordered | Discontinued</code></p>
|
679 739 | /// <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p>
|
680 740 | /// <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p>
|
681 741 | /// <p>You could then use these values in an expression, such as this:</p>
|
682 742 | /// <p><code>ProductStatus IN (:avail, :back, :disc)</code></p>
|
683 743 | /// <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Specifying Conditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
744 + | /* FluentBuilderGenerator.kt:475 */
|
684 745 | pub fn expression_attribute_values(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::AttributeValue) -> Self {
|
685 746 | self.inner = self.inner.expression_attribute_values(k.into(), v);
|
686 747 | self
|
687 748 | }
|
688 - | /// <p>One or more values that can be substituted in an expression.</p>
|
749 + | /// /* FluentBuilderGenerator.kt:498 */<p>One or more values that can be substituted in an expression.</p>
|
689 750 | /// <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <i>ProductStatus</i> attribute was one of the following:</p>
|
690 751 | /// <p><code>Available | Backordered | Discontinued</code></p>
|
691 752 | /// <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p>
|
692 753 | /// <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p>
|
693 754 | /// <p>You could then use these values in an expression, such as this:</p>
|
694 755 | /// <p><code>ProductStatus IN (:avail, :back, :disc)</code></p>
|
695 756 | /// <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Specifying Conditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
757 + | /* FluentBuilderGenerator.kt:500 */
|
696 758 | pub fn set_expression_attribute_values(
|
697 759 | mut self,
|
698 760 | input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
|
699 761 | ) -> Self {
|
700 762 | self.inner = self.inner.set_expression_attribute_values(input);
|
701 763 | self
|
702 764 | }
|
703 - | /// <p>One or more values that can be substituted in an expression.</p>
|
765 + | /// /* FluentBuilderGenerator.kt:518 */<p>One or more values that can be substituted in an expression.</p>
|
704 766 | /// <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <i>ProductStatus</i> attribute was one of the following:</p>
|
705 767 | /// <p><code>Available | Backordered | Discontinued</code></p>
|
706 768 | /// <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p>
|
707 769 | /// <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p>
|
708 770 | /// <p>You could then use these values in an expression, such as this:</p>
|
709 771 | /// <p><code>ProductStatus IN (:avail, :back, :disc)</code></p>
|
710 772 | /// <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Specifying Conditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
|
773 + | /* FluentBuilderGenerator.kt:520 */
|
711 774 | pub fn get_expression_attribute_values(
|
712 775 | &self,
|
713 776 | ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
|
714 777 | self.inner.get_expression_attribute_values()
|
715 778 | }
|
779 + | /* FluentBuilderGenerator.kt:282 */
|
716 780 | }
|