FcoManueel/pg

Performant PostgreSQL client for Golang with ORM capabilities

PostgreSQL client for Golang

Supports:

• Basic types: integers, floats, string, bool, time.Time, and pointers to these types.
• sql.NullBool, sql.NullString, sql.NullInt64 and sql.Float64.
• sql.Scanner and sql/driver.Valuer interfaces.
• Arrays.
• Partially hstore.
• Transactions.
• Prepared statements.
• Notifications using LISTEN and NOTIFY.
• Copying data using COPY FROM and COPY TO.
• Timeouts. Client sends CancelRequest message on timeout.
• Automatic and safe connection pool.
• Queries retries on network errors.
• PostgreSQL to Go struct mapping.
• Migrations.
• Sharding.

API docs: http://godoc.org/gopkg.in/pg.v3. Examples: http://godoc.org/gopkg.in/pg.v3#pkg-examples.

Installation

Install:

go get gopkg.in/pg.v3

Quickstart

package pg_test

import (
	"fmt"

	"gopkg.in/pg.v3"
)

type User struct {
	Id     int64
	Name   string
	Emails []string
}

// go-pg users collection.
type Users struct {
	C []User
}

// Implements pg.Collection.
var _ pg.Collection = &Users{}

// NewRecord returns new user and is used by go-pg to load multiple users.
func (users *Users) NewRecord() interface{} {
	users.C = append(users.C, User{})
	return &users.C[len(users.C)-1]
}

func CreateUser(db *pg.DB, user *User) error {
	_, err := db.QueryOne(user, `
		INSERT INTO users (name, emails) VALUES (?name, ?emails)
		RETURNING id
	`, user)
	return err
}

func GetUser(db *pg.DB, id int64) (*User, error) {
	var user User
	_, err := db.QueryOne(&user, `SELECT * FROM users WHERE id = ?`, id)
	return &user, err
}

func GetUsers(db *pg.DB) ([]User, error) {
	var users Users
	_, err := db.Query(&users, `SELECT * FROM users`)
	return users.C, err
}

func ExampleDB_Query() {
	db := pg.Connect(&pg.Options{
		User: "postgres",
	})

	_, err := db.Exec(`CREATE TEMP TABLE users (id serial, name text, emails text[])`)
	if err != nil {
		panic(err)
	}

	err = CreateUser(db, &User{
		Name:   "admin",
		Emails: []string{"admin1@admin", "admin2@admin"},
	})
	if err != nil {
		panic(err)
	}

	err = CreateUser(db, &User{
		Name:   "root",
		Emails: []string{"root1@root", "root2@root"},
	})
	if err != nil {
		panic(err)
	}

	user, err := GetUser(db, 1)
	if err != nil {
		panic(err)
	}

	users, err := GetUsers(db)
	if err != nil {
		panic(err)
	}

	fmt.Println(user)
	fmt.Println(users[0], users[1])
	// Output: &{1 admin [admin1@admin admin2@admin]}
	// {1 admin [admin1@admin admin2@admin]} {2 root [root1@root root2@root]}
}

Why not database/sql and lib/pq

• On some queries go-pg is 2x faster, because it can load data in 1 client/server round-trip.
• You don't need to use rows.Close to manage connections.
• go-pg manages memory more efficiently than ORMs for database/sql.
• Placeholders support allows you to write complex queries and stick with SQL.

Howto

Please go through examples to get the idea how to use this package.