C言語+MySQL入門|登録後に一覧を更新する

C言語+MySQL入門|登録後に一覧を更新する

前の記事では、DBから取得した商品一覧を、商品ID、商品名、単価、在庫数の四列で表示しました。

今回は、その一覧表示を商品登録画面へ組み込みます。

商品を登録した後、利用者が別の確認用アプリを起動しなくても、同じ画面で登録結果を確認できるようにしましょう。

この記事では、次の内容を詳しく解説します。

  • 商品登録画面と商品一覧表示を組み合わせる。
  • 起動時に商品一覧を取得する。
  • 登録成功後にDBから一覧を取得し直す。
  • 新しい商品配列と商品表へ入れ替える。
  • 登録成功と一覧更新失敗を区別する。
  • 接続を継続利用できない場合は、その先のDB操作を止める。

今回は、登録後の一覧更新までを作成します。入力欄のクリアは、次の14.10で追加します。

登録した商品を同じ画面で確認できるようにしよう

これまでに作成した二つのGUIを組み合わせます。

これまでのGUI使用する処理
14.6の商品登録画面入力取得、検証、商品登録、結果表示
14.8の商品一覧画面一覧取得、商品表の作成、配列の管理

今回更新するのは、商品登録画面のgui/inventory_register.cです。

画面には、次のものを配置します。

  • 商品名と単価の入力欄。
  • 商品を登録ボタン。
  • 一覧を更新ボタン。
  • 商品件数と商品表。
  • 操作結果と次の操作の案内。

一覧を更新ボタンは、商品を登録せず、一覧だけを取得し直すために使用します。

登録成功後に一覧を取得し直そう

登録後の基本的な流れは、次のとおりです。

順序呼び出す処理内容
1collect_product_input入力を取得して検証する
2register_product商品を登録し、結果を受け取る
3登録結果の確認登録が確定したか確認する
4fetch_productsDBから商品一覧を取得し直す
5商品表の作成取得した配列から表を作る
6表示の差し替え新しい一覧を画面へ反映する

今回は、登録した一件を画面へ追加するだけでなく、DBから一覧全体を取得し直します。

これにより、DBが採番した商品IDや、DECIMALとして保存された単価を含め、取得時点の内容を表示できます。

画面の行を増やしただけでは、DBの最新内容を取得したことにはなりません。

図1:登録成功後にDBから一覧を取得し直す

この図から分かること

商品登録が成功した後に、別の処理として一覧を取得します。

取得した商品データから新しい表を作り、画面へ反映します。

今回の例では、20件の商品がある状態から一件登録し、21件の一覧へ更新します。

登録と一覧更新の結果を分けて扱おう

商品登録と一覧取得は、別々のDB操作です。

登録に成功した後で一覧取得に失敗しても、登録済みの商品が取り消されるわけではありません。

登録結果接続状態・一覧更新結果GUIでの扱い
登録成功接続利用可能、一覧更新成功登録成功と一覧更新完了を表示
登録成功一覧取得に失敗登録成功を残し、一覧更新失敗を表示
登録成功表を作成できない登録成功を残し、表示準備の問題を表示
登録成功接続利用不可一覧取得を呼ばず、操作を停止
登録結果不明確定したか確認できない再登録せず、保存状態の確認を案内

特に、登録成功後の一覧更新失敗を、商品登録の失敗として案内しないことが大切です。

一覧更新処理を共通の関数へまとめよう

今回は、一覧取得と商品表の差し替えをrefresh_productsへまとめます。

この処理は、次の三つの場面から呼び出します。

  • 起動時。
  • 一覧を更新ボタンを押したとき。
  • 商品登録が成功した後。

また、一覧更新の結果には、二つの情報が必要です。

情報内容
DB処理の結果fetch_productsのAppResult
表示できたか商品表を作成して差し替えられたか

DBから一覧を取得できても、画面の表を作成できない場合があります。

そのため、DB取得の成功と画面反映の成功も分けて返します。

使用するファイルを確認しよう

今回、DBモジュールの実装は変更しません。

ファイル今回の役割
gui/inventory_register.c登録と一覧更新を組み合わせる
src/product/product.c商品登録
src/product/product_list.c商品一覧取得と配列の解放
src/db/db.c接続
src/db/db_config.c設定読み込み
src/common/validation.c入力検証
run_gui_register.sh商品登録GUIの起動

今回は、商品登録のproduct.cと、一覧取得のproduct_list.cの両方をビルド対象へ指定します。

14.8のgui/inventory_list_fetch.cは、確認用として残しておきます。

登録後に一覧を更新するプログラムを作ろう

gui/inventory_register.cを、次の全文へ置き換えてください。

起動時に一覧を取得し、登録成功後にも同じ一覧更新関数を呼び出します。

商品登録と一覧表示を組み合わせ、登録成功後に一覧を更新するプログラム

ファイル名: gui/inventory_register.c

#include <gtk/gtk.h>

#include "app_types.h"
#include "db.h"
#include "db_config.h"
#include "product.h"
#include "validation.h"

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

/* 一覧更新のDB結果と、画面反映の結果を分ける */
typedef struct {
    AppResult db_result;
    int displayed;
} ListRefreshResult;

/* 登録画面と商品一覧の状態をまとめる */
typedef struct {
    GtkWindow *window;

    GtkEntry *name_entry;
    GtkEntry *price_entry;

    GtkLabel *name_preview;
    GtkLabel *price_preview;

    GtkButton *register_button;
    GtkButton *refresh_button;
    GtkButton *clear_button;

    GtkLabel *connection_status;
    GtkLabel *summary;

    GtkScrolledWindow *list_scroll;
    GtkGrid *product_table;

    GtkLabel *result_title;
    GtkLabel *message;
    GtkLabel *next_action;

    ProductList products;
    int products_loaded;

    /* 登録後や更新失敗後に、再取得が必要であることを示す */
    int list_stale;

    int selected_product_id;

    MYSQL *conn;
    ConnectionError connection_error;

    int db_available;
    int db_failed;
} AppUi;

/* 左寄せで折り返すラベルを作る */
static GtkLabel *create_wrapped_label(const char *text)
{
    GtkLabel *label = GTK_LABEL(gtk_label_new(text));

    gtk_label_set_xalign(label, 0.0f);
    gtk_label_set_wrap(label, TRUE);
    gtk_label_set_wrap_mode(label, PANGO_WRAP_WORD_CHAR);
    gtk_widget_set_hexpand(GTK_WIDGET(label), TRUE);

    return label;
}

/* 結果、説明、次の操作を共通形式で表示する */
static void show_message(
    AppUi *ui,
    const char *title,
    const char *detail,
    const char *next_action,
    const char *display_code
)
{
    gtk_label_set_text(ui->result_title, title);
    gtk_label_set_text(ui->message, detail);

    char *guide = g_strdup_printf(
        "次の操作:%s\n確認コード:%s",
        next_action,
        display_code
    );

    gtk_label_set_text(ui->next_action, guide);
    g_free(guide);
}

/* 秘密情報を含めず、段階ごとの診断情報を記録する */
static void record_error(
    const char *code,
    const char *kind,
    const AppError *error
)
{
    if (!error->present) {
        return;
    }

    g_printerr(
        "code=%s kind=%s operation=%s "
        "mysql_error=%u SQLSTATE=%s\n",
        code,
        kind,
        error->operation,
        error->has_mysql_error ? error->number : 0u,
        error->sqlstate[0] != '\0' ? error->sqlstate : "-----"
    );
}

/* AppResultの診断情報をまとめて記録する */
static void record_result(
    const char *code,
    const AppResult *result
)
{
    if (result->status != APP_OK || !result->connection_reusable) {
        g_printerr(
            "code=%s status=%d connection_reusable=%d\n",
            code,
            (int)result->status,
            result->connection_reusable
        );
    }

    record_error(code, "主処理", &result->error);
    record_error(code, "取消処理", &result->rollback_error);
    record_error(code, "後片付け", &result->cleanup_error);
}

/* 商品表へ表示セルを追加する */
static void add_table_cell(
    GtkGrid *grid,
    const char *text,
    int column,
    int row
)
{
    GtkWidget *label = gtk_label_new(NULL);
    gtk_label_set_text(GTK_LABEL(label), text);

    gtk_label_set_xalign(
        GTK_LABEL(label),
        column >= 2 ? 1.0f : 0.0f
    );

    if (column == 1) {
        gtk_widget_set_hexpand(label, TRUE);
    }

    gtk_grid_attach(grid, label, column, row, 1, 1);
}

/* 商品配列から新しい商品表を作る */
static GtkWidget *create_product_table(
    const ProductList *list,
    int loaded
)
{
    if (list->count > (size_t)(INT_MAX - 1)) {
        return NULL;
    }

    GtkWidget *table = gtk_grid_new();
    GtkGrid *grid = GTK_GRID(table);

    gtk_grid_set_row_spacing(grid, 10);
    gtk_grid_set_column_spacing(grid, 24);

    gtk_widget_set_margin_top(table, 12);
    gtk_widget_set_margin_bottom(table, 12);
    gtk_widget_set_margin_start(table, 12);
    gtk_widget_set_margin_end(table, 12);
    gtk_widget_set_hexpand(table, TRUE);
    gtk_widget_set_valign(table, GTK_ALIGN_START);

    const char *headers[] = {
        "商品ID", "商品名", "単価", "在庫数"
    };

    for (int column = 0; column < 4; ++column) {
        add_table_cell(grid, headers[column], column, 0);
    }

    if (!loaded || list->count == 0) {
        GtkWidget *notice = gtk_label_new(
            loaded
                ? "登録されている商品はありません。"
                : "商品一覧はまだ取得していません。"
        );

        gtk_label_set_xalign(GTK_LABEL(notice), 0.0f);
        gtk_grid_attach(grid, notice, 0, 1, 4, 1);

        return table;
    }

    for (size_t i = 0; i < list->count; ++i) {
        const Product *product = &list->items[i];
        int row = (int)i + 1;

        char id_text[32];
        char stock_text[32];

        snprintf(
            id_text, sizeof id_text,
            "%d", product->product_id
        );
        snprintf(
            stock_text, sizeof stock_text,
            "%d", product->stock
        );

        add_table_cell(grid, id_text, 0, row);
        add_table_cell(grid, product->product_name, 1, row);
        add_table_cell(grid, product->price, 2, row);
        add_table_cell(grid, stock_text, 3, row);
    }

    return table;
}

/* 件数と、一覧の再取得が必要かどうかを表示する */
static void update_summary(AppUi *ui)
{
    if (!ui->products_loaded) {
        gtk_label_set_text(
            ui->summary,
            ui->list_stale
                ? "商品一覧:未取得(再取得が必要)"
                : "商品一覧:未取得"
        );
        return;
    }

    char *text = g_strdup_printf(
        ui->list_stale
            ? "前回取得した商品:%zu件(再取得が必要)"
            : "取得済みの商品:%zu件",
        ui->products.count
    );

    gtk_label_set_text(ui->summary, text);
    g_free(text);
}

/* DB操作に使用する部品の操作可否をそろえる */
static void set_database_controls(AppUi *ui)
{
    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->name_entry), ui->db_available
    );
    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->price_entry), ui->db_available
    );
    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->register_button), ui->db_available
    );
    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->refresh_button), ui->db_available
    );

    /* 入力欄のクリアは次の記事で実装する */
    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->clear_button), FALSE
    );
}

/* 業務結果と商品表を残し、DB操作を停止する */
static void stop_database_actions(AppUi *ui)
{
    ui->db_available = 0;
    ui->db_failed = 1;
    ui->selected_product_id = 0;

    set_database_controls(ui);

    gtk_label_set_text(
        ui->connection_status,
        "DB操作:継続利用を停止しました。"
    );
}

/*
 * 一覧取得と表示更新を共通化する。
 * 登録結果などのメッセージは、この関数では表示しない。
 */
static ListRefreshResult refresh_products(AppUi *ui)
{
    ProductList incoming = {0};
    ListRefreshResult refresh = {0};

    ui->list_stale = 1;

    refresh.db_result = fetch_products(
        ui->conn,
        &incoming
    );

    if (refresh.db_result.status == APP_OK) {
        GtkWidget *next_table = create_product_table(
            &incoming,
            1
        );

        if (next_table != NULL) {
            /* 新しい表を作れた場合だけ差し替える */
            gtk_scrolled_window_set_child(
                ui->list_scroll,
                next_table
            );

            ui->product_table = GTK_GRID(next_table);

            /* 古い配列を解放し、新しい配列の所有権を受け取る */
            free_product_list(&ui->products);

            ui->products = incoming;
            incoming = (ProductList){0};

            ui->products_loaded = 1;
            ui->list_stale = 0;
            ui->selected_product_id = 0;

            refresh.displayed = 1;
        }
    }

    /* 画面側へ渡していない一時配列を片付ける */
    free_product_list(&incoming);

    update_summary(ui);
    return refresh;
}

/* 一覧更新後に、DB操作を停止する必要があるか判定する */
static int refresh_requires_stop(const ListRefreshResult *refresh)
{
    return refresh->db_result.status != APP_OK ||
           !refresh->db_result.connection_reusable ||
           !refresh->displayed;
}

/* 一覧更新の診断情報を記録する */
static void record_refresh_result(
    const char *code,
    const ListRefreshResult *refresh
)
{
    record_result(code, &refresh->db_result);

    if (refresh->db_result.status == APP_OK &&
        !refresh->displayed) {
        g_printerr(
            "code=%s operation=create_product_table\n",
            code
        );
    }
}

/* 起動時や手動更新時の一覧更新結果を表示する */
static void show_refresh_result(
    AppUi *ui,
    const ListRefreshResult *refresh
)
{
    int stop_required = refresh_requires_stop(refresh);
    const char *code;

    if (refresh->displayed) {
        code = stop_required ? "LIST-OK-STOP" : "LIST-OK";

        char *detail = g_strdup_printf(
            "%zu件の商品データを取得し、一覧へ反映しました。",
            ui->products.count
        );

        show_message(
            ui,
            stop_required
                ? "一覧更新完了・DB操作停止"
                : "商品一覧更新完了",
            detail,
            stop_required
                ? "取得と表示は完了しています。"
                  "アプリを終了して接続先を確認してください。"
                : "商品を登録するか、一覧の内容を確認してください。",
            code
        );

        g_free(detail);
    } else {
        int fetched = refresh->db_result.status == APP_OK;
        code = fetched ? "LIST-VIEW" : "LIST-DB";

        show_message(
            ui,
            fetched
                ? "一覧取得成功・表示準備エラー"
                : "商品一覧取得エラー",
            fetched
                ? "一覧データは取得しましたが、"
                  "今回の表で扱える行数を超えています。\n"
                  "商品表は更新していません。"
                : "商品一覧を取得できませんでした。\n"
                  "表示中の一覧がある場合も、"
                  "最新の内容とは限りません。",
            "アプリを終了し、診断情報を確認してください。",
            code
        );
    }

    record_refresh_result(code, refresh);

    if (stop_required) {
        stop_database_actions(ui);
    }
}

/* 入力中の商品名を確認する */
static void on_name_changed(
    GtkEditable *editable,
    gpointer user_data
)
{
    AppUi *ui = user_data;
    const char *name = gtk_editable_get_text(editable);

    if (name[0] == '\0') {
        gtk_label_set_text(
            ui->name_preview,
            "商品名を入力してください。"
        );
        return;
    }

    if (validate_product_name(name) != 0) {
        gtk_label_set_text(
            ui->name_preview,
            "商品名は1〜100文字、最大400バイトで入力してください。\n"
            "空白だけの名前や制御文字は使用できません。"
        );
        return;
    }

    char *text = g_strdup_printf(
        "商品名:%ld文字・%zuバイト。入力形式は使用できます。",
        g_utf8_strlen(name, -1),
        strlen(name)
    );

    gtk_label_set_text(ui->name_preview, text);
    g_free(text);
}

/* 入力中の単価を確認する */
static void on_price_changed(
    GtkEditable *editable,
    gpointer user_data
)
{
    AppUi *ui = user_data;
    const char *price = gtk_editable_get_text(editable);

    if (price[0] == '\0') {
        gtk_label_set_text(
            ui->price_preview,
            "単価を入力してください。例:180.50"
        );
        return;
    }

    gtk_label_set_text(
        ui->price_preview,
        validate_price(price) == 0
            ? "単価の入力形式は使用できます。"
            : "整数部は半角数字で1〜8桁、"
              "小数部は省略または1〜2桁にしてください。"
    );
}

/* 現在の入力を検証し、成功時だけoutへ保存する */
static int collect_product_input(AppUi *ui, ProductInput *out)
{
    const char *name = gtk_editable_get_text(
        GTK_EDITABLE(ui->name_entry)
    );
    const char *price = gtk_editable_get_text(
        GTK_EDITABLE(ui->price_entry)
    );

    if (validate_product_name(name) != 0) {
        show_message(
            ui,
            "入力エラー",
            "商品名が入力条件を満たしていません。",
            "商品名を修正し、登録ボタンを押してください。",
            "INPUT-NAME"
        );
        gtk_widget_grab_focus(GTK_WIDGET(ui->name_entry));
        return -1;
    }

    if (validate_price(price) != 0) {
        show_message(
            ui,
            "入力エラー",
            "単価が入力条件を満たしていません。",
            "単価を修正し、登録ボタンを押してください。",
            "INPUT-PRICE"
        );
        gtk_widget_grab_focus(GTK_WIDGET(ui->price_entry));
        return -1;
    }

    ProductInput input = {0};
    size_t name_length = strlen(name);
    size_t price_length = strlen(price);

    if (name_length >= sizeof input.product_name ||
        price_length >= sizeof input.price) {
        show_message(
            ui,
            "入力データの準備エラー",
            "入力が保存先の配列へ収まりません。",
            "入力条件と保存先の配列容量を確認してください。",
            "INPUT-SIZE"
        );
        return -1;
    }

    memcpy(input.product_name, name, name_length + 1);
    memcpy(input.price, price, price_length + 1);

    *out = input;
    return 0;
}

/* 登録がAPP_OK以外だった場合の案内を表示する */
static void show_registration_failure(
    AppUi *ui,
    const AppResult *result
)
{
    int stop_required =
        !result->connection_reusable ||
        result->status != APP_INVALID_ARGUMENT;

    const char *title;
    const char *detail;
    const char *next_action;
    const char *code;

    switch (result->status) {
    case APP_INVALID_ARGUMENT:
        title = "入力データエラー";
        detail = "商品登録関数が入力データを受け付けませんでした。";
        next_action = stop_required
            ? "アプリを終了し、入力条件と接続状態を確認してください。"
            : "商品名と単価を修正してください。";
        code = "REG-INPUT";
        break;

    case APP_UNCERTAIN:
        title = "登録結果不明";
        detail = "商品登録が確定したかどうかを確認できませんでした。";
        next_action =
            "同じ登録を繰り返さず、アプリを終了して"
            "DBの保存状態を確認してください。";
        code = "REG-UNCERTAIN";
        ui->list_stale = 1;
        break;

    case APP_DB_ERROR:
        title = "DBエラー";
        detail = "商品登録を完了できませんでした。";
        next_action =
            "アプリを終了し、確認コードと診断情報を確認してください。";
        code = "REG-DB";
        break;

    default:
        title = "処理結果の確認が必要";
        detail = "商品登録で想定していない結果を受け取りました。";
        next_action =
            "同じ登録を繰り返さず、アプリを終了して"
            "診断情報を確認してください。";
        code = "REG-STATE";
        ui->list_stale = 1;
        break;
    }

    show_message(ui, title, detail, next_action, code);
    update_summary(ui);
    record_result(code, result);

    if (stop_required) {
        stop_database_actions(ui);
    }
}

/* 商品登録に成功し、接続も利用可能なら一覧を取得し直す */
static void on_register_clicked(
    GtkButton *button,
    gpointer user_data
)
{
    (void)button;
    AppUi *ui = user_data;

    if (!ui->db_available || ui->conn == NULL) {
        return;
    }

    ProductInput input = {0};

    if (collect_product_input(ui, &input) != 0) {
        return;
    }

    int new_product_id = 0;

    AppResult result = register_product(
        ui->conn,
        &input,
        &new_product_id
    );

    if (result.status != APP_OK) {
        show_registration_failure(ui, &result);
        return;
    }

    /* 登録が確定したため、以前の一覧には再取得が必要 */
    ui->list_stale = 1;
    update_summary(ui);

    if (!result.connection_reusable) {
        char *detail = g_strdup_printf(
            "商品はDBへ登録済みです。\n"
            "商品ID:%d\n"
            "商品名:%s\n"
            "単価(入力値):%s\n"
            "接続を継続利用できないため、一覧は取得していません。",
            new_product_id,
            input.product_name,
            input.price
        );

        show_message(
            ui,
            "登録成功・一覧未更新",
            detail,
            "同じ商品を再登録せず、アプリを終了して"
            "接続先を確認してください。",
            "REG-OK-STOP"
        );

        g_free(detail);
        record_result("REG-OK-STOP", &result);
        stop_database_actions(ui);
        return;
    }

    record_result("REG-OK", &result);

    /* ここからは、登録とは別の一覧更新処理 */
    ListRefreshResult refresh = refresh_products(ui);
    int stop_required = refresh_requires_stop(&refresh);

    const char *title;
    const char *list_notice;
    const char *code;

    if (refresh.displayed) {
        title = stop_required
            ? "登録成功・一覧更新完了・DB操作停止"
            : "登録成功・一覧更新完了";

        list_notice =
            "DBから商品一覧を取得し直し、表示へ反映しました。";

        code = stop_required
            ? "REG-LIST-STOP"
            : "REG-LIST-OK";
    } else {
        title = "登録成功・一覧更新失敗";

        list_notice = refresh.db_result.status == APP_OK
            ? "一覧データは取得しましたが、"
              "商品表を作成できませんでした。"
            : "商品一覧を再取得できませんでした。";

        code = refresh.db_result.status == APP_OK
            ? "REG-LIST-VIEW"
            : "REG-LIST-DB";
    }

    char *detail = g_strdup_printf(
        "商品はDBへ登録済みです。\n"
        "商品ID:%d\n"
        "商品名:%s\n"
        "単価(入力値):%s\n"
        "%s",
        new_product_id,
        input.product_name,
        input.price,
        list_notice
    );

    show_message(
        ui,
        title,
        detail,
        stop_required
            ? "同じ商品を再登録せず、アプリを終了してください。"
              "診断情報を確認し、新しく起動して"
              "一覧を取得してください。"
            : "一覧で登録内容を確認してください。"
              "別の商品を登録する場合は入力内容を変更してください。",
        code
    );

    g_free(detail);
    record_refresh_result(code, &refresh);

    if (stop_required) {
        stop_database_actions(ui);
    }
}

/* 商品を登録せず、一覧だけを更新する */
static void on_refresh_clicked(
    GtkButton *button,
    gpointer user_data
)
{
    (void)button;
    AppUi *ui = user_data;

    if (!ui->db_available || ui->conn == NULL) {
        return;
    }

    ListRefreshResult refresh = refresh_products(ui);
    show_refresh_result(ui, &refresh);
}

/* 登録と一覧表示を一つのウィンドウへ配置する */
static void on_activate(GtkApplication *app, gpointer user_data)
{
    AppUi *ui = user_data;

    GtkWindow *existing = gtk_application_get_active_window(app);

    if (existing != NULL) {
        gtk_window_present(existing);
        return;
    }

    ui->window = GTK_WINDOW(gtk_application_window_new(app));

    gtk_window_set_title(
        ui->window,
        "在庫管理アプリ:商品登録と一覧"
    );
    gtk_window_set_default_size(ui->window, 960, 850);

    GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);

    gtk_widget_set_margin_top(root, 20);
    gtk_widget_set_margin_bottom(root, 20);
    gtk_widget_set_margin_start(root, 20);
    gtk_widget_set_margin_end(root, 20);
    gtk_window_set_child(ui->window, root);

    GtkLabel *heading = create_wrapped_label("商品の登録と一覧表示");
    gtk_box_append(GTK_BOX(root), GTK_WIDGET(heading));

    ui->connection_status = create_wrapped_label("");
    gtk_box_append(
        GTK_BOX(root),
        GTK_WIDGET(ui->connection_status)
    );

    GtkWidget *form = gtk_grid_new();
    gtk_grid_set_row_spacing(GTK_GRID(form), 8);
    gtk_grid_set_column_spacing(GTK_GRID(form), 16);

    GtkLabel *name_label = create_wrapped_label("商品名");
    GtkLabel *price_label = create_wrapped_label("単価");

    ui->name_entry = GTK_ENTRY(gtk_entry_new());
    ui->price_entry = GTK_ENTRY(gtk_entry_new());

    gtk_entry_set_placeholder_text(
        ui->name_entry,
        "例:一覧更新確認ノート"
    );
    gtk_entry_set_max_length(ui->name_entry, 100);

    gtk_entry_set_placeholder_text(ui->price_entry, "例:230.00");
    gtk_entry_set_input_purpose(
        ui->price_entry,
        GTK_INPUT_PURPOSE_NUMBER
    );
    gtk_entry_set_alignment(ui->price_entry, 1.0f);

    gtk_widget_set_hexpand(GTK_WIDGET(ui->name_entry), TRUE);
    gtk_widget_set_hexpand(GTK_WIDGET(ui->price_entry), TRUE);

    gtk_label_set_mnemonic_widget(
        name_label, GTK_WIDGET(ui->name_entry)
    );
    gtk_label_set_mnemonic_widget(
        price_label, GTK_WIDGET(ui->price_entry)
    );

    ui->name_preview = create_wrapped_label("");
    ui->price_preview = create_wrapped_label("");

    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(name_label), 0, 0, 1, 1
    );
    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(ui->name_entry), 1, 0, 1, 1
    );
    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(ui->name_preview), 1, 1, 1, 1
    );
    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(price_label), 0, 2, 1, 1
    );
    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(ui->price_entry), 1, 2, 1, 1
    );
    gtk_grid_attach(
        GTK_GRID(form), GTK_WIDGET(ui->price_preview), 1, 3, 1, 1
    );

    gtk_box_append(GTK_BOX(root), form);

    GtkWidget *buttons = gtk_box_new(
        GTK_ORIENTATION_HORIZONTAL,
        12
    );

    ui->register_button = GTK_BUTTON(
        gtk_button_new_with_label("商品を登録")
    );
    ui->refresh_button = GTK_BUTTON(
        gtk_button_new_with_label("一覧を更新")
    );
    ui->clear_button = GTK_BUTTON(
        gtk_button_new_with_label("入力欄をクリア")
    );

    gtk_box_append(
        GTK_BOX(buttons), GTK_WIDGET(ui->register_button)
    );
    gtk_box_append(
        GTK_BOX(buttons), GTK_WIDGET(ui->refresh_button)
    );
    gtk_box_append(
        GTK_BOX(buttons), GTK_WIDGET(ui->clear_button)
    );

    gtk_box_append(GTK_BOX(root), buttons);

    ui->summary = create_wrapped_label("");
    gtk_label_set_selectable(ui->summary, TRUE);
    gtk_box_append(GTK_BOX(root), GTK_WIDGET(ui->summary));

    ui->list_scroll = GTK_SCROLLED_WINDOW(
        gtk_scrolled_window_new()
    );

    gtk_scrolled_window_set_policy(
        ui->list_scroll,
        GTK_POLICY_AUTOMATIC,
        GTK_POLICY_AUTOMATIC
    );
    gtk_scrolled_window_set_has_frame(ui->list_scroll, TRUE);

    gtk_widget_set_hexpand(GTK_WIDGET(ui->list_scroll), TRUE);
    gtk_widget_set_vexpand(GTK_WIDGET(ui->list_scroll), TRUE);

    GtkWidget *initial_table = create_product_table(&ui->products, 0);
    ui->product_table = GTK_GRID(initial_table);

    gtk_scrolled_window_set_child(
        ui->list_scroll,
        initial_table
    );
    gtk_box_append(GTK_BOX(root), GTK_WIDGET(ui->list_scroll));

    ui->result_title = create_wrapped_label("");
    ui->message = create_wrapped_label("");
    ui->next_action = create_wrapped_label("");

    gtk_label_set_selectable(ui->message, TRUE);
    gtk_label_set_selectable(ui->next_action, TRUE);

    gtk_box_append(GTK_BOX(root), GTK_WIDGET(ui->result_title));
    gtk_box_append(GTK_BOX(root), GTK_WIDGET(ui->message));
    gtk_box_append(GTK_BOX(root), GTK_WIDGET(ui->next_action));

    g_signal_connect(
        ui->name_entry, "changed",
        G_CALLBACK(on_name_changed), ui
    );
    g_signal_connect(
        ui->price_entry, "changed",
        G_CALLBACK(on_price_changed), ui
    );
    g_signal_connect(
        ui->register_button, "clicked",
        G_CALLBACK(on_register_clicked), ui
    );
    g_signal_connect(
        ui->refresh_button, "clicked",
        G_CALLBACK(on_refresh_clicked), ui
    );

    on_name_changed(GTK_EDITABLE(ui->name_entry), ui);
    on_price_changed(GTK_EDITABLE(ui->price_entry), ui);
    update_summary(ui);
    set_database_controls(ui);

    if (ui->db_available) {
        gtk_label_set_text(
            ui->connection_status,
            "起動時の接続結果:成功"
        );

        /* 起動時も、登録後と同じ一覧更新関数を使用する */
        ListRefreshResult refresh = refresh_products(ui);
        show_refresh_result(ui, &refresh);
    } else {
        gtk_label_set_text(
            ui->connection_status,
            "起動時の接続結果:失敗"
        );

        show_message(
            ui,
            "DB接続エラー",
            ui->connection_error.user_message,
            "アプリを終了し、接続設定や"
            "サーバーの状態を確認してください。",
            ui->connection_error.display_code
        );
    }

    gtk_window_present(ui->window);
}

/* 設定、接続、GUI実行、終了処理を担当する */
int main(int argc, char *argv[])
{
    int check_only = 0;

    if (argc == 2 && strcmp(argv[1], "--check-config") == 0) {
        check_only = 1;
    } else if (argc != 1) {
        fputs(
            "使い方:\n"
            "  inventory_register.exe\n"
            "  inventory_register.exe --check-config\n",
            stderr
        );
        return EXIT_FAILURE;
    }

    DbConfigStorage storage = {0};
    char reason[512] = {0};

    if (load_db_config(
            "inventory.conf", &storage,
            reason, sizeof reason) != 0) {
        fprintf(
            stderr,
            "接続設定を読み込めませんでした。\n%s\n",
            reason
        );
        return EXIT_FAILURE;
    }

    if (check_only) {
        puts("設定の検証が完了しました。");
        puts("MySQLへは接続していません。");
        return EXIT_SUCCESS;
    }

    DbConfig config = {
        .host = storage.host,
        .port = storage.port,
        .database = storage.database,
        .user = storage.user
    };

    AppUi ui = {0};

    ui.conn = connect_database(
        &config,
        getenv("INVENTORY_DB_PASSWORD"),
        &ui.connection_error
    );

    ui.db_available = ui.conn != NULL;
    ui.db_failed = !ui.db_available;

    if (!ui.db_available) {
        g_printerr(
            "DB接続に失敗しました。\n"
            "%s\n確認コード:%s\n"
            "接続段階:%s MySQLエラー:%u SQLSTATE:%s\n",
            ui.connection_error.user_message,
            ui.connection_error.display_code,
            ui.connection_error.stage,
            ui.connection_error.number,
            ui.connection_error.sqlstate
        );
    }

    GtkApplication *app = gtk_application_new(
        "org.example.InventoryRegister",
        G_APPLICATION_DEFAULT_FLAGS
    );

    g_signal_connect(
        app, "activate",
        G_CALLBACK(on_activate), &ui
    );

    int status = g_application_run(
        G_APPLICATION(app), argc, argv
    );

    free_product_list(&ui.products);

    if (ui.conn != NULL) {
        mysql_close(ui.conn);
        ui.conn = NULL;
        puts("DB接続を終了しました。");
    }

    g_object_unref(app);

    return ui.db_failed ? EXIT_FAILURE : status;
}

図2:登録後に件数と商品表が更新される画面

この図から分かること

商品登録後に一覧を再取得し、件数と商品表を更新します。

登録前が20件で、ほかの商品追加や削除がなければ、一件登録した後は21件になります。

表示する商品IDには、登録関数から返された実際の値を使用します。

商品登録と一覧取得の両方をビルドしよう

起動中の商品登録アプリがあれば、閉じてからビルドします。

MSYS2 UCRT64で、次のコマンドを実行してください。

cd /c/c-mysql/chap14
gcc -std=c17 -Wall -Wextra -Wpedantic \
  -Iinclude \
  gui/inventory_register.c \
  src/db/db.c \
  src/db/db_config.c \
  src/product/product.c \
  src/product/product_list.c \
  src/common/validation.c \
  -o inventory_register.exe \
  $(pkg-config --cflags --libs gtk4 mysqlclient)

14.6のビルドコマンドへ、src/product/product_list.cを追加しています。

ソース今回使用する主な関数
product.cregister_product
product_list.cfetch_products、free_product_list

gui/inventory_list_fetch.cは、今回のビルド対象へ追加しません。今回のmainは、gui/inventory_register.cにあります。

起動には、これまでのスクリプトを使用します。

bash run_gui_register.sh

起動時の商品一覧を確認しよう

今回のプログラムは、接続成功後、画面を表示する前に一覧を取得します。

14.7で確認した状態から商品を追加・削除していなければ、次の件数が表示されます。

実行結果の例

取得済みの商品:20件

商品表には、DBから取得した商品が並びます。

これまでに確認した次の商品も、変更・削除していなければ一覧に含まれます。

商品ID商品名
23入庫確認ノート
27GUI登録確認ノート
28結果表示確認ノート

今回は、固定データの商品表ではありません。表示内容は起動時に取得したDBの内容です。

商品を登録して一覧の更新を確認しよう

確認用として、次の内容を入力します。

項目入力内容
商品名一覧更新確認ノート
単価230.00

商品を登録ボタンを一度押してください。

実行結果の例

ここでは、新しい商品IDが29だった場合を示します。実際には、画面に表示された商品IDを使用してください。

登録成功・一覧更新完了

商品はDBへ登録済みです。
商品ID:29
商品名:一覧更新確認ノート
単価(入力値):230.00
DBから商品一覧を取得し直し、表示へ反映しました。

次の操作:一覧で登録内容を確認してください。別の商品を登録する場合は入力内容を変更してください。
確認コード:REG-LIST-OK

ほかの操作による商品追加・削除がなければ、件数は次のようになります。

取得済みの商品:21件

商品表には、新しい商品も表示されます。

商品ID商品名単価在庫数
29一覧更新確認ノート230.000

商品は商品IDの昇順で表示されるため、新しい商品が下側にある場合はスクロールして確認してください。

refresh_productsの役割を確認しよう

一覧更新の共通処理は、次の関数へまとめています。

static ListRefreshResult refresh_products(AppUi *ui)

この関数は、次の処理を担当します。

  • 空のProductListへ一覧を取得する。
  • 新しい商品表を作る。
  • 商品表を差し替える。
  • 古い商品配列を解放する。
  • 新しい商品配列を保持する。
  • 件数表示を更新する。

一方、登録成功などのメッセージは、この関数では表示していません。

登録後に呼び出した場合と、一覧を更新ボタンから呼び出した場合では、伝える内容が異なるためです。

一覧更新の結果を二つに分けて返す

今回追加したListRefreshResultは、GUI側だけで使用する型です。

typedef struct {
    AppResult db_result;
    int displayed;
} ListRefreshResult;
メンバー内容
db_resultfetch_productsが返した結果
displayed商品表を作成し、画面へ反映できたか

DBの一覧取得がAPP_OKでも、画面へ表示できたとは限りません。

そのため、次の条件をすべて確認してから、継続できると判断します。

return refresh->db_result.status != APP_OK ||
       !refresh->db_result.connection_reusable ||
       !refresh->displayed;

この関数の戻り値は、操作停止が必要なら真になります。

取得結果、接続状態、画面反映の三つを確認しています。

商品登録が成功した場合だけ一覧更新へ進む

登録ボタンでは、まずregister_productの結果を確認します。

if (result.status != APP_OK) {
    show_registration_failure(ui, &result);
    return;
}

APP_OK以外の場合は、通常の登録後更新へ進みません。

また、APP_OKでも接続を継続利用できなければ、その接続でfetch_productsを呼び出しません。

if (!result.connection_reusable) {
    char *detail = g_strdup_printf(
        "商品はDBへ登録済みです。\n"
        "商品ID:%d\n"
        "商品名:%s\n"
        "単価(入力値):%s\n"
        "接続を継続利用できないため、一覧は取得していません。",
        new_product_id,
        input.product_name,
        input.price
    );

    show_message(
        ui,
        "登録成功・一覧未更新",
        detail,
        "同じ商品を再登録せず、アプリを終了して"
        "接続先を確認してください。",
        "REG-OK-STOP"
    );

    g_free(detail);
    record_result("REG-OK-STOP", &result);
    stop_database_actions(ui);
    return;
}

登録は確定していても、次のDB操作へ進めない場合があります。

成功と接続状態を分ける、これまでのルールを引き継いでいます。

一覧更新の失敗で登録成功を取り消さない

登録がAPP_OKで、接続も利用可能なら、一覧更新へ進みます。

ListRefreshResult refresh = refresh_products(ui);

この一覧取得は、登録の確定後に行う別の処理です。

既存のregister_productは、内部でCOMMITの成功を確認してからAPP_OKを返します。mysql_commitは、現在のトランザクションを確定し、成功時に0を返す関数です。

その後の一覧取得に失敗しても、GUI側で登録をやり直したり、追加のROLLBACKを実行したりはしません。

実行結果の例

登録は成功したものの、続く一覧取得に失敗した場合の表示例です。

登録成功・一覧更新失敗

商品はDBへ登録済みです。
商品ID:29
商品名:一覧更新確認ノート
単価(入力値):230.00
商品一覧を再取得できませんでした。

次の操作:同じ商品を再登録せず、アプリを終了してください。診断情報を確認し、新しく起動して一覧を取得してください。
確認コード:REG-LIST-DB

以前の一覧が20件だった場合、件数表示は次のようになります。

前回取得した商品:20件(再取得が必要)

DBには新しい商品が登録されていても、画面の一覧は更新できていません。

この違いを、結果表示と件数表示の両方で伝えています。

図3:登録成功と一覧更新失敗を別々に扱う

この図から分かること

DBへの登録結果と、一覧を更新できたかどうかは別の情報です。

一覧更新に失敗しても、確定済みの商品登録は残ります。

利用者には、同じ登録を繰り返さず、一覧を取得し直すための確認へ進むよう案内します。

新しい一覧を用意してから表示を差し替える

refresh_productsでは、最初に一時変数へ一覧を取得します。

ProductList incoming = {0};

refresh.db_result = fetch_products(
    ui->conn,
    &incoming
);

取得成功後、新しい商品表を作ります。

GtkWidget *next_table = create_product_table(
    &incoming,
    1
);

表を作れた場合だけ、スクロール領域の中身を差し替えます。

gtk_scrolled_window_set_child(
    ui->list_scroll,
    next_table
);

gtk_scrolled_window_set_childは、スクロール領域へ表示する子ウィジェットを設定する関数です。

その後、古い商品配列を解放し、新しい配列を保持します。

free_product_list(&ui->products);

ui->products = incoming;
incoming = (ProductList){0};

取得や表の作成に失敗した場合は、以前の表と配列を残します。

再取得が必要な状態を管理する

今回追加したlist_staleは、以前の一覧をそのまま現在の処理結果として扱えない場合に使用します。

例えば、登録が確定した直後には、以前の商品一覧に新しい商品が含まれていません。

そのため、一覧更新前に次のように設定します。

ui->list_stale = 1;
update_summary(ui);

一覧の取得と表示に成功した場合は、0へ戻します。

ui->products_loaded = 1;
ui->list_stale = 0;
状態件数欄の表示
一覧取得・表示に成功取得済みの商品:21件
登録後、一覧を更新できない前回取得した商品:20件(再取得が必要)
一覧をまだ取得できていない商品一覧:未取得

このフラグは、DBを常時監視するものではありません。

別のアプリで商品が変更された場合も、必要なタイミングで一覧を取得し直します。

一覧を更新ボタンでは登録を行わない

一覧を更新ボタンのコールバックは、一覧更新だけを実行します。

ListRefreshResult refresh = refresh_products(ui);
show_refresh_result(ui, &refresh);

register_productは呼び出していません。

入力欄に商品名と単価が残っていても、一覧を更新ボタンを押しただけでは新しい商品は登録されません。

また、登録や一覧更新で接続を継続利用できなくなった場合は、登録ボタンと一覧更新ボタンを両方無効にします。

gtk_widget_set_sensitiveへFALSEを渡すことで、その部品を利用者が操作できなくなります。

今回は、その状態で再接続する機能は追加していません。アプリを終了し、新しく起動して確認します。

入力欄は残したままにしておこう

今回のプログラムでは、登録成功後も商品名と単価を入力欄へ残しています。

登録した内容と一覧を見比べるためです。

ただし、同じ内容で再び商品を登録ボタンを押すと、もう一件の新規登録になります。

  • 登録内容の確認には商品表を使う。
  • 一覧だけを取得し直す場合は、一覧を更新ボタンを使う。
  • 別の商品を登録する場合は、入力内容を変更する。

入力欄を自動的にクリアする処理は、次の記事で追加します。

DBと画面の内容を照合しよう

MySQLクライアントでは、次のSQLで商品一覧を確認できます。

SELECT
    product_id,
    product_name,
    price,
    stock
FROM products
ORDER BY product_id ASC;

件数は、次のSQLで確認できます。

SELECT COUNT(*) AS product_count
FROM products;

登録前が20件で、その後に今回の一件だけを登録した場合は、21件になります。

商品IDは件数とは別なので、表示された実際の番号で登録商品を確認してください。

登録から一覧更新までを通して確認しよう

最後に、次の順序で確認します。

  1. アプリを起動し、既存の商品一覧が表示されることを確認する。
  2. 商品名と単価を入力する。
  3. 商品を登録ボタンを一度押す。
  4. 登録成功と、採番された商品IDを確認する。
  5. 商品件数が20件から21件へ増えたことを確認する。
  6. 商品表で、登録した商品IDの行を確認する。
  7. 一覧を更新ボタンを押し、同じ商品が重複して増えないことを確認する。
  8. アプリを終了して再起動し、登録した商品が表示されることを確認する。

件数の20件から21件への変化は、ほかの商品追加・削除がない場合の確認例です。プログラムでは件数を固定せず、取得したProductListのcountを表示しています。

登録後の一覧更新を確認できたら、次の14.10では、登録後や利用者の操作で入力欄をクリアし、次の商品を入力しやすくしていきましょう。

Follow me!