pulumi-snowflake 0.58.0a1726035035__py3-none-any.whl → 0.59.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_snowflake/_inputs.py +8587 -2022
- pulumi_snowflake/account.py +28 -50
- pulumi_snowflake/account_parameter.py +0 -28
- pulumi_snowflake/account_password_policy_attachment.py +2 -30
- pulumi_snowflake/account_role.py +41 -36
- pulumi_snowflake/alert.py +28 -40
- pulumi_snowflake/api_authentication_integration_with_authorization_code_grant.py +35 -15
- pulumi_snowflake/api_authentication_integration_with_client_credentials.py +35 -15
- pulumi_snowflake/api_authentication_integration_with_jwt_bearer.py +35 -15
- pulumi_snowflake/api_integration.py +28 -54
- pulumi_snowflake/cortex_search_service.py +28 -76
- pulumi_snowflake/database.py +82 -15
- pulumi_snowflake/database_old.py +0 -72
- pulumi_snowflake/database_role.py +76 -42
- pulumi_snowflake/dynamic_table.py +28 -38
- pulumi_snowflake/email_notification_integration.py +28 -26
- pulumi_snowflake/external_function.py +28 -52
- pulumi_snowflake/external_oauth_integration.py +35 -15
- pulumi_snowflake/external_table.py +28 -48
- pulumi_snowflake/failover_group.py +28 -72
- pulumi_snowflake/file_format.py +28 -26
- pulumi_snowflake/function.py +28 -4
- pulumi_snowflake/get_database_roles.py +63 -36
- pulumi_snowflake/get_masking_policies.py +73 -48
- pulumi_snowflake/get_resource_monitors.py +28 -16
- pulumi_snowflake/get_row_access_policies.py +73 -48
- pulumi_snowflake/get_users.py +96 -33
- pulumi_snowflake/get_views.py +94 -51
- pulumi_snowflake/grant_account_role.py +0 -4
- pulumi_snowflake/grant_application_role.py +0 -4
- pulumi_snowflake/grant_database_role.py +0 -4
- pulumi_snowflake/grant_privileges_to_account_role.py +4 -4
- pulumi_snowflake/grant_privileges_to_database_role.py +6 -2
- pulumi_snowflake/grant_privileges_to_share.py +49 -2
- pulumi_snowflake/managed_account.py +28 -4
- pulumi_snowflake/masking_policy.py +208 -306
- pulumi_snowflake/materialized_view.py +28 -34
- pulumi_snowflake/network_policy.py +35 -15
- pulumi_snowflake/network_policy_attachment.py +0 -30
- pulumi_snowflake/network_rule.py +28 -66
- pulumi_snowflake/notification_integration.py +28 -34
- pulumi_snowflake/oauth_integration.py +0 -34
- pulumi_snowflake/oauth_integration_for_custom_clients.py +35 -101
- pulumi_snowflake/oauth_integration_for_partner_applications.py +35 -15
- pulumi_snowflake/object_parameter.py +0 -98
- pulumi_snowflake/outputs.py +13035 -4202
- pulumi_snowflake/password_policy.py +28 -28
- pulumi_snowflake/pipe.py +28 -4
- pulumi_snowflake/procedure.py +28 -4
- pulumi_snowflake/pulumi-plugin.json +1 -1
- pulumi_snowflake/resource_monitor.py +111 -307
- pulumi_snowflake/role.py +41 -36
- pulumi_snowflake/row_access_policy.py +195 -147
- pulumi_snowflake/saml2_integration.py +35 -15
- pulumi_snowflake/saml_integration.py +0 -34
- pulumi_snowflake/schema.py +39 -19
- pulumi_snowflake/scim_integration.py +35 -15
- pulumi_snowflake/secondary_database.py +35 -19
- pulumi_snowflake/sequence.py +4 -36
- pulumi_snowflake/session_parameter.py +0 -32
- pulumi_snowflake/share.py +28 -28
- pulumi_snowflake/shared_database.py +35 -15
- pulumi_snowflake/stage.py +28 -28
- pulumi_snowflake/storage_integration.py +28 -4
- pulumi_snowflake/stream.py +28 -4
- pulumi_snowflake/streamlit.py +36 -16
- pulumi_snowflake/table.py +28 -32
- pulumi_snowflake/table_column_masking_policy_application.py +2 -14
- pulumi_snowflake/table_constraint.py +0 -152
- pulumi_snowflake/tag.py +28 -40
- pulumi_snowflake/tag_association.py +0 -120
- pulumi_snowflake/tag_masking_policy_association.py +0 -4
- pulumi_snowflake/task.py +28 -92
- pulumi_snowflake/unsafe_execute.py +2 -20
- pulumi_snowflake/user.py +3341 -368
- pulumi_snowflake/user_password_policy_attachment.py +0 -46
- pulumi_snowflake/view.py +465 -185
- pulumi_snowflake/warehouse.py +39 -43
- {pulumi_snowflake-0.58.0a1726035035.dist-info → pulumi_snowflake-0.59.0.dist-info}/METADATA +1 -1
- pulumi_snowflake-0.59.0.dist-info/RECORD +129 -0
- {pulumi_snowflake-0.58.0a1726035035.dist-info → pulumi_snowflake-0.59.0.dist-info}/WHEEL +1 -1
- pulumi_snowflake-0.58.0a1726035035.dist-info/RECORD +0 -129
- {pulumi_snowflake-0.58.0a1726035035.dist-info → pulumi_snowflake-0.59.0.dist-info}/top_level.txt +0 -0
|
@@ -16,74 +16,78 @@ __all__ = ['MaskingPolicyArgs', 'MaskingPolicy']
|
|
|
16
16
|
@pulumi.input_type
|
|
17
17
|
class MaskingPolicyArgs:
|
|
18
18
|
def __init__(__self__, *,
|
|
19
|
+
arguments: pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]],
|
|
20
|
+
body: pulumi.Input[str],
|
|
19
21
|
database: pulumi.Input[str],
|
|
20
|
-
masking_expression: pulumi.Input[str],
|
|
21
22
|
return_data_type: pulumi.Input[str],
|
|
22
23
|
schema: pulumi.Input[str],
|
|
23
|
-
signature: pulumi.Input['MaskingPolicySignatureArgs'],
|
|
24
24
|
comment: Optional[pulumi.Input[str]] = None,
|
|
25
|
-
exempt_other_policies: Optional[pulumi.Input[
|
|
26
|
-
|
|
27
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
or_replace: Optional[pulumi.Input[bool]] = None):
|
|
25
|
+
exempt_other_policies: Optional[pulumi.Input[str]] = None,
|
|
26
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
29
27
|
"""
|
|
30
28
|
The set of arguments for constructing a MaskingPolicy resource.
|
|
31
|
-
:param pulumi.Input[
|
|
32
|
-
:param pulumi.Input[str]
|
|
33
|
-
:param pulumi.Input[str]
|
|
34
|
-
:param pulumi.Input[str]
|
|
35
|
-
:param pulumi.Input[
|
|
29
|
+
:param pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]] arguments: List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
30
|
+
:param pulumi.Input[str] body: Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
31
|
+
:param pulumi.Input[str] database: The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
32
|
+
:param pulumi.Input[str] return_data_type: The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
33
|
+
:param pulumi.Input[str] schema: The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
36
34
|
:param pulumi.Input[str] comment: Specifies a comment for the masking policy.
|
|
37
|
-
:param pulumi.Input[
|
|
38
|
-
:param pulumi.Input[
|
|
39
|
-
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
|
|
40
|
-
:param pulumi.Input[bool] or_replace: Whether to override a previous masking policy with the same name.
|
|
35
|
+
:param pulumi.Input[str] exempt_other_policies: Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
36
|
+
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
41
37
|
"""
|
|
38
|
+
pulumi.set(__self__, "arguments", arguments)
|
|
39
|
+
pulumi.set(__self__, "body", body)
|
|
42
40
|
pulumi.set(__self__, "database", database)
|
|
43
|
-
pulumi.set(__self__, "masking_expression", masking_expression)
|
|
44
41
|
pulumi.set(__self__, "return_data_type", return_data_type)
|
|
45
42
|
pulumi.set(__self__, "schema", schema)
|
|
46
|
-
pulumi.set(__self__, "signature", signature)
|
|
47
43
|
if comment is not None:
|
|
48
44
|
pulumi.set(__self__, "comment", comment)
|
|
49
45
|
if exempt_other_policies is not None:
|
|
50
46
|
pulumi.set(__self__, "exempt_other_policies", exempt_other_policies)
|
|
51
|
-
if if_not_exists is not None:
|
|
52
|
-
pulumi.set(__self__, "if_not_exists", if_not_exists)
|
|
53
47
|
if name is not None:
|
|
54
48
|
pulumi.set(__self__, "name", name)
|
|
55
|
-
if or_replace is not None:
|
|
56
|
-
pulumi.set(__self__, "or_replace", or_replace)
|
|
57
49
|
|
|
58
50
|
@property
|
|
59
51
|
@pulumi.getter
|
|
60
|
-
def
|
|
52
|
+
def arguments(self) -> pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]:
|
|
61
53
|
"""
|
|
62
|
-
The
|
|
54
|
+
List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
63
55
|
"""
|
|
64
|
-
return pulumi.get(self, "
|
|
56
|
+
return pulumi.get(self, "arguments")
|
|
65
57
|
|
|
66
|
-
@
|
|
67
|
-
def
|
|
68
|
-
pulumi.set(self, "
|
|
58
|
+
@arguments.setter
|
|
59
|
+
def arguments(self, value: pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]):
|
|
60
|
+
pulumi.set(self, "arguments", value)
|
|
61
|
+
|
|
62
|
+
@property
|
|
63
|
+
@pulumi.getter
|
|
64
|
+
def body(self) -> pulumi.Input[str]:
|
|
65
|
+
"""
|
|
66
|
+
Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
67
|
+
"""
|
|
68
|
+
return pulumi.get(self, "body")
|
|
69
|
+
|
|
70
|
+
@body.setter
|
|
71
|
+
def body(self, value: pulumi.Input[str]):
|
|
72
|
+
pulumi.set(self, "body", value)
|
|
69
73
|
|
|
70
74
|
@property
|
|
71
|
-
@pulumi.getter
|
|
72
|
-
def
|
|
75
|
+
@pulumi.getter
|
|
76
|
+
def database(self) -> pulumi.Input[str]:
|
|
73
77
|
"""
|
|
74
|
-
|
|
78
|
+
The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
75
79
|
"""
|
|
76
|
-
return pulumi.get(self, "
|
|
80
|
+
return pulumi.get(self, "database")
|
|
77
81
|
|
|
78
|
-
@
|
|
79
|
-
def
|
|
80
|
-
pulumi.set(self, "
|
|
82
|
+
@database.setter
|
|
83
|
+
def database(self, value: pulumi.Input[str]):
|
|
84
|
+
pulumi.set(self, "database", value)
|
|
81
85
|
|
|
82
86
|
@property
|
|
83
87
|
@pulumi.getter(name="returnDataType")
|
|
84
88
|
def return_data_type(self) -> pulumi.Input[str]:
|
|
85
89
|
"""
|
|
86
|
-
|
|
90
|
+
The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
87
91
|
"""
|
|
88
92
|
return pulumi.get(self, "return_data_type")
|
|
89
93
|
|
|
@@ -95,7 +99,7 @@ class MaskingPolicyArgs:
|
|
|
95
99
|
@pulumi.getter
|
|
96
100
|
def schema(self) -> pulumi.Input[str]:
|
|
97
101
|
"""
|
|
98
|
-
The schema in which to create the masking policy.
|
|
102
|
+
The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
99
103
|
"""
|
|
100
104
|
return pulumi.get(self, "schema")
|
|
101
105
|
|
|
@@ -103,18 +107,6 @@ class MaskingPolicyArgs:
|
|
|
103
107
|
def schema(self, value: pulumi.Input[str]):
|
|
104
108
|
pulumi.set(self, "schema", value)
|
|
105
109
|
|
|
106
|
-
@property
|
|
107
|
-
@pulumi.getter
|
|
108
|
-
def signature(self) -> pulumi.Input['MaskingPolicySignatureArgs']:
|
|
109
|
-
"""
|
|
110
|
-
The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
|
|
111
|
-
"""
|
|
112
|
-
return pulumi.get(self, "signature")
|
|
113
|
-
|
|
114
|
-
@signature.setter
|
|
115
|
-
def signature(self, value: pulumi.Input['MaskingPolicySignatureArgs']):
|
|
116
|
-
pulumi.set(self, "signature", value)
|
|
117
|
-
|
|
118
110
|
@property
|
|
119
111
|
@pulumi.getter
|
|
120
112
|
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -129,33 +121,21 @@ class MaskingPolicyArgs:
|
|
|
129
121
|
|
|
130
122
|
@property
|
|
131
123
|
@pulumi.getter(name="exemptOtherPolicies")
|
|
132
|
-
def exempt_other_policies(self) -> Optional[pulumi.Input[
|
|
124
|
+
def exempt_other_policies(self) -> Optional[pulumi.Input[str]]:
|
|
133
125
|
"""
|
|
134
|
-
Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy.
|
|
126
|
+
Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
135
127
|
"""
|
|
136
128
|
return pulumi.get(self, "exempt_other_policies")
|
|
137
129
|
|
|
138
130
|
@exempt_other_policies.setter
|
|
139
|
-
def exempt_other_policies(self, value: Optional[pulumi.Input[
|
|
131
|
+
def exempt_other_policies(self, value: Optional[pulumi.Input[str]]):
|
|
140
132
|
pulumi.set(self, "exempt_other_policies", value)
|
|
141
133
|
|
|
142
|
-
@property
|
|
143
|
-
@pulumi.getter(name="ifNotExists")
|
|
144
|
-
def if_not_exists(self) -> Optional[pulumi.Input[bool]]:
|
|
145
|
-
"""
|
|
146
|
-
Prevent overwriting a previous masking policy with the same name.
|
|
147
|
-
"""
|
|
148
|
-
return pulumi.get(self, "if_not_exists")
|
|
149
|
-
|
|
150
|
-
@if_not_exists.setter
|
|
151
|
-
def if_not_exists(self, value: Optional[pulumi.Input[bool]]):
|
|
152
|
-
pulumi.set(self, "if_not_exists", value)
|
|
153
|
-
|
|
154
134
|
@property
|
|
155
135
|
@pulumi.getter
|
|
156
136
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
157
137
|
"""
|
|
158
|
-
Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
|
|
138
|
+
Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
159
139
|
"""
|
|
160
140
|
return pulumi.get(self, "name")
|
|
161
141
|
|
|
@@ -163,69 +143,81 @@ class MaskingPolicyArgs:
|
|
|
163
143
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
164
144
|
pulumi.set(self, "name", value)
|
|
165
145
|
|
|
166
|
-
@property
|
|
167
|
-
@pulumi.getter(name="orReplace")
|
|
168
|
-
def or_replace(self) -> Optional[pulumi.Input[bool]]:
|
|
169
|
-
"""
|
|
170
|
-
Whether to override a previous masking policy with the same name.
|
|
171
|
-
"""
|
|
172
|
-
return pulumi.get(self, "or_replace")
|
|
173
|
-
|
|
174
|
-
@or_replace.setter
|
|
175
|
-
def or_replace(self, value: Optional[pulumi.Input[bool]]):
|
|
176
|
-
pulumi.set(self, "or_replace", value)
|
|
177
|
-
|
|
178
146
|
|
|
179
147
|
@pulumi.input_type
|
|
180
148
|
class _MaskingPolicyState:
|
|
181
149
|
def __init__(__self__, *,
|
|
150
|
+
arguments: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]] = None,
|
|
151
|
+
body: Optional[pulumi.Input[str]] = None,
|
|
182
152
|
comment: Optional[pulumi.Input[str]] = None,
|
|
183
153
|
database: Optional[pulumi.Input[str]] = None,
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
154
|
+
describe_outputs: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]] = None,
|
|
155
|
+
exempt_other_policies: Optional[pulumi.Input[str]] = None,
|
|
156
|
+
fully_qualified_name: Optional[pulumi.Input[str]] = None,
|
|
187
157
|
name: Optional[pulumi.Input[str]] = None,
|
|
188
|
-
or_replace: Optional[pulumi.Input[bool]] = None,
|
|
189
|
-
qualified_name: Optional[pulumi.Input[str]] = None,
|
|
190
158
|
return_data_type: Optional[pulumi.Input[str]] = None,
|
|
191
159
|
schema: Optional[pulumi.Input[str]] = None,
|
|
192
|
-
|
|
160
|
+
show_outputs: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyShowOutputArgs']]]] = None):
|
|
193
161
|
"""
|
|
194
162
|
Input properties used for looking up and filtering MaskingPolicy resources.
|
|
163
|
+
:param pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]] arguments: List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
164
|
+
:param pulumi.Input[str] body: Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
195
165
|
:param pulumi.Input[str] comment: Specifies a comment for the masking policy.
|
|
196
|
-
:param pulumi.Input[str] database: The database in which to create the masking policy.
|
|
197
|
-
:param pulumi.Input[
|
|
198
|
-
:param pulumi.Input[
|
|
199
|
-
:param pulumi.Input[str]
|
|
200
|
-
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
|
|
201
|
-
:param pulumi.Input[
|
|
202
|
-
:param pulumi.Input[str]
|
|
203
|
-
:param pulumi.Input[
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
166
|
+
:param pulumi.Input[str] database: The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
167
|
+
:param pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]] describe_outputs: Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
|
|
168
|
+
:param pulumi.Input[str] exempt_other_policies: Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
169
|
+
:param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
170
|
+
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
171
|
+
:param pulumi.Input[str] return_data_type: The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
172
|
+
:param pulumi.Input[str] schema: The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
173
|
+
:param pulumi.Input[Sequence[pulumi.Input['MaskingPolicyShowOutputArgs']]] show_outputs: Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
|
|
174
|
+
"""
|
|
175
|
+
if arguments is not None:
|
|
176
|
+
pulumi.set(__self__, "arguments", arguments)
|
|
177
|
+
if body is not None:
|
|
178
|
+
pulumi.set(__self__, "body", body)
|
|
207
179
|
if comment is not None:
|
|
208
180
|
pulumi.set(__self__, "comment", comment)
|
|
209
181
|
if database is not None:
|
|
210
182
|
pulumi.set(__self__, "database", database)
|
|
183
|
+
if describe_outputs is not None:
|
|
184
|
+
pulumi.set(__self__, "describe_outputs", describe_outputs)
|
|
211
185
|
if exempt_other_policies is not None:
|
|
212
186
|
pulumi.set(__self__, "exempt_other_policies", exempt_other_policies)
|
|
213
|
-
if
|
|
214
|
-
pulumi.set(__self__, "
|
|
215
|
-
if masking_expression is not None:
|
|
216
|
-
pulumi.set(__self__, "masking_expression", masking_expression)
|
|
187
|
+
if fully_qualified_name is not None:
|
|
188
|
+
pulumi.set(__self__, "fully_qualified_name", fully_qualified_name)
|
|
217
189
|
if name is not None:
|
|
218
190
|
pulumi.set(__self__, "name", name)
|
|
219
|
-
if or_replace is not None:
|
|
220
|
-
pulumi.set(__self__, "or_replace", or_replace)
|
|
221
|
-
if qualified_name is not None:
|
|
222
|
-
pulumi.set(__self__, "qualified_name", qualified_name)
|
|
223
191
|
if return_data_type is not None:
|
|
224
192
|
pulumi.set(__self__, "return_data_type", return_data_type)
|
|
225
193
|
if schema is not None:
|
|
226
194
|
pulumi.set(__self__, "schema", schema)
|
|
227
|
-
if
|
|
228
|
-
pulumi.set(__self__, "
|
|
195
|
+
if show_outputs is not None:
|
|
196
|
+
pulumi.set(__self__, "show_outputs", show_outputs)
|
|
197
|
+
|
|
198
|
+
@property
|
|
199
|
+
@pulumi.getter
|
|
200
|
+
def arguments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]]:
|
|
201
|
+
"""
|
|
202
|
+
List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
203
|
+
"""
|
|
204
|
+
return pulumi.get(self, "arguments")
|
|
205
|
+
|
|
206
|
+
@arguments.setter
|
|
207
|
+
def arguments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]]):
|
|
208
|
+
pulumi.set(self, "arguments", value)
|
|
209
|
+
|
|
210
|
+
@property
|
|
211
|
+
@pulumi.getter
|
|
212
|
+
def body(self) -> Optional[pulumi.Input[str]]:
|
|
213
|
+
"""
|
|
214
|
+
Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
215
|
+
"""
|
|
216
|
+
return pulumi.get(self, "body")
|
|
217
|
+
|
|
218
|
+
@body.setter
|
|
219
|
+
def body(self, value: Optional[pulumi.Input[str]]):
|
|
220
|
+
pulumi.set(self, "body", value)
|
|
229
221
|
|
|
230
222
|
@property
|
|
231
223
|
@pulumi.getter
|
|
@@ -243,7 +235,7 @@ class _MaskingPolicyState:
|
|
|
243
235
|
@pulumi.getter
|
|
244
236
|
def database(self) -> Optional[pulumi.Input[str]]:
|
|
245
237
|
"""
|
|
246
|
-
The database in which to create the masking policy.
|
|
238
|
+
The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
247
239
|
"""
|
|
248
240
|
return pulumi.get(self, "database")
|
|
249
241
|
|
|
@@ -252,46 +244,46 @@ class _MaskingPolicyState:
|
|
|
252
244
|
pulumi.set(self, "database", value)
|
|
253
245
|
|
|
254
246
|
@property
|
|
255
|
-
@pulumi.getter(name="
|
|
256
|
-
def
|
|
247
|
+
@pulumi.getter(name="describeOutputs")
|
|
248
|
+
def describe_outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]]:
|
|
257
249
|
"""
|
|
258
|
-
|
|
250
|
+
Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
|
|
259
251
|
"""
|
|
260
|
-
return pulumi.get(self, "
|
|
252
|
+
return pulumi.get(self, "describe_outputs")
|
|
261
253
|
|
|
262
|
-
@
|
|
263
|
-
def
|
|
264
|
-
pulumi.set(self, "
|
|
254
|
+
@describe_outputs.setter
|
|
255
|
+
def describe_outputs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]]):
|
|
256
|
+
pulumi.set(self, "describe_outputs", value)
|
|
265
257
|
|
|
266
258
|
@property
|
|
267
|
-
@pulumi.getter(name="
|
|
268
|
-
def
|
|
259
|
+
@pulumi.getter(name="exemptOtherPolicies")
|
|
260
|
+
def exempt_other_policies(self) -> Optional[pulumi.Input[str]]:
|
|
269
261
|
"""
|
|
270
|
-
|
|
262
|
+
Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
271
263
|
"""
|
|
272
|
-
return pulumi.get(self, "
|
|
264
|
+
return pulumi.get(self, "exempt_other_policies")
|
|
273
265
|
|
|
274
|
-
@
|
|
275
|
-
def
|
|
276
|
-
pulumi.set(self, "
|
|
266
|
+
@exempt_other_policies.setter
|
|
267
|
+
def exempt_other_policies(self, value: Optional[pulumi.Input[str]]):
|
|
268
|
+
pulumi.set(self, "exempt_other_policies", value)
|
|
277
269
|
|
|
278
270
|
@property
|
|
279
|
-
@pulumi.getter(name="
|
|
280
|
-
def
|
|
271
|
+
@pulumi.getter(name="fullyQualifiedName")
|
|
272
|
+
def fully_qualified_name(self) -> Optional[pulumi.Input[str]]:
|
|
281
273
|
"""
|
|
282
|
-
|
|
274
|
+
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
283
275
|
"""
|
|
284
|
-
return pulumi.get(self, "
|
|
276
|
+
return pulumi.get(self, "fully_qualified_name")
|
|
285
277
|
|
|
286
|
-
@
|
|
287
|
-
def
|
|
288
|
-
pulumi.set(self, "
|
|
278
|
+
@fully_qualified_name.setter
|
|
279
|
+
def fully_qualified_name(self, value: Optional[pulumi.Input[str]]):
|
|
280
|
+
pulumi.set(self, "fully_qualified_name", value)
|
|
289
281
|
|
|
290
282
|
@property
|
|
291
283
|
@pulumi.getter
|
|
292
284
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
293
285
|
"""
|
|
294
|
-
Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
|
|
286
|
+
Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
295
287
|
"""
|
|
296
288
|
return pulumi.get(self, "name")
|
|
297
289
|
|
|
@@ -299,35 +291,11 @@ class _MaskingPolicyState:
|
|
|
299
291
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
300
292
|
pulumi.set(self, "name", value)
|
|
301
293
|
|
|
302
|
-
@property
|
|
303
|
-
@pulumi.getter(name="orReplace")
|
|
304
|
-
def or_replace(self) -> Optional[pulumi.Input[bool]]:
|
|
305
|
-
"""
|
|
306
|
-
Whether to override a previous masking policy with the same name.
|
|
307
|
-
"""
|
|
308
|
-
return pulumi.get(self, "or_replace")
|
|
309
|
-
|
|
310
|
-
@or_replace.setter
|
|
311
|
-
def or_replace(self, value: Optional[pulumi.Input[bool]]):
|
|
312
|
-
pulumi.set(self, "or_replace", value)
|
|
313
|
-
|
|
314
|
-
@property
|
|
315
|
-
@pulumi.getter(name="qualifiedName")
|
|
316
|
-
def qualified_name(self) -> Optional[pulumi.Input[str]]:
|
|
317
|
-
"""
|
|
318
|
-
Specifies the qualified identifier for the masking policy.
|
|
319
|
-
"""
|
|
320
|
-
return pulumi.get(self, "qualified_name")
|
|
321
|
-
|
|
322
|
-
@qualified_name.setter
|
|
323
|
-
def qualified_name(self, value: Optional[pulumi.Input[str]]):
|
|
324
|
-
pulumi.set(self, "qualified_name", value)
|
|
325
|
-
|
|
326
294
|
@property
|
|
327
295
|
@pulumi.getter(name="returnDataType")
|
|
328
296
|
def return_data_type(self) -> Optional[pulumi.Input[str]]:
|
|
329
297
|
"""
|
|
330
|
-
|
|
298
|
+
The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
331
299
|
"""
|
|
332
300
|
return pulumi.get(self, "return_data_type")
|
|
333
301
|
|
|
@@ -339,7 +307,7 @@ class _MaskingPolicyState:
|
|
|
339
307
|
@pulumi.getter
|
|
340
308
|
def schema(self) -> Optional[pulumi.Input[str]]:
|
|
341
309
|
"""
|
|
342
|
-
The schema in which to create the masking policy.
|
|
310
|
+
The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
343
311
|
"""
|
|
344
312
|
return pulumi.get(self, "schema")
|
|
345
313
|
|
|
@@ -348,16 +316,16 @@ class _MaskingPolicyState:
|
|
|
348
316
|
pulumi.set(self, "schema", value)
|
|
349
317
|
|
|
350
318
|
@property
|
|
351
|
-
@pulumi.getter
|
|
352
|
-
def
|
|
319
|
+
@pulumi.getter(name="showOutputs")
|
|
320
|
+
def show_outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyShowOutputArgs']]]]:
|
|
353
321
|
"""
|
|
354
|
-
|
|
322
|
+
Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
|
|
355
323
|
"""
|
|
356
|
-
return pulumi.get(self, "
|
|
324
|
+
return pulumi.get(self, "show_outputs")
|
|
357
325
|
|
|
358
|
-
@
|
|
359
|
-
def
|
|
360
|
-
pulumi.set(self, "
|
|
326
|
+
@show_outputs.setter
|
|
327
|
+
def show_outputs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyShowOutputArgs']]]]):
|
|
328
|
+
pulumi.set(self, "show_outputs", value)
|
|
361
329
|
|
|
362
330
|
|
|
363
331
|
class MaskingPolicy(pulumi.CustomResource):
|
|
@@ -365,66 +333,32 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
365
333
|
def __init__(__self__,
|
|
366
334
|
resource_name: str,
|
|
367
335
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
336
|
+
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyArgumentArgs', 'MaskingPolicyArgumentArgsDict']]]]] = None,
|
|
337
|
+
body: Optional[pulumi.Input[str]] = None,
|
|
368
338
|
comment: Optional[pulumi.Input[str]] = None,
|
|
369
339
|
database: Optional[pulumi.Input[str]] = None,
|
|
370
|
-
exempt_other_policies: Optional[pulumi.Input[
|
|
371
|
-
if_not_exists: Optional[pulumi.Input[bool]] = None,
|
|
372
|
-
masking_expression: Optional[pulumi.Input[str]] = None,
|
|
340
|
+
exempt_other_policies: Optional[pulumi.Input[str]] = None,
|
|
373
341
|
name: Optional[pulumi.Input[str]] = None,
|
|
374
|
-
or_replace: Optional[pulumi.Input[bool]] = None,
|
|
375
342
|
return_data_type: Optional[pulumi.Input[str]] = None,
|
|
376
343
|
schema: Optional[pulumi.Input[str]] = None,
|
|
377
|
-
signature: Optional[pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']]] = None,
|
|
378
344
|
__props__=None):
|
|
379
345
|
"""
|
|
380
|
-
## Example Usage
|
|
381
|
-
|
|
382
|
-
```python
|
|
383
|
-
import pulumi
|
|
384
|
-
import pulumi_snowflake as snowflake
|
|
385
|
-
|
|
386
|
-
test = snowflake.MaskingPolicy("test",
|
|
387
|
-
name="EXAMPLE_MASKING_POLICY",
|
|
388
|
-
database="EXAMPLE_DB",
|
|
389
|
-
schema="EXAMPLE_SCHEMA",
|
|
390
|
-
signature={
|
|
391
|
-
"columns": [{
|
|
392
|
-
"name": "val",
|
|
393
|
-
"type": "VARCHAR",
|
|
394
|
-
}],
|
|
395
|
-
},
|
|
396
|
-
masking_expression=\"\"\"case
|
|
397
|
-
when current_role() in ('ROLE_A') then
|
|
398
|
-
val
|
|
399
|
-
when is_role_in_session( 'ROLE_B' ) then
|
|
400
|
-
'ABC123'
|
|
401
|
-
else
|
|
402
|
-
'******'
|
|
403
|
-
end
|
|
404
|
-
\"\"\",
|
|
405
|
-
return_data_type="VARCHAR")
|
|
406
|
-
```
|
|
407
|
-
|
|
408
346
|
## Import
|
|
409
347
|
|
|
410
|
-
format is database name | schema name | policy name
|
|
411
|
-
|
|
412
348
|
```sh
|
|
413
|
-
$ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '
|
|
349
|
+
$ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '"<database_name>"."<schema_name>"."<masking_policy_name>"'
|
|
414
350
|
```
|
|
415
351
|
|
|
416
352
|
:param str resource_name: The name of the resource.
|
|
417
353
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
354
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyArgumentArgs', 'MaskingPolicyArgumentArgsDict']]]] arguments: List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
355
|
+
:param pulumi.Input[str] body: Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
418
356
|
:param pulumi.Input[str] comment: Specifies a comment for the masking policy.
|
|
419
|
-
:param pulumi.Input[str] database: The database in which to create the masking policy.
|
|
420
|
-
:param pulumi.Input[
|
|
421
|
-
:param pulumi.Input[
|
|
422
|
-
:param pulumi.Input[str]
|
|
423
|
-
:param pulumi.Input[str]
|
|
424
|
-
:param pulumi.Input[bool] or_replace: Whether to override a previous masking policy with the same name.
|
|
425
|
-
:param pulumi.Input[str] return_data_type: Specifies the data type to return.
|
|
426
|
-
:param pulumi.Input[str] schema: The schema in which to create the masking policy.
|
|
427
|
-
:param pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']] signature: The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
|
|
357
|
+
:param pulumi.Input[str] database: The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
358
|
+
:param pulumi.Input[str] exempt_other_policies: Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
359
|
+
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
360
|
+
:param pulumi.Input[str] return_data_type: The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
361
|
+
:param pulumi.Input[str] schema: The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
428
362
|
"""
|
|
429
363
|
...
|
|
430
364
|
@overload
|
|
@@ -433,40 +367,10 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
433
367
|
args: MaskingPolicyArgs,
|
|
434
368
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
435
369
|
"""
|
|
436
|
-
## Example Usage
|
|
437
|
-
|
|
438
|
-
```python
|
|
439
|
-
import pulumi
|
|
440
|
-
import pulumi_snowflake as snowflake
|
|
441
|
-
|
|
442
|
-
test = snowflake.MaskingPolicy("test",
|
|
443
|
-
name="EXAMPLE_MASKING_POLICY",
|
|
444
|
-
database="EXAMPLE_DB",
|
|
445
|
-
schema="EXAMPLE_SCHEMA",
|
|
446
|
-
signature={
|
|
447
|
-
"columns": [{
|
|
448
|
-
"name": "val",
|
|
449
|
-
"type": "VARCHAR",
|
|
450
|
-
}],
|
|
451
|
-
},
|
|
452
|
-
masking_expression=\"\"\"case
|
|
453
|
-
when current_role() in ('ROLE_A') then
|
|
454
|
-
val
|
|
455
|
-
when is_role_in_session( 'ROLE_B' ) then
|
|
456
|
-
'ABC123'
|
|
457
|
-
else
|
|
458
|
-
'******'
|
|
459
|
-
end
|
|
460
|
-
\"\"\",
|
|
461
|
-
return_data_type="VARCHAR")
|
|
462
|
-
```
|
|
463
|
-
|
|
464
370
|
## Import
|
|
465
371
|
|
|
466
|
-
format is database name | schema name | policy name
|
|
467
|
-
|
|
468
372
|
```sh
|
|
469
|
-
$ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '
|
|
373
|
+
$ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '"<database_name>"."<schema_name>"."<masking_policy_name>"'
|
|
470
374
|
```
|
|
471
375
|
|
|
472
376
|
:param str resource_name: The name of the resource.
|
|
@@ -484,16 +388,14 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
484
388
|
def _internal_init(__self__,
|
|
485
389
|
resource_name: str,
|
|
486
390
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
391
|
+
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyArgumentArgs', 'MaskingPolicyArgumentArgsDict']]]]] = None,
|
|
392
|
+
body: Optional[pulumi.Input[str]] = None,
|
|
487
393
|
comment: Optional[pulumi.Input[str]] = None,
|
|
488
394
|
database: Optional[pulumi.Input[str]] = None,
|
|
489
|
-
exempt_other_policies: Optional[pulumi.Input[
|
|
490
|
-
if_not_exists: Optional[pulumi.Input[bool]] = None,
|
|
491
|
-
masking_expression: Optional[pulumi.Input[str]] = None,
|
|
395
|
+
exempt_other_policies: Optional[pulumi.Input[str]] = None,
|
|
492
396
|
name: Optional[pulumi.Input[str]] = None,
|
|
493
|
-
or_replace: Optional[pulumi.Input[bool]] = None,
|
|
494
397
|
return_data_type: Optional[pulumi.Input[str]] = None,
|
|
495
398
|
schema: Optional[pulumi.Input[str]] = None,
|
|
496
|
-
signature: Optional[pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']]] = None,
|
|
497
399
|
__props__=None):
|
|
498
400
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
499
401
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -503,27 +405,27 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
503
405
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
504
406
|
__props__ = MaskingPolicyArgs.__new__(MaskingPolicyArgs)
|
|
505
407
|
|
|
408
|
+
if arguments is None and not opts.urn:
|
|
409
|
+
raise TypeError("Missing required property 'arguments'")
|
|
410
|
+
__props__.__dict__["arguments"] = arguments
|
|
411
|
+
if body is None and not opts.urn:
|
|
412
|
+
raise TypeError("Missing required property 'body'")
|
|
413
|
+
__props__.__dict__["body"] = body
|
|
506
414
|
__props__.__dict__["comment"] = comment
|
|
507
415
|
if database is None and not opts.urn:
|
|
508
416
|
raise TypeError("Missing required property 'database'")
|
|
509
417
|
__props__.__dict__["database"] = database
|
|
510
418
|
__props__.__dict__["exempt_other_policies"] = exempt_other_policies
|
|
511
|
-
__props__.__dict__["if_not_exists"] = if_not_exists
|
|
512
|
-
if masking_expression is None and not opts.urn:
|
|
513
|
-
raise TypeError("Missing required property 'masking_expression'")
|
|
514
|
-
__props__.__dict__["masking_expression"] = masking_expression
|
|
515
419
|
__props__.__dict__["name"] = name
|
|
516
|
-
__props__.__dict__["or_replace"] = or_replace
|
|
517
420
|
if return_data_type is None and not opts.urn:
|
|
518
421
|
raise TypeError("Missing required property 'return_data_type'")
|
|
519
422
|
__props__.__dict__["return_data_type"] = return_data_type
|
|
520
423
|
if schema is None and not opts.urn:
|
|
521
424
|
raise TypeError("Missing required property 'schema'")
|
|
522
425
|
__props__.__dict__["schema"] = schema
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
__props__.__dict__["
|
|
526
|
-
__props__.__dict__["qualified_name"] = None
|
|
426
|
+
__props__.__dict__["describe_outputs"] = None
|
|
427
|
+
__props__.__dict__["fully_qualified_name"] = None
|
|
428
|
+
__props__.__dict__["show_outputs"] = None
|
|
527
429
|
super(MaskingPolicy, __self__).__init__(
|
|
528
430
|
'snowflake:index/maskingPolicy:MaskingPolicy',
|
|
529
431
|
resource_name,
|
|
@@ -534,17 +436,17 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
534
436
|
def get(resource_name: str,
|
|
535
437
|
id: pulumi.Input[str],
|
|
536
438
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
439
|
+
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyArgumentArgs', 'MaskingPolicyArgumentArgsDict']]]]] = None,
|
|
440
|
+
body: Optional[pulumi.Input[str]] = None,
|
|
537
441
|
comment: Optional[pulumi.Input[str]] = None,
|
|
538
442
|
database: Optional[pulumi.Input[str]] = None,
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
443
|
+
describe_outputs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyDescribeOutputArgs', 'MaskingPolicyDescribeOutputArgsDict']]]]] = None,
|
|
444
|
+
exempt_other_policies: Optional[pulumi.Input[str]] = None,
|
|
445
|
+
fully_qualified_name: Optional[pulumi.Input[str]] = None,
|
|
542
446
|
name: Optional[pulumi.Input[str]] = None,
|
|
543
|
-
or_replace: Optional[pulumi.Input[bool]] = None,
|
|
544
|
-
qualified_name: Optional[pulumi.Input[str]] = None,
|
|
545
447
|
return_data_type: Optional[pulumi.Input[str]] = None,
|
|
546
448
|
schema: Optional[pulumi.Input[str]] = None,
|
|
547
|
-
|
|
449
|
+
show_outputs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyShowOutputArgs', 'MaskingPolicyShowOutputArgsDict']]]]] = None) -> 'MaskingPolicy':
|
|
548
450
|
"""
|
|
549
451
|
Get an existing MaskingPolicy resource's state with the given name, id, and optional extra
|
|
550
452
|
properties used to qualify the lookup.
|
|
@@ -552,104 +454,104 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
552
454
|
:param str resource_name: The unique name of the resulting resource.
|
|
553
455
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
554
456
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
457
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyArgumentArgs', 'MaskingPolicyArgumentArgsDict']]]] arguments: List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
458
|
+
:param pulumi.Input[str] body: Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
555
459
|
:param pulumi.Input[str] comment: Specifies a comment for the masking policy.
|
|
556
|
-
:param pulumi.Input[str] database: The database in which to create the masking policy.
|
|
557
|
-
:param pulumi.Input[
|
|
558
|
-
:param pulumi.Input[
|
|
559
|
-
:param pulumi.Input[str]
|
|
560
|
-
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
|
|
561
|
-
:param pulumi.Input[
|
|
562
|
-
:param pulumi.Input[str]
|
|
563
|
-
:param pulumi.Input[
|
|
564
|
-
:param pulumi.Input[str] schema: The schema in which to create the masking policy.
|
|
565
|
-
:param pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']] signature: The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
|
|
460
|
+
:param pulumi.Input[str] database: The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
461
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyDescribeOutputArgs', 'MaskingPolicyDescribeOutputArgsDict']]]] describe_outputs: Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
|
|
462
|
+
:param pulumi.Input[str] exempt_other_policies: Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
463
|
+
:param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
464
|
+
:param pulumi.Input[str] name: Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
465
|
+
:param pulumi.Input[str] return_data_type: The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
466
|
+
:param pulumi.Input[str] schema: The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
467
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyShowOutputArgs', 'MaskingPolicyShowOutputArgsDict']]]] show_outputs: Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
|
|
566
468
|
"""
|
|
567
469
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
568
470
|
|
|
569
471
|
__props__ = _MaskingPolicyState.__new__(_MaskingPolicyState)
|
|
570
472
|
|
|
473
|
+
__props__.__dict__["arguments"] = arguments
|
|
474
|
+
__props__.__dict__["body"] = body
|
|
571
475
|
__props__.__dict__["comment"] = comment
|
|
572
476
|
__props__.__dict__["database"] = database
|
|
477
|
+
__props__.__dict__["describe_outputs"] = describe_outputs
|
|
573
478
|
__props__.__dict__["exempt_other_policies"] = exempt_other_policies
|
|
574
|
-
__props__.__dict__["
|
|
575
|
-
__props__.__dict__["masking_expression"] = masking_expression
|
|
479
|
+
__props__.__dict__["fully_qualified_name"] = fully_qualified_name
|
|
576
480
|
__props__.__dict__["name"] = name
|
|
577
|
-
__props__.__dict__["or_replace"] = or_replace
|
|
578
|
-
__props__.__dict__["qualified_name"] = qualified_name
|
|
579
481
|
__props__.__dict__["return_data_type"] = return_data_type
|
|
580
482
|
__props__.__dict__["schema"] = schema
|
|
581
|
-
__props__.__dict__["
|
|
483
|
+
__props__.__dict__["show_outputs"] = show_outputs
|
|
582
484
|
return MaskingPolicy(resource_name, opts=opts, __props__=__props__)
|
|
583
485
|
|
|
584
486
|
@property
|
|
585
487
|
@pulumi.getter
|
|
586
|
-
def
|
|
488
|
+
def arguments(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyArgument']]:
|
|
587
489
|
"""
|
|
588
|
-
|
|
490
|
+
List of the arguments for the masking policy. The first column and its data type always indicate the column data type values to mask or tokenize in the subsequent policy conditions. Note that you can not specify a virtual column as the first column argument in a conditional masking policy.
|
|
589
491
|
"""
|
|
590
|
-
return pulumi.get(self, "
|
|
492
|
+
return pulumi.get(self, "arguments")
|
|
591
493
|
|
|
592
494
|
@property
|
|
593
495
|
@pulumi.getter
|
|
594
|
-
def
|
|
496
|
+
def body(self) -> pulumi.Output[str]:
|
|
595
497
|
"""
|
|
596
|
-
|
|
498
|
+
Specifies the SQL expression that transforms the data. To mitigate permadiff on this field, the provider replaces blank characters with a space. This can lead to false positives in cases where a change in case or run of whitespace is semantically significant.
|
|
597
499
|
"""
|
|
598
|
-
return pulumi.get(self, "
|
|
500
|
+
return pulumi.get(self, "body")
|
|
599
501
|
|
|
600
502
|
@property
|
|
601
|
-
@pulumi.getter
|
|
602
|
-
def
|
|
503
|
+
@pulumi.getter
|
|
504
|
+
def comment(self) -> pulumi.Output[Optional[str]]:
|
|
603
505
|
"""
|
|
604
|
-
Specifies
|
|
506
|
+
Specifies a comment for the masking policy.
|
|
605
507
|
"""
|
|
606
|
-
return pulumi.get(self, "
|
|
508
|
+
return pulumi.get(self, "comment")
|
|
607
509
|
|
|
608
510
|
@property
|
|
609
|
-
@pulumi.getter
|
|
610
|
-
def
|
|
511
|
+
@pulumi.getter
|
|
512
|
+
def database(self) -> pulumi.Output[str]:
|
|
611
513
|
"""
|
|
612
|
-
|
|
514
|
+
The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
613
515
|
"""
|
|
614
|
-
return pulumi.get(self, "
|
|
516
|
+
return pulumi.get(self, "database")
|
|
615
517
|
|
|
616
518
|
@property
|
|
617
|
-
@pulumi.getter(name="
|
|
618
|
-
def
|
|
519
|
+
@pulumi.getter(name="describeOutputs")
|
|
520
|
+
def describe_outputs(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyDescribeOutput']]:
|
|
619
521
|
"""
|
|
620
|
-
|
|
522
|
+
Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
|
|
621
523
|
"""
|
|
622
|
-
return pulumi.get(self, "
|
|
524
|
+
return pulumi.get(self, "describe_outputs")
|
|
623
525
|
|
|
624
526
|
@property
|
|
625
|
-
@pulumi.getter
|
|
626
|
-
def
|
|
527
|
+
@pulumi.getter(name="exemptOtherPolicies")
|
|
528
|
+
def exempt_other_policies(self) -> pulumi.Output[Optional[str]]:
|
|
627
529
|
"""
|
|
628
|
-
Specifies the
|
|
530
|
+
Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy. Due to Snowflake limitations, when value is chenged, the resource is recreated. Available options are: "true" or "false". When the value is not set in the configuration the provider will put "default" there which means to use the Snowflake default for this value.
|
|
629
531
|
"""
|
|
630
|
-
return pulumi.get(self, "
|
|
532
|
+
return pulumi.get(self, "exempt_other_policies")
|
|
631
533
|
|
|
632
534
|
@property
|
|
633
|
-
@pulumi.getter(name="
|
|
634
|
-
def
|
|
535
|
+
@pulumi.getter(name="fullyQualifiedName")
|
|
536
|
+
def fully_qualified_name(self) -> pulumi.Output[str]:
|
|
635
537
|
"""
|
|
636
|
-
|
|
538
|
+
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
637
539
|
"""
|
|
638
|
-
return pulumi.get(self, "
|
|
540
|
+
return pulumi.get(self, "fully_qualified_name")
|
|
639
541
|
|
|
640
542
|
@property
|
|
641
|
-
@pulumi.getter
|
|
642
|
-
def
|
|
543
|
+
@pulumi.getter
|
|
544
|
+
def name(self) -> pulumi.Output[str]:
|
|
643
545
|
"""
|
|
644
|
-
Specifies the
|
|
546
|
+
Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
645
547
|
"""
|
|
646
|
-
return pulumi.get(self, "
|
|
548
|
+
return pulumi.get(self, "name")
|
|
647
549
|
|
|
648
550
|
@property
|
|
649
551
|
@pulumi.getter(name="returnDataType")
|
|
650
552
|
def return_data_type(self) -> pulumi.Output[str]:
|
|
651
553
|
"""
|
|
652
|
-
|
|
554
|
+
The return data type must match the input data type of the first column that is specified as an input column. For more information about data types, check [Snowflake docs](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types).
|
|
653
555
|
"""
|
|
654
556
|
return pulumi.get(self, "return_data_type")
|
|
655
557
|
|
|
@@ -657,15 +559,15 @@ class MaskingPolicy(pulumi.CustomResource):
|
|
|
657
559
|
@pulumi.getter
|
|
658
560
|
def schema(self) -> pulumi.Output[str]:
|
|
659
561
|
"""
|
|
660
|
-
The schema in which to create the masking policy.
|
|
562
|
+
The schema in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
|
|
661
563
|
"""
|
|
662
564
|
return pulumi.get(self, "schema")
|
|
663
565
|
|
|
664
566
|
@property
|
|
665
|
-
@pulumi.getter
|
|
666
|
-
def
|
|
567
|
+
@pulumi.getter(name="showOutputs")
|
|
568
|
+
def show_outputs(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyShowOutput']]:
|
|
667
569
|
"""
|
|
668
|
-
|
|
570
|
+
Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
|
|
669
571
|
"""
|
|
670
|
-
return pulumi.get(self, "
|
|
572
|
+
return pulumi.get(self, "show_outputs")
|
|
671
573
|
|