I am facing a problem in the methods that I want to resolve. The error occurs when I’m attempting to execute a method AmountInsertion() on a struct MyTotalAmount. MyTotalAmount embeds another struct MyDatabase, which implements the inter.Database interface.

./db:
    connection.go
    file.SQL
    insertamount.go

./inter:
    interface.go

./total_amount:
    total_amount.go

After executing this code, I am getting this error:

Error

panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x0 pc=0xa8bff0]

goroutine 1 [running]:
main.MyTotalAmount.AmountInsertion(...)
        D:/go/src/github.com/ibilalkayy/test/main.go:367
main.main()
        D:/go/src/github.com/ibilalkayy/test/main.go:376 +0x10
exit status 2

Here is the interface:

package inter

import "database/sql"

type Database interface {
    Connection() (*sql.DB, error)
    Table(number int) (*sql.DB, error)
    InsertAmount(total, spent, remaining int) error
} 

Here is the db package:

package db

import (
    "database/sql"
    "fmt"
    "errors"
    "os"
    "strings"

    "github.com/ibilalkayy/test/inter"
)

type MyDatabase struct {
    inter.Database
}

func (m MyDatabase) Connection() (*sql.DB, error) {
    connectStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s", "localhost", "5432", "postgres", "1122", "flow", "disable")
    db, err := sql.Open("postgres", connectStr)
    if err != nil {
        return nil, err
    }

    err = db.Ping()
    if err != nil {
        return nil, err
    }
    fmt.Println("Connected successfully")
    return db, nil
}

func (m MyDatabase) Table(number int) (*sql.DB, error) {
    db, err := m.Connection()
    if err != nil {
        return nil, err
    }

    query, err := os.ReadFile("db/file.SQL")
    if err != nil {
        return nil, err
    }

    requests := strings.Split(string(query), ";")[number]
    stmt, err := db.Prepare(requests)
    if err != nil {
        return nil, err
    }

    _, err = stmt.Exec()
    if err != nil {
        return nil, err
    }
    return db, nil
}

func (m MyDatabase) InsertAmount(total, spent, remaining, status int) error {
    data, err := m.Table(0)
    if err != nil {
        return err
    }
    query := "INSERT INTO TotalAmount(total_amount, spent_amount, remaining_amount) VALUES($1, $2, $3)"
    insert, err := data.Prepare(query)
    if err != nil {
        return err
    }

    defer insert.Close()

    if total != 0 {
        _, err = insert.Exec(total, spent, remaining)
        if err != nil {
            return err
        }
        fmt.Println("Total amount data is successfully inserted!")
    } else {
        return errors.New("write total amount and category. see 'flow total-amount set -h'")
    }
    return nil
}

Here is the main package:

type MyTotalAmount struct {
    inter.Database
}

func (n MyTotalAmount) AmountInsertion() error {
    err := n.InsertAmount(100, 50, 50)
    if err != nil {
        return err
    }
    return nil
}

func main() {
    var myAmount MyTotalAmount
    err := myAmount.AmountInsertion()
    if err != nil {
        log.Fatal(err)
    }
}