feat(glue): add L2 resources for Database and Table

packages/@aws-cdk/aws-glue/README.md

@@ -1,2 +1,131 @@
 ## The CDK Construct Library for AWS Glue
 This module is part of the [AWS Cloud Development Kit](https://github.com/awslabs/aws-cdk) project.
+
+### Database
+
+A `Database` is a logical grouping of `Tables` in the Glue Catalog.
+
+```ts
+new glue.Database(stack, 'MyDatabase', {
+  databaseName: 'my_database'
+});
+```
+
+By default, a S3 bucket is created where the Database is stored under  `s3://<bucket-name>/`, but you can manually specify another location:
+
+```ts
+new glue.Database(stack, 'MyDatabase', {
+  databaseName: 'my_database',
+  locationUri: 's3://explicit-bucket/some-path/'
+});
+```
+
+### Table
+
+A Glue table describes the structure (column names and types), location of data (S3 objects with a common prefix in a S3 bucket) and format of the files (Json, Avro, Parquet, etc.):
+
+```ts
+new glue.Table(stack, 'MyTable', {
+  database: myDatabase,
+  tableName: 'my_table',
+  columns: [{
+    name: 'col1',
+    type: glue.Schema.string
+  }]
+  storageType: glue.StorageType.Json
+});
+```
+
+By default, a S3 bucket will created to store the table's data but you can manually pass the `bucket` and `prefix`:
+
+```ts
+new glue.Table(stack, 'MyTable', {
+  bucket: myBucket,
+  prefix: 'my-table/'
+  ...
+});
+```
+
+#### Partitions
+
+To improve query performance, a table can specify `partitionKeys` on which data is stored and queried separately. For example, you might partition a table by `year` and `month` to optimize queries based on a time window:
+
+```ts
+new glue.Table(stack, 'MyTable', {
+  database: myDatabase,
+  tableName: 'my_table',
+  columns: [{
+    name: 'col1',
+    type: glue.Schema.string
+  }],
+  partitionKeys: [{
+    name: 'year',
+    type: glue.Schema.smallint
+  }, {
+    name: 'month',
+    type: glue.Schema.smallint
+  }],
+  storageType: glue.StorageType.Json
+});
+```
+
+### [Encryption](https://docs.aws.amazon.com/athena/latest/ug/encryption.html)
+
+You can enable encryption on a S3 bucket:
+* [SSE-S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) - Server side encryption (SSE) with an Amazon S3-managed key.
+```ts
+new glue.Table(stack, 'MyTable', {
+  encryption: glue.TableEncryption.SSE_S3
+  ...
+});
+```
+* [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) - Server-side encryption (SSE) with a AWS Key Management Service customer managed key.
+
+```ts
+// with a KMS managed key
+new glue.Table(stack, 'MyTable', {
+  encryption: glue.TableEncryption.SSE_KMS
+  ...
+});
+
+// with a customer-managed KMS key
+new glue.Table(stack, 'MyTable', {
+  encryption: glue.TableEncryption.SSE_KMS,
+  encryptionKey: new kms.EncryptionKey(stack, 'MyKey')
+  ...
+});
+```
+
+### Types
+
+A table's schema is a collection of columns, each of which have a `name` and a `type`. Types are recursive structures, consisting of primitive and complex types:
+
+#### Primitive
+
+Numeric:
+* `bigint`
+* `float`
+* `integer`
+* `smallint`
+* `tinyint`
+
+Date and Time:
+* `date`
+* `timestamp`
+
+String Types:
+
+* `string`
+* `decimal`
+* `char`
+* `varchar`
+
+Misc:
+* `boolean`
+* `binary`
+
+#### Complex
+
+* `array` - array of some other type.
+* `map` - map of some primitive key type to any value type.
+* `struct` - nested structure containing individually named and typed columns.

packages/@aws-cdk/aws-glue/lib/database.ts

@@ -0,0 +1,143 @@
+import s3 = require('@aws-cdk/aws-s3');
+import cdk = require('@aws-cdk/cdk');
+import { CfnDatabase } from './glue.generated';
+
+export interface IDatabase extends cdk.IConstruct {
+  /**
+   * The ARN of the catalog.
+   */
+  readonly catalogArn: string;
+
+  /**
+   * The catalog id of the database (usually, the AWS account id)
+   */
+  readonly catalogId: string;
+
+  /**
+   * The ARN of the database.
+   */
+  readonly databaseArn: string;
+
+  /**
+   * The name of the database.
+   */
+  readonly databaseName: string;
+
+  /**
+   * The location of the database (for example, an HDFS path).
+   */
+  readonly locationUri: string;
+
+  export(): DatabaseImportProps;
+}
+
+export interface DatabaseImportProps {
+  catalogArn: string;
+  catalogId: string;
+  databaseArn: string;
+  databaseName: string;
+  locationUri: string;
+}
+
+export interface DatabaseProps {
+  /**
+   * The name of the database.
+   */
+  databaseName: string;
+
+  /**
+   * The location of the database (for example, an HDFS path).
+   *
+   * @default a bucket is created and the database is stored under s3://<bucket-name>/<database-name>
+   */
+  locationUri?: string;
+}
+
+/**
+ * A Glue database.
+ */
+export class Database extends cdk.Construct {
+  /**
+   * Creates a Database construct that represents an external database.
+   *
+   * @param scope The scope creating construct (usually `this`).
+   * @param id The construct's id.
+   * @param props A `DatabaseImportProps` object. Can be obtained from a call to `database.export()` or manually created.
+   */
+  public static import(scope: cdk.Construct, id: string, props: DatabaseImportProps): IDatabase {
+    return new ImportedDatabase(scope, id, props);
+  }
+
+  public readonly catalogArn: string;
+  public readonly catalogId: string;
+  public readonly databaseArn: string;
+  public readonly databaseName: string;
+  public readonly locationUri: string;
+
+  constructor(scope: cdk.Construct, id: string, props: DatabaseProps) {
+    super(scope, id);
+
+    if (props.locationUri) {
+      this.locationUri = props.locationUri;
+    } else {
+      const bucket = new s3.Bucket(this, 'Bucket');
+      this.locationUri = cdk.Fn.join('', ['s3://', bucket.bucketName, props.databaseName]);
+    }
+
+    this.catalogId = this.node.stack.accountId;
+    const resource = new CfnDatabase(this, 'Resource', {
+      catalogId: this.catalogId,
+      databaseInput: {
+        name: props.databaseName,
+        locationUri: this.locationUri
+      }
+    });
+
+    // see https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html#data-catalog-resource-arns
+    this.databaseName = resource.databaseName;
+    this.databaseArn = this.node.stack.formatArn({
+      service: 'glue',
+      resource: 'database',
+      resourceName: this.databaseName
+    });
+    // catalogId is implicitly the accountId, which is why we don't pass the catalogId here
+    this.catalogArn = this.node.stack.formatArn({
+      service: 'glue',
+      resource: 'catalog'
+    });
+  }
+
+  /**
+   * Exports this database from the stack.
+   */
+  public export(): DatabaseImportProps {
+    return {
+      catalogArn: new cdk.Output(this, 'CatalogArn', { value: this.catalogArn }).makeImportValue().toString(),
+      catalogId: new cdk.Output(this, 'CatalogId', { value: this.catalogId }).makeImportValue().toString(),
+      databaseArn: new cdk.Output(this, 'DatabaseArn', { value: this.databaseArn }).makeImportValue().toString(),
+      databaseName: new cdk.Output(this, 'DatabaseName', { value: this.databaseName }).makeImportValue().toString(),
+      locationUri: new cdk.Output(this, 'LocationURI', { value: this.locationUri }).makeImportValue().toString()
+    };
+  }
+}
+
+class ImportedDatabase extends cdk.Construct implements IDatabase {
+  public readonly catalogArn: string;
+  public readonly catalogId: string;
+  public readonly databaseArn: string;
+  public readonly databaseName: string;
+  public readonly locationUri: string;
+
+  constructor(parent: cdk.Construct, name: string, private readonly props: DatabaseImportProps) {
+    super(parent, name);
+    this.catalogArn = props.catalogArn;
+    this.catalogId = props.catalogId;
+    this.databaseArn = props.databaseArn;
+    this.databaseName = props.databaseName;
+    this.locationUri = props.locationUri;
+  }
+
+  public export() {
+    return this.props;
+  }
+}

packages/@aws-cdk/aws-glue/lib/index.ts

@@ -1,2 +1,7 @@
 // AWS::Glue CloudFormation Resources:
 export * from './glue.generated';
+
+export * from './database';
+export * from './schema';
+export * from './storage-type';
+export * from './table';