aws.athena.PreparedStatement

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

const test = new aws.s3.BucketV2("test", {
    bucket: "tf-test",
    forceDestroy: true,
});
const testWorkgroup = new aws.athena.Workgroup("test", {name: "tf-test"});
const testDatabase = new aws.athena.Database("test", {
    name: "example",
    bucket: test.bucket,
});
const testPreparedStatement = new aws.athena.PreparedStatement("test", {
    name: "tf_test",
    queryStatement: pulumi.interpolate`SELECT * FROM ${testDatabase.name} WHERE x = ?`,
    workgroup: testWorkgroup.name,
});

import pulumi
import pulumi_aws as aws

test = aws.s3.BucketV2("test",
    bucket="tf-test",
    force_destroy=True)
test_workgroup = aws.athena.Workgroup("test", name="tf-test")
test_database = aws.athena.Database("test",
    name="example",
    bucket=test.bucket)
test_prepared_statement = aws.athena.PreparedStatement("test",
    name="tf_test",
    query_statement=test_database.name.apply(lambda name: f"SELECT * FROM {name} WHERE x = ?"),
    workgroup=test_workgroup.name)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/athena"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := s3.NewBucketV2(ctx, "test", &s3.BucketV2Args{
			Bucket:       pulumi.String("tf-test"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		testWorkgroup, err := athena.NewWorkgroup(ctx, "test", &athena.WorkgroupArgs{
			Name: pulumi.String("tf-test"),
		})
		if err != nil {
			return err
		}
		testDatabase, err := athena.NewDatabase(ctx, "test", &athena.DatabaseArgs{
			Name:   pulumi.String("example"),
			Bucket: test.Bucket,
		})
		if err != nil {
			return err
		}
		_, err = athena.NewPreparedStatement(ctx, "test", &athena.PreparedStatementArgs{
			Name: pulumi.String("tf_test"),
			QueryStatement: testDatabase.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("SELECT * FROM %v WHERE x = ?", name), nil
			}).(pulumi.StringOutput),
			Workgroup: testWorkgroup.Name,
		})
		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 test = new Aws.S3.BucketV2("test", new()
    {
        Bucket = "tf-test",
        ForceDestroy = true,
    });

    var testWorkgroup = new Aws.Athena.Workgroup("test", new()
    {
        Name = "tf-test",
    });

    var testDatabase = new Aws.Athena.Database("test", new()
    {
        Name = "example",
        Bucket = test.Bucket,
    });

    var testPreparedStatement = new Aws.Athena.PreparedStatement("test", new()
    {
        Name = "tf_test",
        QueryStatement = testDatabase.Name.Apply(name => $"SELECT * FROM {name} WHERE x = ?"),
        Workgroup = testWorkgroup.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketV2Args;
import com.pulumi.aws.athena.Workgroup;
import com.pulumi.aws.athena.WorkgroupArgs;
import com.pulumi.aws.athena.Database;
import com.pulumi.aws.athena.DatabaseArgs;
import com.pulumi.aws.athena.PreparedStatement;
import com.pulumi.aws.athena.PreparedStatementArgs;
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 test = new BucketV2("test", BucketV2Args.builder()
            .bucket("tf-test")
            .forceDestroy(true)
            .build());

        var testWorkgroup = new Workgroup("testWorkgroup", WorkgroupArgs.builder()
            .name("tf-test")
            .build());

        var testDatabase = new Database("testDatabase", DatabaseArgs.builder()
            .name("example")
            .bucket(test.bucket())
            .build());

        var testPreparedStatement = new PreparedStatement("testPreparedStatement", PreparedStatementArgs.builder()
            .name("tf_test")
            .queryStatement(testDatabase.name().applyValue(name -> String.format("SELECT * FROM %s WHERE x = ?", name)))
            .workgroup(testWorkgroup.name())
            .build());

    }
}

resources:
  test:
    type: aws:s3:BucketV2
    properties:
      bucket: tf-test
      forceDestroy: true
  testWorkgroup:
    type: aws:athena:Workgroup
    name: test
    properties:
      name: tf-test
  testDatabase:
    type: aws:athena:Database
    name: test
    properties:
      name: example
      bucket: ${test.bucket}
  testPreparedStatement:
    type: aws:athena:PreparedStatement
    name: test
    properties:
      name: tf_test
      queryStatement: SELECT * FROM ${testDatabase.name} WHERE x = ?
      workgroup: ${testWorkgroup.name}

var preparedStatementResource = new Aws.Athena.PreparedStatement("preparedStatementResource", new()
{
    QueryStatement = "string",
    Workgroup = "string",
    Description = "string",
    Name = "string",
});

example, err := athena.NewPreparedStatement(ctx, "preparedStatementResource", &athena.PreparedStatementArgs{
	QueryStatement: pulumi.String("string"),
	Workgroup:      pulumi.String("string"),
	Description:    pulumi.String("string"),
	Name:           pulumi.String("string"),
})

var preparedStatementResource = new PreparedStatement("preparedStatementResource", PreparedStatementArgs.builder()
    .queryStatement("string")
    .workgroup("string")
    .description("string")
    .name("string")
    .build());

prepared_statement_resource = aws.athena.PreparedStatement("preparedStatementResource",
    query_statement="string",
    workgroup="string",
    description="string",
    name="string")

const preparedStatementResource = new aws.athena.PreparedStatement("preparedStatementResource", {
    queryStatement: "string",
    workgroup: "string",
    description: "string",
    name: "string",
});

type: aws:athena:PreparedStatement
properties:
    description: string
    name: string
    queryStatement: string
    workgroup: string