-
Notifications
You must be signed in to change notification settings - Fork 597
/
api_op_CreateSchema.go
255 lines (221 loc) · 8.71 KB
/
api_op_CreateSchema.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
// 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"
)
// Creates a new schema set and registers the schema definition. Returns an error
// if the schema set already exists without actually registering the version.
//
// When the schema set is created, a version checkpoint will be set to the first
// version. Compatibility mode "DISABLED" restricts any additional schema versions
// from being added after the first schema version. For all other compatibility
// modes, validation of compatibility settings will be applied only from the second
// version onwards when the RegisterSchemaVersion API is used.
//
// When this API is called without a RegistryId , this will create an entry for a
// "default-registry" in the registry database tables, if it is not already
// present.
func (c *Client) CreateSchema(ctx context.Context, params *CreateSchemaInput, optFns ...func(*Options)) (*CreateSchemaOutput, error) {
if params == nil {
params = &CreateSchemaInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSchema", params, optFns, c.addOperationCreateSchemaMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSchemaOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSchemaInput struct {
// The data format of the schema definition. Currently AVRO , JSON and PROTOBUF
// are supported.
//
// This member is required.
DataFormat types.DataFormat
// Name of the schema to be created of max length of 255, and may only contain
// letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.
//
// This member is required.
SchemaName *string
// The compatibility mode of the schema. The possible values are:
//
// - NONE: No compatibility mode applies. You can use this choice in development
// scenarios or if you do not know the compatibility mode that you want to apply to
// schemas. Any new version added will be accepted without undergoing a
// compatibility check.
//
// - DISABLED: This compatibility choice prevents versioning for a particular
// schema. You can use this choice to prevent future versioning of a schema.
//
// - BACKWARD: This compatibility choice is recommended as it allows data
// receivers to read both the current and one previous schema version. This means
// that for instance, a new schema version cannot drop data fields or change the
// type of these fields, so they can't be read by readers using the previous
// version.
//
// - BACKWARD_ALL: This compatibility choice allows data receivers to read both
// the current and all previous schema versions. You can use this choice when you
// need to delete fields or add optional fields, and check compatibility against
// all previous schema versions.
//
// - FORWARD: This compatibility choice allows data receivers to read both the
// current and one next schema version, but not necessarily later versions. You can
// use this choice when you need to add fields or delete optional fields, but only
// check compatibility against the last schema version.
//
// - FORWARD_ALL: This compatibility choice allows data receivers to read
// written by producers of any new registered schema. You can use this choice when
// you need to add fields or delete optional fields, and check compatibility
// against all previous schema versions.
//
// - FULL: This compatibility choice allows data receivers to read data written
// by producers using the previous or next version of the schema, but not
// necessarily earlier or later versions. You can use this choice when you need to
// add or remove optional fields, but only check compatibility against the last
// schema version.
//
// - FULL_ALL: This compatibility choice allows data receivers to read data
// written by producers using all previous schema versions. You can use this choice
// when you need to add or remove optional fields, and check compatibility against
// all previous schema versions.
Compatibility types.Compatibility
// An optional description of the schema. If description is not provided, there
// will not be any automatic default value for this.
Description *string
// This is a wrapper shape to contain the registry identity fields. If this is
// not provided, the default registry will be used. The ARN format for the same
// will be: arn:aws:glue:us-east-2::registry/default-registry:random-5-letter-id .
RegistryId *types.RegistryId
// The schema definition using the DataFormat setting for SchemaName .
SchemaDefinition *string
// Amazon Web Services tags that contain a key value pair and may be searched by
// console, command line, or API. If specified, follows the Amazon Web Services
// tags-on-create pattern.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateSchemaOutput struct {
// The schema compatibility mode.
Compatibility types.Compatibility
// The data format of the schema definition. Currently AVRO , JSON and PROTOBUF
// are supported.
DataFormat types.DataFormat
// A description of the schema if specified when created.
Description *string
// The latest version of the schema associated with the returned schema definition.
LatestSchemaVersion *int64
// The next version of the schema associated with the returned schema definition.
NextSchemaVersion *int64
// The Amazon Resource Name (ARN) of the registry.
RegistryArn *string
// The name of the registry.
RegistryName *string
// The Amazon Resource Name (ARN) of the schema.
SchemaArn *string
// The version number of the checkpoint (the last time the compatibility mode was
// changed).
SchemaCheckpoint *int64
// The name of the schema.
SchemaName *string
// The status of the schema.
SchemaStatus types.SchemaStatus
// The unique identifier of the first schema version.
SchemaVersionId *string
// The status of the first schema version created.
SchemaVersionStatus types.SchemaVersionStatus
// The tags for the schema.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSchemaMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSchema{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSchema{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "CreateSchema"); 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 = addOpCreateSchemaValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSchema(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
}
func newServiceMetadataMiddleware_opCreateSchema(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "CreateSchema",
}
}