class Google::Cloud::Bigquery::Routine

# Routine

A user-defined function or a stored procedure.

@example Creating a new routine:

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"

routine = dataset.create_routine "my_routine" do |r|
  r.routine_type = "SCALAR_FUNCTION"
  r.language = "SQL"
  r.arguments = [
    Google::Cloud::Bigquery::Argument.new(name: "x", data_type: "INT64")
  ]
  r.body = "x * 3"
  r.description = "My routine description"
end

puts routine.routine_id

@example Extended example:

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.create_routine "my_routine" do |r|
  r.routine_type = "SCALAR_FUNCTION"
  r.language = :SQL
  r.body = "(SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem)"
  r.arguments = [
    Google::Cloud::Bigquery::Argument.new(
      name: "arr",
      argument_kind: "FIXED_TYPE",
      data_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
        type_kind: "ARRAY",
        array_element_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
          type_kind: "STRUCT",
          struct_type: Google::Cloud::Bigquery::StandardSql::StructType.new(
            fields: [
              Google::Cloud::Bigquery::StandardSql::Field.new(
                name: "name",
                type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "STRING")
              ),
              Google::Cloud::Bigquery::StandardSql::Field.new(
                name: "val",
                type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "INT64")
              )
            ]
          )
        )
      )
    )
  ]
end

@example Retrieving and updating an existing routine:

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.update do |r|
  r.body = "x * 4"
  r.description = "My new routine description"
end

Attributes

gapi[RW]

@private The Google API Client object.

reference[R]

@private A Google API Client Dataset Reference object.

service[RW]

@private The Service object.

Public Class Methods

from_gapi(gapi, service) click to toggle source

@private New Routine from a Google API Client object.

# File lib/google/cloud/bigquery/routine.rb, line 906
def self.from_gapi gapi, service
  new.tap do |r|
    r.instance_variable_set :@gapi, gapi
    r.instance_variable_set :@service, service
  end
end
new() click to toggle source

@private Creates an empty Routine object.

# File lib/google/cloud/bigquery/routine.rb, line 110
def initialize
  @service = nil
  @gapi = nil
  @reference = nil
end
new_reference(project_id, dataset_id, routine_id, service) click to toggle source

@private New lazy Routine object without making an HTTP request, for use with the skip_lookup option.

# File lib/google/cloud/bigquery/routine.rb, line 915
def self.new_reference project_id, dataset_id, routine_id, service
  raise ArgumentError, "project_id is required" unless project_id
  raise ArgumentError, "dataset_id is required" unless dataset_id
  raise ArgumentError, "routine_id is required" unless routine_id
  raise ArgumentError, "service is required" unless service

  gapi = Google::Apis::BigqueryV2::RoutineReference.new(
    project_id: project_id,
    dataset_id: dataset_id,
    routine_id: routine_id
  )
  new.tap do |r|
    r.service = service
    r.instance_variable_set :@reference, gapi
  end
end
new_reference_from_gapi(gapi, service) click to toggle source

@private New lazy Routine object from a Google API Client object.

# File lib/google/cloud/bigquery/routine.rb, line 934
def self.new_reference_from_gapi gapi, service
  new.tap do |b|
    b.service = service
    b.instance_variable_set :@reference, gapi
  end
end

Public Instance Methods

arguments() click to toggle source

The input/output arguments of the routine. Optional.

@return [Array<Argument>, nil] An array of argument objects, or `nil` if the object is a reference (see

{#reference?}).

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

puts "#{routine.routine_id} arguments:"
routine.arguments.each do |arguments|
  puts "* #{arguments.name}"
end

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 339
def arguments
  return nil if reference?
  ensure_full_data!
  # always return frozen arguments
  Array(@gapi.arguments).map { |a| Argument.from_gapi a }.freeze
end
arguments=(new_arguments) click to toggle source

Updates the input/output arguments of the routine. Optional.

@param [Array<Argument>] new_arguments The new arguments.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.arguments = [
  Google::Cloud::Bigquery::Argument.new(name: "x", data_type: "INT64")
]

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 364
def arguments= new_arguments
  ensure_full_data!
  @gapi.update! arguments: new_arguments.map(&:to_gapi)
  update_gapi!
end
body() click to toggle source

The body of the routine. Required.

For functions ({#scalar_function?}), this is the expression in the `AS` clause.

When the routine is a SQL function ({#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).

When the routine is a JavaScript function ({#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.

@return [String, nil] The body of the routine, or `nil` if the object is a reference (see {#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 522
def body
  return nil if reference?
  ensure_full_data!
  @gapi.definition_body
end
body=(new_body) click to toggle source

Updates the body of the routine. Required.

For functions ({#scalar_function?}), this is the expression in the `AS` clause.

When the routine is a SQL function ({#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).

When the routine is a JavaScript function ({#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.

@param [String] new_body The new body of the routine.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 555
def body= new_body
  ensure_full_data!
  @gapi.definition_body = new_body
  update_gapi!
end
created_at() click to toggle source

The time when this routine was created.

@return [Time, nil] The creation time, or `nil` if the object is a reference (see {#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 246
def created_at
  return nil if reference?
  Convert.millis_to_time @gapi.creation_time
end
dataset_id() click to toggle source

The ID of the dataset containing this routine.

@return [String] The dataset ID.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 136
def dataset_id
  return reference.dataset_id if reference?
  @gapi.routine_reference.dataset_id
end
delete() click to toggle source

Permanently deletes the routine.

@return [Boolean] Returns `true` if the routine was deleted.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.delete

@!group Lifecycle

# File lib/google/cloud/bigquery/routine.rb, line 744
def delete
  ensure_service!
  service.delete_routine dataset_id, routine_id
  # Set flag for #exists?
  @exists = false
  true
end
description() click to toggle source

The description of the routine if defined. Optional. [Experimental]

@return [String, nil] The routine description, or `nil` if the object is a reference (see {#reference?}).

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.description #=> "My routine description"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 577
def description
  return nil if reference?
  ensure_full_data!
  @gapi.description
end
description=(new_description) click to toggle source

Updates the description of the routine. Optional. [Experimental]

@param [String] new_description The new routine description.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.description #=> "My routine description"
routine.description = "My updated routine description"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 600
def description= new_description
  ensure_full_data!
  @gapi.description = new_description
  update_gapi!
end
determinism_level() click to toggle source

The JavaScript UDF determinism level. Optional.

  • `DETERMINISTIC` - Deterministic indicates that two calls with the same input to a UDF yield the same output. If all JavaScript UDFs are `DETERMINISTIC`, the query result is potentially cachable.

  • `NOT_DETERMINISTIC` - Not deterministic indicates that the output of the UDF is not guaranteed to yield the same output each time for a given set of inputs. If any JavaScript UDF is `NOT_DETERMINISTIC`, the query result is not cacheable.

Even if a JavaScript UDF is deterministic, many other factors can prevent usage of cached query results. Example factors include but not limited to: DDL/DML, non-deterministic SQL function calls, update of referenced tables/views/UDFs or imported JavaScript libraries. SQL UDFs cannot have determinism specified. Their determinism is automatically determined.

@return [String, nil] The routine determinism level in upper case, or `nil` if not set or the object is a

reference (see {#reference?}).

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.determinism_level #=> "NOT_DETERMINISTIC"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 634
def determinism_level
  return nil if reference?
  ensure_full_data!
  @gapi.determinism_level
end
determinism_level=(new_determinism_level) click to toggle source

Updates the JavaScript UDF determinism level. Optional.

  • `DETERMINISTIC` - Deterministic indicates that two calls with the same input to a UDF yield the same output. If all JavaScript UDFs are `DETERMINISTIC`, the query result is potentially cachable.

  • `NOT_DETERMINISTIC` - Not deterministic indicates that the output of the UDF is not guaranteed to yield the same output each time for a given set of inputs. If any JavaScript UDF is `NOT_DETERMINISTIC`, the query result is not cacheable.

@param [String, nil] new_determinism_level The new routine determinism level in upper case.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.determinism_level #=> "NOT_DETERMINISTIC"
routine.determinism_level = "DETERMINISTIC"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 663
def determinism_level= new_determinism_level
  ensure_full_data!
  @gapi.determinism_level = new_determinism_level
  update_gapi!
end
determinism_level_deterministic?() click to toggle source

Checks if the value of {#determinism_level} is `DETERMINISTIC`. The default is `false`.

@return [Boolean] `true` when `DETERMINISTIC` and the object is not a reference (see {#reference?}), `false`

otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 677
def determinism_level_deterministic?
  @gapi.determinism_level == "DETERMINISTIC"
end
determinism_level_not_deterministic?() click to toggle source

Checks if the value of {#determinism_level} is `NOT_DETERMINISTIC`. The default is `false`.

@return [Boolean] `true` when `NOT_DETERMINISTIC` and the object is not a reference (see {#reference?}),

`false` otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 689
def determinism_level_not_deterministic?
  @gapi.determinism_level == "NOT_DETERMINISTIC"
end
etag() click to toggle source

The ETag hash of the routine.

@return [String, nil] The ETag hash, or `nil` if the object is a reference (see {#reference?}).

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.etag # "etag123456789"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 178
def etag
  return nil if reference?
  @gapi.etag
end
exists?(force: false) click to toggle source

Determines whether the routine exists in the BigQuery service. The result is cached locally. To refresh state, set `force` to `true`.

@param [Boolean] force Force the latest resource representation to be

retrieved from the BigQuery service when `true`. Otherwise the
return value of this method will be memoized to reduce the number of
API calls made to the BigQuery service. The default is `false`.

@return [Boolean] `true` when the routine exists in the BigQuery

service, `false` otherwise.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine", skip_lookup: true
routine.exists? #=> true
# File lib/google/cloud/bigquery/routine.rb, line 800
def exists? force: false
  return resource_exists? if force
  # If we have a value, return it
  return @exists unless @exists.nil?
  # Always true if we have a gapi object
  return true if resource?
  resource_exists?
end
imported_libraries() click to toggle source

The list of the Google Cloud Storage URIs of imported JavaScript libraries. Optional. Only used if {#language} is `JAVASCRIPT` ({#javascript?}).

@return [Array<String>, nil] A frozen array of Google Cloud Storage URIs, e.g.

`["gs://cloud-samples-data/bigquery/udfs/max-value.js"]`, or `nil` if the object is a reference (see
{#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 463
def imported_libraries
  return nil if reference?
  ensure_full_data!
  @gapi.imported_libraries.freeze
end
imported_libraries=(new_imported_libraries) click to toggle source

Updates the list of the Google Cloud Storage URIs of imported JavaScript libraries. Optional. Only used if {#language} is `JAVASCRIPT` ({#javascript?}).

@param [Array<String>, nil] new_imported_libraries An array of Google Cloud Storage URIs, e.g.

`["gs://cloud-samples-data/bigquery/udfs/max-value.js"]`.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.imported_libraries = [
  "gs://cloud-samples-data/bigquery/udfs/max-value.js"
]

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 489
def imported_libraries= new_imported_libraries
  ensure_full_data!
  @gapi.imported_libraries = new_imported_libraries
  update_gapi!
end
javascript?() click to toggle source

Checks if the value of {#language} is `JAVASCRIPT`. The default is `false`.

@return [Boolean] `true` when `JAVASCRIPT` and the object is not a reference (see {#reference?}), `false`

otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 302
def javascript?
  @gapi.language == "JAVASCRIPT"
end
language() click to toggle source

The programming language of routine. Optional. Defaults to “SQL”.

  • `SQL` - SQL language.

  • `JAVASCRIPT` - JavaScript language.

@return [String, nil] The language in upper case, or `nil` if the object is a reference (see {#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 273
def language
  return nil if reference?
  @gapi.language
end
language=(new_language) click to toggle source

Updates the programming language of routine. Optional. Defaults to “SQL”.

  • `SQL` - SQL language.

  • `JAVASCRIPT` - JavaScript language.

@param [String] new_language The new language in upper case.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 288
def language= new_language
  ensure_full_data!
  @gapi.language = new_language
  update_gapi!
end
modified_at() click to toggle source

The time when this routine was last modified.

@return [Time, nil] The last modified time, or `nil` if the object is a reference (see {#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 258
def modified_at
  return nil if reference?
  Convert.millis_to_time @gapi.last_modified_time
end
procedure?() click to toggle source

Checks if the value of {#routine_type} is `PROCEDURE`. The default is `false`.

@return [Boolean] `true` when `PROCEDURE` and the object is not a reference (see {#reference?}), `false`

otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 223
def procedure?
  @gapi.routine_type == "PROCEDURE"
end
project_id() click to toggle source

The ID of the project containing this routine.

@return [String] The project ID.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 148
def project_id
  return reference.project_id if reference?
  @gapi.routine_reference.project_id
end
reference?() click to toggle source

Whether the routine was created without retrieving the resource representation from the BigQuery service.

@return [Boolean] `true` when the routine is just a local reference

object, `false` otherwise.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine", skip_lookup: true

routine.reference? #=> true
routine.reload!
routine.reference? #=> false
# File lib/google/cloud/bigquery/routine.rb, line 828
def reference?
  @gapi.nil?
end
refresh!()
Alias for: reload!
reload!() click to toggle source

Reloads the routine with current data from the BigQuery service.

@return [Google::Cloud::Bigquery::Routine] Returns the reloaded

routine.

@example Skip retrieving the routine from the service, then load it:

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine", skip_lookup: true

routine.reload!

@!group Lifecycle

# File lib/google/cloud/bigquery/routine.rb, line 770
def reload!
  ensure_service!
  @gapi = service.get_routine dataset_id, routine_id
  @reference = nil
  @exists = nil
  self
end
Also aliased as: refresh!
resource?() click to toggle source

Whether the routine was created with a resource representation from the BigQuery service.

@return [Boolean] `true` when the routine was created with a resource

representation, `false` otherwise.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine", skip_lookup: true

routine.resource? #=> false
routine.reload!
routine.resource? #=> true
# File lib/google/cloud/bigquery/routine.rb, line 851
def resource?
  !@gapi.nil?
end
resource_full?() click to toggle source

Whether the routine was created with a full resource representation from the BigQuery service.

@return [Boolean] `true` when the routine was created with a full

resource representation, `false` otherwise.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.resource_full? #=> true
# File lib/google/cloud/bigquery/routine.rb, line 900
def resource_full?
  resource? && !@gapi.definition_body.nil?
end
resource_partial?() click to toggle source

Whether the routine was created with a partial resource representation from the BigQuery service by retrieval through {Dataset#routines}. See [Models: list response](cloud.google.com/bigquery/docs/reference/rest/v2/routines/list#response) for the contents of the partial representation. Accessing any attribute outside of the partial representation will result in loading the full representation.

@return [Boolean] `true` when the routine was created with a partial

resource representation, `false` otherwise.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new

dataset = bigquery.dataset "my_dataset"
routine = dataset.routines.first

routine.resource_partial? #=> true
routine.description # Loads the full resource.
routine.resource_partial? #=> false
# File lib/google/cloud/bigquery/routine.rb, line 879
def resource_partial?
  resource? && !resource_full?
end
return_type() click to toggle source

The return type of the routine. Optional if the routine is a SQL function ({#sql?}); required otherwise.

If absent, the return type is inferred from {#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 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 [Google::Cloud::Bigquery::StandardSql::DataType, nil] The return type in upper case, or `nil` if the

object is a reference (see {#reference?}).

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.return_type.type_kind #=> "INT64"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 404
def return_type
  return nil if reference?
  ensure_full_data!
  return nil unless @gapi.return_type
  StandardSql::DataType.from_gapi @gapi.return_type
end
return_type=(new_return_type) click to toggle source

Updates the return type of the routine. Optional if the routine is a SQL function ({#sql?}); required otherwise.

If absent, the return type is inferred from {#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 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`.

@param [Google::Cloud::Bigquery::StandardSql::DataType, String] new_return_type The new return type for the

routine.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.return_type.type_kind #=> "INT64"
routine.return_type = "STRING"

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 447
def return_type= new_return_type
  ensure_full_data!
  @gapi.return_type = StandardSql::DataType.gapi_from_string_or_data_type new_return_type
  update_gapi!
end
routine_id() click to toggle source

A unique ID for this routine, without the project name.

@return [String] The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum

length is 256 characters.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 124
def routine_id
  return reference.routine_id if reference?
  @gapi.routine_reference.routine_id
end
routine_ref() click to toggle source

@private The gapi fragment containing the Project ID, Dataset ID, and Routine ID.

@return [Google::Apis::BigqueryV2::RoutineReference]

# File lib/google/cloud/bigquery/routine.rb, line 158
def routine_ref
  reference? ? reference : @gapi.routine_reference
end
routine_type() click to toggle source

The type of routine. Required.

  • `SCALAR_FUNCTION` - Non-builtin permanent scalar function.

  • `PROCEDURE` - Stored procedure.

@return [String, nil] The type of routine in upper case, or `nil` if the object is a reference (see

{#reference?}).

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 194
def routine_type
  return nil if reference?
  @gapi.routine_type
end
routine_type=(new_routine_type) click to toggle source

Updates the type of routine. Required.

  • `SCALAR_FUNCTION` - Non-builtin permanent scalar function.

  • `PROCEDURE` - Stored procedure.

@param [String] new_routine_type The new type of the routine in upper case.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 209
def routine_type= new_routine_type
  ensure_full_data!
  @gapi.routine_type = new_routine_type
  update_gapi!
end
scalar_function?() click to toggle source

Checks if the value of {#routine_type} is `SCALAR_FUNCTION`. The default is `true`.

@return [Boolean] `true` when `SCALAR_FUNCTION` and the object is not a reference (see {#reference?}), `false`

otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 235
def scalar_function?
  @gapi.routine_type == "SCALAR_FUNCTION"
end
sql?() click to toggle source

Checks if the value of {#language} is `SQL`. The default is `true`.

@return [Boolean] `true` when `SQL` and the object is not a reference (see {#reference?}), `false`

otherwise.

@!group Attributes

# File lib/google/cloud/bigquery/routine.rb, line 314
def sql?
  return true if @gapi.language.nil?
  @gapi.language == "SQL"
end
update() { |updater| ... } click to toggle source

Updates the routine with changes made in the given block in a single update request. The following attributes may be set: {Updater#routine_type=}, {Updater#language=}, {Updater#arguments=}, {Updater#return_type=}, {Updater#imported_libraries=}, {Updater#body=}, and {Updater#description=}.

@yield [routine] A block for setting properties on the routine. @yieldparam [Google::Cloud::Bigquery::Routine::Updater] routine An updater to set additional properties on the

routine.

@example

require "google/cloud/bigquery"

bigquery = Google::Cloud::Bigquery.new
dataset = bigquery.dataset "my_dataset"
routine = dataset.routine "my_routine"

routine.update do |r|
  r.routine_type = "SCALAR_FUNCTION"
  r.language = "SQL"
  r.arguments = [
    Google::Cloud::Bigquery::Argument.new(name: "x", data_type: "INT64")
  ]
  r.body = "x * 3"
  r.description = "My new routine description"
end

@!group Lifecycle

# File lib/google/cloud/bigquery/routine.rb, line 721
def update
  ensure_full_data!
  updater = Updater.new @gapi
  yield updater
  update_gapi! updater.to_gapi if updater.updates?
end

Protected Instance Methods

ensure_full_data!() click to toggle source

Load the complete representation of the routine if it has been only partially loaded by a request to the API list method.

# File lib/google/cloud/bigquery/routine.rb, line 961
def ensure_full_data!
  reload! unless resource_full?
end
ensure_service!() click to toggle source

Raise an error unless an active service is available.

# File lib/google/cloud/bigquery/routine.rb, line 945
def ensure_service!
  raise "Must have active connection" unless service
end
resource_exists?() click to toggle source

Fetch gapi and memoize whether resource exists.

# File lib/google/cloud/bigquery/routine.rb, line 951
def resource_exists?
  reload!
  @exists = true
rescue Google::Cloud::NotFoundError
  @exists = false
end
update_gapi!(update_gapi = nil) click to toggle source
# File lib/google/cloud/bigquery/routine.rb, line 965
def update_gapi! update_gapi = nil
  update_gapi ||= @gapi
  ensure_service!
  @gapi = service.update_routine dataset_id, routine_id, update_gapi
  self
end