C言語+MySQL入門|在庫履歴を保存する

C言語+MySQL入門|在庫履歴を保存する

12.1と12.2では、入庫・出庫に合わせて在庫数を更新し、stock_historyへ履歴を登録しました。

今回は、その在庫履歴に注目し、何を保存するのか、いつ確定するのか、どの関数が保存を担当するのかを整理します。

現在の在庫数だけでは、その数量になった理由までは分かりません。商品の入庫・出庫を履歴として残しておくと、在庫の増減を後から確認できます。

この記事では、次の内容を扱います。

  • 在庫履歴へ保存する項目を確認する。
  • 入庫と出庫を区別して記録する。
  • 数量と記録日時の扱いを整理する。
  • 履歴登録部分を共通関数へまとめる。
  • 入庫・出庫から同じ履歴保存関数を呼び出す。
  • 履歴登録の成功と、トランザクションの確定を区別する。

履歴の保存は、前の記事までに実装済みです。今回は、その処理を共通化し、入庫と出庫で同じ保存ルールを使えるようにしていきましょう。

在庫履歴には一回の入出庫を保存しよう

productsのstockが表すのは、現在の在庫数です。

一方、stock_historyには、一回ごとの入庫・出庫を保存します。

例えば、商品ID23に対して、次の操作を行ったとします。

操作在庫数の変化保存する履歴
5個入庫0から5IN、数量5
3個入庫5から8IN、数量3
3個出庫8から5OUT、数量3
5個出庫5から0OUT、数量5

現在の在庫数は0ですが、履歴を見ると、合計8個を入庫し、合計8個を出庫したことが分かります。

商品登録だけでは、入出庫履歴を作りません。実際に在庫数を増減した操作を記録します。

保存する五つの項目を確認しよう

第3章で作成したstock_historyには、次の項目があります。

列名型内容
history_idINT履歴を識別する自動採番のID
product_idINT入庫・出庫した商品のID
movement_typeVARCHAR(10)INまたはOUT
quantityINT入庫・出庫した数量
recorded_atDATETIME履歴を登録した日時

Cプログラムから指定するのは、商品ID、入出庫の別、数量です。

履歴IDと記録日時には、テーブル側の設定を利用します。

項目値を用意する場所
history_idMySQLのAUTO_INCREMENT
product_id入出庫関数
movement_type入出庫関数
quantity入出庫関数
recorded_atDEFAULT CURRENT_TIMESTAMP

図1:一回の入出庫を一件の在庫履歴として保存する

この図から分かること

在庫履歴には、一回の入出庫で動かした数量を保存します。

商品ID、入出庫の別、数量はアプリから渡し、履歴IDと記録日時はMySQL側の設定を利用します。

入庫と出庫は種類で区別しよう

入庫と出庫の区別には、movement_typeを使います。

操作movement_typequantityの例
4個入庫IN4
2個出庫OUT2

数量には、どちらの場合も正の整数を保存します。

出庫だからといって、quantityへ負数を保存することはありません。

また、quantityへ保存するのは、処理後の在庫数ではありません。

例えば、在庫数4から2個出庫した場合は、在庫数が2になり、OUT、数量2の履歴が残ります。

記録日時はMySQL側の既定値を使おう

recorded_atには、第3章で次の設定を行いました。

recorded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP

INSERTでrecorded_atを指定しなければ、現在日時が設定されます。DATETIMEでも、DEFAULT CURRENT_TIMESTAMPによる自動初期化を利用できます。

今回も、C側で日時を組み立てず、MySQL側の設定を使用します。

ただし、この日時は履歴のINSERTを実行した際に設定されるもので、COMMIT完了時刻そのものではありません。

また、recorded_atは秒単位のDATETIMEなので、複数の履歴が同じ日時になることもあります。

日時を扱うときの確認点内容
日時の基準MySQLのセッションのタイムゾーン設定
設定される場面履歴のINSERT時
COMMITとの関係確定完了時刻を直接表すものではない
同じ日時の履歴発生する場合がある

商品と履歴の関連は外部キーで守ろう

stock_historyのproduct_idには、productsを参照する外部キーを設定しています。

これにより、存在しない商品の履歴を登録する操作は拒否されます。また、履歴から参照されている商品は、ON DELETE RESTRICTによって削除が拒否されます。

役割を整理すると、次のようになります。

仕組み守ること
外部キー履歴が参照する商品の存在
CHECK制約IN・OUTの種類、正の数量
入出庫関数在庫更新と履歴の数量をそろえる
トランザクション在庫更新と履歴登録をまとめて確定・取消する

DBの制約とアプリの処理を組み合わせて、在庫と履歴の対応を保ちます。

履歴登録を入庫と出庫で共通化しよう

これまでは、stock_receive.cとstock_ship.cの中に、それぞれ履歴登録用の処理を書いていました。

今回は、その部分をstock_history.cへまとめます。

ファイル担当
stock_receive.c在庫の加算と入庫全体の確定・取消
stock_ship.c在庫の減算と出庫全体の確定・取消
stock_history.cIN・OUT履歴の登録
stock_history_internal.h履歴保存用の内部関数の宣言

履歴保存関数は、入庫・出庫関数が開始したトランザクションの中から呼び出します。

接続も、在庫更新に使用したものと同じ接続を渡します。

履歴保存関数の中では、START TRANSACTION、COMMIT、ROLLBACKを行いません。

処理入出庫関数履歴保存関数
トランザクション開始担当する行わない
在庫更新担当する行わない
履歴登録共通関数を呼ぶ担当する
COMMIT・ROLLBACK担当する行わない
履歴用ステートメントの終了任せる担当する
DB接続の終了行わない行わない

DB接続の終了は、これまでと同じくmain側の担当です。

履歴保存関数の戻り値を決めよう

今回作成するappend_stock_historyは、int型で結果を返します。

戻り値意味
0履歴を一件登録し、ステートメントの終了にも成功した
−1引数、SQL処理、後片付けなどに問題があった

ここでの0は、未確定の履歴を登録できた状態です。

入庫・出庫全体の確定成功を表すAPP_OKとは区別します。

append_stock_historyが成功した後、入出庫関数がCOMMITに成功して、初めてAPP_OKを返します。

履歴保存用の内部ヘッダーを作ろう

この関数は、画面側から直接呼ぶためのものではありません。

在庫を一行更新できた入出庫関数から、同じ接続、商品ID、数量を渡して呼び出します。

ファイル名のinternalは、こうした内部処理用であることを分かりやすくするために付けています。

入出庫の種類と履歴保存用の内部関数を宣言するヘッダーファイル

ファイル名: stock_history_internal.h

#ifndef STOCK_HISTORY_INTERNAL_H
#define STOCK_HISTORY_INTERNAL_H

#include <mysql.h>
#include "app_result.h"

/* 履歴に保存できる入出庫の種類 */
typedef enum {
    STOCK_HISTORY_IN = 1,
    STOCK_HISTORY_OUT = 2
} StockHistoryType;

/*
 * 在庫更新済みのトランザクション内からだけ呼び出す内部用関数。
 * 接続、商品ID、数量は、在庫更新と同じものを渡す。
 * START TRANSACTION、COMMIT、ROLLBACK、mysql_closeは行わない。
 * errorとcleanup_errorは、別々のゼロ初期化済み領域を渡す。
 * 戻り値0は履歴登録と後片付けの成功であり、確定成功ではない。
 */
int append_stock_history(
    MYSQL *conn,
    int product_id,
    StockHistoryType type,
    int quantity,
    AppError *error,
    AppError *cleanup_error
);

#endif

StockHistoryTypeは、履歴に保存する種類を指定するための列挙型です。

C側の値DBへ保存する値
STOCK_HISTORY_ININ
STOCK_HISTORY_OUTOUT

呼び出し側が任意の文字列を渡す構成にせず、許可した種類から選ぶ形にしています。

履歴を一件登録する関数を実装しよう

append_stock_historyでは、種類に応じて固定SQLを選びます。

商品IDと数量は、プリペアドステートメントのパラメーターとして渡します。

履歴IDとrecorded_atは、INSERTの列へ指定しません。

入庫・出庫の履歴を一件登録するプログラム

ファイル名: stock_history.c

#include "stock_history_internal.h"

#include <stdio.h>
#include <string.h>

/* 最初のエラーだけを保存する */
static void save_error(AppError *out, const char *operation,
                       unsigned int number, const char *sqlstate)
{
    if (out->present) {
        return;
    }

    out->present = 1;
    out->has_mysql_error = number != 0;
    out->number = number;
    snprintf(out->sqlstate, sizeof out->sqlstate, "%.5s", sqlstate);
    snprintf(out->operation, sizeof out->operation, "%s", operation);
}

static void save_connection_error(AppError *out, MYSQL *conn,
                                   const char *operation)
{
    save_error(out, operation, mysql_errno(conn), mysql_sqlstate(conn));
}

static void save_statement_error(AppError *out, MYSQL_STMT *stmt,
                                  const char *operation)
{
    save_error(out, operation,
               mysql_stmt_errno(stmt), mysql_stmt_sqlstate(stmt));
}

int append_stock_history(
    MYSQL *conn,
    int product_id,
    StockHistoryType type,
    int quantity,
    AppError *error,
    AppError *cleanup_error
)
{
    MYSQL_STMT *stmt = NULL;
    MYSQL_BIND bind[2] = {0};
    const char *sql;
    int status = -1;

    if (error == NULL || cleanup_error == NULL) {
        return -1;
    }

    /* 既存のエラーを消して処理を続けない */
    if (error->present || cleanup_error->present) {
        return -1;
    }

    if (conn == NULL || product_id <= 0 || quantity <= 0) {
        save_error(error, "validate_history_arguments", 0, "-----");
        return -1;
    }

    /* 許可した種類ごとに、固定SQLを選ぶ */
    switch (type) {
    case STOCK_HISTORY_IN:
        sql = "INSERT INTO stock_history "
              "(product_id, movement_type, quantity) "
              "VALUES (?, 'IN', ?)";
        break;
    case STOCK_HISTORY_OUT:
        sql = "INSERT INTO stock_history "
              "(product_id, movement_type, quantity) "
              "VALUES (?, 'OUT', ?)";
        break;
    default:
        save_error(error, "validate_history_type", 0, "-----");
        return -1;
    }

    int values[2] = {product_id, quantity};

    stmt = mysql_stmt_init(conn);

    if (stmt == NULL) {
        save_connection_error(error, conn, "mysql_stmt_init");
        return -1;
    }

    if (mysql_stmt_prepare(stmt, sql, (unsigned long)strlen(sql)) != 0) {
        save_statement_error(error, stmt, "prepare_stock_history");
        goto cleanup;
    }

    if (mysql_stmt_param_count(stmt) != 2) {
        save_error(error, "check_history_parameters", 0, "-----");
        goto cleanup;
    }

    for (size_t i = 0; i < 2; ++i) {
        bind[i].buffer_type = MYSQL_TYPE_LONG;
        bind[i].buffer = &values[i];
        bind[i].buffer_length = sizeof values[i];
        bind[i].is_unsigned = 0;
    }

    if (mysql_stmt_bind_param(stmt, bind) != 0) {
        save_statement_error(error, stmt, "bind_stock_history");
        goto cleanup;
    }

    if (mysql_stmt_execute(stmt) != 0) {
        save_statement_error(error, stmt, "insert_stock_history");
        goto cleanup;
    }

    my_ulonglong rows = mysql_stmt_affected_rows(stmt);

    if (rows == (my_ulonglong)-1) {
        save_statement_error(error, stmt, "history_affected_rows");
        goto cleanup;
    }

    if (rows != 1) {
        save_error(error, "check_history_row_count", 0, "-----");
        goto cleanup;
    }

    /* まだ未確定。最終的なCOMMITは入出庫関数が担当する */
    status = 0;

cleanup:
    if (stmt != NULL) {
        int failed = mysql_stmt_close(stmt) != 0;
        stmt = NULL;

        if (failed) {
            save_connection_error(cleanup_error, conn, "mysql_stmt_close");
            status = -1;
        }
    }

    return status;
}

二つのパラメーターへ商品IDと数量を渡している

今回のSQLでは、movement_typeを固定SQLの中へ書いています。

そのため、パラメーターは商品IDと数量の二つです。

int values[2] = {product_id, quantity};
MYSQL_BINDの要素対応する値
bind[0]product_id
bind[1]quantity

入出庫の種類は、次の分岐で決めています。

switch (type) {
case STOCK_HISTORY_IN:
    sql = "INSERT INTO stock_history "
          "(product_id, movement_type, quantity) "
          "VALUES (?, 'IN', ?)";
    break;
case STOCK_HISTORY_OUT:
    sql = "INSERT INTO stock_history "
          "(product_id, movement_type, quantity) "
          "VALUES (?, 'OUT', ?)";
    break;
default:
    save_error(error, "validate_history_type", 0, "-----");
    return -1;
}

利用者が入力した文字列をSQLへ連結しているわけではありません。

アプリが用意した二つの固定SQLから選び、商品IDと数量をパラメーターとして渡します。

登録行数と後片付けまで確認する

履歴を登録した後は、影響行数が1であることを確認します。

my_ulonglong rows = mysql_stmt_affected_rows(stmt);

if (rows == (my_ulonglong)-1) {
    save_statement_error(error, stmt, "history_affected_rows");
    goto cleanup;
}

if (rows != 1) {
    save_error(error, "check_history_row_count", 0, "-----");
    goto cleanup;
}

SQL実行の成否に加えて、一件の履歴を登録できたことも確認しています。

さらに、履歴用ステートメントの終了に失敗した場合も、−1を返します。

if (failed) {
    save_connection_error(cleanup_error, conn, "mysql_stmt_close");
    status = -1;
}

今回は、履歴用ステートメントの終了をCOMMITより前に行います。

そのため、この段階で問題があれば、入出庫関数へ失敗を返し、在庫更新と履歴登録の両方についてROLLBACKを試みます。

mysql_stmt_closeは、エラーを返した場合もハンドルを解放するため、終了後のstmtは参照しません。

図2:履歴登録の成功と入出庫全体の確定を分ける

この図から分かること

履歴保存関数は、開始済みのトランザクションへ履歴を追加します。

履歴登録に成功しても、まだ確定していません。入出庫関数がCOMMITの成功を確認してから、アプリ全体の成功を返します。

入庫関数から共通の履歴保存処理を呼ぼう

stock_receive.cを、次の内容へ更新します。

在庫加算の条件は、12.1と同じです。

変更点は、履歴用ステートメントの作成・実行・終了を、append_stock_historyへ任せる部分です。

在庫を加算し、共通関数でIN履歴を保存するプログラム

ファイル名: stock_receive.c

#include "stock.h"
#include "stock_history_internal.h"

#include <limits.h>
#include <stdio.h>
#include <string.h>

/* 最初のエラーを保存し、後のエラーで上書きしない */
static void save_error(AppError *out, const char *operation,
                       unsigned int number, const char *sqlstate)
{
    if (out->present) {
        return;
    }

    out->present = 1;
    out->has_mysql_error = number != 0;
    out->number = number;
    snprintf(out->sqlstate, sizeof out->sqlstate, "%.5s", sqlstate);
    snprintf(out->operation, sizeof out->operation, "%s", operation);
}

static void save_connection_error(AppError *out, MYSQL *conn,
                                   const char *operation)
{
    save_error(out, operation, mysql_errno(conn), mysql_sqlstate(conn));
}

static void save_statement_error(AppError *out, MYSQL_STMT *stmt,
                                  const char *operation)
{
    save_error(out, operation,
               mysql_stmt_errno(stmt), mysql_stmt_sqlstate(stmt));
}

/* 作成したステートメントは、失敗した場合も呼び出し元が片付ける */
static int prepare_statement(MYSQL *conn, MYSQL_STMT **out,
                              const char *sql, MYSQL_BIND *bind,
                              unsigned long count, AppError *error)
{
    *out = mysql_stmt_init(conn);

    if (*out == NULL) {
        save_connection_error(error, conn, "mysql_stmt_init");
        return -1;
    }

    if (mysql_stmt_prepare(*out, sql, (unsigned long)strlen(sql)) != 0) {
        save_statement_error(error, *out, "mysql_stmt_prepare");
        return -1;
    }

    if (mysql_stmt_param_count(*out) != count) {
        save_error(error, "check_parameter_count", 0, "-----");
        return -1;
    }

    if (mysql_stmt_bind_param(*out, bind) != 0) {
        save_statement_error(error, *out, "mysql_stmt_bind_param");
        return -1;
    }

    return 0;
}

/* 終了後のハンドルは、成功・失敗を問わず参照しない */
static void close_statement(MYSQL *conn, MYSQL_STMT **stmt,
                             AppResult *result)
{
    if (*stmt == NULL) {
        return;
    }

    int failed = mysql_stmt_close(*stmt) != 0;
    *stmt = NULL;

    if (failed) {
        save_connection_error(&result->cleanup_error,
                               conn, "mysql_stmt_close");
        result->connection_reusable = 0;
    }
}

AppResult receive_stock(MYSQL *conn, int product_id, int quantity)
{
    AppResult result = {.status = APP_DB_ERROR};
    MYSQL_STMT *update_stmt = NULL;
    MYSQL_BIND update_bind[3] = {0};
    int transaction_active = 0;

    const char *update_sql =
        "UPDATE products SET stock = stock + ? "
        "WHERE product_id = ? AND stock <= ?";

    /* 上限の計算前に、商品IDと数量が正であることを確認する */
    if (conn == NULL || product_id <= 0 || quantity <= 0) {
        result.status = APP_INVALID_ARGUMENT;
        save_error(&result.error, "validate_receive_arguments", 0, "-----");
        return result;
    }

    /* 加算後にINT型の上限を超えない条件を作る */
    int update_values[3] = {quantity, product_id, INT_MAX - quantity};

    for (size_t i = 0; i < 3; ++i) {
        update_bind[i].buffer_type = MYSQL_TYPE_LONG;
        update_bind[i].buffer = &update_values[i];
        update_bind[i].buffer_length = sizeof update_values[i];
        update_bind[i].is_unsigned = 0;
    }

    if (prepare_statement(conn, &update_stmt, update_sql,
                           update_bind, 3, &result.error) != 0) {
        goto cleanup;
    }

    /* 商品確認と数量入力を終えてから開始する */
    if (mysql_query(conn, "START TRANSACTION") != 0) {
        save_connection_error(&result.error, conn, "start_transaction");
        goto cleanup;
    }

    transaction_active = 1;

    if (mysql_stmt_execute(update_stmt) != 0) {
        save_statement_error(&result.error, update_stmt, "update_stock");
        goto cleanup;
    }

    my_ulonglong rows = mysql_stmt_affected_rows(update_stmt);

    if (rows == (my_ulonglong)-1) {
        save_statement_error(&result.error, update_stmt, "update_affected_rows");
        goto cleanup;
    }

    if (rows == 0) {
        /* 商品なしと在庫上限は、更新行数だけでは区別しない */
        result.status = APP_NOT_UPDATED;
        goto cleanup;
    }

    if (rows != 1) {
        save_error(&result.error, "check_stock_row_count", 0, "-----");
        goto cleanup;
    }

    /* 同じ接続・商品ID・数量で、未確定のIN履歴を登録する */
    if (append_stock_history(conn, product_id, STOCK_HISTORY_IN, quantity,
                               &result.error, &result.cleanup_error) != 0) {
        goto cleanup;
    }

    if (mysql_commit(conn) != 0) {
        save_connection_error(&result.error, conn, "mysql_commit");
        result.status = APP_UNCERTAIN;
        goto cleanup;
    }

    transaction_active = 0;
    result.status = APP_OK;
    result.connection_reusable = 1;

cleanup:
    if (transaction_active) {
        if (mysql_rollback(conn) != 0) {
            save_connection_error(&result.rollback_error,
                                   conn, "mysql_rollback");

            /* 更新0行を確認済みなら、その業務結果は保持する */
            if (result.status != APP_NOT_UPDATED) {
                result.status = APP_UNCERTAIN;
            }

            result.connection_reusable = 0;
        } else if (result.status == APP_NOT_UPDATED) {
            result.connection_reusable = 1;
        }

        /* COMMITの結果不明は、ROLLBACK成功でも変更しない */
    }

    close_statement(conn, &update_stmt, &result);

    /* 借りた接続自体は閉じない */
    return result;
}

在庫を一行更新できた後に、次の呼び出しを行っています。

if (append_stock_history(conn, product_id, STOCK_HISTORY_IN, quantity,
                           &result.error, &result.cleanup_error) != 0) {
    goto cleanup;
}

在庫更新に使ったconn、product_id、quantityを、そのまま履歴保存関数へ渡しています。

別の商品IDや別の数量を組み立て直さないことが、在庫と履歴をそろえるポイントです。

出庫関数も同じ履歴保存処理を使おう

stock_ship.cも更新します。

出庫では、STOCK_HISTORY_OUTを指定します。在庫が足りる場合だけ減算する条件は、12.2から引き継ぎます。

在庫を減算し、共通関数でOUT履歴を保存するプログラム

ファイル名: stock_ship.c

#include "stock.h"
#include "stock_history_internal.h"

#include <stdio.h>
#include <string.h>

/* 最初のエラーを保存し、後のエラーで上書きしない */
static void save_error(AppError *out, const char *operation,
                       unsigned int number, const char *sqlstate)
{
    if (out->present) {
        return;
    }

    out->present = 1;
    out->has_mysql_error = number != 0;
    out->number = number;
    snprintf(out->sqlstate, sizeof out->sqlstate, "%.5s", sqlstate);
    snprintf(out->operation, sizeof out->operation, "%s", operation);
}

static void save_connection_error(AppError *out, MYSQL *conn,
                                   const char *operation)
{
    save_error(out, operation, mysql_errno(conn), mysql_sqlstate(conn));
}

static void save_statement_error(AppError *out, MYSQL_STMT *stmt,
                                  const char *operation)
{
    save_error(out, operation,
               mysql_stmt_errno(stmt), mysql_stmt_sqlstate(stmt));
}

/* 作成したステートメントは、失敗した場合も呼び出し元が片付ける */
static int prepare_statement(MYSQL *conn, MYSQL_STMT **out,
                              const char *sql, MYSQL_BIND *bind,
                              unsigned long count, AppError *error)
{
    *out = mysql_stmt_init(conn);

    if (*out == NULL) {
        save_connection_error(error, conn, "mysql_stmt_init");
        return -1;
    }

    if (mysql_stmt_prepare(*out, sql, (unsigned long)strlen(sql)) != 0) {
        save_statement_error(error, *out, "mysql_stmt_prepare");
        return -1;
    }

    if (mysql_stmt_param_count(*out) != count) {
        save_error(error, "check_parameter_count", 0, "-----");
        return -1;
    }

    if (mysql_stmt_bind_param(*out, bind) != 0) {
        save_statement_error(error, *out, "mysql_stmt_bind_param");
        return -1;
    }

    return 0;
}

/* 終了後のハンドルは、成功・失敗を問わず参照しない */
static void close_statement(MYSQL *conn, MYSQL_STMT **stmt,
                             AppResult *result)
{
    if (*stmt == NULL) {
        return;
    }

    int failed = mysql_stmt_close(*stmt) != 0;
    *stmt = NULL;

    if (failed) {
        save_connection_error(&result->cleanup_error,
                               conn, "mysql_stmt_close");
        result->connection_reusable = 0;
    }
}

AppResult ship_stock(MYSQL *conn, int product_id, int quantity)
{
    AppResult result = {.status = APP_DB_ERROR};
    MYSQL_STMT *update_stmt = NULL;
    MYSQL_BIND update_bind[3] = {0};
    int transaction_active = 0;

    const char *update_sql =
        "UPDATE products SET stock = stock - ? "
        "WHERE product_id = ? AND stock >= ?";

    /* 数量0や負数では、出庫処理を実行しない */
    if (conn == NULL || product_id <= 0 || quantity <= 0) {
        result.status = APP_INVALID_ARGUMENT;
        save_error(&result.error, "validate_ship_arguments", 0, "-----");
        return result;
    }

    /* 減算する数量と、在庫条件に使う数量をそろえる */
    int update_values[3] = {quantity, product_id, quantity};

    for (size_t i = 0; i < 3; ++i) {
        update_bind[i].buffer_type = MYSQL_TYPE_LONG;
        update_bind[i].buffer = &update_values[i];
        update_bind[i].buffer_length = sizeof update_values[i];
        update_bind[i].is_unsigned = 0;
    }

    if (prepare_statement(conn, &update_stmt, update_sql,
                           update_bind, 3, &result.error) != 0) {
        goto cleanup;
    }

    /* 商品確認と数量入力を終えてから開始する */
    if (mysql_query(conn, "START TRANSACTION") != 0) {
        save_connection_error(&result.error, conn, "start_transaction");
        goto cleanup;
    }

    transaction_active = 1;

    if (mysql_stmt_execute(update_stmt) != 0) {
        save_statement_error(&result.error, update_stmt, "update_stock");
        goto cleanup;
    }

    my_ulonglong rows = mysql_stmt_affected_rows(update_stmt);

    if (rows == (my_ulonglong)-1) {
        save_statement_error(&result.error, update_stmt, "update_affected_rows");
        goto cleanup;
    }

    if (rows == 0) {
        /* 商品なしと在庫不足は、更新行数だけでは区別しない */
        result.status = APP_NOT_UPDATED;
        goto cleanup;
    }

    if (rows != 1) {
        save_error(&result.error, "check_stock_row_count", 0, "-----");
        goto cleanup;
    }

    /* 同じ接続・商品ID・数量で、未確定のOUT履歴を登録する */
    if (append_stock_history(conn, product_id, STOCK_HISTORY_OUT, quantity,
                               &result.error, &result.cleanup_error) != 0) {
        goto cleanup;
    }

    if (mysql_commit(conn) != 0) {
        save_connection_error(&result.error, conn, "mysql_commit");
        result.status = APP_UNCERTAIN;
        goto cleanup;
    }

    transaction_active = 0;
    result.status = APP_OK;
    result.connection_reusable = 1;

cleanup:
    if (transaction_active) {
        if (mysql_rollback(conn) != 0) {
            save_connection_error(&result.rollback_error,
                                   conn, "mysql_rollback");

            /* 更新0行を確認済みなら、その業務結果は保持する */
            if (result.status != APP_NOT_UPDATED) {
                result.status = APP_UNCERTAIN;
            }

            result.connection_reusable = 0;
        } else if (result.status == APP_NOT_UPDATED) {
            result.connection_reusable = 1;
        }

        /* COMMITの結果不明は、ROLLBACK成功でも変更しない */
    }

    close_statement(conn, &update_stmt, &result);

    /* 借りた接続自体は閉じない */
    return result;
}

履歴の後片付けを行うタイミングを確認しよう

今回、履歴用ステートメントは、append_stock_historyの中で終了する形に変わりました。

対象終了するタイミング
履歴用ステートメント履歴保存関数から戻る前
トランザクション入出庫関数のCOMMIT・ROLLBACK
在庫更新用ステートメント入出庫関数の最後
DB接続main側の終了処理

このため、履歴用ステートメントの終了に問題が起きた場合は、COMMITへ進まず、ROLLBACKを試みます。

一方、COMMIT成功後に在庫更新用ステートメントの終了で問題が起きた場合は、これまでどおりAPP_OKを保持します。

問題が起きた場所扱い
履歴の準備・実行・登録行数確認在庫更新も含めてROLLBACKを試みる
履歴用ステートメントの終了COMMIT前なのでROLLBACKを試みる
COMMITの応答確認APP_UNCERTAINを保持する
確定後の在庫更新用ステートメントの終了APP_OKを保持し、後片付けエラーを別に記録する

処理のどの段階で問題が起きたのかによって、確定済みかどうかが異なります。

使用する既存ファイルとビルド方法を確認しよう

次のファイルは、前の記事のものをそのまま使います。

  • stock.h
  • stock_receive_main.c
  • stock_ship_main.c
  • run_stock_receive.sh
  • run_stock_ship.sh
  • app_types.h、app_result.h
  • db.h、db.c
  • db_config.h、db_config.c
  • input.h、input.c
  • validation.h、validation.c
  • product.h、product_find.c
  • inventory.conf

今回変更したのは、履歴保存の内部処理です。公開しているreceive_stockとship_stockの引数や戻り値は変えていないため、既存のmainを変更せずに呼び出せます。

MSYS2 UCRT64で、chap12へ移動します。

cd /c/c-mysql/chap12

入庫プログラムには、stock_history.cを追加してビルドします。

gcc stock_receive_main.c stock_receive.c stock_history.c \
  product_find.c db.c db_config.c input.c validation.c \
  -o stock_receive.exe \
  $(pkg-config --cflags --libs mysqlclient)

出庫プログラムも、同じファイルを追加します。

gcc stock_ship_main.c stock_ship.c stock_history.c \
  product_find.c db.c db_config.c input.c validation.c \
  -o stock_ship.exe \
  $(pkg-config --cflags --libs mysqlclient)

C17と警告オプションを指定する場合は、次のようにします。

gcc -std=c17 -Wall -Wextra -Wpedantic \
  stock_receive_main.c stock_receive.c stock_history.c \
  product_find.c db.c db_config.c input.c validation.c \
  -o stock_receive.exe \
  $(pkg-config --cflags --libs mysqlclient)
gcc -std=c17 -Wall -Wextra -Wpedantic \
  stock_ship_main.c stock_ship.c stock_history.c \
  product_find.c db.c db_config.c input.c validation.c \
  -o stock_ship.exe \
  $(pkg-config --cflags --libs mysqlclient)

stock_history.cを追加し忘れると、append_stock_historyの実体をリンクできません。

また、一つの実行ファイルに組み込むmainは一つです。入庫用と出庫用のmainを同じビルドコマンドへ入れないようにしましょう。

図3:入庫と出庫が同じ履歴保存処理を利用する

この図から分かること

入庫と出庫で異なるのは、在庫を増やすか減らすかと、履歴の種類です。

履歴の準備、登録、登録行数の確認、ステートメントの終了は、同じ関数で行えます。

商品ID23の現在の状態を確認しよう

12.2の実行例を最後まで操作した場合、商品ID23の在庫数は0です。

履歴には、次の四件が残っています。

順番種類数量
1IN5
2IN3
3OUT3
4OUT5

MySQLクライアントで確認します。

USE inventory_db;

SELECT product_id, product_name, stock
FROM products
WHERE product_id = 23;

SELECT product_id, movement_type, quantity
FROM stock_history
WHERE product_id = 23
ORDER BY history_id;

実行結果の例

+------------+----------------+-------+
| product_id | product_name   | stock |
+------------+----------------+-------+
|         23 | 入庫確認ノート |     0 |
+------------+----------------+-------+
1 row in set (0.00 sec)

+------------+---------------+----------+
| product_id | movement_type | quantity |
+------------+---------------+----------+
|         23 | IN            |        5 |
|         23 | IN            |        3 |
|         23 | OUT           |        3 |
|         23 | OUT           |        5 |
+------------+---------------+----------+
4 rows in set (0.00 sec)

以降は、この状態から操作した場合の例です。

すでに別の操作を行っている場合は、実際の在庫数と履歴件数に合わせて確認してください。既存の履歴を消して、例に合わせ直す必要はありません。

共通関数を使って4個入庫してみよう

更新後の入庫プログラムを実行します。

bash run_stock_receive.sh

実行結果の例

設定の検証が完了しました。
MySQLへは接続していません。
MySQLのパスワード:
入庫する商品を指定してください。
商品ID:23
商品名:入庫確認ノート
確認時点の在庫数:0
入庫数量:4
入庫が完了しました。
商品ID:23
入庫数量:4
DB接続を終了しました。

在庫数は0から4へ増え、数量4のIN履歴が一件追加されます。

続いて、2個出庫してみましょう。

bash run_stock_ship.sh

実行結果の例

設定の検証が完了しました。
MySQLへは接続していません。
MySQLのパスワード:
出庫する商品を指定してください。
商品ID:23
商品名:入庫確認ノート
確認時点の在庫数:4
出庫数量:2
出庫が完了しました。
商品ID:23
出庫数量:2
DB接続を終了しました。

在庫数は4から2へ減り、数量2のOUT履歴が一件追加されます。

商品ID・種類・数量・日時が保存されたことを確認しよう

次のSQLで、在庫数と履歴を確認します。

SELECT product_id, stock
FROM products
WHERE product_id = 23;

SELECT product_id, movement_type, quantity, recorded_at
FROM stock_history
WHERE product_id = 23
ORDER BY history_id;

実行結果の例

+------------+-------+
| product_id | stock |
+------------+-------+
|         23 |     2 |
+------------+-------+
1 row in set (0.00 sec)

+------------+---------------+----------+---------------------+
| product_id | movement_type | quantity | recorded_at         |
+------------+---------------+----------+---------------------+
|         23 | IN            |        5 | 2026-10-28 01:46:58 |
|         23 | IN            |        3 | 2026-10-28 02:10:13 |
|         23 | OUT           |        3 | 2026-10-29 00:29:07 |
|         23 | OUT           |        5 | 2026-10-29 00:35:26 |
|         23 | IN            |        4 | 2026-10-29 01:28:05 |
|         23 | OUT           |        2 | 2026-10-29 01:28:56 |
+------------+---------------+----------+---------------------+
6 rows in set (0.00 sec)

記録日時は例です。実際には、履歴を登録した日時が表示されます。

確認するポイントは、次のとおりです。

  • 商品ID23の在庫数が2になっている。
  • 今回の入庫に対応するIN、数量4が追加されている。
  • 今回の出庫に対応するOUT、数量2が追加されている。
  • recorded_atが設定されている。
  • 以前の履歴も残っている。

出庫できなかった場合は履歴を追加しない

現在の在庫数2に対して、3個の出庫を試します。

実行結果の例

設定の検証が完了しました。
MySQLへは接続していません。
MySQLのパスワード:
出庫する商品を指定してください。
商品ID:23
商品名:入庫確認ノート
確認時点の在庫数:2
出庫数量:3
商品が存在しないか、在庫が不足しています。
在庫更新と履歴登録は行われていません。
DB接続を終了しました。

この場合、ship_stockのUPDATEが0行となり、append_stock_historyは呼び出されません。

在庫数と履歴件数を確認します。

SELECT product_id, stock
FROM products
WHERE product_id = 23;

SELECT COUNT(*) AS history_count
FROM stock_history
WHERE product_id = 23;

実行結果の例

+------------+-------+
| product_id | stock |
+------------+-------+
|         23 |     2 |
+------------+-------+
1 row in set (0.00 sec)

+---------------+
| history_count |
+---------------+
|             6 |
+---------------+
1 row in set (0.00 sec)

在庫数は2のまま、履歴件数も6件のままです。

履歴IDの欠番を失敗の証拠にしない

history_idはAUTO_INCREMENTで採番されますが、必ず連番になるわけではありません。

例えば、INSERTで採番された後にROLLBACKすると、その番号が再利用されず、欠番になる場合があります。

調べたいこと使用する情報
履歴件数COUNT(*)
一件の履歴の識別history_id
記録内容product_id、movement_type、quantity
記録日時recorded_at

履歴IDが飛んでいるだけで、履歴が削除された、または保存処理が壊れているとは判断しません。

また、履歴IDは自動採番の識別子であり、複数接続でのCOMMIT完了順を厳密に示すものでもありません。

在庫履歴と診断ログの役割を分けよう

stock_historyとapp_error.logは、保存する目的が異なります。

保存先目的内容の例
stock_history確定した在庫の動きを確認する商品ID23を4個入庫
app_error.log処理上の問題を調査する履歴INSERTで権限エラー

入出庫に失敗してROLLBACKした場合、その操作は確定した在庫履歴としては残しません。

一方、失敗の原因を調べるための情報は、診断ログへ記録します。

COMMITの結果が不明な場合は、履歴が保存済みとも未保存とも決めつけず、在庫と履歴の両方を確認します。

確認するケース期待する動作
入庫が確定した同じ商品ID・数量のIN履歴が一件残る
出庫が確定した同じ商品ID・数量のOUT履歴が一件残る
在庫不足でUPDATEが0行履歴を登録しない
履歴登録に失敗し、ROLLBACKに成功在庫更新と履歴登録を取り消す
履歴用ステートメントの終了に失敗COMMITへ進まず、ROLLBACKを試みる
COMMITの結果が不明APP_UNCERTAINを保持し、状態確認を優先する
確定後の在庫更新用ステートメント終了に問題APP_OKを保持し、後片付けの問題を別に記録する

Follow me!