-
Notifications
You must be signed in to change notification settings - Fork 597
/
api_op_SearchTables.go
270 lines (231 loc) · 8.19 KB
/
api_op_SearchTables.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
// Code generated by smithy-go-codegen DO NOT EDIT.
package glue
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/glue/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Searches a set of tables based on properties in the table metadata as well as
// on the parent database. You can search against text or filter conditions.
//
// You can only get tables that you have access to based on the security policies
// defined in Lake Formation. You need at least a read-only access to the table for
// it to be returned. If you do not have access to all the columns in the table,
// these columns will not be searched against when returning the list of tables
// back to you. If you have access to the columns but not the data in the columns,
// those columns and the associated metadata for those columns will be included in
// the search.
func (c *Client) SearchTables(ctx context.Context, params *SearchTablesInput, optFns ...func(*Options)) (*SearchTablesOutput, error) {
if params == nil {
params = &SearchTablesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchTables", params, optFns, c.addOperationSearchTablesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchTablesOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchTablesInput struct {
// A unique identifier, consisting of account_id .
CatalogId *string
// A list of key-value pairs, and a comparator used to filter the search results.
// Returns all entities matching the predicate.
//
// The Comparator member of the PropertyPredicate struct is used only for time
// fields, and can be omitted for other field types. Also, when comparing string
// values, such as when Key=Name , a fuzzy match algorithm is used. The Key field
// (for example, the value of the Name field) is split on certain punctuation
// characters, for example, -, :, #, etc. into tokens. Then each token is
// exact-match compared with the Value member of PropertyPredicate . For example,
// if Key=Name and Value=link , tables named customer-link and xx-link-yy are
// returned, but xxlinkyy is not returned.
Filters []types.PropertyPredicate
// The maximum number of tables to return in a single response.
MaxResults *int32
// A continuation token, included if this is a continuation call.
NextToken *string
// Allows you to specify that you want to search the tables shared with your
// account. The allowable values are FOREIGN or ALL .
//
// - If set to FOREIGN , will search the tables shared with your account.
//
// - If set to ALL , will search the tables shared with your account, as well as
// the tables in yor local account.
ResourceShareType types.ResourceShareType
// A string used for a text search.
//
// Specifying a value in quotes filters based on an exact match to the value.
SearchText *string
// A list of criteria for sorting the results by a field name, in an ascending or
// descending order.
SortCriteria []types.SortCriterion
noSmithyDocumentSerde
}
type SearchTablesOutput struct {
// A continuation token, present if the current list segment is not the last.
NextToken *string
// A list of the requested Table objects. The SearchTables response returns only
// the tables that you have access to.
TableList []types.Table
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchTablesMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpSearchTables{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSearchTables{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "SearchTables"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchTables(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
// SearchTablesAPIClient is a client that implements the SearchTables operation.
type SearchTablesAPIClient interface {
SearchTables(context.Context, *SearchTablesInput, ...func(*Options)) (*SearchTablesOutput, error)
}
var _ SearchTablesAPIClient = (*Client)(nil)
// SearchTablesPaginatorOptions is the paginator options for SearchTables
type SearchTablesPaginatorOptions struct {
// The maximum number of tables to return in a single response.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchTablesPaginator is a paginator for SearchTables
type SearchTablesPaginator struct {
options SearchTablesPaginatorOptions
client SearchTablesAPIClient
params *SearchTablesInput
nextToken *string
firstPage bool
}
// NewSearchTablesPaginator returns a new SearchTablesPaginator
func NewSearchTablesPaginator(client SearchTablesAPIClient, params *SearchTablesInput, optFns ...func(*SearchTablesPaginatorOptions)) *SearchTablesPaginator {
if params == nil {
params = &SearchTablesInput{}
}
options := SearchTablesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &SearchTablesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchTablesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchTables page.
func (p *SearchTablesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchTablesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.SearchTables(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opSearchTables(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "SearchTables",
}
}