MENU
  1. ホーム
  2. Go
  3. Go言語でのdb.Exec活用ガイド：データ更新・挿入・削除の実践方法

Go言語でのdb.Exec活用ガイド：データ更新・挿入・削除の実践方法

Go

Go言語は、そのシンプルさと効率性から多くの開発者に支持されるプログラミング言語です。その中で、データベース操作は多くのアプリケーションで重要な役割を果たします。本記事では、Go言語の標準的なデータベースインターフェースであるdatabase/sqlパッケージに焦点を当て、その中でも特に汎用性が高いdb.Exec関数について解説します。この関数を使えば、データの挿入、更新、削除など、基本的な操作をシンプルかつ効果的に実現できます。データベース操作の基礎から応用例までを分かりやすく説明し、これからGoでのデータベース操作を始める方にとって役立つ知識を提供します。

目次
  1. `db.Exec`とは？基本的な機能と役割
    1. `db.Exec`の基本的な使い方
    2. 戻り値の役割
    3. `db.Exec`の特長
  2. `db.Exec`を使ったデータ更新の実装例
    1. データ更新操作の概要
    2. 実装例：ユーザー情報の更新
    3. コードの解説
    4. 注意点
  3. `db.Exec`を使ったデータ挿入の実装例
    1. データ挿入操作の概要
    2. 実装例：新しいユーザーの追加
    3. コードの解説
    4. 注意点
    5. 応用例
  4. `db.Exec`を使ったデータ削除の実装例
    1. データ削除操作の概要
    2. 実装例：指定したユーザーの削除
    3. コードの解説
    4. 注意点
    5. 応用例：複数条件での削除
    6. トランザクションとの併用
  5. プレースホルダとSQLインジェクション対策
    1. SQLインジェクションのリスク
    2. プレースホルダを利用した安全なクエリ実行
    3. プレースホルダの具体例
    4. エラーハンドリングの重要性
    5. エスケープ処理を手動で行わない
    6. まとめ
  6. 実行結果の確認とエラーハンドリング
    1. 実行結果の確認
    2. エラーハンドリング
    3. ベストプラクティス
  7. 高頻度操作時のパフォーマンス最適化
    1. 高頻度操作がもたらす課題
    2. コネクションプールの活用
    3. バッチ処理の導入
    4. トランザクションの活用
    5. インデックスの最適化
    6. キャッシュの利用
    7. ベストプラクティス
  8. 応用例：トランザクションとの組み合わせ
    1. トランザクションとは
    2. トランザクションを使用する理由
    3. `db.Exec`とトランザクションの組み合わせ例
    4. コードの解説
    5. トランザクションのベストプラクティス
    6. 応用例：トランザクションを伴う複数テーブルの操作
    7. まとめ
  9. まとめ

`db.Exec`とは？基本的な機能と役割


db.Execは、Go言語のdatabase/sqlパッケージにおいて、データベースに対してSQLクエリを実行するための関数です。この関数は、特にデータの挿入、更新、削除といったデータ操作言語（DML）の処理に適しています。

`db.Exec`の基本的な使い方


db.Execは、SQLクエリと任意のプレースホルダ引数を受け取り、SQL文をデータベースに送信して実行します。例えば、以下のような操作が可能です。

query := "UPDATE users SET name = ? WHERE id = ?"
result, err := db.Exec(query, "John Doe", 1)
if err != nil {
    log.Fatal(err)
}

戻り値の役割


db.Execは2つの値を返します。

  1. sql.Result: 実行されたSQLの影響を受けた行数や、挿入されたレコードのIDなどの情報を取得できます。
  2. error: 実行中に発生したエラー情報を提供します。

`db.Exec`の特長

  • 汎用性: 任意のSQLクエリを実行可能です。
  • シンプルさ: パラメータを使った安全なクエリ実行を簡単に実現できます。
  • 柔軟性: 更新系の操作だけでなく、ストアドプロシージャの実行などにも応用可能です。

db.Execは、特に動的なSQLを扱う場合や、高頻度の更新処理が必要なシステムでその真価を発揮します。

`db.Exec`を使ったデータ更新の実装例

データ更新操作の概要


データベースの更新操作は、既存のデータを変更するために用いられます。Go言語では、db.Exec関数を利用して簡潔に更新処理を実装できます。以下は具体的な使用例です。

実装例：ユーザー情報の更新

以下のコードは、ユーザーの名前を更新する例です。

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql" // MySQLドライバ
)

func main() {
    // データベース接続
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/exampledb")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 更新クエリ
    query := "UPDATE users SET name = ? WHERE id = ?"
    result, err := db.Exec(query, "Alice", 1)
    if err != nil {
        log.Fatal(err)
    }

    // 実行結果の確認
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Updated %d row(s)\n", rowsAffected)
}

コードの解説

  1. データベース接続の確立: sql.Open関数を使い、データベースに接続します。
  2. SQLクエリの実行: db.Execで動的なクエリを実行します。プレースホルダを利用してSQLインジェクションを防止します。
  3. 結果の確認: RowsAffectedメソッドを使い、更新された行数を取得します。

注意点

  • エラーハンドリング: 常にerrorのチェックを行い、予期しない動作を防ぎます。
  • トランザクションの利用: 複数の更新がある場合は、トランザクションを使用して一貫性を保ちます。

このように、db.Execを使うことで、効率的かつ安全にデータベースの更新操作を行うことが可能です。

`db.Exec`を使ったデータ挿入の実装例

データ挿入操作の概要


データ挿入は、データベースに新しいレコードを追加するための操作です。Go言語のdb.Exec関数を使用することで、シンプルかつ効率的にデータを挿入できます。以下に具体例を示します。

実装例：新しいユーザーの追加

以下のコードは、新しいユーザーをusersテーブルに挿入する例です。

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql" // MySQLドライバ
)

func main() {
    // データベース接続
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/exampledb")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 挿入クエリ
    query := "INSERT INTO users (name, age) VALUES (?, ?)"
    result, err := db.Exec(query, "Bob", 25)
    if err != nil {
        log.Fatal(err)
    }

    // 挿入結果の確認
    lastInsertID, err := result.LastInsertId()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Inserted new user with ID: %d\n", lastInsertID)
}

コードの解説

  1. データベース接続: sql.Openを用いて、データベースに接続します。
  2. SQLクエリの準備と実行: db.Exec関数でINSERT文を実行し、新しいレコードを追加します。
  3. 結果の取得: LastInsertIdメソッドを使って、挿入されたレコードのIDを取得します。

注意点

  • プレースホルダの利用: プレースホルダ（?）を使うことで、SQLインジェクション攻撃を防止します。
  • エラーハンドリング: Exec関数や結果取得時に発生する可能性のあるエラーを適切に処理します。
  • 制約違反の対応: データベースの制約（例：ユニークキーや外部キー）に注意し、エラーが発生した場合の対応を考慮します。

応用例


複数のレコードを効率的に挿入する場合、INSERT INTO ... VALUESをループで実行するか、複数の値を一度に挿入する構文を用いると効果的です。

query := "INSERT INTO users (name, age) VALUES (?, ?), (?, ?)"
result, err := db.Exec(query, "Charlie", 30, "Diana", 22)
if err != nil {
    log.Fatal(err)
}

このように、db.Execはデータベースへのデータ挿入をシンプルに実現できる強力なツールです。

`db.Exec`を使ったデータ削除の実装例

データ削除操作の概要


データベースの削除操作は、不要なレコードをデータベースから取り除くために使用します。Go言語では、db.Execを利用して削除クエリを実行できます。シンプルな構文で効率的に削除処理を行うことが可能です。

実装例：指定したユーザーの削除

以下のコードは、特定の条件に一致するユーザーをusersテーブルから削除する例です。

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql" // MySQLドライバ
)

func main() {
    // データベース接続
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/exampledb")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 削除クエリ
    query := "DELETE FROM users WHERE id = ?"
    result, err := db.Exec(query, 1)
    if err != nil {
        log.Fatal(err)
    }

    // 削除結果の確認
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Deleted %d row(s)\n", rowsAffected)
}

コードの解説

  1. データベース接続: sql.Openを使用して、MySQLデータベースに接続します。
  2. SQLクエリの実行: DELETEクエリをdb.Execで実行し、条件に一致するレコードを削除します。
  3. 削除件数の確認: RowsAffectedメソッドを使用して、削除されたレコード数を取得します。

注意点

  • 条件付き削除の実施: WHERE句を必ず使用して、全レコードが削除されることを防ぎます。例：DELETE FROM usersは全行を削除するため注意が必要です。
  • エラーハンドリング: 削除操作中に発生するエラーを適切に処理します。
  • データのバックアップ: 削除操作を実行する前にデータのバックアップを取ることを推奨します。

応用例：複数条件での削除


複数の条件を組み合わせた削除もdb.Execで簡単に実現できます。以下は、年齢が40以上のユーザーを削除する例です。

query := "DELETE FROM users WHERE age >= ?"
result, err := db.Exec(query, 40)
if err != nil {
    log.Fatal(err)
}
rowsAffected, err := result.RowsAffected()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Deleted %d row(s)\n", rowsAffected)

トランザクションとの併用


重要な削除操作では、トランザクションを利用して、エラーが発生した場合にロールバックできるようにするのが安全です。以下のように実装します。

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

query := "DELETE FROM users WHERE id = ?"
_, err = tx.Exec(query, 2)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

これにより、削除操作の信頼性を高めることができます。db.Execを活用すれば、柔軟かつ安全に削除処理を行うことが可能です。

プレースホルダとSQLインジェクション対策

SQLインジェクションのリスク


SQLインジェクションは、ユーザー入力を適切に処理しない場合に発生する重大なセキュリティ脆弱性です。攻撃者は悪意のあるSQLコードを挿入することで、データの漏洩、削除、またはデータベースそのものの破壊を引き起こす可能性があります。

例えば、以下のようなコードは非常に危険です。

query := "DELETE FROM users WHERE id = " + userInput
_, err := db.Exec(query)
if err != nil {
    log.Fatal(err)
}

このコードでは、userInputに不正なSQLコードを注入することで、意図しない操作が実行される可能性があります。

プレースホルダを利用した安全なクエリ実行


Goのdatabase/sqlパッケージでは、SQL文にプレースホルダ（?）を使用し、パラメータ化されたクエリを実行することでSQLインジェクションを防ぎます。以下はその例です。

query := "DELETE FROM users WHERE id = ?"
_, err := db.Exec(query, userInput)
if err != nil {
    log.Fatal(err)
}

この方法では、データベースドライバがプレースホルダに埋め込む値をエスケープ処理するため、不正なSQLが実行されるリスクを排除できます。

プレースホルダの具体例

挿入操作

query := "INSERT INTO users (name, age) VALUES (?, ?)"
_, err := db.Exec(query, "Alice", 25)

更新操作

query := "UPDATE users SET age = ? WHERE name = ?"
_, err := db.Exec(query, 30, "Alice")

削除操作

query := "DELETE FROM users WHERE age > ?"
_, err := db.Exec(query, 50)

エラーハンドリングの重要性


SQLインジェクションを防ぐだけでなく、エラーハンドリングを適切に行うことで、予期しない挙動や潜在的な脆弱性を排除できます。

result, err := db.Exec(query, userInput)
if err != nil {
    log.Printf("Error executing query: %v\n", err)
    return
}
rowsAffected, _ := result.RowsAffected()
log.Printf("Deleted %d rows\n", rowsAffected)

エスケープ処理を手動で行わない


手動でエスケープ処理を実装することは推奨されません。これは、エスケープ処理が適切でなかった場合、依然として脆弱性が残る可能性があるためです。database/sqlパッケージのプレースホルダを常に利用するようにしましょう。

まとめ


プレースホルダを使ったパラメータ化クエリは、SQLインジェクション対策の基本中の基本です。Go言語とdatabase/sqlパッケージを利用する際は、SQL文にプレースホルダを必ず使用し、エラーハンドリングを徹底することで、安全で堅牢なデータベース操作を実現しましょう。

実行結果の確認とエラーハンドリング

実行結果の確認


db.Execの戻り値であるsql.Resultは、SQLクエリの実行結果に関する情報を提供します。これを利用することで、操作の成否や影響を受けたレコード数を確認できます。

RowsAffectedで影響を受けた行数を確認


RowsAffectedメソッドは、更新、削除、または挿入クエリによって影響を受けた行数を返します。

query := "UPDATE users SET age = ? WHERE age > ?"
result, err := db.Exec(query, 30, 25)
if err != nil {
    log.Fatal(err)
}

rowsAffected, err := result.RowsAffected()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Updated %d row(s)\n", rowsAffected)

このコードでは、ageが25より大きいユーザーのageを30に更新し、影響を受けた行数を表示します。

LastInsertIdで挿入されたレコードのIDを取得


LastInsertIdメソッドは、INSERTクエリによって自動生成されたIDを返します。主にAUTO_INCREMENT設定を持つテーブルで有効です。

query := "INSERT INTO users (name, age) VALUES (?, ?)"
result, err := db.Exec(query, "Alice", 25)
if err != nil {
    log.Fatal(err)
}

lastInsertID, err := result.LastInsertId()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("New record inserted with ID: %d\n", lastInsertID)

このコードでは、新しいユーザーを追加し、そのIDを表示します。

エラーハンドリング


データベース操作では、エラーハンドリングを適切に実施することで、予期しない問題に対処できます。

エラーの種類


db.Execで発生する主なエラーには以下が含まれます：

  • 接続エラー: データベースに接続できない場合
  • 構文エラー: SQL文の文法が正しくない場合
  • 制約違反エラー: 一意性制約や外部キー制約などに違反した場合

エラー処理の実装例

query := "UPDATE users SET name = ? WHERE id = ?"
result, err := db.Exec(query, "Bob", 1)
if err != nil {
    if sqlErr, ok := err.(*mysql.MySQLError); ok {
        switch sqlErr.Number {
        case 1062: // Duplicate entry
            log.Println("Duplicate entry error")
        case 1451: // Cannot delete or update a parent row
            log.Println("Foreign key constraint error")
        default:
            log.Printf("MySQL error: %v\n", sqlErr)
        }
    } else {
        log.Printf("Error executing query: %v\n", err)
    }
    return
}

このコードは、MySQL特有のエラーを識別し、適切なエラー処理を行います。

ロギングと通知


重大なエラーが発生した場合、ログに記録するだけでなく、必要に応じて通知を送信する仕組みを構築します。

if err != nil {
    log.Printf("Error: %v\n", err)
    // エラー通知処理を追加
    notifyAdmin(err)
}

ベストプラクティス

  1. エラーの記録: 全てのエラーをログに記録する。
  2. エラーの分類: エラー内容に応じて適切な対応を行う。
  3. 再試行: 一時的な接続エラーの場合は再試行を行う。
  4. デフォルトのエラーハンドリング: 想定外のエラーに対しても処理を続行するか中断するかを決定する。

実行結果を確認し、エラーを適切に処理することで、安全で信頼性の高いデータベース操作が可能になります。

高頻度操作時のパフォーマンス最適化

高頻度操作がもたらす課題


データベースに対する高頻度の挿入、更新、削除操作は、次のような問題を引き起こす可能性があります。

  • 接続のオーバーヘッド: 各操作で新しいデータベース接続を確立するとパフォーマンスが低下します。
  • トランザクションコスト: 毎回クエリを個別に実行することで、トランザクション処理のコストが増加します。
  • ネットワーク遅延: クエリ数が多いほど、ネットワーク通信による遅延が大きくなります。

これらの課題を解決するために、以下の最適化技法を検討します。

コネクションプールの活用


高頻度操作では、接続を毎回確立するのではなく、コネクションプールを活用することでオーバーヘッドを削減できます。Go言語のsql.DBはコネクションプールを標準でサポートしています。

db.SetMaxOpenConns(50)  // 同時接続数の最大値
db.SetMaxIdleConns(25)  // アイドル状態の接続の最大数
db.SetConnMaxLifetime(30 * time.Minute)  // 接続の最大ライフタイム

これにより、データベース接続の再利用が促進され、接続コストを削減できます。

バッチ処理の導入


複数の操作を一つのクエリでまとめることで、ネットワーク遅延とトランザクションのオーバーヘッドを軽減します。

複数挿入の例

query := "INSERT INTO users (name, age) VALUES (?, ?), (?, ?), (?, ?)"
_, err := db.Exec(query, "Alice", 25, "Bob", 30, "Charlie", 35)
if err != nil {
    log.Fatal(err)
}

Prepared Statementを活用したバッチ処理
Prepared Statementを使うことで、高頻度操作の効率をさらに高めることができます。

stmt, err := db.Prepare("INSERT INTO users (name, age) VALUES (?, ?)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

for _, user := range []struct {
    name string
    age  int
}{
    {"Alice", 25},
    {"Bob", 30},
    {"Charlie", 35},
} {
    _, err = stmt.Exec(user.name, user.age)
    if err != nil {
        log.Fatal(err)
    }
}

トランザクションの活用


複数の操作を1つのトランザクションで実行することで、パフォーマンスを向上させるとともに一貫性を保つことができます。

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

_, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", 100, 1)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

_, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", 100, 2)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

インデックスの最適化


データベース内のインデックスを適切に設定することで、検索や更新の効率を向上させます。高頻度のクエリで使用する列にインデックスを付与することで、クエリパフォーマンスを劇的に改善できます。

CREATE INDEX idx_users_age ON users(age);

キャッシュの利用


頻繁に使用されるデータはキャッシュに保存し、データベースへのアクセスを最小限に抑えることでパフォーマンスを向上させます。Goでは、ライブラリ（例：Redis）を活用することでキャッシュを実現できます。

ベストプラクティス

  • クエリの最適化: クエリの構造を見直し、最小限のリソースで目的を達成する。
  • 負荷分散: データベースを分散構成にして、高負荷に耐える。
  • 監視とプロファイリング: 実際のクエリの実行時間や負荷を定期的に監視し、ボトルネックを特定する。

高頻度操作の最適化は、パフォーマンス向上だけでなく、システムの安定性向上にも寄与します。適切な技法を組み合わせ、安全で効率的なデータベース操作を目指しましょう。

応用例：トランザクションとの組み合わせ

トランザクションとは


トランザクションは、複数のデータベース操作を一つのまとまりとして扱い、一貫性を保つための仕組みです。すべての操作が成功した場合にだけ確定（コミット）され、一つでも失敗するとすべての変更が取り消されます（ロールバック）。

トランザクションを使用する理由

  • 一貫性の確保: データベースの状態を部分的に変更した状態で残さない。
  • 原子性: 複数の操作が1つのユニットとして扱われ、全てが成功するか全てが失敗するかのいずれかになる。
  • エラー時の安全性: エラーが発生した際に変更を元に戻す。

`db.Exec`とトランザクションの組み合わせ例


以下は、アカウント間での送金操作をトランザクションを用いて実現する例です。

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql" // MySQLドライバ
)

func main() {
    // データベース接続
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/exampledb")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // トランザクションの開始
    tx, err := db.Begin()
    if err != nil {
        log.Fatal(err)
    }

    // 送金元の残高を減らす
    _, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", 100, 1)
    if err != nil {
        tx.Rollback() // エラー時はロールバック
        log.Fatal("Failed to deduct balance:", err)
    }

    // 送金先の残高を増やす
    _, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", 100, 2)
    if err != nil {
        tx.Rollback() // エラー時はロールバック
        log.Fatal("Failed to add balance:", err)
    }

    // トランザクションの確定
    err = tx.Commit()
    if err != nil {
        log.Fatal("Transaction commit failed:", err)
    }

    fmt.Println("Transaction completed successfully")
}

コードの解説

  1. トランザクションの開始: db.Beginを呼び出してトランザクションを開始します。
  2. 複数の操作を実行: tx.Execを用いて、トランザクション内での操作を実行します。
  3. エラー時のロールバック: 任意の操作でエラーが発生した場合、tx.Rollbackを呼び出してすべての変更を取り消します。
  4. 正常終了時のコミット: すべての操作が成功した場合、tx.Commitを呼び出して変更を確定します。

トランザクションのベストプラクティス

  • 小さなスコープで使用: トランザクション内で行う操作を最小限に抑え、ロック時間を短縮する。
  • エラーハンドリングの徹底: すべてのエラーに対して適切にロールバックを行う。
  • 適切なロック戦略: トランザクション中のテーブルロックや行ロックに注意し、デッドロックを防ぐ。

応用例：トランザクションを伴う複数テーブルの操作


複数のテーブルを操作する場合にも、トランザクションは有効です。以下は、ordersとorder_itemsテーブルを同時に更新する例です。

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

_, err = tx.Exec("INSERT INTO orders (id, total) VALUES (?, ?)", 1, 200)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

_, err = tx.Exec("INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)", 1, 101, 2)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

まとめ


db.Execとトランザクションを組み合わせることで、データベース操作の安全性と一貫性を確保できます。特に複数のクエリを実行する場合や、エラーが許容されない状況では、トランザクションを活用することが重要です。トランザクションの特性を理解し、適切に実装することで、信頼性の高いシステムを構築できます。

まとめ


本記事では、Go言語でのdb.Execを用いたデータ更新、挿入、削除の操作方法を詳しく解説しました。db.Execは、シンプルかつ柔軟なデータベース操作を可能にする便利な関数です。また、SQLインジェクション対策としてのプレースホルダの活用、高頻度操作におけるパフォーマンス最適化、トランザクションによるデータ整合性の確保といった応用例も取り上げました。

これらの技術を組み合わせることで、効率的かつ安全なデータベース操作が実現できます。Go言語を使った開発で、データベースを正確に制御し、信頼性の高いシステムを構築するための基盤として役立ててください。

Go
プログラミング データベース Go

コメント

コメントする

目次
  1. `db.Exec`とは？基本的な機能と役割
    1. `db.Exec`の基本的な使い方
    2. 戻り値の役割
    3. `db.Exec`の特長
  2. `db.Exec`を使ったデータ更新の実装例
    1. データ更新操作の概要
    2. 実装例：ユーザー情報の更新
    3. コードの解説
    4. 注意点
  3. `db.Exec`を使ったデータ挿入の実装例
    1. データ挿入操作の概要
    2. 実装例：新しいユーザーの追加
    3. コードの解説
    4. 注意点
    5. 応用例
  4. `db.Exec`を使ったデータ削除の実装例
    1. データ削除操作の概要
    2. 実装例：指定したユーザーの削除
    3. コードの解説
    4. 注意点
    5. 応用例：複数条件での削除
    6. トランザクションとの併用
  5. プレースホルダとSQLインジェクション対策
    1. SQLインジェクションのリスク
    2. プレースホルダを利用した安全なクエリ実行
    3. プレースホルダの具体例
    4. エラーハンドリングの重要性
    5. エスケープ処理を手動で行わない
    6. まとめ
  6. 実行結果の確認とエラーハンドリング
    1. 実行結果の確認
    2. エラーハンドリング
    3. ベストプラクティス
  7. 高頻度操作時のパフォーマンス最適化
    1. 高頻度操作がもたらす課題
    2. コネクションプールの活用
    3. バッチ処理の導入
    4. トランザクションの活用
    5. インデックスの最適化
    6. キャッシュの利用
    7. ベストプラクティス
  8. 応用例：トランザクションとの組み合わせ
    1. トランザクションとは
    2. トランザクションを使用する理由
    3. `db.Exec`とトランザクションの組み合わせ例
    4. コードの解説
    5. トランザクションのベストプラクティス
    6. 応用例：トランザクションを伴う複数テーブルの操作
    7. まとめ
  9. まとめ