postgresql.Schema

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

const appWww = new postgresql.Role("app_www", {name: "app_www"});
const appDba = new postgresql.Role("app_dba", {name: "app_dba"});
const appReleng = new postgresql.Role("app_releng", {name: "app_releng"});
const mySchema = new postgresql.Schema("my_schema", {
    name: "my_schema",
    owner: "postgres",
    policies: [
        {
            usage: true,
            role: appWww.name,
        },
        {
            create: true,
            usage: true,
            role: appReleng.name,
        },
        {
            createWithGrant: true,
            usageWithGrant: true,
            role: appDba.name,
        },
    ],
});

import pulumi
import pulumi_postgresql as postgresql

app_www = postgresql.Role("app_www", name="app_www")
app_dba = postgresql.Role("app_dba", name="app_dba")
app_releng = postgresql.Role("app_releng", name="app_releng")
my_schema = postgresql.Schema("my_schema",
    name="my_schema",
    owner="postgres",
    policies=[
        {
            "usage": True,
            "role": app_www.name,
        },
        {
            "create": True,
            "usage": True,
            "role": app_releng.name,
        },
        {
            "create_with_grant": True,
            "usage_with_grant": True,
            "role": app_dba.name,
        },
    ])

package main

import (
	"github.com/pulumi/pulumi-postgresql/sdk/v3/go/postgresql"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		appWww, err := postgresql.NewRole(ctx, "app_www", &postgresql.RoleArgs{
			Name: pulumi.String("app_www"),
		})
		if err != nil {
			return err
		}
		appDba, err := postgresql.NewRole(ctx, "app_dba", &postgresql.RoleArgs{
			Name: pulumi.String("app_dba"),
		})
		if err != nil {
			return err
		}
		appReleng, err := postgresql.NewRole(ctx, "app_releng", &postgresql.RoleArgs{
			Name: pulumi.String("app_releng"),
		})
		if err != nil {
			return err
		}
		_, err = postgresql.NewSchema(ctx, "my_schema", &postgresql.SchemaArgs{
			Name:  pulumi.String("my_schema"),
			Owner: pulumi.String("postgres"),
			Policies: postgresql.SchemaPolicyArray{
				&postgresql.SchemaPolicyArgs{
					Usage: pulumi.Bool(true),
					Role:  appWww.Name,
				},
				&postgresql.SchemaPolicyArgs{
					Create: pulumi.Bool(true),
					Usage:  pulumi.Bool(true),
					Role:   appReleng.Name,
				},
				&postgresql.SchemaPolicyArgs{
					CreateWithGrant: pulumi.Bool(true),
					UsageWithGrant:  pulumi.Bool(true),
					Role:            appDba.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var appWww = new PostgreSql.Index.Role("app_www", new()
    {
        Name = "app_www",
    });

    var appDba = new PostgreSql.Index.Role("app_dba", new()
    {
        Name = "app_dba",
    });

    var appReleng = new PostgreSql.Index.Role("app_releng", new()
    {
        Name = "app_releng",
    });

    var mySchema = new PostgreSql.Index.Schema("my_schema", new()
    {
        Name = "my_schema",
        Owner = "postgres",
        Policies = new[]
        {
            new PostgreSql.Inputs.SchemaPolicyArgs
            {
                Usage = true,
                Role = appWww.Name,
            },
            new PostgreSql.Inputs.SchemaPolicyArgs
            {
                Create = true,
                Usage = true,
                Role = appReleng.Name,
            },
            new PostgreSql.Inputs.SchemaPolicyArgs
            {
                CreateWithGrant = true,
                UsageWithGrant = true,
                Role = appDba.Name,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.postgresql.Role;
import com.pulumi.postgresql.RoleArgs;
import com.pulumi.postgresql.Schema;
import com.pulumi.postgresql.SchemaArgs;
import com.pulumi.postgresql.inputs.SchemaPolicyArgs;
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 appWww = new Role("appWww", RoleArgs.builder()
            .name("app_www")
            .build());

        var appDba = new Role("appDba", RoleArgs.builder()
            .name("app_dba")
            .build());

        var appReleng = new Role("appReleng", RoleArgs.builder()
            .name("app_releng")
            .build());

        var mySchema = new Schema("mySchema", SchemaArgs.builder()
            .name("my_schema")
            .owner("postgres")
            .policies(            
                SchemaPolicyArgs.builder()
                    .usage(true)
                    .role(appWww.name())
                    .build(),
                SchemaPolicyArgs.builder()
                    .create(true)
                    .usage(true)
                    .role(appReleng.name())
                    .build(),
                SchemaPolicyArgs.builder()
                    .createWithGrant(true)
                    .usageWithGrant(true)
                    .role(appDba.name())
                    .build())
            .build());

    }
}

resources:
  appWww:
    type: postgresql:Role
    name: app_www
    properties:
      name: app_www
  appDba:
    type: postgresql:Role
    name: app_dba
    properties:
      name: app_dba
  appReleng:
    type: postgresql:Role
    name: app_releng
    properties:
      name: app_releng
  mySchema:
    type: postgresql:Schema
    name: my_schema
    properties:
      name: my_schema
      owner: postgres
      policies:
        - usage: true
          role: ${appWww.name}
        - create: true
          usage: true
          role: ${appReleng.name}
        - createWithGrant: true
          usageWithGrant: true
          role: ${appDba.name}

var schemaResource = new PostgreSql.Schema("schemaResource", new()
{
    Database = "string",
    DropCascade = false,
    IfNotExists = false,
    Name = "string",
    Owner = "string",
});

example, err := postgresql.NewSchema(ctx, "schemaResource", &postgresql.SchemaArgs{
	Database:    pulumi.String("string"),
	DropCascade: pulumi.Bool(false),
	IfNotExists: pulumi.Bool(false),
	Name:        pulumi.String("string"),
	Owner:       pulumi.String("string"),
})

var schemaResource = new Schema("schemaResource", SchemaArgs.builder()
    .database("string")
    .dropCascade(false)
    .ifNotExists(false)
    .name("string")
    .owner("string")
    .build());

schema_resource = postgresql.Schema("schemaResource",
    database="string",
    drop_cascade=False,
    if_not_exists=False,
    name="string",
    owner="string")

const schemaResource = new postgresql.Schema("schemaResource", {
    database: "string",
    dropCascade: false,
    ifNotExists: false,
    name: "string",
    owner: "string",
});

type: postgresql:Schema
properties:
    database: string
    dropCascade: false
    ifNotExists: false
    name: string
    owner: string