oci.Database.getSystemVersions

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

const testSystemVersions = oci.Database.getSystemVersions({
    compartmentId: compartmentId,
    giVersion: systemVersionGiVersion,
    isLatest: systemVersionIsLatest,
    resourceId: testResource.id,
    shape: systemVersionShape,
});

import pulumi
import pulumi_oci as oci

test_system_versions = oci.Database.get_system_versions(compartment_id=compartment_id,
    gi_version=system_version_gi_version,
    is_latest=system_version_is_latest,
    resource_id=test_resource["id"],
    shape=system_version_shape)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := database.GetSystemVersions(ctx, &database.GetSystemVersionsArgs{
			CompartmentId: compartmentId,
			GiVersion:     systemVersionGiVersion,
			IsLatest:      pulumi.BoolRef(systemVersionIsLatest),
			ResourceId:    pulumi.StringRef(testResource.Id),
			Shape:         pulumi.StringRef(systemVersionShape),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testSystemVersions = Oci.Database.GetSystemVersions.Invoke(new()
    {
        CompartmentId = compartmentId,
        GiVersion = systemVersionGiVersion,
        IsLatest = systemVersionIsLatest,
        ResourceId = testResource.Id,
        Shape = systemVersionShape,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.Database.DatabaseFunctions;
import com.pulumi.oci.Database.inputs.GetSystemVersionsArgs;
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 testSystemVersions = DatabaseFunctions.getSystemVersions(GetSystemVersionsArgs.builder()
            .compartmentId(compartmentId)
            .giVersion(systemVersionGiVersion)
            .isLatest(systemVersionIsLatest)
            .resourceId(testResource.id())
            .shape(systemVersionShape)
            .build());

    }
}

variables:
  testSystemVersions:
    fn::invoke:
      function: oci:Database:getSystemVersions
      arguments:
        compartmentId: ${compartmentId}
        giVersion: ${systemVersionGiVersion}
        isLatest: ${systemVersionIsLatest}
        resourceId: ${testResource.id}
        shape: ${systemVersionShape}

function getSystemVersions(args: GetSystemVersionsArgs, opts?: InvokeOptions): Promise<GetSystemVersionsResult>
function getSystemVersionsOutput(args: GetSystemVersionsOutputArgs, opts?: InvokeOptions): Output<GetSystemVersionsResult>

def get_system_versions(compartment_id: Optional[str] = None,
                        filters: Optional[Sequence[GetSystemVersionsFilter]] = None,
                        gi_version: Optional[str] = None,
                        is_latest: Optional[bool] = None,
                        resource_id: Optional[str] = None,
                        shape: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetSystemVersionsResult
def get_system_versions_output(compartment_id: Optional[pulumi.Input[str]] = None,
                        filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetSystemVersionsFilterArgs]]]] = None,
                        gi_version: Optional[pulumi.Input[str]] = None,
                        is_latest: Optional[pulumi.Input[bool]] = None,
                        resource_id: Optional[pulumi.Input[str]] = None,
                        shape: Optional[pulumi.Input[str]] = None,
                        opts: Optional[InvokeOptions] = None) -> Output[GetSystemVersionsResult]

func GetSystemVersions(ctx *Context, args *GetSystemVersionsArgs, opts ...InvokeOption) (*GetSystemVersionsResult, error)
func GetSystemVersionsOutput(ctx *Context, args *GetSystemVersionsOutputArgs, opts ...InvokeOption) GetSystemVersionsResultOutput

public static class GetSystemVersions 
{
    public static Task<GetSystemVersionsResult> InvokeAsync(GetSystemVersionsArgs args, InvokeOptions? opts = null)
    public static Output<GetSystemVersionsResult> Invoke(GetSystemVersionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSystemVersionsResult> getSystemVersions(GetSystemVersionsArgs args, InvokeOptions options)
public static Output<GetSystemVersionsResult> getSystemVersions(GetSystemVersionsArgs args, InvokeOptions options)

fn::invoke:
  function: oci:Database/getSystemVersions:getSystemVersions
  arguments:
    # arguments dictionary