Docs Packages
  1. Packages
  2. Oracle Cloud Infrastructure
  3. API Docs
  4. DataSafe
  5. SensitiveDataModelsSensitiveColumn
Oracle Cloud Infrastructure v1.32.0 published on Thursday, Apr 18, 2024 by Pulumi
pulumi/pulumi-oci

oci.DataSafe.SensitiveDataModelsSensitiveColumn

Explore with Pulumi AI

oci logo
Oracle Cloud Infrastructure v1.32.0 published on Thursday, Apr 18, 2024 by Pulumi
pulumi/pulumi-oci

    This resource provides the Sensitive Data Models Sensitive Column resource in Oracle Cloud Infrastructure Data Safe service.

    Creates a new sensitive column in the specified sensitive data model.

    Example Usage

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

const testSensitiveDataModelsSensitiveColumn = new oci.datasafe.SensitiveDataModelsSensitiveColumn("testSensitiveDataModelsSensitiveColumn", {
    columnName: _var.sensitive_data_models_sensitive_column_column_name,
    object: _var.sensitive_data_models_sensitive_column_object,
    schemaName: _var.sensitive_data_models_sensitive_column_schema_name,
    sensitiveDataModelId: oci_data_safe_sensitive_data_model.test_sensitive_data_model.id,
    appDefinedChildColumnKeys: _var.sensitive_data_models_sensitive_column_app_defined_child_column_keys,
    appName: _var.sensitive_data_models_sensitive_column_app_name,
    dataType: _var.sensitive_data_models_sensitive_column_data_type,
    dbDefinedChildColumnKeys: _var.sensitive_data_models_sensitive_column_db_defined_child_column_keys,
    objectType: _var.sensitive_data_models_sensitive_column_object_type,
    parentColumnKeys: _var.sensitive_data_models_sensitive_column_parent_column_keys,
    relationType: _var.sensitive_data_models_sensitive_column_relation_type,
    sensitiveTypeId: oci_data_safe_sensitive_type.test_sensitive_type.id,
    status: _var.sensitive_data_models_sensitive_column_status,
});

    import pulumi
import pulumi_oci as oci

test_sensitive_data_models_sensitive_column = oci.data_safe.SensitiveDataModelsSensitiveColumn("testSensitiveDataModelsSensitiveColumn",
    column_name=var["sensitive_data_models_sensitive_column_column_name"],
    object=var["sensitive_data_models_sensitive_column_object"],
    schema_name=var["sensitive_data_models_sensitive_column_schema_name"],
    sensitive_data_model_id=oci_data_safe_sensitive_data_model["test_sensitive_data_model"]["id"],
    app_defined_child_column_keys=var["sensitive_data_models_sensitive_column_app_defined_child_column_keys"],
    app_name=var["sensitive_data_models_sensitive_column_app_name"],
    data_type=var["sensitive_data_models_sensitive_column_data_type"],
    db_defined_child_column_keys=var["sensitive_data_models_sensitive_column_db_defined_child_column_keys"],
    object_type=var["sensitive_data_models_sensitive_column_object_type"],
    parent_column_keys=var["sensitive_data_models_sensitive_column_parent_column_keys"],
    relation_type=var["sensitive_data_models_sensitive_column_relation_type"],
    sensitive_type_id=oci_data_safe_sensitive_type["test_sensitive_type"]["id"],
    status=var["sensitive_data_models_sensitive_column_status"])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := DataSafe.NewSensitiveDataModelsSensitiveColumn(ctx, "testSensitiveDataModelsSensitiveColumn", &DataSafe.SensitiveDataModelsSensitiveColumnArgs{
			ColumnName:                pulumi.Any(_var.Sensitive_data_models_sensitive_column_column_name),
			Object:                    pulumi.Any(_var.Sensitive_data_models_sensitive_column_object),
			SchemaName:                pulumi.Any(_var.Sensitive_data_models_sensitive_column_schema_name),
			SensitiveDataModelId:      pulumi.Any(oci_data_safe_sensitive_data_model.Test_sensitive_data_model.Id),
			AppDefinedChildColumnKeys: pulumi.Any(_var.Sensitive_data_models_sensitive_column_app_defined_child_column_keys),
			AppName:                   pulumi.Any(_var.Sensitive_data_models_sensitive_column_app_name),
			DataType:                  pulumi.Any(_var.Sensitive_data_models_sensitive_column_data_type),
			DbDefinedChildColumnKeys:  pulumi.Any(_var.Sensitive_data_models_sensitive_column_db_defined_child_column_keys),
			ObjectType:                pulumi.Any(_var.Sensitive_data_models_sensitive_column_object_type),
			ParentColumnKeys:          pulumi.Any(_var.Sensitive_data_models_sensitive_column_parent_column_keys),
			RelationType:              pulumi.Any(_var.Sensitive_data_models_sensitive_column_relation_type),
			SensitiveTypeId:           pulumi.Any(oci_data_safe_sensitive_type.Test_sensitive_type.Id),
			Status:                    pulumi.Any(_var.Sensitive_data_models_sensitive_column_status),
		})
		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 testSensitiveDataModelsSensitiveColumn = new Oci.DataSafe.SensitiveDataModelsSensitiveColumn("testSensitiveDataModelsSensitiveColumn", new()
    {
        ColumnName = @var.Sensitive_data_models_sensitive_column_column_name,
        Object = @var.Sensitive_data_models_sensitive_column_object,
        SchemaName = @var.Sensitive_data_models_sensitive_column_schema_name,
        SensitiveDataModelId = oci_data_safe_sensitive_data_model.Test_sensitive_data_model.Id,
        AppDefinedChildColumnKeys = @var.Sensitive_data_models_sensitive_column_app_defined_child_column_keys,
        AppName = @var.Sensitive_data_models_sensitive_column_app_name,
        DataType = @var.Sensitive_data_models_sensitive_column_data_type,
        DbDefinedChildColumnKeys = @var.Sensitive_data_models_sensitive_column_db_defined_child_column_keys,
        ObjectType = @var.Sensitive_data_models_sensitive_column_object_type,
        ParentColumnKeys = @var.Sensitive_data_models_sensitive_column_parent_column_keys,
        RelationType = @var.Sensitive_data_models_sensitive_column_relation_type,
        SensitiveTypeId = oci_data_safe_sensitive_type.Test_sensitive_type.Id,
        Status = @var.Sensitive_data_models_sensitive_column_status,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.DataSafe.SensitiveDataModelsSensitiveColumn;
import com.pulumi.oci.DataSafe.SensitiveDataModelsSensitiveColumnArgs;
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 testSensitiveDataModelsSensitiveColumn = new SensitiveDataModelsSensitiveColumn("testSensitiveDataModelsSensitiveColumn", SensitiveDataModelsSensitiveColumnArgs.builder()        
            .columnName(var_.sensitive_data_models_sensitive_column_column_name())
            .object(var_.sensitive_data_models_sensitive_column_object())
            .schemaName(var_.sensitive_data_models_sensitive_column_schema_name())
            .sensitiveDataModelId(oci_data_safe_sensitive_data_model.test_sensitive_data_model().id())
            .appDefinedChildColumnKeys(var_.sensitive_data_models_sensitive_column_app_defined_child_column_keys())
            .appName(var_.sensitive_data_models_sensitive_column_app_name())
            .dataType(var_.sensitive_data_models_sensitive_column_data_type())
            .dbDefinedChildColumnKeys(var_.sensitive_data_models_sensitive_column_db_defined_child_column_keys())
            .objectType(var_.sensitive_data_models_sensitive_column_object_type())
            .parentColumnKeys(var_.sensitive_data_models_sensitive_column_parent_column_keys())
            .relationType(var_.sensitive_data_models_sensitive_column_relation_type())
            .sensitiveTypeId(oci_data_safe_sensitive_type.test_sensitive_type().id())
            .status(var_.sensitive_data_models_sensitive_column_status())
            .build());

    }
}

    resources:
  testSensitiveDataModelsSensitiveColumn:
    type: oci:DataSafe:SensitiveDataModelsSensitiveColumn
    properties:
      #Required
      columnName: ${var.sensitive_data_models_sensitive_column_column_name}
      object: ${var.sensitive_data_models_sensitive_column_object}
      schemaName: ${var.sensitive_data_models_sensitive_column_schema_name}
      sensitiveDataModelId: ${oci_data_safe_sensitive_data_model.test_sensitive_data_model.id}
      #Optional
      appDefinedChildColumnKeys: ${var.sensitive_data_models_sensitive_column_app_defined_child_column_keys}
      appName: ${var.sensitive_data_models_sensitive_column_app_name}
      dataType: ${var.sensitive_data_models_sensitive_column_data_type}
      dbDefinedChildColumnKeys: ${var.sensitive_data_models_sensitive_column_db_defined_child_column_keys}
      objectType: ${var.sensitive_data_models_sensitive_column_object_type}
      parentColumnKeys: ${var.sensitive_data_models_sensitive_column_parent_column_keys}
      relationType: ${var.sensitive_data_models_sensitive_column_relation_type}
      sensitiveTypeId: ${oci_data_safe_sensitive_type.test_sensitive_type.id}
      status: ${var.sensitive_data_models_sensitive_column_status}

    Create SensitiveDataModelsSensitiveColumn Resource

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

    Constructor syntax

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

@overload
def SensitiveDataModelsSensitiveColumn(resource_name: str,
                                       opts: Optional[ResourceOptions] = None,
                                       object: Optional[str] = None,
                                       sensitive_data_model_id: Optional[str] = None,
                                       column_name: Optional[str] = None,
                                       schema_name: Optional[str] = None,
                                       data_type: Optional[str] = None,
                                       db_defined_child_column_keys: Optional[Sequence[str]] = None,
                                       object_type: Optional[str] = None,
                                       parent_column_keys: Optional[Sequence[str]] = None,
                                       relation_type: Optional[str] = None,
                                       app_defined_child_column_keys: Optional[Sequence[str]] = None,
                                       app_name: Optional[str] = None,
                                       sensitive_type_id: Optional[str] = None,
                                       status: Optional[str] = None)
    func NewSensitiveDataModelsSensitiveColumn(ctx *Context, name string, args SensitiveDataModelsSensitiveColumnArgs, opts ...ResourceOption) (*SensitiveDataModelsSensitiveColumn, error)
    public SensitiveDataModelsSensitiveColumn(string name, SensitiveDataModelsSensitiveColumnArgs args, CustomResourceOptions? opts = null)
    public SensitiveDataModelsSensitiveColumn(String name, SensitiveDataModelsSensitiveColumnArgs args)
public SensitiveDataModelsSensitiveColumn(String name, SensitiveDataModelsSensitiveColumnArgs args, CustomResourceOptions options)

    type: oci:DataSafe:SensitiveDataModelsSensitiveColumn
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 SensitiveDataModelsSensitiveColumnArgs
    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 SensitiveDataModelsSensitiveColumnArgs
    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 SensitiveDataModelsSensitiveColumnArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SensitiveDataModelsSensitiveColumnArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SensitiveDataModelsSensitiveColumnArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

    var sensitiveDataModelsSensitiveColumnResource = new Oci.DataSafe.SensitiveDataModelsSensitiveColumn("sensitiveDataModelsSensitiveColumnResource", new()
{
    Object = "string",
    SensitiveDataModelId = "string",
    ColumnName = "string",
    SchemaName = "string",
    DataType = "string",
    DbDefinedChildColumnKeys = new[]
    {
        "string",
    },
    ObjectType = "string",
    ParentColumnKeys = new[]
    {
        "string",
    },
    RelationType = "string",
    AppDefinedChildColumnKeys = new[]
    {
        "string",
    },
    AppName = "string",
    SensitiveTypeId = "string",
    Status = "string",
});

    example, err := DataSafe.NewSensitiveDataModelsSensitiveColumn(ctx, "sensitiveDataModelsSensitiveColumnResource", &DataSafe.SensitiveDataModelsSensitiveColumnArgs{
	Object:               pulumi.String("string"),
	SensitiveDataModelId: pulumi.String("string"),
	ColumnName:           pulumi.String("string"),
	SchemaName:           pulumi.String("string"),
	DataType:             pulumi.String("string"),
	DbDefinedChildColumnKeys: pulumi.StringArray{
		pulumi.String("string"),
	},
	ObjectType: pulumi.String("string"),
	ParentColumnKeys: pulumi.StringArray{
		pulumi.String("string"),
	},
	RelationType: pulumi.String("string"),
	AppDefinedChildColumnKeys: pulumi.StringArray{
		pulumi.String("string"),
	},
	AppName:         pulumi.String("string"),
	SensitiveTypeId: pulumi.String("string"),
	Status:          pulumi.String("string"),
})

    var sensitiveDataModelsSensitiveColumnResource = new SensitiveDataModelsSensitiveColumn("sensitiveDataModelsSensitiveColumnResource", SensitiveDataModelsSensitiveColumnArgs.builder()        
    .object("string")
    .sensitiveDataModelId("string")
    .columnName("string")
    .schemaName("string")
    .dataType("string")
    .dbDefinedChildColumnKeys("string")
    .objectType("string")
    .parentColumnKeys("string")
    .relationType("string")
    .appDefinedChildColumnKeys("string")
    .appName("string")
    .sensitiveTypeId("string")
    .status("string")
    .build());

    sensitive_data_models_sensitive_column_resource = oci.data_safe.SensitiveDataModelsSensitiveColumn("sensitiveDataModelsSensitiveColumnResource",
    object="string",
    sensitive_data_model_id="string",
    column_name="string",
    schema_name="string",
    data_type="string",
    db_defined_child_column_keys=["string"],
    object_type="string",
    parent_column_keys=["string"],
    relation_type="string",
    app_defined_child_column_keys=["string"],
    app_name="string",
    sensitive_type_id="string",
    status="string")

    const sensitiveDataModelsSensitiveColumnResource = new oci.datasafe.SensitiveDataModelsSensitiveColumn("sensitiveDataModelsSensitiveColumnResource", {
    object: "string",
    sensitiveDataModelId: "string",
    columnName: "string",
    schemaName: "string",
    dataType: "string",
    dbDefinedChildColumnKeys: ["string"],
    objectType: "string",
    parentColumnKeys: ["string"],
    relationType: "string",
    appDefinedChildColumnKeys: ["string"],
    appName: "string",
    sensitiveTypeId: "string",
    status: "string",
});

    type: oci:DataSafe:SensitiveDataModelsSensitiveColumn
properties:
    appDefinedChildColumnKeys:
        - string
    appName: string
    columnName: string
    dataType: string
    dbDefinedChildColumnKeys:
        - string
    object: string
    objectType: string
    parentColumnKeys:
        - string
    relationType: string
    schemaName: string
    sensitiveDataModelId: string
    sensitiveTypeId: string
    status: string

    SensitiveDataModelsSensitiveColumn Resource Properties

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

    Inputs

    The SensitiveDataModelsSensitiveColumn resource accepts the following input properties:

    ColumnName string
    The name of the sensitive column.
    Object string
    The database object that contains the sensitive column.
    SchemaName string
    The database schema that contains the sensitive column.
    SensitiveDataModelId string
    The OCID of the sensitive data model.
    AppDefinedChildColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    AppName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    DataType string
    (Updatable) The data type of the sensitive column.
    DbDefinedChildColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    ObjectType string
    The type of the database object that contains the sensitive column.
    ParentColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    RelationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    SensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    Status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    ColumnName string
    The name of the sensitive column.
    Object string
    The database object that contains the sensitive column.
    SchemaName string
    The database schema that contains the sensitive column.
    SensitiveDataModelId string
    The OCID of the sensitive data model.
    AppDefinedChildColumnKeys []string
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    AppName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    DataType string
    (Updatable) The data type of the sensitive column.
    DbDefinedChildColumnKeys []string
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    ObjectType string
    The type of the database object that contains the sensitive column.
    ParentColumnKeys []string
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    RelationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    SensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    Status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    columnName String
    The name of the sensitive column.
    object String
    The database object that contains the sensitive column.
    schemaName String
    The database schema that contains the sensitive column.
    sensitiveDataModelId String
    The OCID of the sensitive data model.
    appDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName String
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    dataType String
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    objectType String
    The type of the database object that contains the sensitive column.
    parentColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType String
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sensitiveTypeId String
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    status String

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    columnName string
    The name of the sensitive column.
    object string
    The database object that contains the sensitive column.
    schemaName string
    The database schema that contains the sensitive column.
    sensitiveDataModelId string
    The OCID of the sensitive data model.
    appDefinedChildColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    dataType string
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    objectType string
    The type of the database object that contains the sensitive column.
    parentColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    column_name str
    The name of the sensitive column.
    object str
    The database object that contains the sensitive column.
    schema_name str
    The database schema that contains the sensitive column.
    sensitive_data_model_id str
    The OCID of the sensitive data model.
    app_defined_child_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    app_name str
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    data_type str
    (Updatable) The data type of the sensitive column.
    db_defined_child_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    object_type str
    The type of the database object that contains the sensitive column.
    parent_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relation_type str
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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_type_id str
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    status str

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    columnName String
    The name of the sensitive column.
    object String
    The database object that contains the sensitive column.
    schemaName String
    The database schema that contains the sensitive column.
    sensitiveDataModelId String
    The OCID of the sensitive data model.
    appDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName String
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    dataType String
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    objectType String
    The type of the database object that contains the sensitive column.
    parentColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType String
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sensitiveTypeId String
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    status String

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    Outputs

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

    ColumnGroups List<string>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    EstimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    Id string
    The provider-assigned unique ID for this managed resource.
    Key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    LifecycleDetails string
    Details about the current state of the sensitive column.
    SampleDataValues List<string>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    Source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    State string
    The current state of the sensitive column.
    TimeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    TimeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    ColumnGroups []string
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    EstimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    Id string
    The provider-assigned unique ID for this managed resource.
    Key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    LifecycleDetails string
    Details about the current state of the sensitive column.
    SampleDataValues []string
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    Source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    State string
    The current state of the sensitive column.
    TimeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    TimeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    columnGroups List<String>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    estimatedDataValueCount String
    The estimated number of data values the column has in the associated database.
    id String
    The provider-assigned unique ID for this managed resource.
    key String
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails String
    Details about the current state of the sensitive column.
    sampleDataValues List<String>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    source String
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state String
    The current state of the sensitive column.
    timeCreated String
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated String
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    columnGroups string[]
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    estimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    id string
    The provider-assigned unique ID for this managed resource.
    key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails string
    Details about the current state of the sensitive column.
    sampleDataValues string[]
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state string
    The current state of the sensitive column.
    timeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    column_groups Sequence[str]
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    estimated_data_value_count str
    The estimated number of data values the column has in the associated database.
    id str
    The provider-assigned unique ID for this managed resource.
    key str
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycle_details str
    Details about the current state of the sensitive column.
    sample_data_values Sequence[str]
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    source str
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state str
    The current state of the sensitive column.
    time_created str
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    time_updated str
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    columnGroups List<String>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    estimatedDataValueCount String
    The estimated number of data values the column has in the associated database.
    id String
    The provider-assigned unique ID for this managed resource.
    key String
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails String
    Details about the current state of the sensitive column.
    sampleDataValues List<String>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    source String
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state String
    The current state of the sensitive column.
    timeCreated String
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated String
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.

    Look up Existing SensitiveDataModelsSensitiveColumn Resource

    Get an existing SensitiveDataModelsSensitiveColumn 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?: SensitiveDataModelsSensitiveColumnState, opts?: CustomResourceOptions): SensitiveDataModelsSensitiveColumn
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        app_defined_child_column_keys: Optional[Sequence[str]] = None,
        app_name: Optional[str] = None,
        column_groups: Optional[Sequence[str]] = None,
        column_name: Optional[str] = None,
        data_type: Optional[str] = None,
        db_defined_child_column_keys: Optional[Sequence[str]] = None,
        estimated_data_value_count: Optional[str] = None,
        key: Optional[str] = None,
        lifecycle_details: Optional[str] = None,
        object: Optional[str] = None,
        object_type: Optional[str] = None,
        parent_column_keys: Optional[Sequence[str]] = None,
        relation_type: Optional[str] = None,
        sample_data_values: Optional[Sequence[str]] = None,
        schema_name: Optional[str] = None,
        sensitive_data_model_id: Optional[str] = None,
        sensitive_type_id: Optional[str] = None,
        source: Optional[str] = None,
        state: Optional[str] = None,
        status: Optional[str] = None,
        time_created: Optional[str] = None,
        time_updated: Optional[str] = None) -> SensitiveDataModelsSensitiveColumn
    func GetSensitiveDataModelsSensitiveColumn(ctx *Context, name string, id IDInput, state *SensitiveDataModelsSensitiveColumnState, opts ...ResourceOption) (*SensitiveDataModelsSensitiveColumn, error)
    public static SensitiveDataModelsSensitiveColumn Get(string name, Input<string> id, SensitiveDataModelsSensitiveColumnState? state, CustomResourceOptions? opts = null)
    public static SensitiveDataModelsSensitiveColumn get(String name, Output<String> id, SensitiveDataModelsSensitiveColumnState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    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:
    AppDefinedChildColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    AppName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    ColumnGroups List<string>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    ColumnName string
    The name of the sensitive column.
    DataType string
    (Updatable) The data type of the sensitive column.
    DbDefinedChildColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    EstimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    Key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    LifecycleDetails string
    Details about the current state of the sensitive column.
    Object string
    The database object that contains the sensitive column.
    ObjectType string
    The type of the database object that contains the sensitive column.
    ParentColumnKeys List<string>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    RelationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    SampleDataValues List<string>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    SchemaName string
    The database schema that contains the sensitive column.
    SensitiveDataModelId string
    The OCID of the sensitive data model.
    SensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    Source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    State string
    The current state of the sensitive column.
    Status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    TimeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    TimeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    AppDefinedChildColumnKeys []string
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    AppName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    ColumnGroups []string
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    ColumnName string
    The name of the sensitive column.
    DataType string
    (Updatable) The data type of the sensitive column.
    DbDefinedChildColumnKeys []string
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    EstimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    Key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    LifecycleDetails string
    Details about the current state of the sensitive column.
    Object string
    The database object that contains the sensitive column.
    ObjectType string
    The type of the database object that contains the sensitive column.
    ParentColumnKeys []string
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    RelationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    SampleDataValues []string
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    SchemaName string
    The database schema that contains the sensitive column.
    SensitiveDataModelId string
    The OCID of the sensitive data model.
    SensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    Source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    State string
    The current state of the sensitive column.
    Status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    TimeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    TimeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    appDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName String
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    columnGroups List<String>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    columnName String
    The name of the sensitive column.
    dataType String
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    estimatedDataValueCount String
    The estimated number of data values the column has in the associated database.
    key String
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails String
    Details about the current state of the sensitive column.
    object String
    The database object that contains the sensitive column.
    objectType String
    The type of the database object that contains the sensitive column.
    parentColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType String
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sampleDataValues List<String>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    schemaName String
    The database schema that contains the sensitive column.
    sensitiveDataModelId String
    The OCID of the sensitive data model.
    sensitiveTypeId String
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    source String
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state String
    The current state of the sensitive column.
    status String

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    timeCreated String
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated String
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    appDefinedChildColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName string
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    columnGroups string[]
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    columnName string
    The name of the sensitive column.
    dataType string
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    estimatedDataValueCount string
    The estimated number of data values the column has in the associated database.
    key string
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails string
    Details about the current state of the sensitive column.
    object string
    The database object that contains the sensitive column.
    objectType string
    The type of the database object that contains the sensitive column.
    parentColumnKeys string[]
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType string
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sampleDataValues string[]
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    schemaName string
    The database schema that contains the sensitive column.
    sensitiveDataModelId string
    The OCID of the sensitive data model.
    sensitiveTypeId string
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    source string
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state string
    The current state of the sensitive column.
    status string

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    timeCreated string
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated string
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    app_defined_child_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    app_name str
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    column_groups Sequence[str]
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    column_name str
    The name of the sensitive column.
    data_type str
    (Updatable) The data type of the sensitive column.
    db_defined_child_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    estimated_data_value_count str
    The estimated number of data values the column has in the associated database.
    key str
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycle_details str
    Details about the current state of the sensitive column.
    object str
    The database object that contains the sensitive column.
    object_type str
    The type of the database object that contains the sensitive column.
    parent_column_keys Sequence[str]
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relation_type str
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sample_data_values Sequence[str]
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    schema_name str
    The database schema that contains the sensitive column.
    sensitive_data_model_id str
    The OCID of the sensitive data model.
    sensitive_type_id str
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    source str
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state str
    The current state of the sensitive column.
    status str

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    time_created str
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    time_updated str
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.
    appDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    appName String
    The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored. If this attribute is not provided, it's automatically populated with the value provided for the schemaName attribute.
    columnGroups List<String>
    The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
    columnName String
    The name of the sensitive column.
    dataType String
    (Updatable) The data type of the sensitive column.
    dbDefinedChildColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the child columns must be added to the sensitive data model before their keys can be specified here. If this attribute is provided, the parentColumnKeys and relationType attributes of the child columns are automatically updated to reflect the relationship.
    estimatedDataValueCount String
    The estimated number of data values the column has in the associated database.
    key String
    The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    lifecycleDetails String
    Details about the current state of the sensitive column.
    object String
    The database object that contains the sensitive column.
    objectType String
    The type of the database object that contains the sensitive column.
    parentColumnKeys List<String>
    (Updatable) Unique keys identifying the columns that are parents of the sensitive column. At present, it accepts only one parent column key. This attribute can be used to establish relationship between columns in a sensitive data model. Note that the parent column must be added to the sensitive data model before its key can be specified here. If this attribute is provided, the appDefinedChildColumnKeys or dbDefinedChildColumnKeys attribute of the parent column is automatically updated to reflect the relationship.
    relationType String
    (Updatable) The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a 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.
    sampleDataValues List<String>
    Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
    schemaName String
    The database schema that contains the sensitive column.
    sensitiveDataModelId String
    The OCID of the sensitive data model.
    sensitiveTypeId String
    (Updatable) The OCID of the sensitive type to be associated with the sensitive column.
    source String
    The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
    state String
    The current state of the sensitive column.
    status String

    (Updatable) The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive.

    ** 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

    timeCreated String
    The date and time, in the format defined by RFC3339, the sensitive column was created in the sensitive data model.
    timeUpdated String
    The date and time, in the format defined by RFC3339, the sensitive column was last updated in the sensitive data model.

    Import

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

    $ pulumi import oci:DataSafe/sensitiveDataModelsSensitiveColumn:SensitiveDataModelsSensitiveColumn test_sensitive_data_models_sensitive_column "sensitiveDataModels/{sensitiveDataModelId}/sensitiveColumns/{sensitiveColumnKey}"

    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 v1.32.0 published on Thursday, Apr 18, 2024 by Pulumi
    pulumi/pulumi-oci