pulumi-snowflake 2.3.0a1753339260__py3-none-any.whl → 2.3.0a1753415140__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.
- pulumi_snowflake/__init__.py +20 -1
- pulumi_snowflake/_inputs.py +17236 -16797
- pulumi_snowflake/account.py +252 -253
- pulumi_snowflake/account_authentication_policy_attachment.py +18 -19
- pulumi_snowflake/account_parameter.py +35 -36
- pulumi_snowflake/account_password_policy_attachment.py +18 -19
- pulumi_snowflake/account_role.py +42 -43
- pulumi_snowflake/alert.py +149 -150
- pulumi_snowflake/api_authentication_integration_with_authorization_code_grant.py +197 -198
- pulumi_snowflake/api_authentication_integration_with_client_credentials.py +180 -181
- pulumi_snowflake/api_authentication_integration_with_jwt_bearer.py +193 -194
- pulumi_snowflake/api_integration.py +251 -252
- pulumi_snowflake/authentication_policy.py +167 -168
- pulumi_snowflake/compute_pool.py +167 -168
- pulumi_snowflake/config/__init__.py +1 -1
- pulumi_snowflake/config/__init__.pyi +1 -2
- pulumi_snowflake/config/outputs.py +21 -22
- pulumi_snowflake/config/vars.py +43 -44
- pulumi_snowflake/cortex_search_service.py +191 -192
- pulumi_snowflake/current_account.py +2096 -2097
- pulumi_snowflake/current_organization_account.py +5863 -0
- pulumi_snowflake/database.py +353 -354
- pulumi_snowflake/database_role.py +63 -64
- pulumi_snowflake/dynamic_table.py +274 -275
- pulumi_snowflake/email_notification_integration.py +70 -71
- pulumi_snowflake/execute.py +61 -62
- pulumi_snowflake/external_function.py +280 -281
- pulumi_snowflake/external_oauth_integration.py +288 -289
- pulumi_snowflake/external_table.py +246 -247
- pulumi_snowflake/external_volume.py +68 -69
- pulumi_snowflake/failover_group.py +135 -136
- pulumi_snowflake/file_format.py +622 -623
- pulumi_snowflake/function_java.py +320 -321
- pulumi_snowflake/function_javascript.py +243 -244
- pulumi_snowflake/function_python.py +334 -335
- pulumi_snowflake/function_scala.py +320 -321
- pulumi_snowflake/function_sql.py +226 -227
- pulumi_snowflake/get_account_roles.py +16 -17
- pulumi_snowflake/get_accounts.py +16 -17
- pulumi_snowflake/get_alerts.py +22 -23
- pulumi_snowflake/get_compute_pools.py +23 -24
- pulumi_snowflake/get_connections.py +10 -11
- pulumi_snowflake/get_cortex_search_services.py +18 -19
- pulumi_snowflake/get_current_account.py +9 -10
- pulumi_snowflake/get_current_role.py +5 -6
- pulumi_snowflake/get_database.py +25 -26
- pulumi_snowflake/get_database_role.py +19 -20
- pulumi_snowflake/get_database_roles.py +17 -18
- pulumi_snowflake/get_databases.py +29 -30
- pulumi_snowflake/get_dynamic_tables.py +13 -14
- pulumi_snowflake/get_external_functions.py +16 -17
- pulumi_snowflake/get_external_tables.py +16 -17
- pulumi_snowflake/get_failover_groups.py +10 -11
- pulumi_snowflake/get_file_formats.py +16 -17
- pulumi_snowflake/get_functions.py +16 -17
- pulumi_snowflake/get_git_repositories.py +18 -19
- pulumi_snowflake/get_grants.py +9 -10
- pulumi_snowflake/get_image_repositories.py +11 -12
- pulumi_snowflake/get_masking_policies.py +18 -19
- pulumi_snowflake/get_materialized_views.py +16 -17
- pulumi_snowflake/get_network_policies.py +16 -17
- pulumi_snowflake/get_parameters.py +34 -35
- pulumi_snowflake/get_pipes.py +16 -17
- pulumi_snowflake/get_procedures.py +16 -17
- pulumi_snowflake/get_resource_monitors.py +10 -11
- pulumi_snowflake/get_row_access_policies.py +18 -19
- pulumi_snowflake/get_schemas.py +30 -31
- pulumi_snowflake/get_secrets.py +17 -18
- pulumi_snowflake/get_security_integrations.py +16 -17
- pulumi_snowflake/get_sequences.py +16 -17
- pulumi_snowflake/get_services.py +30 -31
- pulumi_snowflake/get_shares.py +10 -11
- pulumi_snowflake/get_stages.py +16 -17
- pulumi_snowflake/get_storage_integrations.py +4 -5
- pulumi_snowflake/get_streamlits.py +18 -19
- pulumi_snowflake/get_streams.py +24 -25
- pulumi_snowflake/get_system_generate_scim_access_token.py +11 -12
- pulumi_snowflake/get_system_get_aws_sns_iam_policy.py +11 -12
- pulumi_snowflake/get_system_get_private_link_config.py +21 -22
- pulumi_snowflake/get_system_get_snowflake_platform_info.py +7 -8
- pulumi_snowflake/get_tables.py +24 -25
- pulumi_snowflake/get_tags.py +11 -12
- pulumi_snowflake/get_tasks.py +30 -31
- pulumi_snowflake/get_user_programmatic_access_tokens.py +113 -0
- pulumi_snowflake/get_users.py +29 -30
- pulumi_snowflake/get_views.py +24 -25
- pulumi_snowflake/get_warehouses.py +22 -23
- pulumi_snowflake/git_repository.py +133 -134
- pulumi_snowflake/grant_account_role.py +52 -53
- pulumi_snowflake/grant_application_role.py +52 -53
- pulumi_snowflake/grant_database_role.py +69 -70
- pulumi_snowflake/grant_ownership.py +55 -56
- pulumi_snowflake/grant_privileges_to_account_role.py +125 -126
- pulumi_snowflake/grant_privileges_to_database_role.py +122 -123
- pulumi_snowflake/grant_privileges_to_share.py +154 -155
- pulumi_snowflake/image_repository.py +80 -81
- pulumi_snowflake/job_service.py +148 -149
- pulumi_snowflake/legacy_service_user.py +1269 -1270
- pulumi_snowflake/managed_account.py +140 -141
- pulumi_snowflake/masking_policy.py +136 -137
- pulumi_snowflake/materialized_view.py +149 -150
- pulumi_snowflake/network_policy.py +116 -117
- pulumi_snowflake/network_policy_attachment.py +52 -53
- pulumi_snowflake/network_rule.py +129 -130
- pulumi_snowflake/notification_integration.py +298 -299
- pulumi_snowflake/oauth_integration_for_custom_clients.py +263 -264
- pulumi_snowflake/oauth_integration_for_partner_applications.py +169 -170
- pulumi_snowflake/object_parameter.py +72 -73
- pulumi_snowflake/outputs.py +15957 -15511
- pulumi_snowflake/password_policy.py +299 -300
- pulumi_snowflake/pipe.py +181 -182
- pulumi_snowflake/primary_connection.py +70 -71
- pulumi_snowflake/procedure_java.py +341 -342
- pulumi_snowflake/procedure_javascript.py +247 -248
- pulumi_snowflake/procedure_python.py +338 -339
- pulumi_snowflake/procedure_scala.py +341 -342
- pulumi_snowflake/procedure_sql.py +247 -248
- pulumi_snowflake/provider.py +377 -378
- pulumi_snowflake/pulumi-plugin.json +1 -1
- pulumi_snowflake/resource_monitor.py +165 -166
- pulumi_snowflake/row_access_policy.py +102 -103
- pulumi_snowflake/saml2_integration.py +303 -304
- pulumi_snowflake/schema.py +390 -391
- pulumi_snowflake/scim_integration.py +133 -134
- pulumi_snowflake/secondary_connection.py +72 -73
- pulumi_snowflake/secondary_database.py +350 -351
- pulumi_snowflake/secret_with_authorization_code_grant.py +138 -139
- pulumi_snowflake/secret_with_basic_authentication.py +121 -122
- pulumi_snowflake/secret_with_client_credentials.py +125 -126
- pulumi_snowflake/secret_with_generic_string.py +104 -105
- pulumi_snowflake/sequence.py +121 -122
- pulumi_snowflake/service.py +233 -234
- pulumi_snowflake/service_user.py +1239 -1240
- pulumi_snowflake/share.py +61 -62
- pulumi_snowflake/shared_database.py +299 -300
- pulumi_snowflake/stage.py +234 -235
- pulumi_snowflake/storage_integration.py +230 -231
- pulumi_snowflake/stream_on_directory_table.py +128 -129
- pulumi_snowflake/stream_on_external_table.py +151 -152
- pulumi_snowflake/stream_on_table.py +164 -165
- pulumi_snowflake/stream_on_view.py +164 -165
- pulumi_snowflake/streamlit.py +184 -185
- pulumi_snowflake/table.py +147 -148
- pulumi_snowflake/table_column_masking_policy_application.py +52 -53
- pulumi_snowflake/table_constraint.py +191 -192
- pulumi_snowflake/tag.py +114 -115
- pulumi_snowflake/tag_association.py +86 -87
- pulumi_snowflake/task.py +1224 -1225
- pulumi_snowflake/user.py +1346 -1347
- pulumi_snowflake/user_authentication_policy_attachment.py +35 -36
- pulumi_snowflake/user_password_policy_attachment.py +35 -36
- pulumi_snowflake/user_programmatic_access_token.py +598 -0
- pulumi_snowflake/user_public_keys.py +52 -53
- pulumi_snowflake/view.py +187 -188
- pulumi_snowflake/warehouse.py +286 -287
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/METADATA +1 -1
- pulumi_snowflake-2.3.0a1753415140.dist-info/RECORD +161 -0
- pulumi_snowflake-2.3.0a1753339260.dist-info/RECORD +0 -158
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/WHEEL +0 -0
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -22,50 +21,50 @@ __all__ = ['ProcedurePythonArgs', 'ProcedurePython']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class ProcedurePythonArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
database: pulumi.Input[
|
|
26
|
-
handler: pulumi.Input[
|
|
27
|
-
return_type: pulumi.Input[
|
|
28
|
-
runtime_version: pulumi.Input[
|
|
29
|
-
schema: pulumi.Input[
|
|
30
|
-
snowpark_package: pulumi.Input[
|
|
24
|
+
database: pulumi.Input[_builtins.str],
|
|
25
|
+
handler: pulumi.Input[_builtins.str],
|
|
26
|
+
return_type: pulumi.Input[_builtins.str],
|
|
27
|
+
runtime_version: pulumi.Input[_builtins.str],
|
|
28
|
+
schema: pulumi.Input[_builtins.str],
|
|
29
|
+
snowpark_package: pulumi.Input[_builtins.str],
|
|
31
30
|
arguments: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]] = None,
|
|
32
|
-
comment: Optional[pulumi.Input[
|
|
33
|
-
enable_console_output: Optional[pulumi.Input[
|
|
34
|
-
execute_as: Optional[pulumi.Input[
|
|
35
|
-
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
31
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
enable_console_output: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
execute_as: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
36
35
|
imports: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]] = None,
|
|
37
|
-
is_secure: Optional[pulumi.Input[
|
|
38
|
-
log_level: Optional[pulumi.Input[
|
|
39
|
-
metric_level: Optional[pulumi.Input[
|
|
40
|
-
name: Optional[pulumi.Input[
|
|
41
|
-
null_input_behavior: Optional[pulumi.Input[
|
|
42
|
-
packages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
43
|
-
procedure_definition: Optional[pulumi.Input[
|
|
36
|
+
is_secure: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
log_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
metric_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
null_input_behavior: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
packages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
42
|
+
procedure_definition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
43
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]] = None,
|
|
45
|
-
trace_level: Optional[pulumi.Input[
|
|
44
|
+
trace_level: Optional[pulumi.Input[_builtins.str]] = None):
|
|
46
45
|
"""
|
|
47
46
|
The set of arguments for constructing a ProcedurePython resource.
|
|
48
|
-
:param pulumi.Input[
|
|
49
|
-
:param pulumi.Input[
|
|
50
|
-
:param pulumi.Input[
|
|
51
|
-
:param pulumi.Input[
|
|
52
|
-
:param pulumi.Input[
|
|
53
|
-
:param pulumi.Input[
|
|
47
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
48
|
+
:param pulumi.Input[_builtins.str] handler: Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
49
|
+
:param pulumi.Input[_builtins.str] return_type: Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
50
|
+
:param pulumi.Input[_builtins.str] runtime_version: The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
51
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
52
|
+
:param pulumi.Input[_builtins.str] snowpark_package: The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
54
53
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]] arguments: List of the arguments for the procedure. Consult the [docs](https://docs.snowflake.com/en/sql-reference/sql/create-procedure#all-languages) for more details.
|
|
55
|
-
:param pulumi.Input[
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
54
|
+
:param pulumi.Input[_builtins.str] comment: (Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
55
|
+
:param pulumi.Input[_builtins.bool] enable_console_output: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
56
|
+
:param pulumi.Input[_builtins.str] execute_as: Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
57
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] external_access_integrations: The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
59
58
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]] imports: The location (stage), path, and name of the file(s) to import. You must set the IMPORTS clause to include any files that your stored procedure depends on. If you are writing an in-line stored procedure, you can omit this clause, unless your code depends on classes defined outside the stored procedure or resource files. If your stored procedure’s code will be on a stage, you must also include a path to the module file your code is in. The IMPORTS definition cannot reference variables from arguments that are passed into the stored procedure. Each file in the IMPORTS clause must have a unique name, even if the files are in different subdirectories or different stages.
|
|
60
|
-
:param pulumi.Input[
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
64
|
-
:param pulumi.Input[
|
|
65
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
59
|
+
:param pulumi.Input[_builtins.str] is_secure: (Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
60
|
+
:param pulumi.Input[_builtins.str] log_level: LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
61
|
+
:param pulumi.Input[_builtins.str] metric_level: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
62
|
+
:param pulumi.Input[_builtins.str] name: The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
63
|
+
:param pulumi.Input[_builtins.str] null_input_behavior: Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
64
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] packages: List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
65
|
+
:param pulumi.Input[_builtins.str] procedure_definition: Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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
66
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]] secrets: Assigns the names of [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) to variables so that you can use the variables to reference the secrets when retrieving information from secrets in handler code. Secrets you specify here must be allowed by the [external access integration](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) specified as a value of this CREATE FUNCTION command’s EXTERNAL*ACCESS*INTEGRATIONS parameter.
|
|
68
|
-
:param pulumi.Input[
|
|
67
|
+
:param pulumi.Input[_builtins.str] trace_level: Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
69
68
|
"""
|
|
70
69
|
pulumi.set(__self__, "database", database)
|
|
71
70
|
pulumi.set(__self__, "handler", handler)
|
|
@@ -104,79 +103,79 @@ class ProcedurePythonArgs:
|
|
|
104
103
|
if trace_level is not None:
|
|
105
104
|
pulumi.set(__self__, "trace_level", trace_level)
|
|
106
105
|
|
|
107
|
-
@property
|
|
106
|
+
@_builtins.property
|
|
108
107
|
@pulumi.getter
|
|
109
|
-
def database(self) -> pulumi.Input[
|
|
108
|
+
def database(self) -> pulumi.Input[_builtins.str]:
|
|
110
109
|
"""
|
|
111
110
|
The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
112
111
|
"""
|
|
113
112
|
return pulumi.get(self, "database")
|
|
114
113
|
|
|
115
114
|
@database.setter
|
|
116
|
-
def database(self, value: pulumi.Input[
|
|
115
|
+
def database(self, value: pulumi.Input[_builtins.str]):
|
|
117
116
|
pulumi.set(self, "database", value)
|
|
118
117
|
|
|
119
|
-
@property
|
|
118
|
+
@_builtins.property
|
|
120
119
|
@pulumi.getter
|
|
121
|
-
def handler(self) -> pulumi.Input[
|
|
120
|
+
def handler(self) -> pulumi.Input[_builtins.str]:
|
|
122
121
|
"""
|
|
123
122
|
Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
124
123
|
"""
|
|
125
124
|
return pulumi.get(self, "handler")
|
|
126
125
|
|
|
127
126
|
@handler.setter
|
|
128
|
-
def handler(self, value: pulumi.Input[
|
|
127
|
+
def handler(self, value: pulumi.Input[_builtins.str]):
|
|
129
128
|
pulumi.set(self, "handler", value)
|
|
130
129
|
|
|
131
|
-
@property
|
|
130
|
+
@_builtins.property
|
|
132
131
|
@pulumi.getter(name="returnType")
|
|
133
|
-
def return_type(self) -> pulumi.Input[
|
|
132
|
+
def return_type(self) -> pulumi.Input[_builtins.str]:
|
|
134
133
|
"""
|
|
135
134
|
Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
136
135
|
"""
|
|
137
136
|
return pulumi.get(self, "return_type")
|
|
138
137
|
|
|
139
138
|
@return_type.setter
|
|
140
|
-
def return_type(self, value: pulumi.Input[
|
|
139
|
+
def return_type(self, value: pulumi.Input[_builtins.str]):
|
|
141
140
|
pulumi.set(self, "return_type", value)
|
|
142
141
|
|
|
143
|
-
@property
|
|
142
|
+
@_builtins.property
|
|
144
143
|
@pulumi.getter(name="runtimeVersion")
|
|
145
|
-
def runtime_version(self) -> pulumi.Input[
|
|
144
|
+
def runtime_version(self) -> pulumi.Input[_builtins.str]:
|
|
146
145
|
"""
|
|
147
146
|
The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
148
147
|
"""
|
|
149
148
|
return pulumi.get(self, "runtime_version")
|
|
150
149
|
|
|
151
150
|
@runtime_version.setter
|
|
152
|
-
def runtime_version(self, value: pulumi.Input[
|
|
151
|
+
def runtime_version(self, value: pulumi.Input[_builtins.str]):
|
|
153
152
|
pulumi.set(self, "runtime_version", value)
|
|
154
153
|
|
|
155
|
-
@property
|
|
154
|
+
@_builtins.property
|
|
156
155
|
@pulumi.getter
|
|
157
|
-
def schema(self) -> pulumi.Input[
|
|
156
|
+
def schema(self) -> pulumi.Input[_builtins.str]:
|
|
158
157
|
"""
|
|
159
158
|
The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
160
159
|
"""
|
|
161
160
|
return pulumi.get(self, "schema")
|
|
162
161
|
|
|
163
162
|
@schema.setter
|
|
164
|
-
def schema(self, value: pulumi.Input[
|
|
163
|
+
def schema(self, value: pulumi.Input[_builtins.str]):
|
|
165
164
|
pulumi.set(self, "schema", value)
|
|
166
165
|
|
|
167
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
168
167
|
@pulumi.getter(name="snowparkPackage")
|
|
169
|
-
def snowpark_package(self) -> pulumi.Input[
|
|
168
|
+
def snowpark_package(self) -> pulumi.Input[_builtins.str]:
|
|
170
169
|
"""
|
|
171
170
|
The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
172
171
|
"""
|
|
173
172
|
return pulumi.get(self, "snowpark_package")
|
|
174
173
|
|
|
175
174
|
@snowpark_package.setter
|
|
176
|
-
def snowpark_package(self, value: pulumi.Input[
|
|
175
|
+
def snowpark_package(self, value: pulumi.Input[_builtins.str]):
|
|
177
176
|
pulumi.set(self, "snowpark_package", value)
|
|
178
177
|
|
|
179
|
-
@property
|
|
178
|
+
@_builtins.property
|
|
180
179
|
@pulumi.getter
|
|
181
180
|
def arguments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]]:
|
|
182
181
|
"""
|
|
@@ -188,55 +187,55 @@ class ProcedurePythonArgs:
|
|
|
188
187
|
def arguments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]]):
|
|
189
188
|
pulumi.set(self, "arguments", value)
|
|
190
189
|
|
|
191
|
-
@property
|
|
190
|
+
@_builtins.property
|
|
192
191
|
@pulumi.getter
|
|
193
|
-
def comment(self) -> Optional[pulumi.Input[
|
|
192
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
194
193
|
"""
|
|
195
194
|
(Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
196
195
|
"""
|
|
197
196
|
return pulumi.get(self, "comment")
|
|
198
197
|
|
|
199
198
|
@comment.setter
|
|
200
|
-
def comment(self, value: Optional[pulumi.Input[
|
|
199
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
201
200
|
pulumi.set(self, "comment", value)
|
|
202
201
|
|
|
203
|
-
@property
|
|
202
|
+
@_builtins.property
|
|
204
203
|
@pulumi.getter(name="enableConsoleOutput")
|
|
205
|
-
def enable_console_output(self) -> Optional[pulumi.Input[
|
|
204
|
+
def enable_console_output(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
206
205
|
"""
|
|
207
206
|
Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
208
207
|
"""
|
|
209
208
|
return pulumi.get(self, "enable_console_output")
|
|
210
209
|
|
|
211
210
|
@enable_console_output.setter
|
|
212
|
-
def enable_console_output(self, value: Optional[pulumi.Input[
|
|
211
|
+
def enable_console_output(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
213
212
|
pulumi.set(self, "enable_console_output", value)
|
|
214
213
|
|
|
215
|
-
@property
|
|
214
|
+
@_builtins.property
|
|
216
215
|
@pulumi.getter(name="executeAs")
|
|
217
|
-
def execute_as(self) -> Optional[pulumi.Input[
|
|
216
|
+
def execute_as(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
218
217
|
"""
|
|
219
218
|
Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
220
219
|
"""
|
|
221
220
|
return pulumi.get(self, "execute_as")
|
|
222
221
|
|
|
223
222
|
@execute_as.setter
|
|
224
|
-
def execute_as(self, value: Optional[pulumi.Input[
|
|
223
|
+
def execute_as(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
225
224
|
pulumi.set(self, "execute_as", value)
|
|
226
225
|
|
|
227
|
-
@property
|
|
226
|
+
@_builtins.property
|
|
228
227
|
@pulumi.getter(name="externalAccessIntegrations")
|
|
229
|
-
def external_access_integrations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
228
|
+
def external_access_integrations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
230
229
|
"""
|
|
231
230
|
The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
232
231
|
"""
|
|
233
232
|
return pulumi.get(self, "external_access_integrations")
|
|
234
233
|
|
|
235
234
|
@external_access_integrations.setter
|
|
236
|
-
def external_access_integrations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
235
|
+
def external_access_integrations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
237
236
|
pulumi.set(self, "external_access_integrations", value)
|
|
238
237
|
|
|
239
|
-
@property
|
|
238
|
+
@_builtins.property
|
|
240
239
|
@pulumi.getter
|
|
241
240
|
def imports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]]:
|
|
242
241
|
"""
|
|
@@ -248,91 +247,91 @@ class ProcedurePythonArgs:
|
|
|
248
247
|
def imports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]]):
|
|
249
248
|
pulumi.set(self, "imports", value)
|
|
250
249
|
|
|
251
|
-
@property
|
|
250
|
+
@_builtins.property
|
|
252
251
|
@pulumi.getter(name="isSecure")
|
|
253
|
-
def is_secure(self) -> Optional[pulumi.Input[
|
|
252
|
+
def is_secure(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
254
253
|
"""
|
|
255
254
|
(Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
256
255
|
"""
|
|
257
256
|
return pulumi.get(self, "is_secure")
|
|
258
257
|
|
|
259
258
|
@is_secure.setter
|
|
260
|
-
def is_secure(self, value: Optional[pulumi.Input[
|
|
259
|
+
def is_secure(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
261
260
|
pulumi.set(self, "is_secure", value)
|
|
262
261
|
|
|
263
|
-
@property
|
|
262
|
+
@_builtins.property
|
|
264
263
|
@pulumi.getter(name="logLevel")
|
|
265
|
-
def log_level(self) -> Optional[pulumi.Input[
|
|
264
|
+
def log_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
266
265
|
"""
|
|
267
266
|
LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
268
267
|
"""
|
|
269
268
|
return pulumi.get(self, "log_level")
|
|
270
269
|
|
|
271
270
|
@log_level.setter
|
|
272
|
-
def log_level(self, value: Optional[pulumi.Input[
|
|
271
|
+
def log_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
273
272
|
pulumi.set(self, "log_level", value)
|
|
274
273
|
|
|
275
|
-
@property
|
|
274
|
+
@_builtins.property
|
|
276
275
|
@pulumi.getter(name="metricLevel")
|
|
277
|
-
def metric_level(self) -> Optional[pulumi.Input[
|
|
276
|
+
def metric_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
278
277
|
"""
|
|
279
278
|
METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
280
279
|
"""
|
|
281
280
|
return pulumi.get(self, "metric_level")
|
|
282
281
|
|
|
283
282
|
@metric_level.setter
|
|
284
|
-
def metric_level(self, value: Optional[pulumi.Input[
|
|
283
|
+
def metric_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
285
284
|
pulumi.set(self, "metric_level", value)
|
|
286
285
|
|
|
287
|
-
@property
|
|
286
|
+
@_builtins.property
|
|
288
287
|
@pulumi.getter
|
|
289
|
-
def name(self) -> Optional[pulumi.Input[
|
|
288
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
290
289
|
"""
|
|
291
290
|
The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
292
291
|
"""
|
|
293
292
|
return pulumi.get(self, "name")
|
|
294
293
|
|
|
295
294
|
@name.setter
|
|
296
|
-
def name(self, value: Optional[pulumi.Input[
|
|
295
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
297
296
|
pulumi.set(self, "name", value)
|
|
298
297
|
|
|
299
|
-
@property
|
|
298
|
+
@_builtins.property
|
|
300
299
|
@pulumi.getter(name="nullInputBehavior")
|
|
301
|
-
def null_input_behavior(self) -> Optional[pulumi.Input[
|
|
300
|
+
def null_input_behavior(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
302
301
|
"""
|
|
303
302
|
Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
304
303
|
"""
|
|
305
304
|
return pulumi.get(self, "null_input_behavior")
|
|
306
305
|
|
|
307
306
|
@null_input_behavior.setter
|
|
308
|
-
def null_input_behavior(self, value: Optional[pulumi.Input[
|
|
307
|
+
def null_input_behavior(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
309
308
|
pulumi.set(self, "null_input_behavior", value)
|
|
310
309
|
|
|
311
|
-
@property
|
|
310
|
+
@_builtins.property
|
|
312
311
|
@pulumi.getter
|
|
313
|
-
def packages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
312
|
+
def packages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
314
313
|
"""
|
|
315
314
|
List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
316
315
|
"""
|
|
317
316
|
return pulumi.get(self, "packages")
|
|
318
317
|
|
|
319
318
|
@packages.setter
|
|
320
|
-
def packages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
319
|
+
def packages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
321
320
|
pulumi.set(self, "packages", value)
|
|
322
321
|
|
|
323
|
-
@property
|
|
322
|
+
@_builtins.property
|
|
324
323
|
@pulumi.getter(name="procedureDefinition")
|
|
325
|
-
def procedure_definition(self) -> Optional[pulumi.Input[
|
|
324
|
+
def procedure_definition(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
326
325
|
"""
|
|
327
326
|
Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
328
327
|
"""
|
|
329
328
|
return pulumi.get(self, "procedure_definition")
|
|
330
329
|
|
|
331
330
|
@procedure_definition.setter
|
|
332
|
-
def procedure_definition(self, value: Optional[pulumi.Input[
|
|
331
|
+
def procedure_definition(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
333
332
|
pulumi.set(self, "procedure_definition", value)
|
|
334
333
|
|
|
335
|
-
@property
|
|
334
|
+
@_builtins.property
|
|
336
335
|
@pulumi.getter
|
|
337
336
|
def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]]:
|
|
338
337
|
"""
|
|
@@ -344,16 +343,16 @@ class ProcedurePythonArgs:
|
|
|
344
343
|
def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]]):
|
|
345
344
|
pulumi.set(self, "secrets", value)
|
|
346
345
|
|
|
347
|
-
@property
|
|
346
|
+
@_builtins.property
|
|
348
347
|
@pulumi.getter(name="traceLevel")
|
|
349
|
-
def trace_level(self) -> Optional[pulumi.Input[
|
|
348
|
+
def trace_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
350
349
|
"""
|
|
351
350
|
Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
352
351
|
"""
|
|
353
352
|
return pulumi.get(self, "trace_level")
|
|
354
353
|
|
|
355
354
|
@trace_level.setter
|
|
356
|
-
def trace_level(self, value: Optional[pulumi.Input[
|
|
355
|
+
def trace_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
357
356
|
pulumi.set(self, "trace_level", value)
|
|
358
357
|
|
|
359
358
|
|
|
@@ -361,57 +360,57 @@ class ProcedurePythonArgs:
|
|
|
361
360
|
class _ProcedurePythonState:
|
|
362
361
|
def __init__(__self__, *,
|
|
363
362
|
arguments: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]] = None,
|
|
364
|
-
comment: Optional[pulumi.Input[
|
|
365
|
-
database: Optional[pulumi.Input[
|
|
366
|
-
enable_console_output: Optional[pulumi.Input[
|
|
367
|
-
execute_as: Optional[pulumi.Input[
|
|
368
|
-
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
369
|
-
fully_qualified_name: Optional[pulumi.Input[
|
|
370
|
-
handler: Optional[pulumi.Input[
|
|
363
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
364
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
365
|
+
enable_console_output: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
366
|
+
execute_as: Optional[pulumi.Input[_builtins.str]] = None,
|
|
367
|
+
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
368
|
+
fully_qualified_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
369
|
+
handler: Optional[pulumi.Input[_builtins.str]] = None,
|
|
371
370
|
imports: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]] = None,
|
|
372
|
-
is_secure: Optional[pulumi.Input[
|
|
373
|
-
log_level: Optional[pulumi.Input[
|
|
374
|
-
metric_level: Optional[pulumi.Input[
|
|
375
|
-
name: Optional[pulumi.Input[
|
|
376
|
-
null_input_behavior: Optional[pulumi.Input[
|
|
377
|
-
packages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
371
|
+
is_secure: Optional[pulumi.Input[_builtins.str]] = None,
|
|
372
|
+
log_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
373
|
+
metric_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
374
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
375
|
+
null_input_behavior: Optional[pulumi.Input[_builtins.str]] = None,
|
|
376
|
+
packages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
378
377
|
parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonParameterArgs']]]] = None,
|
|
379
|
-
procedure_definition: Optional[pulumi.Input[
|
|
380
|
-
procedure_language: Optional[pulumi.Input[
|
|
381
|
-
return_type: Optional[pulumi.Input[
|
|
382
|
-
runtime_version: Optional[pulumi.Input[
|
|
383
|
-
schema: Optional[pulumi.Input[
|
|
378
|
+
procedure_definition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
379
|
+
procedure_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
380
|
+
return_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
381
|
+
runtime_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
382
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
384
383
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]] = None,
|
|
385
384
|
show_outputs: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonShowOutputArgs']]]] = None,
|
|
386
|
-
snowpark_package: Optional[pulumi.Input[
|
|
387
|
-
trace_level: Optional[pulumi.Input[
|
|
385
|
+
snowpark_package: Optional[pulumi.Input[_builtins.str]] = None,
|
|
386
|
+
trace_level: Optional[pulumi.Input[_builtins.str]] = None):
|
|
388
387
|
"""
|
|
389
388
|
Input properties used for looking up and filtering ProcedurePython resources.
|
|
390
389
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]] arguments: List of the arguments for the procedure. Consult the [docs](https://docs.snowflake.com/en/sql-reference/sql/create-procedure#all-languages) for more details.
|
|
391
|
-
:param pulumi.Input[
|
|
392
|
-
:param pulumi.Input[
|
|
393
|
-
:param pulumi.Input[
|
|
394
|
-
:param pulumi.Input[
|
|
395
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
396
|
-
:param pulumi.Input[
|
|
397
|
-
:param pulumi.Input[
|
|
390
|
+
:param pulumi.Input[_builtins.str] comment: (Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
391
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
392
|
+
:param pulumi.Input[_builtins.bool] enable_console_output: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
393
|
+
:param pulumi.Input[_builtins.str] execute_as: Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
394
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] external_access_integrations: The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
395
|
+
:param pulumi.Input[_builtins.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).
|
|
396
|
+
:param pulumi.Input[_builtins.str] handler: Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
398
397
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]] imports: The location (stage), path, and name of the file(s) to import. You must set the IMPORTS clause to include any files that your stored procedure depends on. If you are writing an in-line stored procedure, you can omit this clause, unless your code depends on classes defined outside the stored procedure or resource files. If your stored procedure’s code will be on a stage, you must also include a path to the module file your code is in. The IMPORTS definition cannot reference variables from arguments that are passed into the stored procedure. Each file in the IMPORTS clause must have a unique name, even if the files are in different subdirectories or different stages.
|
|
399
|
-
:param pulumi.Input[
|
|
400
|
-
:param pulumi.Input[
|
|
401
|
-
:param pulumi.Input[
|
|
402
|
-
:param pulumi.Input[
|
|
403
|
-
:param pulumi.Input[
|
|
404
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
398
|
+
:param pulumi.Input[_builtins.str] is_secure: (Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
399
|
+
:param pulumi.Input[_builtins.str] log_level: LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
400
|
+
:param pulumi.Input[_builtins.str] metric_level: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
401
|
+
:param pulumi.Input[_builtins.str] name: The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
402
|
+
:param pulumi.Input[_builtins.str] null_input_behavior: Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
403
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] packages: List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
405
404
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonParameterArgs']]] parameters: Outputs the result of `SHOW PARAMETERS IN PROCEDURE` for the given procedure.
|
|
406
|
-
:param pulumi.Input[
|
|
407
|
-
:param pulumi.Input[
|
|
408
|
-
:param pulumi.Input[
|
|
409
|
-
:param pulumi.Input[
|
|
410
|
-
:param pulumi.Input[
|
|
405
|
+
:param pulumi.Input[_builtins.str] procedure_definition: Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
406
|
+
:param pulumi.Input[_builtins.str] procedure_language: Specifies language for the procedure. Used to detect external changes.
|
|
407
|
+
:param pulumi.Input[_builtins.str] return_type: Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
408
|
+
:param pulumi.Input[_builtins.str] runtime_version: The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
409
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
411
410
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]] secrets: Assigns the names of [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) to variables so that you can use the variables to reference the secrets when retrieving information from secrets in handler code. Secrets you specify here must be allowed by the [external access integration](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) specified as a value of this CREATE FUNCTION command’s EXTERNAL*ACCESS*INTEGRATIONS parameter.
|
|
412
411
|
:param pulumi.Input[Sequence[pulumi.Input['ProcedurePythonShowOutputArgs']]] show_outputs: Outputs the result of `SHOW PROCEDURE` for the given procedure.
|
|
413
|
-
:param pulumi.Input[
|
|
414
|
-
:param pulumi.Input[
|
|
412
|
+
:param pulumi.Input[_builtins.str] snowpark_package: The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
413
|
+
:param pulumi.Input[_builtins.str] trace_level: Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
415
414
|
"""
|
|
416
415
|
if arguments is not None:
|
|
417
416
|
pulumi.set(__self__, "arguments", arguments)
|
|
@@ -464,7 +463,7 @@ class _ProcedurePythonState:
|
|
|
464
463
|
if trace_level is not None:
|
|
465
464
|
pulumi.set(__self__, "trace_level", trace_level)
|
|
466
465
|
|
|
467
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
468
467
|
@pulumi.getter
|
|
469
468
|
def arguments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]]:
|
|
470
469
|
"""
|
|
@@ -476,91 +475,91 @@ class _ProcedurePythonState:
|
|
|
476
475
|
def arguments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonArgumentArgs']]]]):
|
|
477
476
|
pulumi.set(self, "arguments", value)
|
|
478
477
|
|
|
479
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
480
479
|
@pulumi.getter
|
|
481
|
-
def comment(self) -> Optional[pulumi.Input[
|
|
480
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
482
481
|
"""
|
|
483
482
|
(Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
484
483
|
"""
|
|
485
484
|
return pulumi.get(self, "comment")
|
|
486
485
|
|
|
487
486
|
@comment.setter
|
|
488
|
-
def comment(self, value: Optional[pulumi.Input[
|
|
487
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
489
488
|
pulumi.set(self, "comment", value)
|
|
490
489
|
|
|
491
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
492
491
|
@pulumi.getter
|
|
493
|
-
def database(self) -> Optional[pulumi.Input[
|
|
492
|
+
def database(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
494
493
|
"""
|
|
495
494
|
The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
496
495
|
"""
|
|
497
496
|
return pulumi.get(self, "database")
|
|
498
497
|
|
|
499
498
|
@database.setter
|
|
500
|
-
def database(self, value: Optional[pulumi.Input[
|
|
499
|
+
def database(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
501
500
|
pulumi.set(self, "database", value)
|
|
502
501
|
|
|
503
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
504
503
|
@pulumi.getter(name="enableConsoleOutput")
|
|
505
|
-
def enable_console_output(self) -> Optional[pulumi.Input[
|
|
504
|
+
def enable_console_output(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
506
505
|
"""
|
|
507
506
|
Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
508
507
|
"""
|
|
509
508
|
return pulumi.get(self, "enable_console_output")
|
|
510
509
|
|
|
511
510
|
@enable_console_output.setter
|
|
512
|
-
def enable_console_output(self, value: Optional[pulumi.Input[
|
|
511
|
+
def enable_console_output(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
513
512
|
pulumi.set(self, "enable_console_output", value)
|
|
514
513
|
|
|
515
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
516
515
|
@pulumi.getter(name="executeAs")
|
|
517
|
-
def execute_as(self) -> Optional[pulumi.Input[
|
|
516
|
+
def execute_as(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
518
517
|
"""
|
|
519
518
|
Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
520
519
|
"""
|
|
521
520
|
return pulumi.get(self, "execute_as")
|
|
522
521
|
|
|
523
522
|
@execute_as.setter
|
|
524
|
-
def execute_as(self, value: Optional[pulumi.Input[
|
|
523
|
+
def execute_as(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
525
524
|
pulumi.set(self, "execute_as", value)
|
|
526
525
|
|
|
527
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
528
527
|
@pulumi.getter(name="externalAccessIntegrations")
|
|
529
|
-
def external_access_integrations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
528
|
+
def external_access_integrations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
530
529
|
"""
|
|
531
530
|
The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
532
531
|
"""
|
|
533
532
|
return pulumi.get(self, "external_access_integrations")
|
|
534
533
|
|
|
535
534
|
@external_access_integrations.setter
|
|
536
|
-
def external_access_integrations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
535
|
+
def external_access_integrations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
537
536
|
pulumi.set(self, "external_access_integrations", value)
|
|
538
537
|
|
|
539
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
540
539
|
@pulumi.getter(name="fullyQualifiedName")
|
|
541
|
-
def fully_qualified_name(self) -> Optional[pulumi.Input[
|
|
540
|
+
def fully_qualified_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
542
541
|
"""
|
|
543
542
|
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
544
543
|
"""
|
|
545
544
|
return pulumi.get(self, "fully_qualified_name")
|
|
546
545
|
|
|
547
546
|
@fully_qualified_name.setter
|
|
548
|
-
def fully_qualified_name(self, value: Optional[pulumi.Input[
|
|
547
|
+
def fully_qualified_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
549
548
|
pulumi.set(self, "fully_qualified_name", value)
|
|
550
549
|
|
|
551
|
-
@property
|
|
550
|
+
@_builtins.property
|
|
552
551
|
@pulumi.getter
|
|
553
|
-
def handler(self) -> Optional[pulumi.Input[
|
|
552
|
+
def handler(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
554
553
|
"""
|
|
555
554
|
Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
556
555
|
"""
|
|
557
556
|
return pulumi.get(self, "handler")
|
|
558
557
|
|
|
559
558
|
@handler.setter
|
|
560
|
-
def handler(self, value: Optional[pulumi.Input[
|
|
559
|
+
def handler(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
561
560
|
pulumi.set(self, "handler", value)
|
|
562
561
|
|
|
563
|
-
@property
|
|
562
|
+
@_builtins.property
|
|
564
563
|
@pulumi.getter
|
|
565
564
|
def imports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]]:
|
|
566
565
|
"""
|
|
@@ -572,79 +571,79 @@ class _ProcedurePythonState:
|
|
|
572
571
|
def imports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonImportArgs']]]]):
|
|
573
572
|
pulumi.set(self, "imports", value)
|
|
574
573
|
|
|
575
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
576
575
|
@pulumi.getter(name="isSecure")
|
|
577
|
-
def is_secure(self) -> Optional[pulumi.Input[
|
|
576
|
+
def is_secure(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
578
577
|
"""
|
|
579
578
|
(Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
580
579
|
"""
|
|
581
580
|
return pulumi.get(self, "is_secure")
|
|
582
581
|
|
|
583
582
|
@is_secure.setter
|
|
584
|
-
def is_secure(self, value: Optional[pulumi.Input[
|
|
583
|
+
def is_secure(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
585
584
|
pulumi.set(self, "is_secure", value)
|
|
586
585
|
|
|
587
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
588
587
|
@pulumi.getter(name="logLevel")
|
|
589
|
-
def log_level(self) -> Optional[pulumi.Input[
|
|
588
|
+
def log_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
590
589
|
"""
|
|
591
590
|
LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
592
591
|
"""
|
|
593
592
|
return pulumi.get(self, "log_level")
|
|
594
593
|
|
|
595
594
|
@log_level.setter
|
|
596
|
-
def log_level(self, value: Optional[pulumi.Input[
|
|
595
|
+
def log_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
597
596
|
pulumi.set(self, "log_level", value)
|
|
598
597
|
|
|
599
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
600
599
|
@pulumi.getter(name="metricLevel")
|
|
601
|
-
def metric_level(self) -> Optional[pulumi.Input[
|
|
600
|
+
def metric_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
602
601
|
"""
|
|
603
602
|
METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
604
603
|
"""
|
|
605
604
|
return pulumi.get(self, "metric_level")
|
|
606
605
|
|
|
607
606
|
@metric_level.setter
|
|
608
|
-
def metric_level(self, value: Optional[pulumi.Input[
|
|
607
|
+
def metric_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
609
608
|
pulumi.set(self, "metric_level", value)
|
|
610
609
|
|
|
611
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
612
611
|
@pulumi.getter
|
|
613
|
-
def name(self) -> Optional[pulumi.Input[
|
|
612
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
614
613
|
"""
|
|
615
614
|
The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
616
615
|
"""
|
|
617
616
|
return pulumi.get(self, "name")
|
|
618
617
|
|
|
619
618
|
@name.setter
|
|
620
|
-
def name(self, value: Optional[pulumi.Input[
|
|
619
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
621
620
|
pulumi.set(self, "name", value)
|
|
622
621
|
|
|
623
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
624
623
|
@pulumi.getter(name="nullInputBehavior")
|
|
625
|
-
def null_input_behavior(self) -> Optional[pulumi.Input[
|
|
624
|
+
def null_input_behavior(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
626
625
|
"""
|
|
627
626
|
Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
628
627
|
"""
|
|
629
628
|
return pulumi.get(self, "null_input_behavior")
|
|
630
629
|
|
|
631
630
|
@null_input_behavior.setter
|
|
632
|
-
def null_input_behavior(self, value: Optional[pulumi.Input[
|
|
631
|
+
def null_input_behavior(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
633
632
|
pulumi.set(self, "null_input_behavior", value)
|
|
634
633
|
|
|
635
|
-
@property
|
|
634
|
+
@_builtins.property
|
|
636
635
|
@pulumi.getter
|
|
637
|
-
def packages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
636
|
+
def packages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
638
637
|
"""
|
|
639
638
|
List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
640
639
|
"""
|
|
641
640
|
return pulumi.get(self, "packages")
|
|
642
641
|
|
|
643
642
|
@packages.setter
|
|
644
|
-
def packages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
643
|
+
def packages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
645
644
|
pulumi.set(self, "packages", value)
|
|
646
645
|
|
|
647
|
-
@property
|
|
646
|
+
@_builtins.property
|
|
648
647
|
@pulumi.getter
|
|
649
648
|
def parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonParameterArgs']]]]:
|
|
650
649
|
"""
|
|
@@ -656,67 +655,67 @@ class _ProcedurePythonState:
|
|
|
656
655
|
def parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonParameterArgs']]]]):
|
|
657
656
|
pulumi.set(self, "parameters", value)
|
|
658
657
|
|
|
659
|
-
@property
|
|
658
|
+
@_builtins.property
|
|
660
659
|
@pulumi.getter(name="procedureDefinition")
|
|
661
|
-
def procedure_definition(self) -> Optional[pulumi.Input[
|
|
660
|
+
def procedure_definition(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
662
661
|
"""
|
|
663
662
|
Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
664
663
|
"""
|
|
665
664
|
return pulumi.get(self, "procedure_definition")
|
|
666
665
|
|
|
667
666
|
@procedure_definition.setter
|
|
668
|
-
def procedure_definition(self, value: Optional[pulumi.Input[
|
|
667
|
+
def procedure_definition(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
669
668
|
pulumi.set(self, "procedure_definition", value)
|
|
670
669
|
|
|
671
|
-
@property
|
|
670
|
+
@_builtins.property
|
|
672
671
|
@pulumi.getter(name="procedureLanguage")
|
|
673
|
-
def procedure_language(self) -> Optional[pulumi.Input[
|
|
672
|
+
def procedure_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
674
673
|
"""
|
|
675
674
|
Specifies language for the procedure. Used to detect external changes.
|
|
676
675
|
"""
|
|
677
676
|
return pulumi.get(self, "procedure_language")
|
|
678
677
|
|
|
679
678
|
@procedure_language.setter
|
|
680
|
-
def procedure_language(self, value: Optional[pulumi.Input[
|
|
679
|
+
def procedure_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
681
680
|
pulumi.set(self, "procedure_language", value)
|
|
682
681
|
|
|
683
|
-
@property
|
|
682
|
+
@_builtins.property
|
|
684
683
|
@pulumi.getter(name="returnType")
|
|
685
|
-
def return_type(self) -> Optional[pulumi.Input[
|
|
684
|
+
def return_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
686
685
|
"""
|
|
687
686
|
Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
688
687
|
"""
|
|
689
688
|
return pulumi.get(self, "return_type")
|
|
690
689
|
|
|
691
690
|
@return_type.setter
|
|
692
|
-
def return_type(self, value: Optional[pulumi.Input[
|
|
691
|
+
def return_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
693
692
|
pulumi.set(self, "return_type", value)
|
|
694
693
|
|
|
695
|
-
@property
|
|
694
|
+
@_builtins.property
|
|
696
695
|
@pulumi.getter(name="runtimeVersion")
|
|
697
|
-
def runtime_version(self) -> Optional[pulumi.Input[
|
|
696
|
+
def runtime_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
698
697
|
"""
|
|
699
698
|
The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
700
699
|
"""
|
|
701
700
|
return pulumi.get(self, "runtime_version")
|
|
702
701
|
|
|
703
702
|
@runtime_version.setter
|
|
704
|
-
def runtime_version(self, value: Optional[pulumi.Input[
|
|
703
|
+
def runtime_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
705
704
|
pulumi.set(self, "runtime_version", value)
|
|
706
705
|
|
|
707
|
-
@property
|
|
706
|
+
@_builtins.property
|
|
708
707
|
@pulumi.getter
|
|
709
|
-
def schema(self) -> Optional[pulumi.Input[
|
|
708
|
+
def schema(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
710
709
|
"""
|
|
711
710
|
The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
712
711
|
"""
|
|
713
712
|
return pulumi.get(self, "schema")
|
|
714
713
|
|
|
715
714
|
@schema.setter
|
|
716
|
-
def schema(self, value: Optional[pulumi.Input[
|
|
715
|
+
def schema(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
717
716
|
pulumi.set(self, "schema", value)
|
|
718
717
|
|
|
719
|
-
@property
|
|
718
|
+
@_builtins.property
|
|
720
719
|
@pulumi.getter
|
|
721
720
|
def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]]:
|
|
722
721
|
"""
|
|
@@ -728,7 +727,7 @@ class _ProcedurePythonState:
|
|
|
728
727
|
def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonSecretArgs']]]]):
|
|
729
728
|
pulumi.set(self, "secrets", value)
|
|
730
729
|
|
|
731
|
-
@property
|
|
730
|
+
@_builtins.property
|
|
732
731
|
@pulumi.getter(name="showOutputs")
|
|
733
732
|
def show_outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonShowOutputArgs']]]]:
|
|
734
733
|
"""
|
|
@@ -740,28 +739,28 @@ class _ProcedurePythonState:
|
|
|
740
739
|
def show_outputs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProcedurePythonShowOutputArgs']]]]):
|
|
741
740
|
pulumi.set(self, "show_outputs", value)
|
|
742
741
|
|
|
743
|
-
@property
|
|
742
|
+
@_builtins.property
|
|
744
743
|
@pulumi.getter(name="snowparkPackage")
|
|
745
|
-
def snowpark_package(self) -> Optional[pulumi.Input[
|
|
744
|
+
def snowpark_package(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
746
745
|
"""
|
|
747
746
|
The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
748
747
|
"""
|
|
749
748
|
return pulumi.get(self, "snowpark_package")
|
|
750
749
|
|
|
751
750
|
@snowpark_package.setter
|
|
752
|
-
def snowpark_package(self, value: Optional[pulumi.Input[
|
|
751
|
+
def snowpark_package(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
753
752
|
pulumi.set(self, "snowpark_package", value)
|
|
754
753
|
|
|
755
|
-
@property
|
|
754
|
+
@_builtins.property
|
|
756
755
|
@pulumi.getter(name="traceLevel")
|
|
757
|
-
def trace_level(self) -> Optional[pulumi.Input[
|
|
756
|
+
def trace_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
758
757
|
"""
|
|
759
758
|
Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
760
759
|
"""
|
|
761
760
|
return pulumi.get(self, "trace_level")
|
|
762
761
|
|
|
763
762
|
@trace_level.setter
|
|
764
|
-
def trace_level(self, value: Optional[pulumi.Input[
|
|
763
|
+
def trace_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
765
764
|
pulumi.set(self, "trace_level", value)
|
|
766
765
|
|
|
767
766
|
|
|
@@ -772,26 +771,26 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
772
771
|
resource_name: str,
|
|
773
772
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
774
773
|
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonArgumentArgs', 'ProcedurePythonArgumentArgsDict']]]]] = None,
|
|
775
|
-
comment: Optional[pulumi.Input[
|
|
776
|
-
database: Optional[pulumi.Input[
|
|
777
|
-
enable_console_output: Optional[pulumi.Input[
|
|
778
|
-
execute_as: Optional[pulumi.Input[
|
|
779
|
-
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
780
|
-
handler: Optional[pulumi.Input[
|
|
774
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
775
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
776
|
+
enable_console_output: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
777
|
+
execute_as: Optional[pulumi.Input[_builtins.str]] = None,
|
|
778
|
+
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
779
|
+
handler: Optional[pulumi.Input[_builtins.str]] = None,
|
|
781
780
|
imports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonImportArgs', 'ProcedurePythonImportArgsDict']]]]] = None,
|
|
782
|
-
is_secure: Optional[pulumi.Input[
|
|
783
|
-
log_level: Optional[pulumi.Input[
|
|
784
|
-
metric_level: Optional[pulumi.Input[
|
|
785
|
-
name: Optional[pulumi.Input[
|
|
786
|
-
null_input_behavior: Optional[pulumi.Input[
|
|
787
|
-
packages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
788
|
-
procedure_definition: Optional[pulumi.Input[
|
|
789
|
-
return_type: Optional[pulumi.Input[
|
|
790
|
-
runtime_version: Optional[pulumi.Input[
|
|
791
|
-
schema: Optional[pulumi.Input[
|
|
781
|
+
is_secure: Optional[pulumi.Input[_builtins.str]] = None,
|
|
782
|
+
log_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
783
|
+
metric_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
784
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
785
|
+
null_input_behavior: Optional[pulumi.Input[_builtins.str]] = None,
|
|
786
|
+
packages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
787
|
+
procedure_definition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
788
|
+
return_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
789
|
+
runtime_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
790
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
792
791
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonSecretArgs', 'ProcedurePythonSecretArgsDict']]]]] = None,
|
|
793
|
-
snowpark_package: Optional[pulumi.Input[
|
|
794
|
-
trace_level: Optional[pulumi.Input[
|
|
792
|
+
snowpark_package: Optional[pulumi.Input[_builtins.str]] = None,
|
|
793
|
+
trace_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
795
794
|
__props__=None):
|
|
796
795
|
"""
|
|
797
796
|
## Import
|
|
@@ -807,26 +806,26 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
807
806
|
:param str resource_name: The name of the resource.
|
|
808
807
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
809
808
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonArgumentArgs', 'ProcedurePythonArgumentArgsDict']]]] arguments: List of the arguments for the procedure. Consult the [docs](https://docs.snowflake.com/en/sql-reference/sql/create-procedure#all-languages) for more details.
|
|
810
|
-
:param pulumi.Input[
|
|
811
|
-
:param pulumi.Input[
|
|
812
|
-
:param pulumi.Input[
|
|
813
|
-
:param pulumi.Input[
|
|
814
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
815
|
-
:param pulumi.Input[
|
|
809
|
+
:param pulumi.Input[_builtins.str] comment: (Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
810
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
811
|
+
:param pulumi.Input[_builtins.bool] enable_console_output: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
812
|
+
:param pulumi.Input[_builtins.str] execute_as: Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
813
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] external_access_integrations: The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
814
|
+
:param pulumi.Input[_builtins.str] handler: Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
816
815
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonImportArgs', 'ProcedurePythonImportArgsDict']]]] imports: The location (stage), path, and name of the file(s) to import. You must set the IMPORTS clause to include any files that your stored procedure depends on. If you are writing an in-line stored procedure, you can omit this clause, unless your code depends on classes defined outside the stored procedure or resource files. If your stored procedure’s code will be on a stage, you must also include a path to the module file your code is in. The IMPORTS definition cannot reference variables from arguments that are passed into the stored procedure. Each file in the IMPORTS clause must have a unique name, even if the files are in different subdirectories or different stages.
|
|
817
|
-
:param pulumi.Input[
|
|
818
|
-
:param pulumi.Input[
|
|
819
|
-
:param pulumi.Input[
|
|
820
|
-
:param pulumi.Input[
|
|
821
|
-
:param pulumi.Input[
|
|
822
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
823
|
-
:param pulumi.Input[
|
|
824
|
-
:param pulumi.Input[
|
|
825
|
-
:param pulumi.Input[
|
|
826
|
-
:param pulumi.Input[
|
|
816
|
+
:param pulumi.Input[_builtins.str] is_secure: (Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
817
|
+
:param pulumi.Input[_builtins.str] log_level: LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
818
|
+
:param pulumi.Input[_builtins.str] metric_level: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
819
|
+
:param pulumi.Input[_builtins.str] name: The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
820
|
+
:param pulumi.Input[_builtins.str] null_input_behavior: Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
821
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] packages: List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
822
|
+
:param pulumi.Input[_builtins.str] procedure_definition: Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
823
|
+
:param pulumi.Input[_builtins.str] return_type: Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
824
|
+
:param pulumi.Input[_builtins.str] runtime_version: The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
825
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
827
826
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonSecretArgs', 'ProcedurePythonSecretArgsDict']]]] secrets: Assigns the names of [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) to variables so that you can use the variables to reference the secrets when retrieving information from secrets in handler code. Secrets you specify here must be allowed by the [external access integration](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) specified as a value of this CREATE FUNCTION command’s EXTERNAL*ACCESS*INTEGRATIONS parameter.
|
|
828
|
-
:param pulumi.Input[
|
|
829
|
-
:param pulumi.Input[
|
|
827
|
+
:param pulumi.Input[_builtins.str] snowpark_package: The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
828
|
+
:param pulumi.Input[_builtins.str] trace_level: Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
830
829
|
"""
|
|
831
830
|
...
|
|
832
831
|
@overload
|
|
@@ -861,26 +860,26 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
861
860
|
resource_name: str,
|
|
862
861
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
863
862
|
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonArgumentArgs', 'ProcedurePythonArgumentArgsDict']]]]] = None,
|
|
864
|
-
comment: Optional[pulumi.Input[
|
|
865
|
-
database: Optional[pulumi.Input[
|
|
866
|
-
enable_console_output: Optional[pulumi.Input[
|
|
867
|
-
execute_as: Optional[pulumi.Input[
|
|
868
|
-
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
869
|
-
handler: Optional[pulumi.Input[
|
|
863
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
864
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
865
|
+
enable_console_output: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
866
|
+
execute_as: Optional[pulumi.Input[_builtins.str]] = None,
|
|
867
|
+
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
868
|
+
handler: Optional[pulumi.Input[_builtins.str]] = None,
|
|
870
869
|
imports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonImportArgs', 'ProcedurePythonImportArgsDict']]]]] = None,
|
|
871
|
-
is_secure: Optional[pulumi.Input[
|
|
872
|
-
log_level: Optional[pulumi.Input[
|
|
873
|
-
metric_level: Optional[pulumi.Input[
|
|
874
|
-
name: Optional[pulumi.Input[
|
|
875
|
-
null_input_behavior: Optional[pulumi.Input[
|
|
876
|
-
packages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
877
|
-
procedure_definition: Optional[pulumi.Input[
|
|
878
|
-
return_type: Optional[pulumi.Input[
|
|
879
|
-
runtime_version: Optional[pulumi.Input[
|
|
880
|
-
schema: Optional[pulumi.Input[
|
|
870
|
+
is_secure: Optional[pulumi.Input[_builtins.str]] = None,
|
|
871
|
+
log_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
872
|
+
metric_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
873
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
874
|
+
null_input_behavior: Optional[pulumi.Input[_builtins.str]] = None,
|
|
875
|
+
packages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
876
|
+
procedure_definition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
877
|
+
return_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
878
|
+
runtime_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
879
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
881
880
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonSecretArgs', 'ProcedurePythonSecretArgsDict']]]]] = None,
|
|
882
|
-
snowpark_package: Optional[pulumi.Input[
|
|
883
|
-
trace_level: Optional[pulumi.Input[
|
|
881
|
+
snowpark_package: Optional[pulumi.Input[_builtins.str]] = None,
|
|
882
|
+
trace_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
884
883
|
__props__=None):
|
|
885
884
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
886
885
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -938,30 +937,30 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
938
937
|
id: pulumi.Input[str],
|
|
939
938
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
940
939
|
arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonArgumentArgs', 'ProcedurePythonArgumentArgsDict']]]]] = None,
|
|
941
|
-
comment: Optional[pulumi.Input[
|
|
942
|
-
database: Optional[pulumi.Input[
|
|
943
|
-
enable_console_output: Optional[pulumi.Input[
|
|
944
|
-
execute_as: Optional[pulumi.Input[
|
|
945
|
-
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
946
|
-
fully_qualified_name: Optional[pulumi.Input[
|
|
947
|
-
handler: Optional[pulumi.Input[
|
|
940
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
941
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
942
|
+
enable_console_output: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
943
|
+
execute_as: Optional[pulumi.Input[_builtins.str]] = None,
|
|
944
|
+
external_access_integrations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
945
|
+
fully_qualified_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
946
|
+
handler: Optional[pulumi.Input[_builtins.str]] = None,
|
|
948
947
|
imports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonImportArgs', 'ProcedurePythonImportArgsDict']]]]] = None,
|
|
949
|
-
is_secure: Optional[pulumi.Input[
|
|
950
|
-
log_level: Optional[pulumi.Input[
|
|
951
|
-
metric_level: Optional[pulumi.Input[
|
|
952
|
-
name: Optional[pulumi.Input[
|
|
953
|
-
null_input_behavior: Optional[pulumi.Input[
|
|
954
|
-
packages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
948
|
+
is_secure: Optional[pulumi.Input[_builtins.str]] = None,
|
|
949
|
+
log_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
950
|
+
metric_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
951
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
952
|
+
null_input_behavior: Optional[pulumi.Input[_builtins.str]] = None,
|
|
953
|
+
packages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
955
954
|
parameters: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonParameterArgs', 'ProcedurePythonParameterArgsDict']]]]] = None,
|
|
956
|
-
procedure_definition: Optional[pulumi.Input[
|
|
957
|
-
procedure_language: Optional[pulumi.Input[
|
|
958
|
-
return_type: Optional[pulumi.Input[
|
|
959
|
-
runtime_version: Optional[pulumi.Input[
|
|
960
|
-
schema: Optional[pulumi.Input[
|
|
955
|
+
procedure_definition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
956
|
+
procedure_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
957
|
+
return_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
958
|
+
runtime_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
959
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
961
960
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonSecretArgs', 'ProcedurePythonSecretArgsDict']]]]] = None,
|
|
962
961
|
show_outputs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonShowOutputArgs', 'ProcedurePythonShowOutputArgsDict']]]]] = None,
|
|
963
|
-
snowpark_package: Optional[pulumi.Input[
|
|
964
|
-
trace_level: Optional[pulumi.Input[
|
|
962
|
+
snowpark_package: Optional[pulumi.Input[_builtins.str]] = None,
|
|
963
|
+
trace_level: Optional[pulumi.Input[_builtins.str]] = None) -> 'ProcedurePython':
|
|
965
964
|
"""
|
|
966
965
|
Get an existing ProcedurePython resource's state with the given name, id, and optional extra
|
|
967
966
|
properties used to qualify the lookup.
|
|
@@ -970,30 +969,30 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
970
969
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
971
970
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
972
971
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonArgumentArgs', 'ProcedurePythonArgumentArgsDict']]]] arguments: List of the arguments for the procedure. Consult the [docs](https://docs.snowflake.com/en/sql-reference/sql/create-procedure#all-languages) for more details.
|
|
973
|
-
:param pulumi.Input[
|
|
974
|
-
:param pulumi.Input[
|
|
975
|
-
:param pulumi.Input[
|
|
976
|
-
:param pulumi.Input[
|
|
977
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
978
|
-
:param pulumi.Input[
|
|
979
|
-
:param pulumi.Input[
|
|
972
|
+
:param pulumi.Input[_builtins.str] comment: (Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
973
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
974
|
+
:param pulumi.Input[_builtins.bool] enable_console_output: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
975
|
+
:param pulumi.Input[_builtins.str] execute_as: Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
976
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] external_access_integrations: The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
977
|
+
:param pulumi.Input[_builtins.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).
|
|
978
|
+
:param pulumi.Input[_builtins.str] handler: Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
980
979
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonImportArgs', 'ProcedurePythonImportArgsDict']]]] imports: The location (stage), path, and name of the file(s) to import. You must set the IMPORTS clause to include any files that your stored procedure depends on. If you are writing an in-line stored procedure, you can omit this clause, unless your code depends on classes defined outside the stored procedure or resource files. If your stored procedure’s code will be on a stage, you must also include a path to the module file your code is in. The IMPORTS definition cannot reference variables from arguments that are passed into the stored procedure. Each file in the IMPORTS clause must have a unique name, even if the files are in different subdirectories or different stages.
|
|
981
|
-
:param pulumi.Input[
|
|
982
|
-
:param pulumi.Input[
|
|
983
|
-
:param pulumi.Input[
|
|
984
|
-
:param pulumi.Input[
|
|
985
|
-
:param pulumi.Input[
|
|
986
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
980
|
+
:param pulumi.Input[_builtins.str] is_secure: (Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
981
|
+
:param pulumi.Input[_builtins.str] log_level: LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
982
|
+
:param pulumi.Input[_builtins.str] metric_level: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
983
|
+
:param pulumi.Input[_builtins.str] name: The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
984
|
+
:param pulumi.Input[_builtins.str] null_input_behavior: Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
985
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] packages: List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
987
986
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonParameterArgs', 'ProcedurePythonParameterArgsDict']]]] parameters: Outputs the result of `SHOW PARAMETERS IN PROCEDURE` for the given procedure.
|
|
988
|
-
:param pulumi.Input[
|
|
989
|
-
:param pulumi.Input[
|
|
990
|
-
:param pulumi.Input[
|
|
991
|
-
:param pulumi.Input[
|
|
992
|
-
:param pulumi.Input[
|
|
987
|
+
:param pulumi.Input[_builtins.str] procedure_definition: Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
988
|
+
:param pulumi.Input[_builtins.str] procedure_language: Specifies language for the procedure. Used to detect external changes.
|
|
989
|
+
:param pulumi.Input[_builtins.str] return_type: Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
990
|
+
:param pulumi.Input[_builtins.str] runtime_version: The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
991
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
993
992
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonSecretArgs', 'ProcedurePythonSecretArgsDict']]]] secrets: Assigns the names of [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) to variables so that you can use the variables to reference the secrets when retrieving information from secrets in handler code. Secrets you specify here must be allowed by the [external access integration](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) specified as a value of this CREATE FUNCTION command’s EXTERNAL*ACCESS*INTEGRATIONS parameter.
|
|
994
993
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ProcedurePythonShowOutputArgs', 'ProcedurePythonShowOutputArgsDict']]]] show_outputs: Outputs the result of `SHOW PROCEDURE` for the given procedure.
|
|
995
|
-
:param pulumi.Input[
|
|
996
|
-
:param pulumi.Input[
|
|
994
|
+
:param pulumi.Input[_builtins.str] snowpark_package: The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
995
|
+
:param pulumi.Input[_builtins.str] trace_level: Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
997
996
|
"""
|
|
998
997
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
999
998
|
|
|
@@ -1026,7 +1025,7 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1026
1025
|
__props__.__dict__["trace_level"] = trace_level
|
|
1027
1026
|
return ProcedurePython(resource_name, opts=opts, __props__=__props__)
|
|
1028
1027
|
|
|
1029
|
-
@property
|
|
1028
|
+
@_builtins.property
|
|
1030
1029
|
@pulumi.getter
|
|
1031
1030
|
def arguments(self) -> pulumi.Output[Optional[Sequence['outputs.ProcedurePythonArgument']]]:
|
|
1032
1031
|
"""
|
|
@@ -1034,63 +1033,63 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1034
1033
|
"""
|
|
1035
1034
|
return pulumi.get(self, "arguments")
|
|
1036
1035
|
|
|
1037
|
-
@property
|
|
1036
|
+
@_builtins.property
|
|
1038
1037
|
@pulumi.getter
|
|
1039
|
-
def comment(self) -> pulumi.Output[Optional[
|
|
1038
|
+
def comment(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1040
1039
|
"""
|
|
1041
1040
|
(Default: `user-defined procedure`) Specifies a comment for the procedure.
|
|
1042
1041
|
"""
|
|
1043
1042
|
return pulumi.get(self, "comment")
|
|
1044
1043
|
|
|
1045
|
-
@property
|
|
1044
|
+
@_builtins.property
|
|
1046
1045
|
@pulumi.getter
|
|
1047
|
-
def database(self) -> pulumi.Output[
|
|
1046
|
+
def database(self) -> pulumi.Output[_builtins.str]:
|
|
1048
1047
|
"""
|
|
1049
1048
|
The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
1050
1049
|
"""
|
|
1051
1050
|
return pulumi.get(self, "database")
|
|
1052
1051
|
|
|
1053
|
-
@property
|
|
1052
|
+
@_builtins.property
|
|
1054
1053
|
@pulumi.getter(name="enableConsoleOutput")
|
|
1055
|
-
def enable_console_output(self) -> pulumi.Output[
|
|
1054
|
+
def enable_console_output(self) -> pulumi.Output[_builtins.bool]:
|
|
1056
1055
|
"""
|
|
1057
1056
|
Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOG*LEVEL). For more information, check [ENABLE*CONSOLE_OUTPUT docs](https://docs.snowflake.com/en/sql-reference/parameters#enable-console-output).
|
|
1058
1057
|
"""
|
|
1059
1058
|
return pulumi.get(self, "enable_console_output")
|
|
1060
1059
|
|
|
1061
|
-
@property
|
|
1060
|
+
@_builtins.property
|
|
1062
1061
|
@pulumi.getter(name="executeAs")
|
|
1063
|
-
def execute_as(self) -> pulumi.Output[Optional[
|
|
1062
|
+
def execute_as(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1064
1063
|
"""
|
|
1065
1064
|
Specifies whether the stored procedure executes with the privileges of the owner (an “owner’s rights” stored procedure) or with the privileges of the caller (a “caller’s rights” stored procedure). If you execute the statement CREATE PROCEDURE … EXECUTE AS CALLER, then in the future the procedure will execute as a caller’s rights procedure. If you execute CREATE PROCEDURE … EXECUTE AS OWNER, then the procedure will execute as an owner’s rights procedure. For more information, see [Understanding caller’s rights and owner’s rights stored procedures](https://docs.snowflake.com/en/developer-guide/stored-procedure/stored-procedures-rights). Valid values are (case-insensitive): `CALLER` | `OWNER`.
|
|
1066
1065
|
"""
|
|
1067
1066
|
return pulumi.get(self, "execute_as")
|
|
1068
1067
|
|
|
1069
|
-
@property
|
|
1068
|
+
@_builtins.property
|
|
1070
1069
|
@pulumi.getter(name="externalAccessIntegrations")
|
|
1071
|
-
def external_access_integrations(self) -> pulumi.Output[Optional[Sequence[
|
|
1070
|
+
def external_access_integrations(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1072
1071
|
"""
|
|
1073
1072
|
The names of [external access integrations](https://docs.snowflake.com/en/sql-reference/sql/create-external-access-integration) needed in order for this procedure’s handler code to access external networks. An external access integration specifies [network rules](https://docs.snowflake.com/en/sql-reference/sql/create-network-rule) and [secrets](https://docs.snowflake.com/en/sql-reference/sql/create-secret) that specify external locations and credentials (if any) allowed for use by handler code when making requests of an external network, such as an external REST API.
|
|
1074
1073
|
"""
|
|
1075
1074
|
return pulumi.get(self, "external_access_integrations")
|
|
1076
1075
|
|
|
1077
|
-
@property
|
|
1076
|
+
@_builtins.property
|
|
1078
1077
|
@pulumi.getter(name="fullyQualifiedName")
|
|
1079
|
-
def fully_qualified_name(self) -> pulumi.Output[
|
|
1078
|
+
def fully_qualified_name(self) -> pulumi.Output[_builtins.str]:
|
|
1080
1079
|
"""
|
|
1081
1080
|
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
1082
1081
|
"""
|
|
1083
1082
|
return pulumi.get(self, "fully_qualified_name")
|
|
1084
1083
|
|
|
1085
|
-
@property
|
|
1084
|
+
@_builtins.property
|
|
1086
1085
|
@pulumi.getter
|
|
1087
|
-
def handler(self) -> pulumi.Output[
|
|
1086
|
+
def handler(self) -> pulumi.Output[_builtins.str]:
|
|
1088
1087
|
"""
|
|
1089
1088
|
Use the name of the stored procedure’s function or method. This can differ depending on whether the code is in-line or referenced at a stage. When the code is in-line, you can specify just the function name. When the code is imported from a stage, specify the fully-qualified handler function name as `<module_name>.<function_name>`.
|
|
1090
1089
|
"""
|
|
1091
1090
|
return pulumi.get(self, "handler")
|
|
1092
1091
|
|
|
1093
|
-
@property
|
|
1092
|
+
@_builtins.property
|
|
1094
1093
|
@pulumi.getter
|
|
1095
1094
|
def imports(self) -> pulumi.Output[Optional[Sequence['outputs.ProcedurePythonImport']]]:
|
|
1096
1095
|
"""
|
|
@@ -1098,55 +1097,55 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1098
1097
|
"""
|
|
1099
1098
|
return pulumi.get(self, "imports")
|
|
1100
1099
|
|
|
1101
|
-
@property
|
|
1100
|
+
@_builtins.property
|
|
1102
1101
|
@pulumi.getter(name="isSecure")
|
|
1103
|
-
def is_secure(self) -> pulumi.Output[Optional[
|
|
1102
|
+
def is_secure(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1104
1103
|
"""
|
|
1105
1104
|
(Default: fallback to Snowflake default - uses special value that cannot be set in the configuration manually (`default`)) Specifies that the procedure is secure. For more information about secure procedures, see [Protecting Sensitive Information with Secure UDFs and Stored Procedures](https://docs.snowflake.com/en/developer-guide/secure-udf-procedure). 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.
|
|
1106
1105
|
"""
|
|
1107
1106
|
return pulumi.get(self, "is_secure")
|
|
1108
1107
|
|
|
1109
|
-
@property
|
|
1108
|
+
@_builtins.property
|
|
1110
1109
|
@pulumi.getter(name="logLevel")
|
|
1111
|
-
def log_level(self) -> pulumi.Output[
|
|
1110
|
+
def log_level(self) -> pulumi.Output[_builtins.str]:
|
|
1112
1111
|
"""
|
|
1113
1112
|
LOG*LEVEL to use when filtering events For more information, check [LOG*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#log-level).
|
|
1114
1113
|
"""
|
|
1115
1114
|
return pulumi.get(self, "log_level")
|
|
1116
1115
|
|
|
1117
|
-
@property
|
|
1116
|
+
@_builtins.property
|
|
1118
1117
|
@pulumi.getter(name="metricLevel")
|
|
1119
|
-
def metric_level(self) -> pulumi.Output[
|
|
1118
|
+
def metric_level(self) -> pulumi.Output[_builtins.str]:
|
|
1120
1119
|
"""
|
|
1121
1120
|
METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check [METRIC*LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#metric-level).
|
|
1122
1121
|
"""
|
|
1123
1122
|
return pulumi.get(self, "metric_level")
|
|
1124
1123
|
|
|
1125
|
-
@property
|
|
1124
|
+
@_builtins.property
|
|
1126
1125
|
@pulumi.getter
|
|
1127
|
-
def name(self) -> pulumi.Output[
|
|
1126
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1128
1127
|
"""
|
|
1129
1128
|
The name of the procedure; the identifier does not need to be unique for the schema in which the procedure is created because stored procedures are [identified and resolved by the combination of the name and argument types](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-naming-conventions.html#label-procedure-function-name-overloading). Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
1130
1129
|
"""
|
|
1131
1130
|
return pulumi.get(self, "name")
|
|
1132
1131
|
|
|
1133
|
-
@property
|
|
1132
|
+
@_builtins.property
|
|
1134
1133
|
@pulumi.getter(name="nullInputBehavior")
|
|
1135
|
-
def null_input_behavior(self) -> pulumi.Output[Optional[
|
|
1134
|
+
def null_input_behavior(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1136
1135
|
"""
|
|
1137
1136
|
Specifies the behavior of the procedure when called with null inputs. Valid values are (case-insensitive): `CALLED ON NULL INPUT` | `RETURNS NULL ON NULL INPUT`.
|
|
1138
1137
|
"""
|
|
1139
1138
|
return pulumi.get(self, "null_input_behavior")
|
|
1140
1139
|
|
|
1141
|
-
@property
|
|
1140
|
+
@_builtins.property
|
|
1142
1141
|
@pulumi.getter
|
|
1143
|
-
def packages(self) -> pulumi.Output[Optional[Sequence[
|
|
1142
|
+
def packages(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1144
1143
|
"""
|
|
1145
1144
|
List of the names of packages deployed in Snowflake that should be included in the handler code’s execution environment. The Snowpark package is required for stored procedures, but is specified in the `snowpark_package` attribute. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
1146
1145
|
"""
|
|
1147
1146
|
return pulumi.get(self, "packages")
|
|
1148
1147
|
|
|
1149
|
-
@property
|
|
1148
|
+
@_builtins.property
|
|
1150
1149
|
@pulumi.getter
|
|
1151
1150
|
def parameters(self) -> pulumi.Output[Sequence['outputs.ProcedurePythonParameter']]:
|
|
1152
1151
|
"""
|
|
@@ -1154,47 +1153,47 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1154
1153
|
"""
|
|
1155
1154
|
return pulumi.get(self, "parameters")
|
|
1156
1155
|
|
|
1157
|
-
@property
|
|
1156
|
+
@_builtins.property
|
|
1158
1157
|
@pulumi.getter(name="procedureDefinition")
|
|
1159
|
-
def procedure_definition(self) -> pulumi.Output[Optional[
|
|
1158
|
+
def procedure_definition(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1160
1159
|
"""
|
|
1161
1160
|
Defines the code executed by the stored procedure. The definition can consist of any valid code. Wrapping `$$` signs are added by the provider automatically; do not include them. The `procedure_definition` value must be Python source code. For more information, see [Python (using Snowpark)](https://docs.snowflake.com/en/developer-guide/stored-procedure/python/procedure-python-overview). 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.
|
|
1162
1161
|
"""
|
|
1163
1162
|
return pulumi.get(self, "procedure_definition")
|
|
1164
1163
|
|
|
1165
|
-
@property
|
|
1164
|
+
@_builtins.property
|
|
1166
1165
|
@pulumi.getter(name="procedureLanguage")
|
|
1167
|
-
def procedure_language(self) -> pulumi.Output[
|
|
1166
|
+
def procedure_language(self) -> pulumi.Output[_builtins.str]:
|
|
1168
1167
|
"""
|
|
1169
1168
|
Specifies language for the procedure. Used to detect external changes.
|
|
1170
1169
|
"""
|
|
1171
1170
|
return pulumi.get(self, "procedure_language")
|
|
1172
1171
|
|
|
1173
|
-
@property
|
|
1172
|
+
@_builtins.property
|
|
1174
1173
|
@pulumi.getter(name="returnType")
|
|
1175
|
-
def return_type(self) -> pulumi.Output[
|
|
1174
|
+
def return_type(self) -> pulumi.Output[_builtins.str]:
|
|
1176
1175
|
"""
|
|
1177
1176
|
Specifies the type of the result returned by the stored procedure. For `<result_data_type>`, use the Snowflake data type that corresponds to the type of the language that you are using (see [SQL-Python Data Type Mappings](https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping.html#label-sql-python-data-type-mappings)). For `RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] )`, if you know the Snowflake data types of the columns in the returned table, specify the column names and types. Otherwise (e.g. if you are determining the column types during run time), you can omit the column names and types (i.e. `TABLE ()`).
|
|
1178
1177
|
"""
|
|
1179
1178
|
return pulumi.get(self, "return_type")
|
|
1180
1179
|
|
|
1181
|
-
@property
|
|
1180
|
+
@_builtins.property
|
|
1182
1181
|
@pulumi.getter(name="runtimeVersion")
|
|
1183
|
-
def runtime_version(self) -> pulumi.Output[
|
|
1182
|
+
def runtime_version(self) -> pulumi.Output[_builtins.str]:
|
|
1184
1183
|
"""
|
|
1185
1184
|
The language runtime version to use. Currently, the supported versions are: 3.9, 3.10, and 3.11.
|
|
1186
1185
|
"""
|
|
1187
1186
|
return pulumi.get(self, "runtime_version")
|
|
1188
1187
|
|
|
1189
|
-
@property
|
|
1188
|
+
@_builtins.property
|
|
1190
1189
|
@pulumi.getter
|
|
1191
|
-
def schema(self) -> pulumi.Output[
|
|
1190
|
+
def schema(self) -> pulumi.Output[_builtins.str]:
|
|
1192
1191
|
"""
|
|
1193
1192
|
The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: `|`, `.`, `"`.
|
|
1194
1193
|
"""
|
|
1195
1194
|
return pulumi.get(self, "schema")
|
|
1196
1195
|
|
|
1197
|
-
@property
|
|
1196
|
+
@_builtins.property
|
|
1198
1197
|
@pulumi.getter
|
|
1199
1198
|
def secrets(self) -> pulumi.Output[Optional[Sequence['outputs.ProcedurePythonSecret']]]:
|
|
1200
1199
|
"""
|
|
@@ -1202,7 +1201,7 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1202
1201
|
"""
|
|
1203
1202
|
return pulumi.get(self, "secrets")
|
|
1204
1203
|
|
|
1205
|
-
@property
|
|
1204
|
+
@_builtins.property
|
|
1206
1205
|
@pulumi.getter(name="showOutputs")
|
|
1207
1206
|
def show_outputs(self) -> pulumi.Output[Sequence['outputs.ProcedurePythonShowOutput']]:
|
|
1208
1207
|
"""
|
|
@@ -1210,17 +1209,17 @@ class ProcedurePython(pulumi.CustomResource):
|
|
|
1210
1209
|
"""
|
|
1211
1210
|
return pulumi.get(self, "show_outputs")
|
|
1212
1211
|
|
|
1213
|
-
@property
|
|
1212
|
+
@_builtins.property
|
|
1214
1213
|
@pulumi.getter(name="snowparkPackage")
|
|
1215
|
-
def snowpark_package(self) -> pulumi.Output[
|
|
1214
|
+
def snowpark_package(self) -> pulumi.Output[_builtins.str]:
|
|
1216
1215
|
"""
|
|
1217
1216
|
The Snowpark package is required for stored procedures, so it must always be present. For more information about Snowpark, see [Snowpark API](https://docs.snowflake.com/en/developer-guide/snowpark/index).
|
|
1218
1217
|
"""
|
|
1219
1218
|
return pulumi.get(self, "snowpark_package")
|
|
1220
1219
|
|
|
1221
|
-
@property
|
|
1220
|
+
@_builtins.property
|
|
1222
1221
|
@pulumi.getter(name="traceLevel")
|
|
1223
|
-
def trace_level(self) -> pulumi.Output[
|
|
1222
|
+
def trace_level(self) -> pulumi.Output[_builtins.str]:
|
|
1224
1223
|
"""
|
|
1225
1224
|
Trace level value to use when generating/filtering trace events For more information, check [TRACE_LEVEL docs](https://docs.snowflake.com/en/sql-reference/parameters#trace-level).
|
|
1226
1225
|
"""
|