databricks.getPipelines

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

const all = databricks.getPipelines({});
export const allPipelines = all.then(all => all.ids);

import pulumi
import pulumi_databricks as databricks

all = databricks.get_pipelines()
pulumi.export("allPipelines", all.ids)

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 {
		all, err := databricks.GetPipelines(ctx, &databricks.GetPipelinesArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("allPipelines", all.Ids)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = Databricks.GetPipelines.Invoke();

    return new Dictionary<string, object?>
    {
        ["allPipelines"] = all.Apply(getPipelinesResult => getPipelinesResult.Ids),
    };
});

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.GetPipelinesArgs;
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 all = DatabricksFunctions.getPipelines();

        ctx.export("allPipelines", all.applyValue(getPipelinesResult -> getPipelinesResult.ids()));
    }
}

variables:
  all:
    fn::invoke:
      Function: databricks:getPipelines
      Arguments: {}
outputs:
  allPipelines: ${all.ids}

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

const this = databricks.getPipelines({
    pipelineName: "my_pipeline",
});
export const myPipeline = _this.then(_this => _this.ids);

import pulumi
import pulumi_databricks as databricks

this = databricks.get_pipelines(pipeline_name="my_pipeline")
pulumi.export("myPipeline", this.ids)

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 {
		this, err := databricks.GetPipelines(ctx, &databricks.GetPipelinesArgs{
			PipelineName: pulumi.StringRef("my_pipeline"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("myPipeline", this.Ids)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @this = Databricks.GetPipelines.Invoke(new()
    {
        PipelineName = "my_pipeline",
    });

    return new Dictionary<string, object?>
    {
        ["myPipeline"] = @this.Apply(@this => @this.Apply(getPipelinesResult => getPipelinesResult.Ids)),
    };
});

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.GetPipelinesArgs;
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 this = DatabricksFunctions.getPipelines(GetPipelinesArgs.builder()
            .pipelineName("my_pipeline")
            .build());

        ctx.export("myPipeline", this_.ids());
    }
}

variables:
  this:
    fn::invoke:
      Function: databricks:getPipelines
      Arguments:
        pipelineName: my_pipeline
outputs:
  myPipeline: ${this.ids}

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

const this = databricks.getPipelines({
    pipelineName: "%pipeline%",
});
export const wildcardPipelines = _this.then(_this => _this.ids);

import pulumi
import pulumi_databricks as databricks

this = databricks.get_pipelines(pipeline_name="%pipeline%")
pulumi.export("wildcardPipelines", this.ids)

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 {
		this, err := databricks.GetPipelines(ctx, &databricks.GetPipelinesArgs{
			PipelineName: pulumi.StringRef("%pipeline%"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("wildcardPipelines", this.Ids)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @this = Databricks.GetPipelines.Invoke(new()
    {
        PipelineName = "%pipeline%",
    });

    return new Dictionary<string, object?>
    {
        ["wildcardPipelines"] = @this.Apply(@this => @this.Apply(getPipelinesResult => getPipelinesResult.Ids)),
    };
});

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.GetPipelinesArgs;
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 this = DatabricksFunctions.getPipelines(GetPipelinesArgs.builder()
            .pipelineName("%pipeline%")
            .build());

        ctx.export("wildcardPipelines", this_.ids());
    }
}

variables:
  this:
    fn::invoke:
      Function: databricks:getPipelines
      Arguments:
        pipelineName: '%pipeline%'
outputs:
  wildcardPipelines: ${this.ids}

function getPipelines(args: GetPipelinesArgs, opts?: InvokeOptions): Promise<GetPipelinesResult>
function getPipelinesOutput(args: GetPipelinesOutputArgs, opts?: InvokeOptions): Output<GetPipelinesResult>

def get_pipelines(ids: Optional[Sequence[str]] = None,
                  pipeline_name: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetPipelinesResult
def get_pipelines_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  pipeline_name: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetPipelinesResult]

func GetPipelines(ctx *Context, args *GetPipelinesArgs, opts ...InvokeOption) (*GetPipelinesResult, error)
func GetPipelinesOutput(ctx *Context, args *GetPipelinesOutputArgs, opts ...InvokeOption) GetPipelinesResultOutput

public static class GetPipelines 
{
    public static Task<GetPipelinesResult> InvokeAsync(GetPipelinesArgs args, InvokeOptions? opts = null)
    public static Output<GetPipelinesResult> Invoke(GetPipelinesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPipelinesResult> getPipelines(GetPipelinesArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: databricks:index/getPipelines:getPipelines
  arguments:
    # arguments dictionary