func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
err = sess.Tx(func(tx sqlbuilder.Tx) error {
// Use tx like you would normally use sess:
total, err := tx.Collection("books").Find().Count()
if err != nil {
return err
}
log.Printf("total within tx: %d", total)
// This won't work on our testing sandbox, you'll have to try it out on a local env.
// if err = tx.Collection("books").Find().Delete(); err != nil {
// return err
// }
return nil
})
if err != nil {
log.Fatal(err)
}
total, err := sess.Collection("books").Find().Count()
if err != nil {
log.Fatal(err)
}
log.Printf("total outside tx: %d", total)
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
req := sess.Select(
"b.id AS book_id",
db.Raw("b.*"),
db.Raw("a.*"),
).From("books b").
Join("authors a").On("b.author_id = a.id").
OrderBy("b.title")
var books []BookAuthor
if err := req.All(&books); err != nil {
log.Fatal(err)
}
for _, book := range books {
log.Printf(
"Book: %q. ID: %d, Author: %s\n",
book.Book.Title,
book.BookID,
book.Author.LastName,
)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
// Set this to true to enable the query logger which will print all SQL
// statements to stdout.
db.Conf.SetLogging(false)
// Define a result set without passing a condition to Find(), this means we
// want to match all the elements on the books table.
res := sess.Collection("books").Find()
// We can use this res object later in different queries, here we'll use it
// to fetch all the books on our catalog in descending order.
var books []Book
if err := res.OrderBy("title DESC").All(&books); err != nil {
log.Fatal(err)
}
// The books slice has been populated!
log.Println("Books:")
for _, book := range books {
log.Printf("%q (ID: %d)\n", book.Title, book.ID)
}
}
func main() {
// Establish a connection.
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close() // Close the connection at the end of the program.
log.Println("Connection established!")
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
howManyBooks, err := sess.Collection("books").Find().Count()
if err != nil {
log.Fatal(err)
}
log.Printf("We have %d books in our database.\n", howManyBooks)
}
func main() {
settings, err := postgresql.ParseURL(connectDSN)
if err != nil {
log.Fatal(err)
}
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
log.Println("Connection established!")
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
req := sess.Collection("stock").Find()
log.Println("Items in stock:")
var item Stock
for req.Next(&item) {
log.Printf("%#v", item)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
req := sess.Collection("employees").Find().OrderBy("last_name")
log.Println("A list of employees:")
var employee Employee
for req.Next(&employee) {
log.Printf("#%d: %s\n", employee.ID, employee.LastName)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
var book Book
if err := sess.Collection("books").Find("title LIKE ?", "Perl%").One(&book); err != nil {
log.Fatal(err)
}
log.Println("We have one Perl related book:")
log.Printf("%q (ID: %d)\n", book.Title, book.ID)
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
res := sess.Collection("customers").Find().OrderBy("last_name")
defer res.Close()
log.Println("Our customers:")
var customer Customer
for res.Next(&customer) {
log.Printf("%d: %s, %s\n", customer.ID, customer.LastName, customer.FirstName)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
var books []Book
err = sess.Collection("books").Find().All(&books)
if err != nil {
log.Fatal(err)
}
for _, book := range books {
log.Printf("%q (ID: %d)\n", book.Title, book.ID)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
type joinResult struct {
// Note that the ID field is ambiguous, that's why we need this field.
ID int `db:"book_id"`
Book `db:",inline"`
Author `db:",inline"`
Subject `db:",inline"`
}
req := sess.Select(
"b.id AS book_id", // See ID field on joinResult type.
db.Raw("b.*"),
db.Raw("a.*"),
db.Raw("s.*"),
).From("books b").
Join("authors a").On("b.author_id = a.id").
Join("subjects s").On("b.subject_id = s.id").
OrderBy("b.title")
iter := req.Iterator()
var books []joinResult
if err := iter.All(&books); err != nil {
log.Fatal(err)
}
for _, book := range books {
log.Printf(
"Book: %q. ID: %d, Author: %s, %s. Subject: %s. Location: %s\n",
book.Book.Title,
book.ID,
book.Author.LastName,
book.Author.FirstName,
book.Subject.Subject,
book.Subject.Location,
)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
// Check if we have any employee with a NULL name.
req := sess.Collection("employees").Find().Where("first_name IS NULL")
var employee Employee
if err := req.One(&employee); err != nil {
log.Printf("All employees have a first name!")
return
}
log.Printf("The employee #%d %q has no name (%#v).", employee.ID, employee.LastName, employee)
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
req := sess.SelectFrom("books").OrderBy("id")
var books []Book
iter := req.Iterator()
if err := iter.All(&books); err != nil {
log.Fatal(err)
}
log.Printf("A list of books:")
for _, book := range books {
log.Printf("%#v\n", book)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
var res db.Result
res = sess.Collection("authors").Find().OrderBy("last_name").Limit(5)
var authors []Author
if err := res.All(&authors); err != nil {
log.Fatal(err)
}
log.Println("Authors (5):")
for _, author := range authors {
log.Printf(
"Last Name: %s\tID: %d\n",
author.LastName,
author.ID,
)
}
res = sess.Collection("employees").Find().OrderBy("last_name").Limit(5)
var employees []Author
if err := res.All(&employees); err != nil {
log.Fatal(err)
}
log.Println("Employees (5):")
for _, employee := range employees {
log.Printf(
"Last Name: %s\tID: %d\n",
employee.LastName,
employee.ID,
)
}
}
func main() {
sess, err := postgresql.Open(settings)
if err != nil {
log.Fatal(err)
}
defer sess.Close()
since := time.Date(2001, time.September, 1, 0, 0, 0, 0, time.Local)
until := time.Date(2001, time.October, 1, 0, 0, 0, 0, time.Local).Add(time.Second * -1)
req := sess.Collection("shipments").Find().
Where("ship_date > ? AND ship_date < ?", since, until).
OrderBy("ship_date")
log.Printf("Shipments between %v and %v:\n", since, until)
var shipment Shipment
for req.Next(&shipment) {
log.Printf("When: %v, ISBN: %s\n", shipment.ShipDate, shipment.ISBN)
}
}