Struct Routine 

pub struct Routine {

    pub etag: String,
    pub routine_reference: RoutineReference,
    pub routine_type: RoutineType,
    pub creation_time: Option<i64>,
    pub last_modified_time: Option<i64>,
    pub language: Option<Language>,
    pub arguments: Option<Vec<Argument>>,
    pub return_type: Option<StandardSqlDataType>,
    pub return_table_type: Option<StandardSqlTableType>,
    pub imported_libraries: Option<Vec<String>>,
    pub definition_body: String,
    pub description: Option<String>,
    pub determinism_level: Option<DeterminismLevel>,
    pub remote_function_options: Option<RemoteFunctionOptions>,
    pub spark_options: Option<SparkOptions>,
}

Fields

etag: String

Output only. A hash of this resource.

routine_reference: RoutineReference

Required. Reference describing the ID of this routine.

routine_type: RoutineType

Required. The type of routine.

creation_time: Option<i64>

Output only. The time when this routine was created, in milliseconds since the epoch.

last_modified_time: Option<i64>

Output only. The time when this routine was last modified, in milliseconds since the epoch.

language: Option<Language>

Optional. Defaults to “SQL” if remoteFunctionOptions field is absent, not set otherwise.

arguments: Option<Vec<Argument>>

Optional.

return_type: Option<StandardSqlDataType>

Optional if language = “SQL”; required otherwise. Cannot be set if routineType = “TABLE_VALUED_FUNCTION”. If absent, the return type is inferred from definitionBody 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 returnType is {typeKind: “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.

return_table_type: Option<StandardSqlTableType>

Optional. Can be set only if routineType = “TABLE_VALUED_FUNCTION”. If absent, the return table type is inferred from definitionBody 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.

imported_libraries: Option<Vec<String>>

Optional. If language = “JAVASCRIPT”, this field stores the path of the imported JAVASCRIPT libraries.

definition_body: 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 definitionBody 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 definitionBody is return “\n”;\n Note that both \n are replaced with linebreaks.

description: Option<String>

Optional. The description of the routine, if defined.

determinism_level: Option<DeterminismLevel>

Optional. The determinism level of the JavaScript UDF, if defined.

remote_function_options: Option<RemoteFunctionOptions>

Optional. Remote function specific options.

spark_options: Option<SparkOptions>

Optional. Spark specific options.

Trait Implementations

impl Clone for Routine

fn clone(&self) -> Routine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Routine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Routine

fn default() -> Routine

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Routine

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Routine

fn eq(&self, other: &Routine) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Routine

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Routine

impl StructuralPartialEq for Routine