pqxd

package module
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 29, 2024 License: MIT Imports: 19 Imported by: 0

README

pqxd - database/sql driver for PartiQL in DynamoDB

Go Reference CI GitHub go.mod Go version (subdirectory of monorepo) GitHub release (latest by date) Go Report Card GitHub License

Quick Start

Install
go get github.com/miyamo2/pqxd
Usage
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/miyamo2/pqxd"
	"log"
	"time"
)

func main() {
	ctx := context.Background()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("ap-northeast-1"))
	if err != nil {
		log.Fatal(err)
	}
	db := sql.OpenDB(pqxd.NewConnector(cfg))
	if db == nil {
		log.Fatal(err)
	}
	if err := db.Ping(); err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	rows, err := db.QueryContext(ctx, `SELECT id, name FROM "users"`)
	if err != nil {
		fmt.Printf("something happend. err: %s\n", err.Error())
		return
	}

	for rows.NextResultSet() { // page feed with next token
		for rows.Next() {
			var (
				id   string
				name string
			)
			if err := rows.Scan(&id, &name); err != nil {
				fmt.Printf("something happend. err: %s\n", err.Error())
				continue
			}
			fmt.Printf("id: %s, name: %d\n", id, name)
		}
	}
}
SELECT

[!TIP] If * is specified in the select column list,
the results of the rows are automatically sorted by column name(asc).

However, if specified with *, the number of attributes may differ from row to row.

Therefore, it is recommended that the selection column list specify the attribute names.

Scan
rows, err := db.QueryContext(context.Background(), `SELECT id, name FROM "users"`)
for rows.NextResultSet() { // page feed with next token
    for rows.Next() {
        var (
            id string
            name string
        )
        if err := rows.Scan(&id, &name); err != nil {
            fmt.Printf("something happend. err: %s\n", err.Error())
            continue
        }
        fmt.Printf("id: %s, name: %d\n", id, name)
    }
}
GetItem
row := db.QueryRowContext(context.Background(), `SELECT id, name FROM "users" WHERE id = ?`, "1")
var (
    id string
    name string
)
if err := row.Scan(&id, &name); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
fmt.Printf("id: %s, name: %d\n", id, name)
GetItem with Global Secondary Index
row := db.QueryRowContext(context.Background(), `SELECT id, name FROM "users"."gsi_pk-gsi-sk_index" WHERE gsi_pk = ? AND gsi_sk = ?`, "foo", "bar")

var (
    id string
    name string
)
if err := row.Scan(&id, &name); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
fmt.Printf("id: %s, name: %d\n", id, name)
With Prepared Statement
ctx := context.Background()

stmt, err := db.PrepareContext(ctx, `SELECT id, name FROM "users" WHERE id = ?`)
if err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
defer stmt.Close()

rows, err := stmt.QueryRowContext(ctx, "1")
if err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}

var (
    id string
    name string
)
if err := row.Scan(&id, &name); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
fmt.Printf("id: %s, name: %d\n", id, name)
With Transaction
tx, err := db.Begin()
if err != nil {
    return err
}

ctx := context.Background()

rows, err := tx.QueryContext(ctx, `SELECT id, name FROM "users" WHERE id = ?`, "1")
if err != nil {
    tx.Rollback()
    return err
}

row := tx.QueryRowContext(ctx, `SELECT id, name FROM "users" WHERE id = ?`, "2")

// WARNING: Do not use `tx.Commit()` when using `SELECT` statement.
//
// Each `sql.Rows` or `sql.Row` is resolved 
// the first time `rows.NextResultSet()`, `rows.Next()` or `row.Scan()` 
// is performed within that transaction.
// So, after the `rows.NextResultSet()`, `rows.Next()` or `row.Scan()` is performed,
// the transaction is automatically committed.
for rows.Next() {
    var (
        id string
        name string
    )
    if err := rows.Scan(&id, &name); err != nil {
        fmt.Printf("something happend. err: %s\n", err.Error())
        continue
    }
    fmt.Printf("id: %s, name: %d\n", id, name)
}

var (
    id string
    name string
)
if err := row.Scan(&id, &name); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
fmt.Printf("id: %s, name: %d\n", id, name)
RETURNING

pqxd supports the RETURNING clause.

row := db.QueryRowContext(context.Background(), `UPDATE "users" SET name = ? SET nickname = ? WHERE id = ? RETURNING MODIFIED OLD *`, "David", "Dave", "3")

var name, nickname sql.NullString
if err := row.Scan(&name, &nickname); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
if name.Valid {
    fmt.Printf("name: %s\n", name.String)
}
if nickname.Valid {
    fmt.Printf("nickname: %s\n", nickname.String)
}

And provides proprietary syntax for specifying a column list instead of *.

row := db.QueryRowContext(context.Background(), `UPDATE "users" SET name = ? SET nickname = ? WHERE id = ? RETURNING ALL OLD id`, "Robert", "Bob", "2")

var id string
if err := row.Scan(&id); err != nil {
    fmt.Printf("something happend. err: %s\n", err.Error())
    return
}
fmt.Printf("id: %s\n", id)
INSERT/UPDATE/DELETE
insertResult, err := db.Exec(`INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`, "3", "Alice")
if err != nil {
    return err
}
affected, err := insertResult.RowsAffected()
if err != nil {
    return err
}
if affected != 1 {
    return fmt.Errorf("expected 1 row affected, got %d", affected)
}

updateResult, err := db.Exec(`UPDATE "users" SET name = ? WHERE id = ?`, "Bob", "2")
if err != nil {
    return err
}
affected, err = updateResult.RowsAffected()
if err != nil {
    return err
}
if affected != 1 {
    return fmt.Errorf("expected 1 row affected, got %d", affected)
}

deleteResult, err := db.Exec(`DELETE FROM "users" WHERE id = ?`, "1")
if err != nil {
    return err
}
affected, err = deleteResult.RowsAffected()
if err != nil {
    return err
}
if affected != 1 {
    return fmt.Errorf("expected 1 row affected, got %d", affected)
}
With Prepared Statement
stmt, err := db.Prepare(`INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`)
if err != nil {
    return err
}
defer stmt.Close()

insertResult, err := stmt.Exec("3", "Alice")
if err != nil {
    return err
}
affected, err := insertResult.RowsAffected()
if err != nil {
    return err
}
if affected != 1 {
    return fmt.Errorf("expected 1 row affected, got %d", affected)
}
With Transaction
tx, err := db.Begin()
if err != nil {
    return err
}

insertResult, err := tx.Exec(`INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`, "3", "Alice")
if err != nil {
    tx.Rollback()
    return err
}

updateResult, err := tx.Exec(`UPDATE "users" SET name = ? WHERE id = ?`, "Bob", "2")
if err != nil {
    tx.Rollback()
    return err
}

deleteResult, err := tx.Exec(`DELETE FROM "users" WHERE id = ?`, "1")
if err != nil {
    tx.Rollback()
    return err
}

// RowsAffected is available after commit
tx.Commit()

// RowsAffected might return 0 or 1. If 0, it means statement is not successful.
if affected, err := insertResult.RowsAffected(); err != nil || affected != 1 {
    return err
}

if affected, err := updateResult.RowsAffected(); err != nil || affected != 1 {
    return err
}

if affected, err := deleteResult.RowsAffected(); err != nil || affected != 1 {
    return err
}
Connection String

We recommend using sql.OpenDB with pqxd.NewConnector instead of sql.Open. But if you want to use sql.Open, you can use the following connection string.

AWS_REGION=<aws region>
;AWS_ACCESS_KEY_ID=<access key ID>
;AWS_SECRET_ACCESS_KEY=<secret access key>
[;ENDPOINT=<amazon dynamodb endpoint>]
Key description
AWS_REGION AWS Region. If not supplied, it is resolved from one of the following environment variables; AWS_REGION or AWS_DEFAULT_REGION.
AWS_ACCESS_KEY_ID AWS Access Key ID. If not supplied, it is resolved from one of the following environment variables; AWS_ACCESS_KEY or AWS_ACCESS_KEY_ID.
AWS_SECRET_ACCESS_KEY AWS Secret Access Key. If not supplied, it is resolved from one of the following environment variables; AWS_SECRET_KEY or AWS_SECRET_ACCESS_KEY.
ENDPOINT Endpoint of DynamoDB. Used to connect locally to an emulator or to a DynamoDB compatible interface. 
db, err := sql.Open(pqxd.DriverName, "AWS_REGION=ap-northeast-1;AWS_ACCESS_KEY_ID=AKIA...;AWS_SECRET_ACCESS_KEY=...;")
O11y
New Relic
package main

import (
	"context"
	"database/sql"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/miyamo2/pqxd"
	nraws "github.com/newrelic/go-agent/v3/integrations/nrawssdk-v2"
	"log"
)

func main() {
	ctx := context.Background()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("ap-northeast-1"))
	if err != nil {
		log.Fatal(err)
	}
	
	// Instrumenting New Relic
	nraws.AppendMiddlewares(&cfg.APIOptions, nil)
	
	db := sql.OpenDB(pqxd.NewConnector(cfg))
	if db == nil {
		log.Fatal(err)
	}
	db.Ping()
}
Datadog
package main

import (
	"context"
	"database/sql"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/miyamo2/pqxd"
	awstrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/aws/aws-sdk-go-v2/aws"
	"log"
)

func main() {
	ctx := context.Background()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("ap-northeast-1"))
	if err != nil {
		log.Fatal(err)
	}
	
	// Instrumenting Datadog
	awstrace.AppendMiddleware(&cfg)

	db := sql.OpenDB(pqxd.NewConnector(cfg))
	if db == nil {
		log.Fatal(err)
	}
	db.Ping()
}
AWS X-Ray
package main

import (
	"context"
	"database/sql"
	"github.com/miyamo2/pqxd"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
	"github.com/aws/aws-xray-sdk-go/instrumentation/awsv2"
	"github.com/aws/aws-xray-sdk-go/xray"
)

func main() {
	ctx := context.Background()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("ap-northeast-1"))
	if err != nil {
		log.Fatalf("unable to load SDK config, %v", err)
	}
	// Instrumenting X-Ray
	awsv2.AWSV2Instrumentor(&cfg.APIOptions)

	db := sql.OpenDB(pqxd.NewConnector(cfg))
	if db == nil {
		log.Fatal(err)
	}
	db.Ping()
}

Contributing

Feel free to open a PR or an Issue.

However, you must promise to follow our Code of Conduct.

Tasks

We recommend that this section be run with xc

test:unit
go test -v -coverpkg='github.com/miyamo2/pqxd' -coverprofile=coverage.out
test:integration
cd tests/integration
xc test

License

pqxd released under the MIT License

Special Thanks

pqxd is inspired by the following projects.
With the utmost respect, we would like to thank the authors and contributors of these projects.

Documentation

Overview

Example 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/miyamo2/pqxd"
)

func main() {
	awsConfig, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	db := sql.OpenDB(pqxd.NewConnector(awsConfig))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if err := db.Ping(); err != nil {
		fmt.Println(err.Error())
	}
}

Output:
Example (ExecContext) 
package main

import (
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	insertResult, err := db.Exec(`INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`, "3", "Alice")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	affected, err := insertResult.RowsAffected()
	if err != nil {
		fmt.Println(err.Error())
	}
	if affected != 1 {
		fmt.Println(fmt.Errorf("expected 1 row affected, got %d", affected))
		return
	}

	updateResult, err := db.Exec(`UPDATE "users" SET "name" = ? WHERE id = ?`, "Bob", "2")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	affected, err = updateResult.RowsAffected()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if affected != 1 {
		fmt.Println(fmt.Errorf("expected 1 row affected, got %d", affected))
		return
	}

	deleteResult, err := db.Exec(`DELETE FROM "users" WHERE id = ?`, "1")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	affected, err = deleteResult.RowsAffected()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if affected != 1 {
		fmt.Println(fmt.Errorf("expected 1 row affected, got %d", affected))
		return
	}
}

Output:
Example (ExecInTransaction) 
package main

import (
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	tx, err := db.Begin()
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	insertResult, err := tx.Exec(`INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`, "3", "Alice")
	if err != nil {
		fmt.Println(err.Error())
		tx.Rollback()
		return
	}

	updateResult, err := tx.Exec(`UPDATE "users" SET "name" = ? WHERE id = ?`, "Bob", "2")
	if err != nil {
		fmt.Println(err.Error())
		tx.Rollback()
		return
	}

	deleteResult, err := tx.Exec(`DELETE FROM "users" WHERE id = ?`, "1")
	if err != nil {
		fmt.Println(err.Error())
		tx.Rollback()
		return
	}

	// RowsAffected is available after commit
	tx.Commit()

	// RowsAffected might return 0 or 1. If 0, it means statement is not successful.
	if affected, err := insertResult.RowsAffected(); err != nil || affected != 1 {
		fmt.Println(err.Error())
		return
	}

	if affected, err := updateResult.RowsAffected(); err != nil || affected != 1 {
		fmt.Println(err.Error())
		return
	}

	if affected, err := deleteResult.RowsAffected(); err != nil || affected != 1 {
		fmt.Println(err.Error())
		return
	}
}

Output:
Example (PrepareContext) 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	stmt, err := db.PrepareContext(context.Background(), `SELECT id, name FROM "users" WHERE id = ?`)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer stmt.Close()

	row := stmt.QueryRowContext(context.Background(), 1)
	var id, name string
	if err := row.Scan(&id, &name); err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Printf("id: %s, name: %s\n", id, name)

	stmt, err = db.PrepareContext(context.Background(), `INSERT INTO "users" VALUE { 'id': ?, 'name': ? }`)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer stmt.Close()

	insertResult, err := stmt.Exec("3", "Alice")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	affected, err := insertResult.RowsAffected()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if affected != 1 {
		fmt.Println(fmt.Errorf("expected 1 row affected, got %d", affected))
		return
	}
}

Output:
Example (QueryContext) 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	rows, err := db.QueryContext(context.Background(), `SELECT id, name FROM "users"`)
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	for rows.NextResultSet() {
		for rows.Next() {
			var id, name string
			err := rows.Scan(&id, &name)
			if err != nil {
				fmt.Println(err.Error())
				return
			}
			fmt.Printf("id: %s, name: %s\n", id, name)
		}
	}
	rows, err = db.QueryContext(context.Background(), `SELECT name FROM "users"`)
	if err != nil {
		fmt.Println(err.Error())
	}
	for rows.NextResultSet() {
		for rows.Next() {
			var name string
			if err := rows.Scan(&name); err != nil {
				fmt.Println(err.Error())
				return
			}
			fmt.Printf("name: %s\n", name)
		}
	}
}

Output:
Example (QueryInTransaction) 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	tx, err := db.BeginTx(context.Background(), nil)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	row := tx.QueryRowContext(context.Background(), `SELECT id, name FROM "users" WHERE id = ?`, 1)
	rows, err := tx.QueryContext(context.Background(), `SELECT id, name FROM "users" WHERE id = ?`, 2)
	if err != nil {
		fmt.Println(err.Error())
		tx.Rollback()
		return
	}

	// WARNING: Do not use `tx.Commit()` when using `SELECT` statement.
	//
	// Each `sql.Rows` or `sql.Row` is resolved
	// the first time `rows.NextResultSet()`, `rows.Next()` or `row.Scan()`
	// is performed within that transaction.
	// So, after the `rows.NextResultSet()`, `rows.Next()` or `row.Scan()` is performed,
	// the transaction is automatically committed.
	for rows.Next() {
		var id, name string
		if err := rows.Scan(&id, &name); err != nil {
			fmt.Println(err.Error())
			tx.Rollback()
			return
		}
		fmt.Printf("id: %s, name: %s\n", id, name)
	}

	var id, name string
	if err := row.Scan(id, name); err != nil {
		return
	}
	fmt.Printf("id: %s, name: %s\n", id, name)
}

Output:
Example (QueryRowContext) 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	var id, name string
	err := db.QueryRowContext(context.Background(), `SELECT id, name FROM "users" WHERE id = ?`, 1).Scan(&id, &name)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Printf("id: %s, name: %s\n", id, name)
}

Output:
Example (Returning) 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/miyamo2/pqxd"
)

var db *sql.DB = sql.OpenDB(pqxd.NewConnector(aws.Config{
	Region:      "ap-northeast-1",
	Credentials: aws.AnonymousCredentials{},
}))

func main() {
	row := db.QueryRowContext(context.Background(), `UPDATE "users" SET name = ? SET nickname = ? WHERE id = ? RETURNING MODIFIED OLD *`, "David", "Dave", "3")

	var name, nickname sql.NullString
	if err := row.Scan(&name, &nickname); err != nil {
		fmt.Printf("something happend. err: %s\n", err.Error())
		return
	}
	if name.Valid {
		fmt.Printf("name: %s\n", name.String)
	}
	if nickname.Valid {
		fmt.Printf("nickname: %s\n", nickname.String)
	}

	row = db.QueryRowContext(context.Background(), `UPDATE "users" SET name = ? SET nickname = ? WHERE id = ? RETURNING ALL OLD id`, "Bob", "2")
	var id string
	if err := row.Scan(&id); err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Printf("id: %s\n", id)
}

Output:
Example (WithOpen) 
package main

import (
	"database/sql"
	"fmt"
	"github.com/miyamo2/pqxd"
	"os"
)

func main() {
	region := os.Getenv("AWS_REGION")
	ak := os.Getenv("AWS_ACCESS_KEY_ID")
	sk := os.Getenv("AWS_SECRET_ACCESS_KEY")

	db, err := sql.Open(pqxd.DriverName, fmt.Sprintf("AWS_REGION=%s;AWS_ACCESS_KEY_ID=%s;AWS_SECRET_ACCESS_KEY=%s", region, ak, sk))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if err := db.Ping(); err != nil {
		fmt.Println(err.Error())
	}
}

Output:

Index

Examples

Constants

View Source 
const DriverName = "pqxd"

DriverName is the name that should be used in sql.Open to use this driver

Example: 

db, err := sql.Open(pqxd.DriverName, "REGION=ap-northeast-1;ACCESSKEY=dummy;SECRETKEY=dummy")

Variables

View Source 
var (
	// ErrNotSupported occurs when performed operation that is not supported in pqxd
	ErrNotSupported = errors.New("pqxd: not supported this operation")

	// ErrInvalidPreparedStatement occurs when the prepared statement is invalid
	ErrInvalidPreparedStatement = errors.New("pqxd: invalid prepared statement")

	// ErrStatementClosed occurs when the statement is closed
	ErrStatementClosed = errors.New("pqxd: statement is closed")

	// ErrTxDualBoot occurs when running more than one transaction at a time in a single connection
	ErrTxDualBoot = errors.New("pqxd: cannot run more than transaction at a time in a single connection")

	// ErrInvalidSyntaxOfQuery occurs when the query syntax is invalid
	ErrInvalidSyntaxOfQuery = errors.New("pqxd: invalid syntax of query")
)

Functions

func NewConnector 

func NewConnector(awsConfig aws.Config, options ...ConnectorOption) driver.Connector

NewConnector creates a new connector with the given aws.Config and ConnectorOption.

Example 
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/miyamo2/pqxd"
)

func main() {
	awsConfig, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	db := sql.OpenDB(pqxd.NewConnector(awsConfig))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if err := db.Ping(); err != nil {
		fmt.Println(err.Error())
	}
}

Output:

Types

type ConnectorOption 

type ConnectorOption func(*ConnectorSetting)

ConnectorOption is the option for the connector.

type ConnectorSetting 

type ConnectorSetting struct{}

ConnectorSetting is the setting for the connector.

Source Files

View all Source files

Directories

Path Synopsis
Package internal is a generated GoMock package.
 Package internal is a generated GoMock package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.