Logo
  1. Potens.io
  2. Goliath
  3. Extras

Articles > GoBQ

  • BigQuery Sessions
  • Goliath GitHub Integration
  • Connections
  • Parameters & Workspace
  • Visualization
  • GoBQ
  • Hints
  • BigQuery Scripting Support

This article provides users with a general guide to the features listed.

These features may have been updated or superseded by additions found in the release notes.

Read the content below to become familiar with the feature and review the release notes to get the latest iteration.

Overview

GoBQ mode allows users to run golang code in a sandboxed environment

Run GoBQ

To run a GoBQ script switch to Mode: GoBQ

0903.png

001.png

1. GoBQ script can be written in the GoBQ text area
2. Clicking Run Script will excute code from the text area
3. The results are divided into two sections:

a. Return value shows anything returned by the script
b. Standard Output shows anything that was printed as the script ran

 

GoBQ Script

func MainReturn

func mainReturn() interface{} {
    return "myvalue"
}

mainReturn is the GoBQ entry point.

When Run Script is clicked function mainReturn is executed

 

Data Types

GoBQ supports various data types that have an equivalent in Goliath (primarily for parameter usage)

Data types are especially important when assigning values to parameters

When assigning values from a script to a parameter sync the golang data type (script value) to the Goliath data type (Goliath parameter value is assigned to)

Supported golang data types Respective Goliath data types
bool boolean
string string
int, int8, int16, int32, int64 number
uint, uint8, uint16, uint32, uint64 number
float32, float64 number

 

Data Type Returned Value

Example 1

func mainReturn() int {
    return 1
}
 
Example 2

func mainReturn() string {
    return "myvalue"
}

The datatype of the returned value can be specified as shown in the examples on the left

Example 1 shows returned value as datatype int
Example 2 shows returned value as datatype string

 

Data Type Parameters

002.png

Goliath parameters can also be used with GoBQ
Be sure to use the appropriate data type when using parameters

 

Supported packages

Import statements are not allowed in playground

Instead a number of packages are already imported and can be used in GoBQ

Imported packages include:

Package Description
reflect

Implements run-time reflection, allowing a program to manipulate objects with arbitrary types. The typical use is to take a value with static type interface{} and extract its dynamic type information by calling TypeOf, which returns a Type.

A call to ValueOf returns a Value representing the run-time data. Zero takes a Type and returns a Value representing a zero value for that type.

See "The Laws of Reflection" for an introduction to reflection in Go: https://golang.org/doc/articles/laws_of_reflection.html

encoding/json

Implements encoding and decoding of JSON as defined in RFC 4627. The mapping between JSON and Go values is described in the documentation for the Marshal and Unmarshal functions.

See "JSON and Go" for an introduction to this package: https://golang.org/doc/articles/json_and_go.html

errors Implements functions to manipulate errors
time

Provides functionality for measuring and displaying time.

The calendrical calculations always assume a Gregorian calendar

math Provides basic constants and mathematical functions
strconv Implements conversions to and from string representations of basic data types
strings

Implements simple functions to manipulate UTF-8 encoded strings.

For information about UTF-8 strings in Go, see https://blog.golang.org/strings

regexp

Implements regular expression search.

The syntax of the regular expressions accepted is the same general syntax used by Perl, Python, and other languages. More precisely, it is the syntax accepted by RE2 and described at https://golang.org/s/re2syntax, except for \C. For an overview of the syntax, run

crypto/sha256 Implements the SHA224 and SHA256 hash algorithms as defined in FIPS 180-4
crypto/hmac  Implements the Keyed-Hash Message Authentication Code (HMAC) as defined in U.S. Federal Information Processing Standards Publication 198. An HMAC is a cryptographic hash that uses a key to sign a message. The receiver verifies the hash by recomputing it using the same key
 cloud.google.com/go/bigquery Provides access to the BigQuery API
 cloud.google.com/go/storage Provides access to the Cloud Storage JSON API
 crypto/md5 Implements the MD5 hash algorithm as defined in RFC 1321
 bytes Implements functions for the manipulation of byte slices. It is analogous to the facilities of the strings package
 sync

Provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channels and communication.

Values containing the types defined in this package should not be copied

 

func mainReturn() int {
    var x, y int = 3, 4
    var f float64 = math.Sqrt(float64(x*x + y*y))
    var z uint = uint(f)
    xPrintln(x, y, z)
    return x
}

Supported packaged can be referenced as usual

In this example the package math (math.Sqrt) is referenced


I/O functions
 

GoBQ mode provides limited access to a set of fmt functions

These functions can be referenced by their alias

Functions and their alias are:

Supported fmt methods Alias to use in GoBQ
fmt.Sprint xSprint
fmt.Sprintf xSprintf
fmt.Sprintln xSprintln
fmt.Print xPrint
fmt.Printf xPrintf
fmt.Println xPrintln
fmt.Fprint xFprint
fmt.Fprintf xFprintf
fmt.Fprintln xFprintln

 

func mainReturn() int {
    var x, y int = 3, 4
    var f float64 = math.Sqrt(float64(x*x + y*y))
    var z uint = uint(f)
    xPrintln(x, y, z)
    return x
}

Supported I/O functions can be referenced via their alias

In this example the I/O function fmt.Println is referenced via alias xPrintln


BigQuery Package

Obtain access to BigQuery API (https://pkg.go.dev/cloud.google.com/go/bigquery)

  1. To obtain bigquery.Client type: func getBigqueryClient(billingProjectId)(*bigquery.Client, error)
  2. Above returns bigquery.Client with user credential and billing project initialized
    1. client, err := getBigqueryClient(billingProjectId)
  3. With above variable user has access to BigQuery API (https://pkg.go.dev/cloud.google.com/go/bigquery#Client)

Storage Package

Obtain access to Cloud Storage API (https://pkg.go.dev/cloud.google.com/go/storage)

  1. Obtain storage.Client type: func getStorageClient()(*storage.Client, error)
  2. Above returns storage.Client with user credential
    1. client, err := getStorageClient()
  3. With above variable user has access to Cloud Storage API (https://pkg.go.dev/cloud.google.com/go/storage#Client)

Examples

When adopting samples from BigQuery Samples to work in Goliath, the following adjustments are needed:

  1. Remove import statement as this is not supported in Goliath Go Editor.
  2. Create Bigquery client with user credential by
    1. Replacing:

    client, err := bigquery.NewClient(ctx, projectID)
    By:
    client, err := getBigqueryClient(projectID)

  3. Place code to be executed in the following entry point function
    func mainReturn() interface{} {
        //code to be executed
    }

 

Potens.io
Launch Magnus | Goliath