Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Oracle Cloud Infrastructure
  3. API Docs
  4. DataSafe
  5. SensitiveDataModelReferentialRelation
Oracle Cloud Infrastructure v2.33.0 published on Thursday, May 1, 2025 by Pulumi
pulumi/pulumi-oci

oci.DataSafe.SensitiveDataModelReferentialRelation

Explore with Pulumi AI

oci logo
Oracle Cloud Infrastructure v2.33.0 published on Thursday, May 1, 2025 by Pulumi
pulumi/pulumi-oci

    This resource provides the Sensitive Data Model Referential Relation resource in Oracle Cloud Infrastructure Data Safe service.

    Creates a new referential relation in the specified sensitive data model.

    Example Usage

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

const testSensitiveDataModelReferentialRelation = new oci.datasafe.SensitiveDataModelReferentialRelation("test_sensitive_data_model_referential_relation", {
    child: {
        appName: sensitiveDataModelReferentialRelationChildAppName,
        columnGroups: sensitiveDataModelReferentialRelationChildColumnGroup,
        object: sensitiveDataModelReferentialRelationChildObject,
        objectType: sensitiveDataModelReferentialRelationChildObjectType,
        schemaName: sensitiveDataModelReferentialRelationChildSchemaName,
        sensitiveTypeIds: sensitiveDataModelReferentialRelationChildSensitiveTypeIds,
    },
    parent: {
        appName: sensitiveDataModelReferentialRelationParentAppName,
        columnGroups: sensitiveDataModelReferentialRelationParentColumnGroup,
        object: sensitiveDataModelReferentialRelationParentObject,
        objectType: sensitiveDataModelReferentialRelationParentObjectType,
        schemaName: sensitiveDataModelReferentialRelationParentSchemaName,
        sensitiveTypeIds: sensitiveDataModelReferentialRelationParentSensitiveTypeIds,
    },
    relationType: sensitiveDataModelReferentialRelationRelationType,
    sensitiveDataModelId: testSensitiveDataModel.id,
    isSensitive: sensitiveDataModelReferentialRelationIsSensitive,
});

    import pulumi
import pulumi_oci as oci

test_sensitive_data_model_referential_relation = oci.data_safe.SensitiveDataModelReferentialRelation("test_sensitive_data_model_referential_relation",
    child={
        "app_name": sensitive_data_model_referential_relation_child_app_name,
        "column_groups": sensitive_data_model_referential_relation_child_column_group,
        "object": sensitive_data_model_referential_relation_child_object,
        "object_type": sensitive_data_model_referential_relation_child_object_type,
        "schema_name": sensitive_data_model_referential_relation_child_schema_name,
        "sensitive_type_ids": sensitive_data_model_referential_relation_child_sensitive_type_ids,
    },
    parent={
        "app_name": sensitive_data_model_referential_relation_parent_app_name,
        "column_groups": sensitive_data_model_referential_relation_parent_column_group,
        "object": sensitive_data_model_referential_relation_parent_object,
        "object_type": sensitive_data_model_referential_relation_parent_object_type,
        "schema_name": sensitive_data_model_referential_relation_parent_schema_name,
        "sensitive_type_ids": sensitive_data_model_referential_relation_parent_sensitive_type_ids,
    },
    relation_type=sensitive_data_model_referential_relation_relation_type,
    sensitive_data_model_id=test_sensitive_data_model["id"],
    is_sensitive=sensitive_data_model_referential_relation_is_sensitive)

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datasafe.NewSensitiveDataModelReferentialRelation(ctx, "test_sensitive_data_model_referential_relation", &datasafe.SensitiveDataModelReferentialRelationArgs{
			Child: &datasafe.SensitiveDataModelReferentialRelationChildArgs{
				AppName:          pulumi.Any(sensitiveDataModelReferentialRelationChildAppName),
				ColumnGroups:     pulumi.Any(sensitiveDataModelReferentialRelationChildColumnGroup),
				Object:           pulumi.Any(sensitiveDataModelReferentialRelationChildObject),
				ObjectType:       pulumi.Any(sensitiveDataModelReferentialRelationChildObjectType),
				SchemaName:       pulumi.Any(sensitiveDataModelReferentialRelationChildSchemaName),
				SensitiveTypeIds: pulumi.Any(sensitiveDataModelReferentialRelationChildSensitiveTypeIds),
			},
			Parent: &datasafe.SensitiveDataModelReferentialRelationParentArgs{
				AppName:          pulumi.Any(sensitiveDataModelReferentialRelationParentAppName),
				ColumnGroups:     pulumi.Any(sensitiveDataModelReferentialRelationParentColumnGroup),
				Object:           pulumi.Any(sensitiveDataModelReferentialRelationParentObject),
				ObjectType:       pulumi.Any(sensitiveDataModelReferentialRelationParentObjectType),
				SchemaName:       pulumi.Any(sensitiveDataModelReferentialRelationParentSchemaName),
				SensitiveTypeIds: pulumi.Any(sensitiveDataModelReferentialRelationParentSensitiveTypeIds),
			},
			RelationType:         pulumi.Any(sensitiveDataModelReferentialRelationRelationType),
			SensitiveDataModelId: pulumi.Any(testSensitiveDataModel.Id),
			IsSensitive:          pulumi.Any(sensitiveDataModelReferentialRelationIsSensitive),
		})
		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 testSensitiveDataModelReferentialRelation = new Oci.DataSafe.SensitiveDataModelReferentialRelation("test_sensitive_data_model_referential_relation", new()
    {
        Child = new Oci.DataSafe.Inputs.SensitiveDataModelReferentialRelationChildArgs
        {
            AppName = sensitiveDataModelReferentialRelationChildAppName,
            ColumnGroups = sensitiveDataModelReferentialRelationChildColumnGroup,
            Object = sensitiveDataModelReferentialRelationChildObject,
            ObjectType = sensitiveDataModelReferentialRelationChildObjectType,
            SchemaName = sensitiveDataModelReferentialRelationChildSchemaName,
            SensitiveTypeIds = sensitiveDataModelReferentialRelationChildSensitiveTypeIds,
        },
        Parent = new Oci.DataSafe.Inputs.SensitiveDataModelReferentialRelationParentArgs
        {
            AppName = sensitiveDataModelReferentialRelationParentAppName,
            ColumnGroups = sensitiveDataModelReferentialRelationParentColumnGroup,
            Object = sensitiveDataModelReferentialRelationParentObject,
            ObjectType = sensitiveDataModelReferentialRelationParentObjectType,
            SchemaName = sensitiveDataModelReferentialRelationParentSchemaName,
            SensitiveTypeIds = sensitiveDataModelReferentialRelationParentSensitiveTypeIds,
        },
        RelationType = sensitiveDataModelReferentialRelationRelationType,
        SensitiveDataModelId = testSensitiveDataModel.Id,
        IsSensitive = sensitiveDataModelReferentialRelationIsSensitive,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.DataSafe.SensitiveDataModelReferentialRelation;
import com.pulumi.oci.DataSafe.SensitiveDataModelReferentialRelationArgs;
import com.pulumi.oci.DataSafe.inputs.SensitiveDataModelReferentialRelationChildArgs;
import com.pulumi.oci.DataSafe.inputs.SensitiveDataModelReferentialRelationParentArgs;
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 testSensitiveDataModelReferentialRelation = new SensitiveDataModelReferentialRelation("testSensitiveDataModelReferentialRelation", SensitiveDataModelReferentialRelationArgs.builder()
            .child(SensitiveDataModelReferentialRelationChildArgs.builder()
                .appName(sensitiveDataModelReferentialRelationChildAppName)
                .columnGroups(sensitiveDataModelReferentialRelationChildColumnGroup)
                .object(sensitiveDataModelReferentialRelationChildObject)
                .objectType(sensitiveDataModelReferentialRelationChildObjectType)
                .schemaName(sensitiveDataModelReferentialRelationChildSchemaName)
                .sensitiveTypeIds(sensitiveDataModelReferentialRelationChildSensitiveTypeIds)
                .build())
            .parent(SensitiveDataModelReferentialRelationParentArgs.builder()
                .appName(sensitiveDataModelReferentialRelationParentAppName)
                .columnGroups(sensitiveDataModelReferentialRelationParentColumnGroup)
                .object(sensitiveDataModelReferentialRelationParentObject)
                .objectType(sensitiveDataModelReferentialRelationParentObjectType)
                .schemaName(sensitiveDataModelReferentialRelationParentSchemaName)
                .sensitiveTypeIds(sensitiveDataModelReferentialRelationParentSensitiveTypeIds)
                .build())
            .relationType(sensitiveDataModelReferentialRelationRelationType)
            .sensitiveDataModelId(testSensitiveDataModel.id())
            .isSensitive(sensitiveDataModelReferentialRelationIsSensitive)
            .build());

    }
}

    resources:
  testSensitiveDataModelReferentialRelation:
    type: oci:DataSafe:SensitiveDataModelReferentialRelation
    name: test_sensitive_data_model_referential_relation
    properties:
      child:
        appName: ${sensitiveDataModelReferentialRelationChildAppName}
        columnGroups: ${sensitiveDataModelReferentialRelationChildColumnGroup}
        object: ${sensitiveDataModelReferentialRelationChildObject}
        objectType: ${sensitiveDataModelReferentialRelationChildObjectType}
        schemaName: ${sensitiveDataModelReferentialRelationChildSchemaName}
        sensitiveTypeIds: ${sensitiveDataModelReferentialRelationChildSensitiveTypeIds}
      parent:
        appName: ${sensitiveDataModelReferentialRelationParentAppName}
        columnGroups: ${sensitiveDataModelReferentialRelationParentColumnGroup}
        object: ${sensitiveDataModelReferentialRelationParentObject}
        objectType: ${sensitiveDataModelReferentialRelationParentObjectType}
        schemaName: ${sensitiveDataModelReferentialRelationParentSchemaName}
        sensitiveTypeIds: ${sensitiveDataModelReferentialRelationParentSensitiveTypeIds}
      relationType: ${sensitiveDataModelReferentialRelationRelationType}
      sensitiveDataModelId: ${testSensitiveDataModel.id}
      isSensitive: ${sensitiveDataModelReferentialRelationIsSensitive}

    Create SensitiveDataModelReferentialRelation Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new SensitiveDataModelReferentialRelation(name: string, args: SensitiveDataModelReferentialRelationArgs, opts?: CustomResourceOptions);
    @overload
def SensitiveDataModelReferentialRelation(resource_name: str,
                                          args: SensitiveDataModelReferentialRelationArgs,
                                          opts: Optional[ResourceOptions] = None)

@overload
def SensitiveDataModelReferentialRelation(resource_name: str,
                                          opts: Optional[ResourceOptions] = None,
                                          child: Optional[SensitiveDataModelReferentialRelationChildArgs] = None,
                                          parent: Optional[SensitiveDataModelReferentialRelationParentArgs] = None,
                                          relation_type: Optional[str] = None,
                                          sensitive_data_model_id: Optional[str] = None,
                                          is_sensitive: Optional[bool] = None)
    func NewSensitiveDataModelReferentialRelation(ctx *Context, name string, args SensitiveDataModelReferentialRelationArgs, opts ...ResourceOption) (*SensitiveDataModelReferentialRelation, error)
    public SensitiveDataModelReferentialRelation(string name, SensitiveDataModelReferentialRelationArgs args, CustomResourceOptions? opts = null)
    public SensitiveDataModelReferentialRelation(String name, SensitiveDataModelReferentialRelationArgs args)
public SensitiveDataModelReferentialRelation(String name, SensitiveDataModelReferentialRelationArgs args, CustomResourceOptions options)

    type: oci:DataSafe:SensitiveDataModelReferentialRelation
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args SensitiveDataModelReferentialRelationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args SensitiveDataModelReferentialRelationArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args SensitiveDataModelReferentialRelationArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SensitiveDataModelReferentialRelationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SensitiveDataModelReferentialRelationArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var sensitiveDataModelReferentialRelationResource = new Oci.DataSafe.SensitiveDataModelReferentialRelation("sensitiveDataModelReferentialRelationResource", new()
{
    Child = new Oci.DataSafe.Inputs.SensitiveDataModelReferentialRelationChildArgs
    {
        AppName = "string",
        ColumnGroups = new[]
        {
            "string",
        },
        Object = "string",
        ObjectType = "string",
        SchemaName = "string",
        SensitiveTypeIds = new[]
        {
            "string",
        },
    },
    Parent = new Oci.DataSafe.Inputs.SensitiveDataModelReferentialRelationParentArgs
    {
        AppName = "string",
        ColumnGroups = new[]
        {
            "string",
        },
        Object = "string",
        ObjectType = "string",
        SchemaName = "string",
        SensitiveTypeIds = new[]
        {
            "string",
        },
    },
    RelationType = "string",
    SensitiveDataModelId = "string",
    IsSensitive = false,
});

    example, err := datasafe.NewSensitiveDataModelReferentialRelation(ctx, "sensitiveDataModelReferentialRelationResource", &datasafe.SensitiveDataModelReferentialRelationArgs{
	Child: &datasafe.SensitiveDataModelReferentialRelationChildArgs{
		AppName: pulumi.String("string"),
		ColumnGroups: pulumi.StringArray{
			pulumi.String("string"),
		},
		Object:     pulumi.String("string"),
		ObjectType: pulumi.String("string"),
		SchemaName: pulumi.String("string"),
		SensitiveTypeIds: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Parent: &datasafe.SensitiveDataModelReferentialRelationParentArgs{
		AppName: pulumi.String("string"),
		ColumnGroups: pulumi.StringArray{
			pulumi.String("string"),
		},
		Object:     pulumi.String("string"),
		ObjectType: pulumi.String("string"),
		SchemaName: pulumi.String("string"),
		SensitiveTypeIds: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	RelationType:         pulumi.String("string"),
	SensitiveDataModelId: pulumi.String("string"),
	IsSensitive:          pulumi.Bool(false),
})

    var sensitiveDataModelReferentialRelationResource = new SensitiveDataModelReferentialRelation("sensitiveDataModelReferentialRelationResource", SensitiveDataModelReferentialRelationArgs.builder()
    .child(SensitiveDataModelReferentialRelationChildArgs.builder()
        .appName("string")
        .columnGroups("string")
        .object("string")
        .objectType("string")
        .schemaName("string")
        .sensitiveTypeIds("string")
        .build())
    .parent(SensitiveDataModelReferentialRelationParentArgs.builder()
        .appName("string")
        .columnGroups("string")
        .object("string")
        .objectType("string")
        .schemaName("string")
        .sensitiveTypeIds("string")
        .build())
    .relationType("string")
    .sensitiveDataModelId("string")
    .isSensitive(false)
    .build());

    sensitive_data_model_referential_relation_resource = oci.data_safe.SensitiveDataModelReferentialRelation("sensitiveDataModelReferentialRelationResource",
    child={
        "app_name": "string",
        "column_groups": ["string"],
        "object": "string",
        "object_type": "string",
        "schema_name": "string",
        "sensitive_type_ids": ["string"],
    },
    parent={
        "app_name": "string",
        "column_groups": ["string"],
        "object": "string",
        "object_type": "string",
        "schema_name": "string",
        "sensitive_type_ids": ["string"],
    },
    relation_type="string",
    sensitive_data_model_id="string",
    is_sensitive=False)

    const sensitiveDataModelReferentialRelationResource = new oci.datasafe.SensitiveDataModelReferentialRelation("sensitiveDataModelReferentialRelationResource", {
    child: {
        appName: "string",
        columnGroups: ["string"],
        object: "string",
        objectType: "string",
        schemaName: "string",
        sensitiveTypeIds: ["string"],
    },
    parent: {
        appName: "string",
        columnGroups: ["string"],
        object: "string",
        objectType: "string",
        schemaName: "string",
        sensitiveTypeIds: ["string"],
    },
    relationType: "string",
    sensitiveDataModelId: "string",
    isSensitive: false,
});

    type: oci:DataSafe:SensitiveDataModelReferentialRelation
properties:
    child:
        appName: string
        columnGroups:
            - string
        object: string
        objectType: string
        schemaName: string
        sensitiveTypeIds:
            - string
    isSensitive: false
    parent:
        appName: string
        columnGroups:
            - string
        object: string
        objectType: string
        schemaName: string
        sensitiveTypeIds:
            - string
    relationType: string
    sensitiveDataModelId: string

    SensitiveDataModelReferentialRelation Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The SensitiveDataModelReferentialRelation resource accepts the following input properties:

    Child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    Parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    RelationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    SensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    IsSensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    Child SensitiveDataModelReferentialRelationChildArgs
    columnsInfo object has details of column group with schema details.
    Parent SensitiveDataModelReferentialRelationParentArgs
    columnsInfo object has details of column group with schema details.
    RelationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    SensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    IsSensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    relationType String
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId String

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    isSensitive Boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    relationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    isSensitive boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    child SensitiveDataModelReferentialRelationChildArgs
    columnsInfo object has details of column group with schema details.
    parent SensitiveDataModelReferentialRelationParentArgs
    columnsInfo object has details of column group with schema details.
    relation_type str
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitive_data_model_id str

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    is_sensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    child Property Map
    columnsInfo object has details of column group with schema details.
    parent Property Map
    columnsInfo object has details of column group with schema details.
    relationType String
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId String

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    isSensitive Boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the SensitiveDataModelReferentialRelation resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    State string
    The current state of the referential relation.
    Id string
    The provider-assigned unique ID for this managed resource.
    Key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    State string
    The current state of the referential relation.
    id String
    The provider-assigned unique ID for this managed resource.
    key String
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    state String
    The current state of the referential relation.
    id string
    The provider-assigned unique ID for this managed resource.
    key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    state string
    The current state of the referential relation.
    id str
    The provider-assigned unique ID for this managed resource.
    key str
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    state str
    The current state of the referential relation.
    id String
    The provider-assigned unique ID for this managed resource.
    key String
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    state String
    The current state of the referential relation.

    Look up Existing SensitiveDataModelReferentialRelation Resource

    Get an existing SensitiveDataModelReferentialRelation resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: SensitiveDataModelReferentialRelationState, opts?: CustomResourceOptions): SensitiveDataModelReferentialRelation
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        child: Optional[SensitiveDataModelReferentialRelationChildArgs] = None,
        is_sensitive: Optional[bool] = None,
        key: Optional[str] = None,
        parent: Optional[SensitiveDataModelReferentialRelationParentArgs] = None,
        relation_type: Optional[str] = None,
        sensitive_data_model_id: Optional[str] = None,
        state: Optional[str] = None) -> SensitiveDataModelReferentialRelation
    func GetSensitiveDataModelReferentialRelation(ctx *Context, name string, id IDInput, state *SensitiveDataModelReferentialRelationState, opts ...ResourceOption) (*SensitiveDataModelReferentialRelation, error)
    public static SensitiveDataModelReferentialRelation Get(string name, Input<string> id, SensitiveDataModelReferentialRelationState? state, CustomResourceOptions? opts = null)
    public static SensitiveDataModelReferentialRelation get(String name, Output<String> id, SensitiveDataModelReferentialRelationState state, CustomResourceOptions options)
    resources:  _:    type: oci:DataSafe:SensitiveDataModelReferentialRelation    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    IsSensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    Key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    Parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    RelationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    SensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    State string
    The current state of the referential relation.
    Child SensitiveDataModelReferentialRelationChildArgs
    columnsInfo object has details of column group with schema details.
    IsSensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    Key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    Parent SensitiveDataModelReferentialRelationParentArgs
    columnsInfo object has details of column group with schema details.
    RelationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    SensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    State string
    The current state of the referential relation.
    child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    isSensitive Boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    key String
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    relationType String
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId String

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    state String
    The current state of the referential relation.
    child SensitiveDataModelReferentialRelationChild
    columnsInfo object has details of column group with schema details.
    isSensitive boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    key string
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    parent SensitiveDataModelReferentialRelationParent
    columnsInfo object has details of column group with schema details.
    relationType string
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId string

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    state string
    The current state of the referential relation.
    child SensitiveDataModelReferentialRelationChildArgs
    columnsInfo object has details of column group with schema details.
    is_sensitive bool
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    key str
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    parent SensitiveDataModelReferentialRelationParentArgs
    columnsInfo object has details of column group with schema details.
    relation_type str
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitive_data_model_id str

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    state str
    The current state of the referential relation.
    child Property Map
    columnsInfo object has details of column group with schema details.
    isSensitive Boolean
    Add to sensitive data model if passed true. If false is passed, then the columns will not be added in the sensitive data model as sensitive columns and if sensitive type OCIDs are assigned to the columns, then the sensitive type OCIDs will not be retained.
    key String
    The unique key that identifies the referential relation. It's numeric and unique within a sensitive data model.
    parent Property Map
    columnsInfo object has details of column group with schema details.
    relationType String
    The type of referential relationship the sensitive column has with its parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
    sensitiveDataModelId String

    The OCID of the sensitive data model.

    ** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

    state String
    The current state of the referential relation.

    Supporting Types

    SensitiveDataModelReferentialRelationChild, SensitiveDataModelReferentialRelationChildArgs

    AppName string
    The application name.
    ColumnGroups List<string>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    Object string
    The database object that contains the columns.
    ObjectType string
    The type of the database object that contains the sensitive column.
    SchemaName string
    The schema name.
    SensitiveTypeIds List<string>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    AppName string
    The application name.
    ColumnGroups []string
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    Object string
    The database object that contains the columns.
    ObjectType string
    The type of the database object that contains the sensitive column.
    SchemaName string
    The schema name.
    SensitiveTypeIds []string
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName String
    The application name.
    columnGroups List<String>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object String
    The database object that contains the columns.
    objectType String
    The type of the database object that contains the sensitive column.
    schemaName String
    The schema name.
    sensitiveTypeIds List<String>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName string
    The application name.
    columnGroups string[]
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object string
    The database object that contains the columns.
    objectType string
    The type of the database object that contains the sensitive column.
    schemaName string
    The schema name.
    sensitiveTypeIds string[]
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    app_name str
    The application name.
    column_groups Sequence[str]
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object str
    The database object that contains the columns.
    object_type str
    The type of the database object that contains the sensitive column.
    schema_name str
    The schema name.
    sensitive_type_ids Sequence[str]
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName String
    The application name.
    columnGroups List<String>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object String
    The database object that contains the columns.
    objectType String
    The type of the database object that contains the sensitive column.
    schemaName String
    The schema name.
    sensitiveTypeIds List<String>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.

    SensitiveDataModelReferentialRelationParent, SensitiveDataModelReferentialRelationParentArgs

    AppName string
    The application name.
    ColumnGroups List<string>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    Object string
    The database object that contains the columns.
    ObjectType string
    The type of the database object that contains the sensitive column.
    SchemaName string
    The schema name.
    SensitiveTypeIds List<string>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    AppName string
    The application name.
    ColumnGroups []string
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    Object string
    The database object that contains the columns.
    ObjectType string
    The type of the database object that contains the sensitive column.
    SchemaName string
    The schema name.
    SensitiveTypeIds []string
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName String
    The application name.
    columnGroups List<String>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object String
    The database object that contains the columns.
    objectType String
    The type of the database object that contains the sensitive column.
    schemaName String
    The schema name.
    sensitiveTypeIds List<String>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName string
    The application name.
    columnGroups string[]
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object string
    The database object that contains the columns.
    objectType string
    The type of the database object that contains the sensitive column.
    schemaName string
    The schema name.
    sensitiveTypeIds string[]
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    app_name str
    The application name.
    column_groups Sequence[str]
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object str
    The database object that contains the columns.
    object_type str
    The type of the database object that contains the sensitive column.
    schema_name str
    The schema name.
    sensitive_type_ids Sequence[str]
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.
    appName String
    The application name.
    columnGroups List<String>
    Group of columns in referential relation. Order needs to be maintained in the elements of the parent/child array listing.
    object String
    The database object that contains the columns.
    objectType String
    The type of the database object that contains the sensitive column.
    schemaName String
    The schema name.
    sensitiveTypeIds List<String>
    Sensitive type ocids of each column groups. Order needs to be maintained with the parent column group. For the DB defined referential relations identified during SDM creation, we cannot add sensitive types. Instead use the sensitiveColumn POST API to mark the columns sensitive.

    Import

    SensitiveDataModelReferentialRelations can be imported using the id, e.g.

    $ pulumi import oci:DataSafe/sensitiveDataModelReferentialRelation:SensitiveDataModelReferentialRelation test_sensitive_data_model_referential_relation "sensitiveDataModels/{sensitiveDataModelId}/referentialRelations/{referentialRelationKey}"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    oci pulumi/pulumi-oci
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the oci Terraform Provider.
    oci logo
    Oracle Cloud Infrastructure v2.33.0 published on Thursday, May 1, 2025 by Pulumi
    pulumi/pulumi-oci