Multi tool use

GORM DB Connection on other package

I start learning Go, reading about pointers, and want to split my database connection , and handler function for API. Already tried myself, by following this solution , but when i trying to read data, i am having this error

[2018-06-26 21:59:45] sql: database is closed
this is my source code.

db.go

package db

import (
"fmt"

"github.com/jinzhu/gorm"
"github.com/joho/godotenv"

"os"
)

var Db *gorm.DB

func Open() error {

var err error
_ = godotenv.Load(".env")

dbType := os.Getenv("DB_TYPE")
dbConnString := os.Getenv("DB_CONN_STRING")

Db, err = gorm.Open(dbType, dbConnString)
if err != nil {
fmt.Println(err)
}
Db.LogMode(true)
defer Db.Close()

return err
}

func Close() error {
return Db.Close()
}


person.go

package model

import (
"github.com/jinzhu/gorm"
"github.com/gin-gonic/gin"
"fmt"
"namastra/gin/result"
"namastra/gin/db"
)

type Person struct {
gorm.Model
FirstName string `json:”firstname”`
LastName string `json:”lastname”`
}

/*var db *gorm.DB
var err error*/

func GetPeople(c *gin.Context) {

var people result.Person
if err := db.Db.Select("ID,first_name,last_name").Find(&people).Error; err != nil {
c.AbortWithStatus(404)
fmt.Println(err)
} else {
c.JSON(200, people)
}
}


main.go

package main

import (
"log"
"namastra/gin/handler"
"namastra/gin/model"
"net/http"
"time"

"github.com/adam-hanna/jwt-auth/jwt"
"github.com/gin-gonic/gin"
_ "github.com/jinzhu/gorm/dialects/postgres"

"namastra/gin/db"
)

func main() {
if err := db.Open(); err != nil {
// handle error
panic(err)
}
defer db.Close()

router := gin.Default()
router.Use(gin.Recovery())
private := router.Group("/auth")

....(ommited)

router.GET("/", gin.WrapH(regularHandler))
router.GET("/people/", model.GetPeople)
router.Run("127.0.0.1:3000")
}


Sorry for my bad english, any kind of help is appreciated.

thank you.

edit1: case closed.

solution is by removing

defer Db.Close()


from db.go.

edi2: update some knowledge i learn by working in go project

defer Db.Close()

1 Answer
1

As start learning GO, usually we put everything on single main.go file, and we think to split the code to multiple files.

That is the time Dependency Injection comes to play.

we can create something like this Env to store the handler.

type Env struct {
db *sql.DB
logger *log.Logger
templates *template.Template
}


and create something like this in models/db.go

package models

import (
"database/sql"
_ "github.com/lib/pq"
)

func NewDB(dataSourceName string) (*sql.DB, error) {
db, err := sql.Open("postgres", dataSourceName)
if err != nil {
return nil, err
}
if err = db.Ping(); err != nil {
return nil, err
}
return db, nil
}


main.go files

package main

import (
"namastra/gin/models"
"database/sql"
"fmt"
"log"
"net/http"
)

type Env struct {
db *sql.DB
}

func main() {
db, err := models.NewDB("postgres://user:pass@localhost/bookstore")
if err != nil {
log.Panic(err)
}
env := &Env{db: db}

http.HandleFunc("/peoples", env.peoplesIndex)
http.ListenAndServe(":3000", nil)
}

func (env *Env) peoplesIndex(w http.ResponseWriter, r *http.Request) {
# ...
}


and in models/people.go

package models

import "database/sql"

type Book struct {
Isbn string
Title string
Author string
Price float32
}

func AllPeoples(db *sql.DB) (*People, error) {
rows, err := db.Query("SELECT * FROM peoples")
if err != nil {
return nil, err
}
defer rows.Close()

# ... ommited for simplicity
}


you can read the full code & explanation in Alex Edwards post

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.