Snowflake v1.1.4, Mar 26 25

Snowflake v1.1.4 published on Wednesday, Mar 26, 2025 by Pulumi

snowflake.ProcedureSql

Explore with Pulumi AI

Snowflake v1.1.4 published on Wednesday, Mar 26, 2025 by Pulumi

Import

$ pulumi import snowflake:index/procedureSql:ProcedureSql example '"<database_name>"."<schema_name>"."<function_name>"(varchar, varchar, varchar)'

Note: Snowflake is not returning all information needed to populate the state correctly after import (e.g. data types with attributes like NUMBER(32, 10) are returned as NUMBER, default values for arguments are not returned at all).

Also, ALTER for functions is very limited so most of the attributes on this resource are marked as force new. Because of that, in multiple situations plan won’t be empty after importing and manual state operations may be required.

Create ProcedureSql Resource

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

Constructor syntax

new ProcedureSql(name: string, args: ProcedureSqlArgs, opts?: CustomResourceOptions);

@overload
def ProcedureSql(resource_name: str,
                 args: ProcedureSqlArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def ProcedureSql(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 procedure_definition: Optional[str] = None,
                 schema: Optional[str] = None,
                 database: Optional[str] = None,
                 return_type: Optional[str] = None,
                 log_level: Optional[str] = None,
                 is_secure: Optional[str] = None,
                 arguments: Optional[Sequence[ProcedureSqlArgumentArgs]] = None,
                 metric_level: Optional[str] = None,
                 name: Optional[str] = None,
                 null_input_behavior: Optional[str] = None,
                 execute_as: Optional[str] = None,
                 enable_console_output: Optional[bool] = None,
                 comment: Optional[str] = None,
                 trace_level: Optional[str] = None)

func NewProcedureSql(ctx *Context, name string, args ProcedureSqlArgs, opts ...ResourceOption) (*ProcedureSql, error)

public ProcedureSql(string name, ProcedureSqlArgs args, CustomResourceOptions? opts = null)

public ProcedureSql(String name, ProcedureSqlArgs args)
public ProcedureSql(String name, ProcedureSqlArgs args, CustomResourceOptions options)

type: snowflake:ProcedureSql
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name string: The unique name of the resource.
args ProcedureSqlArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args ProcedureSqlArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args ProcedureSqlArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ProcedureSqlArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args ProcedureSqlArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

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

var procedureSqlResource = new Snowflake.ProcedureSql("procedureSqlResource", new()
{
    ProcedureDefinition = "string",
    Schema = "string",
    Database = "string",
    ReturnType = "string",
    LogLevel = "string",
    IsSecure = "string",
    Arguments = new[]
    {
        new Snowflake.Inputs.ProcedureSqlArgumentArgs
        {
            ArgDataType = "string",
            ArgName = "string",
            ArgDefaultValue = "string",
        },
    },
    MetricLevel = "string",
    Name = "string",
    NullInputBehavior = "string",
    ExecuteAs = "string",
    EnableConsoleOutput = false,
    Comment = "string",
    TraceLevel = "string",
});

example, err := snowflake.NewProcedureSql(ctx, "procedureSqlResource", &snowflake.ProcedureSqlArgs{
	ProcedureDefinition: pulumi.String("string"),
	Schema:              pulumi.String("string"),
	Database:            pulumi.String("string"),
	ReturnType:          pulumi.String("string"),
	LogLevel:            pulumi.String("string"),
	IsSecure:            pulumi.String("string"),
	Arguments: snowflake.ProcedureSqlArgumentArray{
		&snowflake.ProcedureSqlArgumentArgs{
			ArgDataType:     pulumi.String("string"),
			ArgName:         pulumi.String("string"),
			ArgDefaultValue: pulumi.String("string"),
		},
	},
	MetricLevel:         pulumi.String("string"),
	Name:                pulumi.String("string"),
	NullInputBehavior:   pulumi.String("string"),
	ExecuteAs:           pulumi.String("string"),
	EnableConsoleOutput: pulumi.Bool(false),
	Comment:             pulumi.String("string"),
	TraceLevel:          pulumi.String("string"),
})

var procedureSqlResource = new ProcedureSql("procedureSqlResource", ProcedureSqlArgs.builder()
    .procedureDefinition("string")
    .schema("string")
    .database("string")
    .returnType("string")
    .logLevel("string")
    .isSecure("string")
    .arguments(ProcedureSqlArgumentArgs.builder()
        .argDataType("string")
        .argName("string")
        .argDefaultValue("string")
        .build())
    .metricLevel("string")
    .name("string")
    .nullInputBehavior("string")
    .executeAs("string")
    .enableConsoleOutput(false)
    .comment("string")
    .traceLevel("string")
    .build());

procedure_sql_resource = snowflake.ProcedureSql("procedureSqlResource",
    procedure_definition="string",
    schema="string",
    database="string",
    return_type="string",
    log_level="string",
    is_secure="string",
    arguments=[{
        "arg_data_type": "string",
        "arg_name": "string",
        "arg_default_value": "string",
    }],
    metric_level="string",
    name="string",
    null_input_behavior="string",
    execute_as="string",
    enable_console_output=False,
    comment="string",
    trace_level="string")

const procedureSqlResource = new snowflake.ProcedureSql("procedureSqlResource", {
    procedureDefinition: "string",
    schema: "string",
    database: "string",
    returnType: "string",
    logLevel: "string",
    isSecure: "string",
    arguments: [{
        argDataType: "string",
        argName: "string",
        argDefaultValue: "string",
    }],
    metricLevel: "string",
    name: "string",
    nullInputBehavior: "string",
    executeAs: "string",
    enableConsoleOutput: false,
    comment: "string",
    traceLevel: "string",
});

type: snowflake:ProcedureSql
properties:
    arguments:
        - argDataType: string
          argDefaultValue: string
          argName: string
    comment: string
    database: string
    enableConsoleOutput: false
    executeAs: string
    isSecure: string
    logLevel: string
    metricLevel: string
    name: string
    nullInputBehavior: string
    procedureDefinition: string
    returnType: string
    schema: string
    traceLevel: string

ProcedureSql Resource Properties

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

Inputs

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

The ProcedureSql resource accepts the following input properties:

Database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
ProcedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
ReturnType string: 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 data type). 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 ()).
Schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
Arguments List<ProcedureSqlArgument>: List of the arguments for the procedure. Consult the docs for more details.
Comment string: Specifies a comment for the procedure.
EnableConsoleOutput bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
ExecuteAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
IsSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
LogLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
MetricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
Name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
NullInputBehavior string: 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.
TraceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

Database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
ProcedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
ReturnType string: 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 data type). 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 ()).
Schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
Arguments []ProcedureSqlArgumentArgs: List of the arguments for the procedure. Consult the docs for more details.
Comment string: Specifies a comment for the procedure.
EnableConsoleOutput bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
ExecuteAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
IsSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
LogLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
MetricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
Name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
NullInputBehavior string: 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.
TraceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

database String: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
procedureDefinition String: 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 SQL source code. For more information, see Snowflake Scripting. 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.
returnType String: 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 data type). 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 ()).
schema String: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
arguments List<ProcedureSqlArgument>: List of the arguments for the procedure. Consult the docs for more details.
comment String: Specifies a comment for the procedure.
enableConsoleOutput Boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs String: 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. Valid values are (case-insensitive): CALLER | OWNER.
isSecure String: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel String: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel String: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name String: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior String: 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.
traceLevel String: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
procedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
returnType string: 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 data type). 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 ()).
schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
arguments ProcedureSqlArgument[]: List of the arguments for the procedure. Consult the docs for more details.
comment string: Specifies a comment for the procedure.
enableConsoleOutput boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
isSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior string: 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.
traceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

database str: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
procedure_definition str: 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 SQL source code. For more information, see Snowflake Scripting. 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.
return_type str: 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 data type). 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 ()).
schema str: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
arguments Sequence[ProcedureSqlArgumentArgs]: List of the arguments for the procedure. Consult the docs for more details.
comment str: Specifies a comment for the procedure.
enable_console_output bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
execute_as str: 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. Valid values are (case-insensitive): CALLER | OWNER.
is_secure str: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
log_level str: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metric_level str: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name str: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
null_input_behavior str: 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.
trace_level str: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

database String: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
procedureDefinition String: 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 SQL source code. For more information, see Snowflake Scripting. 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.
returnType String: 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 data type). 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 ()).
schema String: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
arguments List<Property Map>: List of the arguments for the procedure. Consult the docs for more details.
comment String: Specifies a comment for the procedure.
enableConsoleOutput Boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs String: 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. Valid values are (case-insensitive): CALLER | OWNER.
isSecure String: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel String: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel String: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name String: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior String: 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.
traceLevel String: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

Outputs

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

FullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
Id string: The provider-assigned unique ID for this managed resource.
Parameters List<ProcedureSqlParameter>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
ProcedureLanguage string: Specifies language for the procedure. Used to detect external changes.
ShowOutputs List<ProcedureSqlShowOutput>: Outputs the result of SHOW PROCEDURE for the given procedure.

FullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
Id string: The provider-assigned unique ID for this managed resource.
Parameters []ProcedureSqlParameter: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
ProcedureLanguage string: Specifies language for the procedure. Used to detect external changes.
ShowOutputs []ProcedureSqlShowOutput: Outputs the result of SHOW PROCEDURE for the given procedure.

fullyQualifiedName String: Fully qualified name of the resource. For more information, see object name resolution.
id String: The provider-assigned unique ID for this managed resource.
parameters List<ProcedureSqlParameter>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureLanguage String: Specifies language for the procedure. Used to detect external changes.
showOutputs List<ProcedureSqlShowOutput>: Outputs the result of SHOW PROCEDURE for the given procedure.

fullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
id string: The provider-assigned unique ID for this managed resource.
parameters ProcedureSqlParameter[]: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureLanguage string: Specifies language for the procedure. Used to detect external changes.
showOutputs ProcedureSqlShowOutput[]: Outputs the result of SHOW PROCEDURE for the given procedure.

fully_qualified_name str: Fully qualified name of the resource. For more information, see object name resolution.
id str: The provider-assigned unique ID for this managed resource.
parameters Sequence[ProcedureSqlParameter]: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedure_language str: Specifies language for the procedure. Used to detect external changes.
show_outputs Sequence[ProcedureSqlShowOutput]: Outputs the result of SHOW PROCEDURE for the given procedure.

fullyQualifiedName String: Fully qualified name of the resource. For more information, see object name resolution.
id String: The provider-assigned unique ID for this managed resource.
parameters List<Property Map>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureLanguage String: Specifies language for the procedure. Used to detect external changes.
showOutputs List<Property Map>: Outputs the result of SHOW PROCEDURE for the given procedure.

Look up Existing ProcedureSql Resource

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

public static get(name: string, id: Input<ID>, state?: ProcedureSqlState, opts?: CustomResourceOptions): ProcedureSql

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        arguments: Optional[Sequence[ProcedureSqlArgumentArgs]] = None,
        comment: Optional[str] = None,
        database: Optional[str] = None,
        enable_console_output: Optional[bool] = None,
        execute_as: Optional[str] = None,
        fully_qualified_name: Optional[str] = None,
        is_secure: Optional[str] = None,
        log_level: Optional[str] = None,
        metric_level: Optional[str] = None,
        name: Optional[str] = None,
        null_input_behavior: Optional[str] = None,
        parameters: Optional[Sequence[ProcedureSqlParameterArgs]] = None,
        procedure_definition: Optional[str] = None,
        procedure_language: Optional[str] = None,
        return_type: Optional[str] = None,
        schema: Optional[str] = None,
        show_outputs: Optional[Sequence[ProcedureSqlShowOutputArgs]] = None,
        trace_level: Optional[str] = None) -> ProcedureSql

func GetProcedureSql(ctx *Context, name string, id IDInput, state *ProcedureSqlState, opts ...ResourceOption) (*ProcedureSql, error)

public static ProcedureSql Get(string name, Input<string> id, ProcedureSqlState? state, CustomResourceOptions? opts = null)

public static ProcedureSql get(String name, Output<String> id, ProcedureSqlState state, CustomResourceOptions options)

resources:  _:    type: snowflake:ProcedureSql    get:      id: ${id}

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

Arguments List<ProcedureSqlArgument>: List of the arguments for the procedure. Consult the docs for more details.
Comment string: Specifies a comment for the procedure.
Database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
EnableConsoleOutput bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
ExecuteAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
FullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
IsSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
LogLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
MetricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
Name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
NullInputBehavior string: 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.
Parameters List<ProcedureSqlParameter>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
ProcedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
ProcedureLanguage string: Specifies language for the procedure. Used to detect external changes.
ReturnType string: 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 data type). 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 ()).
Schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
ShowOutputs List<ProcedureSqlShowOutput>: Outputs the result of SHOW PROCEDURE for the given procedure.
TraceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

Arguments []ProcedureSqlArgumentArgs: List of the arguments for the procedure. Consult the docs for more details.
Comment string: Specifies a comment for the procedure.
Database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
EnableConsoleOutput bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
ExecuteAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
FullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
IsSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
LogLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
MetricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
Name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
NullInputBehavior string: 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.
Parameters []ProcedureSqlParameterArgs: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
ProcedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
ProcedureLanguage string: Specifies language for the procedure. Used to detect external changes.
ReturnType string: 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 data type). 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 ()).
Schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
ShowOutputs []ProcedureSqlShowOutputArgs: Outputs the result of SHOW PROCEDURE for the given procedure.
TraceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

arguments List<ProcedureSqlArgument>: List of the arguments for the procedure. Consult the docs for more details.
comment String: Specifies a comment for the procedure.
database String: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
enableConsoleOutput Boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs String: 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. Valid values are (case-insensitive): CALLER | OWNER.
fullyQualifiedName String: Fully qualified name of the resource. For more information, see object name resolution.
isSecure String: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel String: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel String: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name String: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior String: 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.
parameters List<ProcedureSqlParameter>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureDefinition String: 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 SQL source code. For more information, see Snowflake Scripting. 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.
procedureLanguage String: Specifies language for the procedure. Used to detect external changes.
returnType String: 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 data type). 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 ()).
schema String: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
showOutputs List<ProcedureSqlShowOutput>: Outputs the result of SHOW PROCEDURE for the given procedure.
traceLevel String: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

arguments ProcedureSqlArgument[]: List of the arguments for the procedure. Consult the docs for more details.
comment string: Specifies a comment for the procedure.
database string: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
enableConsoleOutput boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs string: 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. Valid values are (case-insensitive): CALLER | OWNER.
fullyQualifiedName string: Fully qualified name of the resource. For more information, see object name resolution.
isSecure string: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel string: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel string: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name string: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior string: 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.
parameters ProcedureSqlParameter[]: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureDefinition string: 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 SQL source code. For more information, see Snowflake Scripting. 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.
procedureLanguage string: Specifies language for the procedure. Used to detect external changes.
returnType string: 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 data type). 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 ()).
schema string: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
showOutputs ProcedureSqlShowOutput[]: Outputs the result of SHOW PROCEDURE for the given procedure.
traceLevel string: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

arguments Sequence[ProcedureSqlArgumentArgs]: List of the arguments for the procedure. Consult the docs for more details.
comment str: Specifies a comment for the procedure.
database str: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
enable_console_output bool: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
execute_as str: 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. Valid values are (case-insensitive): CALLER | OWNER.
fully_qualified_name str: Fully qualified name of the resource. For more information, see object name resolution.
is_secure str: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
log_level str: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metric_level str: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name str: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
null_input_behavior str: 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.
parameters Sequence[ProcedureSqlParameterArgs]: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedure_definition str: 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 SQL source code. For more information, see Snowflake Scripting. 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.
procedure_language str: Specifies language for the procedure. Used to detect external changes.
return_type str: 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 data type). 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 ()).
schema str: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
show_outputs Sequence[ProcedureSqlShowOutputArgs]: Outputs the result of SHOW PROCEDURE for the given procedure.
trace_level str: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

arguments List<Property Map>: List of the arguments for the procedure. Consult the docs for more details.
comment String: Specifies a comment for the procedure.
database String: The database in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
enableConsoleOutput Boolean: Enable stdout/stderr fast path logging for anonyous stored procs. This is a public parameter (similar to LOGLEVEL). For more information, check CONSOLE_OUTPUT docsENABLE.
executeAs String: 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. Valid values are (case-insensitive): CALLER | OWNER.
fullyQualifiedName String: Fully qualified name of the resource. For more information, see object name resolution.
isSecure String: Specifies that the procedure is secure. For more information about secure procedures, see Protecting Sensitive Information with Secure UDFs and Stored Procedures. 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.
logLevel String: LOG*LEVEL to use when filtering events For more information, check LOG*LEVEL docs.
metricLevel String: METRIC*LEVEL value to control whether to emit metrics to Event Table For more information, check METRIC*LEVEL docs.
name String: 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. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
nullInputBehavior String: 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.
parameters List<Property Map>: Outputs the result of SHOW PARAMETERS IN PROCEDURE for the given procedure.
procedureDefinition String: 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 SQL source code. For more information, see Snowflake Scripting. 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.
procedureLanguage String: Specifies language for the procedure. Used to detect external changes.
returnType String: 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 data type). 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 ()).
schema String: The schema in which to create the procedure. Due to technical limitations (read more here), avoid using the following characters: |, ., ".
showOutputs List<Property Map>: Outputs the result of SHOW PROCEDURE for the given procedure.
traceLevel String: Trace level value to use when generating/filtering trace events For more information, check TRACE_LEVEL docs.

Supporting Types

ProcedureSqlArgument, ProcedureSqlArgumentArgs

ArgDataType string: The argument type.
ArgName string: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
ArgDefaultValue string

ArgDataType string: The argument type.
ArgName string: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
ArgDefaultValue string

argDataType String: The argument type.
argName String: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
argDefaultValue String

argDataType string: The argument type.
argName string: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
argDefaultValue string

arg_data_type str: The argument type.
arg_name str: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
arg_default_value str

argDataType String: The argument type.
argName String: The argument name. The provider wraps it in double quotes by default, so be aware of that while referencing the argument in the procedure definition.
argDefaultValue String