pulumi-aws-kotlin/com.pulumi.aws.glue.kotlin/CatalogTable

CatalogTable

class CatalogTable : KotlinCustomResource

Provides a Glue Catalog Table Resource. You can refer to the Glue Developer Guide for a full explanation of the Glue Data Catalog functionality.

Example Usage

Basic Table

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const awsGlueCatalogTable = new aws.glue.CatalogTable("aws_glue_catalog_table", {
    name: "MyCatalogTable",
    databaseName: "MyCatalogDatabase",
});

import pulumi
import pulumi_aws as aws
aws_glue_catalog_table = aws.glue.CatalogTable("aws_glue_catalog_table",
    name="MyCatalogTable",
    database_name="MyCatalogDatabase")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var awsGlueCatalogTable = new Aws.Glue.CatalogTable("aws_glue_catalog_table", new()
    {
        Name = "MyCatalogTable",
        DatabaseName = "MyCatalogDatabase",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewCatalogTable(ctx, "aws_glue_catalog_table", &glue.CatalogTableArgs{
			Name:         pulumi.String("MyCatalogTable"),
			DatabaseName: pulumi.String("MyCatalogDatabase"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.CatalogTable;
import com.pulumi.aws.glue.CatalogTableArgs;
import java.util.List;
import java.util.ArrayList;
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 awsGlueCatalogTable = new CatalogTable("awsGlueCatalogTable", CatalogTableArgs.builder()
            .name("MyCatalogTable")
            .databaseName("MyCatalogDatabase")
            .build());
    }
}

resources:
  awsGlueCatalogTable:
    type: aws:glue:CatalogTable
    name: aws_glue_catalog_table
    properties:
      name: MyCatalogTable
      databaseName: MyCatalogDatabase

Parquet Table for Athena

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const awsGlueCatalogTable = new aws.glue.CatalogTable("aws_glue_catalog_table", {
    name: "MyCatalogTable",
    databaseName: "MyCatalogDatabase",
    tableType: "EXTERNAL_TABLE",
    parameters: {
        EXTERNAL: "TRUE",
        "parquet.compression": "SNAPPY",
    },
    storageDescriptor: {
        location: "s3://my-bucket/event-streams/my-stream",
        inputFormat: "org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat",
        outputFormat: "org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat",
        serDeInfo: {
            name: "my-stream",
            serializationLibrary: "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe",
            parameters: {
                "serialization.format": "1",
            },
        },
        columns: [
            {
                name: "my_string",
                type: "string",
            },
            {
                name: "my_double",
                type: "double",
            },
            {
                name: "my_date",
                type: "date",
                comment: "",
            },
            {
                name: "my_bigint",
                type: "bigint",
                comment: "",
            },
            {
                name: "my_struct",
                type: "struct<my_nested_string:string>",
                comment: "",
            },
        ],
    },
});

import pulumi
import pulumi_aws as aws
aws_glue_catalog_table = aws.glue.CatalogTable("aws_glue_catalog_table",
    name="MyCatalogTable",
    database_name="MyCatalogDatabase",
    table_type="EXTERNAL_TABLE",
    parameters={
        "EXTERNAL": "TRUE",
        "parquet.compression": "SNAPPY",
    },
    storage_descriptor={
        "location": "s3://my-bucket/event-streams/my-stream",
        "input_format": "org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat",
        "output_format": "org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat",
        "ser_de_info": {
            "name": "my-stream",
            "serialization_library": "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe",
            "parameters": {
                "serialization.format": "1",
            },
        },
        "columns": [
            {
                "name": "my_string",
                "type": "string",
            },
            {
                "name": "my_double",
                "type": "double",
            },
            {
                "name": "my_date",
                "type": "date",
                "comment": "",
            },
            {
                "name": "my_bigint",
                "type": "bigint",
                "comment": "",
            },
            {
                "name": "my_struct",
                "type": "struct<my_nested_string:string>",
                "comment": "",
            },
        ],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var awsGlueCatalogTable = new Aws.Glue.CatalogTable("aws_glue_catalog_table", new()
    {
        Name = "MyCatalogTable",
        DatabaseName = "MyCatalogDatabase",
        TableType = "EXTERNAL_TABLE",
        Parameters =
        {
            { "EXTERNAL", "TRUE" },
            { "parquet.compression", "SNAPPY" },
        },
        StorageDescriptor = new Aws.Glue.Inputs.CatalogTableStorageDescriptorArgs
        {
            Location = "s3://my-bucket/event-streams/my-stream",
            InputFormat = "org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat",
            OutputFormat = "org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat",
            SerDeInfo = new Aws.Glue.Inputs.CatalogTableStorageDescriptorSerDeInfoArgs
            {
                Name = "my-stream",
                SerializationLibrary = "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe",
                Parameters =
                {
                    { "serialization.format", "1" },
                },
            },
            Columns = new[]
            {
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_string",
                    Type = "string",
                },
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_double",
                    Type = "double",
                },
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_date",
                    Type = "date",
                    Comment = "",
                },
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_bigint",
                    Type = "bigint",
                    Comment = "",
                },
                new Aws.Glue.Inputs.CatalogTableStorageDescriptorColumnArgs
                {
                    Name = "my_struct",
                    Type = "struct<my_nested_string:string>",
                    Comment = "",
                },
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewCatalogTable(ctx, "aws_glue_catalog_table", &glue.CatalogTableArgs{
			Name:         pulumi.String("MyCatalogTable"),
			DatabaseName: pulumi.String("MyCatalogDatabase"),
			TableType:    pulumi.String("EXTERNAL_TABLE"),
			Parameters: pulumi.StringMap{
				"EXTERNAL":            pulumi.String("TRUE"),
				"parquet.compression": pulumi.String("SNAPPY"),
			},
			StorageDescriptor: &glue.CatalogTableStorageDescriptorArgs{
				Location:     pulumi.String("s3://my-bucket/event-streams/my-stream"),
				InputFormat:  pulumi.String("org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat"),
				OutputFormat: pulumi.String("org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat"),
				SerDeInfo: &glue.CatalogTableStorageDescriptorSerDeInfoArgs{
					Name:                 pulumi.String("my-stream"),
					SerializationLibrary: pulumi.String("org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe"),
					Parameters: pulumi.StringMap{
						"serialization.format": pulumi.String("1"),
					},
				},
				Columns: glue.CatalogTableStorageDescriptorColumnArray{
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name: pulumi.String("my_string"),
						Type: pulumi.String("string"),
					},
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name: pulumi.String("my_double"),
						Type: pulumi.String("double"),
					},
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name:    pulumi.String("my_date"),
						Type:    pulumi.String("date"),
						Comment: pulumi.String(""),
					},
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name:    pulumi.String("my_bigint"),
						Type:    pulumi.String("bigint"),
						Comment: pulumi.String(""),
					},
					&glue.CatalogTableStorageDescriptorColumnArgs{
						Name:    pulumi.String("my_struct"),
						Type:    pulumi.String("struct<my_nested_string:string>"),
						Comment: pulumi.String(""),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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 java.util.List;
import java.util.ArrayList;
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 awsGlueCatalogTable = new CatalogTable("awsGlueCatalogTable", CatalogTableArgs.builder()
            .name("MyCatalogTable")
            .databaseName("MyCatalogDatabase")
            .tableType("EXTERNAL_TABLE")
            .parameters(Map.ofEntries(
                Map.entry("EXTERNAL", "TRUE"),
                Map.entry("parquet.compression", "SNAPPY")
            ))
            .storageDescriptor(CatalogTableStorageDescriptorArgs.builder()
                .location("s3://my-bucket/event-streams/my-stream")
                .inputFormat("org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat")
                .outputFormat("org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat")
                .serDeInfo(CatalogTableStorageDescriptorSerDeInfoArgs.builder()
                    .name("my-stream")
                    .serializationLibrary("org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe")
                    .parameters(Map.of("serialization.format", 1))
                    .build())
                .columns(
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_string")
                        .type("string")
                        .build(),
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_double")
                        .type("double")
                        .build(),
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_date")
                        .type("date")
                        .comment("")
                        .build(),
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_bigint")
                        .type("bigint")
                        .comment("")
                        .build(),
                    CatalogTableStorageDescriptorColumnArgs.builder()
                        .name("my_struct")
                        .type("struct<my_nested_string:string>")
                        .comment("")
                        .build())
                .build())
            .build());
    }
}

resources:
  awsGlueCatalogTable:
    type: aws:glue:CatalogTable
    name: aws_glue_catalog_table
    properties:
      name: MyCatalogTable
      databaseName: MyCatalogDatabase
      tableType: EXTERNAL_TABLE
      parameters:
        EXTERNAL: TRUE
        parquet.compression: SNAPPY
      storageDescriptor:
        location: s3://my-bucket/event-streams/my-stream
        inputFormat: org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat
        outputFormat: org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat
        serDeInfo:
          name: my-stream
          serializationLibrary: org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe
          parameters:
            serialization.format: 1
        columns:
          - name: my_string
            type: string
          - name: my_double
            type: double
          - name: my_date
            type: date
            comment: ""
          - name: my_bigint
            type: bigint
            comment: ""
          - name: my_struct
            type: struct<my_nested_string:string>
            comment: ""

Import

Using pulumi import, import Glue Tables using the catalog ID (usually AWS account ID), database name, and table name. For example:

$ pulumi import aws:glue/catalogTable:CatalogTable MyTable 123456789012:MyDatabase:MyTable

Properties

arn

val arn: Output<String>

The ARN of the Glue Table.

catalogId

val catalogId: Output<String>

ID of the Glue Catalog and database to create the table in. If omitted, this defaults to the AWS Account ID plus the database name.

databaseName

val databaseName: Output<String>

Name of the metadata database where the table metadata resides. For Hive compatibility, this must be all lowercase. The follow arguments are optional:

description

val description: Output<String>?

Description of the table.

val id: Output<String>

name

val name: Output<String>

Name of the table. For Hive compatibility, this must be entirely lowercase.

openTableFormatInput

val openTableFormatInput: Output<CatalogTableOpenTableFormatInput>?

Configuration block for open table formats. See open_table_format_input below.

owner

val owner: Output<String>?

Owner of the table.

parameters

val parameters: Output<Map<String, String>>?

Properties associated with this table, as a list of key-value pairs.

partitionIndices

val partitionIndices: Output<List<CatalogTablePartitionIndex>>

Configuration block for a maximum of 3 partition indexes. See partition_index below.

partitionKeys

val partitionKeys: Output<List<CatalogTablePartitionKey>>?

Configuration block of columns by which the table is partitioned. Only primitive types are supported as partition keys. See partition_keys below.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

retention

val retention: Output<Int>?

Retention time for this table.

storageDescriptor

val storageDescriptor: Output<CatalogTableStorageDescriptor>?

Configuration block for information about the physical storage of this table. For more information, refer to the Glue Developer Guide. See storage_descriptor below.

tableType

val tableType: Output<String>?

Type of this table (EXTERNAL_TABLE, VIRTUAL_VIEW, etc.). While optional, some Athena DDL queries such as ALTER TABLE and SHOW CREATE TABLE will fail if this argument is empty.

targetTable

val targetTable: Output<CatalogTableTargetTable>?

Configuration block of a target table for resource linking. See target_table below.

urn

val urn: Output<String>

viewExpandedText

val viewExpandedText: Output<String>?

If the table is a view, the expanded text of the view; otherwise null.

viewOriginalText

val viewOriginalText: Output<String>?

If the table is a view, the original text of the view; otherwise null.