Javaのjavax.sql.rowsetを徹底解説！非接続型データアクセスの真髄

Javaでデータベースを扱う際、多くの開発者は`java.sql.ResultSet`を利用してきました。`ResultSet`は、SQLクエリの実行結果を保持するオブジェクトですが、いくつかの制約がありました。最も大きな制約は、データベースとの接続を維持し続けなければならない点です。つまり、`ResultSet`を操作している間は、常にデータベースコネクションがアクティブである必要があります。

この制約は、リソース管理を複雑にし、特にWebアプリケーションのような多数のクライアントを同時に捌く環境では、コネクションの枯渇という深刻な問題を引き起こす可能性がありました。また、`ResultSet`自体は前方への読み取り専用が基本であり、柔軟なデータ操作には向いていませんでした。

そこで登場したのがjavax.sql.rowsetパッケージ、通称 JDBC RowSet です。`RowSet`は`ResultSet`インターフェースを拡張し、JavaBeansコンポーネントとしての性質を持たせたものです。 これにより、より柔軟で高機能なデータ操作が可能になりました。

`RowSet`の最大の特徴は、「接続型（Connected）」と「非接続型（Disconnected）」という2つの概念を導入した点です。 これが`ResultSet`との決定的な違いであり、`RowSet`の強力さを支える根幹となっています。

この非接続型のアーキテクチャにより、データベースコネクションを効率的に利用でき、ネットワーク負荷の軽減や、モバイルアプリケーションのような非同期環境でのデータ利用が容易になります。

`javax.sql.rowset`パッケージは、主に5つの標準インターフェースを定義しており、それぞれにリファレンス実装が提供されています。 これらの`RowSet`を理解し、使い分けることが効果的なデータベースプログラミングの鍵となります。

JDBC 4.1 (Java SE 7) 以降、`RowSet`のインスタンスを生成する推奨方法は、`RowSetProvider`クラスを使用することです。 このファクトリーAPIを利用することで、特定のJDBCドライバ実装に依存しない、ポータブルなコードを書くことができます。

`RowSetProvider.newFactory().create…()` の形式で、目的の`RowSet`を生成します。

import javax.sql.rowset.RowSetFactory;
import javax.sql.rowset.RowSetProvider;
import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.CachedRowSet;
import java.sql.SQLException;

public class RowSetFactoryExample {
    public static void main(String[] args) {
        try {
            // RowSetFactoryのインスタンスを取得
            RowSetFactory factory = RowSetProvider.newFactory();

            // 各種RowSetを生成
            JdbcRowSet jdbcRs = factory.createJdbcRowSet();
            CachedRowSet cachedRs = factory.createCachedRowSet();
            // WebRowSet webRs = factory.createWebRowSet();
            // FilteredRowSet filteredRs = factory.createFilteredRowSet();
            // JoinRowSet joinRs = factory.createJoinRowSet();

            System.out.println("JdbcRowSet instance created: " + jdbcRs.getClass().getName());
            System.out.println("CachedRowSet instance created: " + cachedRs.getClass().getName());

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

`JdbcRowSet`は、`ResultSet`をラップし、JavaBeansコンポーネントとしての機能を追加したものです。 データベースとの接続を常に維持するため、`ResultSet`と似た感覚で使えますが、プロパティの設定やイベントリスナーの追加など、より柔軟な操作が可能です。

import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.RowSetProvider;
import java.sql.SQLException;

public class JdbcRowSetExample {
    // データベース接続情報は適切に設定してください
    static final String JDBC_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1";
    static final String USER = "sa";
    static final String PASSWORD = "";

    public static void main(String[] args) {
        try (JdbcRowSet jdbcRs = RowSetProvider.newFactory().createJdbcRowSet()) {
            // 接続情報を設定
            jdbcRs.setUrl(JDBC_URL);
            jdbcRs.setUsername(USER);
            jdbcRs.setPassword(PASSWORD);
            
            // 実行するSQLを設定
            jdbcRs.setCommand("SELECT id, name, email FROM users");
            jdbcRs.execute();

            // データを順に表示
            System.out.println("--- User List ---");
            while (jdbcRs.next()) {
                System.out.printf("ID: %d, Name: %s, Email: %s%n",
                        jdbcRs.getInt("id"),
                        jdbcRs.getString("name"),
                        jdbcRs.getString("email"));
            }

            // データを逆順に表示（スクロール可能）
            System.out.println("\n--- Reversed User List ---");
            jdbcRs.afterLast();
            while (jdbcRs.previous()) {
                System.out.printf("ID: %d, Name: %s, Email: %s%n",
                        jdbcRs.getInt("id"),
                        jdbcRs.getString("name"),
                        jdbcRs.getString("email"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

`JdbcRowSet`は内部的に`Connection`と`PreparedStatement`、`ResultSet`を保持しています。`execute()`が呼ばれると、これらのオブジェクトが生成され、データベースへのアクセスが行われます。

`CachedRowSet`は非接続型`RowSet`の基本であり、最も重要なクラスです。 データをメモリにキャッシュするため、データベースから切断された状態でもデータを自由に操作できます。 これは、ネットワークリソースを効率的に使用したい場合や、データをシリアライズして別の層に渡したい場合に非常に強力です。

1. データの取得 (populate)

`CachedRowSet`にデータを格納するには、`execute()`メソッドを呼び出します。このメソッドは内部でデータベースに接続し、SQLを実行して結果セットを取得し、その内容を`CachedRowSet`自身にコピー（populate）した後、接続を閉じます。

import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.RowSetProvider;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class CachedRowSetPopulateExample {
    static final String JDBC_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1";
    static final String USER = "sa";
    static final String PASSWORD = "";

    public static void main(String[] args) {
        // 事前にテーブル作成とデータ挿入を行う (H2データベースの例)
        setupDatabase();

        try (CachedRowSet crs = RowSetProvider.newFactory().createCachedRowSet()) {
            crs.setUrl(JDBC_URL);
            crs.setUsername(USER);
            crs.setPassword(PASSWORD);
            crs.setCommand("SELECT id, name, email FROM users");
            
            // この時点でDBに接続し、データを取得してキャッシュし、接続を閉じる
            crs.execute();

            // --- ここからは非接続状態 ---
            System.out.println("Data has been cached. Connection is closed.");
            
            crs.afterLast(); // カーソルを最終行の後に移動
            while (crs.previous()) {
                System.out.printf("ID: %d, Name: %s, Email: %s%n",
                        crs.getInt("id"),
                        crs.getString("name"),
                        crs.getString("email"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void setupDatabase() {
        try (Connection conn = DriverManager.getConnection(JDBC_URL, USER, PASSWORD);
             java.sql.Statement stmt = conn.createStatement()) {
            stmt.execute("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(255), email VARCHAR(255))");
            stmt.execute("INSERT INTO users VALUES (1, 'Taro Yamada', 'taro@example.com')");
            stmt.execute("INSERT INTO users VALUES (2, 'Hanako Tanaka', 'hanako@example.com')");
        } catch (SQLException e) {
            // ignore if table already exists
        }
    }
}

2. データの更新、挿入、削除

非接続状態でも、`CachedRowSet`内のデータを変更できます。`ResultSet`と同様の`updateXxx`、`insertRow`、`deleteRow`メソッドを使用します。

// ... (上記のCachedRowSetPopulateExampleの続き)
// crs.execute()でデータを取得した後

// --- データ操作 (非接続) ---
// 1. 更新 (Update)
crs.absolute(1); // 1行目に移動
crs.updateString("name", "Taro Yamada Updated");
crs.updateRow(); // 行の更新をキャッシュに反映

// 2. 挿入 (Insert)
crs.moveToInsertRow(); // 挿入用の特別な行に移動
crs.updateInt("id", 3);
crs.updateString("name", "Jiro Sato");
crs.updateString("email", "jiro@example.com");
crs.insertRow(); // 挿入をキャッシュに反映
crs.moveToCurrentRow(); // カーソルを元の位置に戻す

// 3. 削除 (Delete)
crs.absolute(2); // 2行目 (元のHanako Tanaka) に移動
crs.deleteRow(); // 削除をキャッシュに反映

System.out.println("\n--- After local modifications ---");
crs.beforeFirst();
while(crs.next()){
    System.out.printf("ID: %d, Name: %s, Email: %s%n",
        crs.getInt("id"),
        crs.getString("name"),
        crs.getString("email"));
}

3. 変更の同期 (acceptChanges)

ローカルで行った変更をデータベースに反映させるには、`acceptChanges()`メソッドを呼び出します。このメソッドは、内部で再度データベースに接続し、キャッシュされた変更内容（更新、挿入、削除）に基づいてSQL文を生成し、実行します。

// ... (上記のデータ操作の続き)

// 4. データベースへの同期
System.out.println("\n--- Synchronizing with database... ---");
try {
    // 再度DBに接続し、変更をコミットする
    crs.acceptChanges(DriverManager.getConnection(JDBC_URL, USER, PASSWORD));
    System.out.println("Synchronization successful!");
} catch (java.sql.SQLException e) {
    // 特にSyncProviderExceptionのハンドリングが重要
    System.err.println("Synchronization failed!");
    e.printStackTrace();
}

`acceptChanges`は、内部的に`RowSetWriter`というコンポーネントを使ってデータベースへの書き込みを行います。この仕組みにより、書き込み処理をカスタマイズすることも可能です。

`WebRowSet`は`CachedRowSet`の全機能を引き継ぎ、さらにRowSetの内容をXMLとして読み書きする機能を追加したものです。 この特性により、Webサービスや設定ファイルの永続化など、多様なシナリオで活躍します。

XMLのスキーマは標準で定義されており、これにより異なるシステム間での高い相互運用性が保証されます。

WebRowSetをXMLとして書き出す

import javax.sql.rowset.WebRowSet;
import javax.sql.rowset.RowSetProvider;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.SQLException;

// ... (CachedRowSetの例と同様の前提)
public class WebRowSetWriteExample {
    public static void main(String[] args) {
        try (WebRowSet wrs = RowSetProvider.newFactory().createWebRowSet()) {
            wrs.setUrl("jdbc:h2:mem:testdb");
            wrs.setUsername("sa");
            wrs.setPassword("");
            wrs.setCommand("SELECT * FROM users");
            wrs.execute();

            // XMLファイルに書き出す
            try (FileWriter writer = new FileWriter("users.xml")) {
                wrs.writeXml(writer);
                System.out.println("WebRowSet content written to users.xml");
            }

        } catch (SQLException | IOException e) {
            e.printStackTrace();
        }
    }
}

生成される`users.xml`には、プロパティ情報、メタデータ（列情報）、そしてデータ本身（変更前と変更後の両方）が含まれます。

XMLからWebRowSetを復元する

import javax.sql.rowset.WebRowSet;
import javax.sql.rowset.RowSetProvider;
import java.io.FileReader;
import java.io.IOException;
import java.sql.SQLException;

public class WebRowSetReadExample {
    public static void main(String[] args) {
        try (WebRowSet wrs = RowSetProvider.newFactory().createWebRowSet()) {
            
            // XMLファイルから読み込む
            try (FileReader reader = new FileReader("users.xml")) {
                wrs.readXml(reader);
                System.out.println("WebRowSet content read from users.xml");
            }
            
            // 復元したデータを表示
            while (wrs.next()) {
                System.out.printf("ID: %d, Name: %s%n", wrs.getInt("id"), wrs.getString("name"));
            }

        } catch (SQLException | IOException e) {
            e.printStackTrace();
        }
    }
}

データベースへの問い合わせを増やすことなく、クライアントサイドでデータを柔軟に加工したい場合があります。`FilteredRowSet`と`JoinRowSet`は、まさにそのための強力なツールです。

FilteredRowSet: 動的な行フィルタリング

`FilteredRowSet`は、`javax.sql.rowset.Predicate`インターフェースを実装したフィルタ条件を適用することで、表示される行を制限します。 これにより、SQLの`WHERE`句を再実行することなく、メモリ上のデータセットから特定の条件に合うデータだけを抽出できます。

まず、`Predicate`を実装したフィルタクラスを作成します。

import javax.sql.rowset.Predicate;
import javax.sql.RowSet;
import java.sql.SQLException;

// 'T'で始まる名前のユーザーのみを許可するフィルタ
public class NameFilter implements Predicate {
    private String pattern;

    public NameFilter(String pattern) {
        this.pattern = pattern;
    }

    @Override
    public boolean evaluate(RowSet rs) {
        try {
            if (!rs.isAfterLast()) {
                String name = rs.getString("name");
                return name != null && name.startsWith(pattern);
            }
        } catch (SQLException e) {
            return false;
        }
        return false;
    }
    // 他のevaluateメソッドはここでは省略
    @Override public boolean evaluate(Object value, int column) { return false; }
    @Override public boolean evaluate(Object value, String columnName) { return false; }
}

次に、このフィルタを`FilteredRowSet`に適用します。

import javax.sql.rowset.FilteredRowSet;
import javax.sql.rowset.RowSetProvider;
import java.sql.SQLException;

public class FilteredRowSetExample {
    public static void main(String[] args) {
        try (FilteredRowSet frs = RowSetProvider.newFactory().createFilteredRowSet()) {
            frs.setUrl("jdbc:h2:mem:testdb");
            frs.setUsername("sa");
            frs.setPassword("");
            frs.setCommand("SELECT * FROM users");
            frs.execute();

            System.out.println("--- All Users ---");
            frs.beforeFirst();
            while(frs.next()) { System.out.println(frs.getString("name")); }

            // フィルタを適用
            frs.setFilter(new NameFilter("T"));

            System.out.println("\n--- Filtered Users (Name starts with 'T') ---");
            frs.beforeFirst(); // フィルタ適用後はカーソルをリセットする必要がある
            while(frs.next()) {
                System.out.println(frs.getString("name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

フィルタは、データの表示だけでなく、挿入や更新時にも適用され、条件に合わない操作は`SQLException`を引き起こします。

JoinRowSet: メモリ上でのテーブル結合

`JoinRowSet`は、SQLの`JOIN`操作をメモリ上で実現します。 複数の`RowSet`（`CachedRowSet`など）を、共通の列をキーとして結合できます。

import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.JoinRowSet;
import javax.sql.rowset.RowSetProvider;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JoinRowSetExample {
    public static void main(String[] args) {
        setupMoreData(); // 新しいテーブルとデータをセットアップ

        try {
            CachedRowSet users = RowSetProvider.newFactory().createCachedRowSet();
            users.setUrl("jdbc:h2:mem:testdb");
            users.setUsername("sa");
            users.setPassword("");
            users.setCommand("SELECT id AS user_id, name FROM users");
            users.execute();

            CachedRowSet orders = RowSetProvider.newFactory().createCachedRowSet();
            orders.setUrl("jdbc:h2:mem:testdb");
            orders.setUsername("sa");
            orders.setPassword("");
            orders.setCommand("SELECT order_id, user_id, item_name FROM orders");
            orders.execute();

            JoinRowSet jrs = RowSetProvider.newFactory().createJoinRowSet();
            jrs.addRowSet(users, "user_id"); // usersをベースに、結合キーとしてuser_idを指定
            jrs.addRowSet(orders, "user_id"); // ordersを、結合キーとしてuser_idを指定して追加

            System.out.println("--- Joined Data (User and Orders) ---");
            while (jrs.next()) {
                System.out.printf("User: %s, Item: %s%n",
                        jrs.getString("name"),
                        jrs.getString("item_name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    private static void setupMoreData() {
        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "");
             java.sql.Statement stmt = conn.createStatement()) {
            stmt.execute("CREATE TABLE orders (order_id INT PRIMARY KEY, user_id INT, item_name VARCHAR(255))");
            stmt.execute("INSERT INTO orders VALUES (101, 1, 'Laptop')");
            stmt.execute("INSERT INTO orders VALUES (102, 2, 'Monitor')");
            stmt.execute("INSERT INTO orders VALUES (103, 1, 'Mouse')");
        } catch (SQLException e) { /* ignore */ }
    }
}

`JoinRowSet`はデフォルトで内部結合（INNER JOIN）のように振る舞います。結合キーが一致する行のみが結果セットに含まれます。