awscdkgluealpha

package module
v2.182.0-alpha.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 5, 2025 License: Apache-2.0 Imports: 16 Imported by: 1

README

AWS Glue Construct Library

---

The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.

This module is part of the AWS Cloud Development Kit project.

README

AWS Glue is a serverless data integration service that makes it easier to discover, prepare, move, and integrate data from multiple sources for analytics, machine learning (ML), and application development.

The Glue L2 construct has convenience methods working backwards from common use cases and sets required parameters to defaults that align with recommended best practices for each job type. It also provides customers with a balance between flexibility via optional parameter overrides, and opinionated interfaces that discouraging anti-patterns, resulting in reduced time to develop and deploy new resources.

References

Create a Glue Job

A Job encapsulates a script that connects to data sources, processes them, and then writes output to a data target. There are four types of Glue Jobs: Spark (ETL and Streaming), Python Shell, Ray, and Flex Jobs. Most of the required parameters for these jobs are common across all types, but there are a few differences depending on the languages supported and features provided by each type. For all job types, the L2 defaults to AWS best practice recommendations, such as:

  • Use of Secrets Manager for Connection JDBC strings
  • Glue job autoscaling
  • Default parameter values for Glue job creation

This iteration of the L2 construct introduces breaking changes to the existing glue-alpha-module, but these changes streamline the developer experience, introduce new constants for defaults, and replacing synth-time validations with interface contracts for enforcement of the parameter combinations that Glue supports. As an opinionated construct, the Glue L2 construct does not allow developers to create resources that use non-current versions of Glue or deprecated language dependencies (e.g. deprecated versions of Python). As always, L1s allow you to specify a wider range of parameters if you need or want to use alternative configurations.

Optional and required parameters for each job are enforced via interface rather than validation; see Glue's public documentation for more granular details.

Spark Jobs
  1. ETL Jobs

ETL jobs support pySpark and Scala languages, for which there are separate but similar constructors. ETL jobs default to the G2 worker type, but you can override this default with other supported worker type values (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can override to 3.0. The following ETL features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log. You can find more details about version, worker type and other features in Glue's public documentation.

Reference the pyspark-etl-jobs.test.ts and scalaspark-etl-jobs.test.ts unit tests for examples of required-only and optional job parameters when creating these types of jobs.

For the sake of brevity, examples are shown using the pySpark job variety.

Example with only required parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("PySparkETLJob"),
})

Example with optional override parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	JobName: jsii.String("PySparkETLJobCustomName"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

Streaming Jobs

Streaming jobs are similar to ETL jobs, except that they perform ETL on data streams using the Apache Spark Structured Streaming framework. Some Spark job features are not available to Streaming ETL jobs. They support Scala and pySpark languages. PySpark streaming jobs default Python 3.9, which you can override with any non-deprecated version of Python. It defaults to the G2 worker type and Glue 4.0, both of which you can override. The following best practice features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.

Reference the pyspark-streaming-jobs.test.ts and scalaspark-streaming-jobs.test.ts unit tests for examples of required-only and optional job parameters when creating these types of jobs.

Example with only required parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkStreamingJob(stack, jsii.String("ImportedJob"), &PySparkStreamingJobProps{
	Role: Role,
	Script: Script,
})

Example with optional override parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkStreamingJob(stack, jsii.String("PySparkStreamingJob"), &PySparkStreamingJobProps{
	JobName: jsii.String("PySparkStreamingJobCustomName"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

Flex Jobs

The flexible execution class is appropriate for non-urgent jobs such as pre-production jobs, testing, and one-time data loads. Flexible jobs default to Glue version 3.0 and worker type G_2X. The following best practice features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log

Reference the pyspark-flex-etl-jobs.test.ts and scalaspark-flex-etl-jobs.test.ts unit tests for examples of required-only and optional job parameters when creating these types of jobs.

Example with only required parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkFlexEtlJob(stack, jsii.String("ImportedJob"), &PySparkFlexEtlJobProps{
	Role: Role,
	Script: Script,
})

Example with optional override parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("pySparkEtlJob"), &PySparkEtlJobProps{
	JobName: jsii.String("pySparkEtlJob"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})
Python Shell Jobs

Python shell jobs support a Python version that depends on the AWS Glue version you use. These can be used to schedule and run tasks that don't require an Apache Spark environment. Python shell jobs default to Python 3.9 and a MaxCapacity of 0.0625. Python 3.9 supports pre-loaded analytics libraries using the library-set=analytics flag, which is enabled by default.

Reference the pyspark-shell-job.test.ts unit tests for examples of required-only and optional job parameters when creating these types of jobs.

Example with only required parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("ImportedJob"), &PythonShellJobProps{
	Role: Role,
	Script: Script,
})

Example with optional override parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("PythonShellJob"), &PythonShellJobProps{
	JobName: jsii.String("PythonShellJobCustomName"),
	Description: jsii.String("This is a description"),
	PythonVersion: glue.PythonVersion_TWO,
	MaxCapacity: glue.MaxCapacity_DPU_1,
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V2_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})
Ray Jobs

Glue Ray jobs use worker type Z.2X and Glue version 4.0. These are not overrideable since these are the only configuration that Glue Ray jobs currently support. The runtime defaults to Ray2.4 and min workers defaults to 3.

Reference the ray-job.test.ts unit tests for examples of required-only and optional job parameters when creating these types of jobs.

Example with only required parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
})

Example with optional override parameters:

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("RayCustomJobName"),
	Description: jsii.String("This is a description"),
	WorkerType: glue.WorkerType_Z_2X,
	NumberOfWorkers: jsii.Number(5),
	Runtime: glue.Runtime_RAY_TWO_FOUR,
	MaxRetries: jsii.Number(3),
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
})
Enable Job Run Queuing

AWS Glue job queuing monitors your account level quotas and limits. If quotas or limits are insufficient to start a Glue job run, AWS Glue will automatically queue the job and wait for limits to free up. Once limits become available, AWS Glue will retry the job run. Glue jobs will queue for limits like max concurrent job runs per account, max concurrent Data Processing Units (DPU), and resource unavailable due to IP address exhaustion in Amazon Virtual Private Cloud (Amazon VPC).

Enable job run queuing by setting the jobRunQueuingEnabled property to true.

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("PySparkETLJob"),
	JobRunQueuingEnabled: jsii.Boolean(true),
})
Uploading scripts from the CDK app repository to S3

Similar to other L2 constructs, the Glue L2 automates uploading / updating scripts to S3 via an optional fromAsset parameter pointing to a script in the local file structure. You provide the existing S3 bucket and path to which you'd like the script to be uploaded.

Reference the unit tests for examples of repo and S3 code target examples.

Workflow Triggers

You can use Glue workflows to create and visualize complex extract, transform, and load (ETL) activities involving multiple crawlers, jobs, and triggers. Standalone triggers are an anti-pattern, so you must create triggers from within a workflow using the L2 construct.

Within a workflow object, there are functions to create different types of triggers with actions and predicates. You then add those triggers to jobs.

StartOnCreation defaults to true for all trigger types, but you can override it if you prefer for your trigger not to start on creation.

Reference the workflow-triggers.test.ts unit tests for examples of creating workflows and triggers.

  1. On-Demand Triggers

On-demand triggers can start glue jobs or crawlers. This construct provides convenience functions to create on-demand crawler or job triggers. The constructor takes an optional description parameter, but abstracts the requirement of an actions list using the job or crawler objects using conditional types.

  1. Scheduled Triggers

You can create scheduled triggers using cron expressions. This construct provides daily, weekly, and monthly convenience functions, as well as a custom function that allows you to create your own custom timing using the existing event Schedule class without having to build your own cron expressions. The L2 extracts the expression that Glue requires from the Schedule object. The constructor takes an optional description and a list of jobs or crawlers as actions.

3. Notify Event Triggers

There are two types of notify event triggers: batching and non-batching. For batching triggers, you must specify BatchSize. For non-batching triggers, BatchSize defaults to 1. For both triggers, BatchWindow defaults to 900 seconds, but you can override the window to align with your workload's requirements.

4. Conditional Triggers

Conditional triggers have a predicate and actions associated with them. The trigger actions are executed when the predicateCondition is true.

Connection Properties

A Connection allows Glue jobs, crawlers and development endpoints to access certain types of data stores.

***Secrets Management **You must specify JDBC connection credentials in Secrets Manager and provide the Secrets Manager Key name as a property to the job connection.

  • **Networking - the CDK determines the best fit subnet for Glue connection configuration **The prior version of the glue-alpha-module requires the developer to specify the subnet of the Connection when it’s defined. Now, you can still specify the specific subnet you want to use, but are no longer required to. You are only required to provide a VPC and either a public or private subnet selection. Without a specific subnet provided, the L2 leverages the existing EC2 Subnet Selection library to make the best choice selection for the subnet.
var securityGroup securityGroup
var subnet subnet

glue.NewConnection(this, jsii.String("MyConnection"), &ConnectionProps{
	Type: glue.ConnectionType_NETWORK(),
	// The security groups granting AWS Glue inbound access to the data source within the VPC
	SecurityGroups: []iSecurityGroup{
		securityGroup,
	},
	// The VPC subnet which contains the data source
	Subnet: Subnet,
})

For RDS Connection by JDBC, it is recommended to manage credentials using AWS Secrets Manager. To use Secret, specify SECRET_ID in properties like the following code. Note that in this case, the subnet must have a route to the AWS Secrets Manager VPC endpoint or to the AWS Secrets Manager endpoint through a NAT gateway.

var securityGroup securityGroup
var subnet subnet
var db databaseCluster

glue.NewConnection(this, jsii.String("RdsConnection"), &ConnectionProps{
	Type: glue.ConnectionType_JDBC(),
	SecurityGroups: []iSecurityGroup{
		securityGroup,
	},
	Subnet: Subnet,
	Properties: map[string]*string{
		"JDBC_CONNECTION_URL": fmt.Sprintf("jdbc:mysql://%v/databasename", db.clusterEndpoint.socketAddress),
		"JDBC_ENFORCE_SSL": jsii.String("false"),
		"SECRET_ID": db.secret.secretName,
	},
})

If you need to use a connection type that doesn't exist as a static member on ConnectionType, you can instantiate a ConnectionType object, e.g: new glue.ConnectionType('NEW_TYPE').

See Adding a Connection to Your Data Store and Connection Structure documentation for more information on the supported data stores and their configurations.

SecurityConfiguration

A SecurityConfiguration is a set of security properties that can be used by AWS Glue to encrypt data at rest.

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

By default, a shared KMS key is created for use with the encryption configurations that require one. You can also supply your own key for each encryption config, for example, for CloudWatch encryption:

var key key

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
		KmsKey: key,
	},
})

See documentation for more info for Glue encrypting data written by Crawlers, Jobs, and Development Endpoints.

Database

A Database is a logical grouping of Tables in the Glue Catalog.

glue.NewDatabase(this, jsii.String("MyDatabase"), &DatabaseProps{
	DatabaseName: jsii.String("my_database"),
	Description: jsii.String("my_database_description"),
})

Table

A Glue table describes a table of data in S3: its structure (column names and types), location of data (S3 objects with a common prefix in a S3 bucket), and format for the files (Json, Avro, Parquet, etc.):

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
		&column{
			Name: jsii.String("col2"),
			Type: glue.Schema_Array(glue.Schema_STRING()),
			Comment: jsii.String("col2 is an array of strings"),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

By default, a S3 bucket will be created to store the table's data but you can manually pass the bucket and s3Prefix:

var myBucket bucket
var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Bucket: myBucket,
	S3Prefix: jsii.String("my-table/"),
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Glue tables can be configured to contain user-defined properties, to describe the physical storage of table data, through the storageParameters property:

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	StorageParameters: []storageParameter{
		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
		glue.*storageParameter_Custom(jsii.String("separatorChar"), jsii.String(",")),
	},
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Glue tables can also be configured to contain user-defined table properties through the parameters property:

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Parameters: map[string]*string{
		"key1": jsii.String("val1"),
		"key2": jsii.String("val2"),
	},
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})
Partition Keys

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:

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})
Partition Indexes

Another way to improve query performance is to specify partition indexes. If no partition indexes are present on the table, AWS Glue loads all partitions of the table and filters the loaded partitions using the query expression. The query takes more time to run as the number of partitions increase. With an index, the query will try to fetch a subset of the partitions instead of loading all partitions of the table.

The keys of a partition index must be a subset of the partition keys of the table. You can have a maximum of 3 partition indexes per table. To specify a partition index, you can use the partitionIndexes property:

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	PartitionIndexes: []partitionIndex{
		&partitionIndex{
			IndexName: jsii.String("my-index"),
			 // optional
			KeyNames: []*string{
				jsii.String("year"),
			},
		},
	},
	 // supply up to 3 indexes
	DataFormat: glue.DataFormat_JSON(),
})

Alternatively, you can call the addPartitionIndex() function on a table:

var myTable table

myTable.AddPartitionIndex(&PartitionIndex{
	IndexName: jsii.String("my-index"),
	KeyNames: []*string{
		jsii.String("year"),
	},
})
Partition Filtering

If you have a table with a large number of partitions that grows over time, consider using AWS Glue partition indexing and filtering.

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
	EnablePartitionFiltering: jsii.Boolean(true),
})
Glue Connections

Glue connections allow external data connections to third party databases and data warehouses. However, these connections can also be assigned to Glue Tables, allowing you to query external data sources using the Glue Data Catalog.

Whereas S3Table will point to (and if needed, create) a bucket to store the tables' data, ExternalTable will point to an existing table in a data source. For example, to create a table in Glue that points to a table in Redshift:

var myConnection connection
var myDatabase database

glue.NewExternalTable(this, jsii.String("MyTable"), &ExternalTableProps{
	Connection: myConnection,
	ExternalDataLocation: jsii.String("default_db_public_example"),
	 // A table in Redshift
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Encryption

You can enable encryption on a Table's data:

  • S3Managed - (default) Server side encryption (SSE-S3) with an Amazon S3-managed key.
var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_S3_MANAGED,
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})
  • Kms - Server-side encryption (SSE-KMS) with an AWS KMS Key managed by the account owner.
var myDatabase database

// KMS key is created automatically
// KMS key is created automatically
glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_KMS,
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

// with an explicit KMS key
// with an explicit KMS key
glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_KMS,
	EncryptionKey: kms.NewKey(this, jsii.String("MyKey")),
	// ...
	Database: myDatabase,
	Columns: []*column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})
  • KmsManaged - Server-side encryption (SSE-KMS), like Kms, except with an AWS KMS Key managed by the AWS Key Management Service.
var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_KMS_MANAGED,
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})
  • ClientSideKms - Client-side encryption (CSE-KMS) with an AWS KMS Key managed by the account owner.
var myDatabase database

// KMS key is created automatically
// KMS key is created automatically
glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_CLIENT_SIDE_KMS,
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

// with an explicit KMS key
// with an explicit KMS key
glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_CLIENT_SIDE_KMS,
	EncryptionKey: kms.NewKey(this, jsii.String("MyKey")),
	// ...
	Database: myDatabase,
	Columns: []*column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Note: you cannot provide a Bucket when creating the S3Table if you wish to use server-side encryption (KMS, KMS_MANAGED or S3_MANAGED).

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:

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Columns: []column{
		&column{
			Name: jsii.String("primitive_column"),
			Type: glue.Schema_STRING(),
		},
		&column{
			Name: jsii.String("array_column"),
			Type: glue.Schema_Array(glue.Schema_INTEGER()),
			Comment: jsii.String("array<integer>"),
		},
		&column{
			Name: jsii.String("map_column"),
			Type: glue.Schema_Map(glue.Schema_STRING(), glue.Schema_TIMESTAMP()),
			Comment: jsii.String("map<string,string>"),
		},
		&column{
			Name: jsii.String("struct_column"),
			Type: glue.Schema_Struct([]*column{
				&column{
					Name: jsii.String("nested_column"),
					Type: glue.Schema_DATE(),
					Comment: jsii.String("nested comment"),
				},
			}),
			Comment: jsii.String("struct<nested_column:date COMMENT 'nested comment'>"),
		},
	},
	// ...
	Database: myDatabase,
	DataFormat: glue.DataFormat_JSON(),
})

Public FAQ

What are we launching today?

We’re launching new features to an AWS CDK Glue L2 Construct to provide best-practice defaults and convenience methods to create Glue Jobs, Connections, Triggers, Workflows, and the underlying permissions and configuration.

Why should I use this Construct?

Developers should use this Construct to reduce the amount of boilerplate code and complexity each individual has to navigate, and make it easier to create best-practice Glue resources.

What’s not in scope?

Glue Crawlers and other resources that are now managed by the AWS LakeFormation team are not in scope for this effort. Developers should use existing methods to create these resources, and the new Glue L2 construct assumes they already exist as inputs. While best practice is for application and infrastructure code to be as close as possible for teams using fully-implemented DevOps mechanisms, in practice these ETL scripts are likely managed by a data science team who know Python or Scala and don’t necessarily own or manage their own infrastructure deployments. We want to meet developers where they are, and not assume that all of the code resides in the same repository, Developers can automate this themselves via the CDK, however, if they do own both.

Validating Glue version and feature use per AWS region at synth time is also not in scope. AWS’ intention is for all features to eventually be propagated to all Global regions, so the complexity involved in creating and updating region- specific configuration to match shifting feature sets does not out-weigh the likelihood that a developer will use this construct to deploy resources to a region without a particular new feature to a region that doesn’t yet support it without researching or manually attempting to use that feature before developing it via IaC. The developer will, of course, still get feedback from the underlying Glue APIs as CloudFormation deploys the resources similar to the current CDK L1 Glue experience.

Documentation

Overview

The CDK Construct Library for AWS::Glue

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Connection_IsConstruct 

func Connection_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func Connection_IsOwnedResource 

func Connection_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func Connection_IsResource 

func Connection_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func DataQualityRuleset_IsConstruct 

func DataQualityRuleset_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func DataQualityRuleset_IsOwnedResource 

func DataQualityRuleset_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func DataQualityRuleset_IsResource 

func DataQualityRuleset_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func Database_IsConstruct 

func Database_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func Database_IsOwnedResource 

func Database_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func Database_IsResource 

func Database_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func ExternalTable_IsConstruct 

func ExternalTable_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ExternalTable_IsOwnedResource 

func ExternalTable_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ExternalTable_IsResource 

func ExternalTable_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func JobBase_IsConstruct 

func JobBase_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func JobBase_IsOwnedResource 

func JobBase_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func JobBase_IsResource 

func JobBase_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func Job_IsConstruct 

func Job_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func Job_IsOwnedResource 

func Job_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func Job_IsResource 

func Job_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func NewAssetCode_Override 

func NewAssetCode_Override(a AssetCode, path *string, options *awss3assets.AssetOptions)

Experimental.

func NewClassificationString_Override 

func NewClassificationString_Override(c ClassificationString, value *string)

Experimental.

func NewCode_Override 

func NewCode_Override(c Code)

Experimental.

func NewConnectionType_Override 

func NewConnectionType_Override(c ConnectionType, name *string)

Experimental.

func NewConnection_Override 

func NewConnection_Override(c Connection, scope constructs.Construct, id *string, props *ConnectionProps)

Experimental.

func NewDataFormat_Override 

func NewDataFormat_Override(d DataFormat, props *DataFormatProps)

Experimental.

func NewDataQualityRuleset_Override 

func NewDataQualityRuleset_Override(d DataQualityRuleset, scope constructs.Construct, id *string, props *DataQualityRulesetProps)

Experimental.

func NewDataQualityTargetTable_Override 

func NewDataQualityTargetTable_Override(d DataQualityTargetTable, databaseName *string, tableName *string)

Experimental.

func NewDatabase_Override 

func NewDatabase_Override(d Database, scope constructs.Construct, id *string, props *DatabaseProps)

Experimental.

func NewExternalTable_Override 

func NewExternalTable_Override(e ExternalTable, scope constructs.Construct, id *string, props *ExternalTableProps)

Experimental.

func NewInputFormat_Override 

func NewInputFormat_Override(i InputFormat, className *string)

Experimental.

func NewJobBase_Override 

func NewJobBase_Override(j JobBase, scope constructs.Construct, id *string, props *awscdk.ResourceProps)

Experimental.

func NewJob_Override 

func NewJob_Override(j Job, scope constructs.Construct, id *string, props *awscdk.ResourceProps)

Experimental.

func NewOutputFormat_Override 

func NewOutputFormat_Override(o OutputFormat, className *string)

Experimental.

func NewPySparkEtlJob_Override 

func NewPySparkEtlJob_Override(p PySparkEtlJob, scope constructs.Construct, id *string, props *PySparkEtlJobProps)

PySparkEtlJob constructor. Experimental.

func NewPySparkFlexEtlJob_Override 

func NewPySparkFlexEtlJob_Override(p PySparkFlexEtlJob, scope constructs.Construct, id *string, props *PySparkFlexEtlJobProps)

PySparkFlexEtlJob constructor. Experimental.

func NewPySparkStreamingJob_Override 

func NewPySparkStreamingJob_Override(p PySparkStreamingJob, scope constructs.Construct, id *string, props *PySparkStreamingJobProps)

PySparkStreamingJob constructor. Experimental.

func NewPythonShellJob_Override 

func NewPythonShellJob_Override(p PythonShellJob, scope constructs.Construct, id *string, props *PythonShellJobProps)

PythonShellJob constructor. Experimental.

func NewRayJob_Override 

func NewRayJob_Override(r RayJob, scope constructs.Construct, id *string, props *RayJobProps)

RayJob constructor. Experimental.

func NewS3Code_Override 

func NewS3Code_Override(s S3Code, bucket awss3.IBucket, key *string)

Experimental.

func NewS3Table_Override 

func NewS3Table_Override(s S3Table, scope constructs.Construct, id *string, props *S3TableProps)

Experimental.

func NewScalaSparkEtlJob_Override 

func NewScalaSparkEtlJob_Override(s ScalaSparkEtlJob, scope constructs.Construct, id *string, props *ScalaSparkEtlJobProps)

ScalaSparkEtlJob constructor. Experimental.

func NewScalaSparkFlexEtlJob_Override 

func NewScalaSparkFlexEtlJob_Override(s ScalaSparkFlexEtlJob, scope constructs.Construct, id *string, props *ScalaSparkFlexEtlJobProps)

ScalaSparkFlexEtlJob constructor. Experimental.

func NewScalaSparkStreamingJob_Override 

func NewScalaSparkStreamingJob_Override(s ScalaSparkStreamingJob, scope constructs.Construct, id *string, props *ScalaSparkStreamingJobProps)

ScalaSparkStreamingJob constructor. Experimental.

func NewSchema_Override 

func NewSchema_Override(s Schema)

Experimental.

func NewSecurityConfiguration_Override 

func NewSecurityConfiguration_Override(s SecurityConfiguration, scope constructs.Construct, id *string, props *SecurityConfigurationProps)

Experimental.

func NewSerializationLibrary_Override 

func NewSerializationLibrary_Override(s SerializationLibrary, className *string)

Experimental.

func NewStorageParameter_Override 

func NewStorageParameter_Override(s StorageParameter, key *string, value *string)

Experimental.

func NewTableBase_Override 

func NewTableBase_Override(t TableBase, scope constructs.Construct, id *string, props *TableBaseProps)

Experimental.

func NewTable_Override deprecated 

func NewTable_Override(t Table, scope constructs.Construct, id *string, props *S3TableProps)

Deprecated: Use {@link S3Table } instead.

func NewWorkflowBase_Override 

func NewWorkflowBase_Override(w WorkflowBase, scope constructs.Construct, id *string, props *awscdk.ResourceProps)

Experimental.

func NewWorkflow_Override 

func NewWorkflow_Override(w Workflow, scope constructs.Construct, id *string, props *WorkflowProps)

Experimental.

func PySparkEtlJob_IsConstruct 

func PySparkEtlJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func PySparkEtlJob_IsOwnedResource 

func PySparkEtlJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func PySparkEtlJob_IsResource 

func PySparkEtlJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func PySparkFlexEtlJob_IsConstruct 

func PySparkFlexEtlJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func PySparkFlexEtlJob_IsOwnedResource 

func PySparkFlexEtlJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func PySparkFlexEtlJob_IsResource 

func PySparkFlexEtlJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func PySparkStreamingJob_IsConstruct 

func PySparkStreamingJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func PySparkStreamingJob_IsOwnedResource 

func PySparkStreamingJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func PySparkStreamingJob_IsResource 

func PySparkStreamingJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func PythonShellJob_IsConstruct 

func PythonShellJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func PythonShellJob_IsOwnedResource 

func PythonShellJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func PythonShellJob_IsResource 

func PythonShellJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func RayJob_IsConstruct 

func RayJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func RayJob_IsOwnedResource 

func RayJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func RayJob_IsResource 

func RayJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func S3Table_IsConstruct 

func S3Table_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func S3Table_IsOwnedResource 

func S3Table_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func S3Table_IsResource 

func S3Table_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func ScalaSparkEtlJob_IsConstruct 

func ScalaSparkEtlJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ScalaSparkEtlJob_IsOwnedResource 

func ScalaSparkEtlJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ScalaSparkEtlJob_IsResource 

func ScalaSparkEtlJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func ScalaSparkFlexEtlJob_IsConstruct 

func ScalaSparkFlexEtlJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ScalaSparkFlexEtlJob_IsOwnedResource 

func ScalaSparkFlexEtlJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ScalaSparkFlexEtlJob_IsResource 

func ScalaSparkFlexEtlJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func ScalaSparkStreamingJob_IsConstruct 

func ScalaSparkStreamingJob_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ScalaSparkStreamingJob_IsOwnedResource 

func ScalaSparkStreamingJob_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ScalaSparkStreamingJob_IsResource 

func ScalaSparkStreamingJob_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func SecurityConfiguration_IsConstruct 

func SecurityConfiguration_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func SecurityConfiguration_IsOwnedResource 

func SecurityConfiguration_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func SecurityConfiguration_IsResource 

func SecurityConfiguration_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func TableBase_IsConstruct 

func TableBase_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func TableBase_IsOwnedResource 

func TableBase_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func TableBase_IsResource 

func TableBase_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func Table_IsConstruct 

func Table_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Deprecated: Use {@link S3Table } instead.

func Table_IsOwnedResource 

func Table_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Deprecated: Use {@link S3Table } instead.

func Table_IsResource 

func Table_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Deprecated: Use {@link S3Table } instead.

func WorkflowBase_ExtractNameFromArn 

func WorkflowBase_ExtractNameFromArn(scope constructs.Construct, workflowArn *string) *string

Extract workflowName from arn. Experimental.

func WorkflowBase_IsConstruct 

func WorkflowBase_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func WorkflowBase_IsOwnedResource 

func WorkflowBase_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func WorkflowBase_IsResource 

func WorkflowBase_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func Workflow_ExtractNameFromArn 

func Workflow_ExtractNameFromArn(scope constructs.Construct, workflowArn *string) *string

Extract workflowName from arn. Experimental.

func Workflow_IsConstruct 

func Workflow_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func Workflow_IsOwnedResource 

func Workflow_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func Workflow_IsResource 

func Workflow_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

Types

type Action 

type Action struct {
	// The job arguments used when this trigger fires.
	// Default: - no arguments are passed to the job.
	//
	// Experimental.
	Arguments *map[string]*string `field:"optional" json:"arguments" yaml:"arguments"`
	// The name of the crawler to be used with this action.
	// Default: - no crawler is used.
	//
	// Experimental.
	Crawler awsglue.CfnCrawler `field:"optional" json:"crawler" yaml:"crawler"`
	// The job to be executed.
	// Default: - no job is executed.
	//
	// Experimental.
	Job IJob `field:"optional" json:"job" yaml:"job"`
	// The `SecurityConfiguration` to be used with this action.
	// Default: - no security configuration is used.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// The job run timeout.
	//
	// This is the maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	// Default: - the default timeout value set in the job definition.
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
}

Represents a trigger action.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

action := &Action{
	Arguments: map[string]*string{
		"argumentsKey": jsii.String("arguments"),
	},
	Crawler: cfnCrawler,
	Job: job,
	SecurityConfiguration: securityConfiguration,
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
}

Experimental.

type AssetCode 

type AssetCode interface {
	Code
	// Called when the Job is initialized to allow this object to bind.
	// Experimental.
	Bind(scope constructs.Construct, grantable awsiam.IGrantable) *CodeConfig
}

Job Code from a local file.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var dockerImage dockerImage
var grantable iGrantable
var key key
var localBundling iLocalBundling

assetCode := glue_alpha.NewAssetCode(jsii.String("path"), &AssetOptions{
	AssetHash: jsii.String("assetHash"),
	AssetHashType: cdk.AssetHashType_SOURCE,
	Bundling: &BundlingOptions{
		Image: dockerImage,

		// the properties below are optional
		BundlingFileAccess: cdk.BundlingFileAccess_VOLUME_COPY,
		Command: []*string{
			jsii.String("command"),
		},
		Entrypoint: []*string{
			jsii.String("entrypoint"),
		},
		Environment: map[string]*string{
			"environmentKey": jsii.String("environment"),
		},
		Local: localBundling,
		Network: jsii.String("network"),
		OutputType: cdk.BundlingOutput_ARCHIVED,
		Platform: jsii.String("platform"),
		SecurityOpt: jsii.String("securityOpt"),
		User: jsii.String("user"),
		Volumes: []dockerVolume{
			&dockerVolume{
				ContainerPath: jsii.String("containerPath"),
				HostPath: jsii.String("hostPath"),

				// the properties below are optional
				Consistency: cdk.DockerVolumeConsistency_CONSISTENT,
			},
		},
		VolumesFrom: []*string{
			jsii.String("volumesFrom"),
		},
		WorkingDirectory: jsii.String("workingDirectory"),
	},
	DeployTime: jsii.Boolean(false),
	Exclude: []*string{
		jsii.String("exclude"),
	},
	FollowSymlinks: cdk.SymlinkFollowMode_NEVER,
	IgnoreMode: cdk.IgnoreMode_GLOB,
	Readers: []*iGrantable{
		grantable,
	},
	SourceKMSKey: key,
})

Experimental.

func AssetCode_FromAsset 

func AssetCode_FromAsset(path *string, options *awss3assets.AssetOptions) AssetCode

Job code from a local disk path. Experimental.

func Code_FromAsset 

func Code_FromAsset(path *string, options *awss3assets.AssetOptions) AssetCode

Job code from a local disk path. Experimental.

func NewAssetCode 

func NewAssetCode(path *string, options *awss3assets.AssetOptions) AssetCode

Experimental.

func S3Code_FromAsset 

func S3Code_FromAsset(path *string, options *awss3assets.AssetOptions) AssetCode

Job code from a local disk path. Experimental.

type ClassificationString 

type ClassificationString interface {
	// Experimental.
	Value() *string
}

Classification string given to tables with this data format.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

classificationString := glue_alpha.ClassificationString_AVRO()

See: https://docs.aws.amazon.com/glue/latest/dg/add-classifier.html#classifier-built-in

Experimental.

func ClassificationString_AVRO 

func ClassificationString_AVRO() ClassificationString

func ClassificationString_CSV 

func ClassificationString_CSV() ClassificationString

func ClassificationString_JSON 

func ClassificationString_JSON() ClassificationString

func ClassificationString_ORC 

func ClassificationString_ORC() ClassificationString

func ClassificationString_PARQUET 

func ClassificationString_PARQUET() ClassificationString

func ClassificationString_XML 

func ClassificationString_XML() ClassificationString

func NewClassificationString 

func NewClassificationString(value *string) ClassificationString

Experimental.

type CloudWatchEncryption 

type CloudWatchEncryption struct {
	// Encryption mode.
	// Experimental.
	Mode CloudWatchEncryptionMode `field:"required" json:"mode" yaml:"mode"`
	// The KMS key to be used to encrypt the data.
	// Default: A key will be created if one is not provided.
	//
	// Experimental.
	KmsKey awskms.IKey `field:"optional" json:"kmsKey" yaml:"kmsKey"`
}

CloudWatch Logs encryption configuration.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

Experimental.

type CloudWatchEncryptionMode 

type CloudWatchEncryptionMode string

Encryption mode for CloudWatch Logs.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

See: https://docs.aws.amazon.com/glue/latest/webapi/API_CloudWatchEncryption.html#Glue-Type-CloudWatchEncryption-CloudWatchEncryptionMode

Experimental. 

const (
	// Server-side encryption (SSE) with an AWS KMS key managed by the account owner.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
	//
	// Experimental.
	CloudWatchEncryptionMode_KMS CloudWatchEncryptionMode = "KMS"
)

type Code 

type Code interface {
	// Called when the Job is initialized to allow this object to bind.
	// Experimental.
	Bind(scope constructs.Construct, grantable awsiam.IGrantable) *CodeConfig
}

Represents a Glue Job's Code assets (an asset can be a scripts, a jar, a python file or any other file).

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("PySparkETLJob"),
	JobRunQueuingEnabled: jsii.Boolean(true),
})

Experimental.

type CodeConfig 

type CodeConfig struct {
	// The location of the code in S3.
	// Experimental.
	S3Location *awss3.Location `field:"required" json:"s3Location" yaml:"s3Location"`
}

Result of binding `Code` into a `Job`.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

codeConfig := &CodeConfig{
	S3Location: &Location{
		BucketName: jsii.String("bucketName"),
		ObjectKey: jsii.String("objectKey"),

		// the properties below are optional
		ObjectVersion: jsii.String("objectVersion"),
	},
}

Experimental.

type Column 

type Column struct {
	// Name of the column.
	// Experimental.
	Name *string `field:"required" json:"name" yaml:"name"`
	// Type of the column.
	// Experimental.
	Type *Type `field:"required" json:"type" yaml:"type"`
	// Coment describing the column.
	// Default: none.
	//
	// Experimental.
	Comment *string `field:"optional" json:"comment" yaml:"comment"`
}

A column of a table.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

column := &Column{
	Name: jsii.String("name"),
	Type: &Type{
		InputString: jsii.String("inputString"),
		IsPrimitive: jsii.Boolean(false),
	},

	// the properties below are optional
	Comment: jsii.String("comment"),
}

Experimental.

type ColumnCountMismatchHandlingAction 

type ColumnCountMismatchHandlingAction string

Identifies if the file contains less or more values for a row than the number of columns specified in the external table definition.

This property is only available for an uncompressed text file format. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"column_count_mismatch_handling"_

Experimental. 

const (
	// Column count mismatch handling is turned off.
	// Experimental.
	ColumnCountMismatchHandlingAction_DISABLED ColumnCountMismatchHandlingAction = "DISABLED"
	// Fail the query if the column count mismatch is detected.
	// Experimental.
	ColumnCountMismatchHandlingAction_FAIL ColumnCountMismatchHandlingAction = "FAIL"
	// Fill missing values with NULL and ignore the additional values in each row.
	// Experimental.
	ColumnCountMismatchHandlingAction_SET_TO_NULL ColumnCountMismatchHandlingAction = "SET_TO_NULL"
	// Drop all rows that contain column count mismatch error from the scan.
	// Experimental.
	ColumnCountMismatchHandlingAction_DROP_ROW ColumnCountMismatchHandlingAction = "DROP_ROW"
)

type CompressionType 

type CompressionType string

The compression type.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	StorageParameters: []storageParameter{
		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
		glue.*storageParameter_Custom(jsii.String("separatorChar"), jsii.String(",")),
	},
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"compression_type"_

Experimental. 

const (
	// No compression.
	// Experimental.
	CompressionType_NONE CompressionType = "NONE"
	// Burrows-Wheeler compression.
	// Experimental.
	CompressionType_BZIP2 CompressionType = "BZIP2"
	// Deflate compression.
	// Experimental.
	CompressionType_GZIP CompressionType = "GZIP"
	// Compression algorithm focused on high compression and decompression speeds, rather than the maximum possible compression.
	// Experimental.
	CompressionType_SNAPPY CompressionType = "SNAPPY"
)

type Condition 

type Condition struct {
	// The name of the crawler to which this condition applies.
	// Default: - no crawler is specified.
	//
	// Experimental.
	CrawlerName *string `field:"optional" json:"crawlerName" yaml:"crawlerName"`
	// The condition crawler state.
	// Default: - no crawler state is specified.
	//
	// Experimental.
	CrawlState CrawlerState `field:"optional" json:"crawlState" yaml:"crawlState"`
	// The job to which this condition applies.
	// Default: - no job is specified.
	//
	// Experimental.
	Job IJob `field:"optional" json:"job" yaml:"job"`
	// The logical operator for the condition.
	// Default: ConditionLogicalOperator.EQUALS
	//
	// Experimental.
	LogicalOperator ConditionLogicalOperator `field:"optional" json:"logicalOperator" yaml:"logicalOperator"`
	// The condition job state.
	// Default: - no job state is specified.
	//
	// Experimental.
	State JobState `field:"optional" json:"state" yaml:"state"`
}

Represents a trigger condition.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"

var job job

condition := &Condition{
	CrawlerName: jsii.String("crawlerName"),
	CrawlState: glue_alpha.CrawlerState_RUNNING,
	Job: job,
	LogicalOperator: glue_alpha.ConditionLogicalOperator_EQUALS,
	State: glue_alpha.JobState_SUCCEEDED,
}

Experimental.

type ConditionLogicalOperator 

type ConditionLogicalOperator string

Represents the logical operator for evaluating a single condition in the Glue Trigger API. Experimental. 

const (
	// The condition is true if the values are equal.
	// Experimental.
	ConditionLogicalOperator_EQUALS ConditionLogicalOperator = "EQUALS"
)

type ConditionalTriggerOptions 

type ConditionalTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Whether to start the trigger on creation or not.
	// Default: - false.
	//
	// Experimental.
	StartOnCreation *bool `field:"optional" json:"startOnCreation" yaml:"startOnCreation"`
	// The predicate for the trigger.
	// Experimental.
	Predicate *Predicate `field:"required" json:"predicate" yaml:"predicate"`
}

Properties for configuring a Condition (Predicate) based Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

conditionalTriggerOptions := &ConditionalTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},
	Predicate: &Predicate{
		Conditions: []condition{
			&condition{
				CrawlerName: jsii.String("crawlerName"),
				CrawlState: glue_alpha.CrawlerState_RUNNING,
				Job: job,
				LogicalOperator: glue_alpha.ConditionLogicalOperator_EQUALS,
				State: glue_alpha.JobState_SUCCEEDED,
			},
		},
		Logical: glue_alpha.PredicateLogical_AND,
	},

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
	StartOnCreation: jsii.Boolean(false),
}

Experimental.

type Connection 

type Connection interface {
	awscdk.Resource
	IConnection
	// The ARN of the connection.
	// Experimental.
	ConnectionArn() *string
	// The name of the connection.
	// Experimental.
	ConnectionName() *string
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Add additional connection parameters.
	// Experimental.
	AddProperty(key *string, value *string)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

An AWS Glue connection to a data source.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("RayCustomJobName"),
	Description: jsii.String("This is a description"),
	WorkerType: glue.WorkerType_Z_2X,
	NumberOfWorkers: jsii.Number(5),
	Runtime: glue.Runtime_RAY_TWO_FOUR,
	MaxRetries: jsii.Number(3),
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
})

Experimental.

func NewConnection 

func NewConnection(scope constructs.Construct, id *string, props *ConnectionProps) Connection

Experimental.

type ConnectionOptions 

type ConnectionOptions struct {
	// The name of the connection.
	// Default: cloudformation generated name.
	//
	// Experimental.
	ConnectionName *string `field:"optional" json:"connectionName" yaml:"connectionName"`
	// The description of the connection.
	// Default: no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A list of criteria that can be used in selecting this connection.
	//
	// This is useful for filtering the results of https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-connections.html
	// Default: no match criteria.
	//
	// Experimental.
	MatchCriteria *[]*string `field:"optional" json:"matchCriteria" yaml:"matchCriteria"`
	// Key-Value pairs that define parameters for the connection.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html
	//
	// Default: empty properties.
	//
	// Experimental.
	Properties *map[string]*string `field:"optional" json:"properties" yaml:"properties"`
	// The list of security groups needed to successfully make this connection e.g. to successfully connect to VPC.
	// Default: no security group.
	//
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// The VPC subnet to connect to resources within a VPC.
	//
	// See more at https://docs.aws.amazon.com/glue/latest/dg/start-connecting.html.
	// Default: no subnet.
	//
	// Experimental.
	Subnet awsec2.ISubnet `field:"optional" json:"subnet" yaml:"subnet"`
}

Base Connection Options.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var securityGroup securityGroup
var subnet subnet

connectionOptions := &ConnectionOptions{
	ConnectionName: jsii.String("connectionName"),
	Description: jsii.String("description"),
	MatchCriteria: []*string{
		jsii.String("matchCriteria"),
	},
	Properties: map[string]*string{
		"propertiesKey": jsii.String("properties"),
	},
	SecurityGroups: []iSecurityGroup{
		securityGroup,
	},
	Subnet: subnet,
}

Experimental.

type ConnectionProps 

type ConnectionProps struct {
	// The name of the connection.
	// Default: cloudformation generated name.
	//
	// Experimental.
	ConnectionName *string `field:"optional" json:"connectionName" yaml:"connectionName"`
	// The description of the connection.
	// Default: no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A list of criteria that can be used in selecting this connection.
	//
	// This is useful for filtering the results of https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-connections.html
	// Default: no match criteria.
	//
	// Experimental.
	MatchCriteria *[]*string `field:"optional" json:"matchCriteria" yaml:"matchCriteria"`
	// Key-Value pairs that define parameters for the connection.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html
	//
	// Default: empty properties.
	//
	// Experimental.
	Properties *map[string]*string `field:"optional" json:"properties" yaml:"properties"`
	// The list of security groups needed to successfully make this connection e.g. to successfully connect to VPC.
	// Default: no security group.
	//
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// The VPC subnet to connect to resources within a VPC.
	//
	// See more at https://docs.aws.amazon.com/glue/latest/dg/start-connecting.html.
	// Default: no subnet.
	//
	// Experimental.
	Subnet awsec2.ISubnet `field:"optional" json:"subnet" yaml:"subnet"`
	// The type of the connection.
	// Experimental.
	Type ConnectionType `field:"required" json:"type" yaml:"type"`
}

Construction properties for `Connection`.

Example: 

var securityGroup securityGroup
var subnet subnet

glue.NewConnection(this, jsii.String("MyConnection"), &ConnectionProps{
	Type: glue.ConnectionType_NETWORK(),
	// The security groups granting AWS Glue inbound access to the data source within the VPC
	SecurityGroups: []iSecurityGroup{
		securityGroup,
	},
	// The VPC subnet which contains the data source
	Subnet: Subnet,
})

Experimental.

type ConnectionType 

type ConnectionType interface {
	// The name of this ConnectionType, as expected by Connection resource.
	// Experimental.
	Name() *string
	// The connection type name as expected by Connection resource.
	// Experimental.
	ToString() *string
}

The type of the glue connection.

If you need to use a connection type that doesn't exist as a static member, you can instantiate a `ConnectionType` object, e.g: `new ConnectionType('NEW_TYPE')`.

Example: 

var securityGroup securityGroup
var subnet subnet

glue.NewConnection(this, jsii.String("MyConnection"), &ConnectionProps{
	Type: glue.ConnectionType_NETWORK(),
	// The security groups granting AWS Glue inbound access to the data source within the VPC
	SecurityGroups: []iSecurityGroup{
		securityGroup,
	},
	// The VPC subnet which contains the data source
	Subnet: Subnet,
})

See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-connection-connectioninput.html#cfn-glue-connection-connectioninput-connectiontype

Experimental.

func ConnectionType_CUSTOM 

func ConnectionType_CUSTOM() ConnectionType

func ConnectionType_FACEBOOKADS 

func ConnectionType_FACEBOOKADS() ConnectionType

func ConnectionType_GOOGLEADS 

func ConnectionType_GOOGLEADS() ConnectionType

func ConnectionType_GOOGLEANALYTICS4 

func ConnectionType_GOOGLEANALYTICS4() ConnectionType

func ConnectionType_GOOGLESHEETS 

func ConnectionType_GOOGLESHEETS() ConnectionType

func ConnectionType_HUBSPOT 

func ConnectionType_HUBSPOT() ConnectionType

func ConnectionType_INSTAGRAMADS 

func ConnectionType_INSTAGRAMADS() ConnectionType

func ConnectionType_INTERCOM 

func ConnectionType_INTERCOM() ConnectionType

func ConnectionType_JDBC 

func ConnectionType_JDBC() ConnectionType

func ConnectionType_JIRACLOUD 

func ConnectionType_JIRACLOUD() ConnectionType

func ConnectionType_KAFKA 

func ConnectionType_KAFKA() ConnectionType

func ConnectionType_MARKETO 

func ConnectionType_MARKETO() ConnectionType

func ConnectionType_MARKETPLACE 

func ConnectionType_MARKETPLACE() ConnectionType

func ConnectionType_MONGODB 

func ConnectionType_MONGODB() ConnectionType

func ConnectionType_NETSUITEERP 

func ConnectionType_NETSUITEERP() ConnectionType

func ConnectionType_NETWORK 

func ConnectionType_NETWORK() ConnectionType

func ConnectionType_SALESFORCE 

func ConnectionType_SALESFORCE() ConnectionType

func ConnectionType_SALESFORCEMARKETINGCLOUD 

func ConnectionType_SALESFORCEMARKETINGCLOUD() ConnectionType

func ConnectionType_SALESFORCEPARDOT 

func ConnectionType_SALESFORCEPARDOT() ConnectionType

func ConnectionType_SAPODATA 

func ConnectionType_SAPODATA() ConnectionType

func ConnectionType_SERVICENOW 

func ConnectionType_SERVICENOW() ConnectionType

func ConnectionType_SLACK 

func ConnectionType_SLACK() ConnectionType

func ConnectionType_SNAPCHATADS 

func ConnectionType_SNAPCHATADS() ConnectionType

func ConnectionType_STRIPE 

func ConnectionType_STRIPE() ConnectionType

func ConnectionType_VIEW_VALIDATION_ATHENA 

func ConnectionType_VIEW_VALIDATION_ATHENA() ConnectionType

func ConnectionType_VIEW_VALIDATION_REDSHIFT 

func ConnectionType_VIEW_VALIDATION_REDSHIFT() ConnectionType

func ConnectionType_ZENDESK 

func ConnectionType_ZENDESK() ConnectionType

func ConnectionType_ZOHOCRM 

func ConnectionType_ZOHOCRM() ConnectionType

func NewConnectionType 

func NewConnectionType(name *string) ConnectionType

Experimental.

type ContinuousLoggingProps 

type ContinuousLoggingProps struct {
	// Enable continouous logging.
	// Experimental.
	Enabled *bool `field:"required" json:"enabled" yaml:"enabled"`
	// Apply the provided conversion pattern.
	//
	// This is a Log4j Conversion Pattern to customize driver and executor logs.
	// Default: `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`.
	//
	// Experimental.
	ConversionPattern *string `field:"optional" json:"conversionPattern" yaml:"conversionPattern"`
	// Specify a custom CloudWatch log group name.
	// Default: - a log group is created with name `/aws-glue/jobs/logs-v2/`.
	//
	// Experimental.
	LogGroup awslogs.ILogGroup `field:"optional" json:"logGroup" yaml:"logGroup"`
	// Specify a custom CloudWatch log stream prefix.
	// Default: - the job run ID.
	//
	// Experimental.
	LogStreamPrefix *string `field:"optional" json:"logStreamPrefix" yaml:"logStreamPrefix"`
	// Filter out non-useful Apache Spark driver/executor and Apache Hadoop YARN heartbeat log messages.
	// Default: true.
	//
	// Experimental.
	Quiet *bool `field:"optional" json:"quiet" yaml:"quiet"`
}

Properties for enabling Continuous Logging for Glue Jobs.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	JobName: jsii.String("PySparkETLJobCustomName"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html

Experimental.

type CrawlerState 

type CrawlerState string

Represents the state of a crawler for a condition in the Glue Trigger API. Experimental. 

const (
	// The crawler is currently running.
	// Experimental.
	CrawlerState_RUNNING CrawlerState = "RUNNING"
	// The crawler is in the process of being cancelled.
	// Experimental.
	CrawlerState_CANCELLING CrawlerState = "CANCELLING"
	// The crawler has been cancelled.
	// Experimental.
	CrawlerState_CANCELLED CrawlerState = "CANCELLED"
	// The crawler has completed its operation successfully.
	// Experimental.
	CrawlerState_SUCCEEDED CrawlerState = "SUCCEEDED"
	// The crawler has failed to complete its operation.
	// Experimental.
	CrawlerState_FAILED CrawlerState = "FAILED"
	// The crawler encountered an error during its operation.
	// Experimental.
	CrawlerState_ERROR CrawlerState = "ERROR"
)

type CustomScheduledTriggerOptions 

type CustomScheduledTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Whether to start the trigger on creation or not.
	// Default: - false.
	//
	// Experimental.
	StartOnCreation *bool `field:"optional" json:"startOnCreation" yaml:"startOnCreation"`
	// The custom schedule for the trigger.
	// Experimental.
	Schedule TriggerSchedule `field:"required" json:"schedule" yaml:"schedule"`
}

Properties for configuring a custom-scheduled Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration
var triggerSchedule triggerSchedule

customScheduledTriggerOptions := &CustomScheduledTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},
	Schedule: triggerSchedule,

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
	StartOnCreation: jsii.Boolean(false),
}

Experimental.

type DailyScheduleTriggerOptions 

type DailyScheduleTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Whether to start the trigger on creation or not.
	// Default: - false.
	//
	// Experimental.
	StartOnCreation *bool `field:"optional" json:"startOnCreation" yaml:"startOnCreation"`
}

Properties for configuring a daily-scheduled Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

dailyScheduleTriggerOptions := &DailyScheduleTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
	StartOnCreation: jsii.Boolean(false),
}

Experimental.

type DataFormat 

type DataFormat interface {
	// Classification string given to tables with this data format.
	// Experimental.
	ClassificationString() ClassificationString
	// `InputFormat` for this data format.
	// Experimental.
	InputFormat() InputFormat
	// `OutputFormat` for this data format.
	// Experimental.
	OutputFormat() OutputFormat
	// Serialization library for this data format.
	// Experimental.
	SerializationLibrary() SerializationLibrary
}

Defines the input/output formats and ser/de for a single DataFormat.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Experimental.

func DataFormat_APACHE_LOGS 

func DataFormat_APACHE_LOGS() DataFormat

func DataFormat_AVRO 

func DataFormat_AVRO() DataFormat

func DataFormat_CLOUDTRAIL_LOGS 

func DataFormat_CLOUDTRAIL_LOGS() DataFormat

func DataFormat_CSV 

func DataFormat_CSV() DataFormat

func DataFormat_JSON 

func DataFormat_JSON() DataFormat

func DataFormat_LOGSTASH 

func DataFormat_LOGSTASH() DataFormat

func DataFormat_ORC 

func DataFormat_ORC() DataFormat

func DataFormat_PARQUET 

func DataFormat_PARQUET() DataFormat

func DataFormat_TSV 

func DataFormat_TSV() DataFormat

func NewDataFormat 

func NewDataFormat(props *DataFormatProps) DataFormat

Experimental.

type DataFormatProps 

type DataFormatProps struct {
	// `InputFormat` for this data format.
	// Experimental.
	InputFormat InputFormat `field:"required" json:"inputFormat" yaml:"inputFormat"`
	// `OutputFormat` for this data format.
	// Experimental.
	OutputFormat OutputFormat `field:"required" json:"outputFormat" yaml:"outputFormat"`
	// Serialization library for this data format.
	// Experimental.
	SerializationLibrary SerializationLibrary `field:"required" json:"serializationLibrary" yaml:"serializationLibrary"`
	// Classification string given to tables with this data format.
	// Default: - No classification is specified.
	//
	// Experimental.
	ClassificationString ClassificationString `field:"optional" json:"classificationString" yaml:"classificationString"`
}

Properties of a DataFormat instance.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

var classificationString classificationString
var inputFormat inputFormat
var outputFormat outputFormat
var serializationLibrary serializationLibrary

dataFormatProps := &DataFormatProps{
	InputFormat: inputFormat,
	OutputFormat: outputFormat,
	SerializationLibrary: serializationLibrary,

	// the properties below are optional
	ClassificationString: classificationString,
}

Experimental.

type DataQualityRuleset 

type DataQualityRuleset interface {
	awscdk.Resource
	IDataQualityRuleset
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// ARN of this ruleset.
	// Experimental.
	RulesetArn() *string
	// Name of this ruleset.
	// Experimental.
	RulesetName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue Data Quality ruleset.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

var dataQualityTargetTable dataQualityTargetTable

dataQualityRuleset := glue_alpha.NewDataQualityRuleset(this, jsii.String("MyDataQualityRuleset"), &DataQualityRulesetProps{
	RulesetDqdl: jsii.String("rulesetDqdl"),
	TargetTable: dataQualityTargetTable,

	// the properties below are optional
	ClientToken: jsii.String("clientToken"),
	Description: jsii.String("description"),
	RulesetName: jsii.String("rulesetName"),
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
})

Experimental.

func NewDataQualityRuleset 

func NewDataQualityRuleset(scope constructs.Construct, id *string, props *DataQualityRulesetProps) DataQualityRuleset

Experimental.

type DataQualityRulesetProps 

type DataQualityRulesetProps struct {
	// The dqdl of the ruleset.
	// Experimental.
	RulesetDqdl *string `field:"required" json:"rulesetDqdl" yaml:"rulesetDqdl"`
	// The target table of the ruleset.
	// Experimental.
	TargetTable DataQualityTargetTable `field:"required" json:"targetTable" yaml:"targetTable"`
	// The client token of the ruleset.
	// Experimental.
	ClientToken *string `field:"optional" json:"clientToken" yaml:"clientToken"`
	// The description of the ruleset.
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// The name of the ruleset.
	// Default: cloudformation generated name.
	//
	// Experimental.
	RulesetName *string `field:"optional" json:"rulesetName" yaml:"rulesetName"`
	// Key-Value pairs that define tags for the ruleset.
	// Default: empty tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
}

Construction properties for `DataQualityRuleset`.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

var dataQualityTargetTable dataQualityTargetTable

dataQualityRulesetProps := &DataQualityRulesetProps{
	RulesetDqdl: jsii.String("rulesetDqdl"),
	TargetTable: dataQualityTargetTable,

	// the properties below are optional
	ClientToken: jsii.String("clientToken"),
	Description: jsii.String("description"),
	RulesetName: jsii.String("rulesetName"),
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
}

Experimental.

type DataQualityTargetTable 

type DataQualityTargetTable interface {
	// The database name of the target table.
	// Experimental.
	DatabaseName() *string
	// The table name of the target table.
	// Experimental.
	TableName() *string
}

Properties of a DataQualityTargetTable.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

dataQualityTargetTable := glue_alpha.NewDataQualityTargetTable(jsii.String("databaseName"), jsii.String("tableName"))

Experimental.

func NewDataQualityTargetTable 

func NewDataQualityTargetTable(databaseName *string, tableName *string) DataQualityTargetTable

Experimental.

type Database 

type Database interface {
	awscdk.Resource
	IDatabase
	// ARN of the Glue catalog in which this database is stored.
	// Experimental.
	CatalogArn() *string
	// The catalog id of the database (usually, the AWS account id).
	// Experimental.
	CatalogId() *string
	// ARN of this database.
	// Experimental.
	DatabaseArn() *string
	// Name of this database.
	// Experimental.
	DatabaseName() *string
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// Location URI of this database.
	// Experimental.
	LocationUri() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue database.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var stack stack
var accountId string

tagKey := "aws"
tagValues := []*string{
	"dev",
}

database := awscdkgluealpha.NewDatabase(this, jsii.String("Database"))

table := awscdkgluealpha.NewS3Table(this, jsii.String("Table"), &S3TableProps{
	Database: Database,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: awscdkgluealpha.Schema_STRING(),
		},
		&column{
			Name: jsii.String("col2"),
			Type: awscdkgluealpha.Schema_STRING(),
		},
	},
	DataFormat: awscdkgluealpha.DataFormat_CSV(),
})

synthesizer := stack.Synthesizer.(defaultStackSynthesizer)
awscdk.NewCfnDataLakeSettings(this, jsii.String("DataLakeSettings"), &CfnDataLakeSettingsProps{
	Admins: []interface{}{
		&DataLakePrincipalProperty{
			DataLakePrincipalIdentifier: stack.FormatArn(&ArnComponents{
				Service: jsii.String("iam"),
				Resource: jsii.String("role"),
				Region: jsii.String(""),
				Account: accountId,
				ResourceName: jsii.String("Admin"),
			}),
		},
		&DataLakePrincipalProperty{
			// The CDK cloudformation execution role.
			DataLakePrincipalIdentifier: synthesizer.cloudFormationExecutionRoleArn.replace(jsii.String("${AWS::Partition}"), jsii.String("aws")),
		},
	},
})

tag := awscdk.NewCfnTag(this, jsii.String("Tag"), &CfnTagProps{
	CatalogId: accountId,
	TagKey: jsii.String(TagKey),
	TagValues: TagValues,
})

lfTagPairProperty := &LFTagPairProperty{
	CatalogId: accountId,
	TagKey: jsii.String(TagKey),
	TagValues: TagValues,
}

tagAssociation := awscdk.NewCfnTagAssociation(this, jsii.String("TagAssociation"), &CfnTagAssociationProps{
	LfTags: []interface{}{
		lfTagPairProperty,
	},
	Resource: &ResourceProperty{
		TableWithColumns: &TableWithColumnsResourceProperty{
			DatabaseName: database.DatabaseName,
			ColumnNames: []*string{
				jsii.String("col1"),
				jsii.String("col2"),
			},
			CatalogId: accountId,
			Name: table.TableName,
		},
	},
})

tagAssociation.Node.AddDependency(tag)
tagAssociation.Node.AddDependency(table)

Experimental.

func NewDatabase 

func NewDatabase(scope constructs.Construct, id *string, props *DatabaseProps) Database

Experimental.

type DatabaseProps 

type DatabaseProps struct {
	// The name of the database.
	// Default: - generated by CDK.
	//
	// Experimental.
	DatabaseName *string `field:"optional" json:"databaseName" yaml:"databaseName"`
	// A description of the database.
	// Default: - no database description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// The location of the database (for example, an HDFS path).
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-databaseinput.html
	//
	// Default: undefined. This field is optional in AWS::Glue::Database DatabaseInput
	//
	// Experimental.
	LocationUri *string `field:"optional" json:"locationUri" yaml:"locationUri"`
}

Example: 

glue.NewDatabase(this, jsii.String("MyDatabase"), &DatabaseProps{
	DatabaseName: jsii.String("my_database"),
	Description: jsii.String("my_database_description"),
})

Experimental.

type EventBatchingCondition 

type EventBatchingCondition struct {
	// Number of events that must be received from Amazon EventBridge before EventBridge event trigger fires.
	// Experimental.
	BatchSize *float64 `field:"required" json:"batchSize" yaml:"batchSize"`
	// Window of time in seconds after which EventBridge event trigger fires.
	// Default: - 900 seconds.
	//
	// Experimental.
	BatchWindow awscdk.Duration `field:"optional" json:"batchWindow" yaml:"batchWindow"`
}

Represents event trigger batch condition.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"

eventBatchingCondition := &EventBatchingCondition{
	BatchSize: jsii.Number(123),

	// the properties below are optional
	BatchWindow: cdk.Duration_Minutes(jsii.Number(30)),
}

Experimental.

type ExecutionClass 

type ExecutionClass string

The ExecutionClass whether the job is run with a standard or flexible execution class. See: https://docs.aws.amazon.com/glue/latest/dg/add-job.html

Experimental. 

const (
	// The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary.
	// Experimental.
	ExecutionClass_FLEX ExecutionClass = "FLEX"
	// The standard execution class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.
	// Experimental.
	ExecutionClass_STANDARD ExecutionClass = "STANDARD"
)

type ExternalTable 

type ExternalTable interface {
	TableBase
	// This table's columns.
	// Experimental.
	Columns() *[]*Column
	// Indicates whether the table's data is compressed or not.
	// Experimental.
	Compressed() *bool
	// The connection associated to this table.
	// Experimental.
	Connection() IConnection
	// Database this table belongs to.
	// Experimental.
	Database() IDatabase
	// Format of this table's data files.
	// Experimental.
	DataFormat() DataFormat
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// The tables' properties associated with the table.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Experimental.
	Parameters() *map[string]*string
	// This table's partition indexes.
	// Experimental.
	PartitionIndexes() *[]*PartitionIndex
	// This table's partition keys if the table is partitioned.
	// Experimental.
	PartitionKeys() *[]*Column
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The tables' storage descriptor properties.
	// Experimental.
	StorageParameters() *[]StorageParameter
	// ARN of this table.
	// Experimental.
	TableArn() *string
	// Name of this table.
	// Experimental.
	TableName() *string
	// Experimental.
	TableResource() awsglue.CfnTable
	// Add a partition index to the table.
	//
	// You can have a maximum of 3 partition
	// indexes to a table. Partition index keys must be a subset of the table's
	// partition keys.
	// See: https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html
	//
	// Experimental.
	AddPartitionIndex(index *PartitionIndex)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity custom permissions.
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant read permissions to the table.
	// Experimental.
	GrantRead(grantee awsiam.IGrantable) awsiam.Grant
	// Grant read and write permissions to the table.
	// Experimental.
	GrantReadWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Grant the given identity custom permissions to ALL underlying resources of the table.
	//
	// Permissions will be granted to the catalog, the database, and the table.
	// Experimental.
	GrantToUnderlyingResources(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant write permissions to the table.
	// Experimental.
	GrantWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue table that targets an external data location (e.g. A table in a Redshift Cluster).

Example: 

var myConnection connection
var myDatabase database

glue.NewExternalTable(this, jsii.String("MyTable"), &ExternalTableProps{
	Connection: myConnection,
	ExternalDataLocation: jsii.String("default_db_public_example"),
	 // A table in Redshift
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Experimental.

func NewExternalTable 

func NewExternalTable(scope constructs.Construct, id *string, props *ExternalTableProps) ExternalTable

Experimental.

type ExternalTableProps 

type ExternalTableProps struct {
	// Columns of the table.
	// Experimental.
	Columns *[]*Column `field:"required" json:"columns" yaml:"columns"`
	// Database in which to store the table.
	// Experimental.
	Database IDatabase `field:"required" json:"database" yaml:"database"`
	// Storage type of the table's data.
	// Experimental.
	DataFormat DataFormat `field:"required" json:"dataFormat" yaml:"dataFormat"`
	// Indicates whether the table's data is compressed or not.
	// Default: false.
	//
	// Experimental.
	Compressed *bool `field:"optional" json:"compressed" yaml:"compressed"`
	// Description of the table.
	// Default: generated.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables partition filtering.
	// See: https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	EnablePartitionFiltering *bool `field:"optional" json:"enablePartitionFiltering" yaml:"enablePartitionFiltering"`
	// The key/value pairs define properties associated with the table.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	Parameters *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
	// Partition indexes on the table.
	//
	// A maximum of 3 indexes
	// are allowed on a table. Keys in the index must be part
	// of the table's partition keys.
	// Default: table has no partition indexes.
	//
	// Experimental.
	PartitionIndexes *[]*PartitionIndex `field:"optional" json:"partitionIndexes" yaml:"partitionIndexes"`
	// Partition columns of the table.
	// Default: table is not partitioned.
	//
	// Experimental.
	PartitionKeys *[]*Column `field:"optional" json:"partitionKeys" yaml:"partitionKeys"`
	// The user-supplied properties for the description of the physical storage of this table.
	//
	// These properties help describe the format of the data that is stored within the crawled data sources.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	//
	// Some keys will be auto-populated by glue crawlers, however, you can override them by specifying the key and value in this property.
	//
	// Example:
	//      declare const glueDatabase: glue.IDatabase;
	//      const table = new glue.Table(this, 'Table', {
	//        storageParameters: [
	//            glue.StorageParameter.skipHeaderLineCount(1),
	//            glue.StorageParameter.compressionType(glue.CompressionType.GZIP),
	//            glue.StorageParameter.custom('foo', 'bar'), // Will have no effect
	//            glue.StorageParameter.custom('separatorChar', ','), // Will describe the separator char used in the data
	//            glue.StorageParameter.custom(glue.StorageParameters.WRITE_PARALLEL, 'off'),
	//        ],
	//        // ...
	//        database: glueDatabase,
	//        columns: [{
	//            name: 'col1',
	//            type: glue.Schema.STRING,
	//        }],
	//        dataFormat: glue.DataFormat.CSV,
	//      });
	//
	// See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	StorageParameters *[]StorageParameter `field:"optional" json:"storageParameters" yaml:"storageParameters"`
	// Indicates whether the table data is stored in subdirectories.
	// Default: false.
	//
	// Experimental.
	StoredAsSubDirectories *bool `field:"optional" json:"storedAsSubDirectories" yaml:"storedAsSubDirectories"`
	// Name of the table.
	// Default: - generated by CDK.
	//
	// Experimental.
	TableName *string `field:"optional" json:"tableName" yaml:"tableName"`
	// The connection the table will use when performing reads and writes.
	// Default: - No connection.
	//
	// Experimental.
	Connection IConnection `field:"required" json:"connection" yaml:"connection"`
	// The data source location of the glue table, (e.g. `default_db_public_example` for Redshift).
	//
	// If this property is set, it will override both `bucket` and `s3Prefix`.
	// Default: - No outsourced data source location.
	//
	// Experimental.
	ExternalDataLocation *string `field:"required" json:"externalDataLocation" yaml:"externalDataLocation"`
}

Example: 

var myConnection connection
var myDatabase database

glue.NewExternalTable(this, jsii.String("MyTable"), &ExternalTableProps{
	Connection: myConnection,
	ExternalDataLocation: jsii.String("default_db_public_example"),
	 // A table in Redshift
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Experimental.

type GlueVersion 

type GlueVersion string

AWS Glue version determines the versions of Apache Spark and Python that are available to the job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	JobName: jsii.String("PySparkETLJobCustomName"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

See: https://docs.aws.amazon.com/glue/latest/dg/add-job.html.

Experimental. 

const (
	// Glue version using Spark 2.2.1 and Python 2.7.
	// Experimental.
	GlueVersion_V0_9 GlueVersion = "V0_9"
	// Glue version using Spark 2.4.3, Python 2.7 and Python 3.6.
	// Experimental.
	GlueVersion_V1_0 GlueVersion = "V1_0"
	// Glue version using Spark 2.4.3 and Python 3.7.
	// Experimental.
	GlueVersion_V2_0 GlueVersion = "V2_0"
	// Glue version using Spark 3.1.1 and Python 3.7.
	// Experimental.
	GlueVersion_V3_0 GlueVersion = "V3_0"
	// Glue version using Spark 3.3.0 and Python 3.10.
	// Experimental.
	GlueVersion_V4_0 GlueVersion = "V4_0"
	// Glue version using Spark 3.5.2 and Python 3.11.
	// Experimental.
	GlueVersion_V5_0 GlueVersion = "V5_0"
)

type IConnection 

type IConnection interface {
	awscdk.IResource
	// The ARN of the connection.
	// Experimental.
	ConnectionArn() *string
	// The name of the connection.
	// Experimental.
	ConnectionName() *string
}

Interface representing a created or an imported `Connection`. Experimental.

func Connection_FromConnectionArn 

func Connection_FromConnectionArn(scope constructs.Construct, id *string, connectionArn *string) IConnection

Creates a Connection construct that represents an external connection. Experimental.

func Connection_FromConnectionName 

func Connection_FromConnectionName(scope constructs.Construct, id *string, connectionName *string) IConnection

Creates a Connection construct that represents an external connection. Experimental.

type IDataQualityRuleset 

type IDataQualityRuleset interface {
	awscdk.IResource
	// The ARN of the ruleset.
	// Experimental.
	RulesetArn() *string
	// The name of the ruleset.
	// Experimental.
	RulesetName() *string
}

Experimental.

func DataQualityRuleset_FromRulesetArn 

func DataQualityRuleset_FromRulesetArn(scope constructs.Construct, id *string, rulesetArn *string) IDataQualityRuleset

Experimental.

func DataQualityRuleset_FromRulesetName 

func DataQualityRuleset_FromRulesetName(scope constructs.Construct, id *string, rulesetName *string) IDataQualityRuleset

Experimental.

type IDatabase 

type IDatabase interface {
	awscdk.IResource
	// The ARN of the catalog.
	// Experimental.
	CatalogArn() *string
	// The catalog id of the database (usually, the AWS account id).
	// Experimental.
	CatalogId() *string
	// The ARN of the database.
	// Experimental.
	DatabaseArn() *string
	// The name of the database.
	// Experimental.
	DatabaseName() *string
}

Experimental.

func Database_FromDatabaseArn 

func Database_FromDatabaseArn(scope constructs.Construct, id *string, databaseArn *string) IDatabase

Experimental.

type IJob 

type IJob interface {
	awsiam.IGrantable
	awscdk.IResource
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Metric indicating job failure.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Metric indicating job success.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Metric indicating job timeout.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Defines a CloudWatch event rule triggered when something happens with this job.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when this job moves to the FAILED state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when this job moves to the SUCCEEDED state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when this job moves to the TIMEOUT state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
}

Interface representing a new or an imported Glue Job. Experimental.

func Job_FromJobAttributes 

func Job_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func PySparkEtlJob_FromJobAttributes 

func PySparkEtlJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func PySparkFlexEtlJob_FromJobAttributes 

func PySparkFlexEtlJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func PySparkStreamingJob_FromJobAttributes 

func PySparkStreamingJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func PythonShellJob_FromJobAttributes 

func PythonShellJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func RayJob_FromJobAttributes 

func RayJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func ScalaSparkEtlJob_FromJobAttributes 

func ScalaSparkEtlJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func ScalaSparkFlexEtlJob_FromJobAttributes 

func ScalaSparkFlexEtlJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

func ScalaSparkStreamingJob_FromJobAttributes 

func ScalaSparkStreamingJob_FromJobAttributes(scope constructs.Construct, id *string, attrs *JobImportAttributes) IJob

Identifies an existing Glue Job from a subset of attributes that can be referenced from within another Stack or Construct. Experimental.

type ISecurityConfiguration 

type ISecurityConfiguration interface {
	awscdk.IResource
	// The name of the security configuration.
	// Experimental.
	SecurityConfigurationName() *string
}

Interface representing a created or an imported `SecurityConfiguration`. Experimental.

func SecurityConfiguration_FromSecurityConfigurationName 

func SecurityConfiguration_FromSecurityConfigurationName(scope constructs.Construct, id *string, securityConfigurationName *string) ISecurityConfiguration

Creates a Connection construct that represents an external security configuration. Experimental.

type ITable 

type ITable interface {
	awscdk.IResource
	// Experimental.
	TableArn() *string
	// Experimental.
	TableName() *string
}

Experimental.

func ExternalTable_FromTableArn 

func ExternalTable_FromTableArn(scope constructs.Construct, id *string, tableArn *string) ITable

Experimental.

func ExternalTable_FromTableAttributes 

func ExternalTable_FromTableAttributes(scope constructs.Construct, id *string, attrs *TableAttributes) ITable

Creates a Table construct that represents an external table. Experimental.

func S3Table_FromTableArn 

func S3Table_FromTableArn(scope constructs.Construct, id *string, tableArn *string) ITable

Experimental.

func S3Table_FromTableAttributes 

func S3Table_FromTableAttributes(scope constructs.Construct, id *string, attrs *TableAttributes) ITable

Creates a Table construct that represents an external table. Experimental.

func TableBase_FromTableArn 

func TableBase_FromTableArn(scope constructs.Construct, id *string, tableArn *string) ITable

Experimental.

func TableBase_FromTableAttributes 

func TableBase_FromTableAttributes(scope constructs.Construct, id *string, attrs *TableAttributes) ITable

Creates a Table construct that represents an external table. Experimental.

func Table_FromTableArn deprecated 

func Table_FromTableArn(scope constructs.Construct, id *string, tableArn *string) ITable

Deprecated: Use {@link S3Table } instead.

func Table_FromTableAttributes 

func Table_FromTableAttributes(scope constructs.Construct, id *string, attrs *TableAttributes) ITable

Creates a Table construct that represents an external table. Deprecated: Use {@link S3Table } instead.

type IWorkflow 

type IWorkflow interface {
	awscdk.IResource
	// Add an custom-scheduled trigger to the workflow.
	// Experimental.
	AddCustomScheduledTrigger(id *string, options *CustomScheduledTriggerOptions) awsglue.CfnTrigger
	// Add an daily-scheduled trigger to the workflow.
	// Experimental.
	AddDailyScheduledTrigger(id *string, options *DailyScheduleTriggerOptions) awsglue.CfnTrigger
	// Add an on-demand trigger to the workflow.
	// Experimental.
	AddOnDemandTrigger(id *string, options *OnDemandTriggerOptions) awsglue.CfnTrigger
	// Add an weekly-scheduled trigger to the workflow.
	// Experimental.
	AddWeeklyScheduledTrigger(id *string, options *WeeklyScheduleTriggerOptions) awsglue.CfnTrigger
	// The ARN of the workflow.
	// Experimental.
	WorkflowArn() *string
	// The name of the workflow.
	// Experimental.
	WorkflowName() *string
}

The base interface for Glue Workflow. See: https://docs.aws.amazon.com/glue/latest/dg/workflows_overview.html

Experimental.

func Workflow_FromWorkflowArn 

func Workflow_FromWorkflowArn(scope constructs.Construct, id *string, workflowArn *string) IWorkflow

Import an workflow from it's name. Experimental.

func Workflow_FromWorkflowAttributes 

func Workflow_FromWorkflowAttributes(scope constructs.Construct, id *string, attrs *WorkflowAttributes) IWorkflow

Import an existing workflow. Experimental.

func Workflow_FromWorkflowName 

func Workflow_FromWorkflowName(scope constructs.Construct, id *string, workflowName *string) IWorkflow

Import a workflow from its name. Experimental.

type InputFormat 

type InputFormat interface {
	// Experimental.
	ClassName() *string
}

Absolute class name of the Hadoop `InputFormat` to use when reading table files.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

inputFormat := glue_alpha.InputFormat_AVRO()

Experimental.

func InputFormat_AVRO 

func InputFormat_AVRO() InputFormat

func InputFormat_CLOUDTRAIL 

func InputFormat_CLOUDTRAIL() InputFormat

func InputFormat_ORC 

func InputFormat_ORC() InputFormat

func InputFormat_PARQUET 

func InputFormat_PARQUET() InputFormat

func InputFormat_TEXT 

func InputFormat_TEXT() InputFormat

func NewInputFormat 

func NewInputFormat(className *string) InputFormat

Experimental.

func OutputFormat_AVRO 

func OutputFormat_AVRO() InputFormat

func OutputFormat_ORC 

func OutputFormat_ORC() InputFormat

type InvalidCharHandlingAction 

type InvalidCharHandlingAction string

Specifies the action to perform when query results contain invalid UTF-8 character values. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"invalid_char_handling"_

Experimental. 

const (
	// Doesn't perform invalid character handling.
	// Experimental.
	InvalidCharHandlingAction_DISABLED InvalidCharHandlingAction = "DISABLED"
	// Cancels queries that return data containing invalid UTF-8 values.
	// Experimental.
	InvalidCharHandlingAction_FAIL InvalidCharHandlingAction = "FAIL"
	// Replaces invalid UTF-8 values with null.
	// Experimental.
	InvalidCharHandlingAction_SET_TO_NULL InvalidCharHandlingAction = "SET_TO_NULL"
	// Replaces each value in the row with null.
	// Experimental.
	InvalidCharHandlingAction_DROP_ROW InvalidCharHandlingAction = "DROP_ROW"
	// Replaces the invalid character with the replacement character you specify using `REPLACEMENT_CHAR`.
	// Experimental.
	InvalidCharHandlingAction_REPLACE InvalidCharHandlingAction = "REPLACE"
)

type Job 

type Job interface {
	JobBase
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue Job.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var role role

job := glue_alpha.Job_FromJobAttributes(this, jsii.String("MyJob"), &JobImportAttributes{
	JobName: jsii.String("jobName"),

	// the properties below are optional
	Role: role,
})

Experimental.

type JobBase 

type JobBase interface {
	awscdk.Resource
	IJob
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A base class is needed to be able to import existing Jobs into a CDK app to reference as part of a larger stack or construct.

JobBase has the subset of attribtues required to idenitfy and reference an existing Glue Job, as well as some CloudWatch metric conveneince functions to configure an event-driven flow using the job. Experimental.

type JobBookmarksEncryption 

type JobBookmarksEncryption struct {
	// Encryption mode.
	// Experimental.
	Mode JobBookmarksEncryptionMode `field:"required" json:"mode" yaml:"mode"`
	// The KMS key to be used to encrypt the data.
	// Default: A key will be created if one is not provided.
	//
	// Experimental.
	KmsKey awskms.IKey `field:"optional" json:"kmsKey" yaml:"kmsKey"`
}

Job bookmarks encryption configuration.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

Experimental.

type JobBookmarksEncryptionMode 

type JobBookmarksEncryptionMode string

Encryption mode for Job Bookmarks.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

See: https://docs.aws.amazon.com/glue/latest/webapi/API_JobBookmarksEncryption.html#Glue-Type-JobBookmarksEncryption-JobBookmarksEncryptionMode

Experimental. 

const (
	// Client-side encryption (CSE) with an AWS KMS key managed by the account owner.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingClientSideEncryption.html
	//
	// Experimental.
	JobBookmarksEncryptionMode_CLIENT_SIDE_KMS JobBookmarksEncryptionMode = "CLIENT_SIDE_KMS"
)

type JobImportAttributes 

type JobImportAttributes struct {
	// The name of the job.
	// Experimental.
	JobName *string `field:"required" json:"jobName" yaml:"jobName"`
	// The IAM role assumed by Glue to run this job.
	// Default: - undefined.
	//
	// Experimental.
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
}

A subset of Job attributes are required for importing an existing job into a CDK project.

This is ionly used when using fromJobAttributes to identify and reference the existing job.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var role role

jobImportAttributes := &JobImportAttributes{
	JobName: jsii.String("jobName"),

	// the properties below are optional
	Role: role,
}

Experimental.

type JobLanguage 

type JobLanguage string

Runtime language of the Glue job. Experimental. 

const (
	// Scala.
	// Experimental.
	JobLanguage_SCALA JobLanguage = "SCALA"
	// Python.
	// Experimental.
	JobLanguage_PYTHON JobLanguage = "PYTHON"
)

type JobProperties 

type JobProperties struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
}

JobProperties will be used to create new Glue Jobs using this L2 Construct.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

jobProperties := &JobProperties{
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
}

Experimental.

type JobState 

type JobState string

Job states emitted by Glue to CloudWatch Events. See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types for more information.

Experimental. 

const (
	// State indicating job run succeeded.
	// Experimental.
	JobState_SUCCEEDED JobState = "SUCCEEDED"
	// State indicating job run failed.
	// Experimental.
	JobState_FAILED JobState = "FAILED"
	// State indicating job run timed out.
	// Experimental.
	JobState_TIMEOUT JobState = "TIMEOUT"
	// State indicating job is starting.
	// Experimental.
	JobState_STARTING JobState = "STARTING"
	// State indicating job is running.
	// Experimental.
	JobState_RUNNING JobState = "RUNNING"
	// State indicating job is stopping.
	// Experimental.
	JobState_STOPPING JobState = "STOPPING"
	// State indicating job stopped.
	// Experimental.
	JobState_STOPPED JobState = "STOPPED"
)

type JobType 

type JobType string

The job type.

If you need to use a JobType that doesn't exist as a static member, you can instantiate a `JobType` object, e.g: `JobType.of('other name')`. Experimental. 

const (
	// Command for running a Glue Spark job.
	// Experimental.
	JobType_ETL JobType = "ETL"
	// Command for running a Glue Spark streaming job.
	// Experimental.
	JobType_STREAMING JobType = "STREAMING"
	// Command for running a Glue python shell job.
	// Experimental.
	JobType_PYTHON_SHELL JobType = "PYTHON_SHELL"
	// Command for running a Glue Ray job.
	// Experimental.
	JobType_RAY JobType = "RAY"
)

type MaxCapacity 

type MaxCapacity string

The number of AWS Glue data processing units (DPUs) that can be allocated when this job runs.

A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("PythonShellJob"), &PythonShellJobProps{
	JobName: jsii.String("PythonShellJobCustomName"),
	Description: jsii.String("This is a description"),
	PythonVersion: glue.PythonVersion_TWO,
	MaxCapacity: glue.MaxCapacity_DPU_1,
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V2_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

Experimental. 

const (
	// DPU value of 1/16th.
	// Experimental.
	MaxCapacity_DPU_1_16TH MaxCapacity = "DPU_1_16TH"
	// DPU value of 1.
	// Experimental.
	MaxCapacity_DPU_1 MaxCapacity = "DPU_1"
)

type MetricType 

type MetricType string

The Glue CloudWatch metric type. See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html

Experimental. 

const (
	// A value at a point in time.
	// Experimental.
	MetricType_GAUGE MetricType = "GAUGE"
	// An aggregate number.
	// Experimental.
	MetricType_COUNT MetricType = "COUNT"
)

type NotifyEventTriggerOptions 

type NotifyEventTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Batch condition for the trigger.
	// Default: - no batch condition.
	//
	// Experimental.
	EventBatchingCondition *EventBatchingCondition `field:"optional" json:"eventBatchingCondition" yaml:"eventBatchingCondition"`
}

Properties for configuring an Event Bridge based Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

notifyEventTriggerOptions := &NotifyEventTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},

	// the properties below are optional
	Description: jsii.String("description"),
	EventBatchingCondition: &EventBatchingCondition{
		BatchSize: jsii.Number(123),

		// the properties below are optional
		BatchWindow: cdk.Duration_*Minutes(jsii.Number(30)),
	},
	Name: jsii.String("name"),
}

Experimental.

type NumericOverflowHandlingAction 

type NumericOverflowHandlingAction string

Specifies the action to perform when ORC data contains an integer (for example, BIGINT or int64) that is larger than the column definition (for example, SMALLINT or int16). See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"numeric_overflow_handling"_

Experimental. 

const (
	// Invalid character handling is turned off.
	// Experimental.
	NumericOverflowHandlingAction_DISABLED NumericOverflowHandlingAction = "DISABLED"
	// Cancel the query when the data includes invalid characters.
	// Experimental.
	NumericOverflowHandlingAction_FAIL NumericOverflowHandlingAction = "FAIL"
	// Set invalid characters to null.
	// Experimental.
	NumericOverflowHandlingAction_SET_TO_NULL NumericOverflowHandlingAction = "SET_TO_NULL"
	// Set each value in the row to null.
	// Experimental.
	NumericOverflowHandlingAction_DROP_ROW NumericOverflowHandlingAction = "DROP_ROW"
)

type OnDemandTriggerOptions 

type OnDemandTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
}

Properties for configuring an on-demand Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

onDemandTriggerOptions := &OnDemandTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
}

Experimental.

type OrcColumnMappingType 

type OrcColumnMappingType string

Specifies how to map columns when the table uses ORC data format. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"orc.schema.resolution"_

Experimental. 

const (
	// Map columns by name.
	// Experimental.
	OrcColumnMappingType_NAME OrcColumnMappingType = "NAME"
	// Map columns by position.
	// Experimental.
	OrcColumnMappingType_POSITION OrcColumnMappingType = "POSITION"
)

type OutputFormat 

type OutputFormat interface {
	// Experimental.
	ClassName() *string
}

Absolute class name of the Hadoop `OutputFormat` to use when writing table files.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

outputFormat := glue_alpha.NewOutputFormat(jsii.String("className"))

Experimental.

func NewOutputFormat 

func NewOutputFormat(className *string) OutputFormat

Experimental.

func OutputFormat_HIVE_IGNORE_KEY_TEXT 

func OutputFormat_HIVE_IGNORE_KEY_TEXT() OutputFormat

func OutputFormat_PARQUET 

func OutputFormat_PARQUET() OutputFormat

type PartitionIndex 

type PartitionIndex struct {
	// The partition key names that comprise the partition index.
	//
	// The names must correspond to a name in the
	// table's partition keys.
	// Experimental.
	KeyNames *[]*string `field:"required" json:"keyNames" yaml:"keyNames"`
	// The name of the partition index.
	// Default: - a name will be generated for you.
	//
	// Experimental.
	IndexName *string `field:"optional" json:"indexName" yaml:"indexName"`
}

Properties of a Partition Index.

Example: 

var myTable table

myTable.AddPartitionIndex(&PartitionIndex{
	IndexName: jsii.String("my-index"),
	KeyNames: []*string{
		jsii.String("year"),
	},
})

Experimental.

type Predicate 

type Predicate struct {
	// A list of the conditions that determine when the trigger will fire.
	// Default: - no conditions are provided.
	//
	// Experimental.
	Conditions *[]*Condition `field:"optional" json:"conditions" yaml:"conditions"`
	// The logical operator to be applied to the conditions.
	// Default: - ConditionLogical.AND if multiple conditions are provided, no logical operator if only one condition
	//
	// Experimental.
	Logical PredicateLogical `field:"optional" json:"logical" yaml:"logical"`
}

Represents a trigger predicate.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"

var job job

predicate := &Predicate{
	Conditions: []condition{
		&condition{
			CrawlerName: jsii.String("crawlerName"),
			CrawlState: glue_alpha.CrawlerState_RUNNING,
			Job: job,
			LogicalOperator: glue_alpha.ConditionLogicalOperator_EQUALS,
			State: glue_alpha.JobState_SUCCEEDED,
		},
	},
	Logical: glue_alpha.PredicateLogical_AND,
}

Experimental.

type PredicateLogical 

type PredicateLogical string

Experimental. 

const (
	// All conditions must be true for the predicate to be true.
	// Experimental.
	PredicateLogical_AND PredicateLogical = "AND"
	// At least one condition must be true for the predicate to be true.
	// Experimental.
	PredicateLogical_ANY PredicateLogical = "ANY"
)

type PySparkEtlJob 

type PySparkEtlJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

PySpark ETL Jobs class.

ETL jobs support pySpark and Scala languages, for which there are separate but similar constructors. ETL jobs default to the G2 worker type, but you can override this default with other supported worker type values (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can override to 3.0. The following ETL features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log. You can find more details about version, worker type and other features in Glue's public documentation.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("PySparkETLJob"),
	JobRunQueuingEnabled: jsii.Boolean(true),
})

Experimental.

func NewPySparkEtlJob 

func NewPySparkEtlJob(scope constructs.Construct, id *string, props *PySparkEtlJobProps) PySparkEtlJob

PySparkEtlJob constructor. Experimental.

type PySparkEtlJobProps 

type PySparkEtlJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no extra files specified.
	//
	// Experimental.
	ExtraFiles *[]Code `field:"optional" json:"extraFiles" yaml:"extraFiles"`
	// Extra Jars S3 URL (optional) S3 URL where additional jar dependencies are located.
	// Default: - no extra jar files.
	//
	// Experimental.
	ExtraJars *[]Code `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Extra Python Files S3 URL (optional) S3 URL where additional python dependencies are located.
	// Default: - no extra files.
	//
	// Experimental.
	ExtraPythonFiles *[]Code `field:"optional" json:"extraPythonFiles" yaml:"extraPythonFiles"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: false.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Properties for creating a Python Spark ETL job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("PySparkETLJob"),
	JobRunQueuingEnabled: jsii.Boolean(true),
})

Experimental.

type PySparkFlexEtlJob 

type PySparkFlexEtlJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Flex Jobs class.

Flex jobs supports Python and Scala language. The flexible execution class is appropriate for non-urgent jobs such as pre-production jobs, testing, and one-time data loads. Flexible job runs are supported for jobs using AWS Glue version 3.0 or later and G.1X or G.2X worker types but will default to the latest version of Glue (currently Glue 3.0.)

Similar to ETL, we’ll enable these features: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkFlexEtlJob(stack, jsii.String("ImportedJob"), &PySparkFlexEtlJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

func NewPySparkFlexEtlJob 

func NewPySparkFlexEtlJob(scope constructs.Construct, id *string, props *PySparkFlexEtlJobProps) PySparkFlexEtlJob

PySparkFlexEtlJob constructor. Experimental.

type PySparkFlexEtlJobProps 

type PySparkFlexEtlJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no extra files specified.
	//
	// Experimental.
	ExtraFiles *[]Code `field:"optional" json:"extraFiles" yaml:"extraFiles"`
	// Extra Jars S3 URL (optional) S3 URL where additional jar dependencies are located.
	// Default: - no extra jar files.
	//
	// Experimental.
	ExtraJars *[]Code `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Additional Python files that AWS Glue adds to the Python path before executing your script.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no extra python files specified.
	//
	// Experimental.
	ExtraPythonFiles *[]Code `field:"optional" json:"extraPythonFiles" yaml:"extraPythonFiles"`
	// Specifies configuration properties of a notification (optional).
	//
	// After a job run starts, the number of minutes to wait before sending a job run delay notification.
	// Default: - undefined.
	//
	// Experimental.
	NotifyDelayAfter awscdk.Duration `field:"optional" json:"notifyDelayAfter" yaml:"notifyDelayAfter"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Properties for PySparkFlexEtlJob.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkFlexEtlJob(stack, jsii.String("ImportedJob"), &PySparkFlexEtlJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

type PySparkStreamingJob 

type PySparkStreamingJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Python Spark Streaming Jobs class.

A Streaming job is similar to an ETL job, except that it performs ETL on data streams using the Apache Spark Structured Streaming framework. These jobs will default to use Python 3.9.

Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL, it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker and 4.0 version for streaming jobs which developers can override. We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkStreamingJob(stack, jsii.String("ImportedJob"), &PySparkStreamingJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

func NewPySparkStreamingJob 

func NewPySparkStreamingJob(scope constructs.Construct, id *string, props *PySparkStreamingJobProps) PySparkStreamingJob

PySparkStreamingJob constructor. Experimental.

type PySparkStreamingJobProps 

type PySparkStreamingJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no extra files specified.
	//
	// Experimental.
	ExtraFiles *[]Code `field:"optional" json:"extraFiles" yaml:"extraFiles"`
	// Extra Jars S3 URL (optional) S3 URL where additional jar dependencies are located.
	// Default: - no extra jar files.
	//
	// Experimental.
	ExtraJars *[]Code `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Extra Python Files S3 URL (optional) S3 URL where additional python dependencies are located.
	// Default: - no extra files.
	//
	// Experimental.
	ExtraPythonFiles *[]Code `field:"optional" json:"extraPythonFiles" yaml:"extraPythonFiles"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: - no job run queuing.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Properties for creating a Python Spark ETL job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkStreamingJob(stack, jsii.String("ImportedJob"), &PySparkStreamingJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

type PythonShellJob 

type PythonShellJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Python Shell Jobs class.

A Python shell job runs Python scripts as a shell and supports a Python version that depends on the AWS Glue version you are using. This can be used to schedule and run tasks that don't require an Apache Spark environment.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("ImportedJob"), &PythonShellJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

func NewPythonShellJob 

func NewPythonShellJob(scope constructs.Construct, id *string, props *PythonShellJobProps) PythonShellJob

PythonShellJob constructor. Experimental.

type PythonShellJobProps 

type PythonShellJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: false.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// The total number of DPU to assign to the Python Job.
	// Default: 0.0625
	//
	// Experimental.
	MaxCapacity MaxCapacity `field:"optional" json:"maxCapacity" yaml:"maxCapacity"`
	// Python Version The version of Python to use to execute this job.
	// Default: 3.9 for Shell Jobs
	//
	// Experimental.
	PythonVersion PythonVersion `field:"optional" json:"pythonVersion" yaml:"pythonVersion"`
}

Properties for creating a Python Shell job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("ImportedJob"), &PythonShellJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

type PythonVersion 

type PythonVersion string

Python version.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPythonShellJob(stack, jsii.String("PythonShellJob"), &PythonShellJobProps{
	JobName: jsii.String("PythonShellJobCustomName"),
	Description: jsii.String("This is a description"),
	PythonVersion: glue.PythonVersion_TWO,
	MaxCapacity: glue.MaxCapacity_DPU_1,
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V2_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

Experimental. 

const (
	// Python 2 (the exact version depends on GlueVersion and JobCommand used).
	// Experimental.
	PythonVersion_TWO PythonVersion = "TWO"
	// Python 3 (the exact version depends on GlueVersion and JobCommand used).
	// Experimental.
	PythonVersion_THREE PythonVersion = "THREE"
	// Python 3.9 (the exact version depends on GlueVersion and JobCommand used).
	// Experimental.
	PythonVersion_THREE_NINE PythonVersion = "THREE_NINE"
)

type RayJob 

type RayJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Ray Jobs class.

Glue Ray jobs use worker type Z.2X and Glue version 4.0. These are not overrideable since these are the only configuration that Glue Ray jobs currently support. The runtime defaults to Ray2.4 and min workers defaults to 3.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

func NewRayJob 

func NewRayJob(scope constructs.Construct, id *string, props *RayJobProps) RayJob

RayJob constructor. Experimental.

type RayJobProps 

type RayJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: - no job run queuing.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// Sets the Ray runtime environment version.
	// Default: - Runtime version will default to Ray2.4
	//
	// Experimental.
	Runtime Runtime `field:"optional" json:"runtime" yaml:"runtime"`
}

Properties for creating a Ray Glue job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
})

Experimental.

type Runtime 

type Runtime string

AWS Glue runtime determines the runtime engine of the job.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("RayCustomJobName"),
	Description: jsii.String("This is a description"),
	WorkerType: glue.WorkerType_Z_2X,
	NumberOfWorkers: jsii.Number(5),
	Runtime: glue.Runtime_RAY_TWO_FOUR,
	MaxRetries: jsii.Number(3),
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
})

Experimental. 

const (
	// Runtime for a Glue for Ray 2.4.
	// Experimental.
	Runtime_RAY_TWO_FOUR Runtime = "RAY_TWO_FOUR"
)

type S3Code 

type S3Code interface {
	Code
	// Called when the Job is initialized to allow this object to bind.
	// Experimental.
	Bind(_scope constructs.Construct, grantable awsiam.IGrantable) *CodeConfig
}

Glue job Code from an S3 bucket.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket

s3Code := glue_alpha.NewS3Code(bucket, jsii.String("key"))

Experimental.

func AssetCode_FromBucket 

func AssetCode_FromBucket(bucket awss3.IBucket, key *string) S3Code

Job code as an S3 object. Experimental.

func Code_FromBucket 

func Code_FromBucket(bucket awss3.IBucket, key *string) S3Code

Job code as an S3 object. Experimental.

func NewS3Code 

func NewS3Code(bucket awss3.IBucket, key *string) S3Code

Experimental.

func S3Code_FromBucket 

func S3Code_FromBucket(bucket awss3.IBucket, key *string) S3Code

Job code as an S3 object. Experimental.

type S3Encryption 

type S3Encryption struct {
	// Encryption mode.
	// Experimental.
	Mode S3EncryptionMode `field:"required" json:"mode" yaml:"mode"`
	// The KMS key to be used to encrypt the data.
	// Default: no kms key if mode = S3_MANAGED. A key will be created if one is not provided and mode = KMS.
	//
	// Experimental.
	KmsKey awskms.IKey `field:"optional" json:"kmsKey" yaml:"kmsKey"`
}

S3 encryption configuration.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

Experimental.

type S3EncryptionMode 

type S3EncryptionMode string

Encryption mode for S3.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

See: https://docs.aws.amazon.com/glue/latest/webapi/API_S3Encryption.html#Glue-Type-S3Encryption-S3EncryptionMode

Experimental. 

const (
	// Server side encryption (SSE) with an Amazon S3-managed key.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html
	//
	// Experimental.
	S3EncryptionMode_S3_MANAGED S3EncryptionMode = "S3_MANAGED"
	// Server-side encryption (SSE) with an AWS KMS key managed by the account owner.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
	//
	// Experimental.
	S3EncryptionMode_KMS S3EncryptionMode = "KMS"
)

type S3Table 

type S3Table interface {
	TableBase
	// S3 bucket in which the table's data resides.
	// Experimental.
	Bucket() awss3.IBucket
	// This table's columns.
	// Experimental.
	Columns() *[]*Column
	// Indicates whether the table's data is compressed or not.
	// Experimental.
	Compressed() *bool
	// Database this table belongs to.
	// Experimental.
	Database() IDatabase
	// Format of this table's data files.
	// Experimental.
	DataFormat() DataFormat
	// The type of encryption enabled for the table.
	// Experimental.
	Encryption() TableEncryption
	// The KMS key used to secure the data if `encryption` is set to `CSE-KMS` or `SSE-KMS`.
	//
	// Otherwise, `undefined`.
	// Experimental.
	EncryptionKey() awskms.IKey
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// The tables' properties associated with the table.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Experimental.
	Parameters() *map[string]*string
	// This table's partition indexes.
	// Experimental.
	PartitionIndexes() *[]*PartitionIndex
	// This table's partition keys if the table is partitioned.
	// Experimental.
	PartitionKeys() *[]*Column
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// S3 Key Prefix under which this table's files are stored in S3.
	// Experimental.
	S3Prefix() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The tables' storage descriptor properties.
	// Experimental.
	StorageParameters() *[]StorageParameter
	// ARN of this table.
	// Experimental.
	TableArn() *string
	// Name of this table.
	// Experimental.
	TableName() *string
	// Experimental.
	TableResource() awsglue.CfnTable
	// Add a partition index to the table.
	//
	// You can have a maximum of 3 partition
	// indexes to a table. Partition index keys must be a subset of the table's
	// partition keys.
	// See: https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html
	//
	// Experimental.
	AddPartitionIndex(index *PartitionIndex)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Experimental.
	GenerateS3PrefixForGrant() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity custom permissions.
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant read permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Experimental.
	GrantRead(grantee awsiam.IGrantable) awsiam.Grant
	// Grant read and write permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Experimental.
	GrantReadWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Grant the given identity custom permissions to ALL underlying resources of the table.
	//
	// Permissions will be granted to the catalog, the database, and the table.
	// Experimental.
	GrantToUnderlyingResources(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant write permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Experimental.
	GrantWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue table that targets a S3 dataset.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
	EnablePartitionFiltering: jsii.Boolean(true),
})

Experimental.

func NewS3Table 

func NewS3Table(scope constructs.Construct, id *string, props *S3TableProps) S3Table

Experimental.

type S3TableProps 

type S3TableProps struct {
	// Columns of the table.
	// Experimental.
	Columns *[]*Column `field:"required" json:"columns" yaml:"columns"`
	// Database in which to store the table.
	// Experimental.
	Database IDatabase `field:"required" json:"database" yaml:"database"`
	// Storage type of the table's data.
	// Experimental.
	DataFormat DataFormat `field:"required" json:"dataFormat" yaml:"dataFormat"`
	// Indicates whether the table's data is compressed or not.
	// Default: false.
	//
	// Experimental.
	Compressed *bool `field:"optional" json:"compressed" yaml:"compressed"`
	// Description of the table.
	// Default: generated.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables partition filtering.
	// See: https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	EnablePartitionFiltering *bool `field:"optional" json:"enablePartitionFiltering" yaml:"enablePartitionFiltering"`
	// The key/value pairs define properties associated with the table.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	Parameters *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
	// Partition indexes on the table.
	//
	// A maximum of 3 indexes
	// are allowed on a table. Keys in the index must be part
	// of the table's partition keys.
	// Default: table has no partition indexes.
	//
	// Experimental.
	PartitionIndexes *[]*PartitionIndex `field:"optional" json:"partitionIndexes" yaml:"partitionIndexes"`
	// Partition columns of the table.
	// Default: table is not partitioned.
	//
	// Experimental.
	PartitionKeys *[]*Column `field:"optional" json:"partitionKeys" yaml:"partitionKeys"`
	// The user-supplied properties for the description of the physical storage of this table.
	//
	// These properties help describe the format of the data that is stored within the crawled data sources.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	//
	// Some keys will be auto-populated by glue crawlers, however, you can override them by specifying the key and value in this property.
	//
	// Example:
	//      declare const glueDatabase: glue.IDatabase;
	//      const table = new glue.Table(this, 'Table', {
	//        storageParameters: [
	//            glue.StorageParameter.skipHeaderLineCount(1),
	//            glue.StorageParameter.compressionType(glue.CompressionType.GZIP),
	//            glue.StorageParameter.custom('foo', 'bar'), // Will have no effect
	//            glue.StorageParameter.custom('separatorChar', ','), // Will describe the separator char used in the data
	//            glue.StorageParameter.custom(glue.StorageParameters.WRITE_PARALLEL, 'off'),
	//        ],
	//        // ...
	//        database: glueDatabase,
	//        columns: [{
	//            name: 'col1',
	//            type: glue.Schema.STRING,
	//        }],
	//        dataFormat: glue.DataFormat.CSV,
	//      });
	//
	// See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	StorageParameters *[]StorageParameter `field:"optional" json:"storageParameters" yaml:"storageParameters"`
	// Indicates whether the table data is stored in subdirectories.
	// Default: false.
	//
	// Experimental.
	StoredAsSubDirectories *bool `field:"optional" json:"storedAsSubDirectories" yaml:"storedAsSubDirectories"`
	// Name of the table.
	// Default: - generated by CDK.
	//
	// Experimental.
	TableName *string `field:"optional" json:"tableName" yaml:"tableName"`
	// S3 bucket in which to store data.
	// Default: one is created for you.
	//
	// Experimental.
	Bucket awss3.IBucket `field:"optional" json:"bucket" yaml:"bucket"`
	// The kind of encryption to secure the data with.
	//
	// You can only provide this option if you are not explicitly passing in a bucket.
	//
	// If you choose `SSE-KMS`, you *can* provide an un-managed KMS key with `encryptionKey`.
	// If you choose `CSE-KMS`, you *must* provide an un-managed KMS key with `encryptionKey`.
	// Default: BucketEncryption.S3_MANAGED
	//
	// Experimental.
	Encryption TableEncryption `field:"optional" json:"encryption" yaml:"encryption"`
	// External KMS key to use for bucket encryption.
	//
	// The `encryption` property must be `SSE-KMS` or `CSE-KMS`.
	// Default: key is managed by KMS.
	//
	// Experimental.
	EncryptionKey awskms.IKey `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// S3 prefix under which table objects are stored.
	// Default: - No prefix. The data will be stored under the root of the bucket.
	//
	// Experimental.
	S3Prefix *string `field:"optional" json:"s3Prefix" yaml:"s3Prefix"`
}

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
	EnablePartitionFiltering: jsii.Boolean(true),
})

Experimental.

type ScalaSparkEtlJob 

type ScalaSparkEtlJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Spark ETL Jobs class.

ETL jobs support pySpark and Scala languages, for which there are separate but similar constructors. ETL jobs default to the G2 worker type, but you can override this default with other supported worker type values (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can override to 3.0. The following ETL features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log. You can find more details about version, worker type and other features in Glue's public documentation.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkEtlJob := glue_alpha.NewScalaSparkEtlJob(this, jsii.String("MyScalaSparkEtlJob"), &ScalaSparkEtlJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraJars: []*code{
		code,
	},
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	JobRunQueuingEnabled: jsii.Boolean(false),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
})

Experimental.

func NewScalaSparkEtlJob 

func NewScalaSparkEtlJob(scope constructs.Construct, id *string, props *ScalaSparkEtlJobProps) ScalaSparkEtlJob

ScalaSparkEtlJob constructor. Experimental.

type ScalaSparkEtlJobProps 

type ScalaSparkEtlJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Class name (required for Scala scripts) Package and class name for the entry point of Glue job execution for Java scripts.
	// Experimental.
	ClassName *string `field:"required" json:"className" yaml:"className"`
	// Extra Jars S3 URL (optional) S3 URL where additional jar dependencies are located.
	// Default: - no extra jar files.
	//
	// Experimental.
	ExtraJars *[]Code `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: - no job run queuing.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Properties for creating a Scala Spark ETL job.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkEtlJobProps := &ScalaSparkEtlJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraJars: []*code{
		code,
	},
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	JobRunQueuingEnabled: jsii.Boolean(false),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
}

Experimental.

type ScalaSparkFlexEtlJob 

type ScalaSparkFlexEtlJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Spark ETL Jobs class.

ETL jobs support pySpark and Scala languages, for which there are separate but similar constructors. ETL jobs default to the G2 worker type, but you can override this default with other supported worker type values (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can override to 3.0. The following ETL features are enabled by default: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log. You can find more details about version, worker type and other features in Glue's public documentation.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkFlexEtlJob := glue_alpha.NewScalaSparkFlexEtlJob(this, jsii.String("MyScalaSparkFlexEtlJob"), &ScalaSparkFlexEtlJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraFiles: []*code{
		code,
	},
	ExtraJars: []*code{
		code,
	},
	ExtraJarsFirst: jsii.Boolean(false),
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NotifyDelayAfter: cdk.Duration_Minutes(jsii.Number(30)),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_*Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
})

Experimental.

func NewScalaSparkFlexEtlJob 

func NewScalaSparkFlexEtlJob(scope constructs.Construct, id *string, props *ScalaSparkFlexEtlJobProps) ScalaSparkFlexEtlJob

ScalaSparkFlexEtlJob constructor. Experimental.

type ScalaSparkFlexEtlJobProps 

type ScalaSparkFlexEtlJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// The fully qualified Scala class name that serves as the entry point for the job.
	// See:  `--class` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	ClassName *string `field:"required" json:"className" yaml:"className"`
	// Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
	//
	// Only individual files are supported, directories are not supported.
	// See:  `--extra-files` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: [] - no extra files are copied to the working directory.
	//
	// Experimental.
	ExtraFiles *[]Code `field:"optional" json:"extraFiles" yaml:"extraFiles"`
	// Additional Java .jar files that AWS Glue adds to the Java classpath before executing your script. Only individual files are supported, directories are not supported.
	// See:  `--extra-jars` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: [] - no extra jars are added to the classpath.
	//
	// Experimental.
	ExtraJars *[]Code `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Setting this value to true prioritizes the customer's extra JAR files in the classpath.
	// See:  `--user-jars-first` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: false - priority is not given to user-provided jars.
	//
	// Experimental.
	ExtraJarsFirst *bool `field:"optional" json:"extraJarsFirst" yaml:"extraJarsFirst"`
	// Specifies configuration properties of a notification (optional).
	//
	// After a job run starts, the number of minutes to wait before sending a job run delay notification.
	// Default: - undefined.
	//
	// Experimental.
	NotifyDelayAfter awscdk.Duration `field:"optional" json:"notifyDelayAfter" yaml:"notifyDelayAfter"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Flex Jobs class.

Flex jobs supports Python and Scala language. The flexible execution class is appropriate for non-urgent jobs such as pre-production jobs, testing, and one-time data loads. Flexible job runs are supported for jobs using AWS Glue version 3.0 or later and G.1X or G.2X worker types but will default to the latest version of Glue (currently Glue 3.0.)

Similar to ETL, we’ll enable these features: —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkFlexEtlJobProps := &ScalaSparkFlexEtlJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraFiles: []*code{
		code,
	},
	ExtraJars: []*code{
		code,
	},
	ExtraJarsFirst: jsii.Boolean(false),
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NotifyDelayAfter: cdk.Duration_Minutes(jsii.Number(30)),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_*Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
}

Experimental.

type ScalaSparkStreamingJob 

type ScalaSparkStreamingJob interface {
	Job
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The ARN of the job.
	// Experimental.
	JobArn() *string
	// The name of the job.
	// Experimental.
	JobName() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The IAM role Glue assumes to run this job.
	// Experimental.
	Role() awsiam.IRole
	// The Spark UI logs location if Spark UI monitoring and debugging is enabled.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	SparkUILoggingLocation() *SparkUILoggingLocation
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the job arn.
	// Experimental.
	BuildJobArn(scope constructs.Construct, jobName *string) *string
	// Check no usage of reserved arguments.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Experimental.
	CheckNoReservedArgs(defaultArguments *map[string]*string) *map[string]*string
	// Experimental.
	CodeS3ObjectUrl(code Code) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Create a CloudWatch metric.
	// See: https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
	//
	// Experimental.
	Metric(metricName *string, type_ MetricType, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job failure.
	//
	// This metric is based on the Rule returned by no-args onFailure() call.
	// Experimental.
	MetricFailure(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job success.
	//
	// This metric is based on the Rule returned by no-args onSuccess() call.
	// Experimental.
	MetricSuccess(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Return a CloudWatch Metric indicating job timeout.
	//
	// This metric is based on the Rule returned by no-args onTimeout() call.
	// Experimental.
	MetricTimeout(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Create a CloudWatch Event Rule for this Glue Job when it's in a given state.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching FAILED state.
	// Experimental.
	OnFailure(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule for the transition into the input jobState.
	// Experimental.
	OnStateChange(id *string, jobState JobState, options *awsevents.OnEventOptions) awsevents.Rule
	// Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
	// Experimental.
	OnSuccess(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Return a CloudWatch Event Rule matching TIMEOUT state.
	// Experimental.
	OnTimeout(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Setup Continuous Loggiung Properties.
	//
	// Returns: String containing the args for the continuous logging command.
	// Experimental.
	SetupContinuousLogging(role awsiam.IRole, props *ContinuousLoggingProps) interface{}
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Scala Streaming Jobs class.

A Streaming job is similar to an ETL job, except that it performs ETL on data streams using the Apache Spark Structured Streaming framework. These jobs will default to use Python 3.9.

Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL, it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker and 4.0 version for streaming jobs which developers can override. We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkStreamingJob := glue_alpha.NewScalaSparkStreamingJob(this, jsii.String("MyScalaSparkStreamingJob"), &ScalaSparkStreamingJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraJars: []*string{
		jsii.String("extraJars"),
	},
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	JobRunQueuingEnabled: jsii.Boolean(false),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
})

Experimental.

func NewScalaSparkStreamingJob 

func NewScalaSparkStreamingJob(scope constructs.Construct, id *string, props *ScalaSparkStreamingJobProps) ScalaSparkStreamingJob

ScalaSparkStreamingJob constructor. Experimental.

type ScalaSparkStreamingJobProps 

type ScalaSparkStreamingJobProps struct {
	// IAM Role (required) IAM Role to use for Glue job execution Must be specified by the developer because the L2 doesn't have visibility into the actions the script(s) takes during the job execution The role must trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions.
	// See: https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html
	//
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
	// Script Code Location (required) Script to run when the Glue job executes.
	//
	// Can be uploaded
	// from the local directory structure using fromAsset
	// or referenced via S3 location using fromBucket.
	// Experimental.
	Script Code `field:"required" json:"script" yaml:"script"`
	// Connections (optional) List of connections to use for this Glue job Connections are used to connect to other AWS Service or resources within a VPC.
	// Default: [] - no connections are added to the job.
	//
	// Experimental.
	Connections *[]IConnection `field:"optional" json:"connections" yaml:"connections"`
	// Enables continuous logging with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - continuous logging is enabled.
	//
	// Experimental.
	ContinuousLogging *ContinuousLoggingProps `field:"optional" json:"continuousLogging" yaml:"continuousLogging"`
	// Default Arguments (optional) The default arguments for every run of this Glue job, specified as name-value pairs.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	// for a list of reserved parameters.
	//
	// Default: - no arguments.
	//
	// Experimental.
	DefaultArguments *map[string]*string `field:"optional" json:"defaultArguments" yaml:"defaultArguments"`
	// Description (optional) Developer-specified description of the Glue job.
	// Default: - no value.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables the collection of metrics for job profiling.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - no profiling metrics emitted.
	//
	// Experimental.
	EnableProfilingMetrics *bool `field:"optional" json:"enableProfilingMetrics" yaml:"enableProfilingMetrics"`
	// Glue Version The version of Glue to use to execute this job.
	// Default: 3.0 for ETL
	//
	// Experimental.
	GlueVersion GlueVersion `field:"optional" json:"glueVersion" yaml:"glueVersion"`
	// Name of the Glue job (optional) Developer-specified name of the Glue job.
	// Default: - a name is automatically generated.
	//
	// Experimental.
	JobName *string `field:"optional" json:"jobName" yaml:"jobName"`
	// Max Concurrent Runs (optional) The maximum number of runs this Glue job can concurrently run.
	//
	// An error is returned when this threshold is reached. The maximum value
	// you can specify is controlled by a service limit.
	// Default: 1.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Max Retries (optional) Maximum number of retry attempts Glue performs if the job fails.
	// Default: 0.
	//
	// Experimental.
	MaxRetries *float64 `field:"optional" json:"maxRetries" yaml:"maxRetries"`
	// Number of Workers (optional) Number of workers for Glue to use during job execution.
	// Default: 10.
	//
	// Experimental.
	NumberOfWorkers *float64 `field:"optional" json:"numberOfWorkers" yaml:"numberOfWorkers"`
	// Security Configuration (optional) Defines the encryption options for the Glue job.
	// Default: - no security configuration.
	//
	// Experimental.
	SecurityConfiguration ISecurityConfiguration `field:"optional" json:"securityConfiguration" yaml:"securityConfiguration"`
	// Tags (optional) A list of key:value pairs of tags to apply to this Glue job resources.
	// Default: {} - no tags.
	//
	// Experimental.
	Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
	// Timeout (optional) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status.
	//
	// Specified in minutes.
	// Default: 2880 (2 days for non-streaming).
	//
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// Worker Type (optional) Type of Worker for Glue to use during job execution Enum options: Standard, G_1X, G_2X, G_025X.
	//
	// G_4X, G_8X, Z_2X.
	// Default: WorkerType.G_1X
	//
	// Experimental.
	WorkerType WorkerType `field:"optional" json:"workerType" yaml:"workerType"`
	// Class name (required for Scala scripts) Package and class name for the entry point of Glue job execution for Java scripts.
	// Experimental.
	ClassName *string `field:"required" json:"className" yaml:"className"`
	// Extra Jars S3 URL (optional) S3 URL where additional jar dependencies are located.
	// Default: - no extra jar files.
	//
	// Experimental.
	ExtraJars *[]*string `field:"optional" json:"extraJars" yaml:"extraJars"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: - no job run queuing.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// Enables the Spark UI debugging and monitoring with the specified props.
	// See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
	//
	// Default: - Spark UI debugging and monitoring is disabled.
	//
	// Experimental.
	SparkUI *SparkUIProps `field:"optional" json:"sparkUI" yaml:"sparkUI"`
}

Properties for creating a Scala Spark ETL job.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var code code
var connection connection
var logGroup logGroup
var role role
var securityConfiguration securityConfiguration

scalaSparkStreamingJobProps := &ScalaSparkStreamingJobProps{
	ClassName: jsii.String("className"),
	Role: role,
	Script: code,

	// the properties below are optional
	Connections: []iConnection{
		connection,
	},
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),

		// the properties below are optional
		ConversionPattern: jsii.String("conversionPattern"),
		LogGroup: logGroup,
		LogStreamPrefix: jsii.String("logStreamPrefix"),
		Quiet: jsii.Boolean(false),
	},
	DefaultArguments: map[string]*string{
		"defaultArgumentsKey": jsii.String("defaultArguments"),
	},
	Description: jsii.String("description"),
	EnableProfilingMetrics: jsii.Boolean(false),
	ExtraJars: []*string{
		jsii.String("extraJars"),
	},
	GlueVersion: glue_alpha.GlueVersion_V0_9,
	JobName: jsii.String("jobName"),
	JobRunQueuingEnabled: jsii.Boolean(false),
	MaxConcurrentRuns: jsii.Number(123),
	MaxRetries: jsii.Number(123),
	NumberOfWorkers: jsii.Number(123),
	SecurityConfiguration: securityConfiguration,
	SparkUI: &SparkUIProps{
		Bucket: bucket,
		JobRunQueuingEnabled: jsii.Boolean(false),
		Prefix: jsii.String("prefix"),
	},
	Tags: map[string]*string{
		"tagsKey": jsii.String("tags"),
	},
	Timeout: cdk.Duration_Minutes(jsii.Number(30)),
	WorkerType: glue_alpha.WorkerType_STANDARD,
}

Experimental.

type Schema 

type Schema interface {
}

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

See: https://docs.aws.amazon.com/athena/latest/ug/data-types.html

Experimental.

func NewSchema 

func NewSchema() Schema

Experimental.

type SecurityConfiguration 

type SecurityConfiguration interface {
	awscdk.Resource
	ISecurityConfiguration
	// The KMS key used in CloudWatch encryption if it requires a kms key.
	// Experimental.
	CloudWatchEncryptionKey() awskms.IKey
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The KMS key used in job bookmarks encryption if it requires a kms key.
	// Experimental.
	JobBookmarksEncryptionKey() awskms.IKey
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The KMS key used in S3 encryption if it requires a kms key.
	// Experimental.
	S3EncryptionKey() awskms.IKey
	// The name of the security configuration.
	// Experimental.
	SecurityConfigurationName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A security configuration is a set of security properties that can be used by AWS Glue to encrypt data at rest.

The following scenarios show some of the ways that you can use a security configuration. - Attach a security configuration to an AWS Glue crawler to write encrypted Amazon CloudWatch Logs. - Attach a security configuration to an extract, transform, and load (ETL) job to write encrypted Amazon Simple Storage Service (Amazon S3) targets and encrypted CloudWatch Logs. - Attach a security configuration to an ETL job to write its jobs bookmarks as encrypted Amazon S3 data. - Attach a security configuration to a development endpoint to write encrypted Amazon S3 targets.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewRayJob(stack, jsii.String("ImportedJob"), &RayJobProps{
	Role: Role,
	Script: Script,
	JobName: jsii.String("RayCustomJobName"),
	Description: jsii.String("This is a description"),
	WorkerType: glue.WorkerType_Z_2X,
	NumberOfWorkers: jsii.Number(5),
	Runtime: glue.Runtime_RAY_TWO_FOUR,
	MaxRetries: jsii.Number(3),
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
})

Experimental.

func NewSecurityConfiguration 

func NewSecurityConfiguration(scope constructs.Construct, id *string, props *SecurityConfigurationProps) SecurityConfiguration

Experimental.

type SecurityConfigurationProps 

type SecurityConfigurationProps struct {
	// The encryption configuration for Amazon CloudWatch Logs.
	// Default: no cloudwatch logs encryption.
	//
	// Experimental.
	CloudWatchEncryption *CloudWatchEncryption `field:"optional" json:"cloudWatchEncryption" yaml:"cloudWatchEncryption"`
	// The encryption configuration for Glue Job Bookmarks.
	// Default: no job bookmarks encryption.
	//
	// Experimental.
	JobBookmarksEncryption *JobBookmarksEncryption `field:"optional" json:"jobBookmarksEncryption" yaml:"jobBookmarksEncryption"`
	// The encryption configuration for Amazon Simple Storage Service (Amazon S3) data.
	// Default: no s3 encryption.
	//
	// Experimental.
	S3Encryption *S3Encryption `field:"optional" json:"s3Encryption" yaml:"s3Encryption"`
	// The name of the security configuration.
	// Default: - generated by CDK.
	//
	// Experimental.
	SecurityConfigurationName *string `field:"optional" json:"securityConfigurationName" yaml:"securityConfigurationName"`
}

Constructions properties of `SecurityConfiguration`.

Example: 

glue.NewSecurityConfiguration(this, jsii.String("MySecurityConfiguration"), &SecurityConfigurationProps{
	CloudWatchEncryption: &CloudWatchEncryption{
		Mode: glue.CloudWatchEncryptionMode_KMS,
	},
	JobBookmarksEncryption: &JobBookmarksEncryption{
		Mode: glue.JobBookmarksEncryptionMode_CLIENT_SIDE_KMS,
	},
	S3Encryption: &S3Encryption{
		Mode: glue.S3EncryptionMode_KMS,
	},
})

Experimental.

type SerializationLibrary 

type SerializationLibrary interface {
	// Experimental.
	ClassName() *string
}

Serialization library to use when serializing/deserializing (SerDe) table records.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

serializationLibrary := glue_alpha.SerializationLibrary_AVRO()

See: https://cwiki.apache.org/confluence/display/Hive/SerDe

Experimental.

func NewSerializationLibrary 

func NewSerializationLibrary(className *string) SerializationLibrary

Experimental.

func SerializationLibrary_AVRO 

func SerializationLibrary_AVRO() SerializationLibrary

func SerializationLibrary_CLOUDTRAIL 

func SerializationLibrary_CLOUDTRAIL() SerializationLibrary

func SerializationLibrary_GROK 

func SerializationLibrary_GROK() SerializationLibrary

func SerializationLibrary_HIVE_JSON 

func SerializationLibrary_HIVE_JSON() SerializationLibrary

func SerializationLibrary_LAZY_SIMPLE 

func SerializationLibrary_LAZY_SIMPLE() SerializationLibrary

func SerializationLibrary_OPENX_JSON 

func SerializationLibrary_OPENX_JSON() SerializationLibrary

func SerializationLibrary_OPEN_CSV 

func SerializationLibrary_OPEN_CSV() SerializationLibrary

func SerializationLibrary_ORC 

func SerializationLibrary_ORC() SerializationLibrary

func SerializationLibrary_PARQUET 

func SerializationLibrary_PARQUET() SerializationLibrary

func SerializationLibrary_REGEXP 

func SerializationLibrary_REGEXP() SerializationLibrary

type SparkUILoggingLocation 

type SparkUILoggingLocation struct {
	// The bucket where the Glue job stores the logs.
	// Experimental.
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	// The path inside the bucket (objects prefix) where the Glue job stores the logs.
	// Default: '/' - the logs will be written at the root of the bucket.
	//
	// Experimental.
	Prefix *string `field:"optional" json:"prefix" yaml:"prefix"`
}

The Spark UI logging location.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket

sparkUILoggingLocation := &SparkUILoggingLocation{
	Bucket: bucket,

	// the properties below are optional
	Prefix: jsii.String("prefix"),
}

See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html

Experimental.

type SparkUIProps 

type SparkUIProps struct {
	// The bucket where the Glue job stores the logs.
	// Default: a new bucket will be created.
	//
	// Experimental.
	Bucket awss3.IBucket `field:"optional" json:"bucket" yaml:"bucket"`
	// Specifies whether job run queuing is enabled for the job runs for this job.
	//
	// A value of true means job run queuing is enabled for the job runs.
	// If false or not populated, the job runs will not be considered for queueing.
	// If this field does not match the value set in the job run, then the value from
	// the job run field will be used. This property must be set to false for flex jobs.
	// If this property is enabled, maxRetries must be set to zero.
	// Default: - no job run queuing.
	//
	// Experimental.
	JobRunQueuingEnabled *bool `field:"optional" json:"jobRunQueuingEnabled" yaml:"jobRunQueuingEnabled"`
	// The path inside the bucket (objects prefix) where the Glue job stores the logs.
	//
	// Use format `'/foo/bar'`.
	// Default: - the logs will be written at the root of the bucket.
	//
	// Experimental.
	Prefix *string `field:"optional" json:"prefix" yaml:"prefix"`
}

Properties for enabling Spark UI monitoring feature for Spark-based Glue jobs.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket

sparkUIProps := &SparkUIProps{
	Bucket: bucket,
	JobRunQueuingEnabled: jsii.Boolean(false),
	Prefix: jsii.String("prefix"),
}

See: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html

Experimental.

type StorageParameter 

type StorageParameter interface {
	// Experimental.
	Key() *string
	// Experimental.
	Value() *string
}

A storage parameter. The list of storage parameters available is not exhaustive and other keys may be used.

If you would like to specify a storage parameter that is not available as a static member of this class, use the `StorageParameter.custom` method.

The list of storage parameters currently known within the CDK is listed.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	StorageParameters: []storageParameter{
		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
		glue.*storageParameter_Custom(jsii.String("separatorChar"), jsii.String(",")),
	},
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_

Experimental.

func NewStorageParameter 

func NewStorageParameter(key *string, value *string) StorageParameter

Experimental.

func StorageParameter_ColumnCountMismatchHandling 

func StorageParameter_ColumnCountMismatchHandling(value ColumnCountMismatchHandlingAction) StorageParameter

Identifies if the file contains less or more values for a row than the number of columns specified in the external table definition.

This property is only available for an uncompressed text file format. Experimental.

func StorageParameter_CompressionType 

func StorageParameter_CompressionType(value CompressionType) StorageParameter

The type of compression used on the table, when the file name does not contain an extension.

This value overrides the compression type specified through the extension. Experimental.

func StorageParameter_Custom 

func StorageParameter_Custom(key *string, value interface{}) StorageParameter

A custom storage parameter. Experimental.

func StorageParameter_DataCleansingEnabled 

func StorageParameter_DataCleansingEnabled(value *bool) StorageParameter

Determines whether data handling is on for the table. Experimental.

func StorageParameter_InvalidCharHandling 

func StorageParameter_InvalidCharHandling(value InvalidCharHandlingAction) StorageParameter

Specifies the action to perform when query results contain invalid UTF-8 character values. Experimental.

func StorageParameter_NumRows 

func StorageParameter_NumRows(value *float64) StorageParameter

A property that sets the numRows value for the table definition.

To explicitly update an external table's statistics, set the numRows property to indicate the size of the table. Amazon Redshift doesn't analyze external tables to generate the table statistics that the query optimizer uses to generate a query plan. If table statistics aren't set for an external table, Amazon Redshift generates a query execution plan based on an assumption that external tables are the larger tables and local tables are the smaller tables. Experimental.

func StorageParameter_NumericOverflowHandling 

func StorageParameter_NumericOverflowHandling(value NumericOverflowHandlingAction) StorageParameter

Specifies the action to perform when ORC data contains an integer (for example, BIGINT or int64) that is larger than the column definition (for example, SMALLINT or int16). Experimental.

func StorageParameter_OrcSchemaResolution 

func StorageParameter_OrcSchemaResolution(value OrcColumnMappingType) StorageParameter

A property that sets the column mapping type for tables that use ORC data format.

This property is ignored for other data formats. If this property is omitted, columns are mapped by `OrcColumnMappingType.NAME` by default. Default: OrcColumnMappingType.NAME

Experimental.

func StorageParameter_ReplacementChar 

func StorageParameter_ReplacementChar(value *string) StorageParameter

Specifies the replacement character to use when you set `INVALID_CHAR_HANDLING` to `REPLACE`. Experimental.

func StorageParameter_SerializationNullFormat 

func StorageParameter_SerializationNullFormat(value *string) StorageParameter

A property that sets number of rows to skip at the beginning of each source file. Experimental.

func StorageParameter_SkipHeaderLineCount 

func StorageParameter_SkipHeaderLineCount(value *float64) StorageParameter

The number of rows to skip at the top of a CSV file when the table is being created. Experimental.

func StorageParameter_SurplusBytesHandling 

func StorageParameter_SurplusBytesHandling(value SurplusBytesHandlingAction) StorageParameter

Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARBYTE data.

By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column. Experimental.

func StorageParameter_SurplusCharHandling 

func StorageParameter_SurplusCharHandling(value SurplusCharHandlingAction) StorageParameter

Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARCHAR, CHAR, or string data.

By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column. Experimental.

func StorageParameter_WriteKmsKeyId 

func StorageParameter_WriteKmsKeyId(value *string) StorageParameter

You can specify an AWS Key Management Service key to enable Server–Side Encryption (SSE) for Amazon S3 objects. Experimental.

func StorageParameter_WriteMaxFileSizeMb 

func StorageParameter_WriteMaxFileSizeMb(value *float64) StorageParameter

A property that sets the maximum size (in MB) of each file written to Amazon S3 by CREATE EXTERNAL TABLE AS.

The size must be a valid integer between 5 and 6200. The default maximum file size is 6,200 MB. This table property also applies to any subsequent INSERT statement into the same external table. Experimental.

func StorageParameter_WriteParallel 

func StorageParameter_WriteParallel(value WriteParallel) StorageParameter

A property that sets whether CREATE EXTERNAL TABLE AS should write data in parallel.

When 'write.parallel' is set to off, CREATE EXTERNAL TABLE AS writes to one or more data files serially onto Amazon S3. This table property also applies to any subsequent INSERT statement into the same external table. Default: WriteParallel.ON

Experimental.

type StorageParameters 

type StorageParameters string

The storage parameter keys that are currently known, this list is not exhaustive and other keys may be used.

Example: 

var glueDatabase iDatabase

table := glue.NewTable(this, jsii.String("Table"), &S3TableProps{
	StorageParameters: []storageParameter{
		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
		glue.*storageParameter_Custom(jsii.String("foo"), jsii.String("bar")),
		glue.*storageParameter_*Custom(jsii.String("separatorChar"), jsii.String(",")),
		glue.*storageParameter_*Custom(glue.StorageParameters_WRITE_PARALLEL, jsii.String("off")),
	},
	// ...
	Database: glueDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_CSV(),
})

Experimental. 

const (
	// The number of rows to skip at the top of a CSV file when the table is being created.
	// Experimental.
	StorageParameters_SKIP_HEADER_LINE_COUNT StorageParameters = "SKIP_HEADER_LINE_COUNT"
	// Determines whether data handling is on for the table.
	// Experimental.
	StorageParameters_DATA_CLEANSING_ENABLED StorageParameters = "DATA_CLEANSING_ENABLED"
	// The type of compression used on the table, when the file name does not contain an extension.
	//
	// This value overrides the compression type specified through the extension.
	// Experimental.
	StorageParameters_COMPRESSION_TYPE StorageParameters = "COMPRESSION_TYPE"
	// Specifies the action to perform when query results contain invalid UTF-8 character values.
	// Experimental.
	StorageParameters_INVALID_CHAR_HANDLING StorageParameters = "INVALID_CHAR_HANDLING"
	// Specifies the replacement character to use when you set `INVALID_CHAR_HANDLING` to `REPLACE`.
	// Experimental.
	StorageParameters_REPLACEMENT_CHAR StorageParameters = "REPLACEMENT_CHAR"
	// Specifies the action to perform when ORC data contains an integer (for example, BIGINT or int64) that is larger than the column definition (for example, SMALLINT or int16).
	// Experimental.
	StorageParameters_NUMERIC_OVERFLOW_HANDLING StorageParameters = "NUMERIC_OVERFLOW_HANDLING"
	// Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARBYTE data.
	//
	// By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column.
	// Experimental.
	StorageParameters_SURPLUS_BYTES_HANDLING StorageParameters = "SURPLUS_BYTES_HANDLING"
	// Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARCHAR, CHAR, or string data.
	//
	// By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column.
	// Experimental.
	StorageParameters_SURPLUS_CHAR_HANDLING StorageParameters = "SURPLUS_CHAR_HANDLING"
	// Identifies if the file contains less or more values for a row than the number of columns specified in the external table definition.
	//
	// This property is only available for an uncompressed text file format.
	// Experimental.
	StorageParameters_COLUMN_COUNT_MISMATCH_HANDLING StorageParameters = "COLUMN_COUNT_MISMATCH_HANDLING"
	// A property that sets the numRows value for the table definition.
	//
	// To explicitly update an external table's statistics, set the numRows property to indicate the size of the table. Amazon Redshift doesn't analyze external tables to generate the table statistics that the query optimizer uses to generate a query plan. If table statistics aren't set for an external table, Amazon Redshift generates a query execution plan based on an assumption that external tables are the larger tables and local tables are the smaller tables.
	// Experimental.
	StorageParameters_NUM_ROWS StorageParameters = "NUM_ROWS"
	// A property that sets number of rows to skip at the beginning of each source file.
	// Experimental.
	StorageParameters_SERIALIZATION_NULL_FORMAT StorageParameters = "SERIALIZATION_NULL_FORMAT"
	// A property that sets the column mapping type for tables that use ORC data format.
	//
	// This property is ignored for other data formats.
	// Experimental.
	StorageParameters_ORC_SCHEMA_RESOLUTION StorageParameters = "ORC_SCHEMA_RESOLUTION"
	// A property that sets whether CREATE EXTERNAL TABLE AS should write data in parallel.
	//
	// When 'write.parallel' is set to off, CREATE EXTERNAL TABLE AS writes to one or more data files serially onto Amazon S3. This table property also applies to any subsequent INSERT statement into the same external table.
	// Experimental.
	StorageParameters_WRITE_PARALLEL StorageParameters = "WRITE_PARALLEL"
	// A property that sets the maximum size (in MB) of each file written to Amazon S3 by CREATE EXTERNAL TABLE AS.
	//
	// The size must be a valid integer between 5 and 6200. The default maximum file size is 6,200 MB. This table property also applies to any subsequent INSERT statement into the same external table.
	// Experimental.
	StorageParameters_WRITE_MAX_FILESIZE_MB StorageParameters = "WRITE_MAX_FILESIZE_MB"
	// You can specify an AWS Key Management Service key to enable Server–Side Encryption (SSE) for Amazon S3 objects.
	// Experimental.
	StorageParameters_WRITE_KMS_KEY_ID StorageParameters = "WRITE_KMS_KEY_ID"
)

type SurplusBytesHandlingAction 

type SurplusBytesHandlingAction string

Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARBYTE data.

By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"surplus_bytes_handling"_

Experimental. 

const (
	// Replaces data that exceeds the column width with null.
	// Experimental.
	SurplusBytesHandlingAction_SET_TO_NULL SurplusBytesHandlingAction = "SET_TO_NULL"
	// Doesn't perform surplus byte handling.
	// Experimental.
	SurplusBytesHandlingAction_DISABLED SurplusBytesHandlingAction = "DISABLED"
	// Cancels queries that return data exceeding the column width.
	// Experimental.
	SurplusBytesHandlingAction_FAIL SurplusBytesHandlingAction = "FAIL"
	// Drop all rows that contain data exceeding column width.
	// Experimental.
	SurplusBytesHandlingAction_DROP_ROW SurplusBytesHandlingAction = "DROP_ROW"
	// Removes the characters that exceed the maximum number of characters defined for the column.
	// Experimental.
	SurplusBytesHandlingAction_TRUNCATE SurplusBytesHandlingAction = "TRUNCATE"
)

type SurplusCharHandlingAction 

type SurplusCharHandlingAction string

Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARCHAR, CHAR, or string data.

By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"surplus_char_handling"_

Experimental. 

const (
	// Replaces data that exceeds the column width with null.
	// Experimental.
	SurplusCharHandlingAction_SET_TO_NULL SurplusCharHandlingAction = "SET_TO_NULL"
	// Doesn't perform surplus character handling.
	// Experimental.
	SurplusCharHandlingAction_DISABLED SurplusCharHandlingAction = "DISABLED"
	// Cancels queries that return data exceeding the column width.
	// Experimental.
	SurplusCharHandlingAction_FAIL SurplusCharHandlingAction = "FAIL"
	// Replaces each value in the row with null.
	// Experimental.
	SurplusCharHandlingAction_DROP_ROW SurplusCharHandlingAction = "DROP_ROW"
	// Removes the characters that exceed the maximum number of characters defined for the column.
	// Experimental.
	SurplusCharHandlingAction_TRUNCATE SurplusCharHandlingAction = "TRUNCATE"
)

type Table deprecated 

type Table interface {
	S3Table
	// S3 bucket in which the table's data resides.
	// Deprecated: Use {@link S3Table } instead.
	Bucket() awss3.IBucket
	// This table's columns.
	// Deprecated: Use {@link S3Table } instead.
	Columns() *[]*Column
	// Indicates whether the table's data is compressed or not.
	// Deprecated: Use {@link S3Table } instead.
	Compressed() *bool
	// Database this table belongs to.
	// Deprecated: Use {@link S3Table } instead.
	Database() IDatabase
	// Format of this table's data files.
	// Deprecated: Use {@link S3Table } instead.
	DataFormat() DataFormat
	// The type of encryption enabled for the table.
	// Deprecated: Use {@link S3Table } instead.
	Encryption() TableEncryption
	// The KMS key used to secure the data if `encryption` is set to `CSE-KMS` or `SSE-KMS`.
	//
	// Otherwise, `undefined`.
	// Deprecated: Use {@link S3Table } instead.
	EncryptionKey() awskms.IKey
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Deprecated: Use {@link S3Table } instead.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Deprecated: Use {@link S3Table } instead.
	Node() constructs.Node
	// The tables' properties associated with the table.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Deprecated: Use {@link S3Table } instead.
	Parameters() *map[string]*string
	// This table's partition indexes.
	// Deprecated: Use {@link S3Table } instead.
	PartitionIndexes() *[]*PartitionIndex
	// This table's partition keys if the table is partitioned.
	// Deprecated: Use {@link S3Table } instead.
	PartitionKeys() *[]*Column
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Deprecated: Use {@link S3Table } instead.
	PhysicalName() *string
	// S3 Key Prefix under which this table's files are stored in S3.
	// Deprecated: Use {@link S3Table } instead.
	S3Prefix() *string
	// The stack in which this resource is defined.
	// Deprecated: Use {@link S3Table } instead.
	Stack() awscdk.Stack
	// The tables' storage descriptor properties.
	// Deprecated: Use {@link S3Table } instead.
	StorageParameters() *[]StorageParameter
	// ARN of this table.
	// Deprecated: Use {@link S3Table } instead.
	TableArn() *string
	// Name of this table.
	// Deprecated: Use {@link S3Table } instead.
	TableName() *string
	// Deprecated: Use {@link S3Table } instead.
	TableResource() awsglue.CfnTable
	// Add a partition index to the table.
	//
	// You can have a maximum of 3 partition
	// indexes to a table. Partition index keys must be a subset of the table's
	// partition keys.
	// See: https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html
	//
	// Deprecated: Use {@link S3Table } instead.
	AddPartitionIndex(index *PartitionIndex)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Deprecated: Use {@link S3Table } instead.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Deprecated: Use {@link S3Table } instead.
	GeneratePhysicalName() *string
	// Deprecated: Use {@link S3Table } instead.
	GenerateS3PrefixForGrant() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Deprecated: Use {@link S3Table } instead.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Deprecated: Use {@link S3Table } instead.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity custom permissions.
	// Deprecated: Use {@link S3Table } instead.
	Grant(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant read permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Deprecated: Use {@link S3Table } instead.
	GrantRead(grantee awsiam.IGrantable) awsiam.Grant
	// Grant read and write permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Deprecated: Use {@link S3Table } instead.
	GrantReadWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Grant the given identity custom permissions to ALL underlying resources of the table.
	//
	// Permissions will be granted to the catalog, the database, and the table.
	// Deprecated: Use {@link S3Table } instead.
	GrantToUnderlyingResources(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Grant write permissions to the table and the underlying data stored in S3 to an IAM principal.
	// Deprecated: Use {@link S3Table } instead.
	GrantWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Returns a string representation of this construct.
	// Deprecated: Use {@link S3Table } instead.
	ToString() *string
}

A Glue table.

Example: 

var glueDatabase iDatabase

table := glue.NewTable(this, jsii.String("Table"), &S3TableProps{
	StorageParameters: []storageParameter{
		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
		glue.*storageParameter_Custom(jsii.String("foo"), jsii.String("bar")),
		glue.*storageParameter_*Custom(jsii.String("separatorChar"), jsii.String(",")),
		glue.*storageParameter_*Custom(glue.StorageParameters_WRITE_PARALLEL, jsii.String("off")),
	},
	// ...
	Database: glueDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_CSV(),
})

Deprecated: Use {@link S3Table } instead.

func NewTable deprecated 

func NewTable(scope constructs.Construct, id *string, props *S3TableProps) Table

Deprecated: Use {@link S3Table } instead.

type TableAttributes 

type TableAttributes struct {
	// Experimental.
	TableArn *string `field:"required" json:"tableArn" yaml:"tableArn"`
	// Experimental.
	TableName *string `field:"required" json:"tableName" yaml:"tableName"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

tableAttributes := &TableAttributes{
	TableArn: jsii.String("tableArn"),
	TableName: jsii.String("tableName"),
}

Experimental.

type TableBase 

type TableBase interface {
	awscdk.Resource
	ITable
	// This table's columns.
	// Experimental.
	Columns() *[]*Column
	// Indicates whether the table's data is compressed or not.
	// Experimental.
	Compressed() *bool
	// Database this table belongs to.
	// Experimental.
	Database() IDatabase
	// Format of this table's data files.
	// Experimental.
	DataFormat() DataFormat
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// The tables' properties associated with the table.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Experimental.
	Parameters() *map[string]*string
	// Experimental.
	PartitionIndexes() *[]*PartitionIndex
	// This table's partition keys if the table is partitioned.
	// Experimental.
	PartitionKeys() *[]*Column
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The tables' storage descriptor properties.
	// Experimental.
	StorageParameters() *[]StorageParameter
	// Experimental.
	TableArn() *string
	// Experimental.
	TableName() *string
	// Experimental.
	TableResource() awsglue.CfnTable
	// Add a partition index to the table.
	//
	// You can have a maximum of 3 partition
	// indexes to a table. Partition index keys must be a subset of the table's
	// partition keys.
	// See: https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html
	//
	// Experimental.
	AddPartitionIndex(index *PartitionIndex)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity custom permissions.
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Experimental.
	GrantRead(grantee awsiam.IGrantable) awsiam.Grant
	// Experimental.
	GrantReadWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Grant the given identity custom permissions to ALL underlying resources of the table.
	//
	// Permissions will be granted to the catalog, the database, and the table.
	// Experimental.
	GrantToUnderlyingResources(grantee awsiam.IGrantable, actions *[]*string) awsiam.Grant
	// Experimental.
	GrantWrite(grantee awsiam.IGrantable) awsiam.Grant
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A Glue table.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

tableBase := glue_alpha.TableBase_FromTableArn(this, jsii.String("MyTableBase"), jsii.String("tableArn"))

Experimental.

type TableBaseProps 

type TableBaseProps struct {
	// Columns of the table.
	// Experimental.
	Columns *[]*Column `field:"required" json:"columns" yaml:"columns"`
	// Database in which to store the table.
	// Experimental.
	Database IDatabase `field:"required" json:"database" yaml:"database"`
	// Storage type of the table's data.
	// Experimental.
	DataFormat DataFormat `field:"required" json:"dataFormat" yaml:"dataFormat"`
	// Indicates whether the table's data is compressed or not.
	// Default: false.
	//
	// Experimental.
	Compressed *bool `field:"optional" json:"compressed" yaml:"compressed"`
	// Description of the table.
	// Default: generated.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables partition filtering.
	// See: https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	EnablePartitionFiltering *bool `field:"optional" json:"enablePartitionFiltering" yaml:"enablePartitionFiltering"`
	// The key/value pairs define properties associated with the table.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	Parameters *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
	// Partition indexes on the table.
	//
	// A maximum of 3 indexes
	// are allowed on a table. Keys in the index must be part
	// of the table's partition keys.
	// Default: table has no partition indexes.
	//
	// Experimental.
	PartitionIndexes *[]*PartitionIndex `field:"optional" json:"partitionIndexes" yaml:"partitionIndexes"`
	// Partition columns of the table.
	// Default: table is not partitioned.
	//
	// Experimental.
	PartitionKeys *[]*Column `field:"optional" json:"partitionKeys" yaml:"partitionKeys"`
	// The user-supplied properties for the description of the physical storage of this table.
	//
	// These properties help describe the format of the data that is stored within the crawled data sources.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	//
	// Some keys will be auto-populated by glue crawlers, however, you can override them by specifying the key and value in this property.
	//
	// Example:
	//   var glueDatabase iDatabase
	//
	//   table := glue.NewTable(this, jsii.String("Table"), &S3TableProps{
	//   	StorageParameters: []storageParameter{
	//   		glue.*storageParameter_SkipHeaderLineCount(jsii.Number(1)),
	//   		glue.*storageParameter_CompressionType(glue.CompressionType_GZIP),
	//   		glue.*storageParameter_Custom(jsii.String("foo"), jsii.String("bar")),
	//   		glue.*storageParameter_*Custom(jsii.String("separatorChar"), jsii.String(",")),
	//   		glue.*storageParameter_*Custom(glue.StorageParameters_WRITE_PARALLEL, jsii.String("off")),
	//   	},
	//   	// ...
	//   	Database: glueDatabase,
	//   	Columns: []column{
	//   		&column{
	//   			Name: jsii.String("col1"),
	//   			Type: glue.Schema_STRING(),
	//   		},
	//   	},
	//   	DataFormat: glue.DataFormat_CSV(),
	//   })
	//
	// See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	StorageParameters *[]StorageParameter `field:"optional" json:"storageParameters" yaml:"storageParameters"`
	// Indicates whether the table data is stored in subdirectories.
	// Default: false.
	//
	// Experimental.
	StoredAsSubDirectories *bool `field:"optional" json:"storedAsSubDirectories" yaml:"storedAsSubDirectories"`
	// Name of the table.
	// Default: - generated by CDK.
	//
	// Experimental.
	TableName *string `field:"optional" json:"tableName" yaml:"tableName"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

var database database
var dataFormat dataFormat
var storageParameter storageParameter

tableBaseProps := &TableBaseProps{
	Columns: []column{
		&column{
			Name: jsii.String("name"),
			Type: &Type{
				InputString: jsii.String("inputString"),
				IsPrimitive: jsii.Boolean(false),
			},

			// the properties below are optional
			Comment: jsii.String("comment"),
		},
	},
	Database: database,
	DataFormat: dataFormat,

	// the properties below are optional
	Compressed: jsii.Boolean(false),
	Description: jsii.String("description"),
	EnablePartitionFiltering: jsii.Boolean(false),
	Parameters: map[string]*string{
		"parametersKey": jsii.String("parameters"),
	},
	PartitionIndexes: []partitionIndex{
		&partitionIndex{
			KeyNames: []*string{
				jsii.String("keyNames"),
			},

			// the properties below are optional
			IndexName: jsii.String("indexName"),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("name"),
			Type: &Type{
				InputString: jsii.String("inputString"),
				IsPrimitive: jsii.Boolean(false),
			},

			// the properties below are optional
			Comment: jsii.String("comment"),
		},
	},
	StorageParameters: []*storageParameter{
		storageParameter,
	},
	StoredAsSubDirectories: jsii.Boolean(false),
	TableName: jsii.String("tableName"),
}

Experimental.

type TableEncryption 

type TableEncryption string

Encryption options for a Table.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Encryption: glue.TableEncryption_S3_MANAGED,
	// ...
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

See: https://docs.aws.amazon.com/athena/latest/ug/encryption.html

Experimental. 

const (
	// Server side encryption (SSE) with an Amazon S3-managed key.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html
	//
	// Experimental.
	TableEncryption_S3_MANAGED TableEncryption = "S3_MANAGED"
	// Server-side encryption (SSE) with an AWS KMS key managed by the account owner.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
	//
	// Experimental.
	TableEncryption_KMS TableEncryption = "KMS"
	// Server-side encryption (SSE) with an AWS KMS key managed by the KMS service.
	// Experimental.
	TableEncryption_KMS_MANAGED TableEncryption = "KMS_MANAGED"
	// Client-side encryption (CSE) with an AWS KMS key managed by the account owner.
	// See: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingClientSideEncryption.html
	//
	// Experimental.
	TableEncryption_CLIENT_SIDE_KMS TableEncryption = "CLIENT_SIDE_KMS"
)

type TableProps 

type TableProps struct {
	// Columns of the table.
	// Experimental.
	Columns *[]*Column `field:"required" json:"columns" yaml:"columns"`
	// Database in which to store the table.
	// Experimental.
	Database IDatabase `field:"required" json:"database" yaml:"database"`
	// Storage type of the table's data.
	// Experimental.
	DataFormat DataFormat `field:"required" json:"dataFormat" yaml:"dataFormat"`
	// Indicates whether the table's data is compressed or not.
	// Default: false.
	//
	// Experimental.
	Compressed *bool `field:"optional" json:"compressed" yaml:"compressed"`
	// Description of the table.
	// Default: generated.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Enables partition filtering.
	// See: https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	EnablePartitionFiltering *bool `field:"optional" json:"enablePartitionFiltering" yaml:"enablePartitionFiltering"`
	// The key/value pairs define properties associated with the table.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html#cfn-glue-table-tableinput-parameters
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	Parameters *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
	// Partition indexes on the table.
	//
	// A maximum of 3 indexes
	// are allowed on a table. Keys in the index must be part
	// of the table's partition keys.
	// Default: table has no partition indexes.
	//
	// Experimental.
	PartitionIndexes *[]*PartitionIndex `field:"optional" json:"partitionIndexes" yaml:"partitionIndexes"`
	// Partition columns of the table.
	// Default: table is not partitioned.
	//
	// Experimental.
	PartitionKeys *[]*Column `field:"optional" json:"partitionKeys" yaml:"partitionKeys"`
	// The user-supplied properties for the description of the physical storage of this table.
	//
	// These properties help describe the format of the data that is stored within the crawled data sources.
	//
	// The key/value pairs that are allowed to be submitted are not limited, however their functionality is not guaranteed.
	//
	// Some keys will be auto-populated by glue crawlers, however, you can override them by specifying the key and value in this property.
	//
	// Example:
	//      declare const glueDatabase: glue.IDatabase;
	//      const table = new glue.Table(this, 'Table', {
	//        storageParameters: [
	//            glue.StorageParameter.skipHeaderLineCount(1),
	//            glue.StorageParameter.compressionType(glue.CompressionType.GZIP),
	//            glue.StorageParameter.custom('foo', 'bar'), // Will have no effect
	//            glue.StorageParameter.custom('separatorChar', ','), // Will describe the separator char used in the data
	//            glue.StorageParameter.custom(glue.StorageParameters.WRITE_PARALLEL, 'off'),
	//        ],
	//        // ...
	//        database: glueDatabase,
	//        columns: [{
	//            name: 'col1',
	//            type: glue.Schema.STRING,
	//        }],
	//        dataFormat: glue.DataFormat.CSV,
	//      });
	//
	// See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_
	//
	// Default: - The parameter is not defined.
	//
	// Experimental.
	StorageParameters *[]StorageParameter `field:"optional" json:"storageParameters" yaml:"storageParameters"`
	// Indicates whether the table data is stored in subdirectories.
	// Default: false.
	//
	// Experimental.
	StoredAsSubDirectories *bool `field:"optional" json:"storedAsSubDirectories" yaml:"storedAsSubDirectories"`
	// Name of the table.
	// Default: - generated by CDK.
	//
	// Experimental.
	TableName *string `field:"optional" json:"tableName" yaml:"tableName"`
	// S3 bucket in which to store data.
	// Default: one is created for you.
	//
	// Experimental.
	Bucket awss3.IBucket `field:"optional" json:"bucket" yaml:"bucket"`
	// The kind of encryption to secure the data with.
	//
	// You can only provide this option if you are not explicitly passing in a bucket.
	//
	// If you choose `SSE-KMS`, you *can* provide an un-managed KMS key with `encryptionKey`.
	// If you choose `CSE-KMS`, you *must* provide an un-managed KMS key with `encryptionKey`.
	// Default: BucketEncryption.S3_MANAGED
	//
	// Experimental.
	Encryption TableEncryption `field:"optional" json:"encryption" yaml:"encryption"`
	// External KMS key to use for bucket encryption.
	//
	// The `encryption` property must be `SSE-KMS` or `CSE-KMS`.
	// Default: key is managed by KMS.
	//
	// Experimental.
	EncryptionKey awskms.IKey `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// S3 prefix under which table objects are stored.
	// Default: - No prefix. The data will be stored under the root of the bucket.
	//
	// Experimental.
	S3Prefix *string `field:"optional" json:"s3Prefix" yaml:"s3Prefix"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var database database
var dataFormat dataFormat
var key key
var storageParameter storageParameter

tableProps := &TableProps{
	Columns: []column{
		&column{
			Name: jsii.String("name"),
			Type: &Type{
				InputString: jsii.String("inputString"),
				IsPrimitive: jsii.Boolean(false),
			},

			// the properties below are optional
			Comment: jsii.String("comment"),
		},
	},
	Database: database,
	DataFormat: dataFormat,

	// the properties below are optional
	Bucket: bucket,
	Compressed: jsii.Boolean(false),
	Description: jsii.String("description"),
	EnablePartitionFiltering: jsii.Boolean(false),
	Encryption: glue_alpha.TableEncryption_S3_MANAGED,
	EncryptionKey: key,
	Parameters: map[string]*string{
		"parametersKey": jsii.String("parameters"),
	},
	PartitionIndexes: []partitionIndex{
		&partitionIndex{
			KeyNames: []*string{
				jsii.String("keyNames"),
			},

			// the properties below are optional
			IndexName: jsii.String("indexName"),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("name"),
			Type: &Type{
				InputString: jsii.String("inputString"),
				IsPrimitive: jsii.Boolean(false),
			},

			// the properties below are optional
			Comment: jsii.String("comment"),
		},
	},
	S3Prefix: jsii.String("s3Prefix"),
	StorageParameters: []*storageParameter{
		storageParameter,
	},
	StoredAsSubDirectories: jsii.Boolean(false),
	TableName: jsii.String("tableName"),
}

Experimental.

type TriggerOptions 

type TriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
}

Properties for configuring a Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

triggerOptions := &TriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
}

Experimental.

type TriggerSchedule 

type TriggerSchedule interface {
	// The expression string for the schedule.
	// Experimental.
	ExpressionString() *string
}

Represents a trigger schedule.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

triggerSchedule := glue_alpha.TriggerSchedule_Cron(&CronOptions{
	Day: jsii.String("day"),
	Hour: jsii.String("hour"),
	Minute: jsii.String("minute"),
	Month: jsii.String("month"),
	WeekDay: jsii.String("weekDay"),
	Year: jsii.String("year"),
})

Experimental.

func TriggerSchedule_Cron 

func TriggerSchedule_Cron(options *awsevents.CronOptions) TriggerSchedule

Creates a new TriggerSchedule instance with a cron expression.

Returns: A new TriggerSchedule instance. Experimental.

func TriggerSchedule_Expression 

func TriggerSchedule_Expression(expression *string) TriggerSchedule

Creates a new TriggerSchedule instance with a custom expression.

Returns: A new TriggerSchedule instance. Experimental.

type Type 

type Type struct {
	// Glue InputString for this type.
	// Experimental.
	InputString *string `field:"required" json:"inputString" yaml:"inputString"`
	// Indicates whether this type is a primitive data type.
	// Experimental.
	IsPrimitive *bool `field:"required" json:"isPrimitive" yaml:"isPrimitive"`
}

Represents a type of a column in a table schema.

Example: 

var myDatabase database

glue.NewS3Table(this, jsii.String("MyTable"), &S3TableProps{
	Database: myDatabase,
	Columns: []column{
		&column{
			Name: jsii.String("col1"),
			Type: glue.Schema_STRING(),
		},
	},
	PartitionKeys: []*column{
		&column{
			Name: jsii.String("year"),
			Type: glue.Schema_SMALL_INT(),
		},
		&column{
			Name: jsii.String("month"),
			Type: glue.Schema_SMALL_INT(),
		},
	},
	DataFormat: glue.DataFormat_JSON(),
})

Experimental.

func Schema_Array 

func Schema_Array(itemType *Type) *Type

Creates an array of some other type. Experimental.

func Schema_BIG_INT 

func Schema_BIG_INT() *Type

func Schema_BINARY 

func Schema_BINARY() *Type

func Schema_BOOLEAN 

func Schema_BOOLEAN() *Type

func Schema_Char 

func Schema_Char(length *float64) *Type

Fixed length character data, with a specified length between 1 and 255. Experimental.

func Schema_DATE 

func Schema_DATE() *Type

func Schema_DOUBLE 

func Schema_DOUBLE() *Type

func Schema_Decimal 

func Schema_Decimal(precision *float64, scale *float64) *Type

Creates a decimal type.

TODO: Bounds. Experimental.

func Schema_FLOAT 

func Schema_FLOAT() *Type

func Schema_INTEGER 

func Schema_INTEGER() *Type

func Schema_Map 

func Schema_Map(keyType *Type, valueType *Type) *Type

Creates a map of some primitive key type to some value type. Experimental.

func Schema_SMALL_INT 

func Schema_SMALL_INT() *Type

func Schema_STRING 

func Schema_STRING() *Type

func Schema_Struct 

func Schema_Struct(columns *[]*Column) *Type

Creates a nested structure containing individually named and typed columns. Experimental.

func Schema_TIMESTAMP 

func Schema_TIMESTAMP() *Type

func Schema_TINY_INT 

func Schema_TINY_INT() *Type

func Schema_Varchar 

func Schema_Varchar(length *float64) *Type

Variable length character data, with a specified length between 1 and 65535. Experimental.

type WeeklyScheduleTriggerOptions 

type WeeklyScheduleTriggerOptions struct {
	// The actions initiated by this trigger.
	// Experimental.
	Actions *[]*Action `field:"required" json:"actions" yaml:"actions"`
	// A description for the trigger.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// A name for the trigger.
	// Default: - no name is provided.
	//
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Whether to start the trigger on creation or not.
	// Default: - false.
	//
	// Experimental.
	StartOnCreation *bool `field:"optional" json:"startOnCreation" yaml:"startOnCreation"`
}

Properties for configuring a weekly-scheduled Glue Trigger.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cfnCrawler cfnCrawler
var job job
var securityConfiguration securityConfiguration

weeklyScheduleTriggerOptions := &WeeklyScheduleTriggerOptions{
	Actions: []action{
		&action{
			Arguments: map[string]*string{
				"argumentsKey": jsii.String("arguments"),
			},
			Crawler: cfnCrawler,
			Job: job,
			SecurityConfiguration: securityConfiguration,
			Timeout: cdk.Duration_Minutes(jsii.Number(30)),
		},
	},

	// the properties below are optional
	Description: jsii.String("description"),
	Name: jsii.String("name"),
	StartOnCreation: jsii.Boolean(false),
}

Experimental.

type WorkerType 

type WorkerType string

The type of predefined worker that is allocated when a job runs.

If you need to use a WorkerType that doesn't exist as a static member, you can instantiate a `WorkerType` object, e.g: `WorkerType.of('other type')`

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"
import iam "github.com/aws/aws-cdk-go/awscdk"
var stack stack
var role iRole
var script code

glue.NewPySparkEtlJob(stack, jsii.String("PySparkETLJob"), &PySparkEtlJobProps{
	JobName: jsii.String("PySparkETLJobCustomName"),
	Description: jsii.String("This is a description"),
	Role: Role,
	Script: Script,
	GlueVersion: glue.GlueVersion_V3_0,
	ContinuousLogging: &ContinuousLoggingProps{
		Enabled: jsii.Boolean(false),
	},
	WorkerType: glue.WorkerType_G_2X,
	MaxConcurrentRuns: jsii.Number(100),
	Timeout: cdk.Duration_Hours(jsii.Number(2)),
	Connections: []iConnection{
		glue.Connection_FromConnectionName(stack, jsii.String("Connection"), jsii.String("connectionName")),
	},
	SecurityConfiguration: glue.SecurityConfiguration_FromSecurityConfigurationName(stack, jsii.String("SecurityConfig"), jsii.String("securityConfigName")),
	Tags: map[string]*string{
		"FirstTagName": jsii.String("FirstTagValue"),
		"SecondTagName": jsii.String("SecondTagValue"),
		"XTagName": jsii.String("XTagValue"),
	},
	NumberOfWorkers: jsii.Number(2),
	MaxRetries: jsii.Number(2),
})

Experimental. 

const (
	// Standard Worker Type 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.
	// Experimental.
	WorkerType_STANDARD WorkerType = "STANDARD"
	// G.1X Worker Type 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. Suitable for memory-intensive jobs.
	// Experimental.
	WorkerType_G_1X WorkerType = "G_1X"
	// G.2X Worker Type 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. Suitable for memory-intensive jobs.
	// Experimental.
	WorkerType_G_2X WorkerType = "G_2X"
	// G.4X Worker Type 4 DPU (16 vCPU, 64 GB of memory, 256 GB disk), and provides 1 executor per worker. We recommend this worker type for jobs whose workloads contain your most demanding transforms, aggregations, joins, and queries. This worker type is available only for AWS Glue version 3.0 or later jobs.
	// Experimental.
	WorkerType_G_4X WorkerType = "G_4X"
	// G.8X Worker Type 8 DPU (32 vCPU, 128 GB of memory, 512 GB disk), and provides 1 executor per worker. We recommend this worker type for jobs whose workloads contain your most demanding transforms, aggregations, joins, and queries. This worker type is available only for AWS Glue version 3.0 or later jobs.
	// Experimental.
	WorkerType_G_8X WorkerType = "G_8X"
	// G.025X Worker Type 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. Suitable for low volume streaming jobs.
	// Experimental.
	WorkerType_G_025X WorkerType = "G_025X"
	// Z.2X Worker Type.
	// Experimental.
	WorkerType_Z_2X WorkerType = "Z_2X"
)

type Workflow 

type Workflow interface {
	WorkflowBase
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The ARN of the workflow.
	// Experimental.
	WorkflowArn() *string
	// The name of the workflow.
	// Experimental.
	WorkflowName() *string
	// Add a Condition (Predicate) based trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddconditionalTrigger(id *string, options *ConditionalTriggerOptions) awsglue.CfnTrigger
	// Add a custom-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddCustomScheduledTrigger(id *string, options *CustomScheduledTriggerOptions) awsglue.CfnTrigger
	// Add a daily-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddDailyScheduledTrigger(id *string, options *DailyScheduleTriggerOptions) awsglue.CfnTrigger
	// Add an Event Bridge based trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddNotifyEventTrigger(id *string, options *NotifyEventTriggerOptions) awsglue.CfnTrigger
	// Add an on-demand trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddOnDemandTrigger(id *string, options *OnDemandTriggerOptions) awsglue.CfnTrigger
	// Add a weekly-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddWeeklyScheduledTrigger(id *string, options *WeeklyScheduleTriggerOptions) awsglue.CfnTrigger
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	BuildWorkflowArn(scope constructs.Construct, workflowName *string) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

This module defines a construct for creating and managing AWS Glue Workflows and Triggers.

AWS Glue Workflows are orchestration services that allow you to create, manage, and monitor complex extract, transform, and load (ETL) activities involving multiple crawlers, jobs, and triggers. Workflows are designed to allow you to manage interdependent jobs and crawlers as a single unit, making it easier to orchestrate and monitor complex ETL pipelines.

Triggers are used to initiate an AWS Glue Workflow. You can configure different types of triggers, such as on-demand, scheduled, event-based, or conditional triggers, to start your Workflow based on specific conditions or events.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

workflow := glue_alpha.NewWorkflow(this, jsii.String("MyWorkflow"), &WorkflowProps{
	DefaultRunProperties: map[string]*string{
		"defaultRunPropertiesKey": jsii.String("defaultRunProperties"),
	},
	Description: jsii.String("description"),
	MaxConcurrentRuns: jsii.Number(123),
	WorkflowName: jsii.String("workflowName"),
})

See: https://docs.aws.amazon.com/glue/latest/dg/about-triggers.html

## Usage Example

```ts const app = new App(); const stack = new Stack(app, 'TestStack');

// Create a Glue Job declare const role: iam.IRole; declare const script: glue.Code; const job = new glue.PySparkStreamingJob(stack, 'ImportedJob', { role, script });

// Create a Glue Workflow const workflow = new glue.Workflow(stack, 'TestWorkflow');

// Add an on-demand trigger to the Workflow workflow.addOnDemandTrigger('OnDemandTrigger', { actions: [{ job: job }], }); ```.

Experimental.

func NewWorkflow 

func NewWorkflow(scope constructs.Construct, id *string, props *WorkflowProps) Workflow

Experimental.

type WorkflowAttributes 

type WorkflowAttributes struct {
	// The name of the workflow to import.
	// Experimental.
	WorkflowName *string `field:"required" json:"workflowName" yaml:"workflowName"`
	// The ARN of the workflow to import.
	// Default: - derived from the workflow name.
	//
	// Experimental.
	WorkflowArn *string `field:"optional" json:"workflowArn" yaml:"workflowArn"`
}

Properties for importing a Workflow using its attributes.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

workflowAttributes := &WorkflowAttributes{
	WorkflowName: jsii.String("workflowName"),

	// the properties below are optional
	WorkflowArn: jsii.String("workflowArn"),
}

Experimental.

type WorkflowBase 

type WorkflowBase interface {
	awscdk.Resource
	IWorkflow
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The ARN of the workflow.
	// Experimental.
	WorkflowArn() *string
	// The name of the workflow.
	// Experimental.
	WorkflowName() *string
	// Add a Condition (Predicate) based trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddconditionalTrigger(id *string, options *ConditionalTriggerOptions) awsglue.CfnTrigger
	// Add a custom-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddCustomScheduledTrigger(id *string, options *CustomScheduledTriggerOptions) awsglue.CfnTrigger
	// Add a daily-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddDailyScheduledTrigger(id *string, options *DailyScheduleTriggerOptions) awsglue.CfnTrigger
	// Add an Event Bridge based trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddNotifyEventTrigger(id *string, options *NotifyEventTriggerOptions) awsglue.CfnTrigger
	// Add an on-demand trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddOnDemandTrigger(id *string, options *OnDemandTriggerOptions) awsglue.CfnTrigger
	// Add a weekly-scheduled trigger to the workflow.
	//
	// Returns: The created CfnTrigger resource.
	// Experimental.
	AddWeeklyScheduledTrigger(id *string, options *WeeklyScheduleTriggerOptions) awsglue.CfnTrigger
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	BuildWorkflowArn(scope constructs.Construct, workflowName *string) *string
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Base abstract class for Workflow. See: https://docs.aws.amazon.com/glue/latest/dg/about-triggers.html

Experimental.

type WorkflowProps 

type WorkflowProps struct {
	// A map of properties to use when this workflow is executed.
	// Default: - no default run properties.
	//
	// Experimental.
	DefaultRunProperties *map[string]*string `field:"optional" json:"defaultRunProperties" yaml:"defaultRunProperties"`
	// A description of the workflow.
	// Default: - no description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// The maximum number of concurrent runs allowed for the workflow.
	// Default: - no limit.
	//
	// Experimental.
	MaxConcurrentRuns *float64 `field:"optional" json:"maxConcurrentRuns" yaml:"maxConcurrentRuns"`
	// Name of the workflow.
	// Default: - a name will be generated.
	//
	// Experimental.
	WorkflowName *string `field:"optional" json:"workflowName" yaml:"workflowName"`
}

Properties for defining a Workflow.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import glue_alpha "github.com/aws/aws-cdk-go/awscdkgluealpha"

workflowProps := &WorkflowProps{
	DefaultRunProperties: map[string]*string{
		"defaultRunPropertiesKey": jsii.String("defaultRunProperties"),
	},
	Description: jsii.String("description"),
	MaxConcurrentRuns: jsii.Number(123),
	WorkflowName: jsii.String("workflowName"),
}

Experimental.

type WriteParallel 

type WriteParallel string

Specifies how to handle data being loaded that exceeds the length of the data type defined for columns containing VARCHAR, CHAR, or string data.

By default, Redshift Spectrum sets the value to null for data that exceeds the width of the column. See: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html#r_CREATE_EXTERNAL_TABLE-parameters - under _"TABLE PROPERTIES"_ > _"surplus_char_handling"_

Experimental. 

const (
	// Write data in parallel.
	// Experimental.
	WriteParallel_ON WriteParallel = "ON"
	// Write data serially.
	// Experimental.
	WriteParallel_OFF WriteParallel = "OFF"
)

Source Files

View all Source files

Directories

Path Synopsis
Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.
 Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.