How can i mock database calls without a library?

i've been trying to wrap my head around unit testing, dependency injection, tdd and all that stuff and i've been stuck on testing functions that make database calls, for example.

Let's say you have a PostgresStore struct that takes in a Database interface, which has a Query() method.

type PostgresStore struct {
	db Database
}

type Database interface {
	Query(query string, args ...interface{}) (*sql.Rows, error)
}

And your PostgresStore has a GetPatients method, which calls database query.

func (p *PostgresStore) GetPatients() ([]Patient, error) {
	rows, err := p.db.Query("SELECT id, name, age, insurance FROM patients")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Patient{}
	for rows.Next() {
		var i Patient
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Surname,
			&i.Age,
			&i.InsuranceCompany,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

In the real implementation, you would just pass a *sql.DB as Database argument, but how would you guys write a unit test with a fake database struct?

let me try to clarify some of your doubts. First of all, I'm gonna share a working example to better understand what's going on. Then, I'm gonna mention all of the relevant aspects.

repo/db.go

package repo

import "database/sql"

type Patient struct {
	ID               int
	Name             string
	Surname          string
	Age              int
	InsuranceCompany string
}

type PostgresStore struct {
	// rely on the generic DB provided by the "sql" package
	db *sql.DB
}

func (p *PostgresStore) GetPatient(id int) ([]Patient, error) {
	rows, err := p.db.Query("SELECT id, name, age, insurance FROM patients")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Patient{}
	for rows.Next() {
		var i Patient
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Surname,
			&i.Age,
			&i.InsuranceCompany,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

Here, the only relevant change is how you define the PostgresStore struct. As the db field, you should rely on the generic DB provided by the database/sql package of the Go Standard Library. Thanks to this, it's trivial to swap its implementation with a fake one, as we're gonna see later.
> Please note that in the GetPatient method you're accepting an id parameter but you're not using it. Your query is more suitable to a method like GetAllPatients or something like that. Be sure to fix it accordingly.

repo/db_test.go

package repo

import (
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"
)

func TestGetPatient(t *testing.T) {
	// 1. set up fake db and mock
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("err not expected: %v", err)
	}

	// 2. configure the mock. What we expect (query or command)? The outcome (error vs no error).
	rows := sqlmock.NewRows([]string{"id", "name", "surname", "age", "insurance"}).AddRow(1, "john", "doe", 23, "insurance-test")
	mock.ExpectQuery("SELECT id, name, age, insurance FROM patients").WillReturnRows(rows)

	// 3. instantiate the PostgresStore with the fake db
	sut := &PostgresStore{
		db: db,
	}

	// 4. invoke the action we've to test
	got, err := sut.GetPatient(1)

	// 5. assert the result
	assert.Nil(t, err)
	assert.Contains(t, got, Patient{1, "john", "doe", 23, "insurance-test"})
}

Here, there are a lot to cover. First, you can check the comments within the code that give you a better idea of each step. In the code, we're relying on the package github.com/DATA-DOG/go-sqlmock that allows us to easily mock a database client.

Obviously, the purpose of this code is to give a general idea on how to implement your needs. It can be written in a better way but it can be a good starting point for writing tests in this scenario.

Let me know if this helps, thanks!