cdk-glue-iceberg-table 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,78 @@
1
+ import { IcebergType } from './iceberg-type';
2
+ /**
3
+ * Discriminator for `IcebergPartitionTransform`.
4
+ */
5
+ export declare enum IcebergPartitionTransformKind {
6
+ IDENTITY = "identity",
7
+ YEAR = "year",
8
+ MONTH = "month",
9
+ DAY = "day",
10
+ HOUR = "hour",
11
+ VOID = "void",
12
+ BUCKET = "bucket",
13
+ TRUNCATE = "truncate"
14
+ }
15
+ /**
16
+ * Construction options for an `IcebergPartitionTransform`.
17
+ *
18
+ * Most callers should use the static factories
19
+ * (`IcebergPartitionTransform.IDENTITY`,
20
+ * `IcebergPartitionTransform.bucket(...)`, etc.) rather than
21
+ * instantiate directly. The constructor exists for jsii reflection
22
+ * and runs the same validation as the factories.
23
+ */
24
+ export interface IcebergPartitionTransformOptions {
25
+ /** Discriminator. */
26
+ readonly kind: IcebergPartitionTransformKind;
27
+ /** Number of buckets (positive integer). Required when `kind === BUCKET`. */
28
+ readonly bucketCount?: number;
29
+ /** Truncate width (positive integer). Required when `kind === TRUNCATE`. */
30
+ readonly truncateWidth?: number;
31
+ }
32
+ /**
33
+ * One of the partition / sort transforms defined in the Iceberg spec.
34
+ *
35
+ * Use the static factories on this class to construct one. The
36
+ * resulting object knows (a) the literal string Glue expects for
37
+ * `IcebergPartitionField.transform` and (b) which source column types
38
+ * it is legal to apply against.
39
+ */
40
+ export declare class IcebergPartitionTransform {
41
+ /** `identity` — source value unmodified. Legal on any column type. */
42
+ static readonly IDENTITY: IcebergPartitionTransform;
43
+ /** `year` — extracts the year of a date/timestamp. */
44
+ static readonly YEAR: IcebergPartitionTransform;
45
+ /** `month` — extracts the month of a date/timestamp. */
46
+ static readonly MONTH: IcebergPartitionTransform;
47
+ /** `day` — extracts the day of a date/timestamp. */
48
+ static readonly DAY: IcebergPartitionTransform;
49
+ /** `hour` — extracts the hour of a timestamp (not a date). */
50
+ static readonly HOUR: IcebergPartitionTransform;
51
+ /** `void` — always-null partition. Useful for partition-spec evolution. */
52
+ static readonly VOID: IcebergPartitionTransform;
53
+ /**
54
+ * `bucket[N]` — Murmur3 hash of the source mod N.
55
+ * @param numBuckets Number of buckets (positive integer).
56
+ */
57
+ static bucket(numBuckets: number): IcebergPartitionTransform;
58
+ /**
59
+ * `truncate[W]` — truncate the source to width W.
60
+ * @param width Width (positive integer).
61
+ */
62
+ static truncate(width: number): IcebergPartitionTransform;
63
+ /** Discriminator. */
64
+ readonly kind: IcebergPartitionTransformKind;
65
+ /** Number of buckets (set when `kind === BUCKET`). */
66
+ readonly bucketCount?: number;
67
+ /** Truncate width (set when `kind === TRUNCATE`). */
68
+ readonly truncateWidth?: number;
69
+ constructor(options: IcebergPartitionTransformOptions);
70
+ /** Iceberg/Glue transform string (e.g. `identity`, `bucket[16]`, `hour`). */
71
+ toTransformString(): string;
72
+ /**
73
+ * Throws if this transform is not legal on the given source type.
74
+ *
75
+ * @internal
76
+ */
77
+ validateSourceType(sourceColumnName: string, sourceType: IcebergType): void;
78
+ }
@@ -0,0 +1,219 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.IcebergPartitionTransform = exports.IcebergPartitionTransformKind = void 0;
4
+ const iceberg_type_1 = require("./iceberg-type");
5
+ /**
6
+ * Discriminator for `IcebergPartitionTransform`.
7
+ */
8
+ var IcebergPartitionTransformKind;
9
+ (function (IcebergPartitionTransformKind) {
10
+ IcebergPartitionTransformKind["IDENTITY"] = "identity";
11
+ IcebergPartitionTransformKind["YEAR"] = "year";
12
+ IcebergPartitionTransformKind["MONTH"] = "month";
13
+ IcebergPartitionTransformKind["DAY"] = "day";
14
+ IcebergPartitionTransformKind["HOUR"] = "hour";
15
+ IcebergPartitionTransformKind["VOID"] = "void";
16
+ IcebergPartitionTransformKind["BUCKET"] = "bucket";
17
+ IcebergPartitionTransformKind["TRUNCATE"] = "truncate";
18
+ })(IcebergPartitionTransformKind || (exports.IcebergPartitionTransformKind = IcebergPartitionTransformKind = {}));
19
+ /**
20
+ * One of the partition / sort transforms defined in the Iceberg spec.
21
+ *
22
+ * Use the static factories on this class to construct one. The
23
+ * resulting object knows (a) the literal string Glue expects for
24
+ * `IcebergPartitionField.transform` and (b) which source column types
25
+ * it is legal to apply against.
26
+ */
27
+ class IcebergPartitionTransform {
28
+ /** `identity` — source value unmodified. Legal on any column type. */
29
+ static IDENTITY = new IcebergPartitionTransform({
30
+ kind: IcebergPartitionTransformKind.IDENTITY,
31
+ });
32
+ /** `year` — extracts the year of a date/timestamp. */
33
+ static YEAR = new IcebergPartitionTransform({
34
+ kind: IcebergPartitionTransformKind.YEAR,
35
+ });
36
+ /** `month` — extracts the month of a date/timestamp. */
37
+ static MONTH = new IcebergPartitionTransform({
38
+ kind: IcebergPartitionTransformKind.MONTH,
39
+ });
40
+ /** `day` — extracts the day of a date/timestamp. */
41
+ static DAY = new IcebergPartitionTransform({
42
+ kind: IcebergPartitionTransformKind.DAY,
43
+ });
44
+ /** `hour` — extracts the hour of a timestamp (not a date). */
45
+ static HOUR = new IcebergPartitionTransform({
46
+ kind: IcebergPartitionTransformKind.HOUR,
47
+ });
48
+ /** `void` — always-null partition. Useful for partition-spec evolution. */
49
+ static VOID = new IcebergPartitionTransform({
50
+ kind: IcebergPartitionTransformKind.VOID,
51
+ });
52
+ /**
53
+ * `bucket[N]` — Murmur3 hash of the source mod N.
54
+ * @param numBuckets Number of buckets (positive integer).
55
+ */
56
+ static bucket(numBuckets) {
57
+ return new IcebergPartitionTransform({
58
+ kind: IcebergPartitionTransformKind.BUCKET,
59
+ bucketCount: numBuckets,
60
+ });
61
+ }
62
+ /**
63
+ * `truncate[W]` — truncate the source to width W.
64
+ * @param width Width (positive integer).
65
+ */
66
+ static truncate(width) {
67
+ return new IcebergPartitionTransform({
68
+ kind: IcebergPartitionTransformKind.TRUNCATE,
69
+ truncateWidth: width,
70
+ });
71
+ }
72
+ /** Discriminator. */
73
+ kind;
74
+ /** Number of buckets (set when `kind === BUCKET`). */
75
+ bucketCount;
76
+ /** Truncate width (set when `kind === TRUNCATE`). */
77
+ truncateWidth;
78
+ constructor(options) {
79
+ this.kind = options.kind;
80
+ switch (options.kind) {
81
+ case IcebergPartitionTransformKind.IDENTITY:
82
+ case IcebergPartitionTransformKind.YEAR:
83
+ case IcebergPartitionTransformKind.MONTH:
84
+ case IcebergPartitionTransformKind.DAY:
85
+ case IcebergPartitionTransformKind.HOUR:
86
+ case IcebergPartitionTransformKind.VOID:
87
+ /// These transforms carry no extra data.
88
+ break;
89
+ case IcebergPartitionTransformKind.BUCKET:
90
+ if (options.bucketCount === undefined) {
91
+ throw new Error('bucket transform requires bucketCount');
92
+ }
93
+ if (!Number.isInteger(options.bucketCount) || options.bucketCount < 1) {
94
+ throw new Error(`bucket() numBuckets must be a positive integer, got ${options.bucketCount}`);
95
+ }
96
+ this.bucketCount = options.bucketCount;
97
+ break;
98
+ case IcebergPartitionTransformKind.TRUNCATE:
99
+ if (options.truncateWidth === undefined) {
100
+ throw new Error('truncate transform requires truncateWidth');
101
+ }
102
+ if (!Number.isInteger(options.truncateWidth) || options.truncateWidth < 1) {
103
+ throw new Error(`truncate() width must be a positive integer, got ${options.truncateWidth}`);
104
+ }
105
+ this.truncateWidth = options.truncateWidth;
106
+ break;
107
+ /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */
108
+ default: {
109
+ const exhaustive = options.kind;
110
+ throw new Error(`unknown IcebergPartitionTransformKind: ${exhaustive}`);
111
+ }
112
+ }
113
+ }
114
+ /** Iceberg/Glue transform string (e.g. `identity`, `bucket[16]`, `hour`). */
115
+ toTransformString() {
116
+ switch (this.kind) {
117
+ case IcebergPartitionTransformKind.BUCKET:
118
+ return `bucket[${this.bucketCount}]`;
119
+ case IcebergPartitionTransformKind.TRUNCATE:
120
+ return `truncate[${this.truncateWidth}]`;
121
+ case IcebergPartitionTransformKind.IDENTITY:
122
+ case IcebergPartitionTransformKind.YEAR:
123
+ case IcebergPartitionTransformKind.MONTH:
124
+ case IcebergPartitionTransformKind.DAY:
125
+ case IcebergPartitionTransformKind.HOUR:
126
+ case IcebergPartitionTransformKind.VOID:
127
+ return this.kind;
128
+ /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */
129
+ default: {
130
+ const exhaustive = this.kind;
131
+ throw new Error(`unknown IcebergPartitionTransformKind in toTransformString: ${exhaustive}`);
132
+ }
133
+ }
134
+ }
135
+ /**
136
+ * Throws if this transform is not legal on the given source type.
137
+ *
138
+ * @internal
139
+ */
140
+ validateSourceType(sourceColumnName, sourceType) {
141
+ switch (this.kind) {
142
+ case IcebergPartitionTransformKind.IDENTITY:
143
+ case IcebergPartitionTransformKind.VOID:
144
+ return;
145
+ case IcebergPartitionTransformKind.YEAR:
146
+ case IcebergPartitionTransformKind.MONTH:
147
+ case IcebergPartitionTransformKind.DAY:
148
+ if (!isTemporal(sourceType)) {
149
+ throw new Error(`partition transform '${this.kind}' on column '${sourceColumnName}' `
150
+ + 'requires a date/timestamp/timestamptz column');
151
+ }
152
+ return;
153
+ case IcebergPartitionTransformKind.HOUR:
154
+ if (!isTimestamp(sourceType)) {
155
+ throw new Error(`partition transform 'hour' on column '${sourceColumnName}' `
156
+ + 'requires a timestamp/timestamptz column');
157
+ }
158
+ return;
159
+ case IcebergPartitionTransformKind.BUCKET:
160
+ if (!isBucketLegal(sourceType)) {
161
+ throw new Error(`partition transform 'bucket[${this.bucketCount}]' on column '${sourceColumnName}' requires `
162
+ + 'an int/long/decimal/date/time/timestamp/timestamptz/string/uuid/fixed/binary column');
163
+ }
164
+ return;
165
+ case IcebergPartitionTransformKind.TRUNCATE:
166
+ if (!isTruncateLegal(sourceType)) {
167
+ throw new Error(`partition transform 'truncate[${this.truncateWidth}]' on column '${sourceColumnName}' requires `
168
+ + 'an int/long/decimal/string/binary column');
169
+ }
170
+ return;
171
+ /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */
172
+ default: {
173
+ const exhaustive = this.kind;
174
+ throw new Error(`unknown IcebergPartitionTransformKind in validateSourceType: ${exhaustive}`);
175
+ }
176
+ }
177
+ }
178
+ }
179
+ exports.IcebergPartitionTransform = IcebergPartitionTransform;
180
+ function isTemporal(type) {
181
+ return type.kind === iceberg_type_1.IcebergTypeKind.DATE
182
+ || type.kind === iceberg_type_1.IcebergTypeKind.TIMESTAMP
183
+ || type.kind === iceberg_type_1.IcebergTypeKind.TIMESTAMPTZ;
184
+ }
185
+ function isTimestamp(type) {
186
+ return type.kind === iceberg_type_1.IcebergTypeKind.TIMESTAMP
187
+ || type.kind === iceberg_type_1.IcebergTypeKind.TIMESTAMPTZ;
188
+ }
189
+ function isBucketLegal(type) {
190
+ switch (type.kind) {
191
+ case iceberg_type_1.IcebergTypeKind.INT:
192
+ case iceberg_type_1.IcebergTypeKind.LONG:
193
+ case iceberg_type_1.IcebergTypeKind.DATE:
194
+ case iceberg_type_1.IcebergTypeKind.TIME:
195
+ case iceberg_type_1.IcebergTypeKind.TIMESTAMP:
196
+ case iceberg_type_1.IcebergTypeKind.TIMESTAMPTZ:
197
+ case iceberg_type_1.IcebergTypeKind.STRING:
198
+ case iceberg_type_1.IcebergTypeKind.UUID:
199
+ case iceberg_type_1.IcebergTypeKind.BINARY:
200
+ case iceberg_type_1.IcebergTypeKind.DECIMAL:
201
+ case iceberg_type_1.IcebergTypeKind.FIXED:
202
+ return true;
203
+ default:
204
+ return false;
205
+ }
206
+ }
207
+ function isTruncateLegal(type) {
208
+ switch (type.kind) {
209
+ case iceberg_type_1.IcebergTypeKind.INT:
210
+ case iceberg_type_1.IcebergTypeKind.LONG:
211
+ case iceberg_type_1.IcebergTypeKind.STRING:
212
+ case iceberg_type_1.IcebergTypeKind.BINARY:
213
+ case iceberg_type_1.IcebergTypeKind.DECIMAL:
214
+ return true;
215
+ default:
216
+ return false;
217
+ }
218
+ }
219
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-partition-transform.js","sourceRoot":"","sources":["../../../lib/iceberg/iceberg-partition-transform.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    IcebergType,\n    IcebergTypeKind,\n} from './iceberg-type';\n\n/**\n * Discriminator for `IcebergPartitionTransform`.\n */\nexport enum IcebergPartitionTransformKind {\n    IDENTITY = 'identity',\n    YEAR = 'year',\n    MONTH = 'month',\n    DAY = 'day',\n    HOUR = 'hour',\n    VOID = 'void',\n    BUCKET = 'bucket',\n    TRUNCATE = 'truncate',\n}\n\n/**\n * Construction options for an `IcebergPartitionTransform`.\n *\n * Most callers should use the static factories\n * (`IcebergPartitionTransform.IDENTITY`,\n * `IcebergPartitionTransform.bucket(...)`, etc.) rather than\n * instantiate directly. The constructor exists for jsii reflection\n * and runs the same validation as the factories.\n */\nexport interface IcebergPartitionTransformOptions {\n    /** Discriminator. */\n    readonly kind: IcebergPartitionTransformKind;\n\n    /** Number of buckets (positive integer). Required when `kind === BUCKET`. */\n    readonly bucketCount?: number;\n\n    /** Truncate width (positive integer). Required when `kind === TRUNCATE`. */\n    readonly truncateWidth?: number;\n}\n\n/**\n * One of the partition / sort transforms defined in the Iceberg spec.\n *\n * Use the static factories on this class to construct one. The\n * resulting object knows (a) the literal string Glue expects for\n * `IcebergPartitionField.transform` and (b) which source column types\n * it is legal to apply against.\n */\nexport class IcebergPartitionTransform {\n    /** `identity` — source value unmodified. Legal on any column type. */\n    public static readonly IDENTITY: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.IDENTITY,\n    });\n\n    /** `year` — extracts the year of a date/timestamp. */\n    public static readonly YEAR: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.YEAR,\n    });\n\n    /** `month` — extracts the month of a date/timestamp. */\n    public static readonly MONTH: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.MONTH,\n    });\n\n    /** `day` — extracts the day of a date/timestamp. */\n    public static readonly DAY: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.DAY,\n    });\n\n    /** `hour` — extracts the hour of a timestamp (not a date). */\n    public static readonly HOUR: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.HOUR,\n    });\n\n    /** `void` — always-null partition. Useful for partition-spec evolution. */\n    public static readonly VOID: IcebergPartitionTransform = new IcebergPartitionTransform({\n        kind: IcebergPartitionTransformKind.VOID,\n    });\n\n    /**\n     * `bucket[N]` — Murmur3 hash of the source mod N.\n     * @param numBuckets Number of buckets (positive integer).\n     */\n    public static bucket(numBuckets: number): IcebergPartitionTransform {\n        return new IcebergPartitionTransform({\n            kind: IcebergPartitionTransformKind.BUCKET,\n            bucketCount: numBuckets,\n        });\n    }\n\n    /**\n     * `truncate[W]` — truncate the source to width W.\n     * @param width Width (positive integer).\n     */\n    public static truncate(width: number): IcebergPartitionTransform {\n        return new IcebergPartitionTransform({\n            kind: IcebergPartitionTransformKind.TRUNCATE,\n            truncateWidth: width,\n        });\n    }\n\n    /** Discriminator. */\n    public readonly kind: IcebergPartitionTransformKind;\n\n    /** Number of buckets (set when `kind === BUCKET`). */\n    public readonly bucketCount?: number;\n\n    /** Truncate width (set when `kind === TRUNCATE`). */\n    public readonly truncateWidth?: number;\n\n    public constructor(options: IcebergPartitionTransformOptions) {\n        this.kind = options.kind;\n        switch (options.kind) {\n            case IcebergPartitionTransformKind.IDENTITY:\n            case IcebergPartitionTransformKind.YEAR:\n            case IcebergPartitionTransformKind.MONTH:\n            case IcebergPartitionTransformKind.DAY:\n            case IcebergPartitionTransformKind.HOUR:\n            case IcebergPartitionTransformKind.VOID:\n                /// These transforms carry no extra data.\n                break;\n            case IcebergPartitionTransformKind.BUCKET:\n                if (options.bucketCount === undefined) {\n                    throw new Error('bucket transform requires bucketCount');\n                }\n                if (!Number.isInteger(options.bucketCount) || options.bucketCount < 1) {\n                    throw new Error(`bucket() numBuckets must be a positive integer, got ${options.bucketCount}`);\n                }\n                this.bucketCount = options.bucketCount;\n                break;\n            case IcebergPartitionTransformKind.TRUNCATE:\n                if (options.truncateWidth === undefined) {\n                    throw new Error('truncate transform requires truncateWidth');\n                }\n                if (!Number.isInteger(options.truncateWidth) || options.truncateWidth < 1) {\n                    throw new Error(`truncate() width must be a positive integer, got ${options.truncateWidth}`);\n                }\n                this.truncateWidth = options.truncateWidth;\n                break;\n            /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */\n            default: {\n                const exhaustive: never = options.kind;\n                throw new Error(`unknown IcebergPartitionTransformKind: ${exhaustive}`);\n            }\n        }\n    }\n\n    /** Iceberg/Glue transform string (e.g. `identity`, `bucket[16]`, `hour`). */\n    public toTransformString(): string {\n        switch (this.kind) {\n            case IcebergPartitionTransformKind.BUCKET:\n                return `bucket[${this.bucketCount}]`;\n            case IcebergPartitionTransformKind.TRUNCATE:\n                return `truncate[${this.truncateWidth}]`;\n            case IcebergPartitionTransformKind.IDENTITY:\n            case IcebergPartitionTransformKind.YEAR:\n            case IcebergPartitionTransformKind.MONTH:\n            case IcebergPartitionTransformKind.DAY:\n            case IcebergPartitionTransformKind.HOUR:\n            case IcebergPartitionTransformKind.VOID:\n                return this.kind;\n            /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */\n            default: {\n                const exhaustive: never = this.kind;\n                throw new Error(`unknown IcebergPartitionTransformKind in toTransformString: ${exhaustive}`);\n            }\n        }\n    }\n\n    /**\n     * Throws if this transform is not legal on the given source type.\n     *\n     * @internal\n     */\n    public validateSourceType(sourceColumnName: string, sourceType: IcebergType): void {\n        switch (this.kind) {\n            case IcebergPartitionTransformKind.IDENTITY:\n            case IcebergPartitionTransformKind.VOID:\n                return;\n            case IcebergPartitionTransformKind.YEAR:\n            case IcebergPartitionTransformKind.MONTH:\n            case IcebergPartitionTransformKind.DAY:\n                if (!isTemporal(sourceType)) {\n                    throw new Error(\n                        `partition transform '${this.kind}' on column '${sourceColumnName}' `\n                        + 'requires a date/timestamp/timestamptz column',\n                    );\n                }\n                return;\n            case IcebergPartitionTransformKind.HOUR:\n                if (!isTimestamp(sourceType)) {\n                    throw new Error(\n                        `partition transform 'hour' on column '${sourceColumnName}' `\n                        + 'requires a timestamp/timestamptz column',\n                    );\n                }\n                return;\n            case IcebergPartitionTransformKind.BUCKET:\n                if (!isBucketLegal(sourceType)) {\n                    throw new Error(\n                        `partition transform 'bucket[${this.bucketCount}]' on column '${sourceColumnName}' requires `\n                        + 'an int/long/decimal/date/time/timestamp/timestamptz/string/uuid/fixed/binary column',\n                    );\n                }\n                return;\n            case IcebergPartitionTransformKind.TRUNCATE:\n                if (!isTruncateLegal(sourceType)) {\n                    throw new Error(\n                        `partition transform 'truncate[${this.truncateWidth}]' on column '${sourceColumnName}' requires `\n                        + 'an int/long/decimal/string/binary column',\n                    );\n                }\n                return;\n            /* istanbul ignore next: defensive — TS exhaustiveness covers this, only reachable from non-TS bindings */\n            default: {\n                const exhaustive: never = this.kind;\n                throw new Error(`unknown IcebergPartitionTransformKind in validateSourceType: ${exhaustive}`);\n            }\n        }\n    }\n}\n\nfunction isTemporal(type: IcebergType): boolean {\n    return type.kind === IcebergTypeKind.DATE\n        || type.kind === IcebergTypeKind.TIMESTAMP\n        || type.kind === IcebergTypeKind.TIMESTAMPTZ;\n}\n\nfunction isTimestamp(type: IcebergType): boolean {\n    return type.kind === IcebergTypeKind.TIMESTAMP\n        || type.kind === IcebergTypeKind.TIMESTAMPTZ;\n}\n\nfunction isBucketLegal(type: IcebergType): boolean {\n    switch (type.kind) {\n        case IcebergTypeKind.INT:\n        case IcebergTypeKind.LONG:\n        case IcebergTypeKind.DATE:\n        case IcebergTypeKind.TIME:\n        case IcebergTypeKind.TIMESTAMP:\n        case IcebergTypeKind.TIMESTAMPTZ:\n        case IcebergTypeKind.STRING:\n        case IcebergTypeKind.UUID:\n        case IcebergTypeKind.BINARY:\n        case IcebergTypeKind.DECIMAL:\n        case IcebergTypeKind.FIXED:\n            return true;\n        default:\n            return false;\n    }\n}\n\nfunction isTruncateLegal(type: IcebergType): boolean {\n    switch (type.kind) {\n        case IcebergTypeKind.INT:\n        case IcebergTypeKind.LONG:\n        case IcebergTypeKind.STRING:\n        case IcebergTypeKind.BINARY:\n        case IcebergTypeKind.DECIMAL:\n            return true;\n        default:\n            return false;\n    }\n}\n"]}
@@ -0,0 +1,54 @@
1
+ /**
2
+ * Iceberg table property keys and validation.
3
+ *
4
+ * `AWS::Glue::Table.OpenTableFormatInput.IcebergInput.IcebergTableInput.properties`
5
+ * is a free-form string map. Glue does not validate the keys, but
6
+ * Athena's writer will reject queries against tables whose properties
7
+ * contradict each other (e.g. `write.format.default=parquet` with
8
+ * `write.parquet.compression-codec=lzo`). The L2 enforces the same
9
+ * matrix at synth time so that misconfigured tables never make it to
10
+ * a deploy.
11
+ */
12
+ /** Apache Iceberg format version. Defaults to `V2` in the L2. */
13
+ export declare enum IcebergFormatVersion {
14
+ /** v1 — read-only Hive-compatible analytic tables. */
15
+ V1 = "1",
16
+ /** v2 — adds row-level deletes (default). */
17
+ V2 = "2"
18
+ }
19
+ /** Data-file storage format for an Iceberg table. */
20
+ export declare enum IcebergDataFormat {
21
+ /** Apache Parquet (default). */
22
+ PARQUET = "parquet",
23
+ /** Apache ORC. */
24
+ ORC = "orc",
25
+ /** Apache Avro. */
26
+ AVRO = "avro"
27
+ }
28
+ /** Canonical Iceberg property keys the L2 understands. */
29
+ export declare const ICEBERG_PROPERTY_KEYS: {
30
+ readonly FORMAT_VERSION: "format-version";
31
+ readonly WRITE_FORMAT_DEFAULT: "write.format.default";
32
+ readonly WRITE_PARQUET_COMPRESSION_CODEC: "write.parquet.compression-codec";
33
+ readonly WRITE_ORC_COMPRESSION_CODEC: "write.orc.compression-codec";
34
+ readonly WRITE_AVRO_COMPRESSION_CODEC: "write.avro.compression-codec";
35
+ readonly WRITE_TARGET_FILE_SIZE_BYTES: "write.target-file-size-bytes";
36
+ readonly WRITE_DELETE_MODE: "write.delete.mode";
37
+ readonly WRITE_UPDATE_MODE: "write.update.mode";
38
+ readonly WRITE_MERGE_MODE: "write.merge.mode";
39
+ readonly WRITE_DISTRIBUTION_MODE: "write.distribution-mode";
40
+ readonly GC_ENABLED: "gc.enabled";
41
+ readonly HISTORY_EXPIRE_MAX_SNAPSHOT_AGE_MS: "history.expire.max-snapshot-age-ms";
42
+ readonly HISTORY_EXPIRE_MIN_SNAPSHOTS_TO_KEEP: "history.expire.min-snapshots-to-keep";
43
+ readonly COMMIT_RETRY_NUM_RETRIES: "commit.retry.num-retries";
44
+ };
45
+ /**
46
+ * Validates that the merged property map for a table is internally
47
+ * consistent. Throws `Error` on the first conflict so the user sees
48
+ * one clear message per deploy.
49
+ *
50
+ * @internal
51
+ */
52
+ export declare function validateIcebergProperties(dataFormat: IcebergDataFormat, formatVersion: IcebergFormatVersion, properties: {
53
+ [key: string]: string;
54
+ }): void;
@@ -0,0 +1,183 @@
1
+ "use strict";
2
+ /**
3
+ * Iceberg table property keys and validation.
4
+ *
5
+ * `AWS::Glue::Table.OpenTableFormatInput.IcebergInput.IcebergTableInput.properties`
6
+ * is a free-form string map. Glue does not validate the keys, but
7
+ * Athena's writer will reject queries against tables whose properties
8
+ * contradict each other (e.g. `write.format.default=parquet` with
9
+ * `write.parquet.compression-codec=lzo`). The L2 enforces the same
10
+ * matrix at synth time so that misconfigured tables never make it to
11
+ * a deploy.
12
+ */
13
+ Object.defineProperty(exports, "__esModule", { value: true });
14
+ exports.ICEBERG_PROPERTY_KEYS = exports.IcebergDataFormat = exports.IcebergFormatVersion = void 0;
15
+ exports.validateIcebergProperties = validateIcebergProperties;
16
+ /** Apache Iceberg format version. Defaults to `V2` in the L2. */
17
+ var IcebergFormatVersion;
18
+ (function (IcebergFormatVersion) {
19
+ /** v1 — read-only Hive-compatible analytic tables. */
20
+ IcebergFormatVersion["V1"] = "1";
21
+ /** v2 — adds row-level deletes (default). */
22
+ IcebergFormatVersion["V2"] = "2";
23
+ })(IcebergFormatVersion || (exports.IcebergFormatVersion = IcebergFormatVersion = {}));
24
+ /** Data-file storage format for an Iceberg table. */
25
+ var IcebergDataFormat;
26
+ (function (IcebergDataFormat) {
27
+ /** Apache Parquet (default). */
28
+ IcebergDataFormat["PARQUET"] = "parquet";
29
+ /** Apache ORC. */
30
+ IcebergDataFormat["ORC"] = "orc";
31
+ /** Apache Avro. */
32
+ IcebergDataFormat["AVRO"] = "avro";
33
+ })(IcebergDataFormat || (exports.IcebergDataFormat = IcebergDataFormat = {}));
34
+ /** Canonical Iceberg property keys the L2 understands. */
35
+ exports.ICEBERG_PROPERTY_KEYS = {
36
+ FORMAT_VERSION: 'format-version',
37
+ WRITE_FORMAT_DEFAULT: 'write.format.default',
38
+ WRITE_PARQUET_COMPRESSION_CODEC: 'write.parquet.compression-codec',
39
+ WRITE_ORC_COMPRESSION_CODEC: 'write.orc.compression-codec',
40
+ WRITE_AVRO_COMPRESSION_CODEC: 'write.avro.compression-codec',
41
+ WRITE_TARGET_FILE_SIZE_BYTES: 'write.target-file-size-bytes',
42
+ WRITE_DELETE_MODE: 'write.delete.mode',
43
+ WRITE_UPDATE_MODE: 'write.update.mode',
44
+ WRITE_MERGE_MODE: 'write.merge.mode',
45
+ WRITE_DISTRIBUTION_MODE: 'write.distribution-mode',
46
+ GC_ENABLED: 'gc.enabled',
47
+ HISTORY_EXPIRE_MAX_SNAPSHOT_AGE_MS: 'history.expire.max-snapshot-age-ms',
48
+ HISTORY_EXPIRE_MIN_SNAPSHOTS_TO_KEEP: 'history.expire.min-snapshots-to-keep',
49
+ COMMIT_RETRY_NUM_RETRIES: 'commit.retry.num-retries',
50
+ };
51
+ const PARQUET_CODECS = new Set([
52
+ 'zstd',
53
+ 'snappy',
54
+ 'gzip',
55
+ 'brotli',
56
+ 'lz4',
57
+ 'uncompressed',
58
+ ]);
59
+ const ORC_CODECS = new Set([
60
+ 'zstd',
61
+ 'snappy',
62
+ 'zlib',
63
+ 'lz4',
64
+ 'lzo',
65
+ 'none',
66
+ ]);
67
+ const AVRO_CODECS = new Set([
68
+ 'gzip',
69
+ 'snappy',
70
+ 'zstd',
71
+ 'uncompressed',
72
+ ]);
73
+ const WRITE_MODES = new Set([
74
+ 'copy-on-write',
75
+ 'merge-on-read',
76
+ ]);
77
+ const DISTRIBUTION_MODES = new Set([
78
+ 'none',
79
+ 'hash',
80
+ 'range',
81
+ ]);
82
+ const BOOLEAN_VALUES = new Set([
83
+ 'true',
84
+ 'false',
85
+ ]);
86
+ /**
87
+ * Validates that the merged property map for a table is internally
88
+ * consistent. Throws `Error` on the first conflict so the user sees
89
+ * one clear message per deploy.
90
+ *
91
+ * @internal
92
+ */
93
+ function validateIcebergProperties(dataFormat, formatVersion, properties) {
94
+ /// 1. write.format.default must match the chosen data format.
95
+ const declaredFormat = properties[exports.ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT];
96
+ if (declaredFormat !== undefined && declaredFormat !== dataFormat) {
97
+ throw new Error(`tableProperties['${exports.ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT}'] is '${declaredFormat}' `
98
+ + `but dataFormat is '${dataFormat}'. Drop the property or change dataFormat to match.`);
99
+ }
100
+ /// 2. format-version must match the chosen format version.
101
+ const declaredVersion = properties[exports.ICEBERG_PROPERTY_KEYS.FORMAT_VERSION];
102
+ if (declaredVersion !== undefined && declaredVersion !== formatVersion) {
103
+ throw new Error(`tableProperties['${exports.ICEBERG_PROPERTY_KEYS.FORMAT_VERSION}'] is '${declaredVersion}' `
104
+ + `but formatVersion is '${formatVersion}'. Drop the property or change formatVersion to match.`);
105
+ }
106
+ /// 3. Compression codec must be valid for the chosen format and
107
+ /// must be set on the correct codec key for that format.
108
+ validateCompressionForFormat(dataFormat, properties);
109
+ /// 4. write modes must be valid Iceberg literals.
110
+ validateEnumProperty(properties, exports.ICEBERG_PROPERTY_KEYS.WRITE_DELETE_MODE, WRITE_MODES);
111
+ validateEnumProperty(properties, exports.ICEBERG_PROPERTY_KEYS.WRITE_UPDATE_MODE, WRITE_MODES);
112
+ validateEnumProperty(properties, exports.ICEBERG_PROPERTY_KEYS.WRITE_MERGE_MODE, WRITE_MODES);
113
+ validateEnumProperty(properties, exports.ICEBERG_PROPERTY_KEYS.WRITE_DISTRIBUTION_MODE, DISTRIBUTION_MODES);
114
+ /// 5. merge-on-read requires format-version=2.
115
+ if (formatVersion === IcebergFormatVersion.V1) {
116
+ for (const key of [
117
+ exports.ICEBERG_PROPERTY_KEYS.WRITE_DELETE_MODE,
118
+ exports.ICEBERG_PROPERTY_KEYS.WRITE_UPDATE_MODE,
119
+ exports.ICEBERG_PROPERTY_KEYS.WRITE_MERGE_MODE,
120
+ ]) {
121
+ if (properties[key] === 'merge-on-read') {
122
+ throw new Error(`tableProperties['${key}'] = 'merge-on-read' requires formatVersion v2; got v1`);
123
+ }
124
+ }
125
+ }
126
+ /// 6. gc.enabled is a boolean.
127
+ validateEnumProperty(properties, exports.ICEBERG_PROPERTY_KEYS.GC_ENABLED, BOOLEAN_VALUES);
128
+ /// 7. Numeric properties must parse to positive integers.
129
+ validatePositiveInt(properties, exports.ICEBERG_PROPERTY_KEYS.WRITE_TARGET_FILE_SIZE_BYTES);
130
+ validatePositiveInt(properties, exports.ICEBERG_PROPERTY_KEYS.HISTORY_EXPIRE_MAX_SNAPSHOT_AGE_MS);
131
+ validatePositiveInt(properties, exports.ICEBERG_PROPERTY_KEYS.HISTORY_EXPIRE_MIN_SNAPSHOTS_TO_KEEP);
132
+ validatePositiveInt(properties, exports.ICEBERG_PROPERTY_KEYS.COMMIT_RETRY_NUM_RETRIES);
133
+ }
134
+ function validateCompressionForFormat(dataFormat, properties) {
135
+ const candidates = [
136
+ {
137
+ key: exports.ICEBERG_PROPERTY_KEYS.WRITE_PARQUET_COMPRESSION_CODEC,
138
+ allowed: PARQUET_CODECS,
139
+ ownerFormat: IcebergDataFormat.PARQUET,
140
+ },
141
+ {
142
+ key: exports.ICEBERG_PROPERTY_KEYS.WRITE_ORC_COMPRESSION_CODEC,
143
+ allowed: ORC_CODECS,
144
+ ownerFormat: IcebergDataFormat.ORC,
145
+ },
146
+ {
147
+ key: exports.ICEBERG_PROPERTY_KEYS.WRITE_AVRO_COMPRESSION_CODEC,
148
+ allowed: AVRO_CODECS,
149
+ ownerFormat: IcebergDataFormat.AVRO,
150
+ },
151
+ ];
152
+ for (const candidate of candidates) {
153
+ const value = properties[candidate.key];
154
+ if (value === undefined) {
155
+ continue;
156
+ }
157
+ if (candidate.ownerFormat !== dataFormat) {
158
+ throw new Error(`tableProperties['${candidate.key}'] is set but dataFormat is '${dataFormat}'. `
159
+ + `That codec key only applies to '${candidate.ownerFormat}' tables.`);
160
+ }
161
+ if (!candidate.allowed.has(value)) {
162
+ throw new Error(`tableProperties['${candidate.key}'] = '${value}' is not a valid ${candidate.ownerFormat} `
163
+ + `compression codec. Allowed: ${Array.from(candidate.allowed).sort().join(', ')}.`);
164
+ }
165
+ }
166
+ }
167
+ function validateEnumProperty(properties, key, allowed) {
168
+ const value = properties[key];
169
+ if (value !== undefined && !allowed.has(value)) {
170
+ throw new Error(`tableProperties['${key}'] = '${value}' is not valid. `
171
+ + `Allowed: ${Array.from(allowed).sort().join(', ')}.`);
172
+ }
173
+ }
174
+ function validatePositiveInt(properties, key) {
175
+ const raw = properties[key];
176
+ if (raw === undefined) {
177
+ return;
178
+ }
179
+ if (!/^[0-9]+$/.test(raw) || Number(raw) < 1) {
180
+ throw new Error(`tableProperties['${key}'] = '${raw}' must be a positive integer string.`);
181
+ }
182
+ }
183
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iceberg-table-properties.js","sourceRoot":"","sources":["../../../lib/iceberg/iceberg-table-properties.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Iceberg table property keys and validation.\n *\n * `AWS::Glue::Table.OpenTableFormatInput.IcebergInput.IcebergTableInput.properties`\n * is a free-form string map. Glue does not validate the keys, but\n * Athena's writer will reject queries against tables whose properties\n * contradict each other (e.g. `write.format.default=parquet` with\n * `write.parquet.compression-codec=lzo`). The L2 enforces the same\n * matrix at synth time so that misconfigured tables never make it to\n * a deploy.\n */\n\n/** Apache Iceberg format version. Defaults to `V2` in the L2. */\nexport enum IcebergFormatVersion {\n    /** v1 — read-only Hive-compatible analytic tables. */\n    V1 = '1',\n\n    /** v2 — adds row-level deletes (default). */\n    V2 = '2',\n}\n\n/** Data-file storage format for an Iceberg table. */\nexport enum IcebergDataFormat {\n    /** Apache Parquet (default). */\n    PARQUET = 'parquet',\n\n    /** Apache ORC. */\n    ORC = 'orc',\n\n    /** Apache Avro. */\n    AVRO = 'avro',\n}\n\n/** Canonical Iceberg property keys the L2 understands. */\nexport const ICEBERG_PROPERTY_KEYS = {\n    FORMAT_VERSION: 'format-version',\n    WRITE_FORMAT_DEFAULT: 'write.format.default',\n    WRITE_PARQUET_COMPRESSION_CODEC: 'write.parquet.compression-codec',\n    WRITE_ORC_COMPRESSION_CODEC: 'write.orc.compression-codec',\n    WRITE_AVRO_COMPRESSION_CODEC: 'write.avro.compression-codec',\n    WRITE_TARGET_FILE_SIZE_BYTES: 'write.target-file-size-bytes',\n    WRITE_DELETE_MODE: 'write.delete.mode',\n    WRITE_UPDATE_MODE: 'write.update.mode',\n    WRITE_MERGE_MODE: 'write.merge.mode',\n    WRITE_DISTRIBUTION_MODE: 'write.distribution-mode',\n    GC_ENABLED: 'gc.enabled',\n    HISTORY_EXPIRE_MAX_SNAPSHOT_AGE_MS: 'history.expire.max-snapshot-age-ms',\n    HISTORY_EXPIRE_MIN_SNAPSHOTS_TO_KEEP: 'history.expire.min-snapshots-to-keep',\n    COMMIT_RETRY_NUM_RETRIES: 'commit.retry.num-retries',\n} as const;\n\nconst PARQUET_CODECS = new Set([\n    'zstd',\n    'snappy',\n    'gzip',\n    'brotli',\n    'lz4',\n    'uncompressed',\n]);\n\nconst ORC_CODECS = new Set([\n    'zstd',\n    'snappy',\n    'zlib',\n    'lz4',\n    'lzo',\n    'none',\n]);\n\nconst AVRO_CODECS = new Set([\n    'gzip',\n    'snappy',\n    'zstd',\n    'uncompressed',\n]);\n\nconst WRITE_MODES = new Set([\n    'copy-on-write',\n    'merge-on-read',\n]);\n\nconst DISTRIBUTION_MODES = new Set([\n    'none',\n    'hash',\n    'range',\n]);\n\nconst BOOLEAN_VALUES = new Set([\n    'true',\n    'false',\n]);\n\n/**\n * Validates that the merged property map for a table is internally\n * consistent. Throws `Error` on the first conflict so the user sees\n * one clear message per deploy.\n *\n * @internal\n */\nexport function validateIcebergProperties(\n    dataFormat: IcebergDataFormat,\n    formatVersion: IcebergFormatVersion,\n    properties: { [key: string]: string },\n): void {\n    /// 1. write.format.default must match the chosen data format.\n    const declaredFormat = properties[ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT];\n    if (declaredFormat !== undefined && declaredFormat !== dataFormat) {\n        throw new Error(\n            `tableProperties['${ICEBERG_PROPERTY_KEYS.WRITE_FORMAT_DEFAULT}'] is '${declaredFormat}' `\n            + `but dataFormat is '${dataFormat}'. Drop the property or change dataFormat to match.`,\n        );\n    }\n\n    /// 2. format-version must match the chosen format version.\n    const declaredVersion = properties[ICEBERG_PROPERTY_KEYS.FORMAT_VERSION];\n    if (declaredVersion !== undefined && declaredVersion !== formatVersion) {\n        throw new Error(\n            `tableProperties['${ICEBERG_PROPERTY_KEYS.FORMAT_VERSION}'] is '${declaredVersion}' `\n            + `but formatVersion is '${formatVersion}'. Drop the property or change formatVersion to match.`,\n        );\n    }\n\n    /// 3. Compression codec must be valid for the chosen format and\n    ///    must be set on the correct codec key for that format.\n    validateCompressionForFormat(dataFormat, properties);\n\n    /// 4. write modes must be valid Iceberg literals.\n    validateEnumProperty(properties, ICEBERG_PROPERTY_KEYS.WRITE_DELETE_MODE, WRITE_MODES);\n    validateEnumProperty(properties, ICEBERG_PROPERTY_KEYS.WRITE_UPDATE_MODE, WRITE_MODES);\n    validateEnumProperty(properties, ICEBERG_PROPERTY_KEYS.WRITE_MERGE_MODE, WRITE_MODES);\n    validateEnumProperty(properties, ICEBERG_PROPERTY_KEYS.WRITE_DISTRIBUTION_MODE, DISTRIBUTION_MODES);\n\n    /// 5. merge-on-read requires format-version=2.\n    if (formatVersion === IcebergFormatVersion.V1) {\n        for (const key of [\n            ICEBERG_PROPERTY_KEYS.WRITE_DELETE_MODE,\n            ICEBERG_PROPERTY_KEYS.WRITE_UPDATE_MODE,\n            ICEBERG_PROPERTY_KEYS.WRITE_MERGE_MODE,\n        ]) {\n            if (properties[key] === 'merge-on-read') {\n                throw new Error(\n                    `tableProperties['${key}'] = 'merge-on-read' requires formatVersion v2; got v1`,\n                );\n            }\n        }\n    }\n\n    /// 6. gc.enabled is a boolean.\n    validateEnumProperty(properties, ICEBERG_PROPERTY_KEYS.GC_ENABLED, BOOLEAN_VALUES);\n\n    /// 7. Numeric properties must parse to positive integers.\n    validatePositiveInt(properties, ICEBERG_PROPERTY_KEYS.WRITE_TARGET_FILE_SIZE_BYTES);\n    validatePositiveInt(properties, ICEBERG_PROPERTY_KEYS.HISTORY_EXPIRE_MAX_SNAPSHOT_AGE_MS);\n    validatePositiveInt(properties, ICEBERG_PROPERTY_KEYS.HISTORY_EXPIRE_MIN_SNAPSHOTS_TO_KEEP);\n    validatePositiveInt(properties, ICEBERG_PROPERTY_KEYS.COMMIT_RETRY_NUM_RETRIES);\n}\n\nfunction validateCompressionForFormat(\n    dataFormat: IcebergDataFormat,\n    properties: { [key: string]: string },\n): void {\n    const candidates: Array<{ key: string; allowed: ReadonlySet<string>; ownerFormat: IcebergDataFormat }> = [\n        {\n            key: ICEBERG_PROPERTY_KEYS.WRITE_PARQUET_COMPRESSION_CODEC,\n            allowed: PARQUET_CODECS,\n            ownerFormat: IcebergDataFormat.PARQUET,\n        },\n        {\n            key: ICEBERG_PROPERTY_KEYS.WRITE_ORC_COMPRESSION_CODEC,\n            allowed: ORC_CODECS,\n            ownerFormat: IcebergDataFormat.ORC,\n        },\n        {\n            key: ICEBERG_PROPERTY_KEYS.WRITE_AVRO_COMPRESSION_CODEC,\n            allowed: AVRO_CODECS,\n            ownerFormat: IcebergDataFormat.AVRO,\n        },\n    ];\n    for (const candidate of candidates) {\n        const value = properties[candidate.key];\n        if (value === undefined) {\n            continue;\n        }\n        if (candidate.ownerFormat !== dataFormat) {\n            throw new Error(\n                `tableProperties['${candidate.key}'] is set but dataFormat is '${dataFormat}'. `\n                + `That codec key only applies to '${candidate.ownerFormat}' tables.`,\n            );\n        }\n        if (!candidate.allowed.has(value)) {\n            throw new Error(\n                `tableProperties['${candidate.key}'] = '${value}' is not a valid ${candidate.ownerFormat} `\n                + `compression codec. Allowed: ${Array.from(candidate.allowed).sort().join(', ')}.`,\n            );\n        }\n    }\n}\n\nfunction validateEnumProperty(\n    properties: { [key: string]: string },\n    key: string,\n    allowed: ReadonlySet<string>,\n): void {\n    const value = properties[key];\n    if (value !== undefined && !allowed.has(value)) {\n        throw new Error(\n            `tableProperties['${key}'] = '${value}' is not valid. `\n            + `Allowed: ${Array.from(allowed).sort().join(', ')}.`,\n        );\n    }\n}\n\nfunction validatePositiveInt(\n    properties: { [key: string]: string },\n    key: string,\n): void {\n    const raw = properties[key];\n    if (raw === undefined) {\n        return;\n    }\n    if (!/^[0-9]+$/.test(raw) || Number(raw) < 1) {\n        throw new Error(\n            `tableProperties['${key}'] = '${raw}' must be a positive integer string.`,\n        );\n    }\n}\n"]}