databricks.getTables

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(async() => 
{
    var thingsTables = await Databricks.GetTables.InvokeAsync(new()
    {
        CatalogName = "sandbox",
        SchemaName = "things",
    });

    var thingsGrants = new List<Databricks.Grants>();
    foreach (var range in )
    {
        thingsGrants.Add(new Databricks.Grants($"thingsGrants-{range.Key}", new()
        {
            Table = range.Value,
            GrantDetails = new[]
            {
                new Databricks.Inputs.GrantsGrantArgs
                {
                    Principal = "sensitive",
                    Privileges = new[]
                    {
                        "SELECT",
                        "MODIFY",
                    },
                },
            },
        }));
    }
});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		thingsTables, err := databricks.GetTables(ctx, &databricks.GetTablesArgs{
			CatalogName: "sandbox",
			SchemaName:  "things",
		}, nil)
		if err != nil {
			return err
		}
		var thingsGrants []*databricks.Grants
		for key0, val0 := range thingsTables.Ids {
			__res, err := databricks.NewGrants(ctx, fmt.Sprintf("thingsGrants-%v", key0), &databricks.GrantsArgs{
				Table: pulumi.String(val0),
				Grants: databricks.GrantsGrantArray{
					&databricks.GrantsGrantArgs{
						Principal: pulumi.String("sensitive"),
						Privileges: pulumi.StringArray{
							pulumi.String("SELECT"),
							pulumi.String("MODIFY"),
						},
					},
				},
			})
			if err != nil {
				return err
			}
			thingsGrants = append(thingsGrants, __res)
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.DatabricksFunctions;
import com.pulumi.databricks.inputs.GetTablesArgs;
import com.pulumi.databricks.Grants;
import com.pulumi.databricks.GrantsArgs;
import com.pulumi.databricks.inputs.GrantsGrantArgs;
import com.pulumi.codegen.internal.KeyedValue;
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) {
        final var thingsTables = DatabricksFunctions.getTables(GetTablesArgs.builder()
            .catalogName("sandbox")
            .schemaName("things")
            .build());

        final var thingsGrants = thingsTables.applyValue(getTablesResult -> {
            final var resources = new ArrayList<Grants>();
            for (var range : KeyedValue.of(getTablesResult.ids()) {
                var resource = new Grants("thingsGrants-" + range.key(), GrantsArgs.builder()                
                    .table(range.value())
                    .grants(GrantsGrantArgs.builder()
                        .principal("sensitive")
                        .privileges(                        
                            "SELECT",
                            "MODIFY")
                        .build())
                    .build());

                resources.add(resource);
            }

            return resources;
        });

    }
}

import pulumi
import pulumi_databricks as databricks

things_tables = databricks.get_tables(catalog_name="sandbox",
    schema_name="things")
things_grants = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(things_tables.ids)]:
    things_grants.append(databricks.Grants(f"thingsGrants-{range['key']}",
        table=range["value"],
        grants=[databricks.GrantsGrantArgs(
            principal="sensitive",
            privileges=[
                "SELECT",
                "MODIFY",
            ],
        )]))

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

export = async () => {
    const thingsTables = await databricks.getTables({
        catalogName: "sandbox",
        schemaName: "things",
    });
    const thingsGrants: databricks.Grants[] = [];
    for (const range of thingsTables.ids.map((v, k) => ({key: k, value: v}))) {
        thingsGrants.push(new databricks.Grants(`thingsGrants-${range.key}`, {
            table: range.value,
            grants: [{
                principal: "sensitive",
                privileges: [
                    "SELECT",
                    "MODIFY",
                ],
            }],
        }));
    }
}

resources:
  thingsGrants:
    type: databricks:Grants
    properties:
      table: ${range.value}
      grants:
        - principal: sensitive
          privileges:
            - SELECT
            - MODIFY
    options: {}
variables:
  thingsTables:
    fn::invoke:
      Function: databricks:getTables
      Arguments:
        catalogName: sandbox
        schemaName: things