Connection Pooling

In this lesson, explore connection pooling through one small Go program, and connect its output to the language rules behind it.

A *sql.DB is a concurrency-safe pool handle. Controls such as SetMaxOpenConns, SetMaxIdleConns, and SetConnMaxLifetime tune resource reuse and the number of simultaneous connections.

Pool limits should be based on database capacity and observed load. An overly small pool can create waiting; a huge pool can overload the database.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

The zero-value handle above is used solely to demonstrate setters and statistics; production code must first create a properly initialized handle with sql.Open. Reference: Managing connections.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import (
	"database/sql"
	"fmt"
	"time"
)

func main() {
	db := new(sql.DB)
	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(2)
	db.SetConnMaxLifetime(time.Minute)
	fmt.Println("Max open:", db.Stats().MaxOpenConnections)
}

Output

Max open: 10

The example configures a pool handle and reads its maximum-open limit as 10. It does not attempt SQL operations or connect to a database.

• Do not use a zero-value *sql.DB for actual queries; obtain a real handle from sql.Open.
• Pool tuning must respect server-side connection limits.

Configure a real sql.Open handle and inspect DB.Stats under representative concurrent requests.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Connection Pooling in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.