bigquery

README

BigQuery SQL Driver for Golang

This is an implementation of the BigQuery Client as a database/sql/driver for easy integration and usage.

Goals of project

This project is meant to be a basic database/sql driver implementation for Golang so that developers can easily use *sql.DB functions with Google's BigQuery database.

Unlike the original project, this driver

• does not contain ORM extension
• uses different connection string

Connection string

The connection string format is URL with bigquery scheme and host representing project ID. Path (optional) represents location (cloud region).

• bigquery://projectid/?param1=value&param2=value
• bigquery://projectid/location?param1=value&param2=value

Common parameters

• dataset - dataset ID. When set, it allows to use unqualified tables names in queries.

Authentication parameters

As this is using the Google Cloud Go SDK, you will need to have your credentials available via the GOOGLE_APPLICATION_CREDENTIALS environment variable point to your credential JSON file.

Alternatively, you can use one of the following parameters:

• apiKey - API key value
• credentials - base-64 encoded service account or refresh token JSON credentials

Examples:

• bigquery://projectid/?apiKey=AIzaSyB6XK8IO5AzKZXoioQOVNTFYzbDBjY5hy4
• bigquery://projectid/?credentials=eyJ0eXBlIjoiYXV0...

Usage

package main

import "github.com/bonitoo-io/go-sql-bigquery"

func main() {
    db, err := sql.Open("bigquery", "bigquery://lunar-1234/?dataset=storeys")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close() 
    ...
}

Contribution

Contributions are welcome.

Current Support

• driver.Conn implemented
• driver.Querier implemented
• driver.Pinger implemented
• driver.DriverContext implemented
• driver.QueryerContext implemented
• driver.ExecerContext implemented
• driver.RowsColumnTypeDatabaseTypeName implemented
• Prepared Statements - supported via a quick hack
• Parameterized Queries

Documentation

Index

• Constants
• func NewStmt(query string, c *Conn) *stmt
• type Config
  • func ConfigFromConnString(in string) (*Config, error)
• type Conn
  • func NewConn(ctx context.Context, cfg *Config) (c *Conn, err error)
  • func (c *Conn) Begin() (driver.Tx, error)
  • func (c *Conn) Close() (err error)
  • func (c *Conn) Exec(query string, args []driver.Value) (res driver.Result, err error)
  • func (c *Conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
  • func (c *Conn) Ping(ctx context.Context) (err error)
  • func (c *Conn) Prepare(query string) (stmt driver.Stmt, err error)
  • func (c *Conn) Query(query string, args []driver.Value) (rows driver.Rows, err error)
  • func (c *Conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
• type Connector
  • func NewConnector(connectionString string) *Connector
  • func (c *Connector) Connect(ctx context.Context) (driver.Conn, error)
  • func (c *Connector) Driver() driver.Driver
• type Dataset
• type Driver
  • func (d *Driver) Open(connectionString string) (c driver.Conn, err error)
  • func (d *Driver) OpenConnector(connectionString string) (c driver.Connector, err error)

Constants

const (
	ConnectionStringEnvKey = "BIGQUERY_CONNECTION_STRING"
)

Functions

func NewStmt

func NewStmt(query string, c *Conn) *stmt

Types

type Config

type Config struct {
	ProjectID   string
	Location    string
	DatasetID   string
	ApiKey      string
	Credentials string
}

func ConfigFromConnString

func ConfigFromConnString(in string) (*Config, error)

ConfigFromConnString will return the Config structures

type Conn

type Conn struct {
	// contains filtered or unexported fields
}

func NewConn

func NewConn(ctx context.Context, cfg *Config) (c *Conn, err error)

NewConn returns a connection for this Config

func (*Conn) Begin

func (c *Conn) Begin() (driver.Tx, error)

Begin is stubbed out and not used

func (*Conn) Close

func (c *Conn) Close() (err error)

Close closes the connection

func (*Conn) Exec

func (c *Conn) Exec(query string, args []driver.Value) (res driver.Result, err error)

Deprecated: Drivers should implement ExecerContext instead.

func (*Conn) ExecContext

func (c *Conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)

func (*Conn) Ping

func (c *Conn) Ping(ctx context.Context) (err error)

Ping the BigQuery service and make sure it's reachable

func (*Conn) Prepare

func (c *Conn) Prepare(query string) (stmt driver.Stmt, err error)

Prepare is stubbed out and not used

func (*Conn) Query

func (c *Conn) Query(query string, args []driver.Value) (rows driver.Rows, err error)

Deprecated: Drivers should implement QueryerContext instead.

func (*Conn) QueryContext

func (c *Conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)

type Connector

type Connector struct {
	Info   map[string]string
	Client *bigquery.Client
	// contains filtered or unexported fields
}

func NewConnector

func NewConnector(connectionString string) *Connector

func (*Connector) Connect

func (c *Connector) Connect(ctx context.Context) (driver.Conn, error)

func (*Connector) Driver

func (c *Connector) Driver() driver.Driver

type Dataset

type Dataset interface {
	// Create creates a dataset in the BigQuery service. An error will be returned if the
	// dataset already exists. Pass in a DatasetMetadata value to configure the dataset.
	Create(ctx context.Context, md *bigquery.DatasetMetadata) (err error)
	// Delete deletes the dataset.  Delete will fail if the dataset is not empty.
	Delete(ctx context.Context) (err error)
	// DeleteWithContents deletes the dataset, as well as contained resources.
	DeleteWithContents(ctx context.Context) (err error)
	// Metadata fetches the metadata for the dataset.
	Metadata(ctx context.Context) (md *bigquery.DatasetMetadata, err error)
	// Update modifies specific Dataset metadata fields.
	// To perform a read-modify-write that protects against intervening reads,
	// set the etag argument to the DatasetMetadata.ETag field from the read.
	// Pass the empty string for etag for a "blind write" that will always succeed.
	Update(ctx context.Context, dm bigquery.DatasetMetadataToUpdate, etag string) (md *bigquery.DatasetMetadata, err error)
	// Table creates a handle to a BigQuery table in the dataset.
	// To determine if a table exists, call Table.Metadata.
	// If the table does not already exist, use Table.Create to create it.
	Table(tableID string) *bigquery.Table
	// Tables returns an iterator over the tables in the Dataset.
	Tables(ctx context.Context) *bigquery.TableIterator
	// Model creates a handle to a BigQuery model in the dataset.
	// To determine if a model exists, call Model.Metadata.
	// If the model does not already exist, you can create it via execution
	// of a CREATE MODEL query.
	Model(modelID string) *bigquery.Model
	// Models returns an iterator over the models in the Dataset.
	Models(ctx context.Context) *bigquery.ModelIterator
	// Routine creates a handle to a BigQuery routine in the dataset.
	// To determine if a routine exists, call Routine.Metadata.
	Routine(routineID string) *bigquery.Routine
	// Routines returns an iterator over the routines in the Dataset.
	Routines(ctx context.Context) *bigquery.RoutineIterator
}

type Driver

type Driver struct {
}

func (*Driver) Open

func (d *Driver) Open(connectionString string) (c driver.Conn, err error)

func (*Driver) OpenConnector

func (d *Driver) OpenConnector(connectionString string) (c driver.Connector, err error)