Golang
2024.07.19
2024.10.03
0

【Golang】Gormで独自の型を使う方法

Golang
, DB
, gorm

この記事はで読むことができます。

Contents

1 はじめに
2 独自型を使う利点
3 基本的な独自型の実装
4 Scanner と Valuer インターフェースの実装
5 独自型を使ったモデルの定義
6 より複雑な独自型の例
7 独自型を使う際の注意点
8 独自型の活用例
9 まとめ

はじめに

Gormは、Go言語用の人気のあるORMライブラリです。ORMとは「Object-Relational Mapping」の略で、データベースとオブジェクト指向プログラミング言語の間の「通訳」のような役割を果たします。Gormを使うと、データベース操作をより簡単に、そして柔軟に行うことができます。

本記事では、Gormを使って独自の型（カスタム型）をデータベースで扱う方法について詳しく解説します。独自型を使うことで、アプリケーションの要件に合わせてデータの扱い方をカスタマイズでき、より表現力豊かなコードを書くことができます。

独自型を使う利点

独自型を使うことには、いくつかの大きな利点があります。

データの意味をより明確に表現できる: 例えば、単なる文字列ではなく「Email型」や「郵便番号型」を定義することで、コードの意図がより明確になります。
型安全性の向上: Go言語の型システムを活用して、誤った型の使用を防ぐことができます。
ビジネスロジックのカプセル化: データの検証や変換のロジックを型自体に含めることができ、コードの再利用性が高まります。
データベースとの柔軟なマッピング: 独自の方法でデータをシリアライズ/デシリアライズすることで、データベースのスキーマとGoの型を柔軟に対応付けられます。

それでは、具体的な実装方法を見ていきましょう。

基本的な独自型の実装

まず、最も基本的な独自型の実装方法を見ていきます。ここでは、電話番号を表す独自型を例に説明します。

type PhoneNumber string

type User struct {
    ID          uint
    Name        string
    PhoneNumber PhoneNumber
}

type PhoneNumber string

type User struct {

ID uint

Name string

PhoneNumber PhoneNumber

}

この例では、PhoneNumberという独自型を定義しています。この型は内部的にはstring型ですが、電話番号であることを明示的に示すことができます。

Gormは、このような単純な独自型を自動的に扱うことができます。つまり、特別な設定をしなくても、データベースへの保存や読み込みが可能です。

db.Create(&amp;User{Name: "John Doe", PhoneNumber: "090-1234-5678"})

1	db.Create(&User{Name: "John Doe", PhoneNumber: "090-1234-5678"})

この方法は簡単ですが、電話番号の形式を制限したり、特別な処理を加えたりすることはできません。より高度な制御が必要な場合は、次のセクションで説明する方法を使います。

Scanner と Valuer インターフェースの実装

Goのdatabase/sql パッケージには、ScannerとValuerという2つの重要なインターフェースがあります。これらを実装することで、独自型とデータベース間のデータ変換をカスタマイズできます。

Scanner: データベースから値を読み込む際に使用
Valuer: データベースに値を保存する際に使用

以下に、これらのインターフェースを実装したPhoneNumber型の例を示します：

import (
    "database/sql/driver"
    "errors"
    "fmt"
    "regexp"
)

type PhoneNumber string

// Scan implements the sql.Scanner interface
func (p *PhoneNumber) Scan(value interface{}) error {
    strValue, ok := value.(string)
    if !ok {
        return errors.New("phone number must be a string")
    }

    if !isValidPhoneNumber(strValue) {
        return fmt.Errorf("invalid phone number format: %s", strValue)
    }

    *p = PhoneNumber(strValue)
    return nil
}

// Value implements the driver.Valuer interface
func (p PhoneNumber) Value() (driver.Value, error) {
    if !isValidPhoneNumber(string(p)) {
        return nil, fmt.Errorf("invalid phone number format: %s", string(p))
    }
    return string(p), nil
}

func isValidPhoneNumber(phone string) bool {
    pattern := `^\d{3}-\d{4}-\d{4}$`
    matched, _ := regexp.MatchString(pattern, phone)
    return matched
}

import (

"database/sql/driver"

"errors"

"fmt"

"regexp"

)

type PhoneNumber string

// Scan implements the sql.Scanner interface

func (p *PhoneNumber) Scan(value interface{}) error {

strValue, ok := value.(string)

if !ok {

return errors.New("phone number must be a string")

}

if !isValidPhoneNumber(strValue) {

return fmt.Errorf("invalid phone number format: %s", strValue)

}

*p = PhoneNumber(strValue)

return nil

}

// Value implements the driver.Valuer interface

func (p PhoneNumber) Value() (driver.Value, error) {

if !isValidPhoneNumber(string(p)) {

return nil, fmt.Errorf("invalid phone number format: %s", string(p))

}

return string(p), nil

}

func isValidPhoneNumber(phone string) bool {

pattern := `^\d{3}-\d{4}-\d{4}$`

matched, _ := regexp.MatchString(pattern, phone)

return matched

}

この実装では、以下のことを行っています。

Scanメソッド

データベースから読み込んだ値が文字列であることを確認
電話番号の形式が正しいかチェック
正しければ、その値をPhoneNumber型に設定

Valueメソッド

データベースに保存する前に、電話番号の形式が正しいかチェック
正しければ、その値を文字列として返す

isValidPhoneNumber関数

正規表現を使って、電話番号が「000-0000-0000」の形式であるかチェック

この実装により、データベースとの間でデータをやり取りする際に、電話番号の形式を自動的にチェックできます。不正な形式の電話番号はデータベースに保存されず、エラーが返されます。

独自型を使ったモデルの定義

先ほど定義したPhoneNumber型を使って、ユーザーモデルを定義してみましょう。

type User struct {
    ID          uint
    Name        string
    PhoneNumber PhoneNumber
}

type User struct {

ID uint

Name string

PhoneNumber PhoneNumber

}

このモデルを使ってデータベース操作を行う例を見てみます：

// ユーザーの作成
user := User{
    Name:        "田中太郎",
    PhoneNumber: "090-1234-5678",
}
result := db.Create(&amp;user)
if result.Error != nil {
    log.Fatal(result.Error)
}

// ユーザーの取得
var retrievedUser User
db.First(&amp;retrievedUser, user.ID)
fmt.Printf("Retrieved user: %+v\n", retrievedUser)

// 不正な電話番号でのユーザー作成（エラーになる）
invalidUser := User{
    Name:        "鈴木花子",
    PhoneNumber: "090-invalid-number",
}
result = db.Create(&amp;invalidUser)
if result.Error != nil {
    fmt.Printf("Error creating user: %v\n", result.Error)
}

// ユーザーの作成

user := User{

Name: "田中太郎",

PhoneNumber: "090-1234-5678",

}

result := db.Create(&user)

if result.Error != nil {

log.Fatal(result.Error)

}

// ユーザーの取得

var retrievedUser User

db.First(&retrievedUser, user.ID)

fmt.Printf("Retrieved user: %+v\n", retrievedUser)

// 不正な電話番号でのユーザー作成（エラーになる）

invalidUser := User{

Name: "鈴木花子",

PhoneNumber: "090-invalid-number",

}

result = db.Create(&invalidUser)

if result.Error != nil {

fmt.Printf("Error creating user: %v\n", result.Error)

}

この例では、正しい形式の電話番号を持つユーザーは問題なく作成されますが、不正な形式の電話番号を持つユーザーの作成はエラーになります。これにより、データベースに保存されるデータの整合性を保つことができます。

より複雑な独自型の例

電話番号以外にも、様々な独自型を定義できます。例えば、JSONデータを扱う独自型を作ってみましょう。

import (
    "database/sql/driver"
    "encoding/json"
    "errors"
)

type JSONData map&#91;string]interface{}

func (j *JSONData) Scan(value interface{}) error {
    bytes, ok := value.(&#91;]byte)
    if !ok {
        return errors.New("type assertion to &#91;]byte failed")
    }

    return json.Unmarshal(bytes, &amp;j)
}

func (j JSONData) Value() (driver.Value, error) {
    return json.Marshal(j)
}

type Product struct {
    ID       uint
    Name     string
    Metadata JSONData
}

import (

"database/sql/driver"

"encoding/json"

"errors"

)

type JSONData map[string]interface{}

func (j *JSONData) Scan(value interface{}) error {

bytes, ok := value.([]byte)

if !ok {

return errors.New("type assertion to []byte failed")

}

return json.Unmarshal(bytes, &j)

}

func (j JSONData) Value() (driver.Value, error) {

return json.Marshal(j)

}

type Product struct {

ID uint

Name string

Metadata JSONData

}

このJSONData型を使うと、データベース内でJSONデータを柔軟に扱うことができます。例えば：

product := Product{
    Name: "スマートフォン",
    Metadata: JSONData{
        "color":  "ブラック",
        "weight": 150,
        "dimensions": map&#91;string]int{
            "width":  70,
            "height": 140,
            "depth":  8,
        },
    },
}

db.Create(&amp;product)

var retrievedProduct Product
db.First(&amp;retrievedProduct, product.ID)
fmt.Printf("Retrieved product: %+v\n", retrievedProduct)

product := Product{

Name: "スマートフォン",

Metadata: JSONData{

"color": "ブラック",

"weight": 150,

"dimensions": map[string]int{

"width": 70,

"height": 140,

"depth": 8,

}

db.Create(&product)

var retrievedProduct Product

db.First(&retrievedProduct, product.ID)

fmt.Printf("Retrieved product: %+v\n", retrievedProduct)

この例では、製品の詳細情報を柔軟なJSONデータとして保存しています。データベースからデータを取得する際は、自動的にGo言語のmap型に変換されます。

独自型を使う際の注意点

独自型を使用する際は、以下の点に注意してください。

パフォーマンス: ScannerとValuerインターフェースの実装は、データベースとの通信の度に呼び出されます。複雑な処理を行う場合、パフォーマンスに影響を与える可能性があります。
NULL値の扱い: データベースでNULL値を許容する場合、それを適切に扱える実装が必要です。例えば、ポインタ型を使用するなどの工夫が必要になることがあります。
マイグレーション: 独自型を使用する場合、Gormの自動マイグレーション機能が正しく動作しない可能性があります。必要に応じて、手動でのマイグレーション管理を検討してください。
クエリの複雑さ: 独自型を使うと、クエリが複雑になる場合があります。特に、独自型のフィールドを使って検索や並べ替えを行う場合は注意が必要です。

独自型の活用例

独自型は、様々な場面で活用できます。以下にいくつかの例を示します。

メールアドレス

メールアドレスの形式を検証する独自型を作成できます。

   type Email string

   func (e *Email) Scan(value interface{}) error {
       // メールアドレスの形式をチェックするロジック
   }

   func (e Email) Value() (driver.Value, error) {
       // メールアドレスを文字列に変換するロジック
   }

type Email string

func (e *Email) Scan(value interface{}) error {

// メールアドレスの形式をチェックするロジック

}

func (e Email) Value() (driver.Value, error) {

// メールアドレスを文字列に変換するロジック

}

暗号化されたデータ

データベースに保存する前に自動的に暗号化し、読み込み時に復号化する独自型を作成できます。

   type EncryptedString string

   func (e *EncryptedString) Scan(value interface{}) error {
       // 復号化ロジック
   }

   func (e EncryptedString) Value() (driver.Value, error) {
       // 暗号化ロジック
   }

type EncryptedString string

func (e *EncryptedString) Scan(value interface{}) error {

// 復号化ロジック

}

func (e EncryptedString) Value() (driver.Value, error) {

// 暗号化ロジック

}

列挙型

定義された値のみを許可する列挙型を作成できます。

   type Status string

   const (
       StatusPending   Status = "pending"
       StatusApproved  Status = "approved"
       StatusRejected  Status = "rejected"
   )

   func (s *Status) Scan(value interface{}) error {
       // 有効な値かチェックするロジック
   }

   func (s Status) Value() (driver.Value, error) {
       // 文字列に変換するロジック
   }

type Status string

const (

StatusPending Status = "pending"

StatusApproved Status = "approved"

StatusRejected Status = "rejected"

)

func (s *Status) Scan(value interface{}) error {

// 有効な値かチェックするロジック

}

func (s Status) Value() (driver.Value, error) {

// 文字列に変換するロジック

}

これらの例は、アプリケーションのビジネスロジックをデータモデルに組み込むことで、コードの品質と保守性を向上させる方法を示しています。

まとめ

Gormで独自型を使うことで、データベース操作をより柔軟かつ安全に行うことができます。独自型を通じて、以下のような利点を得られます。

データの意味をより明確に表現できる
型安全性の向上
ビジネスロジックのカプセル化
データベースとの柔軟なマッピング

ScannerとValuerインターフェースを実装することで、データベースとの間でのデータ変換をカスタマイズでき、アプリケーションの要件に合わせた柔軟な設計が可能になります。

ただし、独自型の使用にはパフォーマンスやマイグレーションの観点から注意点もあります。これらのトレードオフを十分に理解した上で、適切に使用することが重要です。

Gormと独自型を組み合わせることで、よりクリーンで保守性の高いデータベース操作を実現できます。独自型の使用は、単なる技術的な実装の話にとどまらず、ドメイン駆動設計(DDD)のような設計手法とも親和性が高く、より良いソフトウェア設計につながる可能性を秘めています。

Goプログラミングの腕を上げたい方、より堅牢なアプリケーションを作りたい方は、ぜひGormでの独自型の活用を検討してみてください。型安全性とビジネスロジックの統合による利点を、実際のプロジェクトで体験してみることをおすすめします。

この記事は役に立ちましたか？

もし参考になりましたら、下記のボタンで教えてください。

投稿者: 最強エンジニア
Golang
DB, Golang, gorm
コメント: 0

【完全ガイド】GoのORMライブラリ、その名もgorm 前の記事 Gormで複雑なSQLを実行したい！【ひと味違うDB操作】次の記事

0 コメント
0 トラックバック

この記事へのコメントはありません。

はじめに

独自型を使う利点

基本的な独自型の実装

Scanner と Valuer インターフェースの実装

独自型を使ったモデルの定義

より複雑な独自型の例

独自型を使う際の注意点

独自型の活用例

メールアドレス

暗号化されたデータ

列挙型

まとめ

関連記事

【完全ガイド】GolangでGoogle認証

【ステップ3】”Hello, World!”、最初のGoプログラム

【ステップ6】Go言語でのコンソールからの入力と出力

Golangのコンテキストパッケージ：効果的な活用方法ガイド

コメント