This is our fourth tutorial in our series building a rest api with golang.Make sure your have read our previous tutorial Planning Our Project.
You can find the code for this tutorial on Github
In this tutorial we are going to learn how we can define our models using gorm which is a golang orm library.
This will allow us to easily query,update,add and delete data from our postgres database with minimal effort.
With gorm making foreign keys and database indexes will also be a very trivial activity.
Making the database connection
To start off make a database called delivery in your postgres this is the database we will be using.
For gorm to be able to access the database we need to make a connection.
To avoid circular import we have created a package called database.
Open the database.go and copy the following code.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package database
import "github.com/jinzhu/gorm"
var (
DBCon *gorm.DB
)
func InitDB() {
var err error
//connect to postgres database
DBCon, err = gorm.Open("postgres", "host=localhost port=myport user=gorm dbname=delivery password=mypassword")
//where myhost is port is the port postgres is running on
//user is your postgres use name
//password is your postgres password
if err != nil {
panic("failed to connect database")
}
}
|
Finally we now need to initialize the database in our main.go file.
Open the main.go and copy the code below.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main
import (
"food-delivery/database"
_ "github.com/jinzhu/gorm/dialects/postgres"
)
func main() {
////initialize the database
database.InitDB()
///finally close the connection when you are done
defer database.DBCon.Close()
}
|
Every thing is now in order we can now connect to our database and query our data.
But One thing is missing in our database,the table to store our data
In gorm tables are defined by use of a models(struct).In the next section we are going to define our models.
Defining Our Models In Gorm.
Now that we already know all the models that we need in our projects let go ahead and make them.
Open the models.go file we created in the third tutorial and copy the code below.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
package models
import "time"
type Food struct {
//food will contains this fields....
//we have also defined they type
ID int `json:"id,primary_key"` //this will be the primary key field
Name int `gorm:"size:255"` ///the name field will only allow a maximum of 255 characters
OrderItems []OrderItems
//this defines the relationship between orderitems and food
//its says that one food can belong to many orderitems and foodId is the foreign_key
Price float64
CreatedAt time.Time
UpdatedAt time.Time
}
type User struct {
//this represents the customer
ID int `json:"id,primary_key"` //this will be the primary key field
FirstName string `gorm:"size:255"`
SecondName string `gorm:"size:255"`
Orders []Orders
//this defines the relationship between orders and users
//its says that one user can have to many orders and UserID is the foreign_key in the order table
AddressID int
///address_id is a foreign_key from the address table....
CreatedAt time.Time
UpdatedAt time.Time
}
type Orders struct {
ID int `json:"id,primary_key"` //this will be the primary key field
OrderItems []OrderItems
//this defines the relationship between orders and orderitems
//its says that one order can have many orderitems and OrderId is the foreign_key in the orderitems table
UserID int `json:"user_id"` ///this is a foreign_key from the user_table
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type OrderItems struct {
ID int `json:"id,primary_key"` //this will be the primary key field
OrderId int //this is foreign_key from the order table
FoodID int //this is foreign_key from the food table
Price int `json:"price"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type Address struct {
ID int `json:"id,primary_key"` //this will be the primary key field
User []User
//this defines the relationship between users and Address
//its says that one address can belong to many users and is the foreign_key address_id
AddressName string `gorm:"size:255"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
|
Short Explanation
foreign_key-this are used to define the relationship between two tables.For Example a user can have many emails.
If we were to represent this information we would have two tables.One called user tables and another email.
In the email table we would have user_id as a foreign key.
table names -the table name will be the pluralized version of our model names.
For example the table name for Food will be foods.
You can change this behaviour and provide your own table name.
Nice with that all our models and tables are now ready.
However there is one more thing that we have not done.
That is running our database migration so that we can persist our tables in our postgres database.
In the next tutorial we are going to look at gorm migration and how they are done.
After we will be good to go.
Conclusion
In this tutorial we have learnt the basics of how models are defined using gorm.
As you will learn later you can also define a field that cannot be null.
However this is enough to make a basic go api.
In the next tutorial we are going to learn how you can run migration in golang.
See you in the next tutorial.Happy Coding!!.
