aws.glue.MLTransform

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const testCatalogDatabase = new aws.glue.CatalogDatabase("test", {name: "example"});
const testCatalogTable = new aws.glue.CatalogTable("test", {
    storageDescriptor: {
        serDeInfo: {
            name: "ser_de_name",
            parameters: {
                param1: "param_val_1",
            },
            serializationLibrary: "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe",
        },
        skewedInfo: {
            skewedColumnNames: ["my_column_1"],
            skewedColumnValueLocationMaps: {
                my_column_1: "my_column_1_val_loc_map",
            },
            skewedColumnValues: ["skewed_val_1"],
        },
        columns: [
            {
                name: "my_column_1",
                type: "int",
                comment: "my_column1_comment",
            },
            {
                name: "my_column_2",
                type: "string",
                comment: "my_column2_comment",
            },
        ],
        sortColumns: [{
            column: "my_column_1",
            sortOrder: 1,
        }],
        bucketColumns: ["bucket_column_1"],
        compressed: false,
        inputFormat: "SequenceFileInputFormat",
        location: "my_location",
        numberOfBuckets: 1,
        outputFormat: "SequenceFileInputFormat",
        storedAsSubDirectories: false,
        parameters: {
            param1: "param1_val",
        },
    },
    partitionKeys: [
        {
            name: "my_column_1",
            type: "int",
            comment: "my_column_1_comment",
        },
        {
            name: "my_column_2",
            type: "string",
            comment: "my_column_2_comment",
        },
    ],
    name: "example",
    databaseName: testCatalogDatabase.name,
    owner: "my_owner",
    retention: 1,
    tableType: "VIRTUAL_VIEW",
    viewExpandedText: "view_expanded_text_1",
    viewOriginalText: "view_original_text_1",
    parameters: {
        param1: "param1_val",
    },
});
const test = new aws.glue.MLTransform("test", {
    parameters: {
        findMatchesParameters: {
            primaryKeyColumnName: "my_column_1",
        },
        transformType: "FIND_MATCHES",
    },
    inputRecordTables: [{
        databaseName: testCatalogTable.databaseName,
        tableName: testCatalogTable.name,
    }],
    name: "example",
    roleArn: testAwsIamRole.arn,
}, {
    dependsOn: [testAwsIamRolePolicyAttachment],
});

import pulumi
import pulumi_aws as aws

test_catalog_database = aws.glue.CatalogDatabase("test", name="example")
test_catalog_table = aws.glue.CatalogTable("test",
    storage_descriptor={
        "ser_de_info": {
            "name": "ser_de_name",
            "parameters": {
                "param1": "param_val_1",
            },
            "serialization_library": "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe",
        },
        "skewed_info": {
            "skewed_column_names": ["my_column_1"],
            "skewed_column_value_location_maps": {
                "my_column_1": "my_column_1_val_loc_map",
            },
            "skewed_column_values": ["skewed_val_1"],
        },
        "columns": [
            {
                "name": "my_column_1",
                "type": "int",
                "comment": "my_column1_comment",
            },
            {
                "name": "my_column_2",
                "type": "string",
                "comment": "my_column2_comment",
            },
        ],
        "sort_columns": [{
            "column": "my_column_1",
            "sort_order": 1,
        }],
        "bucket_columns": ["bucket_column_1"],
        "compressed": False,
        "input_format": "SequenceFileInputFormat",
        "location": "my_location",
        "number_of_buckets": 1,
        "output_format": "SequenceFileInputFormat",
        "stored_as_sub_directories": False,
        "parameters": {
            "param1": "param1_val",
        },
    },
    partition_keys=[
        {
            "name": "my_column_1",
            "type": "int",
            "comment": "my_column_1_comment",
        },
        {
            "name": "my_column_2",
            "type": "string",
            "comment": "my_column_2_comment",
        },
    ],
    name="example",
    database_name=test_catalog_database.name,
    owner="my_owner",
    retention=1,
    table_type="VIRTUAL_VIEW",
    view_expanded_text="view_expanded_text_1",
    view_original_text="view_original_text_1",
    parameters={
        "param1": "param1_val",
    })
test = aws.glue.MLTransform("test",
    parameters={
        "find_matches_parameters": {
            "primary_key_column_name": "my_column_1",
        },
        "transform_type": "FIND_MATCHES",
    },
    input_record_tables=[{
        "database_name": test_catalog_table.database_name,
        "table_name": test_catalog_table.name,
    }],
    name="example",
    role_arn=test_aws_iam_role["arn"],
    opts = pulumi.ResourceOptions(depends_on=[test_aws_iam_role_policy_attachment]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testCatalogDatabase, err := glue.NewCatalogDatabase(ctx, "test", &glue.CatalogDatabaseArgs{
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		testCatalogTable, err := glue.NewCatalogTable(ctx, "test", &glue.CatalogTableArgs{
			StorageDescriptor: &glue.CatalogTableStorageDescriptorArgs{
				SerDeInfo: &glue.CatalogTableStorageDescriptorSerDeInfoArgs{
					Name: pulumi.String("ser_de_name"),
					Parameters: pulumi.StringMap{
						"param1": pulumi.String("param_val_1"),
					},
					SerializationLibrary: pulumi.String("org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe"),
				},
				SkewedInfo: &glue.CatalogTableStorageDescriptorSkewedInfoArgs{
					SkewedColumnNames: pulumi.StringArray{
						pulumi.String("my_column_1"),
					},
					SkewedColumnValueLocationMaps: pulumi.StringMap{
						"my_column_1": pulumi.String("my_column_1_val_loc_map"),
					},
					SkewedColumnValues: pulumi.StringArray{
						pulumi.String("skewed_val_1"),
					},
				},
				Columns: glue.CatalogTableStorageDescriptorColumnArray{
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name:    pulumi.String("my_column_1"),
						Type:    pulumi.String("int"),
						Comment: pulumi.String("my_column1_comment"),
					},
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name:    pulumi.String("my_column_2"),
						Type:    pulumi.String("string"),
						Comment: pulumi.String("my_column2_comment"),
					},
				},
				SortColumns: glue.CatalogTableStorageDescriptorSortColumnArray{
					&glue.CatalogTableStorageDescriptorSortColumnArgs{
						Column:    pulumi.String("my_column_1"),
						SortOrder: pulumi.Int(1),
					},
				},
				BucketColumns: pulumi.StringArray{
					pulumi.String("bucket_column_1"),
				},
				Compressed:             pulumi.Bool(false),
				InputFormat:            pulumi.String("SequenceFileInputFormat"),
				Location:               pulumi.String("my_location"),
				NumberOfBuckets:        pulumi.Int(1),
				OutputFormat:           pulumi.String("SequenceFileInputFormat"),
				StoredAsSubDirectories: pulumi.Bool(false),
				Parameters: pulumi.StringMap{
					"param1": pulumi.String("param1_val"),
				},
			},
			PartitionKeys: glue.CatalogTablePartitionKeyArray{
				&glue.CatalogTablePartitionKeyArgs{
					Name:    pulumi.String("my_column_1"),
					Type:    pulumi.String("int"),
					Comment: pulumi.String("my_column_1_comment"),
				},
				&glue.CatalogTablePartitionKeyArgs{
					Name:    pulumi.String("my_column_2"),
					Type:    pulumi.String("string"),
					Comment: pulumi.String("my_column_2_comment"),
				},
			},
			Name:             pulumi.String("example"),
			DatabaseName:     testCatalogDatabase.Name,
			Owner:            pulumi.String("my_owner"),
			Retention:        pulumi.Int(1),
			TableType:        pulumi.String("VIRTUAL_VIEW"),
			ViewExpandedText: pulumi.String("view_expanded_text_1"),
			ViewOriginalText: pulumi.String("view_original_text_1"),
			Parameters: pulumi.StringMap{
				"param1": pulumi.String("param1_val"),
			},
		})
		if err != nil {
			return err
		}
		_, err = glue.NewMLTransform(ctx, "test", &glue.MLTransformArgs{
			Parameters: &glue.MLTransformParametersArgs{
				FindMatchesParameters: &glue.MLTransformParametersFindMatchesParametersArgs{
					PrimaryKeyColumnName: pulumi.String("my_column_1"),
				},
				TransformType: pulumi.String("FIND_MATCHES"),
			},
			InputRecordTables: glue.MLTransformInputRecordTableArray{
				&glue.MLTransformInputRecordTableArgs{
					DatabaseName: testCatalogTable.DatabaseName,
					TableName:    testCatalogTable.Name,
				},
			},
			Name:    pulumi.String("example"),
			RoleArn: pulumi.Any(testAwsIamRole.Arn),
		}, pulumi.DependsOn([]pulumi.Resource{
			testAwsIamRolePolicyAttachment,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var testCatalogDatabase = new Aws.Glue.CatalogDatabase("test", new()
    {
        Name = "example",
    });

    var testCatalogTable = new Aws.Glue.CatalogTable("test", new()
    {
        StorageDescriptor = new Aws.Glue.Inputs.CatalogTableStorageDescriptorArgs
        {
            SerDeInfo = new Aws.Glue.Inputs.CatalogTableStorageDescriptorSerDeInfoArgs
            {
                Name = "ser_de_name",
                Parameters = 
                {
                    { "param1", "param_val_1" },
                },
                SerializationLibrary = "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe",
            },
            SkewedInfo = new Aws.Glue.Inputs.CatalogTableStorageDescriptorSkewedInfoArgs
            {
                SkewedColumnNames = new[]
                {
                    "my_column_1",
                },
                SkewedColumnValueLocationMaps = 
                {
                    { "my_column_1", "my_column_1_val_loc_map" },
                },
                SkewedColumnValues = new[]
                {
                    "skewed_val_1",
                },
            },
            Columns = new[]
            {
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_column_1",
                    Type = "int",
                    Comment = "my_column1_comment",
                },
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_column_2",
                    Type = "string",
                    Comment = "my_column2_comment",
                },
            },
            SortColumns = new[]
            {
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorSortColumnArgs
                {
                    Column = "my_column_1",
                    SortOrder = 1,
                },
            },
            BucketColumns = new[]
            {
                "bucket_column_1",
            },
            Compressed = false,
            InputFormat = "SequenceFileInputFormat",
            Location = "my_location",
            NumberOfBuckets = 1,
            OutputFormat = "SequenceFileInputFormat",
            StoredAsSubDirectories = false,
            Parameters = 
            {
                { "param1", "param1_val" },
            },
        },
        PartitionKeys = new[]
        {
            new Aws.Glue.Inputs.CatalogTablePartitionKeyArgs
            {
                Name = "my_column_1",
                Type = "int",
                Comment = "my_column_1_comment",
            },
            new Aws.Glue.Inputs.CatalogTablePartitionKeyArgs
            {
                Name = "my_column_2",
                Type = "string",
                Comment = "my_column_2_comment",
            },
        },
        Name = "example",
        DatabaseName = testCatalogDatabase.Name,
        Owner = "my_owner",
        Retention = 1,
        TableType = "VIRTUAL_VIEW",
        ViewExpandedText = "view_expanded_text_1",
        ViewOriginalText = "view_original_text_1",
        Parameters = 
        {
            { "param1", "param1_val" },
        },
    });

    var test = new Aws.Glue.MLTransform("test", new()
    {
        Parameters = new Aws.Glue.Inputs.MLTransformParametersArgs
        {
            FindMatchesParameters = new Aws.Glue.Inputs.MLTransformParametersFindMatchesParametersArgs
            {
                PrimaryKeyColumnName = "my_column_1",
            },
            TransformType = "FIND_MATCHES",
        },
        InputRecordTables = new[]
        {
            new Aws.Glue.Inputs.MLTransformInputRecordTableArgs
            {
                DatabaseName = testCatalogTable.DatabaseName,
                TableName = testCatalogTable.Name,
            },
        },
        Name = "example",
        RoleArn = testAwsIamRole.Arn,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            testAwsIamRolePolicyAttachment,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.CatalogDatabase;
import com.pulumi.aws.glue.CatalogDatabaseArgs;
import com.pulumi.aws.glue.CatalogTable;
import com.pulumi.aws.glue.CatalogTableArgs;
import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorArgs;
import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorSerDeInfoArgs;
import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorSkewedInfoArgs;
import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorColumnArgs;
import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorSortColumnArgs;
import com.pulumi.aws.glue.inputs.CatalogTablePartitionKeyArgs;
import com.pulumi.aws.glue.MLTransform;
import com.pulumi.aws.glue.MLTransformArgs;
import com.pulumi.aws.glue.inputs.MLTransformParametersArgs;
import com.pulumi.aws.glue.inputs.MLTransformParametersFindMatchesParametersArgs;
import com.pulumi.aws.glue.inputs.MLTransformInputRecordTableArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testCatalogDatabase = new CatalogDatabase("testCatalogDatabase", CatalogDatabaseArgs.builder()
            .name("example")
            .build());

        var testCatalogTable = new CatalogTable("testCatalogTable", CatalogTableArgs.builder()
            .storageDescriptor(CatalogTableStorageDescriptorArgs.builder()
                .serDeInfo(CatalogTableStorageDescriptorSerDeInfoArgs.builder()
                    .name("ser_de_name")
                    .parameters(Map.of("param1", "param_val_1"))
                    .serializationLibrary("org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe")
                    .build())
                .skewedInfo(CatalogTableStorageDescriptorSkewedInfoArgs.builder()
                    .skewedColumnNames("my_column_1")
                    .skewedColumnValueLocationMaps(Map.of("my_column_1", "my_column_1_val_loc_map"))
                    .skewedColumnValues("skewed_val_1")
                    .build())
                .columns(                
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_column_1")
                        .type("int")
                        .comment("my_column1_comment")
                        .build(),
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_column_2")
                        .type("string")
                        .comment("my_column2_comment")
                        .build())
                .sortColumns(CatalogTableStorageDescriptorSortColumnArgs.builder()
                    .column("my_column_1")
                    .sortOrder(1)
                    .build())
                .bucketColumns("bucket_column_1")
                .compressed(false)
                .inputFormat("SequenceFileInputFormat")
                .location("my_location")
                .numberOfBuckets(1)
                .outputFormat("SequenceFileInputFormat")
                .storedAsSubDirectories(false)
                .parameters(Map.of("param1", "param1_val"))
                .build())
            .partitionKeys(            
                CatalogTablePartitionKeyArgs.builder()
                    .name("my_column_1")
                    .type("int")
                    .comment("my_column_1_comment")
                    .build(),
                CatalogTablePartitionKeyArgs.builder()
                    .name("my_column_2")
                    .type("string")
                    .comment("my_column_2_comment")
                    .build())
            .name("example")
            .databaseName(testCatalogDatabase.name())
            .owner("my_owner")
            .retention(1)
            .tableType("VIRTUAL_VIEW")
            .viewExpandedText("view_expanded_text_1")
            .viewOriginalText("view_original_text_1")
            .parameters(Map.of("param1", "param1_val"))
            .build());

        var test = new MLTransform("test", MLTransformArgs.builder()
            .parameters(MLTransformParametersArgs.builder()
                .findMatchesParameters(MLTransformParametersFindMatchesParametersArgs.builder()
                    .primaryKeyColumnName("my_column_1")
                    .build())
                .transformType("FIND_MATCHES")
                .build())
            .inputRecordTables(MLTransformInputRecordTableArgs.builder()
                .databaseName(testCatalogTable.databaseName())
                .tableName(testCatalogTable.name())
                .build())
            .name("example")
            .roleArn(testAwsIamRole.get("arn"))
            .build(), CustomResourceOptions.builder()
                .dependsOn(testAwsIamRolePolicyAttachment)
                .build());

    }
}

resources:
  test:
    type: aws:glue:MLTransform
    properties:
      parameters:
        findMatchesParameters:
          primaryKeyColumnName: my_column_1
        transformType: FIND_MATCHES
      inputRecordTables:
        - databaseName: ${testCatalogTable.databaseName}
          tableName: ${testCatalogTable.name}
      name: example
      roleArn: ${testAwsIamRole.arn}
    options:
      dependsOn:
        - ${testAwsIamRolePolicyAttachment}
  testCatalogDatabase:
    type: aws:glue:CatalogDatabase
    name: test
    properties:
      name: example
  testCatalogTable:
    type: aws:glue:CatalogTable
    name: test
    properties:
      storageDescriptor:
        serDeInfo:
          name: ser_de_name
          parameters:
            param1: param_val_1
          serializationLibrary: org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe
        skewedInfo:
          skewedColumnNames:
            - my_column_1
          skewedColumnValueLocationMaps:
            my_column_1: my_column_1_val_loc_map
          skewedColumnValues:
            - skewed_val_1
        columns:
          - name: my_column_1
            type: int
            comment: my_column1_comment
          - name: my_column_2
            type: string
            comment: my_column2_comment
        sortColumns:
          - column: my_column_1
            sortOrder: 1
        bucketColumns:
          - bucket_column_1
        compressed: false
        inputFormat: SequenceFileInputFormat
        location: my_location
        numberOfBuckets: 1
        outputFormat: SequenceFileInputFormat
        storedAsSubDirectories: false
        parameters:
          param1: param1_val
      partitionKeys:
        - name: my_column_1
          type: int
          comment: my_column_1_comment
        - name: my_column_2
          type: string
          comment: my_column_2_comment
      name: example
      databaseName: ${testCatalogDatabase.name}
      owner: my_owner
      retention: 1
      tableType: VIRTUAL_VIEW
      viewExpandedText: view_expanded_text_1
      viewOriginalText: view_original_text_1
      parameters:
        param1: param1_val

terraform {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_glue_m_l_transform" "test" {
  depends_on = [testAwsIamRolePolicyAttachment]
  lifecycle {
    create_before_destroy = true
  }
  parameters = {
    find_matches_parameters = {
      primary_key_column_name = "my_column_1"
    }
    transform_type = "FIND_MATCHES"
  }
  input_record_tables {
    database_name = aws_glue_catalog_table.test.database_name
    table_name    = aws_glue_catalog_table.test.name
  }
  name     = "example"
  role_arn = testAwsIamRole.arn
}
resource "aws_glue_catalog_database" "test" {
  lifecycle {
    create_before_destroy = true
  }
  name = "example"
}
resource "aws_glue_catalog_table" "test" {
  lifecycle {
    create_before_destroy = true
  }
  storage_descriptor {
    ser_de_info {
      name = "ser_de_name"
      parameters = {
        "param1" = "param_val_1"
      }
      serialization_library = "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe"
    }
    skewed_info {
      skewed_column_names = ["my_column_1"]
      skewed_column_value_location_maps = {
        "my_column_1" = "my_column_1_val_loc_map"
      }
      skewed_column_values = ["skewed_val_1"]
    }
    columns {
      name    = "my_column_1"
      type    = "int"
      comment = "my_column1_comment"
    }
    columns {
      name    = "my_column_2"
      type    = "string"
      comment = "my_column2_comment"
    }
    sort_columns {
      column     = "my_column_1"
      sort_order = 1
    }
    bucket_columns            = ["bucket_column_1"]
    compressed                = false
    input_format              = "SequenceFileInputFormat"
    location                  = "my_location"
    number_of_buckets         = 1
    output_format             = "SequenceFileInputFormat"
    stored_as_sub_directories = false
    parameters = {
      "param1" = "param1_val"
    }
  }
  partition_keys {
    name    = "my_column_1"
    type    = "int"
    comment = "my_column_1_comment"
  }
  partition_keys {
    name    = "my_column_2"
    type    = "string"
    comment = "my_column_2_comment"
  }
  name               = "example"
  database_name      = aws_glue_catalog_database.test.name
  owner              = "my_owner"
  retention          = 1
  table_type         = "VIRTUAL_VIEW"
  view_expanded_text = "view_expanded_text_1"
  view_original_text = "view_original_text_1"
  parameters = {
    "param1" = "param1_val"
  }
}

var mltransformResource = new Aws.Glue.MLTransform("mltransformResource", new()
{
    Parameters = new Aws.Glue.Inputs.MLTransformParametersArgs
    {
        FindMatchesParameters = new Aws.Glue.Inputs.MLTransformParametersFindMatchesParametersArgs
        {
            AccuracyCostTradeOff = 0.0,
            EnforceProvidedLabels = false,
            PrecisionRecallTradeOff = 0.0,
            PrimaryKeyColumnName = "string",
        },
        TransformType = "string",
    },
    RoleArn = "string",
    InputRecordTables = new[]
    {
        new Aws.Glue.Inputs.MLTransformInputRecordTableArgs
        {
            DatabaseName = "string",
            TableName = "string",
            CatalogId = "string",
            ConnectionName = "string",
        },
    },
    MaxCapacity = 0.0,
    MaxRetries = 0,
    Name = "string",
    NumberOfWorkers = 0,
    Description = "string",
    Region = "string",
    GlueVersion = "string",
    Tags = 
    {
        { "string", "string" },
    },
    Timeout = 0,
    WorkerType = "string",
});

example, err := glue.NewMLTransform(ctx, "mltransformResource", &glue.MLTransformArgs{
	Parameters: &glue.MLTransformParametersArgs{
		FindMatchesParameters: &glue.MLTransformParametersFindMatchesParametersArgs{
			AccuracyCostTradeOff:    pulumi.Float64(0),
			EnforceProvidedLabels:   pulumi.Bool(false),
			PrecisionRecallTradeOff: pulumi.Float64(0),
			PrimaryKeyColumnName:    pulumi.String("string"),
		},
		TransformType: pulumi.String("string"),
	},
	RoleArn: pulumi.String("string"),
	InputRecordTables: glue.MLTransformInputRecordTableArray{
		&glue.MLTransformInputRecordTableArgs{
			DatabaseName:   pulumi.String("string"),
			TableName:      pulumi.String("string"),
			CatalogId:      pulumi.String("string"),
			ConnectionName: pulumi.String("string"),
		},
	},
	MaxCapacity:     pulumi.Float64(0),
	MaxRetries:      pulumi.Int(0),
	Name:            pulumi.String("string"),
	NumberOfWorkers: pulumi.Int(0),
	Description:     pulumi.String("string"),
	Region:          pulumi.String("string"),
	GlueVersion:     pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Timeout:    pulumi.Int(0),
	WorkerType: pulumi.String("string"),
})

resource "aws_glue_m_l_transform" "mltransformResource" {
  lifecycle {
    create_before_destroy = true
  }
  parameters = {
    find_matches_parameters = {
      accuracy_cost_trade_off    = 0
      enforce_provided_labels    = false
      precision_recall_trade_off = 0
      primary_key_column_name    = "string"
    }
    transform_type = "string"
  }
  role_arn = "string"
  input_record_tables {
    database_name   = "string"
    table_name      = "string"
    catalog_id      = "string"
    connection_name = "string"
  }
  max_capacity      = 0
  max_retries       = 0
  name              = "string"
  number_of_workers = 0
  description       = "string"
  region            = "string"
  glue_version      = "string"
  tags = {
    "string" = "string"
  }
  timeout     = 0
  worker_type = "string"
}

var mltransformResource = new MLTransform("mltransformResource", MLTransformArgs.builder()
    .parameters(MLTransformParametersArgs.builder()
        .findMatchesParameters(MLTransformParametersFindMatchesParametersArgs.builder()
            .accuracyCostTradeOff(0.0)
            .enforceProvidedLabels(false)
            .precisionRecallTradeOff(0.0)
            .primaryKeyColumnName("string")
            .build())
        .transformType("string")
        .build())
    .roleArn("string")
    .inputRecordTables(MLTransformInputRecordTableArgs.builder()
        .databaseName("string")
        .tableName("string")
        .catalogId("string")
        .connectionName("string")
        .build())
    .maxCapacity(0.0)
    .maxRetries(0)
    .name("string")
    .numberOfWorkers(0)
    .description("string")
    .region("string")
    .glueVersion("string")
    .tags(Map.of("string", "string"))
    .timeout(0)
    .workerType("string")
    .build());

mltransform_resource = aws.glue.MLTransform("mltransformResource",
    parameters={
        "find_matches_parameters": {
            "accuracy_cost_trade_off": float(0),
            "enforce_provided_labels": False,
            "precision_recall_trade_off": float(0),
            "primary_key_column_name": "string",
        },
        "transform_type": "string",
    },
    role_arn="string",
    input_record_tables=[{
        "database_name": "string",
        "table_name": "string",
        "catalog_id": "string",
        "connection_name": "string",
    }],
    max_capacity=float(0),
    max_retries=0,
    name="string",
    number_of_workers=0,
    description="string",
    region="string",
    glue_version="string",
    tags={
        "string": "string",
    },
    timeout=0,
    worker_type="string")

const mltransformResource = new aws.glue.MLTransform("mltransformResource", {
    parameters: {
        findMatchesParameters: {
            accuracyCostTradeOff: 0,
            enforceProvidedLabels: false,
            precisionRecallTradeOff: 0,
            primaryKeyColumnName: "string",
        },
        transformType: "string",
    },
    roleArn: "string",
    inputRecordTables: [{
        databaseName: "string",
        tableName: "string",
        catalogId: "string",
        connectionName: "string",
    }],
    maxCapacity: 0,
    maxRetries: 0,
    name: "string",
    numberOfWorkers: 0,
    description: "string",
    region: "string",
    glueVersion: "string",
    tags: {
        string: "string",
    },
    timeout: 0,
    workerType: "string",
});

type: aws:glue:MLTransform
properties:
    description: string
    glueVersion: string
    inputRecordTables:
        - catalogId: string
          connectionName: string
          databaseName: string
          tableName: string
    maxCapacity: 0
    maxRetries: 0
    name: string
    numberOfWorkers: 0
    parameters:
        findMatchesParameters:
            accuracyCostTradeOff: 0
            enforceProvidedLabels: false
            precisionRecallTradeOff: 0
            primaryKeyColumnName: string
        transformType: string
    region: string
    roleArn: string
    tags:
        string: string
    timeout: 0
    workerType: string