routines

Creates, updates, deletes, gets or lists a routines resource.

Overview

Name	`routines`
Type	Resource
Id	`google.bigquery.routines`

Fields

The following fields are returned by SELECT queries:

get
list

Name	Datatype	Description
`arguments`	`array`	Optional.
`creationTime`	`string (int64)`	Output only. The time when this routine was created, in milliseconds since the epoch.
`dataGovernanceType`	`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.
`definitionBody`	`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`	`string`	Optional. The description of the routine, if defined.
`determinismLevel`	`string`	Optional. The determinism level of the JavaScript UDF, if defined.
`etag`	`string`	Output only. A hash of this resource.
`externalRuntimeOptions`	`object`	Optional. Options for the runtime of the external system executing the routine. This field is only applicable for Python UDFs. Preview (id: ExternalRuntimeOptions)
`importedLibraries`	`array`	Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
`language`	`string`	Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
`lastModifiedTime`	`string (int64)`	Output only. The time when this routine was last modified, in milliseconds since the epoch.
`pythonOptions`	`object`	Optional. Options for the Python UDF. Preview (id: PythonOptions)
`remoteFunctionOptions`	`object`	Optional. Remote function specific options. (id: RemoteFunctionOptions)
`returnTableType`	`object`	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. (id: StandardSqlTableType)
`returnType`	`object`	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. (id: StandardSqlDataType)
`routineReference`	`object`	Id path of a routine. (id: RoutineReference)
`routineType`	`string`	Required. The type of routine.
`securityMode`	`string`	Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine's configuration.
`sparkOptions`	`object`	Optional. Spark specific options. (id: SparkOptions)
`strictMode`	`boolean`	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`.

Name	Datatype	Description
`arguments`	`array`	Optional.
`creationTime`	`string (int64)`	Output only. The time when this routine was created, in milliseconds since the epoch.
`dataGovernanceType`	`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.
`definitionBody`	`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`	`string`	Optional. The description of the routine, if defined.
`determinismLevel`	`string`	Optional. The determinism level of the JavaScript UDF, if defined.
`etag`	`string`	Output only. A hash of this resource.
`externalRuntimeOptions`	`object`	Optional. Options for the runtime of the external system executing the routine. This field is only applicable for Python UDFs. Preview (id: ExternalRuntimeOptions)
`importedLibraries`	`array`	Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
`language`	`string`	Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
`lastModifiedTime`	`string (int64)`	Output only. The time when this routine was last modified, in milliseconds since the epoch.
`pythonOptions`	`object`	Optional. Options for the Python UDF. Preview (id: PythonOptions)
`remoteFunctionOptions`	`object`	Optional. Remote function specific options. (id: RemoteFunctionOptions)
`returnTableType`	`object`	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. (id: StandardSqlTableType)
`returnType`	`object`	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. (id: StandardSqlDataType)
`routineReference`	`object`	Id path of a routine. (id: RoutineReference)
`routineType`	`string`	Required. The type of routine.
`securityMode`	`string`	Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine's configuration.
`sparkOptions`	`object`	Optional. Spark specific options. (id: SparkOptions)
`strictMode`	`boolean`	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`.

Methods

The following methods are available for this resource:

Name	Accessible by	Required Params	Optional Params	Description
`get`	`select`	`projectId`, `+datasetId`, `+routineId`	`readMask`	Gets the specified routine resource by routine ID.
`list`	`select`	`projectId`, `+datasetId`	`maxResults`, `pageToken`, `readMask`, `filter`	Lists all routines in the specified dataset. Requires the READER dataset role.
`insert`	`insert`	`projectId`, `+datasetId`		Creates a new routine in the dataset.
`update`	`replace`	`projectId`, `+datasetId`, `+routineId`		Updates information in an existing routine. The update method replaces the entire Routine resource.
`delete`	`delete`	`projectId`, `+datasetId`, `+routineId`		Deletes the routine specified by routineId from the dataset.

Parameters

Parameters can be passed in the WHERE clause of a query. Check the Methods section to see which parameters are required or optional for each operation.

Name	Datatype	Description
`+datasetId`	`string`
`+routineId`	`string`
`projectId`	`string`
`filter`	`string`
`maxResults`	`integer (uint32)`
`pageToken`	`string`
`readMask`	`string (google-fieldmask)`

`SELECT` examples

get
list

Gets the specified routine resource by routine ID.

SELECT
arguments,
creationTime,
dataGovernanceType,
definitionBody,
description,
determinismLevel,
etag,
externalRuntimeOptions,
importedLibraries,
language,
lastModifiedTime,
pythonOptions,
remoteFunctionOptions,
returnTableType,
returnType,
routineReference,
routineType,
securityMode,
sparkOptions,
strictMode
FROM google.bigquery.routines
WHERE projectId = '{{ projectId }}' -- required
AND +datasetId = '{{ +datasetId }}' -- required
AND +routineId = '{{ +routineId }}' -- required
AND readMask = '{{ readMask }}'
;

Lists all routines in the specified dataset. Requires the READER dataset role.

SELECT
arguments,
creationTime,
dataGovernanceType,
definitionBody,
description,
determinismLevel,
etag,
externalRuntimeOptions,
importedLibraries,
language,
lastModifiedTime,
pythonOptions,
remoteFunctionOptions,
returnTableType,
returnType,
routineReference,
routineType,
securityMode,
sparkOptions,
strictMode
FROM google.bigquery.routines
WHERE projectId = '{{ projectId }}' -- required
AND +datasetId = '{{ +datasetId }}' -- required
AND maxResults = '{{ maxResults }}'
AND pageToken = '{{ pageToken }}'
AND readMask = '{{ readMask }}'
AND filter = '{{ filter }}'
;

`INSERT` examples

insert
Manifest

Creates a new routine in the dataset.

INSERT INTO google.bigquery.routines (
data__language,
data__externalRuntimeOptions,
data__returnType,
data__sparkOptions,
data__returnTableType,
data__importedLibraries,
data__pythonOptions,
data__remoteFunctionOptions,
data__securityMode,
data__routineType,
data__determinismLevel,
data__description,
data__strictMode,
data__arguments,
data__routineReference,
data__definitionBody,
data__dataGovernanceType,
projectId,
+datasetId
)
SELECT 
'{{ language }}',
'{{ externalRuntimeOptions }}',
'{{ returnType }}',
'{{ sparkOptions }}',
'{{ returnTableType }}',
'{{ importedLibraries }}',
'{{ pythonOptions }}',
'{{ remoteFunctionOptions }}',
'{{ securityMode }}',
'{{ routineType }}',
'{{ determinismLevel }}',
'{{ description }}',
{{ strictMode }},
'{{ arguments }}',
'{{ routineReference }}',
'{{ definitionBody }}',
'{{ dataGovernanceType }}',
'{{ projectId }}',
'{{ +datasetId }}'
RETURNING
arguments,
creationTime,
dataGovernanceType,
definitionBody,
description,
determinismLevel,
etag,
externalRuntimeOptions,
importedLibraries,
language,
lastModifiedTime,
pythonOptions,
remoteFunctionOptions,
returnTableType,
returnType,
routineReference,
routineType,
securityMode,
sparkOptions,
strictMode
;

# Description fields are for documentation purposes
- name: routines
  props:
    - name: projectId
      value: string
      description: Required parameter for the routines resource.
    - name: +datasetId
      value: string
      description: Required parameter for the routines resource.
    - name: language
      value: string
      description: >
        Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
        
      valid_values: ['LANGUAGE_UNSPECIFIED', 'SQL', 'JAVASCRIPT', 'PYTHON', 'JAVA', 'SCALA']
    - name: externalRuntimeOptions
      value: object
      description: >
        Optional. Options for the runtime of the external system executing the routine. This field is only applicable for Python UDFs. [Preview](https://cloud.google.com/products/#product-launch-stages)
        
    - name: returnType
      value: object
      description: >
        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.
        
    - name: sparkOptions
      value: object
      description: >
        Optional. Spark specific options.
        
    - name: returnTableType
      value: object
      description: >
        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.
        
    - name: importedLibraries
      value: array
      description: >
        Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
        
    - name: pythonOptions
      value: object
      description: >
        Optional. Options for the Python UDF. [Preview](https://cloud.google.com/products/#product-launch-stages)
        
    - name: remoteFunctionOptions
      value: object
      description: >
        Optional. Remote function specific options.
        
    - name: securityMode
      value: string
      description: >
        Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine's configuration.
        
      valid_values: ['SECURITY_MODE_UNSPECIFIED', 'DEFINER', 'INVOKER']
    - name: routineType
      value: string
      description: >
        Required. The type of routine.
        
      valid_values: ['ROUTINE_TYPE_UNSPECIFIED', 'SCALAR_FUNCTION', 'PROCEDURE', 'TABLE_VALUED_FUNCTION', 'AGGREGATE_FUNCTION']
    - name: determinismLevel
      value: string
      description: >
        Optional. The determinism level of the JavaScript UDF, if defined.
        
      valid_values: ['DETERMINISM_LEVEL_UNSPECIFIED', 'DETERMINISTIC', 'NOT_DETERMINISTIC']
    - name: description
      value: string
      description: >
        Optional. The description of the routine, if defined.
        
    - name: strictMode
      value: boolean
      description: >
        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`.
        
    - name: arguments
      value: array
      description: >
        Optional.
        
    - name: routineReference
      value: object
      description: >
        Id path of a routine.
        
    - name: definitionBody
      value: string
      description: >
        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.
        
    - name: dataGovernanceType
      value: string
      description: >
        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](https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask).
        
      valid_values: ['DATA_GOVERNANCE_TYPE_UNSPECIFIED', 'DATA_MASKING']

`REPLACE` examples

update

Updates information in an existing routine. The update method replaces the entire Routine resource.

REPLACE google.bigquery.routines
SET 
data__language = '{{ language }}',
data__externalRuntimeOptions = '{{ externalRuntimeOptions }}',
data__returnType = '{{ returnType }}',
data__sparkOptions = '{{ sparkOptions }}',
data__returnTableType = '{{ returnTableType }}',
data__importedLibraries = '{{ importedLibraries }}',
data__pythonOptions = '{{ pythonOptions }}',
data__remoteFunctionOptions = '{{ remoteFunctionOptions }}',
data__securityMode = '{{ securityMode }}',
data__routineType = '{{ routineType }}',
data__determinismLevel = '{{ determinismLevel }}',
data__description = '{{ description }}',
data__strictMode = {{ strictMode }},
data__arguments = '{{ arguments }}',
data__routineReference = '{{ routineReference }}',
data__definitionBody = '{{ definitionBody }}',
data__dataGovernanceType = '{{ dataGovernanceType }}'
WHERE 
projectId = '{{ projectId }}' --required
AND +datasetId = '{{ +datasetId }}' --required
AND +routineId = '{{ +routineId }}' --required
RETURNING
arguments,
creationTime,
dataGovernanceType,
definitionBody,
description,
determinismLevel,
etag,
externalRuntimeOptions,
importedLibraries,
language,
lastModifiedTime,
pythonOptions,
remoteFunctionOptions,
returnTableType,
returnType,
routineReference,
routineType,
securityMode,
sparkOptions,
strictMode;

`DELETE` examples

delete

Deletes the routine specified by routineId from the dataset.

DELETE FROM google.bigquery.routines
WHERE projectId = '{{ projectId }}' --required
AND +datasetId = '{{ +datasetId }}' --required
AND +routineId = '{{ +routineId }}' --required
;

Overview​

Fields​

Methods​

Parameters​

SELECT examples​

INSERT examples​

REPLACE examples​

DELETE examples​