pulumi-snowflake 0.59.0a1726827563__py3-none-any.whl → 0.59.0a1726831379__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.

Potentially problematic release.

This version of pulumi-snowflake might be problematic. Click here for more details.

Files changed (17) hide show
  1. pulumi_snowflake/_inputs.py +859 -26
  2. pulumi_snowflake/get_database_roles.py +4 -0
  3. pulumi_snowflake/get_masking_policies.py +73 -48
  4. pulumi_snowflake/get_resource_monitors.py +28 -16
  5. pulumi_snowflake/get_row_access_policies.py +73 -48
  6. pulumi_snowflake/get_views.py +4 -0
  7. pulumi_snowflake/masking_policy.py +192 -234
  8. pulumi_snowflake/outputs.py +1101 -74
  9. pulumi_snowflake/pulumi-plugin.json +1 -1
  10. pulumi_snowflake/resource_monitor.py +83 -259
  11. pulumi_snowflake/row_access_policy.py +168 -114
  12. pulumi_snowflake/view.py +7 -7
  13. pulumi_snowflake/warehouse.py +4 -4
  14. {pulumi_snowflake-0.59.0a1726827563.dist-info → pulumi_snowflake-0.59.0a1726831379.dist-info}/METADATA +1 -1
  15. {pulumi_snowflake-0.59.0a1726827563.dist-info → pulumi_snowflake-0.59.0a1726831379.dist-info}/RECORD +17 -17
  16. {pulumi_snowflake-0.59.0a1726827563.dist-info → pulumi_snowflake-0.59.0a1726831379.dist-info}/WHEEL +0 -0
  17. {pulumi_snowflake-0.59.0a1726827563.dist-info → pulumi_snowflake-0.59.0a1726831379.dist-info}/top_level.txt +0 -0
pulumi_snowflake/masking_policy.py CHANGED
@@ -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[bool]] = None,
26
- if_not_exists: Optional[pulumi.Input[bool]] = None,
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[str] database: The database in which to create the masking policy.
32
- :param pulumi.Input[str] masking_expression: Specifies the SQL expression that transforms the data.
33
- :param pulumi.Input[str] return_data_type: Specifies the data type to return.
34
- :param pulumi.Input[str] schema: The schema in which to create the masking policy.
35
- :param pulumi.Input['MaskingPolicySignatureArgs'] signature: The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
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[bool] 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.
38
- :param pulumi.Input[bool] if_not_exists: Prevent overwriting a previous masking policy with the same name.
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 database(self) -> pulumi.Input[str]:
52
+ def arguments(self) -> pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]:
61
53
  """
62
- The database in which to create the masking policy.
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, "database")
56
+ return pulumi.get(self, "arguments")
65
57
 
66
- @database.setter
67
- def database(self, value: pulumi.Input[str]):
68
- pulumi.set(self, "database", value)
58
+ @arguments.setter
59
+ def arguments(self, value: pulumi.Input[Sequence[pulumi.Input['MaskingPolicyArgumentArgs']]]):
60
+ pulumi.set(self, "arguments", value)
69
61
 
70
62
  @property
71
- @pulumi.getter(name="maskingExpression")
72
- def masking_expression(self) -> pulumi.Input[str]:
63
+ @pulumi.getter
64
+ def body(self) -> pulumi.Input[str]:
73
65
  """
74
- Specifies the SQL expression that transforms the data.
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.
75
67
  """
76
- return pulumi.get(self, "masking_expression")
68
+ return pulumi.get(self, "body")
77
69
 
78
- @masking_expression.setter
79
- def masking_expression(self, value: pulumi.Input[str]):
80
- pulumi.set(self, "masking_expression", value)
70
+ @body.setter
71
+ def body(self, value: pulumi.Input[str]):
72
+ pulumi.set(self, "body", value)
73
+
74
+ @property
75
+ @pulumi.getter
76
+ def database(self) -> pulumi.Input[str]:
77
+ """
78
+ The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
79
+ """
80
+ return pulumi.get(self, "database")
81
+
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
- Specifies the data type to return.
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[bool]]:
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[bool]]):
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
- exempt_other_policies: Optional[pulumi.Input[bool]] = None,
154
+ describe_outputs: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]] = None,
155
+ exempt_other_policies: Optional[pulumi.Input[str]] = None,
185
156
  fully_qualified_name: Optional[pulumi.Input[str]] = None,
186
- if_not_exists: Optional[pulumi.Input[bool]] = None,
187
- masking_expression: Optional[pulumi.Input[str]] = None,
188
157
  name: Optional[pulumi.Input[str]] = None,
189
- or_replace: Optional[pulumi.Input[bool]] = None,
190
158
  return_data_type: Optional[pulumi.Input[str]] = None,
191
159
  schema: Optional[pulumi.Input[str]] = None,
192
- signature: Optional[pulumi.Input['MaskingPolicySignatureArgs']] = None):
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[bool] 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.
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.
198
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).
199
- :param pulumi.Input[bool] if_not_exists: Prevent overwriting a previous masking policy with the same name.
200
- :param pulumi.Input[str] masking_expression: Specifies the SQL expression that transforms the data.
201
- :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.
202
- :param pulumi.Input[bool] or_replace: Whether to override a previous masking policy with the same name.
203
- :param pulumi.Input[str] return_data_type: Specifies the data type to return.
204
- :param pulumi.Input[str] schema: The schema in which to create the masking policy.
205
- :param pulumi.Input['MaskingPolicySignatureArgs'] signature: The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
206
- """
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
187
  if fully_qualified_name is not None:
214
188
  pulumi.set(__self__, "fully_qualified_name", fully_qualified_name)
215
- if if_not_exists is not None:
216
- pulumi.set(__self__, "if_not_exists", if_not_exists)
217
- if masking_expression is not None:
218
- pulumi.set(__self__, "masking_expression", masking_expression)
219
189
  if name is not None:
220
190
  pulumi.set(__self__, "name", name)
221
- if or_replace is not None:
222
- pulumi.set(__self__, "or_replace", or_replace)
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 signature is not None:
228
- pulumi.set(__self__, "signature", signature)
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
 
@@ -251,16 +243,28 @@ class _MaskingPolicyState:
251
243
  def database(self, value: Optional[pulumi.Input[str]]):
252
244
  pulumi.set(self, "database", value)
253
245
 
246
+ @property
247
+ @pulumi.getter(name="describeOutputs")
248
+ def describe_outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]]:
249
+ """
250
+ Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
251
+ """
252
+ return pulumi.get(self, "describe_outputs")
253
+
254
+ @describe_outputs.setter
255
+ def describe_outputs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyDescribeOutputArgs']]]]):
256
+ pulumi.set(self, "describe_outputs", value)
257
+
254
258
  @property
255
259
  @pulumi.getter(name="exemptOtherPolicies")
256
- def exempt_other_policies(self) -> Optional[pulumi.Input[bool]]:
260
+ def exempt_other_policies(self) -> Optional[pulumi.Input[str]]:
257
261
  """
258
- Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy.
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.
259
263
  """
260
264
  return pulumi.get(self, "exempt_other_policies")
261
265
 
262
266
  @exempt_other_policies.setter
263
- def exempt_other_policies(self, value: Optional[pulumi.Input[bool]]):
267
+ def exempt_other_policies(self, value: Optional[pulumi.Input[str]]):
264
268
  pulumi.set(self, "exempt_other_policies", value)
265
269
 
266
270
  @property
@@ -275,35 +279,11 @@ class _MaskingPolicyState:
275
279
  def fully_qualified_name(self, value: Optional[pulumi.Input[str]]):
276
280
  pulumi.set(self, "fully_qualified_name", value)
277
281
 
278
- @property
279
- @pulumi.getter(name="ifNotExists")
280
- def if_not_exists(self) -> Optional[pulumi.Input[bool]]:
281
- """
282
- Prevent overwriting a previous masking policy with the same name.
283
- """
284
- return pulumi.get(self, "if_not_exists")
285
-
286
- @if_not_exists.setter
287
- def if_not_exists(self, value: Optional[pulumi.Input[bool]]):
288
- pulumi.set(self, "if_not_exists", value)
289
-
290
- @property
291
- @pulumi.getter(name="maskingExpression")
292
- def masking_expression(self) -> Optional[pulumi.Input[str]]:
293
- """
294
- Specifies the SQL expression that transforms the data.
295
- """
296
- return pulumi.get(self, "masking_expression")
297
-
298
- @masking_expression.setter
299
- def masking_expression(self, value: Optional[pulumi.Input[str]]):
300
- pulumi.set(self, "masking_expression", value)
301
-
302
282
  @property
303
283
  @pulumi.getter
304
284
  def name(self) -> Optional[pulumi.Input[str]]:
305
285
  """
306
- 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: `|`, `.`, `(`, `)`, `"`
307
287
  """
308
288
  return pulumi.get(self, "name")
309
289
 
@@ -311,23 +291,11 @@ class _MaskingPolicyState:
311
291
  def name(self, value: Optional[pulumi.Input[str]]):
312
292
  pulumi.set(self, "name", value)
313
293
 
314
- @property
315
- @pulumi.getter(name="orReplace")
316
- def or_replace(self) -> Optional[pulumi.Input[bool]]:
317
- """
318
- Whether to override a previous masking policy with the same name.
319
- """
320
- return pulumi.get(self, "or_replace")
321
-
322
- @or_replace.setter
323
- def or_replace(self, value: Optional[pulumi.Input[bool]]):
324
- pulumi.set(self, "or_replace", 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
- Specifies the data type to return.
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 signature(self) -> Optional[pulumi.Input['MaskingPolicySignatureArgs']]:
319
+ @pulumi.getter(name="showOutputs")
320
+ def show_outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MaskingPolicyShowOutputArgs']]]]:
353
321
  """
354
- The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
322
+ Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
355
323
  """
356
- return pulumi.get(self, "signature")
324
+ return pulumi.get(self, "show_outputs")
357
325
 
358
- @signature.setter
359
- def signature(self, value: Optional[pulumi.Input['MaskingPolicySignatureArgs']]):
360
- pulumi.set(self, "signature", value)
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,38 +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[bool]] = None,
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
346
  ## Import
381
347
 
382
- format is database name | schema name | policy name
383
-
384
348
  ```sh
385
- $ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example 'dbName|schemaName|policyName'
349
+ $ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '"<database_name>"."<schema_name>"."<masking_policy_name>"'
386
350
  ```
387
351
 
388
352
  :param str resource_name: The name of the resource.
389
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.
390
356
  :param pulumi.Input[str] comment: Specifies a comment for the masking policy.
391
- :param pulumi.Input[str] database: The database in which to create the masking policy.
392
- :param pulumi.Input[bool] 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.
393
- :param pulumi.Input[bool] if_not_exists: Prevent overwriting a previous masking policy with the same name.
394
- :param pulumi.Input[str] masking_expression: Specifies the SQL expression that transforms the data.
395
- :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.
396
- :param pulumi.Input[bool] or_replace: Whether to override a previous masking policy with the same name.
397
- :param pulumi.Input[str] return_data_type: Specifies the data type to return.
398
- :param pulumi.Input[str] schema: The schema in which to create the masking policy.
399
- :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: `|`, `.`, `(`, `)`, `"`
400
362
  """
401
363
  ...
402
364
  @overload
@@ -407,10 +369,8 @@ class MaskingPolicy(pulumi.CustomResource):
407
369
  """
408
370
  ## Import
409
371
 
410
- format is database name | schema name | policy name
411
-
412
372
  ```sh
413
- $ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example 'dbName|schemaName|policyName'
373
+ $ pulumi import snowflake:index/maskingPolicy:MaskingPolicy example '"<database_name>"."<schema_name>"."<masking_policy_name>"'
414
374
  ```
415
375
 
416
376
  :param str resource_name: The name of the resource.
@@ -428,16 +388,14 @@ class MaskingPolicy(pulumi.CustomResource):
428
388
  def _internal_init(__self__,
429
389
  resource_name: str,
430
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,
431
393
  comment: Optional[pulumi.Input[str]] = None,
432
394
  database: Optional[pulumi.Input[str]] = None,
433
- exempt_other_policies: Optional[pulumi.Input[bool]] = None,
434
- if_not_exists: Optional[pulumi.Input[bool]] = None,
435
- masking_expression: Optional[pulumi.Input[str]] = None,
395
+ exempt_other_policies: Optional[pulumi.Input[str]] = None,
436
396
  name: Optional[pulumi.Input[str]] = None,
437
- or_replace: Optional[pulumi.Input[bool]] = None,
438
397
  return_data_type: Optional[pulumi.Input[str]] = None,
439
398
  schema: Optional[pulumi.Input[str]] = None,
440
- signature: Optional[pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']]] = None,
441
399
  __props__=None):
442
400
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
443
401
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -447,27 +405,27 @@ class MaskingPolicy(pulumi.CustomResource):
447
405
  raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
448
406
  __props__ = MaskingPolicyArgs.__new__(MaskingPolicyArgs)
449
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
450
414
  __props__.__dict__["comment"] = comment
451
415
  if database is None and not opts.urn:
452
416
  raise TypeError("Missing required property 'database'")
453
417
  __props__.__dict__["database"] = database
454
418
  __props__.__dict__["exempt_other_policies"] = exempt_other_policies
455
- __props__.__dict__["if_not_exists"] = if_not_exists
456
- if masking_expression is None and not opts.urn:
457
- raise TypeError("Missing required property 'masking_expression'")
458
- __props__.__dict__["masking_expression"] = masking_expression
459
419
  __props__.__dict__["name"] = name
460
- __props__.__dict__["or_replace"] = or_replace
461
420
  if return_data_type is None and not opts.urn:
462
421
  raise TypeError("Missing required property 'return_data_type'")
463
422
  __props__.__dict__["return_data_type"] = return_data_type
464
423
  if schema is None and not opts.urn:
465
424
  raise TypeError("Missing required property 'schema'")
466
425
  __props__.__dict__["schema"] = schema
467
- if signature is None and not opts.urn:
468
- raise TypeError("Missing required property 'signature'")
469
- __props__.__dict__["signature"] = signature
426
+ __props__.__dict__["describe_outputs"] = None
470
427
  __props__.__dict__["fully_qualified_name"] = None
428
+ __props__.__dict__["show_outputs"] = None
471
429
  super(MaskingPolicy, __self__).__init__(
472
430
  'snowflake:index/maskingPolicy:MaskingPolicy',
473
431
  resource_name,
@@ -478,17 +436,17 @@ class MaskingPolicy(pulumi.CustomResource):
478
436
  def get(resource_name: str,
479
437
  id: pulumi.Input[str],
480
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,
481
441
  comment: Optional[pulumi.Input[str]] = None,
482
442
  database: Optional[pulumi.Input[str]] = None,
483
- exempt_other_policies: Optional[pulumi.Input[bool]] = None,
443
+ describe_outputs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyDescribeOutputArgs', 'MaskingPolicyDescribeOutputArgsDict']]]]] = None,
444
+ exempt_other_policies: Optional[pulumi.Input[str]] = None,
484
445
  fully_qualified_name: Optional[pulumi.Input[str]] = None,
485
- if_not_exists: Optional[pulumi.Input[bool]] = None,
486
- masking_expression: Optional[pulumi.Input[str]] = None,
487
446
  name: Optional[pulumi.Input[str]] = None,
488
- or_replace: Optional[pulumi.Input[bool]] = None,
489
447
  return_data_type: Optional[pulumi.Input[str]] = None,
490
448
  schema: Optional[pulumi.Input[str]] = None,
491
- signature: Optional[pulumi.Input[Union['MaskingPolicySignatureArgs', 'MaskingPolicySignatureArgsDict']]] = None) -> 'MaskingPolicy':
449
+ show_outputs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MaskingPolicyShowOutputArgs', 'MaskingPolicyShowOutputArgsDict']]]]] = None) -> 'MaskingPolicy':
492
450
  """
493
451
  Get an existing MaskingPolicy resource's state with the given name, id, and optional extra
494
452
  properties used to qualify the lookup.
@@ -496,35 +454,51 @@ class MaskingPolicy(pulumi.CustomResource):
496
454
  :param str resource_name: The unique name of the resulting resource.
497
455
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
498
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.
499
459
  :param pulumi.Input[str] comment: Specifies a comment for the masking policy.
500
- :param pulumi.Input[str] database: The database in which to create the masking policy.
501
- :param pulumi.Input[bool] 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.
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.
502
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).
503
- :param pulumi.Input[bool] if_not_exists: Prevent overwriting a previous masking policy with the same name.
504
- :param pulumi.Input[str] masking_expression: Specifies the SQL expression that transforms the data.
505
- :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.
506
- :param pulumi.Input[bool] or_replace: Whether to override a previous masking policy with the same name.
507
- :param pulumi.Input[str] return_data_type: Specifies the data type to return.
508
- :param pulumi.Input[str] schema: The schema in which to create the masking policy.
509
- :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.
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.
510
468
  """
511
469
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
512
470
 
513
471
  __props__ = _MaskingPolicyState.__new__(_MaskingPolicyState)
514
472
 
473
+ __props__.__dict__["arguments"] = arguments
474
+ __props__.__dict__["body"] = body
515
475
  __props__.__dict__["comment"] = comment
516
476
  __props__.__dict__["database"] = database
477
+ __props__.__dict__["describe_outputs"] = describe_outputs
517
478
  __props__.__dict__["exempt_other_policies"] = exempt_other_policies
518
479
  __props__.__dict__["fully_qualified_name"] = fully_qualified_name
519
- __props__.__dict__["if_not_exists"] = if_not_exists
520
- __props__.__dict__["masking_expression"] = masking_expression
521
480
  __props__.__dict__["name"] = name
522
- __props__.__dict__["or_replace"] = or_replace
523
481
  __props__.__dict__["return_data_type"] = return_data_type
524
482
  __props__.__dict__["schema"] = schema
525
- __props__.__dict__["signature"] = signature
483
+ __props__.__dict__["show_outputs"] = show_outputs
526
484
  return MaskingPolicy(resource_name, opts=opts, __props__=__props__)
527
485
 
486
+ @property
487
+ @pulumi.getter
488
+ def arguments(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyArgument']]:
489
+ """
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.
491
+ """
492
+ return pulumi.get(self, "arguments")
493
+
494
+ @property
495
+ @pulumi.getter
496
+ def body(self) -> pulumi.Output[str]:
497
+ """
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.
499
+ """
500
+ return pulumi.get(self, "body")
501
+
528
502
  @property
529
503
  @pulumi.getter
530
504
  def comment(self) -> pulumi.Output[Optional[str]]:
@@ -537,15 +511,23 @@ class MaskingPolicy(pulumi.CustomResource):
537
511
  @pulumi.getter
538
512
  def database(self) -> pulumi.Output[str]:
539
513
  """
540
- The database in which to create the masking policy.
514
+ The database in which to create the masking policy. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `(`, `)`, `"`
541
515
  """
542
516
  return pulumi.get(self, "database")
543
517
 
518
+ @property
519
+ @pulumi.getter(name="describeOutputs")
520
+ def describe_outputs(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyDescribeOutput']]:
521
+ """
522
+ Outputs the result of `DESCRIBE MASKING POLICY` for the given masking policy.
523
+ """
524
+ return pulumi.get(self, "describe_outputs")
525
+
544
526
  @property
545
527
  @pulumi.getter(name="exemptOtherPolicies")
546
- def exempt_other_policies(self) -> pulumi.Output[Optional[bool]]:
528
+ def exempt_other_policies(self) -> pulumi.Output[Optional[str]]:
547
529
  """
548
- Specifies whether the row access policy or conditional masking policy can reference a column that is already protected by a masking policy.
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.
549
531
  """
550
532
  return pulumi.get(self, "exempt_other_policies")
551
533
 
@@ -557,43 +539,19 @@ class MaskingPolicy(pulumi.CustomResource):
557
539
  """
558
540
  return pulumi.get(self, "fully_qualified_name")
559
541
 
560
- @property
561
- @pulumi.getter(name="ifNotExists")
562
- def if_not_exists(self) -> pulumi.Output[Optional[bool]]:
563
- """
564
- Prevent overwriting a previous masking policy with the same name.
565
- """
566
- return pulumi.get(self, "if_not_exists")
567
-
568
- @property
569
- @pulumi.getter(name="maskingExpression")
570
- def masking_expression(self) -> pulumi.Output[str]:
571
- """
572
- Specifies the SQL expression that transforms the data.
573
- """
574
- return pulumi.get(self, "masking_expression")
575
-
576
542
  @property
577
543
  @pulumi.getter
578
544
  def name(self) -> pulumi.Output[str]:
579
545
  """
580
- Specifies the identifier for the masking policy; must be unique for the database and schema in which the masking policy is created.
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: `|`, `.`, `(`, `)`, `"`
581
547
  """
582
548
  return pulumi.get(self, "name")
583
549
 
584
- @property
585
- @pulumi.getter(name="orReplace")
586
- def or_replace(self) -> pulumi.Output[Optional[bool]]:
587
- """
588
- Whether to override a previous masking policy with the same name.
589
- """
590
- return pulumi.get(self, "or_replace")
591
-
592
550
  @property
593
551
  @pulumi.getter(name="returnDataType")
594
552
  def return_data_type(self) -> pulumi.Output[str]:
595
553
  """
596
- Specifies the data type to return.
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).
597
555
  """
598
556
  return pulumi.get(self, "return_data_type")
599
557
 
@@ -601,15 +559,15 @@ class MaskingPolicy(pulumi.CustomResource):
601
559
  @pulumi.getter
602
560
  def schema(self) -> pulumi.Output[str]:
603
561
  """
604
- 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: `|`, `.`, `(`, `)`, `"`
605
563
  """
606
564
  return pulumi.get(self, "schema")
607
565
 
608
566
  @property
609
- @pulumi.getter
610
- def signature(self) -> pulumi.Output['outputs.MaskingPolicySignature']:
567
+ @pulumi.getter(name="showOutputs")
568
+ def show_outputs(self) -> pulumi.Output[Sequence['outputs.MaskingPolicyShowOutput']]:
611
569
  """
612
- The signature for the masking policy; specifies the input columns and data types to evaluate at query runtime.
570
+ Outputs the result of `SHOW MASKING POLICY` for the given masking policy.
613
571
  """
614
- return pulumi.get(self, "signature")
572
+ return pulumi.get(self, "show_outputs")
615
573