Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string
}

    Access to the specified resource was denied.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type CompressionFormat

    type CompressionFormat string
    const (
    	CompressionFormatGzip    CompressionFormat = "GZIP"
    	CompressionFormatLz4     CompressionFormat = "LZ4"
    	CompressionFormatSnappy  CompressionFormat = "SNAPPY"
    	CompressionFormatBzip2   CompressionFormat = "BZIP2"
    	CompressionFormatDeflate CompressionFormat = "DEFLATE"
    	CompressionFormatLzo     CompressionFormat = "LZO"
    	CompressionFormatBrotli  CompressionFormat = "BROTLI"
    	CompressionFormatZstd    CompressionFormat = "ZSTD"
    	CompressionFormatZlib    CompressionFormat = "ZLIB"
    )

      Enum values for CompressionFormat

      func (CompressionFormat) Values

        Values returns all known values for CompressionFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type ConditionExpression

        type ConditionExpression struct {
        
        	// A specific condition to apply to a recipe action. For more information, see
        	// Recipe structure
        	// (https://docs.aws.amazon.com/databrew/latest/dg/recipe-structure.html) in the
        	// AWS Glue DataBrew Developer Guide.
        	//
        	// This member is required.
        	Condition *string
        
        	// A column to apply this condition to, within an AWS Glue DataBrew dataset.
        	//
        	// This member is required.
        	TargetColumn *string
        
        	// A value that the condition must evaluate to for the condition to succeed.
        	Value *string
        }

          Represents an individual condition that evaluates to true or false. Conditions are used with recipe actions: The action is only performed for column values where the condition evaluates to true. If a recipe requires more than one condition, then the recipe must specify multiple ConditionExpression elements. Each condition is applied to the rows in a dataset first, before the recipe action is performed.

          type ConflictException

          type ConflictException struct {
          	Message *string
          }

            Updating or deleting a resource can cause an inconsistent state.

            func (*ConflictException) Error

            func (e *ConflictException) Error() string

            func (*ConflictException) ErrorCode

            func (e *ConflictException) ErrorCode() string

            func (*ConflictException) ErrorFault

            func (e *ConflictException) ErrorFault() smithy.ErrorFault

            func (*ConflictException) ErrorMessage

            func (e *ConflictException) ErrorMessage() string

            type DataCatalogInputDefinition

            type DataCatalogInputDefinition struct {
            
            	// The name of a database in the Data Catalog.
            	//
            	// This member is required.
            	DatabaseName *string
            
            	// The name of a database table in the Data Catalog. This table corresponds to a
            	// DataBrew dataset.
            	//
            	// This member is required.
            	TableName *string
            
            	// The unique identifier of the AWS account that holds the Data Catalog that stores
            	// the data.
            	CatalogId *string
            
            	// An Amazon location that AWS Glue Data Catalog can use as a temporary directory.
            	TempDirectory *S3Location
            }

              Represents how metadata stored in the AWS Glue Data Catalog is defined in an AWS Glue DataBrew dataset.

              type Dataset

              type Dataset struct {
              
              	// Information on how DataBrew can find the dataset, in either the AWS Glue Data
              	// Catalog or Amazon S3.
              	//
              	// This member is required.
              	Input *Input
              
              	// The unique name of the dataset.
              	//
              	// This member is required.
              	Name *string
              
              	// The ID of the AWS account that owns the dataset.
              	AccountId *string
              
              	// The date and time that the dataset was created.
              	CreateDate *time.Time
              
              	// The identifier (the user name) of the user who created the dataset.
              	CreatedBy *string
              
              	// Options that define how DataBrew interprets the data in the dataset.
              	FormatOptions *FormatOptions
              
              	// The identifier (the user name) of the user who last modified the dataset.
              	LastModifiedBy *string
              
              	// The last modification date and time of the dataset.
              	LastModifiedDate *time.Time
              
              	// The unique Amazon Resource Name (ARN) for the dataset.
              	ResourceArn *string
              
              	// The location of the data for the dataset, either Amazon S3 or the AWS Glue Data
              	// Catalog.
              	Source Source
              
              	// Metadata tags that have been applied to the dataset.
              	Tags map[string]string
              }

                Represents a dataset that can be processed by AWS Glue DataBrew.

                type EncryptionMode

                type EncryptionMode string
                const (
                	EncryptionModeSsekms EncryptionMode = "SSE-KMS"
                	EncryptionModeSses3  EncryptionMode = "SSE-S3"
                )

                  Enum values for EncryptionMode

                  func (EncryptionMode) Values

                  func (EncryptionMode) Values() []EncryptionMode

                    Values returns all known values for EncryptionMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type ExcelOptions

                    type ExcelOptions struct {
                    
                    	// Specifies one or more sheet numbers in the Excel file, which will be included in
                    	// the dataset.
                    	SheetIndexes []int32
                    
                    	// Specifies one or more named sheets in the Excel file, which will be included in
                    	// the dataset.
                    	SheetNames []string
                    }

                      Options that define how DataBrew will interpret a Microsoft Excel file, when creating a dataset from that file.

                      type FormatOptions

                      type FormatOptions struct {
                      
                      	// Options that define how Excel input is to be interpreted by DataBrew.
                      	Excel *ExcelOptions
                      
                      	// Options that define how JSON input is to be interpreted by DataBrew.
                      	Json *JsonOptions
                      }

                        Options that define how Microsoft Excel input is to be interpreted by DataBrew.

                        type Input

                        type Input struct {
                        
                        	// The AWS Glue Data Catalog parameters for the data.
                        	DataCatalogInputDefinition *DataCatalogInputDefinition
                        
                        	// The Amazon S3 location where the data is stored.
                        	S3InputDefinition *S3Location
                        }

                          Information on how AWS Glue DataBrew can find data, in either the AWS Glue Data Catalog or Amazon S3.

                          type InternalServerException

                          type InternalServerException struct {
                          	Message *string
                          }

                            An internal service failure occurred.

                            func (*InternalServerException) Error

                            func (e *InternalServerException) Error() string

                            func (*InternalServerException) ErrorCode

                            func (e *InternalServerException) ErrorCode() string

                            func (*InternalServerException) ErrorFault

                            func (e *InternalServerException) ErrorFault() smithy.ErrorFault

                            func (*InternalServerException) ErrorMessage

                            func (e *InternalServerException) ErrorMessage() string

                            type Job

                            type Job struct {
                            
                            	// The unique name of the job.
                            	//
                            	// This member is required.
                            	Name *string
                            
                            	// The ID of the AWS account that owns the job.
                            	AccountId *string
                            
                            	// The date and time that the job was created.
                            	CreateDate *time.Time
                            
                            	// The identifier (the user name) of the user who created the job.
                            	CreatedBy *string
                            
                            	// A dataset that the job is to process.
                            	DatasetName *string
                            
                            	// The Amazon Resource Name (ARN) of an encryption key that is used to protect a
                            	// job.
                            	EncryptionKeyArn *string
                            
                            	// The encryption mode for the job, which can be one of the following:
                            	//
                            	// * SSE-KMS -
                            	// Server-side encryption with AWS KMS-managed keys.
                            	//
                            	// * SSE-S3 - Server-side
                            	// encryption with keys managed by Amazon S3.
                            	EncryptionMode EncryptionMode
                            
                            	// The identifier (the user name) of the user who last modified the job.
                            	LastModifiedBy *string
                            
                            	// The modification date and time of the job.
                            	LastModifiedDate *time.Time
                            
                            	// The current status of Amazon CloudWatch logging for the job.
                            	LogSubscription LogSubscription
                            
                            	// The maximum number of nodes that can be consumed when the job processes data.
                            	MaxCapacity int32
                            
                            	// The maximum number of times to retry the job after a job run fails.
                            	MaxRetries int32
                            
                            	// One or more artifacts that represent output from running the job.
                            	Outputs []Output
                            
                            	// The name of the project that the job is associated with.
                            	ProjectName *string
                            
                            	// A set of steps that the job runs.
                            	RecipeReference *RecipeReference
                            
                            	// The unique Amazon Resource Name (ARN) for the job.
                            	ResourceArn *string
                            
                            	// The Amazon Resource Name (ARN) of the role that will be assumed for this job.
                            	RoleArn *string
                            
                            	// Metadata tags that have been applied to the job.
                            	Tags map[string]string
                            
                            	// The job's timeout in minutes. A job that attempts to run longer than this
                            	// timeout period ends with a status of TIMEOUT.
                            	Timeout int32
                            
                            	// The job type of the job, which must be one of the following:
                            	//
                            	// * PROFILE - A job
                            	// to analyze a dataset, to determine its size, data types, data distribution, and
                            	// more.
                            	//
                            	// * RECIPE - A job to apply one or more transformations to a dataset.
                            	Type JobType
                            }

                              Represents all of the attributes of an AWS Glue DataBrew job.

                              type JobRun

                              type JobRun struct {
                              
                              	// The number of times that DataBrew has attempted to run the job.
                              	Attempt int32
                              
                              	// The date and time when the job completed processing.
                              	CompletedOn *time.Time
                              
                              	// The name of the dataset for the job to process.
                              	DatasetName *string
                              
                              	// A message indicating an error (if any) that was encountered when the job ran.
                              	ErrorMessage *string
                              
                              	// The amount of time, in seconds, during which a job run consumed resources.
                              	ExecutionTime int32
                              
                              	// The name of the job being processed during this run.
                              	JobName *string
                              
                              	// The name of an Amazon CloudWatch log group, where the job writes diagnostic
                              	// messages when it runs.
                              	LogGroupName *string
                              
                              	// The current status of Amazon CloudWatch logging for the job run.
                              	LogSubscription LogSubscription
                              
                              	// One or more output artifacts from a job run.
                              	Outputs []Output
                              
                              	// The set of steps processed by the job.
                              	RecipeReference *RecipeReference
                              
                              	// The unique identifier of the job run.
                              	RunId *string
                              
                              	// The identifier (the user name) of the user who initiated the job run.
                              	StartedBy *string
                              
                              	// The date and time when the job run began.
                              	StartedOn *time.Time
                              
                              	// The current state of the job run entity itself.
                              	State JobRunState
                              }

                                Represents one run of an AWS Glue DataBrew job.

                                type JobRunState

                                type JobRunState string
                                const (
                                	JobRunStateStarting  JobRunState = "STARTING"
                                	JobRunStateRunning   JobRunState = "RUNNING"
                                	JobRunStateStopping  JobRunState = "STOPPING"
                                	JobRunStateStopped   JobRunState = "STOPPED"
                                	JobRunStateSucceeded JobRunState = "SUCCEEDED"
                                	JobRunStateFailed    JobRunState = "FAILED"
                                	JobRunStateTimeout   JobRunState = "TIMEOUT"
                                )

                                  Enum values for JobRunState

                                  func (JobRunState) Values

                                  func (JobRunState) Values() []JobRunState

                                    Values returns all known values for JobRunState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                    type JobType

                                    type JobType string
                                    const (
                                    	JobTypeProfile JobType = "PROFILE"
                                    	JobTypeRecipe  JobType = "RECIPE"
                                    )

                                      Enum values for JobType

                                      func (JobType) Values

                                      func (JobType) Values() []JobType

                                        Values returns all known values for JobType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                        type JsonOptions

                                        type JsonOptions struct {
                                        
                                        	// A value that specifies whether JSON input contains embedded new line characters.
                                        	MultiLine bool
                                        }

                                          Represents the JSON-specific options that define how input is to be interpreted by AWS Glue DataBrew.

                                          type LogSubscription

                                          type LogSubscription string
                                          const (
                                          	LogSubscriptionEnable  LogSubscription = "ENABLE"
                                          	LogSubscriptionDisable LogSubscription = "DISABLE"
                                          )

                                            Enum values for LogSubscription

                                            func (LogSubscription) Values

                                            func (LogSubscription) Values() []LogSubscription

                                              Values returns all known values for LogSubscription. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                              type Output

                                              type Output struct {
                                              
                                              	// The location in Amazon S3 where the job writes its output.
                                              	//
                                              	// This member is required.
                                              	Location *S3Location
                                              
                                              	// The compression algorithm used to compress the output text of the job.
                                              	CompressionFormat CompressionFormat
                                              
                                              	// The data format of the output of the job.
                                              	Format OutputFormat
                                              
                                              	// A value that, if true, means that any data in the location specified for output
                                              	// is overwritten with new output.
                                              	Overwrite bool
                                              
                                              	// The names of one or more partition columns for the output of the job.
                                              	PartitionColumns []string
                                              }

                                                Represents individual output from a particular job run.

                                                type OutputFormat

                                                type OutputFormat string
                                                const (
                                                	OutputFormatCsv         OutputFormat = "CSV"
                                                	OutputFormatJson        OutputFormat = "JSON"
                                                	OutputFormatParquet     OutputFormat = "PARQUET"
                                                	OutputFormatGlueparquet OutputFormat = "GLUEPARQUET"
                                                	OutputFormatAvro        OutputFormat = "AVRO"
                                                	OutputFormatOrc         OutputFormat = "ORC"
                                                	OutputFormatXml         OutputFormat = "XML"
                                                )

                                                  Enum values for OutputFormat

                                                  func (OutputFormat) Values

                                                  func (OutputFormat) Values() []OutputFormat

                                                    Values returns all known values for OutputFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type Project

                                                    type Project struct {
                                                    
                                                    	// The unique name of a project.
                                                    	//
                                                    	// This member is required.
                                                    	Name *string
                                                    
                                                    	// The name of a recipe that will be developed during a project session.
                                                    	//
                                                    	// This member is required.
                                                    	RecipeName *string
                                                    
                                                    	// The ID of the AWS account that owns the project.
                                                    	AccountId *string
                                                    
                                                    	// The date and time that the project was created.
                                                    	CreateDate *time.Time
                                                    
                                                    	// The identifier (the user name) of the user who crated the project.
                                                    	CreatedBy *string
                                                    
                                                    	// The dataset that the project is to act upon.
                                                    	DatasetName *string
                                                    
                                                    	// The identifier (user name) of the user who last modified the project.
                                                    	LastModifiedBy *string
                                                    
                                                    	// The last modification date and time for the project.
                                                    	LastModifiedDate *time.Time
                                                    
                                                    	// The date and time when the project was opened.
                                                    	OpenDate *time.Time
                                                    
                                                    	// The identifier (the user name) of the user that opened the project for use.
                                                    	OpenedBy *string
                                                    
                                                    	// The Amazon Resource Name (ARN) for the project.
                                                    	ResourceArn *string
                                                    
                                                    	// The Amazon Resource Name (ARN) of the role that will be assumed for this
                                                    	// project.
                                                    	RoleArn *string
                                                    
                                                    	// The sample size and sampling type to apply to the data. If this parameter isn't
                                                    	// specified, then the sample will consiste of the first 500 rows from the dataset.
                                                    	Sample *Sample
                                                    
                                                    	// Metadata tags that have been applied to the project.
                                                    	Tags map[string]string
                                                    }

                                                      Represents all of the attributes of an AWS Glue DataBrew project.

                                                      type Recipe

                                                      type Recipe struct {
                                                      
                                                      	// The unique name for the recipe.
                                                      	//
                                                      	// This member is required.
                                                      	Name *string
                                                      
                                                      	// The date and time that the recipe was created.
                                                      	CreateDate *time.Time
                                                      
                                                      	// The identifier (the user name) of the user who created the recipe.
                                                      	CreatedBy *string
                                                      
                                                      	// The description of the recipe.
                                                      	Description *string
                                                      
                                                      	// The identifier (user name) of the user who last modified the recipe.
                                                      	LastModifiedBy *string
                                                      
                                                      	// The last modification date and time of the recipe.
                                                      	LastModifiedDate *time.Time
                                                      
                                                      	// The name of the project that the recipe is associated with.
                                                      	ProjectName *string
                                                      
                                                      	// The identifier (the user name) of the user who published the recipe.
                                                      	PublishedBy *string
                                                      
                                                      	// The date and time when the recipe was published.
                                                      	PublishedDate *time.Time
                                                      
                                                      	// The identifier for the version for the recipe.
                                                      	RecipeVersion *string
                                                      
                                                      	// The Amazon Resource Name (ARN) for the recipe.
                                                      	ResourceArn *string
                                                      
                                                      	// A list of steps that are defined by the recipe.
                                                      	Steps []RecipeStep
                                                      
                                                      	// Metadata tags that have been applied to the recipe.
                                                      	Tags map[string]string
                                                      }

                                                        Represents one or more actions to be performed on an AWS Glue DataBrew dataset.

                                                        type RecipeAction

                                                        type RecipeAction struct {
                                                        
                                                        	// The name of a valid DataBrew transformation to be performed on the data.
                                                        	//
                                                        	// This member is required.
                                                        	Operation *string
                                                        
                                                        	// Contextual parameters for the transformation.
                                                        	Parameters map[string]string
                                                        }

                                                          Represents a transformation and associated parameters that are used to apply a change to an AWS Glue DataBrew dataset. For more information, see Recipe structure (https://docs.aws.amazon.com/databrew/latest/dg/recipe-structure.html) and ecipe actions reference (https://docs.aws.amazon.com/databrew/latest/dg/recipe-actions-reference.html) .

                                                          type RecipeReference

                                                          type RecipeReference struct {
                                                          
                                                          	// The name of the recipe.
                                                          	//
                                                          	// This member is required.
                                                          	Name *string
                                                          
                                                          	// The identifier for the version for the recipe.
                                                          	RecipeVersion *string
                                                          }

                                                            Represents all of the attributes of an AWS Glue DataBrew recipe.

                                                            type RecipeStep

                                                            type RecipeStep struct {
                                                            
                                                            	// The particular action to be performed in the recipe step.
                                                            	//
                                                            	// This member is required.
                                                            	Action *RecipeAction
                                                            
                                                            	// One or more conditions that must be met, in order for the recipe step to
                                                            	// succeed. All of the conditions in the array must be met. In other words, all of
                                                            	// the conditions must be combined using a logical AND operation.
                                                            	ConditionExpressions []ConditionExpression
                                                            }

                                                              Represents a single step to be performed in an AWS Glue DataBrew recipe.

                                                              type RecipeVersionErrorDetail

                                                              type RecipeVersionErrorDetail struct {
                                                              
                                                              	// The HTTP status code for the error.
                                                              	ErrorCode *string
                                                              
                                                              	// The text of the error message.
                                                              	ErrorMessage *string
                                                              
                                                              	// The identifier for the recipe version associated with this error.
                                                              	RecipeVersion *string
                                                              }

                                                                Represents any errors encountered when attempting to delete multiple recipe versions.

                                                                type ResourceNotFoundException

                                                                type ResourceNotFoundException struct {
                                                                	Message *string
                                                                }

                                                                  One or more resources can't be found.

                                                                  func (*ResourceNotFoundException) Error

                                                                  func (e *ResourceNotFoundException) Error() string

                                                                  func (*ResourceNotFoundException) ErrorCode

                                                                  func (e *ResourceNotFoundException) ErrorCode() string

                                                                  func (*ResourceNotFoundException) ErrorFault

                                                                  func (*ResourceNotFoundException) ErrorMessage

                                                                  func (e *ResourceNotFoundException) ErrorMessage() string

                                                                  type S3Location

                                                                  type S3Location struct {
                                                                  
                                                                  	// The S3 bucket name.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Bucket *string
                                                                  
                                                                  	// The unique name of the object in the bucket.
                                                                  	Key *string
                                                                  }

                                                                    An Amazon S3 location (bucket name an object key) where DataBrew can read input data, or write output from a job.

                                                                    type Sample

                                                                    type Sample struct {
                                                                    
                                                                    	// The way in which DataBrew obtains rows from a dataset.
                                                                    	//
                                                                    	// This member is required.
                                                                    	Type SampleType
                                                                    
                                                                    	// The number of rows in the sample.
                                                                    	Size *int32
                                                                    }

                                                                      Represents the sample size and sampling type for AWS Glue DataBrew to use for interactive data analysis.

                                                                      type SampleType

                                                                      type SampleType string
                                                                      const (
                                                                      	SampleTypeFirstN SampleType = "FIRST_N"
                                                                      	SampleTypeLastN  SampleType = "LAST_N"
                                                                      	SampleTypeRandom SampleType = "RANDOM"
                                                                      )

                                                                        Enum values for SampleType

                                                                        func (SampleType) Values

                                                                        func (SampleType) Values() []SampleType

                                                                          Values returns all known values for SampleType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                          type Schedule

                                                                          type Schedule struct {
                                                                          
                                                                          	// The name of the schedule.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Name *string
                                                                          
                                                                          	// The ID of the AWS account that owns the schedule.
                                                                          	AccountId *string
                                                                          
                                                                          	// The date and time that the schedule was created.
                                                                          	CreateDate *time.Time
                                                                          
                                                                          	// The identifier (the user name) of the user who created the schedule.
                                                                          	CreatedBy *string
                                                                          
                                                                          	// The date(s) and time(s), in cron format, when the job will run.
                                                                          	CronExpression *string
                                                                          
                                                                          	// A list of jobs to be run, according to the schedule.
                                                                          	JobNames []string
                                                                          
                                                                          	// The identifier (the user name) of the user who last modified the schedule.
                                                                          	LastModifiedBy *string
                                                                          
                                                                          	// The date and time when the schedule was last modified.
                                                                          	LastModifiedDate *time.Time
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the schedule.
                                                                          	ResourceArn *string
                                                                          
                                                                          	// Metadata tags that have been applied to the schedule.
                                                                          	Tags map[string]string
                                                                          }

                                                                            Represents one or more dates and times when a job is to run.

                                                                            type ServiceQuotaExceededException

                                                                            type ServiceQuotaExceededException struct {
                                                                            	Message *string
                                                                            }

                                                                              A service quota is exceeded.

                                                                              func (*ServiceQuotaExceededException) Error

                                                                              func (*ServiceQuotaExceededException) ErrorCode

                                                                              func (e *ServiceQuotaExceededException) ErrorCode() string

                                                                              func (*ServiceQuotaExceededException) ErrorFault

                                                                              func (*ServiceQuotaExceededException) ErrorMessage

                                                                              func (e *ServiceQuotaExceededException) ErrorMessage() string

                                                                              type SessionStatus

                                                                              type SessionStatus string
                                                                              const (
                                                                              	SessionStatusAssigned     SessionStatus = "ASSIGNED"
                                                                              	SessionStatusFailed       SessionStatus = "FAILED"
                                                                              	SessionStatusInitializing SessionStatus = "INITIALIZING"
                                                                              	SessionStatusProvisioning SessionStatus = "PROVISIONING"
                                                                              	SessionStatusReady        SessionStatus = "READY"
                                                                              	SessionStatusRecycling    SessionStatus = "RECYCLING"
                                                                              	SessionStatusRotating     SessionStatus = "ROTATING"
                                                                              	SessionStatusTerminated   SessionStatus = "TERMINATED"
                                                                              	SessionStatusTerminating  SessionStatus = "TERMINATING"
                                                                              	SessionStatusUpdating     SessionStatus = "UPDATING"
                                                                              )

                                                                                Enum values for SessionStatus

                                                                                func (SessionStatus) Values

                                                                                func (SessionStatus) Values() []SessionStatus

                                                                                  Values returns all known values for SessionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                  type Source

                                                                                  type Source string
                                                                                  const (
                                                                                  	SourceS3          Source = "S3"
                                                                                  	SourceDatacatalog Source = "DATA-CATALOG"
                                                                                  )

                                                                                    Enum values for Source

                                                                                    func (Source) Values

                                                                                    func (Source) Values() []Source

                                                                                      Values returns all known values for Source. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type ValidationException

                                                                                      type ValidationException struct {
                                                                                      	Message *string
                                                                                      }

                                                                                        The input parameters for this request failed validation.

                                                                                        func (*ValidationException) Error

                                                                                        func (e *ValidationException) Error() string

                                                                                        func (*ValidationException) ErrorCode

                                                                                        func (e *ValidationException) ErrorCode() string

                                                                                        func (*ValidationException) ErrorFault

                                                                                        func (e *ValidationException) ErrorFault() smithy.ErrorFault

                                                                                        func (*ValidationException) ErrorMessage

                                                                                        func (e *ValidationException) ErrorMessage() string

                                                                                        type ViewFrame

                                                                                        type ViewFrame struct {
                                                                                        
                                                                                        	// The starting index for the range of columns to return in the view frame.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	StartColumnIndex *int32
                                                                                        
                                                                                        	// The number of columns to include in the view frame, beginning with the
                                                                                        	// StartColumnIndex value and ignoring any columns in the HiddenColumns list.
                                                                                        	ColumnRange *int32
                                                                                        
                                                                                        	// A list of columns to hide in the view frame.
                                                                                        	HiddenColumns []string
                                                                                        }

                                                                                          Represents the data being being transformed during an AWS Glue DataBrew project session.