pub struct Routine {Show 20 fields
pub arguments: Option<Vec<Argument>>,
pub creation_time: Option<i64>,
pub data_governance_type: Option<String>,
pub definition_body: Option<String>,
pub description: Option<String>,
pub determinism_level: Option<String>,
pub etag: Option<String>,
pub external_runtime_options: Option<ExternalRuntimeOptions>,
pub imported_libraries: Option<Vec<String>>,
pub language: Option<String>,
pub last_modified_time: Option<i64>,
pub python_options: Option<PythonOptions>,
pub remote_function_options: Option<RemoteFunctionOptions>,
pub return_table_type: Option<StandardSqlTableType>,
pub return_type: Option<StandardSqlDataType>,
pub routine_reference: Option<RoutineReference>,
pub routine_type: Option<String>,
pub security_mode: Option<String>,
pub spark_options: Option<SparkOptions>,
pub strict_mode: Option<bool>,
}Expand description
A user-defined function or a stored procedure.
§Activities
This type is used in activities, which are methods you may call on this type or where this type is involved in. The list links the activity name, along with information about where it is used (one of request and response).
- delete routines (none)
- get routines (response)
- get iam policy routines (none)
- insert routines (request|response)
- list routines (none)
- set iam policy routines (none)
- test iam permissions routines (none)
- update routines (request|response)
Fields§
§arguments: Option<Vec<Argument>>Optional.
creation_time: Option<i64>Output only. The time when this routine was created, in milliseconds since the epoch.
data_governance_type: Option<String>Optional. If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see Create custom masking routines.
definition_body: Option<String>Required. The body of the routine. For functions, this is the expression in the AS clause. If language = "SQL", it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y)) The definition_body is concat(x, "\n", y) (\n is not replaced with linebreak). If language="JAVASCRIPT", it is the evaluated string in the AS clause. For example, for the function created with the following statement: CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n' The definition_body is return "\n";\n Note that both \n are replaced with linebreaks. If definition_body references another routine, then that routine must be fully qualified with its project ID.
description: Option<String>Optional. The description of the routine, if defined.
determinism_level: Option<String>Optional. The determinism level of the JavaScript UDF, if defined.
etag: Option<String>Output only. A hash of this resource.
external_runtime_options: Option<ExternalRuntimeOptions>Optional. Options for the runtime of the external system executing the routine. This field is only applicable for Python UDFs. Preview
imported_libraries: Option<Vec<String>>Optional. If language = “JAVASCRIPT”, this field stores the path of the imported JAVASCRIPT libraries.
language: Option<String>Optional. Defaults to “SQL” if remote_function_options field is absent, not set otherwise.
last_modified_time: Option<i64>Output only. The time when this routine was last modified, in milliseconds since the epoch.
python_options: Option<PythonOptions>Optional. Options for the Python UDF. Preview
remote_function_options: Option<RemoteFunctionOptions>Optional. Remote function specific options.
return_table_type: Option<StandardSqlTableType>Optional. Can be set only if routine_type = “TABLE_VALUED_FUNCTION”. If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
return_type: Option<StandardSqlDataType>Optional if language = “SQL”; required otherwise. Cannot be set if routine_type = “TABLE_VALUED_FUNCTION”. If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y); * CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1)); * CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1)); The return_type is {type_kind: "FLOAT64"} for Add and Decrement, and is absent for Increment (inferred as FLOAT64 at query time). Suppose the function Add is replaced by CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y); Then the inferred return type of Increment is automatically changed to INT64 at query time, while the return type of Decrement remains FLOAT64.
routine_reference: Option<RoutineReference>Required. Reference describing the ID of this routine.
routine_type: Option<String>Required. The type of routine.
security_mode: Option<String>Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine’s configuration.
spark_options: Option<SparkOptions>Optional. Spark specific options.
strict_mode: Option<bool>Optional. Use this option to catch many common errors. Error checking is not exhaustive, and successfully creating a procedure doesn’t guarantee that the procedure will successfully execute at runtime. If strictMode is set to TRUE, the procedure body is further checked for errors such as non-existent tables or columns. The CREATE PROCEDURE statement fails if the body fails any of these checks. If strictMode is set to FALSE, the procedure body is checked only for syntax. For procedures that invoke themselves recursively, specify strictMode=FALSE to avoid non-existent procedure errors during validation. Default value is TRUE.