Gin, Gorm, PostgreSQL을 사용한 Golang RESTful API

라우팅에 gin, ORM에 gorm, 데이터베이스로 PostgreSQL을 사용하는 Golang RESTful API 서비스의 종합적인 예입니다. 이 예에는 데이터베이스 및 테이블 생성, 데이터 삽입 및 쿼리, 인덱싱, 함수 및 저장 프로시저, 트리거, 뷰, CTE, 트랜잭션, 제약 조건, JSON 처리 등 PostgreSQL 기능이 포함되어 있습니다.

1. 프로젝트 설정

PostgreSQL, Golang 및 go 모드가 설정되어 있다고 가정하고 프로젝트를 초기화합니다.

mkdir library-api
cd library-api
go mod init library-api

프로젝트 구조

/library-api
|-- db.sql
|-- main.go
|-- go.mod

2. 종속성 설치

필요한 패키지 설치:

go get github.com/gin-gonic/gin
go get gorm.io/gorm
go get gorm.io/driver/postgres

3. PostgreSQL 스키마

다음은 데이터베이스 스키마를 생성하기 위한 SQL 스크립트입니다.

-- Create the library database.
CREATE DATABASE library;

-- Connect to the library database.
\c library;

-- Create tables.
CREATE TABLE authors (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL UNIQUE,
    bio TEXT
);

CREATE TABLE books (
    id SERIAL PRIMARY KEY,
    title VARCHAR(200) NOT NULL,
    -- This creates a foreign key constraint:
    -- It establishes a relationship between author_id in the books table and the id column in the authors table, ensuring that each author_id corresponds to an existing id in the authors table.
    -- ON DELETE CASCADE: This means that if an author is deleted from the authors table, all related records in the books table (i.e., books written by that author) will automatically be deleted as well.
    author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE,
    published_date DATE NOT NULL,
    description TEXT,
    details JSONB
);

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- CREATE TABLE borrow_logs (
--     id SERIAL PRIMARY KEY,
--     user_id INTEGER REFERENCES users(id),
--     book_id INTEGER REFERENCES books(id),
--     borrowed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
--     returned_at TIMESTAMP
-- );

-- Create a partitioned table for borrow logs based on year.
-- The borrow_logs table is partitioned by year using PARTITION BY RANGE (borrowed_at).
CREATE TABLE borrow_logs (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    book_id INTEGER REFERENCES books(id),
    borrowed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    returned_at TIMESTAMP
) PARTITION BY RANGE (borrowed_at);

-- Create partitions for each year.
-- Automatic Routing: PostgreSQL automatically directs INSERT operations to the appropriate partition (borrow_logs_2023 or borrow_logs_2024) based on the borrowed_at date.
CREATE TABLE borrow_logs_2023 PARTITION OF borrow_logs
    FOR VALUES FROM ('2023-01-01') TO ('2024-01-01');

CREATE TABLE borrow_logs_2024 PARTITION OF borrow_logs
    FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');
-- Benefit: This helps in improving query performance and managing large datasets by ensuring that data for each year is stored separately.



-- Indexes for faster searching.
CREATE INDEX idx_books_published_date ON books (published_date);
CREATE INDEX idx_books_details ON books USING GIN (details);
-- GIN Index (Generalized Inverted Index).  It is particularly useful for indexing columns with complex data types like arrays, JSONB, or text search fields


-- Add a full-text index to the title and description of books
CREATE INDEX book_text_idx ON books USING GIN (to_tsvector('english', title || ' ' || description));
-- to_tsvector('english', ...) converts the concatenated title and description fields into a Text Search Vector (tsv) suitable for full-text searching.
-- The || operator concatenates the title and description fields, so both fields are indexed together for searching.
-- 'english' specifies the language dictionary, which helps with stemming and stop-word filtering.


-- Create a simple view for books with author information.
CREATE VIEW book_author_view AS
SELECT books.id AS book_id, books.title, authors.name AS author_name
FROM books
JOIN authors ON books.author_id = authors.id;

-- Create a view to get user borrow history
CREATE VIEW user_borrow_history AS
SELECT
    u.id AS user_id,
    u.name AS user_name,
    b.title AS book_title,
    bl.borrowed_at,
    bl.returned_at
FROM
    users u
    JOIN borrow_logs bl ON u.id = bl.user_id
    JOIN books b ON bl.book_id = b.id;

-- Use a CTE to get all active borrow logs (not yet returned)
WITH active_borrows AS (
    SELECT * FROM borrow_logs WHERE returned_at IS NULL
)
SELECT * FROM active_borrows;

-- Function to calculate the number of books borrowed by a user.
-- Creates a function that takes an INT parameter user_id and returns an INT value. If the function already exists, it will replace it.
CREATE OR REPLACE FUNCTION get_borrow_count(user_id INT) RETURNS INT AS $$
    --  is a placeholder for the first input. When the function is executed, PostgreSQL replaces  with the actual user_id value that is passed in by the caller.
    SELECT COUNT(*) FROM borrow_logs WHERE user_id = ;
$$ LANGUAGE SQL;
-- AS $$ ... $$: This defines the body of the function between the dollar signs ($$).
-- LANGUAGE SQL: Specifies that the function is written in SQL.


-- Trigger to log activities.
CREATE TABLE activity_logs (
    id SERIAL PRIMARY KEY,
    description TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE OR REPLACE FUNCTION log_activity() RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO activity_logs (description)
    -- NEW refers to the new row being inserted or modified by the triggering event.
    VALUES ('A borrow_log entry has been added with ID ' || NEW.id);
    -- The function returns NEW, which means that the new data will be used as it is after the trigger action.
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- It uses plpgsql, which is a procedural language in PostgreSQL

CREATE TRIGGER log_borrow_activity
AFTER INSERT ON borrow_logs
FOR EACH ROW EXECUTE FUNCTION log_activity();

-- Add a JSONB column to store metadata
ALTER TABLE books ADD COLUMN metadata JSONB;
-- Example metadata: {"tags": ["fiction", "bestseller"], "page_count": 320}

4. 골랭 코드

다음은 Gin 및 GORM을 사용하는 RESTful API의 전체 예입니다.

package main

import (
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

type Author struct {
    ID   uint   `gorm:"primaryKey"`
    Name string `gorm:"not null;unique"`
    Bio  string
}

type Book struct {
    ID            uint                   `gorm:"primaryKey"`
    Title         string                 `gorm:"not null"`
    AuthorID      uint                   `gorm:"not null"`
    PublishedDate time.Time              `gorm:"not null"`
    Details       map[string]interface{} `gorm:"type:jsonb"`
}

type User struct {
    ID        uint   `gorm:"primaryKey"`
    Name      string `gorm:"not null"`
    Email     string `gorm:"not null;unique"`
    CreatedAt time.Time
}

type BorrowLog struct {
    ID         uint      `gorm:"primaryKey"`
    UserID     uint      `gorm:"not null"`
    BookID     uint      `gorm:"not null"`
    BorrowedAt time.Time `gorm:"default:CURRENT_TIMESTAMP"`
    ReturnedAt *time.Time
}

var db *gorm.DB

func initDB() {
    dsn := "host=localhost user=postgres password=yourpassword dbname=library port=5432 sslmode=disable"
    var err error
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect to database")
    }

    // Auto-migrate models.
    db.AutoMigrate(&Author{}, &Book{}, &User{}, &BorrowLog{})
}

func main() {
    initDB()
    r := gin.Default()

    r.POST("/authors", createAuthor)
    r.POST("/books", createBook)
    r.POST("/users", createUser)
    r.POST("/borrow", borrowBook)
    r.GET("/borrow/:id", getBorrowCount)
    r.GET("/books", listBooks)

    r.Run(":8080")
}

func createAuthor(c *gin.Context) {
    var author Author
    if err := c.ShouldBindJSON(&author); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    if err := db.Create(&author).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, author)
}

func createBook(c *gin.Context) {
    var book Book
    if err := c.ShouldBindJSON(&book); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    if err := db.Create(&book).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, book)
}

func createUser(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    if err := db.Create(&user).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, user)
}

// The Golang code does not need changes specifically to use the partitioned tables; the partitioning is handled by PostgreSQL
// you simply insert into the borrow_logs table, and PostgreSQL will automatically route the data to the correct partition.
func borrowBook(c *gin.Context) {
    var log BorrowLog
    if err := c.ShouldBindJSON(&log); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    tx := db.Begin()
    if err := tx.Create(&log).Error; err != nil {
        tx.Rollback()
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    tx.Commit()
    c.JSON(http.StatusOK, log)
}

func getBorrowCount(c *gin.Context) {
    userID := c.Param("id")
    var count int
    if err := db.Raw("SELECT get_borrow_count(?)", userID).Scan(&count).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"borrow_count": count})
}

// When querying a partitioned table in PostgreSQL using Golang, no changes are needed in the query logic or code.
// You interact with the parent table (borrow_logs in this case) as you would with any normal table, and PostgreSQL automatically manages retrieving the data from the appropriate partitions.
// Performance: PostgreSQL optimizes the query by scanning only the relevant partitions, which can significantly speed up queries when dealing with large datasets.
// Here’s how you might query the borrow_logs table using GORM, even though it’s partitioned:
func getBorrowLogs(c *gin.Context) {
    var logs []BorrowLog
    if err := db.Where("user_id = ?", c.Param("user_id")).Find(&logs).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, logs)
}

func listBooks(c *gin.Context) {
    var books []Book
    db.Preload("Author").Find(&books)
    c.JSON(http.StatusOK, books)
}

Golang 코드 설명:

• 데이터베이스 초기화: PostgreSQL 데이터베이스에 연결하고 GORM을 초기화합니다.
• 경로: 저자, 도서, 사용자 생성, 도서 대출, 대출 횟수 가져오기를 위한 경로를 정의합니다.
• 거래 처리: 일관성을 보장하기 위해 책을 빌릴 때 거래를 사용합니다.
• Preload: GORM의 Preload를 사용하여 관련 테이블(책이 있는 저자)을 조인합니다.
• 저장 프로시저 호출: db.Raw를 사용하여 빌림 횟수 계산을 위한 사용자 정의 PostgreSQL 함수를 호출합니다.

5. API 실행

• PostgreSQL SQL 스크립트를 실행하여 테이블, 인덱스, 뷰, 함수 및 트리거를 생성합니다.

• 다음을 사용하여 Golang 서버를 시작하세요
  

   go run main.go
  

이제 다양한 PostgreSQL 기능을 포함하는 포괄적인 Golang RESTful API가 있어 학습이나 인터뷰를 위한 강력한 예시가 되었습니다.

6. 더 많은 기능을 추가합니다.

Views, CTE(Common Table Expressions), 전체 텍스트 인덱싱을 통합하여 추가 PostgreSQL 기능으로 Golang RESTful API 예제를 개선해 보겠습니다. 및 JSON 처리. 이러한 각 기능은 관련 PostgreSQL 테이블 정의 및 Golang 코드와 상호 작용하여 시연됩니다.

이 부분에 대한 데이터 스키마는 이미 지난 섹션에서 준비되어 있으므로 golang 코드를 더 추가하면 됩니다.

mkdir library-api
cd library-api
go mod init library-api

기능 요약:

• 뷰: user_borrow_history 뷰를 통해 데이터 액세스를 단순화하여 복잡한 조인을 더 쉽게 쿼리할 수 있습니다.
• CTE: 활성 차용 로그 가져오기와 같은 구성된 쿼리에 WITH 절을 사용하세요.
• 전체 텍스트 색인: to_tsVector에 GIN 색인이 있는 도서에 대한 검색 기능을 향상합니다.

• JSON 처리:

  • JSONB 유형을 사용하여 풍부한 메타데이터를 저장하고 업데이트합니다.
  • getBookTags는 메타데이터 JSONB 열에서 특정 JSON 필드(태그)를 검색합니다.
  • updateBookPageCount는 메타데이터 JSONB 열의 page_count 필드를 업데이트하거나 추가합니다.

  GORM이 포함된 원시 SQL에 db.Raw 및 db.Exec를 사용하면 PostgreSQL의 강력한 기능을 활용하는 동시에 애플리케이션의 다른 부분에 대해 GORM의 ORM 기능을 유지할 수 있습니다. 이로 인해 솔루션이 유연해지고 기능이 풍부해졌습니다.

7. 기타 고급 기능

이 확장된 예에서는 Golang과 PostgreSQL을 사용하여 다음 기능을 통합하는 방법을 보여 드리겠습니다.

1. VACUUM: 데드 튜플이 차지하는 스토리지를 회수하고 테이블 팽창을 방지하는 데 사용됩니다.
2. MVCC: 행의 서로 다른 버전을 유지하여 동시 트랜잭션을 허용하는 개념.
3. 창 함수: 현재 행과 관련된 테이블 행 집합에 대해 계산을 수행하는 데 사용됩니다.

1. Golang에서 VACUUM 사용하기

VACUUM은 일반적으로 애플리케이션 코드에서 직접 사용되지 않고 유지 관리 작업으로 사용됩니다. 그러나 관리 목적으로 GORM의 Exec을 사용하여 실행할 수 있습니다.

/library-api
|-- db.sql
|-- main.go
|-- go.mod

• VACUUM ANALYZE books: 스토리지를 회수하고 쿼리 플래너가 books 테이블에 사용하는 통계를 업데이트합니다.
• VACUUM 실행은 일반적으로 사용량이 적은 시간에 수행되거나 각 요청이 아닌 유지 관리 스크립트의 일부로 수행됩니다.

2. MVCC(다중 버전 동시성 제어) 이해

PostgreSQL의 MVCC는 다양한 버전의 행을 유지하여 동시 트랜잭션을 허용합니다. 다음은 트랜잭션을 사용하여 Golang에서 MVCC 동작을 시연하는 방법에 대한 예입니다.

go get github.com/gin-gonic/gin
go get gorm.io/gorm
go get gorm.io/driver/postgres

• FOR UPDATE: 트랜잭션 중에 업데이트를 위해 선택한 행을 잠가서 현재 트랜잭션이 완료될 때까지 다른 트랜잭션이 이를 수정하지 못하도록 합니다.
• 이는 동시 액세스 중에 일관성을 보장하며 MVCC가 동시 읽기를 허용하지만 업데이트를 위해 행을 잠그는 방법을 보여줍니다.

3. GORM에서 창 함수 사용하기

창 함수는 현재 행과 관련된 테이블 행 집합에 대해 계산을 수행하는 데 사용됩니다. 다음은 각 저자의 누적 대출 누계를 계산하기 위해 윈도우 기능을 사용하는 예입니다.

mkdir library-api
cd library-api
go mod init library-api

• SUM(COUNT(bl.id)) OVER (PARTITION BY a.id ORDER BY bl.borrowed_at):borrowed_at 날짜순으로 정렬하여 저자별 대출 도서 누계를 계산하는 창 함수입니다.
• 이를 통해 각 저자의 대출 추세가 시간에 따라 어떻게 변하는지와 같은 통찰력을 얻을 수 있습니다.

위 내용은 Gin, Gorm, PostgreSQL을 사용한 Golang RESTful API의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!